+
+
+
+
+
+
+ Namespace: columns - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.columns.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.columns.html
new file mode 100644
index 0000000..93521db
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.columns.html
@@ -0,0 +1,874 @@
+
+
+
+
+
+
+
+
+
+ Reference to internal functions for use by plug-in developers. Note that these +methods are references to internal functions and are considered to be private. +If you use these methods, be aware that they are liable to change between versions +(check the upgrade notes).
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> _fnJsonString
- JSON stringify. If JSON.stringify it provided by the browser, json2.js or any other +library, then we use that as it is fast, safe and accurate. If the function isn't +available then we need to built it ourselves - the insperation for this function comes +from Craig Buckler ( http://www.sitepoint.com/javascript-json-serialization/ ). It is +not perfect and absolutely should not be used as a replacement to json2.js - but it does +do what we need, without requiring a dependency for DataTables. +
Methods
+ +-
+
- <static> _fnAddColumn(oSettings, nTh)
- Add a column to the list used for the table with default values
- <static> _fnAddData(oSettings, aData) → {int}
- Add a data array to the table, creating DOM node etc. This is the parallel to +_fnGatherData, but for adding rows from a Javascript source, rather than a +DOM source.
- <static> _fnAddOptionsHtml(oSettings)
- Add the options to the page HTML for the table
- <static> _fnAdjustColumnSizing(oSettings)
- Adjust the table column widths for new data. Note: you would probably want to +do a redraw after calling this function!
- <static> _fnAjaxParameters(oSettings) → {bool}
- Build up the parameters in an object needed for a server-side processing request
- <static> _fnAjaxUpdate(oSettings) → {boolean}
- Update the table using an Ajax call
- <static> _fnAjaxUpdateDraw(oSettings, json)
- Data the data from the server (nuking the old) and redraw the table
- <static> _fnApplyColumnDefs(oSettings, aoColDefs, aoCols, fn)
- Take the column definitions and static columns arrays and calculate how +they relate to column indexes. The callback function will then apply the +definition found for a column to a suitable configuration object.
- <static> _fnApplyToChildren(fn, array, array)
- Apply a given function to the display child nodes of an element array (typically +TD children of TR rows
- <static> _fnBindAction(n, oData, {function))
- Bind an event handers to allow a click or return key to activate the callback. +This is good for accessability since a return on the keyboard will have the +same effect as a click, if the element has focus.
- <static> _fnBuildHead(oSettings)
- Create the HTML header for the table
- <static> _fnBuildSearchArray(oSettings, iMaster)
- Create an array which can be quickly search through
- <static> _fnBuildSearchRow(oSettings, aData)
- Create a searchable string from a single data row
- <static> _fnCalculateColumnWidths(oSettings)
- Calculate the width of columns for the table
- <static> _fnCalculateEnd(oSettings)
- Rcalculate the end point based on the start point
- <static> _fnCallbackFire(oSettings, sStore, sTrigger, {array))
- Fire callback functions and trigger events. Note that the loop over the callback +array store is done backwards! Further note that you do not want to fire off triggers +in time sensitive applications (for example cell creation) as its slow.
- <static> _fnCallbackReg(oSettings, sStore, fn, {string))
- Register a callback function. Easily allows a callback function to be added to +an array store of callback functions that can then all be called together.
- <static> _fnClearTable(oSettings)
- Nuke the table
- <static> _fnColumnIndexToVisible(iMatch, oSettings) → {int}
- Covert the index of an index in the data array and convert it to the visible + column index (take account of hidden columns)
- <static> _fnColumnOptions(oSettings, iCol, oOptions)
- Apply options for a column
- <static> _fnColumnOrdering(oSettings) → {string}
- Get the column ordering that DataTables expects
- <static> _fnConvertToWidth(sWidth, nParent) → {int}
- Convert a CSS unit width to pixels (e.g. 2em)
- <static> _fnCreateCookie(sName, sValue, iSecs, sBaseName, fnCallback)
- Create a new cookie with a value to store the state of a table
- <static> _fnCreateTr(oSettings, iRow)
- Create a new TR element (and it's TD children) for a row
- <static> _fnDataToSearch(sData, sType) → {string}
- Convert raw data into something that the user can search on
- <static> _fnDeleteIndex(a, iTarget)
- Take an array of integers (index array) and remove a target integer (value - not +the key!)
- <static> _fnDetectHeader(array, nThead)
- Use the DOM source to create up an array of header cells. The idea here is to +create a layout grid (array) of rows x columns, which contains a reference +to the cell that that point in the grid (regardless of col/rowspan), such that +any column / row could be removed and the new grid constructed
- <static> _fnDetectType(sData) → {string}
- Get the sort type based on an input string
- <static> _fnDraw(oSettings)
- Insert the required TR nodes into the table for display
- <static> _fnDrawHead(oSettings, array, bIncludeHidden)
- Draw the header (or footer) element based on the column visibility states. The +methodology here is to use the layout array from _fnDetectHeader, modified for +the instantaneous column visibility, to construct the new layout. The grid is +traversed over cell at a time in a rows x columns grid fashion, although each +cell insert can cover multiple elements in the grid - which is tracks using the +aApplied array. Cell inserts in the grid will only occur where there isn't +already a cell in that position.
- <static> _fnEscapeRegex(sVal) → {string}
- scape a string stuch that it can be used in a regular expression
- <static> _fnExtend(oOut, oExtender) → {object}
- Extend objects - very similar to jQuery.extend, but deep copy objects, and shallow +copy arrays. The reason we need to do this, is that we don't want to deep copy array +init values (such as aaSorting) since the dev wouldn't be able to override them, but +we do want to deep copy arrays.
- <static> _fnExternApiFunc(sFunc) → {function}
- Create a wrapper function for exporting an internal functions to an external API.
- <static> _fnFeatureHtmlFilter(oSettings) → {node}
- Generate the node required for filtering text
- <static> _fnFeatureHtmlInfo(oSettings) → {node}
- Generate the node required for the info display
- <static> _fnFeatureHtmlLength(oSettings) → {node}
- Generate the node required for user display length changing
- <static> _fnFeatureHtmlPaginate(oSettings) → {node}
- Generate the node required for default pagination
- <static> _fnFeatureHtmlProcessing(oSettings) → {node}
- Generate the node required for the processing node
- <static> _fnFeatureHtmlTable(oSettings) → {node}
- Add any control elements for the table - specifically scrolling
- <static> _fnFilter(oSettings, sInput, iForce, bRegex, bSmart, bCaseInsensitive)
- Filter the data table based on user input and draw the table
- <static> _fnFilterColumn(oSettings, sInput, iColumn, bRegex, bSmart, bCaseInsensitive)
- Filter the table on a per-column basis
- <static> _fnFilterComplete(oSettings, oSearch, iForce)
- Filter the table using both the global filter and column based filtering
- <static> _fnFilterCreateSearch(sSearch, bRegex, bSmart, bCaseInsensitive) → {RegExp}
- Build a regular expression object suitable for searching a table
- <static> _fnFilterCustom(oSettings)
- Apply custom filtering functions
- <static> _fnGatherData(oSettings)
- Read in the data from the target table from the DOM
- <static> _fnGetCellData(oSettings, iRow, iCol, sSpecific) → {*}
- Get the data for a given cell from the internal cache, taking into account data mapping
- <static> _fnGetDataMaster(oSettings)
- Return an array with the full table data
- <static> _fnGetMaxLenString(oSettings, iCol) → {string}
- Get the maximum strlen for each data column
- <static> _fnGetObjectDataFn(mSource) → {function}
- Return a function that can be used to get data from a source object, taking +into account the ability to use nested objects as a source
- <static> _fnGetRowData(oSettings, iRow, sSpecific) → {array}
- Get an array of data for a given row from the internal data cache
- <static> _fnGetTdNodes(oSettings, iIndividualRow) → {array}
- Return an flat array with all TD nodes for the table, or row
- <static> _fnGetTrNodes(oSettings) → {array}
- Return an array with the TR nodes for the table
- <static> _fnGetUniqueThs(oSettings, nHeader, aLayout)
- Get an array of unique th elements, one for each column
- <static> _fnGetWidestNode(oSettings, iCol) → {string}
- Get the widest node
- <static> _fnInitComplete(oSettings, json)
- Draw the table for the first time, adding all required features
- <static> _fnInitialise(oSettings)
- Draw the table for the first time, adding all required features
- <static> _fnLanguageCompat(oSettings)
- Language compatibility - when certain options are given, and others aren't, we +need to duplicate the values over, in order to provide backwards compatibility +with older language files.
- <static> _fnLoadState(oSettings, oInit)
- Attempt to load a saved table state from a cookie
- <static> _fnLog(oSettings, iLevel, sMesg)
- Log an error message
- <static> _fnMap(oRet, oSrc, sName, sMappedName)
- See if a property is defined on one object, if so assign it to the other object
- <static> _fnNodeToColumnIndex(oSettings, iRow, n) → {int}
- Take a TD element and convert it into a column data index (not the visible index)
- <static> _fnNodeToDataIndex(oSettings, n) → {int}
- Take a TR element and convert it to an index in aoData
- <static> _fnPageChange(oSettings, mAction) → {bool}
- Alter the display settings to change the page
- <static> _fnProcessingDisplay(oSettings, bShow)
- Display or hide the processing indicator
- <static> _fnReadCookie(sName) → {string}
- Read an old cookie to get a cookie with an old table state
- <static> _fnReDraw(oSettings)
- Redraw the table - taking account of the various features which are enabled
- <static> _fnRender(oSettings, iRow, iCol) → {*}
- Call the developer defined fnRender function for a given cell (row/column) with +the required parameters and return the result.
- <static> _fnReOrderIndex(oSettings)
- Figure out how to reorder a display list
- <static> _fnSaveState(oSettings)
- Save the state of a table in a cookie such that the page can be reloaded
- <static> _fnScrollBarWidth() → {int}
- Get the width of a scroll bar in this browser being used
- <static> _fnScrollDraw(o) → {node}
- Update the various tables for resizing. It's a bit of a pig this function, but +basically the idea to: + 1. Re-create the table inside the scrolling div + 2. Take live measurements from the DOM + 3. Apply the measurements + 4. Clean up
- <static> _fnScrollingWidthAdjust(oSettings, n)
- Adjust a table's width to take account of scrolling
- <static> _fnServerParams(oSettings, array)
- Add Ajax parameters from plugins
- <static> _fnSetCellData(oSettings, iRow, iCol, val)
- Set the value for a specific cell, into the internal data cache
- <static> _fnSetObjectDataFn(mSource) → {function}
- Return a function that can be used to set data from a source object, taking +into account the ability to use nested objects as a source
- <static> _fnSettingsFromNode(nTable) → {object}
- Return the settings object for a particular table
- <static> _fnSort(oSettings, bApplyClasses)
- Change the order of the table
- <static> _fnSortAttachListener(oSettings, nNode, iDataIndex, fnCallback)
- Attach a sort handler (click) to a node
- <static> _fnSortingClasses(oSettings)
- Set the sorting classes on the header, Note: it is safe to call this function +when bSort and bSortClasses are false
- <static> _fnStringToCss(aArray1, aArray2) → {int}
- Append a CSS unit (only if required) to a string
- <static> _fnUpdateInfo(oSettings)
- Update the information elements in the display
- <static> _fnVisbleColumns(oS) → {int}
- Get the number of visible columns
- <static> _fnVisibleToColumnIndex(oSettings, iMatch) → {int}
- Covert the index of a visible column to the index in the data array (take account +of hidden columns) +
+
+
+
+
+ Details
+Properties
+-
+
- <static> _fnJsonString
JSON stringify. If JSON.stringify it provided by the browser, json2.js or any other +library, then we use that as it is fast, safe and accurate. If the function isn't +available then we need to built it ourselves - the insperation for this function comes +from Craig Buckler ( http://www.sitepoint.com/javascript-json-serialization/ ). It is +not perfect and absolutely should not be used as a replacement to json2.js - but it does +do what we need, without requiring a dependency for DataTables.
-
+
+
+
Methods
+-
+
- <static> _fnAddColumn(oSettings, nTh)
Add a column to the list used for the table with default values
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object nTh node The th element for this column - <static> _fnAddData(oSettings, aData) → {int}
Add a data array to the table, creating DOM node etc. This is the parallel to +_fnGatherData, but for adding rows from a Javascript source, rather than a +DOM source.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object aData array data array to be added Returns:
>=0 if successful (index of new aoData entry), -1 if failed
- <static> _fnAddOptionsHtml(oSettings)
Add the options to the page HTML for the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnAdjustColumnSizing(oSettings)
Adjust the table column widths for new data. Note: you would probably want to +do a redraw after calling this function!
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnAjaxParameters(oSettings) → {bool}
Build up the parameters in an object needed for a server-side processing request
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
block the table drawing or not
- <static> _fnAjaxUpdate(oSettings) → {boolean}
Update the table using an Ajax call
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Block the table drawing or not
- <static> _fnAjaxUpdateDraw(oSettings, json)
Data the data from the server (nuking the old) and redraw the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2json object json data return from the server. json.sEcho string Tracking flag for DataTables to match requests json.iTotalRecords int Number of records in the data set, not accounting for filtering json.iTotalDisplayRecords int Number of records in the data set, accounting for filtering json.aaData array The data to display on this page json.sColumns string <optional> Column ordering (sName, comma separated) - <static> _fnApplyColumnDefs(oSettings, aoColDefs, aoCols, fn)
Take the column definitions and static columns arrays and calculate how +they relate to column indexes. The callback function will then apply the +definition found for a column to a suitable configuration object.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2aoColDefs array The aoColumnDefs array that is to be applied 3aoCols array The aoColumns array that defines columns individually fn function Callback function - takes two parameters, the calculated + column index and the definition for that column. - <static> _fnApplyToChildren(fn, array, array)
Apply a given function to the display child nodes of an element array (typically +TD children of TR rows
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1fn function Method to apply to the objects 2array {nodes} an1 List of elements to look through for display children array {nodes} an2 Another list (identical structure to the first) - optional - <static> _fnBindAction(n, oData, {function))
Bind an event handers to allow a click or return key to activate the callback. +This is good for accessability since a return on the keyboard will have the +same effect as a click, if the element has focus.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1n element Element to bind the action to 2oData object Data object to pass to the triggered function {function) fn Callback function for when the event is triggered - <static> _fnBuildHead(oSettings)
Create the HTML header for the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnBuildSearchArray(oSettings, iMaster)
Create an array which can be quickly search through
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iMaster int use the master data array - optional - <static> _fnBuildSearchRow(oSettings, aData)
Create a searchable string from a single data row
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object aData array Row data array to use for the data to search - <static> _fnCalculateColumnWidths(oSettings)
Calculate the width of columns for the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnCalculateEnd(oSettings)
Rcalculate the end point based on the start point
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnCallbackFire(oSettings, sStore, sTrigger, {array))
Fire callback functions and trigger events. Note that the loop over the callback +array store is done backwards! Further note that you do not want to fire off triggers +in time sensitive applications (for example cell creation) as its slow.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2sStore string Name of the array storeage for the callbacks in oSettings 3sTrigger string Name of the jQuery custom event to trigger. If null no trigger + is fired {array) aArgs Array of arguments to pass to the callback function / trigger - <static> _fnCallbackReg(oSettings, sStore, fn, {string))
Register a callback function. Easily allows a callback function to be added to +an array store of callback functions that can then all be called together.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2sStore string Name of the array storeage for the callbacks in oSettings 3fn function Function to be called back {string) sName Identifying name for the callback (i.e. a label) - <static> _fnClearTable(oSettings)
Nuke the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnColumnIndexToVisible(iMatch, oSettings) → {int}
Covert the index of an index in the data array and convert it to the visible + column index (take account of hidden columns)
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1iMatch int Column index to lookup oSettings object dataTables settings object Returns:
i the data index
- <static> _fnColumnOptions(oSettings, iCol, oOptions)
Apply options for a column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iCol int column index to consider oOptions object object with sType, bVisible and bSearchable - <static> _fnColumnOrdering(oSettings) → {string}
Get the column ordering that DataTables expects
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
comma separated list of names
- <static> _fnConvertToWidth(sWidth, nParent) → {int}
Convert a CSS unit width to pixels (e.g. 2em)
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sWidth string width to be converted nParent node parent to get the with for (required for relative widths) - optional Returns:
iWidth width in pixels
- <static> _fnCreateCookie(sName, sValue, iSecs, sBaseName, fnCallback)
Create a new cookie with a value to store the state of a table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sName string name of the cookie to create 2sValue string the value the cookie should take 3iSecs int duration of the cookie 4sBaseName string sName is made up of the base + file name - this is the base fnCallback function User definable function to modify the cookie - <static> _fnCreateTr(oSettings, iRow)
Create a new TR element (and it's TD children) for a row
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iRow int Row to consider - <static> _fnDataToSearch(sData, sType) → {string}
Convert raw data into something that the user can search on
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sData string data to be modified sType string data type Returns:
search string
- <static> _fnDeleteIndex(a, iTarget)
Take an array of integers (index array) and remove a target integer (value - not +the key!)
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1a array Index array to target iTarget int value to find - <static> _fnDetectHeader(array, nThead)
Use the DOM source to create up an array of header cells. The idea here is to +create a layout grid (array) of rows x columns, which contains a reference +to the cell that that point in the grid (regardless of col/rowspan), such that +any column / row could be removed and the new grid constructed
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1array {object} aLayout Array to store the calculated layout in nThead node The header/footer element for the table - <static> _fnDetectType(sData) → {string}
Get the sort type based on an input string
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sData string data we wish to know the type of Returns:
type (defaults to 'string' if no type can be detected)
- <static> _fnDraw(oSettings)
Insert the required TR nodes into the table for display
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnDrawHead(oSettings, array, bIncludeHidden)
Draw the header (or footer) element based on the column visibility states. The +methodology here is to use the layout array from _fnDetectHeader, modified for +the instantaneous column visibility, to construct the new layout. The grid is +traversed over cell at a time in a rows x columns grid fashion, although each +cell insert can cover multiple elements in the grid - which is tracks using the +aApplied array. Cell inserts in the grid will only occur where there isn't +already a cell in that position.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2array {objects} aoSource Layout array from _fnDetectHeader bIncludeHidden boolean Optional false If true then include the hidden columns in the calc, - <static> _fnEscapeRegex(sVal) → {string}
scape a string stuch that it can be used in a regular expression
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sVal string string to escape Returns:
escaped string
- <static> _fnExtend(oOut, oExtender) → {object}
Extend objects - very similar to jQuery.extend, but deep copy objects, and shallow +copy arrays. The reason we need to do this, is that we don't want to deep copy array +init values (such as aaSorting) since the dev wouldn't be able to override them, but +we do want to deep copy arrays.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oOut object Object to extend oExtender object Object from which the properties will be applied to oOut Returns:
oOut Reference, just for convenience - oOut === the return.
- <static> _fnExternApiFunc(sFunc) → {function}
Create a wrapper function for exporting an internal functions to an external API.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sFunc string API function name Returns:
wrapped function
- <static> _fnFeatureHtmlFilter(oSettings) → {node}
Generate the node required for filtering text
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Filter control element
- <static> _fnFeatureHtmlInfo(oSettings) → {node}
Generate the node required for the info display
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Information element
- <static> _fnFeatureHtmlLength(oSettings) → {node}
Generate the node required for user display length changing
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Display length feature node
- <static> _fnFeatureHtmlPaginate(oSettings) → {node}
Generate the node required for default pagination
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Pagination feature node
- <static> _fnFeatureHtmlProcessing(oSettings) → {node}
Generate the node required for the processing node
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Processing element
- <static> _fnFeatureHtmlTable(oSettings) → {node}
Add any control elements for the table - specifically scrolling
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
Node to add to the DOM
- <static> _fnFilter(oSettings, sInput, iForce, bRegex, bSmart, bCaseInsensitive)
Filter the data table based on user input and draw the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2sInput string string to filter on 3iForce int optional - force a research of the master array (1) or not (undefined or 0) 4bRegex bool treat as a regular expression or not 5bSmart bool perform smart filtering or not bCaseInsensitive bool Do case insenstive matching or not - <static> _fnFilterColumn(oSettings, sInput, iColumn, bRegex, bSmart, bCaseInsensitive)
Filter the table on a per-column basis
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2sInput string string to filter on 3iColumn int column to filter 4bRegex bool treat search string as a regular expression or not 5bSmart bool use smart filtering or not bCaseInsensitive bool Do case insenstive matching or not - <static> _fnFilterComplete(oSettings, oSearch, iForce)
Filter the table using both the global filter and column based filtering
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2oSearch object search information iForce int Optional force a research of the master array (1) or not (undefined or 0) - <static> _fnFilterCreateSearch(sSearch, bRegex, bSmart, bCaseInsensitive) → {RegExp}
Build a regular expression object suitable for searching a table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sSearch string string to search for 2bRegex bool treat as a regular expression or not 3bSmart bool perform smart filtering or not bCaseInsensitive bool Do case insenstive matching or not Returns:
constructed object
- <static> _fnFilterCustom(oSettings)
Apply custom filtering functions
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnGatherData(oSettings)
Read in the data from the target table from the DOM
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnGetCellData(oSettings, iRow, iCol, sSpecific) → {*}
Get the data for a given cell from the internal cache, taking into account data mapping
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iRow int aoData row id 3iCol int Column index sSpecific string data get type ('display', 'type' 'filter' 'sort') Returns:
Cell data
- <static> _fnGetDataMaster(oSettings)
Return an array with the full table data
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
array {array} aData Master data array
- <static> _fnGetMaxLenString(oSettings, iCol) → {string}
Get the maximum strlen for each data column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iCol int column of interest Returns:
max strlens for each column
- <static> _fnGetObjectDataFn(mSource) → {function}
Return a function that can be used to get data from a source object, taking +into account the ability to use nested objects as a source
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +mSource string | int | function The data source for the object Returns:
Data get function
- <static> _fnGetRowData(oSettings, iRow, sSpecific) → {array}
Get an array of data for a given row from the internal data cache
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iRow int aoData row id sSpecific string data get type ('type' 'filter' 'sort') Returns:
Data array
- <static> _fnGetTdNodes(oSettings, iIndividualRow) → {array}
Return an flat array with all TD nodes for the table, or row
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iIndividualRow int Optional aoData index to get the nodes for - optional + if not given then the return array will contain all nodes for the table Returns:
TD array
- <static> _fnGetTrNodes(oSettings) → {array}
Return an array with the TR nodes for the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
TR array
- <static> _fnGetUniqueThs(oSettings, nHeader, aLayout)
Get an array of unique th elements, one for each column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2nHeader node automatically detect the layout from this node - optional aLayout array thead/tfoot layout from _fnDetectHeader - optional Returns:
array {node} aReturn list of unique ths
- <static> _fnGetWidestNode(oSettings, iCol) → {string}
Get the widest node
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iCol int column of interest Returns:
max strlens for each column
- <static> _fnInitComplete(oSettings, json)
Draw the table for the first time, adding all required features
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object json object Optional JSON from the server that completed the table, if using Ajax source + with client-side processing (optional) - <static> _fnInitialise(oSettings)
Draw the table for the first time, adding all required features
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnLanguageCompat(oSettings)
Language compatibility - when certain options are given, and others aren't, we +need to duplicate the values over, in order to provide backwards compatibility +with older language files.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnLoadState(oSettings, oInit)
Attempt to load a saved table state from a cookie
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object oInit object DataTables init object so we can override settings - <static> _fnLog(oSettings, iLevel, sMesg)
Log an error message
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iLevel int log error messages, or display them to the user sMesg string error message - <static> _fnMap(oRet, oSrc, sName, sMappedName)
See if a property is defined on one object, if so assign it to the other object
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oRet object target object 2oSrc object source object 3sName string property sMappedName string Optional name to map too - optional, sName used if not given - <static> _fnNodeToColumnIndex(oSettings, iRow, n) → {int}
Take a TD element and convert it into a column data index (not the visible index)
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iRow int The row number the TD/TH can be found in n node The TD/TH element to find Returns:
index if the node is found, -1 if not
- <static> _fnNodeToDataIndex(oSettings, n) → {int}
Take a TR element and convert it to an index in aoData
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object n node the TR element to find Returns:
index if the node is found, null if not
- <static> _fnPageChange(oSettings, mAction) → {bool}
Alter the display settings to change the page
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object mAction string | int Paging action to take: "first", "previous", "next" or "last" + or page number to jump to (integer) Returns:
true page has changed, false - no change (no effect) eg 'first' on page 1
- <static> _fnProcessingDisplay(oSettings, bShow)
Display or hide the processing indicator
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object bShow bool Show the processing indicator (true) or not (false) - <static> _fnReadCookie(sName) → {string}
Read an old cookie to get a cookie with an old table state
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sName string name of the cookie to read Returns:
contents of the cookie - or null if no cookie with that name found
- <static> _fnReDraw(oSettings)
Redraw the table - taking account of the various features which are enabled
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnRender(oSettings, iRow, iCol) → {*}
Call the developer defined fnRender function for a given cell (row/column) with +the required parameters and return the result.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iRow int aoData index for the row iCol int aoColumns index for the column Returns:
Return of the developer's fnRender function
- <static> _fnReOrderIndex(oSettings)
Figure out how to reorder a display list
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object Returns:
array {int} aiReturn index list for reordering
- <static> _fnSaveState(oSettings)
Save the state of a table in a cookie such that the page can be reloaded
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnScrollBarWidth() → {int}
Get the width of a scroll bar in this browser being used
+-
+
+
Returns:
width in pixels
- <static> _fnScrollDraw(o) → {node}
Update the various tables for resizing. It's a bit of a pig this function, but +basically the idea to: + 1. Re-create the table inside the scrolling div + 2. Take live measurements from the DOM + 3. Apply the measurements + 4. Clean up
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +o object dataTables settings object Returns:
Node to add to the DOM
- <static> _fnScrollingWidthAdjust(oSettings, n)
Adjust a table's width to take account of scrolling
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object n node table node - <static> _fnServerParams(oSettings, array)
Add Ajax parameters from plugins
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object array {objects} aoData name/value pairs to send to the server - <static> _fnSetCellData(oSettings, iRow, iCol, val)
Set the value for a specific cell, into the internal data cache
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2iRow int aoData row id 3iCol int Column index val * Value to set - <static> _fnSetObjectDataFn(mSource) → {function}
Return a function that can be used to set data from a source object, taking +into account the ability to use nested objects as a source
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +mSource string | int | function The data source for the object Returns:
Data set function
- <static> _fnSettingsFromNode(nTable) → {object}
Return the settings object for a particular table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +nTable node table we are using as a dataTable Returns:
Settings object - or null if not found
- <static> _fnSort(oSettings, bApplyClasses)
Change the order of the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object bApplyClasses bool optional - should we apply classes or not - <static> _fnSortAttachListener(oSettings, nNode, iDataIndex, fnCallback)
Attach a sort handler (click) to a node
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object 2nNode node node to attach the handler to 3iDataIndex int column sorting index fnCallback function Optional callback function - <static> _fnSortingClasses(oSettings)
Set the sorting classes on the header, Note: it is safe to call this function +when bSort and bSortClasses are false
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnStringToCss(aArray1, aArray2) → {int}
Append a CSS unit (only if required) to a string
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1aArray1 array first array aArray2 array second array Returns:
0 if match, 1 if length is different, 2 if no match
- <static> _fnUpdateInfo(oSettings)
Update the information elements in the display
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object dataTables settings object - <static> _fnVisbleColumns(oS) → {int}
Get the number of visible columns
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oS object dataTables settings object Returns:
i the number of visible columns
- <static> _fnVisibleToColumnIndex(oSettings, iMatch) → {int}
Covert the index of a visible column to the index in the data array (take account +of hidden columns)
+ +-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object dataTables settings object iMatch int Visible column index to lookup Returns:
i the data index
+
+
+
+ Namespace: defaults - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: columns
+Ancestry: DataTable ยป .defaults. ยป columns
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.html
new file mode 100644
index 0000000..e7dc20b
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.html
@@ -0,0 +1,1748 @@
+
+
+
+
+
+
+
+
+
+ Column options that can be given to DataTables at initialisation time.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> aDataSort :array
- Allows a column's sorting to take multiple columns into account when +doing a sort. For example first name / last name columns make sense to +do a multi-column sort over the two columns.
- <static> asSorting :array
- You can control the default sorting direction, and even alter the behaviour +of the sort handler (i.e. only allow ascending sorting etc) using this +parameter.
- <static> bSearchable :boolean
- Enable or disable filtering on the data in this column.
- <static> bSortable :boolean
- Enable or disable sorting on this column.
- <static> bUseRendered :boolean
- When using fnRender() for a column, you may wish to use the original data +(before rendering) for sorting and filtering (the default is to used the +rendered data that the user can see). This may be useful for dates etc. +NOTE* It is it is advisable now to use mDataProp as a function and make +use of the 'type' that it gives, allowing (potentially) different data to +be used for sorting, filtering, display and type detection.
- <static> bVisible :boolean
- Enable or disable the display of this column.
- <static> fnCreatedCell :function
- Developer definable function that is called whenever a cell is created (Ajax source, +etc) or processed for input (DOM source). This can be used as a compliment to fnRender +allowing you to modify the DOM element (add background colour for example) when the +element is available (since it is not when fnRender is called).
- <static> fnRender :function
- Custom display function that will be called for the display of each cell in +this column.
- <static> iDataSort :int
- The column index (starting from 0!) that you wish a sort to be performed +upon when this column is selected for sorting. This can be used for sorting +on hidden columns for example.
- <static> mDataProp :string|int|function|null
- This property can be used to read data from any JSON data source property,
+including deeply nested objects / properties. mDataProp can be given in a
+number of different ways which effect its behaviour:
+
-
+
- integer - treated as an array index for the data source. This is the + default that DataTables uses (incrementally increased for each column). +
- string - read an object property from the data source. Note that you can + use Javascript dotted notation to read deep properties/arrays from the + data source. +
- null - the sDefaultContent option will be used for the cell (null + by default, so you will need to specify the default content you want - + typically an empty string). This can be useful on generated columns such + as edit / delete action columns. +
- function - the function given will be executed whenever DataTables
+ needs to set or get the data for a cell in the column. The function
+ takes three parameters:
+
-
+
- {array|object} The data source for the row +
- {string} The type call data requested - this will be 'set' when + setting data or 'filter', 'display', 'type', 'sort' or undefined when + gathering data. Note that when undefined is given for the type + DataTables expects to get the raw data for the object back +
- {*} Data to set when the second parameter is 'set'. +
+
- <static> sCellType :string
- Change the cell type created for the column - either TD cells or TH cells. This +can be useful as TH cells have semantic meaning in the table body, allowing them +to act as a header for a row (you may wish to add scope='row' to the TH elements).
- <static> sClass :string
- Class to give to each cell in this column.
- <static> sContentPadding :string
- When DataTables calculates the column widths to assign to each column, +it finds the longest string in each column and then constructs a +temporary table and reads the widths from that. The problem with this +is that "mmm" is much wider then "iiii", but the latter is a longer +string - thus the calculation can go wrong (doing it properly and putting +it into an DOM object and measuring that is horribly(!) slow). Thus as +a "work around" we provide this option. It will append its value to the +text that is found to be the longest string for the column - i.e. padding. +Generally you shouldn't need this, and it is not documented on the +general DataTables.net documentation
- <static> sDefaultContent :string
- Allows a default value to be given for a column's data, and will be used +whenever a null data source is encountered (this can be because mDataProp +is set to null, or because the data source itself is null).
- <static> sName :string
- This parameter is only used in DataTables' server-side processing. It can +be exceptionally useful to know what columns are being displayed on the +client side, and to map these to database fields. When defined, the names +also allow DataTables to reorder information from the server if it comes +back in an unexpected order (i.e. if you switch your columns around on the +client-side, your server-side code does not also need updating).
- <static> sSortDataType :string
- Defines a data source type for the sorting which can be used to read +realtime information from the table (updating the internally cached +version) prior to sorting. This allows sorting to occur on user editable +elements such as form inputs.
- <static> sTitle :string
- The title of this column.
- <static> sType :string
- The type allows you to specify how the data for this column will be sorted. +Four types (string, numeric, date and html (which will strip HTML tags +before sorting)) are currently available. Note that only date formats +understood by Javascript's Date() object will be accepted as type date. For +example: "Mar 26, 2008 5:03 PM". May take the values: 'string', 'numeric', +'date' or 'html' (by default). Further types can be adding through +plug-ins.
- <static> sWidth :string
- Defining the width of the column, this parameter may take any CSS value +(3em, 20px etc). DataTables applys 'smart' widths to columns which have not +been given a specific width through this interface ensuring that the table +remains readable. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> aDataSort :array
Allows a column's sorting to take multiple columns into account when +doing a sort. For example first name / last name columns make sense to +do a multi-column sort over the two columns.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "aDataSort": [ 0, 1 ], "aTargets": [ 0 ] }, + { "aDataSort": [ 1, 0 ], "aTargets": [ 1 ] }, + { "aDataSort": [ 2, 3, 4 ], "aTargets": [ 2 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "aDataSort": [ 0, 1 ] }, + { "aDataSort": [ 1, 0 ] }, + { "aDataSort": [ 2, 3, 4 ] }, + null, + null + ] + } ); + } );+- <static> asSorting :array
You can control the default sorting direction, and even alter the behaviour +of the sort handler (i.e. only allow ascending sorting etc) using this +parameter.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "asSorting": [ "asc" ], "aTargets": [ 1 ] }, + { "asSorting": [ "desc", "asc", "asc" ], "aTargets": [ 2 ] }, + { "asSorting": [ "desc" ], "aTargets": [ 3 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + null, + { "asSorting": [ "asc" ] }, + { "asSorting": [ "desc", "asc", "asc" ] }, + { "asSorting": [ "desc" ] }, + null + ] + } ); + } );+- <static> bSearchable :boolean
Enable or disable filtering on the data in this column.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "bSearchable": false, "aTargets": [ 0 ] } + ] } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "bSearchable": false }, + null, + null, + null, + null + ] } ); + } );+- <static> bSortable :boolean
Enable or disable sorting on this column.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "bSortable": false, "aTargets": [ 0 ] } + ] } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "bSortable": false }, + null, + null, + null, + null + ] } ); + } );+- <static> bUseRendered :boolean
When using fnRender() for a column, you may wish to use the original data +(before rendering) for sorting and filtering (the default is to used the +rendered data that the user can see). This may be useful for dates etc. +NOTE* It is it is advisable now to use mDataProp as a function and make +use of the 'type' that it gives, allowing (potentially) different data to +be used for sorting, filtering, display and type detection.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { + "fnRender": function ( oObj ) { + return oObj.aData[0] +' '+ oObj.aData[3]; + }, + "bUseRendered": false, + "aTargets": [ 0 ] + } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { + "fnRender": function ( oObj ) { + return oObj.aData[0] +' '+ oObj.aData[3]; + }, + "bUseRendered": false + }, + null, + null, + null, + null + ] + } ); + } );+- <static> bVisible :boolean
Enable or disable the display of this column.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "bVisible": false, "aTargets": [ 0 ] } + ] } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "bVisible": false }, + null, + null, + null, + null + ] } ); + } );+- <static> fnCreatedCell :function
Developer definable function that is called whenever a cell is created (Ajax source, +etc) or processed for input (DOM source). This can be used as a compliment to fnRender +allowing you to modify the DOM element (add background colour for example) when the +element is available (since it is not when fnRender is called).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nTd element The TD node that has been created 2sData * The Data for the cell 3oData array | object The data for the whole row 4iRow int The row index for the aoData data store iCol int The column index for aoColumns Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ { + "aTargets": [3], + "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) { + if ( sData == "1.7" ) { + $(nTd).css('color', 'blue') + } + } + } ] + }); + } );+- <static> fnRender :function
Custom display function that will be called for the display of each cell in +this column.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1o object Object with the following parameters: o.iDataRow int The row in aoData o.iDataColumn int The column in question o.aData array The data for the row in question o.oSettings object The settings object for this DataTables instance o.mDataProp object The data property used for this column val * The current cell value Returns:
The string you which to use in the display
Examples:
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { + "fnRender": function ( o, val ) { + return o.aData[0] +' '+ o.aData[3]; + }, + "aTargets": [ 0 ] + } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "fnRender": function ( o, val ) { + return o.aData[0] +' '+ o.aData[3]; + } }, + null, + null, + null, + null + ] + } ); + } );+- <static> iDataSort :int
The column index (starting from 0!) that you wish a sort to be performed +upon when this column is selected for sorting. This can be used for sorting +on hidden columns for example.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "iDataSort": 1, "aTargets": [ 0 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "iDataSort": 1 }, + null, + null, + null, + null + ] + } ); + } );+- <static> mDataProp :string|int|function|null
This property can be used to read data from any JSON data source property, +including deeply nested objects / properties. mDataProp can be given in a +number of different ways which effect its behaviour: +
-
+
- integer - treated as an array index for the data source. This is the + default that DataTables uses (incrementally increased for each column). +
- string - read an object property from the data source. Note that you can + use Javascript dotted notation to read deep properties/arrays from the + data source. +
- null - the sDefaultContent option will be used for the cell (null + by default, so you will need to specify the default content you want - + typically an empty string). This can be useful on generated columns such + as edit / delete action columns. +
- function - the function given will be executed whenever DataTables
+ needs to set or get the data for a cell in the column. The function
+ takes three parameters:
+
-
+
- {array|object} The data source for the row +
- {string} The type call data requested - this will be 'set' when + setting data or 'filter', 'display', 'type', 'sort' or undefined when + gathering data. Note that when undefined is given for the type + DataTables expects to get the raw data for the object back +
- {*} Data to set when the second parameter is 'set'. +
+
-
+
+
Examples
+++ +// Read table data from objects + $(document).ready(function() { + var oTable = $('#example').dataTable( { + "sAjaxSource": "sources/deep.txt", + "aoColumns": [ + { "mDataProp": "engine" }, + { "mDataProp": "browser" }, + { "mDataProp": "platform.inner" }, + { "mDataProp": "platform.details.0" }, + { "mDataProp": "platform.details.1" } + ] + } ); + } ); + ++++// Using mDataProp as a function to provide different information for + // sorting, filtering and display. In this case, currency (price) + $(document).ready(function() { + var oTable = $('#example').dataTable( { + "aoColumnDefs": [ + { + "aTargets": [ 0 ], + "mDataProp": function ( source, type, val ) { + if (type === 'set') { + source.price = val; + // Store the computed dislay and filter values for efficiency + source.price_display = val=="" ? "" : "$"+numberFormat(val); + source.price_filter = val=="" ? "" : "$"+numberFormat(val)+" "+val; + return; + } + else if (type === 'display') { + return source.price_display; + } + else if (type === 'filter') { + return source.price_filter; + } + // 'sort', 'type' and undefined all just use the integer + return source.price; + } + ] + } ); + } );+- <static> sCellType :string
Change the cell type created for the column - either TD cells or TH cells. This +can be useful as TH cells have semantic meaning in the table body, allowing them +to act as a header for a row (you may wish to add scope='row' to the TH elements).
-
+
+
Example
+++// Make the first column use TH cells + $(document).ready(function() { + var oTable = $('#example').dataTable( { + "aoColumnDefs": [ + { + "aTargets": [ 0 ], + "sCellType": "th" + ] + } ); + } );+- <static> sClass :string
Class to give to each cell in this column.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sClass": "my_class", "aTargets": [ 0 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "sClass": "my_class" }, + null, + null, + null, + null + ] + } ); + } );+- <static> sContentPadding :string
When DataTables calculates the column widths to assign to each column, +it finds the longest string in each column and then constructs a +temporary table and reads the widths from that. The problem with this +is that "mmm" is much wider then "iiii", but the latter is a longer +string - thus the calculation can go wrong (doing it properly and putting +it into an DOM object and measuring that is horribly(!) slow). Thus as +a "work around" we provide this option. It will append its value to the +text that is found to be the longest string for the column - i.e. padding. +Generally you shouldn't need this, and it is not documented on the +general DataTables.net documentation
-
+
+
Example
+++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + null, + null, + null, + { + "sContentPadding": "mmm" + } + ] + } ); + } );+- <static> sDefaultContent :string
Allows a default value to be given for a column's data, and will be used +whenever a null data source is encountered (this can be because mDataProp +is set to null, or because the data source itself is null).
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { + "mDataProp": null, + "sDefaultContent": "Edit", + "aTargets": [ -1 ] + } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + null, + null, + null, + { + "mDataProp": null, + "sDefaultContent": "Edit" + } + ] + } ); + } );+- <static> sName :string
This parameter is only used in DataTables' server-side processing. It can +be exceptionally useful to know what columns are being displayed on the +client side, and to map these to database fields. When defined, the names +also allow DataTables to reorder information from the server if it comes +back in an unexpected order (i.e. if you switch your columns around on the +client-side, your server-side code does not also need updating).
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sName": "engine", "aTargets": [ 0 ] }, + { "sName": "browser", "aTargets": [ 1 ] }, + { "sName": "platform", "aTargets": [ 2 ] }, + { "sName": "version", "aTargets": [ 3 ] }, + { "sName": "grade", "aTargets": [ 4 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "sName": "engine" }, + { "sName": "browser" }, + { "sName": "platform" }, + { "sName": "version" }, + { "sName": "grade" } + ] + } ); + } );+- <static> sSortDataType :string
Defines a data source type for the sorting which can be used to read +realtime information from the table (updating the internally cached +version) prior to sorting. This allows sorting to occur on user editable +elements such as form inputs.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sSortDataType": "dom-text", "aTargets": [ 2, 3 ] }, + { "sType": "numeric", "aTargets": [ 3 ] }, + { "sSortDataType": "dom-select", "aTargets": [ 4 ] }, + { "sSortDataType": "dom-checkbox", "aTargets": [ 5 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + null, + null, + { "sSortDataType": "dom-text" }, + { "sSortDataType": "dom-text", "sType": "numeric" }, + { "sSortDataType": "dom-select" }, + { "sSortDataType": "dom-checkbox" } + ] + } ); + } );+- <static> sTitle :string
The title of this column.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sTitle": "My column title", "aTargets": [ 0 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "sTitle": "My column title" }, + null, + null, + null, + null + ] + } ); + } );+- <static> sType :string
The type allows you to specify how the data for this column will be sorted. +Four types (string, numeric, date and html (which will strip HTML tags +before sorting)) are currently available. Note that only date formats +understood by Javascript's Date() object will be accepted as type date. For +example: "Mar 26, 2008 5:03 PM". May take the values: 'string', 'numeric', +'date' or 'html' (by default). Further types can be adding through +plug-ins.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sType": "html", "aTargets": [ 0 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "sType": "html" }, + null, + null, + null, + null + ] + } ); + } );+- <static> sWidth :string
Defining the width of the column, this parameter may take any CSS value +(3em, 20px etc). DataTables applys 'smart' widths to columns which have not +been given a specific width through this interface ensuring that the table +remains readable.
-
+
+
Examples
+++ +// Using aoColumnDefs + $(document).ready(function() { + $('#example').dataTable( { + "aoColumnDefs": [ + { "sWidth": "20%", "aTargets": [ 0 ] } + ] + } ); + } ); + ++++// Using aoColumns + $(document).ready(function() { + $('#example').dataTable( { + "aoColumns": [ + { "sWidth": "20%" }, + null, + null, + null, + null + ] + } ); + } );+
+
+
+
+
+
+
+
+ Namespace: oLanguage - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.html
new file mode 100644
index 0000000..814abaf
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.html
@@ -0,0 +1,362 @@
+
+
+
+
+
+
+
+
+
+ Initialisation options that can be given to DataTables at initialisation +time.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- columns
- Column options that can be given to DataTables at initialisation time.
- oLanguage
- All strings that DataTables uses in the user interface that it creates +are defined in this object, allowing you to modified them individually or +completely replace them all as required.
- oSearch
- This parameter allows you to have define the global filtering state at +initialisation time. As an object the "sSearch" parameter must be +defined, but all other parameters are optional. When "bRegex" is true, +the search string will be treated as a regular expression, when false +(default) it will be treated as a straight string. When "bSmart" +DataTables will use it's smart filtering methods (to word match at +any point in the data), when false this will not be done. +
Properties
+ +-
+
- <static> aaData :array
- An array of data to use for the table, passed in at initialisation which +will be used in preference to any data which is already in the DOM. This is +particularly useful for constructing tables purely in Javascript, for +example with a custom Ajax call.
- <static> aaSorting :array
- If sorting is enabled, then DataTables will perform a first pass sort on +initialisation. You can define which column(s) the sort is performed upon, +and the sorting direction, with this variable. The aaSorting array should +contain an array for each column to be sorted initially containing the +column's index and a direction string ('asc' or 'desc').
- <static> aaSortingFixed :array
- This parameter is basically identical to the aaSorting parameter, but +cannot be overridden by user interaction with the table. What this means +is that you could have a column (visible or hidden) which the sorting will +always be forced on first - any sorting after that (from the user) will +then be performed as required. This can be useful for grouping rows +together.
- <static> aLengthMenu :array
- This parameter allows you to readily specify the entries in the length drop +down menu that DataTables shows when pagination is enabled. It can be +either a 1D array of options which will be used for both the displayed +option and the value, or a 2D array which will use the array in the first +position as the value, and the array in the second position as the +displayed options (useful for language strings such as 'All').
- <static> aoColumnDefs
- Very similar to aoColumns, aoColumnDefs allows you to target a specific
+column, multiple columns, or all columns, using the aTargets property of
+each object in the array. This allows great flexibility when creating
+tables, as the aoColumnDefs arrays can be of any length, targeting the
+columns you specifically want. aoColumnDefs may use any of the column
+options available: DataTable.defaults.columns, but it _must_
+have aTargets defined in each object in the array. Values in the aTargets
+array may be:
+
-
+
- a string - class name will be matched on the TH for the column +
- 0 or a positive integer - column index counting from the left +
- a negative integer - column index counting from the right +
- the string "_all" - all columns (i.e. assign a default) +
- <static> aoColumns
- The aoColumns option in the initialisation parameter allows you to define +details about the way individual columns behave. For a full list of +column options that can be set, please see +DataTable.defaults.columns. Note that if you use aoColumns to +define your columns, you must have an entry in the array for every single +column that you have in your table (these can be null if you don't which +to specify any options).
- <static> aoSearchCols :array
- Basically the same as oSearch, this parameter defines the individual column +filtering state at initialisation time. The array must be of the same size +as the number of columns, and each element be an object with the parameters +"sSearch" and "bEscapeRegex" (the latter is optional). 'null' is also +accepted and the default will be used.
- <static> asStripeClasses :array
- An array of CSS classes that should be applied to displayed rows. This +array may be of any length, and DataTables will apply each class +sequentially, looping when required.
- <static> bAutoWidth :boolean
- Enable or disable automatic column width calculation. This can be disabled +as an optimisation (it takes some time to calculate the widths) if the +tables widths are passed in using aoColumns.
- <static> bDeferRender :boolean
- Deferred rendering can provide DataTables with a huge speed boost when you +are using an Ajax or JS data source for the table. This option, when set to +true, will cause DataTables to defer the creation of the table elements for +each row until they are needed for a draw - saving a significant amount of +time.
- <static> bDestroy :boolean
- Replace a DataTable which matches the given selector and replace it with +one which has the properties of the new initialisation object passed. If no +table matches the selector, then the new DataTable will be constructed as +per normal.
- <static> bFilter :boolean
- Enable or disable filtering of data. Filtering in DataTables is "smart" in +that it allows the end user to input multiple words (space separated) and +will match a row containing those words, even if not in the order that was +specified (this allow matching across multiple columns). Note that if you +wish to use filtering in DataTables this must remain 'true' - to remove the +default filtering input box and retain filtering abilities, please use +DataTable.defaults.sDom.
- <static> bInfo :boolean
- Enable or disable the table information display. This shows information +about the data that is currently visible on the page, including information +about filtered data if that action is being performed.
- <static> bJQueryUI :boolean
- Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some +slightly different and additional mark-up from what DataTables has +traditionally used).
- <static> bLengthChange :boolean
- Allows the end user to select the size of a formatted page from a select +menu (sizes are 10, 25, 50 and 100). Requires pagination (bPaginate).
- <static> bPaginate :boolean
- Enable or disable pagination.
- <static> bProcessing :boolean
- Enable or disable the display of a 'processing' indicator when the table is +being processed (e.g. a sort). This is particularly useful for tables with +large amounts of data where it can take a noticeable amount of time to sort +the entries.
- <static> bRetrieve :boolean
- Retrieve the DataTables object for the given selector. Note that if the +table has already been initialised, this parameter will cause DataTables +to simply return the object that has already been set up - it will not take +account of any changes you might have made to the initialisation object +passed to DataTables (setting this parameter to true is an acknowledgement +that you understand this). bDestroy can be used to reinitialise a table if +you need.
- <static> bScrollAutoCss :boolean
- Indicate if DataTables should be allowed to set the padding / margin +etc for the scrolling header elements or not. Typically you will want +this.
- <static> bScrollCollapse :boolean
- When vertical (y) scrolling is enabled, DataTables will force the height of +the table's viewport to the given height at all times (useful for layout). +However, this can look odd when filtering data down to a small data set, +and the footer is left "floating" further down. This parameter (when +enabled) will cause DataTables to collapse the table's viewport down when +the result set will fit within the given Y height.
- <static> bScrollInfinite :boolean
- Enable infinite scrolling for DataTables (to be used in combination with +sScrollY). Infinite scrolling means that DataTables will continually load +data as a user scrolls through a table, which is very useful for large +dataset. This cannot be used with pagination, which is automatically +disabled. Note - the Scroller extra for DataTables is recommended in +in preference to this option.
- <static> bServerSide :boolean
- Configure DataTables to use server-side processing. Note that the +sAjaxSource parameter must also be given in order to give DataTables a +source to obtain the required data for each draw.
- <static> bSort :boolean
- Enable or disable sorting of columns. Sorting of individual columns can be +disabled by the "bSortable" option for each column.
- <static> bSortCellsTop :boolean
- Allows control over whether DataTables should use the top (true) unique +cell that is found for a single column, or the bottom (false - default). +This is useful when using complex headers.
- <static> bSortClasses :boolean
- Enable or disable the addition of the classes 'sorting_1', 'sorting_2' and +'sorting_3' to the columns which are currently being sorted on. This is +presented as a feature switch as it can increase processing time (while +classes are removed and added) so for large data sets you might want to +turn this off.
- <static> bStateSave :boolean
- Enable or disable state saving. When enabled a cookie will be used to save +table display information such as pagination information, display length, +filtering and sorting. As such when the end user reloads the page the +display display will match what thy had previously set up.
- <static> fnCookieCallback :function
- Customise the cookie and / or the parameters being stored when using +DataTables with state saving enabled. This function is called whenever +the cookie is modified, and it expects a fully formed cookie string to be +returned. Note that the data object passed in is a Javascript object which +must be converted to a string (JSON.stringify for example).
- <static> fnCreatedRow :function
- This function is called when a TR element is created (and all TD child +elements have been inserted), or registered if using a DOM source, allowing +manipulation of the TR element (adding classes etc).
- <static> fnDrawCallback :function
- This function is called on every 'draw' event, and allows you to +dynamically modify any aspect you want about the created DOM.
- <static> fnFooterCallback :function
- Identical to fnHeaderCallback() but for the table footer this function +allows you to modify the table footer on every 'draw' even.
- <static> fnFormatNumber :function
- When rendering large numbers in the information element for the table +(i.e. "Showing 1 to 10 of 57 entries") DataTables will render large numbers +to have a comma separator for the 'thousands' units (e.g. 1 million is +rendered as "1,000,000") to help readability for the end user. This +function will override the default method DataTables uses.
- <static> fnHeaderCallback :function
- This function is called on every 'draw' event, and allows you to +dynamically modify the header row. This can be used to calculate and +display useful information about the table.
- <static> fnInfoCallback :function
- The information element can be used to convey information about the current +state of the table. Although the internationalisation options presented by +DataTables are quite capable of dealing with most customisations, there may +be times where you wish to customise the string further. This callback +allows you to do exactly that.
- <static> fnInitComplete :function
- Called when the table has been initialised. Normally DataTables will +initialise sequentially and there will be no need for this function, +however, this does not hold true when using external language information +since that is obtained using an async XHR call.
- <static> fnPreDrawCallback :function
- Called at the very start of each table draw and can be used to cancel the +draw by returning false, any other return (including undefined) results in +the full draw occurring).
- <static> fnRowCallback :function
- This function allows you to 'post process' each row after it have been +generated for each table draw, but before it is rendered on screen. This +function might be used for setting the row class name etc.
- <static> fnServerData :function
- This parameter allows you to override the default function which obtains +the data from the server ($.getJSON) so something more suitable for your +application. For example you could use POST data, or pull information from +a Gears or AIR database.
- <static> fnServerParams :function
- It is often useful to send extra data to the server when making an Ajax +request - for example custom filtering information, and this callback +function makes it trivial to send extra information to the server. The +passed in parameter is the data set that has been constructed by +DataTables, and you can add to this or modify it as you require.
- <static> fnStateLoad :function
- Load the table state. With this function you can define from where, and how, the +state of a table is loaded. By default DataTables will load from its state saving +cookie, but you might wish to use local storage (HTML5) or a server-side database.
- <static> fnStateLoaded :function
- Callback that is called when the state has been loaded from the state saving method +and the DataTables settings object has been modified as a result of the loaded state.
- <static> fnStateLoadParams :function
- Callback which allows modification of the saved state prior to loading that state. +This callback is called when the table is loading state from the stored data, but +prior to the settings object being modified by the saved state. Note that for +plug-in authors, you should use the 'stateLoadParams' event to load parameters for +a plug-in.
- <static> fnStateSave :function
- Save the table state. This function allows you to define where and how the state +information for the table is stored - by default it will use a cookie, but you +might want to use local storage (HTML5) or a server-side database.
- <static> fnStateSaveParams :function
- Callback which allows modification of the state to be saved. Called when the table +has changed state a new state save is required. This method allows modification of +the state saving object prior to actually doing the save, including addition or +other state properties or modification. Note that for plug-in authors, you should +use the 'stateSaveParams' event to save parameters for a plug-in.
- <static> iCookieDuration :int
- Duration of the cookie which is used for storing session information. This +value is given in seconds.
- <static> iDeferLoading :int|array
- When enabled DataTables will not make a request to the server for the first +page draw - rather it will use the data already on the page (no sorting etc +will be applied to it), thus saving on an XHR at load time. iDeferLoading +is used to indicate that deferred loading is required, but it is also used +to tell DataTables how many records there are in the full table (allowing +the information element and pagination to be displayed correctly). In the case +where a filtering is applied to the table on initial load, this can be +indicated by giving the parameter as an array, where the first element is +the number of records available after filtering and the second element is the +number of records without filtering (allowing the table information element +to be shown correctly).
- <static> iDisplayLength :int
- Number of rows to display on a single page when using pagination. If +feature enabled (bLengthChange) then the end user will be able to override +this to a custom setting using a pop-up menu.
- <static> iDisplayStart :int
- Define the starting point for data display when using DataTables with +pagination. Note that this parameter is the number of records, rather than +the page number, so if you have 10 records per page and want to start on +the third page, it should be "20".
- <static> iScrollLoadGap :int
- The scroll gap is the amount of scrolling that is left to go before +DataTables will load the next 'page' of data automatically. You typically +want a gap which is big enough that the scrolling will be smooth for the +user, while not so large that it will load more data than need.
- <static> iTabIndex :int
- By default DataTables allows keyboard navigation of the table (sorting, paging, +and filtering) by adding a tabindex attribute to the required elements. This +allows you to tab through the controls and press the enter key to activate them. +The tabindex is default 0, meaning that the tab follows the flow of the document. +You can overrule this using this parameter if you wish. Use a value of -1 to +disable built-in keyboard navigation.
- <static> sAjaxDataProp :string
- By default DataTables will look for the property 'aaData' when obtaining +data from an Ajax source or for server-side processing - this parameter +allows that property to be changed. You can use Javascript dotted object +notation to get a data source for multiple levels of nesting.
- <static> sAjaxSource :string
- You can instruct DataTables to load data from an external source using this +parameter (use aData if you want to pass data in you already have). Simply +provide a url a JSON object can be obtained from. This object must include +the parameter 'aaData' which is the data source for the table.
- <static> sCookiePrefix :string
- This parameter can be used to override the default prefix that DataTables +assigns to a cookie when state saving is enabled.
- <static> sDom :string
- This initialisation variable allows you to specify exactly where in the
+DOM you want DataTables to inject the various controls it adds to the page
+(for example you might want the pagination controls at the top of the
+table). DIV elements (with or without a custom class) can also be added to
+aid styling. The follow syntax is used:
+
-
+
- The following options are allowed:
+
-
+
- 'l' - Length changing 'f' - Filtering input
+ - 't' - The table! +
- 'i' - Information +
- 'p' - Pagination +
- 'r' - pRocessing +
- The following constants are allowed: +
+-
+
- 'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix') +
- 'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix') +
- The following syntax is expected: +
+-
+
- '<' and '>' - div elements +
- '<"class" and '>' - div with a class +
- '<"#id" and '>' - div with an ID +
- Examples: +
+-
+
- '<"wrapper"flipt>' +
- '<lf<t>ip>' +
- The following options are allowed:
+
- <static> sPaginationType :string
- DataTables features two different built-in pagination interaction methods +('two_button' or 'full_numbers') which present different page controls to +the end user. Further methods can be added using the API (see below).
- <static> sScrollX :string
- Enable horizontal scrolling. When a table is too wide to fit into a certain +layout, or you have a large number of columns in the table, you can enable +x-scrolling to show the table in a viewport, which can be scrolled. This +property can be any CSS unit, or a number (in which case it will be treated +as a pixel measurement).
- <static> sScrollXInner :string
- This property can be used to force a DataTable to use more width than it +might otherwise do when x-scrolling is enabled. For example if you have a +table which requires to be well spaced, this parameter is useful for +"over-sizing" the table, and thus forcing scrolling. This property can by +any CSS unit, or a number (in which case it will be treated as a pixel +measurement).
- <static> sScrollY :string
- Enable vertical scrolling. Vertical scrolling will constrain the DataTable +to the given height, and enable scrolling for any data which overflows the +current viewport. This can be used as an alternative to paging to display +a lot of data in a small area (although paging and scrolling can both be +enabled at the same time). This property can be any CSS unit, or a number +(in which case it will be treated as a pixel measurement).
- <static> sServerMethod :string
- Set the HTTP method that is used to make the Ajax call for server-side +processing or Ajax sourced data. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> aaData :array
An array of data to use for the table, passed in at initialisation which +will be used in preference to any data which is already in the DOM. This is +particularly useful for constructing tables purely in Javascript, for +example with a custom Ajax call.
-
+
+
Examples
+++ +// Using a 2D array data source + $(document).ready( function () { + $('#example').dataTable( { + "aaData": [ + ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'], + ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'], + ], + "aoColumns": [ + { "sTitle": "Engine" }, + { "sTitle": "Browser" }, + { "sTitle": "Platform" }, + { "sTitle": "Version" }, + { "sTitle": "Grade" } + ] + } ); + } ); + ++++// Using an array of objects as a data source (mDataProp) + $(document).ready( function () { + $('#example').dataTable( { + "aaData": [ + { + "engine": "Trident", + "browser": "Internet Explorer 4.0", + "platform": "Win 95+", + "version": 4, + "grade": "X" + }, + { + "engine": "Trident", + "browser": "Internet Explorer 5.0", + "platform": "Win 95+", + "version": 5, + "grade": "C" + } + ], + "aoColumns": [ + { "sTitle": "Engine", "mDataProp": "engine" }, + { "sTitle": "Browser", "mDataProp": "browser" }, + { "sTitle": "Platform", "mDataProp": "platform" }, + { "sTitle": "Version", "mDataProp": "version" }, + { "sTitle": "Grade", "mDataProp": "grade" } + ] + } ); + } );+- <static> aaSorting :array
If sorting is enabled, then DataTables will perform a first pass sort on +initialisation. You can define which column(s) the sort is performed upon, +and the sorting direction, with this variable. The aaSorting array should +contain an array for each column to be sorted initially containing the +column's index and a direction string ('asc' or 'desc').
-
+
+
Example
+++// Sort by 3rd column first, and then 4th column + $(document).ready( function() { + $('#example').dataTable( { + "aaSorting": [[2,'asc'], [3,'desc']] + } ); + } ); + + // No initial sorting + $(document).ready( function() { + $('#example').dataTable( { + "aaSorting": [] + } ); + } );+- <static> aaSortingFixed :array
This parameter is basically identical to the aaSorting parameter, but +cannot be overridden by user interaction with the table. What this means +is that you could have a column (visible or hidden) which the sorting will +always be forced on first - any sorting after that (from the user) will +then be performed as required. This can be useful for grouping rows +together.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "aaSortingFixed": [[0,'asc']] + } ); + } )+- <static> aLengthMenu :array
This parameter allows you to readily specify the entries in the length drop +down menu that DataTables shows when pagination is enabled. It can be +either a 1D array of options which will be used for both the displayed +option and the value, or a 2D array which will use the array in the first +position as the value, and the array in the second position as the +displayed options (useful for language strings such as 'All').
-
+
+
Examples
+++ +$(document).ready(function() { + $('#example').dataTable( { + "aLengthMenu": [[10, 25, 50, -1], [10, 25, 50, "All"]] + } ); + } ); + ++++// Setting the default display length as well as length menu + // This is likely to be wanted if you remove the '10' option which + // is the iDisplayLength default. + $(document).ready(function() { + $('#example').dataTable( { + "iDisplayLength": 25, + "aLengthMenu": [[25, 50, 100, -1], [25, 50, 100, "All"]] + } ); + } );+- <static> aoColumnDefs
Very similar to aoColumns, aoColumnDefs allows you to target a specific +column, multiple columns, or all columns, using the aTargets property of +each object in the array. This allows great flexibility when creating +tables, as the aoColumnDefs arrays can be of any length, targeting the +columns you specifically want. aoColumnDefs may use any of the column +options available: DataTable.defaults.columns, but it _must_ +have aTargets defined in each object in the array. Values in the aTargets +array may be: +
-
+
- a string - class name will be matched on the TH for the column +
- 0 or a positive integer - column index counting from the left +
- a negative integer - column index counting from the right +
- the string "_all" - all columns (i.e. assign a default) +
-
+
+
- <static> aoColumns
The aoColumns option in the initialisation parameter allows you to define +details about the way individual columns behave. For a full list of +column options that can be set, please see +DataTable.defaults.columns. Note that if you use aoColumns to +define your columns, you must have an entry in the array for every single +column that you have in your table (these can be null if you don't which +to specify any options).
-
+
+
- <static> aoSearchCols :array
Basically the same as oSearch, this parameter defines the individual column +filtering state at initialisation time. The array must be of the same size +as the number of columns, and each element be an object with the parameters +"sSearch" and "bEscapeRegex" (the latter is optional). 'null' is also +accepted and the default will be used.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "aoSearchCols": [ + null, + { "sSearch": "My filter" }, + null, + { "sSearch": "^[0-9]", "bEscapeRegex": false } + ] + } ); + } )+- <static> asStripeClasses :array
An array of CSS classes that should be applied to displayed rows. This +array may be of any length, and DataTables will apply each class +sequentially, looping when required.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "asStripeClasses": [ 'strip1', 'strip2', 'strip3' ] + } ); + } )+- <static> bAutoWidth :boolean
Enable or disable automatic column width calculation. This can be disabled +as an optimisation (it takes some time to calculate the widths) if the +tables widths are passed in using aoColumns.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bAutoWidth": false + } ); + } );+- <static> bDeferRender :boolean
Deferred rendering can provide DataTables with a huge speed boost when you +are using an Ajax or JS data source for the table. This option, when set to +true, will cause DataTables to defer the creation of the table elements for +each row until they are needed for a draw - saving a significant amount of +time.
-
+
+
Example
+++$(document).ready(function() { + var oTable = $('#example').dataTable( { + "sAjaxSource": "sources/arrays.txt", + "bDeferRender": true + } ); + } );+- <static> bDestroy :boolean
Replace a DataTable which matches the given selector and replace it with +one which has the properties of the new initialisation object passed. If no +table matches the selector, then the new DataTable will be constructed as +per normal.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sScrollY": "200px", + "bPaginate": false + } ); + + // Some time later.... + $('#example').dataTable( { + "bFilter": false, + "bDestroy": true + } ); + } );+- <static> bFilter :boolean
Enable or disable filtering of data. Filtering in DataTables is "smart" in +that it allows the end user to input multiple words (space separated) and +will match a row containing those words, even if not in the order that was +specified (this allow matching across multiple columns). Note that if you +wish to use filtering in DataTables this must remain 'true' - to remove the +default filtering input box and retain filtering abilities, please use +DataTable.defaults.sDom.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bFilter": false + } ); + } );+- <static> bInfo :boolean
Enable or disable the table information display. This shows information +about the data that is currently visible on the page, including information +about filtered data if that action is being performed.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bInfo": false + } ); + } );+- <static> bJQueryUI :boolean
Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some +slightly different and additional mark-up from what DataTables has +traditionally used).
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "bJQueryUI": true + } ); + } );+- <static> bLengthChange :boolean
Allows the end user to select the size of a formatted page from a select +menu (sizes are 10, 25, 50 and 100). Requires pagination (bPaginate).
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bLengthChange": false + } ); + } );+- <static> bPaginate :boolean
Enable or disable pagination.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bPaginate": false + } ); + } );+- <static> bProcessing :boolean
Enable or disable the display of a 'processing' indicator when the table is +being processed (e.g. a sort). This is particularly useful for tables with +large amounts of data where it can take a noticeable amount of time to sort +the entries.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bProcessing": true + } ); + } );+- <static> bRetrieve :boolean
Retrieve the DataTables object for the given selector. Note that if the +table has already been initialised, this parameter will cause DataTables +to simply return the object that has already been set up - it will not take +account of any changes you might have made to the initialisation object +passed to DataTables (setting this parameter to true is an acknowledgement +that you understand this). bDestroy can be used to reinitialise a table if +you need.
-
+
+
Example
+++$(document).ready(function() { + initTable(); + tableActions(); + } ); + + function initTable () + { + return $('#example').dataTable( { + "sScrollY": "200px", + "bPaginate": false, + "bRetrieve": true + } ); + } + + function tableActions () + { + var oTable = initTable(); + // perform API operations with oTable + }+- <static> bScrollAutoCss :boolean
Indicate if DataTables should be allowed to set the padding / margin +etc for the scrolling header elements or not. Typically you will want +this.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "bScrollAutoCss": false, + "sScrollY": "200px" + } ); + } );+- <static> bScrollCollapse :boolean
When vertical (y) scrolling is enabled, DataTables will force the height of +the table's viewport to the given height at all times (useful for layout). +However, this can look odd when filtering data down to a small data set, +and the footer is left "floating" further down. This parameter (when +enabled) will cause DataTables to collapse the table's viewport down when +the result set will fit within the given Y height.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sScrollY": "200", + "bScrollCollapse": true + } ); + } );+- <static> bScrollInfinite :boolean
Enable infinite scrolling for DataTables (to be used in combination with +sScrollY). Infinite scrolling means that DataTables will continually load +data as a user scrolls through a table, which is very useful for large +dataset. This cannot be used with pagination, which is automatically +disabled. Note - the Scroller extra for DataTables is recommended in +in preference to this option.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "bScrollInfinite": true, + "bScrollCollapse": true, + "sScrollY": "200px" + } ); + } );+- <static> bServerSide :boolean
Configure DataTables to use server-side processing. Note that the +sAjaxSource parameter must also be given in order to give DataTables a +source to obtain the required data for each draw.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bServerSide": true, + "sAjaxSource": "xhr.php" + } ); + } );+- <static> bSort :boolean
Enable or disable sorting of columns. Sorting of individual columns can be +disabled by the "bSortable" option for each column.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bSort": false + } ); + } );+- <static> bSortCellsTop :boolean
Allows control over whether DataTables should use the top (true) unique +cell that is found for a single column, or the bottom (false - default). +This is useful when using complex headers.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "bSortCellsTop": true + } ); + } );+- <static> bSortClasses :boolean
Enable or disable the addition of the classes 'sorting_1', 'sorting_2' and +'sorting_3' to the columns which are currently being sorted on. This is +presented as a feature switch as it can increase processing time (while +classes are removed and added) so for large data sets you might want to +turn this off.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bSortClasses": false + } ); + } );+- <static> bStateSave :boolean
Enable or disable state saving. When enabled a cookie will be used to save +table display information such as pagination information, display length, +filtering and sorting. As such when the end user reloads the page the +display display will match what thy had previously set up.
-
+
+
Example
+++$(document).ready( function () { + $('#example').dataTable( { + "bStateSave": true + } ); + } );+- <static> fnCookieCallback :function
Customise the cookie and / or the parameters being stored when using +DataTables with state saving enabled. This function is called whenever +the cookie is modified, and it expects a fully formed cookie string to be +returned. Note that the data object passed in is a Javascript object which +must be converted to a string (JSON.stringify for example).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sName string Name of the cookie defined by DataTables 2oData object Data to be stored in the cookie 3sExpires string Cookie expires string sPath string Path of the cookie to set Returns:
Cookie formatted string (which should be encoded by + using encodeURIComponent())
Example:
+++$(document).ready( function () { + $('#example').dataTable( { + "fnCookieCallback": function (sName, oData, sExpires, sPath) { + // Customise oData or sName or whatever else here + return sName + "="+JSON.stringify(oData)+"; expires=" + sExpires +"; path=" + sPath; + } + } ); + } );+- <static> fnCreatedRow :function
This function is called when a TR element is created (and all TD child +elements have been inserted), or registered if using a DOM source, allowing +manipulation of the TR element (adding classes etc).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nRow node "TR" element for the current row 2aData array Raw data array for this row iDataIndex int The index of this row in aoData Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "fnCreatedRow": function( nRow, aData, iDataIndex ) { + // Bold the grade for all 'A' grade browsers + if ( aData[4] == "A" ) + { + $('td:eq(4)', nRow).html( 'A' ); + } + } + } ); + } );+- <static> fnDrawCallback :function
This function is called on every 'draw' event, and allows you to +dynamically modify any aspect you want about the created DOM.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object DataTables settings object Example:
+++$(document).ready( function() { + $('#example').dataTable( { + "fnDrawCallback": function( oSettings ) { + alert( 'DataTables has redrawn the table' ); + } + } ); + } );+Identical to fnHeaderCallback() but for the table footer this function +allows you to modify the table footer on every 'draw' even.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nFoot node "TR" element for the footer 2aData array Full table data (as derived from the original HTML) 3iStart int Index for the current display starting point in the + display array 4iEnd int Index for the current display ending point in the + display array aiDisplay array int Index array to translate the visual position + to the full data array Example:
+++$(document).ready( function() { + $('#example').dataTable( { + "fnFooterCallback": function( nFoot, aData, iStart, iEnd, aiDisplay ) { + nFoot.getElementsByTagName('th')[0].innerHTML = "Starting index is "+iStart; + } + } ); + } )+- <static> fnFormatNumber :function
When rendering large numbers in the information element for the table +(i.e. "Showing 1 to 10 of 57 entries") DataTables will render large numbers +to have a comma separator for the 'thousands' units (e.g. 1 million is +rendered as "1,000,000") to help readability for the end user. This +function will override the default method DataTables uses.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +iIn int number to be formatted Returns:
formatted string for DataTables to show the number
Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "fnFormatNumber": function ( iIn ) { + if ( iIn < 1000 ) { + return iIn; + } else { + var + s=(iIn+""), + a=s.split(""), out="", + iLen=s.length; + + for ( var i=0 ; i<iLen ; i++ ) { + if ( i%3 === 0 && i !== 0 ) { + out = "'"+out; + } + out = a[iLen-i-1]+out; + } + } + return out; + }; + } ); + } );+- <static> fnHeaderCallback :function
This function is called on every 'draw' event, and allows you to +dynamically modify the header row. This can be used to calculate and +display useful information about the table.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nHead node "TR" element for the header 2aData array Full table data (as derived from the original HTML) 3iStart int Index for the current display starting point in the + display array 4iEnd int Index for the current display ending point in the + display array aiDisplay array int Index array to translate the visual position + to the full data array Example:
+++$(document).ready( function() { + $('#example').dataTable( { + "fnHeaderCallback": function( nHead, aData, iStart, iEnd, aiDisplay ) { + nHead.getElementsByTagName('th')[0].innerHTML = "Displaying "+(iEnd-iStart)+" records"; + } + } ); + } )+- <static> fnInfoCallback :function
The information element can be used to convey information about the current +state of the table. Although the internationalisation options presented by +DataTables are quite capable of dealing with most customisations, there may +be times where you wish to customise the string further. This callback +allows you to do exactly that.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object 2iStart int Starting position in data for the draw 3iEnd int End position in data for the draw 4iMax int Total number of rows in the table (regardless of + filtering) 5iTotal int Total number of rows in the data set, after filtering sPre string The string that DataTables has formatted using it's + own rules Returns:
The string to be displayed in the information element.
Example:
+++$('#example').dataTable( { + "fnInfoCallback": function( oSettings, iStart, iEnd, iMax, iTotal, sPre ) { + return iStart +" to "+ iEnd; + } + } );+- <static> fnInitComplete :function
Called when the table has been initialised. Normally DataTables will +initialise sequentially and there will be no need for this function, +however, this does not hold true when using external language information +since that is obtained using an async XHR call.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object json object The JSON object request from the server - only + present if client-side Ajax sourced data is used Example:
+++$(document).ready( function() { + $('#example').dataTable( { + "fnInitComplete": function(oSettings, json) { + alert( 'DataTables has finished its initialisation.' ); + } + } ); + } )+- <static> fnPreDrawCallback :function
Called at the very start of each table draw and can be used to cancel the +draw by returning false, any other return (including undefined) results in +the full draw occurring).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object DataTables settings object Returns:
False will cancel the draw, anything else (including no + return) will allow it to complete.
Example:
+++$(document).ready( function() { + $('#example').dataTable( { + "fnPreDrawCallback": function( oSettings ) { + if ( $('#test').val() == 1 ) { + return false; + } + } + } ); + } );+- <static> fnRowCallback :function
This function allows you to 'post process' each row after it have been +generated for each table draw, but before it is rendered on screen. This +function might be used for setting the row class name etc.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nRow node "TR" element for the current row 2aData array Raw data array for this row 3iDisplayIndex int The display index for the current table draw iDisplayIndexFull int The index of the data in the full list of + rows (after filtering) Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "fnRowCallback": function( nRow, aData, iDisplayIndex, iDisplayIndexFull ) { + // Bold the grade for all 'A' grade browsers + if ( aData[4] == "A" ) + { + $('td:eq(4)', nRow).html( 'A' ); + } + } + } ); + } );+- <static> fnServerData :function
This parameter allows you to override the default function which obtains +the data from the server ($.getJSON) so something more suitable for your +application. For example you could use POST data, or pull information from +a Gears or AIR database.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sSource string HTTP source to obtain the data from (sAjaxSource) 2aoData array A key/value pair object containing the data to send + to the server 3fnCallback function to be called on completion of the data get + process that will draw the data on the page. oSettings object DataTables settings object Example:
+++// POST data to server + $(document).ready(function() { + $('#example').dataTable( { + "bProcessing": true, + "bServerSide": true, + "sAjaxSource": "xhr.php", + "fnServerData": function ( sSource, aoData, fnCallback ) { + $.ajax( { + "dataType": 'json', + "type": "POST", + "url": sSource, + "data": aoData, + "success": fnCallback + } ); + } + } ); + } );+- <static> fnServerParams :function
It is often useful to send extra data to the server when making an Ajax +request - for example custom filtering information, and this callback +function makes it trivial to send extra information to the server. The +passed in parameter is the data set that has been constructed by +DataTables, and you can add to this or modify it as you require.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +aoData array Data array (array of objects which are name/value + pairs) that has been constructed by DataTables and will be sent to the + server. In the case of Ajax sourced data with server-side processing + this will be an empty array, for server-side processing there will be a + significant number of parameters! Returns:
Ensure that you modify the aoData array passed in, + as this is passed by reference.
Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "bProcessing": true, + "bServerSide": true, + "sAjaxSource": "scripts/server_processing.php", + "fnServerParams": function ( aoData ) { + aoData.push( { "name": "more_data", "value": "my_value" } ); + } + } ); + } );+- <static> fnStateLoad :function
Load the table state. With this function you can define from where, and how, the +state of a table is loaded. By default DataTables will load from its state saving +cookie, but you might wish to use local storage (HTML5) or a server-side database.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oSettings object DataTables settings object Returns:
The DataTables state object to be loaded
Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateLoad": function (oSettings, oData) { + var o; + + // Send an Ajax request to the server to get the data. Note that + // this is a synchronous request. + $.ajax( { + "url": "/state_load", + "async": false, + "dataType": "json", + "success": function (json) { + o = json; + } + } ); + + return o; + } + } ); + } );+- <static> fnStateLoaded :function
Callback that is called when the state has been loaded from the state saving method +and the DataTables settings object has been modified as a result of the loaded state.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object oData object The state object that was loaded Example:
+++// Show an alert with the filtering value that was saved + $(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateLoaded": function (oSettings, oData) { + alert( 'Saved filter was: '+oData.oSearch.sSearch ); + } ); + } );+- <static> fnStateLoadParams :function
Callback which allows modification of the saved state prior to loading that state. +This callback is called when the table is loading state from the stored data, but +prior to the settings object being modified by the saved state. Note that for +plug-in authors, you should use the 'stateLoadParams' event to load parameters for +a plug-in.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object oData object The state object that is to be loaded Examples:
+++ +// Remove a saved filter, so filtering is never loaded + $(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateLoadParams": function (oSettings, oData) { + oData.oSearch.sSearch = ""; + } ); + } ); + ++++// Disallow state loading by returning false + $(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateLoadParams": function (oSettings, oData) { + return false; + } ); + } );+- <static> fnStateSave :function
Save the table state. This function allows you to define where and how the state +information for the table is stored - by default it will use a cookie, but you +might want to use local storage (HTML5) or a server-side database.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object oData object The state object to be saved Example:
+++$(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateSave": function (oSettings, oData) { + // Send an Ajax request to the server with the state object + $.ajax( { + "url": "/state_save", + "data": oData, + "dataType": "json", + "method": "POST" + "success": function () {} + } ); + } + } ); + } );+- <static> fnStateSaveParams :function
Callback which allows modification of the state to be saved. Called when the table +has changed state a new state save is required. This method allows modification of +the state saving object prior to actually doing the save, including addition or +other state properties or modification. Note that for plug-in authors, you should +use the 'stateSaveParams' event to save parameters for a plug-in.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oSettings object DataTables settings object oData object The state object to be saved Example:
+++// Remove a saved filter, so filtering is never saved + $(document).ready(function() { + $('#example').dataTable( { + "bStateSave": true, + "fnStateSaveParams": function (oSettings, oData) { + oData.oSearch.sSearch = ""; + } ); + } );+- <static> iCookieDuration :int
Duration of the cookie which is used for storing session information. This +value is given in seconds.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "iCookieDuration": 60*60*24 // 1 day + } ); + } )+- <static> iDeferLoading :int|array
When enabled DataTables will not make a request to the server for the first +page draw - rather it will use the data already on the page (no sorting etc +will be applied to it), thus saving on an XHR at load time. iDeferLoading +is used to indicate that deferred loading is required, but it is also used +to tell DataTables how many records there are in the full table (allowing +the information element and pagination to be displayed correctly). In the case +where a filtering is applied to the table on initial load, this can be +indicated by giving the parameter as an array, where the first element is +the number of records available after filtering and the second element is the +number of records without filtering (allowing the table information element +to be shown correctly).
-
+
+
Examples
+++ +// 57 records available in the table, no filtering applied + $(document).ready(function() { + $('#example').dataTable( { + "bServerSide": true, + "sAjaxSource": "scripts/server_processing.php", + "iDeferLoading": 57 + } ); + } ); + ++++// 57 records after filtering, 100 without filtering (an initial filter applied) + $(document).ready(function() { + $('#example').dataTable( { + "bServerSide": true, + "sAjaxSource": "scripts/server_processing.php", + "iDeferLoading": [ 57, 100 ], + "oSearch": { + "sSearch": "my_filter" + } + } ); + } );+- <static> iDisplayLength :int
Number of rows to display on a single page when using pagination. If +feature enabled (bLengthChange) then the end user will be able to override +this to a custom setting using a pop-up menu.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "iDisplayLength": 50 + } ); + } )+- <static> iDisplayStart :int
Define the starting point for data display when using DataTables with +pagination. Note that this parameter is the number of records, rather than +the page number, so if you have 10 records per page and want to start on +the third page, it should be "20".
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "iDisplayStart": 20 + } ); + } )+- <static> iScrollLoadGap :int
The scroll gap is the amount of scrolling that is left to go before +DataTables will load the next 'page' of data automatically. You typically +want a gap which is big enough that the scrolling will be smooth for the +user, while not so large that it will load more data than need.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "bScrollInfinite": true, + "bScrollCollapse": true, + "sScrollY": "200px", + "iScrollLoadGap": 50 + } ); + } );+- <static> iTabIndex :int
By default DataTables allows keyboard navigation of the table (sorting, paging, +and filtering) by adding a tabindex attribute to the required elements. This +allows you to tab through the controls and press the enter key to activate them. +The tabindex is default 0, meaning that the tab follows the flow of the document. +You can overrule this using this parameter if you wish. Use a value of -1 to +disable built-in keyboard navigation.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "iTabIndex": 1 + } ); + } );+- <static> sAjaxDataProp :string
By default DataTables will look for the property 'aaData' when obtaining +data from an Ajax source or for server-side processing - this parameter +allows that property to be changed. You can use Javascript dotted object +notation to get a data source for multiple levels of nesting.
-
+
+
Examples
+++ +// Get data from { "data": [...] } + $(document).ready(function() { + var oTable = $('#example').dataTable( { + "sAjaxSource": "sources/data.txt", + "sAjaxDataProp": "data" + } ); + } ); + ++++// Get data from { "data": { "inner": [...] } } + $(document).ready(function() { + var oTable = $('#example').dataTable( { + "sAjaxSource": "sources/data.txt", + "sAjaxDataProp": "data.inner" + } ); + } );+- <static> sAjaxSource :string
You can instruct DataTables to load data from an external source using this +parameter (use aData if you want to pass data in you already have). Simply +provide a url a JSON object can be obtained from. This object must include +the parameter 'aaData' which is the data source for the table.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "sAjaxSource": "http://www.sprymedia.co.uk/dataTables/json.php" + } ); + } )+- <static> sCookiePrefix :string
This parameter can be used to override the default prefix that DataTables +assigns to a cookie when state saving is enabled.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sCookiePrefix": "my_datatable_", + } ); + } );+- <static> sDom :string
This initialisation variable allows you to specify exactly where in the +DOM you want DataTables to inject the various controls it adds to the page +(for example you might want the pagination controls at the top of the +table). DIV elements (with or without a custom class) can also be added to +aid styling. The follow syntax is used: +
-
+
- The following options are allowed:
+
-
+
- 'l' - Length changing 'f' - Filtering input
+ - 't' - The table! +
- 'i' - Information +
- 'p' - Pagination +
- 'r' - pRocessing +
- The following constants are allowed: +
+-
+
- 'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix') +
- 'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix') +
- The following syntax is expected: +
+-
+
- '<' and '>' - div elements +
- '<"class" and '>' - div with a class +
- '<"#id" and '>' - div with an ID +
- Examples: +
+-
+
- '<"wrapper"flipt>' +
- '<lf<t>ip>' +
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sDom": '<"top"i>rt<"bottom"flp><"clear"&lgt;' + } ); + } );+- The following options are allowed:
+
- <static> sPaginationType :string
DataTables features two different built-in pagination interaction methods +('two_button' or 'full_numbers') which present different page controls to +the end user. Further methods can be added using the API (see below).
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "sPaginationType": "full_numbers" + } ); + } )+- <static> sScrollX :string
Enable horizontal scrolling. When a table is too wide to fit into a certain +layout, or you have a large number of columns in the table, you can enable +x-scrolling to show the table in a viewport, which can be scrolled. This +property can be any CSS unit, or a number (in which case it will be treated +as a pixel measurement).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sScrollX": "100%", + "bScrollCollapse": true + } ); + } );+- <static> sScrollXInner :string
This property can be used to force a DataTable to use more width than it +might otherwise do when x-scrolling is enabled. For example if you have a +table which requires to be well spaced, this parameter is useful for +"over-sizing" the table, and thus forcing scrolling. This property can by +any CSS unit, or a number (in which case it will be treated as a pixel +measurement).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sScrollX": "100%", + "sScrollXInner": "110%" + } ); + } );+- <static> sScrollY :string
Enable vertical scrolling. Vertical scrolling will constrain the DataTable +to the given height, and enable scrolling for any data which overflows the +current viewport. This can be used as an alternative to paging to display +a lot of data in a small area (although paging and scrolling can both be +enabled at the same time). This property can be any CSS unit, or a number +(in which case it will be treated as a pixel measurement).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "sScrollY": "200px", + "bPaginate": false + } ); + } );+- <static> sServerMethod :string
Set the HTTP method that is used to make the Ajax call for server-side +processing or Ajax sourced data.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "bServerSide": true, + "sAjaxSource": "scripts/post.php", + "sServerMethod": "POST" + } ); + } );+
+
+
+
+ Namespace: oAria - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oLanguage
+Ancestry: DataTable ยป .defaults. ยป oLanguage
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oAria.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oAria.html
new file mode 100644
index 0000000..7b79718
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oAria.html
@@ -0,0 +1,135 @@
+
+
+
+
+
+
+
+
+
+ All strings that DataTables uses in the user interface that it creates +are defined in this object, allowing you to modified them individually or +completely replace them all as required.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- oAria
- Strings that are used for WAI-ARIA labels and controls only (these are not +actually visible on the page, but will be read by screenreaders, and thus +must be internationalised as well).
- oPaginate
- Pagination string used by DataTables for the two built-in pagination +control types ("two_button" and "full_numbers") +
Properties
+ +-
+
- <static> sEmptyTable :string
- This string is shown in preference to sZeroRecords when the table is +empty of data (regardless of filtering). Note that this is an optional +parameter - if it is not given, the value of sZeroRecords will be used +instead (either the default or given value).
- <static> sInfo :string
- This string gives information to the end user about the information that +is current on display on the page. The _START_, _END_ and _TOTAL_ +variables are all dynamically replaced as the table display updates, and +can be freely moved or removed as the language requirements change.
- <static> sInfoEmpty :string
- Display information string for when the table is empty. Typically the +format of this string should match sInfo.
- <static> sInfoFiltered :string
- When a user filters the information in a table, this string is appended +to the information (sInfo) to give an idea of how strong the filtering +is. The variable _MAX_ is dynamically updated.
- <static> sInfoPostFix :string
- If can be useful to append extra information to the info string at times, +and this variable does exactly that. This information will be appended to +the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are +being used) at all times.
- <static> sInfoThousands :string
- DataTables has a build in number formatter (fnFormatNumber) which is used +to format large numbers that are used in the table information. By +default a comma is used, but this can be trivially changed to any +character you wish with this parameter.
- <static> sLengthMenu :string
- Detail the action that will be taken when the drop down menu for the +pagination length option is changed. The '_MENU_' variable is replaced +with a default select list of 10, 25, 50 and 100, and can be replaced +with a custom select box if required.
- <static> sLoadingRecords :string
- When using Ajax sourced data and during the first draw when DataTables is +gathering the data, this message is shown in an empty row in the table to +indicate to the end user the the data is being loaded. Note that this +parameter is not used when loading data by server-side processing, just +Ajax sourced data with client-side processing.
- <static> sProcessing :string
- Text which is displayed when the table is processing a user action +(usually a sort command or similar).
- <static> sSearch :string
- Details the actions that will be taken when the user types into the +filtering input text box. The variable "_INPUT_", if used in the string, +is replaced with the HTML text box for the filtering input allowing +control over where it appears in the string. If "_INPUT_" is not given +then the input box is appended to the string automatically.
- <static> sUrl :string
- All of the language information can be stored in a file on the +server-side, which DataTables will look up if this parameter is passed. +It must store the URL of the language file, which is in a JSON format, +and the object has the same properties as the oLanguage object in the +initialiser object (i.e. the above parameters). Please refer to one of +the example language files to see how this works in action.
- <static> sZeroRecords :string
- Text shown inside the table records when the is no information to be +displayed after filtering. sEmptyTable is shown when there is simply no +information in the table at all (regardless of filtering). +
+
+
+
+
+ Details
+Properties
+-
+
- <static> sEmptyTable :string
This string is shown in preference to sZeroRecords when the table is +empty of data (regardless of filtering). Note that this is an optional +parameter - if it is not given, the value of sZeroRecords will be used +instead (either the default or given value).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sEmptyTable": "No data available in table" + } + } ); + } );+- <static> sInfo :string
This string gives information to the end user about the information that +is current on display on the page. The _START_, _END_ and _TOTAL_ +variables are all dynamically replaced as the table display updates, and +can be freely moved or removed as the language requirements change.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfo": "Got a total of _TOTAL_ entries to show (_START_ to _END_)" + } + } ); + } );+- <static> sInfoEmpty :string
Display information string for when the table is empty. Typically the +format of this string should match sInfo.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoEmpty": "No entries to show" + } + } ); + } );+- <static> sInfoFiltered :string
When a user filters the information in a table, this string is appended +to the information (sInfo) to give an idea of how strong the filtering +is. The variable _MAX_ is dynamically updated.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoFiltered": " - filtering from _MAX_ records" + } + } ); + } );+- <static> sInfoPostFix :string
If can be useful to append extra information to the info string at times, +and this variable does exactly that. This information will be appended to +the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are +being used) at all times.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoPostFix": "All records shown are derived from real information." + } + } ); + } );+- <static> sInfoThousands :string
DataTables has a build in number formatter (fnFormatNumber) which is used +to format large numbers that are used in the table information. By +default a comma is used, but this can be trivially changed to any +character you wish with this parameter.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoThousands": "'" + } + } ); + } );+- <static> sLengthMenu :string
Detail the action that will be taken when the drop down menu for the +pagination length option is changed. The '_MENU_' variable is replaced +with a default select list of 10, 25, 50 and 100, and can be replaced +with a custom select box if required.
-
+
+
Examples
+++ +// Language change only + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sLengthMenu": "Display _MENU_ records" + } + } ); + } ); + ++++// Language and options change + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sLengthMenu": 'Display records' + } + } ); + } );+- <static> sLoadingRecords :string
When using Ajax sourced data and during the first draw when DataTables is +gathering the data, this message is shown in an empty row in the table to +indicate to the end user the the data is being loaded. Note that this +parameter is not used when loading data by server-side processing, just +Ajax sourced data with client-side processing.
-
+
+
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "oLanguage": { + "sLoadingRecords": "Please wait - loading..." + } + } ); + } );+- <static> sProcessing :string
Text which is displayed when the table is processing a user action +(usually a sort command or similar).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sProcessing": "DataTables is currently busy" + } + } ); + } );+- <static> sSearch :string
Details the actions that will be taken when the user types into the +filtering input text box. The variable "_INPUT_", if used in the string, +is replaced with the HTML text box for the filtering input allowing +control over where it appears in the string. If "_INPUT_" is not given +then the input box is appended to the string automatically.
-
+
+
Examples
+++ +// Input text box will be appended at the end automatically + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sSearch": "Filter records:" + } + } ); + } ); + ++++// Specify where the filter should appear + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sSearch": "Apply filter _INPUT_ to table" + } + } ); + } );+- <static> sUrl :string
All of the language information can be stored in a file on the +server-side, which DataTables will look up if this parameter is passed. +It must store the URL of the language file, which is in a JSON format, +and the object has the same properties as the oLanguage object in the +initialiser object (i.e. the above parameters). Please refer to one of +the example language files to see how this works in action.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sUrl": "http://www.sprymedia.co.uk/dataTables/lang.txt" + } + } ); + } );+- <static> sZeroRecords :string
Text shown inside the table records when the is no information to be +displayed after filtering. sEmptyTable is shown when there is simply no +information in the table at all (regardless of filtering).
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sZeroRecords": "No records to display" + } + } ); + } );+
+
+
+
+ Namespace: oPaginate - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oAria
+Ancestry: DataTable ยป .defaults ยป .oLanguage. ยป oAria
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oPaginate.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oPaginate.html
new file mode 100644
index 0000000..e20881c
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oLanguage.oPaginate.html
@@ -0,0 +1,164 @@
+
+
+
+
+
+
+
+
+
+ Strings that are used for WAI-ARIA labels and controls only (these are not +actually visible on the page, but will be read by screenreaders, and thus +must be internationalised as well).
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> sSortAscending :string
- ARIA label that is added to the table headers when the column may be +sorted ascending by activing the column (click or return when focused). +Note that the column header is prefixed to this string.
- <static> sSortDescending :string
- ARIA label that is added to the table headers when the column may be +sorted descending by activing the column (click or return when focused). +Note that the column header is prefixed to this string. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> sSortAscending :string
ARIA label that is added to the table headers when the column may be +sorted ascending by activing the column (click or return when focused). +Note that the column header is prefixed to this string.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oAria": { + "sSortAscending": " - click/return to sort ascending" + } + } + } ); + } );+- <static> sSortDescending :string
ARIA label that is added to the table headers when the column may be +sorted descending by activing the column (click or return when focused). +Note that the column header is prefixed to this string.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oAria": { + "sSortDescending": " - click/return to sort descending" + } + } + } ); + } );+
+
+
+
+ Namespace: oSearch - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oPaginate
+Ancestry: DataTable ยป .defaults ยป .oLanguage. ยป oPaginate
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oSearch.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oSearch.html
new file mode 100644
index 0000000..ce463f4
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.defaults.oSearch.html
@@ -0,0 +1,129 @@
+
+
+
+
+
+
+
+
+
+ Pagination string used by DataTables for the two built-in pagination +control types ("two_button" and "full_numbers")
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> sFirst :string
- Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the first page.
- <static> sLast :string
- Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the last page.
- <static> sNext :string
- Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the next page.
- <static> sPrevious :string
- Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the previous page. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> sFirst :string
Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the first page.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oPaginate": { + "sFirst": "First page" + } + } + } ); + } );+- <static> sLast :string
Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the last page.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oPaginate": { + "sLast": "Last page" + } + } + } ); + } );+- <static> sNext :string
Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the next page.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oPaginate": { + "sNext": "Next page" + } + } + } ); + } );+- <static> sPrevious :string
Text to use when using the 'full_numbers' type of pagination for the +button to take the user to the previous page.
-
+
+
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "oPaginate": { + "sPrevious": "Previous page" + } + } + } ); + } );+
+
+
+
+ Namespace: ext - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oSearch
+Ancestry: DataTable ยป .defaults. ยป oSearch
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.ext.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.ext.html
new file mode 100644
index 0000000..405a9f5
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.ext.html
@@ -0,0 +1,764 @@
+
+
+
+
+
+
+
+
+
+ This parameter allows you to have define the global filtering state at +initialisation time. As an object the "sSearch" parameter must be +defined, but all other parameters are optional. When "bRegex" is true, +the search string will be treated as a regular expression, when false +(default) it will be treated as a straight string. When "bSmart" +DataTables will use it's smart filtering methods (to word match at +any point in the data), when false this will not be done.
-
+
+
Example
+
+
+ $(document).ready( function() {
+ $('#example').dataTable( {
+ "oSearch": {"sSearch": "Initial search"}
+ } );
+ } )
+ Extends
+ + +
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> bCaseInsensitive :boolean
- Flag to indicate if the filtering should be case insensitive or not
- <static> bRegex :boolean
- Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
- <static> bSmart :boolean
- Flag to indicate if DataTables is to use its smart filtering or not.
- <static> sSearch :string
- Applied search term
+
+
+
+
+
+ Details
+Properties
+-
+
- <static> bCaseInsensitive :boolean
Flag to indicate if the filtering should be case insensitive or not
- <static> bRegex :boolean
Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
- <static> bSmart :boolean
Flag to indicate if DataTables is to use its smart filtering or not.
- <static> sSearch :string
Applied search term
+
+
+
+
+
+
+
+ Class: DataTable - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.html
new file mode 100644
index 0000000..eb12882
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.html
@@ -0,0 +1,1362 @@
+
+
+
+
+
+
+
+
+
+ Extension object for DataTables that is used to provide all extension options.
Note that the DataTable.ext object is available through
+jQuery.fn.dataTable.ext where it may be accessed and manipulated. It is
+also aliased to jQuery.fn.dataTableExt for historic reasons.
-
+
+
Extends
+ + +
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> afnFiltering :array
- Plug-in filtering functions - this method of filtering is complimentary to the default +type based filtering, and a lot more comprehensive as it allows you complete control +over the filtering logic. Each element in this array is a function (parameters +described below) that is called for every row in the table, and your logic decides if +it should be included in the filtered data set or not. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {array|object} Data for the row to be processed (same as the original format + that was passed in as the data source, or an array from a DOM data source +
- {int} Row index in aoData (DataTable.models.oSettings.aoData), which can + be useful to retrieve the TR element if you need DOM interaction. +
+ -
+ Function return:
+
-
+
- {boolean} Include the row in the filtered result set (true) or not (false) +
-
+ Function input parameters:
+
- <static> afnSortData :array
- Plug-in sorting functions - this method of sorting is complimentary to the default type +based sorting that DataTables does automatically, allowing much greater control over the +the data that is being used to sort a column. This is useful if you want to do sorting +based on live data (for example the contents of an 'input' element) rather than just the +static string that DataTables knows of. The way these plug-ins work is that you create +an array of the values you wish to be sorted for the column in question and then return +that array. Which pre-sorting function is run here depends on the sSortDataType parameter +that is used for the column (if any). This is the corollary of ofnSearch for sort +data. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {int} Target column index +
+ -
+ Function return:
+
-
+
- {array} Data for the column to be sorted upon +
-
+ Function input parameters:
+
- <static> aoFeatures :array
- Feature plug-ins - This is an array of objects which describe the feature plug-ins that are +available to DataTables. These feature plug-ins are accessible through the sDom initialisation +option. As such, each feature plug-in must describe a function that is used to initialise +itself (fnInit), a character so the feature can be enabled by sDom (cFeature) and the name +of the feature (sFeature). Thus the objects attached to this method must provide: +
-
+
- {function} fnInit Initialisation of the plug-in
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
+ -
+ Function return:
+
-
+
- {node|null} The element which contains your feature. Note that the return + may also be void if your plug-in does not require to inject any DOM elements + into DataTables control (sDom) - for example this might be useful when + developing a plug-in which allows table control via keyboard entry. +
+ -
+ Function input parameters:
+
- {character} cFeature Character that will be matched in sDom - case sensitive +
- {string} sFeature Feature name +
- {function} fnInit Initialisation of the plug-in
+
- <static> aTypes :array
- Type detection plug-in functions - DataTables utilises types to define how sorting and +filtering behave, and types can be either be defined by the developer (sType for the +column) or they can be automatically detected by the methods in this array. The functions +defined in the array are quite simple, taking a single parameter (the data to analyse) +and returning the type if it is a known type, or null otherwise. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be analysed +
+ -
+ Function return:
+
-
+
- {string|null} Data type detected, or null if unknown (and thus pass it + on to the other type detection functions. +
-
+ Function input parameters:
+
- <static> fnVersionCheck :function
- Provide a common method for plug-ins to check the version of DataTables being used, +in order to ensure compatibility.
- <static> iApiIndex :int
- Index for what 'this' index API functions should use
- <static> oApi :object
- Container for all private functions in DataTables so they can be exposed externally
- <static> ofnSearch :object
- Pre-processing of filtering data plug-ins - When you assign the sType for a column +(or have it automatically detected for you by DataTables or a type detection plug-in), +you will typically be using this for custom sorting, but it can also be used to provide +custom filtering by allowing you to pre-processing the data and returning the data in +the format that should be filtered upon. This is done by adding functions this object +with a parameter name which matches the sType for that target column. This is the +corollary of afnSortData for filtering data. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be prepared for filtering +
+ -
+ Function return:
+
-
+
- {string|null} Formatted string that will be used for the filtering. +
-
+ Function input parameters:
+
- <static> oJUIClasses :object
- Storage for the various classes that DataTables uses - jQuery UI suitable
- <static> oPagination :object
- Pagination plug-in methods - The style and controls of the pagination can significantly +impact on how the end user interacts with the data in your table, and DataTables allows +the addition of pagination controls by extending this object, which can then be enabled +through the sPaginationType initialisation parameter. Each pagination type that +is added is an object (the property name of which is what sPaginationType refers +to) that has two properties, both methods that are used by DataTables to update the +control's state. +
-
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {node} Container into which the pagination controls must be inserted +
- {function} Draw callback function - whenever the controls cause a page + change, this method must be called to redraw the table. +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - This function is called whenever the paging status of the table changes and is
+ typically used to update classes and/or text of the paging controls to reflex the new
+ status.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {function} Draw callback function - in case you need to redraw the table again + or attach new event listeners +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
- <static> oSort :object
- Sorting plug-in methods - Sorting in DataTables is based on the detected type of the +data column (you can add your own type detection functions, or override automatic +detection using sType). With this specific type given to the column, DataTables will +apply the required sort from the functions in the object. Each sort type must provide +two mandatory methods, one each for ascending and descending sorting, and can optionally +provide a pre-formatting method that will help speed up sorting by allowing DataTables +to pre-format the sort data only once (rather than every time the actual sort functions +are run). The two sorting functions are typical Javascript sort methods: +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data to compare to the second parameter +
- {*} Data to compare to the first parameter +
+ -
+ Function return:
+
-
+
- {int} Sorting match: <0 if first parameter should be sorted lower than + the second parameter, ===0 if the two parameters are equal and >0 if + the first parameter should be sorted height than the second parameter. +
-
+ Function input parameters:
+
- <static> oStdClasses :object
- Storage for the various classes that DataTables uses
- <static> sErrMode :string
- How should DataTables report an error. Can take the value 'alert' or 'throw'
- <static> sVersion :string
- Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional
+
+
+
+
+
+ Details
+Properties
+-
+
- <static> afnFiltering :array
Plug-in filtering functions - this method of filtering is complimentary to the default +type based filtering, and a lot more comprehensive as it allows you complete control +over the filtering logic. Each element in this array is a function (parameters +described below) that is called for every row in the table, and your logic decides if +it should be included in the filtered data set or not. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {array|object} Data for the row to be processed (same as the original format + that was passed in as the data source, or an array from a DOM data source +
- {int} Row index in aoData (DataTable.models.oSettings.aoData), which can + be useful to retrieve the TR element if you need DOM interaction. +
+ -
+ Function return:
+
-
+
- {boolean} Include the row in the filtered result set (true) or not (false) +
-
+
+
Extended from:
Example
+++// The following example shows custom filtering being applied to the fourth column (i.e. + // the aData[3] index) based on two input values from the end-user, matching the data in + // a certain range. + $.fn.dataTableExt.afnFiltering.push( + function( oSettings, aData, iDataIndex ) { + var iMin = document.getElementById('min').value * 1; + var iMax = document.getElementById('max').value * 1; + var iVersion = aData[3] == "-" ? 0 : aData[3]*1; + if ( iMin == "" && iMax == "" ) { + return true; + } + else if ( iMin == "" && iVersion < iMax ) { + return true; + } + else if ( iMin < iVersion && "" == iMax ) { + return true; + } + else if ( iMin < iVersion && iVersion < iMax ) { + return true; + } + return false; + } + );+-
+ Function input parameters:
+
- <static> afnSortData :array
Plug-in sorting functions - this method of sorting is complimentary to the default type +based sorting that DataTables does automatically, allowing much greater control over the +the data that is being used to sort a column. This is useful if you want to do sorting +based on live data (for example the contents of an 'input' element) rather than just the +static string that DataTables knows of. The way these plug-ins work is that you create +an array of the values you wish to be sorted for the column in question and then return +that array. Which pre-sorting function is run here depends on the sSortDataType parameter +that is used for the column (if any). This is the corollary of ofnSearch for sort +data. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {int} Target column index +
+ -
+ Function return:
+
-
+
- {array} Data for the column to be sorted upon +
-
+
- Deprecated
- Yes +
Extended from:
Example
+++// Updating the cached sorting information with user entered values in HTML input elements + jQuery.fn.dataTableExt.afnSortData['dom-text'] = function ( oSettings, iColumn ) + { + var aData = []; + $( 'td:eq('+iColumn+') input', oSettings.oApi._fnGetTrNodes(oSettings) ).each( function () { + aData.push( this.value ); + } ); + return aData; + }+-
+ Function input parameters:
+
- <static> aoFeatures :array
Feature plug-ins - This is an array of objects which describe the feature plug-ins that are +available to DataTables. These feature plug-ins are accessible through the sDom initialisation +option. As such, each feature plug-in must describe a function that is used to initialise +itself (fnInit), a character so the feature can be enabled by sDom (cFeature) and the name +of the feature (sFeature). Thus the objects attached to this method must provide: +
-
+
- {function} fnInit Initialisation of the plug-in
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
+ -
+ Function return:
+
-
+
- {node|null} The element which contains your feature. Note that the return + may also be void if your plug-in does not require to inject any DOM elements + into DataTables control (sDom) - for example this might be useful when + developing a plug-in which allows table control via keyboard entry. +
+ -
+ Function input parameters:
+
- {character} cFeature Character that will be matched in sDom - case sensitive +
- {string} sFeature Feature name +
-
+
+
Extended from:
Example
+++// How TableTools initialises itself. + $.fn.dataTableExt.aoFeatures.push( { + "fnInit": function( oSettings ) { + return new TableTools( { "oDTSettings": oSettings } ); + }, + "cFeature": "T", + "sFeature": "TableTools" + } );+- {function} fnInit Initialisation of the plug-in
+
- <static> aTypes :array
Type detection plug-in functions - DataTables utilises types to define how sorting and +filtering behave, and types can be either be defined by the developer (sType for the +column) or they can be automatically detected by the methods in this array. The functions +defined in the array are quite simple, taking a single parameter (the data to analyse) +and returning the type if it is a known type, or null otherwise. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be analysed +
+ -
+ Function return:
+
-
+
- {string|null} Data type detected, or null if unknown (and thus pass it + on to the other type detection functions. +
-
+
+
Extended from:
Example
+++// Currency type detection plug-in: + jQuery.fn.dataTableExt.aTypes.push( + function ( sData ) { + var sValidChars = "0123456789.-"; + var Char; + + // Check the numeric part + for ( i=1 ; i+ -
+ Function input parameters:
+
- <static> fnVersionCheck :function
Provide a common method for plug-ins to check the version of DataTables being used, +in order to ensure compatibility.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sVersion string Version string to check for, in the format "X.Y.Z". Note + that the formats "X" and "X.Y" are also acceptable. Returns:
true if this version of DataTables is greater or equal to the + required version, or false if this version of DataTales is not suitable
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + alert( oTable.fnVersionCheck( '1.9.0' ) ); + } );+- <static> iApiIndex :int
Index for what 'this' index API functions should use
- <static> oApi :object
Container for all private functions in DataTables so they can be exposed externally
- <static> ofnSearch :object
Pre-processing of filtering data plug-ins - When you assign the sType for a column +(or have it automatically detected for you by DataTables or a type detection plug-in), +you will typically be using this for custom sorting, but it can also be used to provide +custom filtering by allowing you to pre-processing the data and returning the data in +the format that should be filtered upon. This is done by adding functions this object +with a parameter name which matches the sType for that target column. This is the +corollary of afnSortData for filtering data. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be prepared for filtering +
+ -
+ Function return:
+
-
+
- {string|null} Formatted string that will be used for the filtering. +
-
+
- Deprecated
- Yes +
Extended from:
Example
+++$.fn.dataTableExt.ofnSearch['title-numeric'] = function ( sData ) { + return sData.replace(/\n/g," ").replace( /<.*?>/g, "" ); + }+-
+ Function input parameters:
+
- <static> oJUIClasses :object
Storage for the various classes that DataTables uses - jQuery UI suitable
- <static> oPagination :object
Pagination plug-in methods - The style and controls of the pagination can significantly +impact on how the end user interacts with the data in your table, and DataTables allows +the addition of pagination controls by extending this object, which can then be enabled +through the sPaginationType initialisation parameter. Each pagination type that +is added is an object (the property name of which is what sPaginationType refers +to) that has two properties, both methods that are used by DataTables to update the +control's state. +
-
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {node} Container into which the pagination controls must be inserted +
- {function} Draw callback function - whenever the controls cause a page + change, this method must be called to redraw the table. +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - This function is called whenever the paging status of the table changes and is
+ typically used to update classes and/or text of the paging controls to reflex the new
+ status.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {function} Draw callback function - in case you need to redraw the table again + or attach new event listeners +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+
+
Extended from:
Example
+++$.fn.dataTableExt.oPagination.four_button = { + "fnInit": function ( oSettings, nPaging, fnCallbackDraw ) { + nFirst = document.createElement( 'span' ); + nPrevious = document.createElement( 'span' ); + nNext = document.createElement( 'span' ); + nLast = document.createElement( 'span' ); + + nFirst.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sFirst ) ); + nPrevious.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sPrevious ) ); + nNext.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sNext ) ); + nLast.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sLast ) ); + + nFirst.className = "paginate_button first"; + nPrevious.className = "paginate_button previous"; + nNext.className="paginate_button next"; + nLast.className = "paginate_button last"; + + nPaging.appendChild( nFirst ); + nPaging.appendChild( nPrevious ); + nPaging.appendChild( nNext ); + nPaging.appendChild( nLast ); + + $(nFirst).click( function () { + oSettings.oApi._fnPageChange( oSettings, "first" ); + fnCallbackDraw( oSettings ); + } ); + + $(nPrevious).click( function() { + oSettings.oApi._fnPageChange( oSettings, "previous" ); + fnCallbackDraw( oSettings ); + } ); + + $(nNext).click( function() { + oSettings.oApi._fnPageChange( oSettings, "next" ); + fnCallbackDraw( oSettings ); + } ); + + $(nLast).click( function() { + oSettings.oApi._fnPageChange( oSettings, "last" ); + fnCallbackDraw( oSettings ); + } ); + + $(nFirst).bind( 'selectstart', function () { return false; } ); + $(nPrevious).bind( 'selectstart', function () { return false; } ); + $(nNext).bind( 'selectstart', function () { return false; } ); + $(nLast).bind( 'selectstart', function () { return false; } ); + }, + + "fnUpdate": function ( oSettings, fnCallbackDraw ) { + if ( !oSettings.aanFeatures.p ) { + return; + } + + // Loop over each instance of the pager + var an = oSettings.aanFeatures.p; + for ( var i=0, iLen=an.length ; i+ -
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
- <static> oSort :object
Sorting plug-in methods - Sorting in DataTables is based on the detected type of the +data column (you can add your own type detection functions, or override automatic +detection using sType). With this specific type given to the column, DataTables will +apply the required sort from the functions in the object. Each sort type must provide +two mandatory methods, one each for ascending and descending sorting, and can optionally +provide a pre-formatting method that will help speed up sorting by allowing DataTables +to pre-format the sort data only once (rather than every time the actual sort functions +are run). The two sorting functions are typical Javascript sort methods: +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data to compare to the second parameter +
- {*} Data to compare to the first parameter +
+ -
+ Function return:
+
-
+
- {int} Sorting match: <0 if first parameter should be sorted lower than + the second parameter, ===0 if the two parameters are equal and >0 if + the first parameter should be sorted height than the second parameter. +
-
+
+
Extended from:
Examples
+++ +// Case-sensitive string sorting, with no pre-formatting method + $.extend( $.fn.dataTableExt.oSort, { + "string-case-asc": function(x,y) { + return ((x < y) ? -1 : ((x > y) ? 1 : 0)); + }, + "string-case-desc": function(x,y) { + return ((x < y) ? 1 : ((x > y) ? -1 : 0)); + } + } ); + ++++// Case-insensitive string sorting, with pre-formatting + $.extend( $.fn.dataTableExt.oSort, { + "string-pre": function(x) { + return x.toLowerCase(); + }, + "string-asc": function(x,y) { + return ((x < y) ? -1 : ((x > y) ? 1 : 0)); + }, + "string-desc": function(x,y) { + return ((x < y) ? 1 : ((x > y) ? -1 : 0)); + } + } );+-
+ Function input parameters:
+
- <static> oStdClasses :object
Storage for the various classes that DataTables uses
- <static> sErrMode :string
How should DataTables report an error. Can take the value 'alert' or 'throw'
- <static> sVersion :string
Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional
+
+
+
+ Namespace: ext - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Class: DataTable
+ +
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.ext.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.ext.html
new file mode 100644
index 0000000..778206b
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.ext.html
@@ -0,0 +1,762 @@
+
+
+
+
+
+
+
+
+
+ - new DataTable(oInit)
DataTables is a plug-in for the jQuery Javascript library. It is a +highly flexible tool, based upon the foundations of progressive +enhancement, which will add advanced interaction controls to any +HTML table. For a full list of features please refer to +DataTables.net.
Note that the DataTable object is not a global variable but is +aliased to jQuery.fn.DataTable and jQuery.fn.dataTable through which +it may be accessed.+Constructor
-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +oInit object Optional {} Configuration object for DataTables. Options + are defined by DataTable.defaults Examples:
+++ +// Basic initialisation + $(document).ready( function { + $('#example').dataTable(); + } ); + ++++// Initialisation with configuration options - in this case, disable + // pagination and sorting. + $(document).ready( function { + $('#example').dataTable( { + "bPaginate": false, + "bSort": false + } ); + } );+
Requires
+-
+
- module:jQuery +
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- defaults
- Initialisation options that can be given to DataTables at initialisation +time.
- ext
- Extension object for DataTables that is used to provide all extension options.
Note that the DataTable.ext object is available through +jQuery.fn.dataTable.ext where it may be accessed and manipulated. It is +also aliased to jQuery.fn.dataTableExt for historic reasons. - models
- Object models container, for the various models that DataTables has available +to it. These models define the objects that are used to hold the active state +and configuration of the table.
- oApi
- Reference to internal functions for use by plug-in developers. Note that these +methods are references to internal functions and are considered to be private. +If you use these methods, be aware that they are liable to change between versions +(check the upgrade notes). +
Properties
+ +-
+
- <static> version :string
- Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional +
Methods
+ +-
+
- $(sSelector, oOpts) → {object}
- Perform a jQuery selector action on the table's TR elements (from the tbody) and +return the resulting jQuery object.
- _(sSelector, oOpts) → {array}
- Almost identical to $ in operation, but in this case returns the data for the matched +rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes +rather than any decendents, so the data can be obtained for the row/cell. If matching +rows are found, the data returned is the original data array/object that was used to +create the row (or a generated array if from a DOM source). + +This method is often useful incombination with $ where both functions are given the +same parameters and the array indexes will match identically.
- fnAddData(mData, bRedraw) → {array}
- Add a single new row or multiple rows of data to the table. Please note +that this is suitable for client-side processing only - if you are using +server-side processing (i.e. "bServerSide": true), then to add data, you +must add it to the data source, i.e. the server-side, through an Ajax call.
- fnAdjustColumnSizing(bRedraw)
- This function will make DataTables recalculate the column sizes, based on the data +contained in the table and the sizes applied to the columns (in the DOM, CSS or +through the sWidth parameter). This can be useful when the width of the table's +parent element changes (for example a window resize).
- fnClearTable(bRedraw)
- Quickly and simply clear a table
- fnClose(nTr) → {int}
- The exact opposite of 'opening' a row, this function will close any rows which +are currently 'open'.
- fnDeleteRow(mTarget, fnCallBack, bRedraw) → {array}
- Remove a row for the table
- fnDestroy(bRemove)
- Restore the table to it's original state in the DOM by removing all of DataTables +enhancements, alterations to the DOM structure of the table and event listeners.
- fnDraw(bComplete)
- Redraw the table
- fnFilter(sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive)
- Filter the input based on data
- fnGetData(mRow, iCol) → {array|object|string}
- Get the data for the whole table, an individual row or an individual cell based on the +provided parameters.
- fnGetNodes(iRow) → {array|node}
- Get an array of the TR nodes that are used in the table's body. Note that you will +typically want to use the '$' API method in preference to this as it is more +flexible.
- fnGetPosition(nNode) → {int}
- Get the array indexes of a particular cell from it's DOM element +and column index including hidden columns
- <static> fnIsDataTable(nTable) → {boolean}
- Check if a TABLE node is a DataTable table already or not.
- fnIsOpen(nTr) → {boolean}
- Check to see if a row is 'open' or not.
- fnOpen(nTr, mHtml, sClass) → {node}
- This function will place a new row directly after a row which is currently +on display on the page, with the HTML contents that is passed into the +function. This can be used, for example, to ask for confirmation that a +particular record should be deleted.
- fnPageChange(mAction, bRedraw)
- Change the pagination - provides the internal logic for pagination in a simple API +function. With this function you can have a DataTables table go to the next, +previous, first or last pages.
- fnSetColumnVis(iCol, bShow, bRedraw)
- Show a particular column
- fnSettings() → {object}
- Get the settings for a particular table for external manipulation
- fnSort(iCol)
- Sort the table by a particular column
- fnSortListener(nNode, iColumn, fnCallback)
- Attach a sort listener to an element for a given column
- <static> fnTables(bVisible) → {array}
- Get all DataTable tables that have been initialised - optionally you can select to +get only currently visible tables.
- fnUpdate(mData, mRow, iColumn, bRedraw, bAction) → {int}
- Update a table cell or row - this method will accept either a single value to +update the cell with, an array of values with one element for each column or +an object in the same format as the original data source. The function is +self-referencing in order to make the multi column updates easier.
- fnVersionCheck(sVersion) → {boolean}
- Provide a common method for plug-ins to check the version of DataTables being used, in order +to ensure compatibility.
- <static> fnVersionCheck(sVersion) → {boolean}
- Provide a common method for plug-ins to check the version of DataTables being used, in order +to ensure compatibility. +
Events
+-
+
- destroy
- Destroy event, fired when the DataTable is destroyed by calling fnDestroy or passing +the bDestroy:true parameter in the initialisation object. This can be used to remove +bound events, added DOM nodes, etc.
- draw
- Draw event, fired whenever the table is redrawn on the page, at the same point as +fnDrawCallback. This may be useful for binding events or performing calculations when +the table is altered at all.
- filter
- Filter event, fired when the filtering applied to the table (using the build in global +global filter, or column filters) is altered.
- init
- DataTables initialisation complete event, fired when the table is fully drawn, +including Ajax data loaded, if Ajax data is required.
- page
- Page change event, fired when the paging of the table is altered.
- processing
- Processing event, fired when DataTables is doing some kind of processing (be it, +sort, filter or anything else). Can be used to indicate to the end user that +there is something happening, or that something has finished.
- sort
- Sort event, fired when the sorting applied to the table is altered.
- stateLoaded
- State loaded event, fired when state has been loaded from stored data and the settings +object has been modified by the loaded data.
- stateLoadParams
- State load event, fired when the table is loading state from the stored data, but +prior to the settings object being modified by the saved state - allowing modification +of the saved state is required or loading of state for a plug-in.
- stateSaveParams
- State save event, fired when the table has changed state a new state save is required. +This method allows modification of the state saving object prior to actually doing the +save, including addition or other state properties (for plug-ins) or modification +of a DataTables core property.
- xhr
- Ajax (XHR) event, fired whenever an Ajax request is completed from a request to +made to the server for new data (note that this trigger is called in fnServerData, +if you override fnServerData and which to use this event, you need to trigger it in +you success function). + +
+
+
+
+
+ Details
+Properties
+-
+
- <static> version :string
Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional
-
+
+
+
Methods
+-
+
- $(sSelector, oOpts) → {object}
Perform a jQuery selector action on the table's TR elements (from the tbody) and +return the resulting jQuery object.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sSelector string | node | jQuery jQuery selector or node collection to act on 2oOpts object Optional Optional parameters for modifying the rows to be included oOpts.filter string <optional> none Select TR elements that meet the current filter + criterion ("applied") or all TR elements (i.e. no filter). oOpts.order string <optional> current Order of the TR elements in the processed array. + Can be either 'current', whereby the current sorting of the table is used, or + 'original' whereby the original order the data was read into the table is used. oOpts.page string <optional> all Limit the selection to the currently displayed page + ("current") or not ("all"). If 'current' is given, then order is assumed to be + 'current' and filter is 'applied', regardless of what they might be given as. Returns:
jQuery object, filtered by the given selector.
Examples:
+++ +$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Highlight every second row + oTable.$('tr:odd').css('backgroundColor', 'blue'); + } ); + ++++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Filter to rows with 'Webkit' in them, add a background colour and then + // remove the filter, thus highlighting the 'Webkit' rows only. + oTable.fnFilter('Webkit'); + oTable.$('tr', {"filter": "applied"}).css('backgroundColor', 'blue'); + oTable.fnFilter(''); + } );+- _(sSelector, oOpts) → {array}
Almost identical to $ in operation, but in this case returns the data for the matched +rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes +rather than any decendents, so the data can be obtained for the row/cell. If matching +rows are found, the data returned is the original data array/object that was used to +create the row (or a generated array if from a DOM source).
This method is often useful incombination with $ where both functions are given the +same parameters and the array indexes will match identically.+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sSelector string | node | jQuery jQuery selector or node collection to act on 2oOpts object Optional Optional parameters for modifying the rows to be included oOpts.filter string <optional> none Select elements that meet the current filter + criterion ("applied") or all elements (i.e. no filter). oOpts.order string <optional> current Order of the data in the processed array. + Can be either 'current', whereby the current sorting of the table is used, or + 'original' whereby the original order the data was read into the table is used. oOpts.page string <optional> all Limit the selection to the currently displayed page + ("current") or not ("all"). If 'current' is given, then order is assumed to be + 'current' and filter is 'applied', regardless of what they might be given as. Returns:
Data for the matched elements. If any elements, as a result of the + selector, were not TR, TD or TH elements in the DataTable, they will have a null + entry in the array.
Examples:
+++ +$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Get the data from the first row in the table + var data = oTable._('tr:first'); + + // Do something useful with the data + alert( "First cell is: "+data[0] ); + } ); + ++++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Filter to 'Webkit' and get all data for + oTable.fnFilter('Webkit'); + var data = oTable._('tr', {"filter": "applied"}); + + // Do something with the data + alert( data.length+" rows matched the filter" ); + } );+- fnAddData(mData, bRedraw) → {array}
Add a single new row or multiple rows of data to the table. Please note +that this is suitable for client-side processing only - if you are using +server-side processing (i.e. "bServerSide": true), then to add data, you +must add it to the data source, i.e. the server-side, through an Ajax call.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1mData array | object The data to be added to the table. This can be: + -
+
- 1D array of data - add a single row with the data provided +
- 2D array of arrays - add multiple rows in a single call +
- object - data object when using mDataProp +
- array of objects - multiple data objects when using mDataProp +
bRedraw bool Optional true redraw the table or not Returns:
An array of integers, representing the list of indexes in + aoData (DataTable.models.oSettings) that have been added to + the table.
Example:
+++// Global var for counter + var giCount = 2; + + $(document).ready(function() { + $('#example').dataTable(); + } ); + + function fnClickAddRow() { + $('#example').dataTable().fnAddData( [ + giCount+".1", + giCount+".2", + giCount+".3", + giCount+".4" ] + ); + + giCount++; + }+- fnAdjustColumnSizing(bRedraw)
This function will make DataTables recalculate the column sizes, based on the data +contained in the table and the sizes applied to the columns (in the DOM, CSS or +through the sWidth parameter). This can be useful when the width of the table's +parent element changes (for example a window resize).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +bRedraw boolean Optional true Redraw the table or not, you will typically want to Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable( { + "sScrollY": "200px", + "bPaginate": false + } ); + + $(window).bind('resize', function () { + oTable.fnAdjustColumnSizing(); + } ); + } );+- fnClearTable(bRedraw)
Quickly and simply clear a table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +bRedraw bool Optional true redraw the table or not Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...) + oTable.fnClearTable(); + } );+- fnClose(nTr) → {int}
The exact opposite of 'opening' a row, this function will close any rows which +are currently 'open'.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +nTr node the table row to 'close' Returns:
0 on success, or 1 if failed (can't find the row)
Example:
+++$(document).ready(function() { + var oTable; + + // 'open' an information row when a row is clicked on + $('#example tbody tr').click( function () { + if ( oTable.fnIsOpen(this) ) { + oTable.fnClose( this ); + } else { + oTable.fnOpen( this, "Temporary row opened", "info_row" ); + } + } ); + + oTable = $('#example').dataTable(); + } );+- fnDeleteRow(mTarget, fnCallBack, bRedraw) → {array}
Remove a row for the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1mTarget mixed The index of the row from aoData to be deleted, or + the TR element you want to delete 2fnCallBack function | null Optional Callback function bRedraw bool Optional true Redraw the table or not Returns:
The row that was deleted
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Immediately remove the first row + oTable.fnDeleteRow( 0 ); + } );+- fnDestroy(bRemove)
Restore the table to it's original state in the DOM by removing all of DataTables +enhancements, alterations to the DOM structure of the table and event listeners.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +bRemove boolean Optional false Completely remove the table from the DOM Example:
+++$(document).ready(function() { + // This example is fairly pointless in reality, but shows how fnDestroy can be used + var oTable = $('#example').dataTable(); + oTable.fnDestroy(); + } );+- fnDraw(bComplete)
Redraw the table
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +bComplete bool Optional true Re-filter and resort (if enabled) the table before the draw. Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Re-draw the table - you wouldn't want to do it here, but it's an example :-) + oTable.fnDraw(); + } );+- fnFilter(sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive)
Filter the input based on data
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1sInput string String to filter the table on 2iColumn int | null Optional Column to limit filtering to 3bRegex bool Optional false Treat as regular expression or not 4bSmart bool Optional true Perform smart filtering or not 5bShowGlobal bool Optional true Show the input global filter in it's input box(es) bCaseInsensitive bool Optional true Do case-insensitive matching (true) or not (false) Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Sometime later - filter... + oTable.fnFilter( 'test string' ); + } );+- fnGetData(mRow, iCol) → {array|object|string}
Get the data for the whole table, an individual row or an individual cell based on the +provided parameters.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1mRow int | node Optional A TR row node, TD/TH cell node or an integer. If given as + a TR node then the data source for the whole row will be returned. If given as a + TD/TH cell node then iCol will be automatically calculated and the data for the + cell returned. If given as an integer, then this is treated as the aoData internal + data index for the row (see fnGetPosition) and the data for that row used. iCol int Optional Optional column index that you want the data of. Returns:
If mRow is undefined, then the data for all rows is + returned. If mRow is defined, just data for that row, and is iCol is + defined, only data for the designated cell is returned.
Examples:
+++ +// Row data + $(document).ready(function() { + oTable = $('#example').dataTable(); + + oTable.$('tr').click( function () { + var data = oTable.fnGetData( this ); + // ... do something with the array / object of data for the row + } ); + } ); + ++++// Individual cell data + $(document).ready(function() { + oTable = $('#example').dataTable(); + + oTable.$('td').click( function () { + var sData = oTable.fnGetData( this ); + alert( 'The cell clicked on had the value of '+sData ); + } ); + } );+- fnGetNodes(iRow) → {array|node}
Get an array of the TR nodes that are used in the table's body. Note that you will +typically want to use the '$' API method in preference to this as it is more +flexible.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +iRow int Optional Optional row index for the TR element you want Returns:
If iRow is undefined, returns an array of all TR elements + in the table's body, or iRow is defined, just the TR element requested.
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Get the nodes from the table + var nNodes = oTable.fnGetNodes( ); + } );+- fnGetPosition(nNode) → {int}
Get the array indexes of a particular cell from it's DOM element +and column index including hidden columns
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +nNode node this can either be a TR, TD or TH in the table's body Returns:
If nNode is given as a TR, then a single index is returned, or + if given as a cell, an array of [row index, column index (visible)] is given.
Example:
+++$(document).ready(function() { + $('#example tbody td').click( function () { + // Get the position of the current data from the node + var aPos = oTable.fnGetPosition( this ); + + // Get the data array for this row + var aData = oTable.fnGetData( aPos[0] ); + + // Update the data array and return the value + aData[ aPos[1] ] = 'clicked'; + this.innerHTML = 'clicked'; + } ); + + // Init DataTables + oTable = $('#example').dataTable(); + } );+- <static> fnIsDataTable(nTable) → {boolean}
Check if a TABLE node is a DataTable table already or not.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +nTable node The TABLE node to check if it is a DataTable or not (note that other + node types can be passed in, but will always return false). Returns:
true the table given is a DataTable, or false otherwise
Example:
+++var ex = document.getElementById('example'); + if ( ! $.fn.DataTable.fnIsDataTable( ex ) ) { + $(ex).dataTable(); + }+- fnIsOpen(nTr) → {boolean}
Check to see if a row is 'open' or not.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +nTr node the table row to check Returns:
true if the row is currently open, false otherwise
Example:
+++$(document).ready(function() { + var oTable; + + // 'open' an information row when a row is clicked on + $('#example tbody tr').click( function () { + if ( oTable.fnIsOpen(this) ) { + oTable.fnClose( this ); + } else { + oTable.fnOpen( this, "Temporary row opened", "info_row" ); + } + } ); + + oTable = $('#example').dataTable(); + } );+- fnOpen(nTr, mHtml, sClass) → {node}
This function will place a new row directly after a row which is currently +on display on the page, with the HTML contents that is passed into the +function. This can be used, for example, to ask for confirmation that a +particular record should be deleted.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nTr node The table row to 'open' 2mHtml string | node | jQuery The HTML to put into the row sClass string Class to give the new TD cell Returns:
The row opened. Note that if the table row passed in as the + first parameter, is not found in the table, this method will silently + return.
Example:
+++$(document).ready(function() { + var oTable; + + // 'open' an information row when a row is clicked on + $('#example tbody tr').click( function () { + if ( oTable.fnIsOpen(this) ) { + oTable.fnClose( this ); + } else { + oTable.fnOpen( this, "Temporary row opened", "info_row" ); + } + } ); + + oTable = $('#example').dataTable(); + } );+- fnPageChange(mAction, bRedraw)
Change the pagination - provides the internal logic for pagination in a simple API +function. With this function you can have a DataTables table go to the next, +previous, first or last pages.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1mAction string | int Paging action to take: "first", "previous", "next" or "last" + or page number to jump to (integer), note that page 0 is the first page. bRedraw bool Optional true Redraw the table or not Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + oTable.fnPageChange( 'next' ); + } );+- fnSetColumnVis(iCol, bShow, bRedraw)
Show a particular column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1iCol int The column whose display should be changed 2bShow bool Show (true) or hide (false) the column bRedraw bool Optional true Redraw the table or not Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Hide the second column after initialisation + oTable.fnSetColumnVis( 1, false ); + } );+- fnSettings() → {object}
Get the settings for a particular table for external manipulation
+-
+
+
Returns:
DataTables settings object. See + DataTable.models.oSettings
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + var oSettings = oTable.fnSettings(); + + // Show an example parameter from the settings + alert( oSettings._iDisplayStart ); + } );+- fnSort(iCol)
Sort the table by a particular column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +iCol int the data index to sort on. Note that this will not match the + 'display index' if you have hidden data entries Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Sort immediately with columns 0 and 1 + oTable.fnSort( [ [0,'asc'], [1,'asc'] ] ); + } );+- fnSortListener(nNode, iColumn, fnCallback)
Attach a sort listener to an element for a given column
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nNode node the element to attach the sort listener to 2iColumn int the column that a click on this node will sort on fnCallback function Optional callback function when sort is run Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + + // Sort on column 1, when 'sorter' is clicked on + oTable.fnSortListener( document.getElementById('sorter'), 1 ); + } );+- <static> fnTables(bVisible) → {array}
Get all DataTable tables that have been initialised - optionally you can select to +get only currently visible tables.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +bVisible boolean Optional false Flag to indicate if you want all (default) or + visible tables only. Returns:
Array of TABLE nodes (not DataTable instances) which are DataTables
Example:
+++var table = $.fn.dataTable.fnTables(true); + if ( table.length > 0 ) { + $(table).dataTable().fnAdjustColumnSizing(); + }+- fnUpdate(mData, mRow, iColumn, bRedraw, bAction) → {int}
Update a table cell or row - this method will accept either a single value to +update the cell with, an array of values with one element for each column or +an object in the same format as the original data source. The function is +self-referencing in order to make the multi column updates easier.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1mData object | array | string Data to update the cell/row with 2mRow node | int TR element you want to update or the aoData index 3iColumn int Optional The column to update (not used of mData is an array or object) 4bRedraw bool Optional true Redraw the table or not bAction bool Optional true Perform predraw actions or not Returns:
0 on success, 1 on error
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell + oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], 1, 0 ); // Row + } );+- fnVersionCheck(sVersion) → {boolean}
Provide a common method for plug-ins to check the version of DataTables being used, in order +to ensure compatibility.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sVersion string Version string to check for, in the format "X.Y.Z". Note that the + formats "X" and "X.Y" are also acceptable. Returns:
true if this version of DataTables is greater or equal to the required + version, or false if this version of DataTales is not suitable
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + alert( oTable.fnVersionCheck( '1.9.0' ) ); + } );+- <static> fnVersionCheck(sVersion) → {boolean}
Provide a common method for plug-ins to check the version of DataTables being used, in order +to ensure compatibility.
+ +-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sVersion string Version string to check for, in the format "X.Y.Z". Note that the + formats "X" and "X.Y" are also acceptable. Returns:
true if this version of DataTables is greater or equal to the required + version, or false if this version of DataTales is not suitable
Example:
+++alert( $.fn.dataTable.fnVersionCheck( '1.9.0' ) );
+
+
Events
+-
+
- destroy
Destroy event, fired when the DataTable is destroyed by calling fnDestroy or passing +the bDestroy:true parameter in the initialisation object. This can be used to remove +bound events, added DOM nodes, etc.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings - draw
Draw event, fired whenever the table is redrawn on the page, at the same point as +fnDrawCallback. This may be useful for binding events or performing calculations when +the table is altered at all.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings - filter
Filter event, fired when the filtering applied to the table (using the build in global +global filter, or column filters) is altered.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings - init
DataTables initialisation complete event, fired when the table is fully drawn, +including Ajax data loaded, if Ajax data is required.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object 2oSettings object DataTables settings object json object The JSON object request from the server - only + present if client-side Ajax sourced data is used - page
Page change event, fired when the paging of the table is altered.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings - processing
Processing event, fired when DataTables is doing some kind of processing (be it, +sort, filter or anything else). Can be used to indicate to the end user that +there is something happening, or that something has finished.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object 2oSettings object DataTables settings object bShow boolean Flag for if DataTables is doing processing or not - sort
Sort event, fired when the sorting applied to the table is altered.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings - stateLoaded
State loaded event, fired when state has been loaded from stored data and the settings +object has been modified by the loaded data.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object 2oSettings object DataTables settings object json object The saved state information - stateLoadParams
State load event, fired when the table is loading state from the stored data, but +prior to the settings object being modified by the saved state - allowing modification +of the saved state is required or loading of state for a plug-in.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object 2oSettings object DataTables settings object json object The saved state information - stateSaveParams
State save event, fired when the table has changed state a new state save is required. +This method allows modification of the state saving object prior to actually doing the +save, including addition or other state properties (for plug-ins) or modification +of a DataTables core property.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object 2oSettings object DataTables settings object json object The state information to be saved - xhr
Ajax (XHR) event, fired whenever an Ajax request is completed from a request to +made to the server for new data (note that this trigger is called in fnServerData, +if you override fnServerData and which to use this event, you need to trigger it in +you success function).
+ +-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1e event jQuery event object o object DataTables settings object DataTable.models.oSettings
+
+
+
+
+
+
+
+ Namespace: models - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.html
new file mode 100644
index 0000000..4e9d44e
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.html
@@ -0,0 +1,108 @@
+
+
+
+
+
+
+
+
+
+ DataTables extension options and plug-ins. This namespace acts as a collection "area"
+for plug-ins that can be used to extend the default DataTables behaviour - indeed many
+of the build in methods use this method to provide their own capabilities (sorting methods
+for example).
Note that this namespace is aliased to jQuery.fn.dataTableExt so it can be readily accessed
+and modified by plug-ins.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> afnFiltering :array
- Plug-in filtering functions - this method of filtering is complimentary to the default
+type based filtering, and a lot more comprehensive as it allows you complete control
+over the filtering logic. Each element in this array is a function (parameters
+described below) that is called for every row in the table, and your logic decides if
+it should be included in the filtered data set or not.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {array|object} Data for the row to be processed (same as the original format + that was passed in as the data source, or an array from a DOM data source +
- {int} Row index in aoData (DataTable.models.oSettings.aoData), which can + be useful to retrieve the TR element if you need DOM interaction. +
+ -
+ Function return:
+
-
+
- {boolean} Include the row in the filtered result set (true) or not (false) +
-
+ Function input parameters:
+
- <static> afnSortData :array
- Plug-in sorting functions - this method of sorting is complimentary to the default type
+based sorting that DataTables does automatically, allowing much greater control over the
+the data that is being used to sort a column. This is useful if you want to do sorting
+based on live data (for example the contents of an 'input' element) rather than just the
+static string that DataTables knows of. The way these plug-ins work is that you create
+an array of the values you wish to be sorted for the column in question and then return
+that array. Which pre-sorting function is run here depends on the sSortDataType parameter
+that is used for the column (if any). This is the corollary of ofnSearch for sort
+data.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {int} Target column index +
+ -
+ Function return:
+
-
+
- {array} Data for the column to be sorted upon +
-
+ Function input parameters:
+
- <static> aoFeatures :array
- Feature plug-ins - This is an array of objects which describe the feature plug-ins that are
+available to DataTables. These feature plug-ins are accessible through the sDom initialisation
+option. As such, each feature plug-in must describe a function that is used to initialise
+itself (fnInit), a character so the feature can be enabled by sDom (cFeature) and the name
+of the feature (sFeature). Thus the objects attached to this method must provide:
+
-
+
- {function} fnInit Initialisation of the plug-in
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
+ -
+ Function return:
+
-
+
- {node|null} The element which contains your feature. Note that the return + may also be void if your plug-in does not require to inject any DOM elements + into DataTables control (sDom) - for example this might be useful when + developing a plug-in which allows table control via keyboard entry. +
+ -
+ Function input parameters:
+
- {character} cFeature Character that will be matched in sDom - case sensitive +
- {string} sFeature Feature name +
- {function} fnInit Initialisation of the plug-in
+
- <static> aTypes :array
- Type detection plug-in functions - DataTables utilises types to define how sorting and
+filtering behave, and types can be either be defined by the developer (sType for the
+column) or they can be automatically detected by the methods in this array. The functions
+defined in the array are quite simple, taking a single parameter (the data to analyse)
+and returning the type if it is a known type, or null otherwise.
+
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be analysed +
+ -
+ Function return:
+
-
+
- {string|null} Data type detected, or null if unknown (and thus pass it + on to the other type detection functions. +
-
+ Function input parameters:
+
- <static> fnVersionCheck :function
- Provide a common method for plug-ins to check the version of DataTables being used, +in order to ensure compatibility.
- <static> iApiIndex :int
- Index for what 'this' index API functions should use
- <static> oApi :object
- Container for all private functions in DataTables so they can be exposed externally
- <static> ofnSearch :object
- Pre-processing of filtering data plug-ins - When you assign the sType for a column
+(or have it automatically detected for you by DataTables or a type detection plug-in),
+you will typically be using this for custom sorting, but it can also be used to provide
+custom filtering by allowing you to pre-processing the data and returning the data in
+the format that should be filtered upon. This is done by adding functions this object
+with a parameter name which matches the sType for that target column. This is the
+corollary of afnSortData for filtering data.
+
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be prepared for filtering +
+ -
+ Function return:
+
-
+
- {string|null} Formatted string that will be used for the filtering. +
-
+ Function input parameters:
+
- <static> oJUIClasses :object
- Storage for the various classes that DataTables uses - jQuery UI suitable
- <static> oPagination :object
- Pagination plug-in methods - The style and controls of the pagination can significantly
+impact on how the end user interacts with the data in your table, and DataTables allows
+the addition of pagination controls by extending this object, which can then be enabled
+through the sPaginationType initialisation parameter. Each pagination type that
+is added is an object (the property name of which is what sPaginationType refers
+to) that has two properties, both methods that are used by DataTables to update the
+control's state.
+
-
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {node} Container into which the pagination controls must be inserted +
- {function} Draw callback function - whenever the controls cause a page + change, this method must be called to redraw the table. +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - This function is called whenever the paging status of the table changes and is
+ typically used to update classes and/or text of the paging controls to reflex the new
+ status.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {function} Draw callback function - in case you need to redraw the table again + or attach new event listeners +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
- <static> oSort :object
- Sorting plug-in methods - Sorting in DataTables is based on the detected type of the
+data column (you can add your own type detection functions, or override automatic
+detection using sType). With this specific type given to the column, DataTables will
+apply the required sort from the functions in the object. Each sort type must provide
+two mandatory methods, one each for ascending and descending sorting, and can optionally
+provide a pre-formatting method that will help speed up sorting by allowing DataTables
+to pre-format the sort data only once (rather than every time the actual sort functions
+are run). The two sorting functions are typical Javascript sort methods:
+
-
+
-
+ Function input parameters:
+
-
+
- {*} Data to compare to the second parameter +
- {*} Data to compare to the first parameter +
+ -
+ Function return:
+
-
+
- {int} Sorting match: <0 if first parameter should be sorted lower than + the second parameter, ===0 if the two parameters are equal and >0 if + the first parameter should be sorted height than the second parameter. +
-
+ Function input parameters:
+
- <static> oStdClasses :object
- Storage for the various classes that DataTables uses
- <static> sErrMode :string
- How should DataTables report an error. Can take the value 'alert' or 'throw'
- <static> sVersion :string
- Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional +
+
+
+
+
+ Details
+Properties
+-
+
- <static> afnFiltering :array
Plug-in filtering functions - this method of filtering is complimentary to the default +type based filtering, and a lot more comprehensive as it allows you complete control +over the filtering logic. Each element in this array is a function (parameters +described below) that is called for every row in the table, and your logic decides if +it should be included in the filtered data set or not. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {array|object} Data for the row to be processed (same as the original format + that was passed in as the data source, or an array from a DOM data source +
- {int} Row index in aoData (DataTable.models.oSettings.aoData), which can + be useful to retrieve the TR element if you need DOM interaction. +
+ -
+ Function return:
+
-
+
- {boolean} Include the row in the filtered result set (true) or not (false) +
-
+
+
Example
+++// The following example shows custom filtering being applied to the fourth column (i.e. + // the aData[3] index) based on two input values from the end-user, matching the data in + // a certain range. + $.fn.dataTableExt.afnFiltering.push( + function( oSettings, aData, iDataIndex ) { + var iMin = document.getElementById('min').value * 1; + var iMax = document.getElementById('max').value * 1; + var iVersion = aData[3] == "-" ? 0 : aData[3]*1; + if ( iMin == "" && iMax == "" ) { + return true; + } + else if ( iMin == "" && iVersion < iMax ) { + return true; + } + else if ( iMin < iVersion && "" == iMax ) { + return true; + } + else if ( iMin < iVersion && iVersion < iMax ) { + return true; + } + return false; + } + );+-
+ Function input parameters:
+
- <static> afnSortData :array
Plug-in sorting functions - this method of sorting is complimentary to the default type +based sorting that DataTables does automatically, allowing much greater control over the +the data that is being used to sort a column. This is useful if you want to do sorting +based on live data (for example the contents of an 'input' element) rather than just the +static string that DataTables knows of. The way these plug-ins work is that you create +an array of the values you wish to be sorted for the column in question and then return +that array. Which pre-sorting function is run here depends on the sSortDataType parameter +that is used for the column (if any). This is the corollary of ofnSearch for sort +data. +
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {int} Target column index +
+ -
+ Function return:
+
-
+
- {array} Data for the column to be sorted upon +
-
+
- Deprecated
- Yes +
Example
+++// Updating the cached sorting information with user entered values in HTML input elements + jQuery.fn.dataTableExt.afnSortData['dom-text'] = function ( oSettings, iColumn ) + { + var aData = []; + $( 'td:eq('+iColumn+') input', oSettings.oApi._fnGetTrNodes(oSettings) ).each( function () { + aData.push( this.value ); + } ); + return aData; + }+-
+ Function input parameters:
+
- <static> aoFeatures :array
Feature plug-ins - This is an array of objects which describe the feature plug-ins that are +available to DataTables. These feature plug-ins are accessible through the sDom initialisation +option. As such, each feature plug-in must describe a function that is used to initialise +itself (fnInit), a character so the feature can be enabled by sDom (cFeature) and the name +of the feature (sFeature). Thus the objects attached to this method must provide: +
-
+
- {function} fnInit Initialisation of the plug-in
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
+ -
+ Function return:
+
-
+
- {node|null} The element which contains your feature. Note that the return + may also be void if your plug-in does not require to inject any DOM elements + into DataTables control (sDom) - for example this might be useful when + developing a plug-in which allows table control via keyboard entry. +
+ -
+ Function input parameters:
+
- {character} cFeature Character that will be matched in sDom - case sensitive +
- {string} sFeature Feature name +
-
+
+
Example
+++// How TableTools initialises itself. + $.fn.dataTableExt.aoFeatures.push( { + "fnInit": function( oSettings ) { + return new TableTools( { "oDTSettings": oSettings } ); + }, + "cFeature": "T", + "sFeature": "TableTools" + } );+- {function} fnInit Initialisation of the plug-in
+
- <static> aTypes :array
Type detection plug-in functions - DataTables utilises types to define how sorting and +filtering behave, and types can be either be defined by the developer (sType for the +column) or they can be automatically detected by the methods in this array. The functions +defined in the array are quite simple, taking a single parameter (the data to analyse) +and returning the type if it is a known type, or null otherwise. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be analysed +
+ -
+ Function return:
+
-
+
- {string|null} Data type detected, or null if unknown (and thus pass it + on to the other type detection functions. +
-
+
+
Example
+++// Currency type detection plug-in: + jQuery.fn.dataTableExt.aTypes.push( + function ( sData ) { + var sValidChars = "0123456789.-"; + var Char; + + // Check the numeric part + for ( i=1 ; i+ -
+ Function input parameters:
+
- <static> fnVersionCheck :function
Provide a common method for plug-ins to check the version of DataTables being used, +in order to ensure compatibility.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +sVersion string Version string to check for, in the format "X.Y.Z". Note + that the formats "X" and "X.Y" are also acceptable. Returns:
true if this version of DataTables is greater or equal to the + required version, or false if this version of DataTales is not suitable
Example:
+++$(document).ready(function() { + var oTable = $('#example').dataTable(); + alert( oTable.fnVersionCheck( '1.9.0' ) ); + } );+- <static> iApiIndex :int
Index for what 'this' index API functions should use
-
+
+
- <static> oApi :object
Container for all private functions in DataTables so they can be exposed externally
-
+
+
- <static> ofnSearch :object
Pre-processing of filtering data plug-ins - When you assign the sType for a column +(or have it automatically detected for you by DataTables or a type detection plug-in), +you will typically be using this for custom sorting, but it can also be used to provide +custom filtering by allowing you to pre-processing the data and returning the data in +the format that should be filtered upon. This is done by adding functions this object +with a parameter name which matches the sType for that target column. This is the +corollary of afnSortData for filtering data. +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data from the column cell to be prepared for filtering +
+ -
+ Function return:
+
-
+
- {string|null} Formatted string that will be used for the filtering. +
-
+
- Deprecated
- Yes +
Example
+++$.fn.dataTableExt.ofnSearch['title-numeric'] = function ( sData ) { + return sData.replace(/\n/g," ").replace( /<.*?>/g, "" ); + }+-
+ Function input parameters:
+
- <static> oJUIClasses :object
Storage for the various classes that DataTables uses - jQuery UI suitable
-
+
+
- <static> oPagination :object
Pagination plug-in methods - The style and controls of the pagination can significantly +impact on how the end user interacts with the data in your table, and DataTables allows +the addition of pagination controls by extending this object, which can then be enabled +through the sPaginationType initialisation parameter. Each pagination type that +is added is an object (the property name of which is what sPaginationType refers +to) that has two properties, both methods that are used by DataTables to update the +control's state. +
-
+
-
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {node} Container into which the pagination controls must be inserted +
- {function} Draw callback function - whenever the controls cause a page + change, this method must be called to redraw the table. +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+ fnInit - This function is called whenever the paging status of the table changes and is
+ typically used to update classes and/or text of the paging controls to reflex the new
+ status.
+
-
+
-
+ Function input parameters:
+
-
+
- {object} DataTables settings object: see DataTable.models.oSettings. +
- {function} Draw callback function - in case you need to redraw the table again + or attach new event listeners +
+ -
+ Function return:
+
-
+
- No return required +
-
+ Function input parameters:
+
-
+
+
Example
+++$.fn.dataTableExt.oPagination.four_button = { + "fnInit": function ( oSettings, nPaging, fnCallbackDraw ) { + nFirst = document.createElement( 'span' ); + nPrevious = document.createElement( 'span' ); + nNext = document.createElement( 'span' ); + nLast = document.createElement( 'span' ); + + nFirst.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sFirst ) ); + nPrevious.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sPrevious ) ); + nNext.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sNext ) ); + nLast.appendChild( document.createTextNode( oSettings.oLanguage.oPaginate.sLast ) ); + + nFirst.className = "paginate_button first"; + nPrevious.className = "paginate_button previous"; + nNext.className="paginate_button next"; + nLast.className = "paginate_button last"; + + nPaging.appendChild( nFirst ); + nPaging.appendChild( nPrevious ); + nPaging.appendChild( nNext ); + nPaging.appendChild( nLast ); + + $(nFirst).click( function () { + oSettings.oApi._fnPageChange( oSettings, "first" ); + fnCallbackDraw( oSettings ); + } ); + + $(nPrevious).click( function() { + oSettings.oApi._fnPageChange( oSettings, "previous" ); + fnCallbackDraw( oSettings ); + } ); + + $(nNext).click( function() { + oSettings.oApi._fnPageChange( oSettings, "next" ); + fnCallbackDraw( oSettings ); + } ); + + $(nLast).click( function() { + oSettings.oApi._fnPageChange( oSettings, "last" ); + fnCallbackDraw( oSettings ); + } ); + + $(nFirst).bind( 'selectstart', function () { return false; } ); + $(nPrevious).bind( 'selectstart', function () { return false; } ); + $(nNext).bind( 'selectstart', function () { return false; } ); + $(nLast).bind( 'selectstart', function () { return false; } ); + }, + + "fnUpdate": function ( oSettings, fnCallbackDraw ) { + if ( !oSettings.aanFeatures.p ) { + return; + } + + // Loop over each instance of the pager + var an = oSettings.aanFeatures.p; + for ( var i=0, iLen=an.length ; i+ -
+ fnInit - Initialisation of the paging controls. Called only during initialisation
+ of the table. It is expected that this function will add the required DOM elements
+ to the page for the paging controls to work. The element pointer
+ 'oSettings.aanFeatures.p' array is provided by DataTables to contain the paging
+ controls (note that this is a 2D array to allow for multiple instances of each
+ DataTables DOM element). It is suggested that you add the controls to this element
+ as children
+
- <static> oSort :object
Sorting plug-in methods - Sorting in DataTables is based on the detected type of the +data column (you can add your own type detection functions, or override automatic +detection using sType). With this specific type given to the column, DataTables will +apply the required sort from the functions in the object. Each sort type must provide +two mandatory methods, one each for ascending and descending sorting, and can optionally +provide a pre-formatting method that will help speed up sorting by allowing DataTables +to pre-format the sort data only once (rather than every time the actual sort functions +are run). The two sorting functions are typical Javascript sort methods: +
-
+
-
+ Function input parameters:
+
-
+
- {*} Data to compare to the second parameter +
- {*} Data to compare to the first parameter +
+ -
+ Function return:
+
-
+
- {int} Sorting match: <0 if first parameter should be sorted lower than + the second parameter, ===0 if the two parameters are equal and >0 if + the first parameter should be sorted height than the second parameter. +
-
+
+
Examples
+++ +// Case-sensitive string sorting, with no pre-formatting method + $.extend( $.fn.dataTableExt.oSort, { + "string-case-asc": function(x,y) { + return ((x < y) ? -1 : ((x > y) ? 1 : 0)); + }, + "string-case-desc": function(x,y) { + return ((x < y) ? 1 : ((x > y) ? -1 : 0)); + } + } ); + ++++// Case-insensitive string sorting, with pre-formatting + $.extend( $.fn.dataTableExt.oSort, { + "string-pre": function(x) { + return x.toLowerCase(); + }, + "string-asc": function(x,y) { + return ((x < y) ? -1 : ((x > y) ? 1 : 0)); + }, + "string-desc": function(x,y) { + return ((x < y) ? 1 : ((x > y) ? -1 : 0)); + } + } );+-
+ Function input parameters:
+
- <static> oStdClasses :object
Storage for the various classes that DataTables uses
-
+
+
- <static> sErrMode :string
How should DataTables report an error. Can take the value 'alert' or 'throw'
-
+
+
- <static> sVersion :string
Version string for plug-ins to check compatibility. Allowed format is +a.b.c.d.e where: a:int, b:int, c:int, d:string(dev|beta), e:int. d and +e are optional
-
+
+
+
+
+
+
+
+
+
+ Namespace: oColumn - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oColumn.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oColumn.html
new file mode 100644
index 0000000..887b2c7
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oColumn.html
@@ -0,0 +1,335 @@
+
+
+
+
+
+
+
+
+
+ Object models container, for the various models that DataTables has available +to it. These models define the objects that are used to hold the active state +and configuration of the table.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- ext
- DataTables extension options and plug-ins. This namespace acts as a collection "area"
+for plug-ins that can be used to extend the default DataTables behaviour - indeed many
+of the build in methods use this method to provide their own capabilities (sorting methods
+for example).
Note that this namespace is aliased to jQuery.fn.dataTableExt so it can be readily accessed +and modified by plug-ins. - oColumn
- Template object for the column information object in DataTables. This object
+is held in the settings aoColumns array and contains all the information that
+DataTables needs about each individual column.
Note that this object is related to DataTable.defaults.columns +but this one is the internal data store for DataTables's cache of columns. +It should NOT be manipulated outside of DataTables. Any configuration should +be done through the initialisation options. - oRow
- Template object for the way in which DataTables holds information about +each individual row. This is the object format used for the settings +aoData array.
- oSearch
- Template object for the way in which DataTables holds information about +search information for the global filter and individual column filters.
- oSettings
- DataTables settings object - this holds all the information needed for a
+given table, including configuration, data and current application of the
+table options. DataTables does not have a single instance for each DataTable
+with the settings attached to that instance, but rather instances of the
+DataTable "class" are created on-the-fly as needed (typically by a
+$().dataTable() call) and the settings object is then applied to that
+instance.
Note that this object is related to DataTable.defaults but this +one is the internal data store for DataTables's cache of columns. It should +NOT be manipulated outside of DataTables. Any configuration should be done +through the initialisation options.
+
+
+
+ Namespace: oRow - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oColumn
+Ancestry: DataTable ยป .models. ยป oColumn
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oRow.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oRow.html
new file mode 100644
index 0000000..7de3c9f
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oRow.html
@@ -0,0 +1,111 @@
+
+
+
+
+
+
+
+
+
+ Template object for the column information object in DataTables. This object
+is held in the settings aoColumns array and contains all the information that
+DataTables needs about each individual column.
Note that this object is related to DataTable.defaults.columns
+but this one is the internal data store for DataTables's cache of columns.
+It should NOT be manipulated outside of DataTables. Any configuration should
+be done through the initialisation options.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> aDataSort :array
- A list of the columns that sorting should occur on when this column +is sorted. That this property is an array allows multi-column sorting +to be defined for a column (for example first name / last name columns +would benefit from this). The values are integers pointing to the +columns to be sorted on (typically it will be a single integer pointing +at itself, but that doesn't need to be the case).
- <static> asSorting :array
- Define the sorting directions that are applied to the column, in sequence +as the column is repeatedly sorted upon - i.e. the first value is used +as the sorting direction when the column if first sorted (clicked on). +Sort it again (click again) and it will move on to the next index. +Repeat until loop.
- <static> bSearchable :boolean
- Flag to indicate if the column is searchable, and thus should be included +in the filtering or not.
- <static> bSortable :boolean
- Flag to indicate if the column is sortable or not.
- <static> bUseRendered :boolean
- When using fnRender, you have two options for what to do with the data, +and this property serves as the switch. Firstly, you can have the sorting +and filtering use the rendered value (true - default), or you can have +the sorting and filtering us the original value (false). +NOTE* It is it is advisable now to use mDataProp as a function and make +use of the 'type' that it gives, allowing (potentially) different data to +be used for sorting, filtering, display and type detection.
- <static> bVisible :boolean
- Flag to indicate if the column is currently visible in the table or not
- <static> fnCreatedCell :function
- Developer definable function that is called whenever a cell is created (Ajax source, +etc) or processed for input (DOM source). This can be used as a compliment to fnRender +allowing you to modify the DOM element (add background colour for example) when the +element is available (since it is not when fnRender is called).
- <static> fnGetData :function
- Function to get data from a cell in a column. You should never +access data directly through _aData internally in DataTables - always use +the method attached to this property. It allows mDataProp to function as +required. This function is automatically assigned by the column +initialisation method
- <static> fnRender :function
- Custom display function that will be called for the display of each cell +in this column.
- <static> fnSetData :function
- Function to set data for a cell in the column. You should never +set the data directly to _aData internally in DataTables - always use +this method. It allows mDataProp to function as required. This function +is automatically assigned by the column initialisation method
- <static> mDataProp :function|int|string|null
- Property to read the value for the cells in the column from the data +source array / object. If null, then the default content is used, if a +function is given then the return from the function is used.
- <static> nTf :node
- Unique footer TH/TD element for this column (if there is one). Not used +in DataTables as such, but can be used for plug-ins to reference the +footer for each column.
- <static> nTh :node
- Unique header TH/TD element for this column - this is what the sorting +listener is attached to (if sorting is enabled.)
- <static> sClass :string
- The class to apply to all TD elements in the table's TBODY for the column
- <static> sContentPadding :string
- When DataTables calculates the column widths to assign to each column, +it finds the longest string in each column and then constructs a +temporary table and reads the widths from that. The problem with this +is that "mmm" is much wider then "iiii", but the latter is a longer +string - thus the calculation can go wrong (doing it properly and putting +it into an DOM object and measuring that is horribly(!) slow). Thus as +a "work around" we provide this option. It will append its value to the +text that is found to be the longest string for the column - i.e. padding.
- <static> sDefaultContent :string
- Allows a default value to be given for a column's data, and will be used +whenever a null data source is encountered (this can be because mDataProp +is set to null, or because the data source itself is null).
- <static> sName :string
- Name for the column, allowing reference to the column by name as well as +by index (needs a lookup to work by name).
- <static> sSortDataType :string
- Custom sorting data type - defines which of the available plug-ins in +afnSortData the custom sorting will use - if any is defined.
- <static> sSortingClass :string
- Class to be applied to the header element when sorting on this column
- <static> sSortingClassJUI :string
- Class to be applied to the header element when sorting on this column - +when jQuery UI theming is used.
- <static> sTitle :string
- Title of the column - what is seen in the TH element (nTh).
- <static> sType :string
- Column sorting and filtering type
- <static> sWidth :string
- Width of the column
- <static> sWidthOrig :string
- Width of the column when it was first "encountered" +
+
+
+
+
+ Details
+Properties
+-
+
- <static> aDataSort :array
A list of the columns that sorting should occur on when this column +is sorted. That this property is an array allows multi-column sorting +to be defined for a column (for example first name / last name columns +would benefit from this). The values are integers pointing to the +columns to be sorted on (typically it will be a single integer pointing +at itself, but that doesn't need to be the case).
-
+
+
- <static> asSorting :array
Define the sorting directions that are applied to the column, in sequence +as the column is repeatedly sorted upon - i.e. the first value is used +as the sorting direction when the column if first sorted (clicked on). +Sort it again (click again) and it will move on to the next index. +Repeat until loop.
-
+
+
- <static> bSearchable :boolean
Flag to indicate if the column is searchable, and thus should be included +in the filtering or not.
-
+
+
- <static> bSortable :boolean
Flag to indicate if the column is sortable or not.
-
+
+
- <static> bUseRendered :boolean
When using fnRender, you have two options for what to do with the data, +and this property serves as the switch. Firstly, you can have the sorting +and filtering use the rendered value (true - default), or you can have +the sorting and filtering us the original value (false). +NOTE* It is it is advisable now to use mDataProp as a function and make +use of the 'type' that it gives, allowing (potentially) different data to +be used for sorting, filtering, display and type detection.
-
+
- Deprecated
- Yes +
- <static> bVisible :boolean
Flag to indicate if the column is currently visible in the table or not
-
+
+
- <static> fnCreatedCell :function
Developer definable function that is called whenever a cell is created (Ajax source, +etc) or processed for input (DOM source). This can be used as a compliment to fnRender +allowing you to modify the DOM element (add background colour for example) when the +element is available (since it is not when fnRender is called).
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1nTd element The TD node that has been created 2sData * The Data for the cell 3oData array | object The data for the whole row iRow int The row index for the aoData data store - <static> fnGetData :function
Function to get data from a cell in a column. You should never +access data directly through _aData internally in DataTables - always use +the method attached to this property. It allows mDataProp to function as +required. This function is automatically assigned by the column +initialisation method
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oData array | object The data array/object for the array + (i.e. aoData[]._aData) sSpecific string The specific data type you want to get - + 'display', 'type' 'filter' 'sort' Returns:
The data for the cell from the given row's data
- <static> fnRender :function
Custom display function that will be called for the display of each cell +in this column.
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1o object Object with the following parameters: o.iDataRow int The row in aoData o.iDataColumn int The column in question 4{array o.aData The data for the row in question o.oSettings object The settings object for this DataTables instance Returns:
The string you which to use in the display
- <static> fnSetData :function
Function to set data for a cell in the column. You should never +set the data directly to _aData internally in DataTables - always use +this method. It allows mDataProp to function as required. This function +is automatically assigned by the column initialisation method
+-
+
+
Parameters:
+ ++ +
+ + + + ++ Name +Type +Attributes +Default +Description +1oData array | object The data array/object for the array + (i.e. aoData[]._aData) sValue * Value to set - <static> mDataProp :function|int|string|null
Property to read the value for the cells in the column from the data +source array / object. If null, then the default content is used, if a +function is given then the return from the function is used.
-
+
+
- <static> nTf :node
Unique footer TH/TD element for this column (if there is one). Not used +in DataTables as such, but can be used for plug-ins to reference the +footer for each column.
-
+
+
- <static> nTh :node
Unique header TH/TD element for this column - this is what the sorting +listener is attached to (if sorting is enabled.)
-
+
+
- <static> sClass :string
The class to apply to all TD elements in the table's TBODY for the column
-
+
+
- <static> sContentPadding :string
When DataTables calculates the column widths to assign to each column, +it finds the longest string in each column and then constructs a +temporary table and reads the widths from that. The problem with this +is that "mmm" is much wider then "iiii", but the latter is a longer +string - thus the calculation can go wrong (doing it properly and putting +it into an DOM object and measuring that is horribly(!) slow). Thus as +a "work around" we provide this option. It will append its value to the +text that is found to be the longest string for the column - i.e. padding.
-
+
+
- <static> sDefaultContent :string
Allows a default value to be given for a column's data, and will be used +whenever a null data source is encountered (this can be because mDataProp +is set to null, or because the data source itself is null).
-
+
+
- <static> sName :string
Name for the column, allowing reference to the column by name as well as +by index (needs a lookup to work by name).
-
+
+
- <static> sSortDataType :string
Custom sorting data type - defines which of the available plug-ins in +afnSortData the custom sorting will use - if any is defined.
-
+
+
- <static> sSortingClass :string
Class to be applied to the header element when sorting on this column
-
+
+
- <static> sSortingClassJUI :string
Class to be applied to the header element when sorting on this column - +when jQuery UI theming is used.
-
+
+
- <static> sTitle :string
Title of the column - what is seen in the TH element (nTh).
-
+
+
- <static> sType :string
Column sorting and filtering type
-
+
+
- <static> sWidth :string
Width of the column
-
+
+
- <static> sWidthOrig :string
Width of the column when it was first "encountered"
-
+
+
+
+
+
+
+
+
+
+ Namespace: oSearch - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSearch.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSearch.html
new file mode 100644
index 0000000..3b9c14d
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSearch.html
@@ -0,0 +1,112 @@
+
+
+
+
+
+
+
+
+
+ Template object for the way in which DataTables holds information about +each individual row. This is the object format used for the settings +aoData array.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> nTr :node
- TR element for the row
- <static> _aData :array|object
- Data object from the original data source for the row. This is either +an array if using the traditional form of DataTables, or an object if +using mDataProp options. The exact type will depend on the passed in +data from the data source, or will be an array if using DOM a data +source. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> nTr :node
TR element for the row
-
+
+
- <static> _aData :array|object
Data object from the original data source for the row. This is either +an array if using the traditional form of DataTables, or an object if +using mDataProp options. The exact type will depend on the passed in +data from the data source, or will be an array if using DOM a data +source.
-
+
+
+
+
+
+ Namespace: oSettings - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oSearch
+Ancestry: DataTable ยป .models. ยป oSearch
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.html
new file mode 100644
index 0000000..8db20b0
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.html
@@ -0,0 +1,517 @@
+
+
+
+
+
+
+
+
+
+ Template object for the way in which DataTables holds information about +search information for the global filter and individual column filters.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> bCaseInsensitive :boolean
- Flag to indicate if the filtering should be case insensitive or not
- <static> bRegex :boolean
- Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
- <static> bSmart :boolean
- Flag to indicate if DataTables is to use its smart filtering or not.
- <static> sSearch :string
- Applied search term +
+
+
+
+
+ Details
+Properties
+-
+
- <static> bCaseInsensitive :boolean
Flag to indicate if the filtering should be case insensitive or not
-
+
+
- <static> bRegex :boolean
Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
-
+
+
- <static> bSmart :boolean
Flag to indicate if DataTables is to use its smart filtering or not.
-
+
+
- <static> sSearch :string
Applied search term
-
+
+
+
+
+
+ Namespace: oFeatures - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oSettings
+Ancestry: DataTable ยป .models. ยป oSettings
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oFeatures.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oFeatures.html
new file mode 100644
index 0000000..ce02d70
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oFeatures.html
@@ -0,0 +1,200 @@
+
+
+
+
+
+
+
+
+
+ DataTables settings object - this holds all the information needed for a
+given table, including configuration, data and current application of the
+table options. DataTables does not have a single instance for each DataTable
+with the settings attached to that instance, but rather instances of the
+DataTable "class" are created on-the-fly as needed (typically by a
+$().dataTable() call) and the settings object is then applied to that
+instance.
Note that this object is related to DataTable.defaults but this
+one is the internal data store for DataTables's cache of columns. It should
+NOT be manipulated outside of DataTables. Any configuration should be done
+through the initialisation options.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- oFeatures
- Primary features of DataTables and their enablement state.
- oLanguage
- Language information for the table.
- oPreviousSearch
- Store the applied global search information in case we want to force a +research or compare the old search to a new one. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- oScroll
- Scrolling settings for a table. +
Properties
+ +-
+
- <static> aanFeatures :array
- Array referencing the nodes which are used for the features. The
+parameters of this object match what is allowed by sDom - i.e.
+
-
+
- 'l' - Length changing +
- 'f' - Filtering input +
- 't' - The table! +
- 'i' - Information +
- 'p' - Pagination +
- 'r' - pRocessing +
- <static> aaSorting :array
- Sorting that is applied to the table. Note that the inner arrays are
+used in the following manner:
+
-
+
- Index 0 - column number +
- Index 1 - current sorting direction +
- Index 2 - index of asSorting for this column +
- <static> aaSortingFixed :array|null
- Sorting that is always applied to the table (i.e. prefixed in front of +aaSorting). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> aiDisplay :array
- Array of indexes which are in the current display (after filtering etc)
- <static> aiDisplayMaster :array
- Array of indexes for display - no filtering
- <static> aLengthMenu :array
- List of options that can be used for the user selectable length menu. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> aoColumns :array
- Store information about each column that is in use
- <static> aoData :array
- Store data information - see DataTable.models.oRow for detailed +information.
- <static> aoDestroyCallback :array
- Destroy callback functions - for plug-ins to attach themselves to the +destroy so they can clean up markup and events.
- <static> aoDrawCallback :array
- Array of callback functions for draw callback functions
- <static> aoFooter :array
- Store information about the table's footer
- <static> aoFooterCallback :array
- Callback function for the footer on each draw.
- <static> aoHeader :array
- Store information about the table's header
- <static> aoHeaderCallback :array
- Callback functions for the header on each draw.
- <static> aoInitComplete :array
- Callback functions for when the table has been initialised.
- <static> aoOpenRows :array
- Information about open rows. Each object in the array has the parameters +'nTr' and 'nParent'
- <static> aoPreDrawCallback :array
- Callback functions for just before the table is redrawn. A return of +false will be used to cancel the draw.
- <static> aoPreSearchCols :array
- Store the applied search for each column - see +DataTable.models.oSearch for the format that is used for the +filtering information for each column.
- <static> aoRowCallback :array
- Callback functions array for every time a row is inserted (i.e. on a draw).
- <static> aoRowCreatedCallback :array
- Array of callback functions for row created function
- <static> aoServerParams :array
- Functions which are called prior to sending an Ajax request so extra +parameters can easily be sent to the server
- <static> aoStateLoad :array
- Array of callback functions for state loading. Each array element is an
+object with the following parameters:
+
-
+
- function:fn - function to call. Takes two parameters, oSettings + and the object stored. May return false to cancel state loading +
- string:sName - name of callback +
- <static> aoStateLoaded :array
- Callbacks for operating on the settings object once the saved state has been +loaded
- <static> aoStateLoadParams :array
- Callbacks for modifying the settings that have been stored for state saving +prior to using the stored values to restore the state.
- <static> aoStateSave :array
- Array of callback functions for state saving. Each array element is an
+object with the following parameters:
+
-
+
- function:fn - function to call. Takes two parameters, oSettings + and the JSON string to save that has been thus far created. Returns + a JSON string to be inserted into a json object + (i.e. '"param": [ 0, 1, 2]') +
- string:sName - name of callback +
- <static> aoStateSaveParams :array
- Callbacks for modifying the settings to be stored for state saving, prior to +saving state.
- <static> asDataSearch :array
- Search data array for regular expression searching
- <static> asDestroyStripes :array
- If restoring a table - we should restore its striping classes as well
- <static> asStripeClasses :array
- Classes to use for the striping of a table. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bAjaxDataGet :boolean
- Note if draw should be blocked while getting data
- <static> bDeferLoading :boolean
- Indicate if when using server-side processing the loading of data +should be deferred until the second draw. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bDrawing :boolean
- Indicate if a redraw is being done - useful for Ajax
- <static> bFiltered :boolean
- Flag attached to the settings object so you can check in the draw +callback if filtering has been done in the draw. Deprecated in favour of +events.
- <static> bInitialised :boolean
- Indicate if all required information has been read in
- <static> bJUI :boolean
- Flag to indicate if jQuery UI marking and classes should be used. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bSortCellsTop :boolean
- Indicate that if multiple rows are in the header and there is more than +one unique cell per column, if the top one (true) or bottom one (false) +should be used for sorting / title by DataTables. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bSorted :boolean
- Flag attached to the settings object so you can check in the draw +callback if sorting has been done in the draw. Deprecated in favour of +events.
- <static> fnCookieCallback :function
- Callback function for cookie creation. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> fnFormatNumber :function
- Format numbers for display. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> fnServerData :function
- Function to get the server-side data. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> iCookieDuration :int
- The cookie duration (for bStateSave) in seconds. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> iDraw :int
- Counter for the draws that the table does. Also used as a tracker for +server-side processing
- <static> iDrawError :int
- Draw index (iDraw) of the last error when parsing the returned data
- <static> iTabIndex
- tabindex attribute value that is added to DataTables control elements, allowing +keyboard navigation of the table and its controls.
- <static> jqXHR :object
- The last jQuery XHR object that was used for server-side data gathering. +This can be used for working with the XHR information in one of the +callbacks
- <static> nScrollFoot
- DIV container for the footer scrolling table if scrolling
- <static> nScrollHead
- DIV container for the footer scrolling table if scrolling
- <static> nTable :node
- The TABLE node for the main table
- <static> nTableWrapper :node
- Cache the wrapper node (contains all DataTables controlled elements)
- <static> nTBody :node
- Permanent ref to the tbody element
- <static> nTFoot :node
- Permanent ref to the tfoot element - if it exists
- <static> nTHead :node
- Permanent ref to the thead element
- <static> oClasses :object
- The classes to use for the table
- <static> oInit :object
- Initialisation object that is used for the table
- <static> oInstance :object
- The DataTables object for this table
- <static> oLoadedState :object
- State that was loaded from the cookie. Useful for back reference
- <static> sAjaxDataProp :string
- Property from a given object from which to read the table data from. This +can be an empty string (when not server-side processing), in which case +it is assumed an an array is given directly. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sAjaxSource :string
- Source url for AJAX data for the table. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sCookiePrefix :string
- The cookie name prefix. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sDestroyWidth :int
- If restoring a table - we should restore its width
- <static> sDom :string
- Dictate the positioning of DataTables' control elements - see +DataTable.model.oInit.sDom. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sInstance :string
- Unique identifier for each instance of the DataTables object. If there +is an ID on the table node, then it takes that value, otherwise an +incrementing internal counter is used.
- <static> sPaginationType :string
- Which type of pagination should be used. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sServerMethod :string
- Send the XHR HTTP method - GET or POST (could be PUT or DELETE if +required). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sTableId :string
- Cache the table ID for quick access
- <static> _iDisplayLength :int
- Paging display length
- <static> _iDisplayStart :int
- Paging start point - aiDisplay index +
Methods
+ +-
+
- <static> fnDisplayEnd()
- Set the display end point - aiDisplay index
- <static> fnRecordsDisplay()
- Get the number of records in the current record set, after filtering
- <static> fnRecordsTotal()
- Get the number of records in the current record set, before filtering +
+
+
+
+
+ Details
+Properties
+-
+
- <static> aanFeatures :array
Array referencing the nodes which are used for the features. The +parameters of this object match what is allowed by sDom - i.e. +
-
+
- 'l' - Length changing +
- 'f' - Filtering input +
- 't' - The table! +
- 'i' - Information +
- 'p' - Pagination +
- 'r' - pRocessing +
-
+
+
- <static> aaSorting :array
Sorting that is applied to the table. Note that the inner arrays are +used in the following manner: +
-
+
- Index 0 - column number +
- Index 1 - current sorting direction +
- Index 2 - index of asSorting for this column +
-
+
+
- <static> aaSortingFixed :array|null
Sorting that is always applied to the table (i.e. prefixed in front of +aaSorting). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> aiDisplay :array
Array of indexes which are in the current display (after filtering etc)
-
+
+
- <static> aiDisplayMaster :array
Array of indexes for display - no filtering
-
+
+
- <static> aLengthMenu :array
List of options that can be used for the user selectable length menu. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> aoColumns :array
Store information about each column that is in use
-
+
+
- <static> aoData :array
Store data information - see DataTable.models.oRow for detailed +information.
-
+
+
- <static> aoDestroyCallback :array
Destroy callback functions - for plug-ins to attach themselves to the +destroy so they can clean up markup and events.
-
+
+
- <static> aoDrawCallback :array
Array of callback functions for draw callback functions
-
+
+
- <static> aoFooter :array
Store information about the table's footer
-
+
+
- <static> aoFooterCallback :array
Callback function for the footer on each draw.
-
+
+
- <static> aoHeader :array
Store information about the table's header
-
+
+
- <static> aoHeaderCallback :array
Callback functions for the header on each draw.
-
+
+
- <static> aoInitComplete :array
Callback functions for when the table has been initialised.
-
+
+
- <static> aoOpenRows :array
Information about open rows. Each object in the array has the parameters +'nTr' and 'nParent'
-
+
+
- <static> aoPreDrawCallback :array
Callback functions for just before the table is redrawn. A return of +false will be used to cancel the draw.
-
+
+
- <static> aoPreSearchCols :array
Store the applied search for each column - see +DataTable.models.oSearch for the format that is used for the +filtering information for each column.
-
+
+
- <static> aoRowCallback :array
Callback functions array for every time a row is inserted (i.e. on a draw).
-
+
+
- <static> aoRowCreatedCallback :array
Array of callback functions for row created function
-
+
+
- <static> aoServerParams :array
Functions which are called prior to sending an Ajax request so extra +parameters can easily be sent to the server
-
+
+
- <static> aoStateLoad :array
Array of callback functions for state loading. Each array element is an +object with the following parameters: +
-
+
- function:fn - function to call. Takes two parameters, oSettings + and the object stored. May return false to cancel state loading +
- string:sName - name of callback +
-
+
+
- <static> aoStateLoaded :array
Callbacks for operating on the settings object once the saved state has been +loaded
-
+
+
- <static> aoStateLoadParams :array
Callbacks for modifying the settings that have been stored for state saving +prior to using the stored values to restore the state.
-
+
+
- <static> aoStateSave :array
Array of callback functions for state saving. Each array element is an +object with the following parameters: +
-
+
- function:fn - function to call. Takes two parameters, oSettings + and the JSON string to save that has been thus far created. Returns + a JSON string to be inserted into a json object + (i.e. '"param": [ 0, 1, 2]') +
- string:sName - name of callback +
-
+
+
- <static> aoStateSaveParams :array
Callbacks for modifying the settings to be stored for state saving, prior to +saving state.
-
+
+
- <static> asDataSearch :array
Search data array for regular expression searching
-
+
+
- <static> asDestroyStripes :array
If restoring a table - we should restore its striping classes as well
-
+
+
- <static> asStripeClasses :array
Classes to use for the striping of a table. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bAjaxDataGet :boolean
Note if draw should be blocked while getting data
-
+
+
- <static> bDeferLoading :boolean
Indicate if when using server-side processing the loading of data +should be deferred until the second draw. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bDrawing :boolean
Indicate if a redraw is being done - useful for Ajax
-
+
+
- <static> bFiltered :boolean
Flag attached to the settings object so you can check in the draw +callback if filtering has been done in the draw. Deprecated in favour of +events.
-
+
- Deprecated
- Yes +
- <static> bInitialised :boolean
Indicate if all required information has been read in
-
+
+
- <static> bJUI :boolean
Flag to indicate if jQuery UI marking and classes should be used. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bSortCellsTop :boolean
Indicate that if multiple rows are in the header and there is more than +one unique cell per column, if the top one (true) or bottom one (false) +should be used for sorting / title by DataTables. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bSorted :boolean
Flag attached to the settings object so you can check in the draw +callback if sorting has been done in the draw. Deprecated in favour of +events.
-
+
- Deprecated
- Yes +
- <static> fnCookieCallback :function
Callback function for cookie creation. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
+-
+
+
- <static> fnFormatNumber :function
Format numbers for display. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
+-
+
+
- <static> fnServerData :function
Function to get the server-side data. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
+-
+
+
- <static> iCookieDuration :int
The cookie duration (for bStateSave) in seconds. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> iDraw :int
Counter for the draws that the table does. Also used as a tracker for +server-side processing
-
+
+
- <static> iDrawError :int
Draw index (iDraw) of the last error when parsing the returned data
-
+
+
- <static> iTabIndex
tabindex attribute value that is added to DataTables control elements, allowing +keyboard navigation of the table and its controls.
-
+
+
- <static> jqXHR :object
The last jQuery XHR object that was used for server-side data gathering. +This can be used for working with the XHR information in one of the +callbacks
-
+
+
- <static> nScrollFoot
DIV container for the footer scrolling table if scrolling
-
+
+
- <static> nScrollHead
DIV container for the footer scrolling table if scrolling
-
+
+
- <static> nTable :node
The TABLE node for the main table
-
+
+
- <static> nTableWrapper :node
Cache the wrapper node (contains all DataTables controlled elements)
-
+
+
- <static> nTBody :node
Permanent ref to the tbody element
-
+
+
- <static> nTFoot :node
Permanent ref to the tfoot element - if it exists
-
+
+
- <static> nTHead :node
Permanent ref to the thead element
-
+
+
- <static> oClasses :object
The classes to use for the table
-
+
+
- <static> oInit :object
Initialisation object that is used for the table
-
+
+
- <static> oInstance :object
The DataTables object for this table
-
+
+
- <static> oLoadedState :object
State that was loaded from the cookie. Useful for back reference
-
+
+
- <static> sAjaxDataProp :string
Property from a given object from which to read the table data from. This +can be an empty string (when not server-side processing), in which case +it is assumed an an array is given directly. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sAjaxSource :string
Source url for AJAX data for the table. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sCookiePrefix :string
The cookie name prefix. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sDestroyWidth :int
If restoring a table - we should restore its width
-
+
+
- <static> sDom :string
Dictate the positioning of DataTables' control elements - see +DataTable.model.oInit.sDom. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sInstance :string
Unique identifier for each instance of the DataTables object. If there +is an ID on the table node, then it takes that value, otherwise an +incrementing internal counter is used.
-
+
+
- <static> sPaginationType :string
Which type of pagination should be used. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sServerMethod :string
Send the XHR HTTP method - GET or POST (could be PUT or DELETE if +required). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sTableId :string
Cache the table ID for quick access
-
+
+
- <static> _iDisplayLength :int
Paging display length
-
+
+
- <static> _iDisplayStart :int
Paging start point - aiDisplay index
-
+
+
+
Methods
+-
+
- <static> fnDisplayEnd()
Set the display end point - aiDisplay index
+-
+
+
- <static> fnRecordsDisplay()
Get the number of records in the current record set, after filtering
+-
+
+
- <static> fnRecordsTotal()
Get the number of records in the current record set, before filtering
+ +-
+
+
+
+
+
+ Namespace: oLanguage - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oFeatures
+Ancestry: DataTable ยป .models ยป .oSettings. ยป oFeatures
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oLanguage.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oLanguage.html
new file mode 100644
index 0000000..e399a50
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oLanguage.html
@@ -0,0 +1,370 @@
+
+
+
+
+
+
+
+
+
+ Primary features of DataTables and their enablement state.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> bAutoWidth :boolean
- Flag to say if DataTables should automatically try to calculate the +optimum table and columns widths (true) or not (false). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bDeferRender :boolean
- Delay the creation of TR and TD elements until they are actually +needed by a driven page draw. This can give a significant speed +increase for Ajax source and Javascript source data, but makes no +difference at all fro DOM and server-side processing tables. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bFilter :boolean
- Enable filtering on the table or not. Note that if this is disabled +then there is no filtering at all on the table, including fnFilter. +To just remove the filtering input use sDom and remove the 'f' option. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bInfo :boolean
- Table information element (the 'Showing x of y records' div) enable +flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bLengthChange :boolean
- Present a user control allowing the end user to change the page size +when pagination is enabled. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bPaginate :boolean
- Pagination enabled or not. Note that if this is disabled then length +changing must also be disabled. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bProcessing :boolean
- Processing indicator enable flag whenever DataTables is enacting a +user request - typically an Ajax request for server-side processing. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bServerSide :boolean
- Server-side processing enabled flag - when enabled DataTables will +get all data from the server for every draw - there is no filtering, +sorting or paging done on the client-side. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bSort :boolean
- Sorting enablement flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bSortClasses :boolean
- Apply a class to the columns which are being sorted to provide a +visual highlight or not. This can slow things down when enabled since +there is a lot of DOM interaction. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bStateSave :boolean
- State saving enablement flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> bAutoWidth :boolean
Flag to say if DataTables should automatically try to calculate the +optimum table and columns widths (true) or not (false). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bDeferRender :boolean
Delay the creation of TR and TD elements until they are actually +needed by a driven page draw. This can give a significant speed +increase for Ajax source and Javascript source data, but makes no +difference at all fro DOM and server-side processing tables. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bFilter :boolean
Enable filtering on the table or not. Note that if this is disabled +then there is no filtering at all on the table, including fnFilter. +To just remove the filtering input use sDom and remove the 'f' option. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bInfo :boolean
Table information element (the 'Showing x of y records' div) enable +flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bLengthChange :boolean
Present a user control allowing the end user to change the page size +when pagination is enabled. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bPaginate :boolean
Pagination enabled or not. Note that if this is disabled then length +changing must also be disabled. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bProcessing :boolean
Processing indicator enable flag whenever DataTables is enacting a +user request - typically an Ajax request for server-side processing. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bServerSide :boolean
Server-side processing enabled flag - when enabled DataTables will +get all data from the server for every draw - there is no filtering, +sorting or paging done on the client-side. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bSort :boolean
Sorting enablement flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bSortClasses :boolean
Apply a class to the columns which are being sorted to provide a +visual highlight or not. This can slow things down when enabled since +there is a lot of DOM interaction. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bStateSave :boolean
State saving enablement flag. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
+
+
+
+ Namespace: oPreviousSearch - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oLanguage
+Ancestry: DataTable ยป .models ยป .oSettings. ยป oLanguage
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oPreviousSearch.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oPreviousSearch.html
new file mode 100644
index 0000000..c180724
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oPreviousSearch.html
@@ -0,0 +1,118 @@
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary
+ +Namespaces
+-
+
- oAria
- Strings that are used for WAI-ARIA labels and controls only (these are not +actually visible on the page, but will be read by screenreaders, and thus +must be internationalised as well).
- oPaginate
- Pagination string used by DataTables for the two built-in pagination +control types ("two_button" and "full_numbers") +
Properties
+ +-
+
- <static> fnInfoCallback :function
- Information callback function. See +DataTable.defaults.fnInfoCallback
- <static> sEmptyTable :string
- This string is shown in preference to sZeroRecords when the table is +empty of data (regardless of filtering). Note that this is an optional +parameter - if it is not given, the value of sZeroRecords will be used +instead (either the default or given value).
- <static> sInfo :string
- This string gives information to the end user about the information that +is current on display on the page. The _START_, _END_ and _TOTAL_ +variables are all dynamically replaced as the table display updates, and +can be freely moved or removed as the language requirements change.
- <static> sInfoEmpty :string
- Display information string for when the table is empty. Typically the +format of this string should match sInfo.
- <static> sInfoFiltered :string
- When a user filters the information in a table, this string is appended +to the information (sInfo) to give an idea of how strong the filtering +is. The variable _MAX_ is dynamically updated.
- <static> sInfoPostFix :string
- If can be useful to append extra information to the info string at times, +and this variable does exactly that. This information will be appended to +the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are +being used) at all times.
- <static> sInfoThousands :string
- DataTables has a build in number formatter (fnFormatNumber) which is used +to format large numbers that are used in the table information. By +default a comma is used, but this can be trivially changed to any +character you wish with this parameter.
- <static> sLengthMenu :string
- Detail the action that will be taken when the drop down menu for the +pagination length option is changed. The '_MENU_' variable is replaced +with a default select list of 10, 25, 50 and 100, and can be replaced +with a custom select box if required.
- <static> sLoadingRecords :string
- When using Ajax sourced data and during the first draw when DataTables is +gathering the data, this message is shown in an empty row in the table to +indicate to the end user the the data is being loaded. Note that this +parameter is not used when loading data by server-side processing, just +Ajax sourced data with client-side processing.
- <static> sProcessing :string
- Text which is displayed when the table is processing a user action +(usually a sort command or similar).
- <static> sSearch :string
- Details the actions that will be taken when the user types into the +filtering input text box. The variable "_INPUT_", if used in the string, +is replaced with the HTML text box for the filtering input allowing +control over where it appears in the string. If "_INPUT_" is not given +then the input box is appended to the string automatically.
- <static> sUrl :string
- All of the language information can be stored in a file on the +server-side, which DataTables will look up if this parameter is passed. +It must store the URL of the language file, which is in a JSON format, +and the object has the same properties as the oLanguage object in the +initialiser object (i.e. the above parameters). Please refer to one of +the example language files to see how this works in action.
- <static> sZeroRecords :string
- Text shown inside the table records when the is no information to be +displayed after filtering. sEmptyTable is shown when there is simply no +information in the table at all (regardless of filtering).
+
+
+
+
+
+ Details
+Properties
+-
+
- <static> fnInfoCallback :function
Information callback function. See +DataTable.defaults.fnInfoCallback
+-
+
+
- <static> sEmptyTable :string
This string is shown in preference to sZeroRecords when the table is +empty of data (regardless of filtering). Note that this is an optional +parameter - if it is not given, the value of sZeroRecords will be used +instead (either the default or given value).
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sEmptyTable": "No data available in table" + } + } ); + } );+- <static> sInfo :string
This string gives information to the end user about the information that +is current on display on the page. The _START_, _END_ and _TOTAL_ +variables are all dynamically replaced as the table display updates, and +can be freely moved or removed as the language requirements change.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfo": "Got a total of _TOTAL_ entries to show (_START_ to _END_)" + } + } ); + } );+- <static> sInfoEmpty :string
Display information string for when the table is empty. Typically the +format of this string should match sInfo.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoEmpty": "No entries to show" + } + } ); + } );+- <static> sInfoFiltered :string
When a user filters the information in a table, this string is appended +to the information (sInfo) to give an idea of how strong the filtering +is. The variable _MAX_ is dynamically updated.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoFiltered": " - filtering from _MAX_ records" + } + } ); + } );+- <static> sInfoPostFix :string
If can be useful to append extra information to the info string at times, +and this variable does exactly that. This information will be appended to +the sInfo (sInfoEmpty and sInfoFiltered in whatever combination they are +being used) at all times.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoPostFix": "All records shown are derived from real information." + } + } ); + } );+- <static> sInfoThousands :string
DataTables has a build in number formatter (fnFormatNumber) which is used +to format large numbers that are used in the table information. By +default a comma is used, but this can be trivially changed to any +character you wish with this parameter.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sInfoThousands": "'" + } + } ); + } );+- <static> sLengthMenu :string
Detail the action that will be taken when the drop down menu for the +pagination length option is changed. The '_MENU_' variable is replaced +with a default select list of 10, 25, 50 and 100, and can be replaced +with a custom select box if required.
-
+
+
Extended from:
Examples
+++ +// Language change only + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sLengthMenu": "Display _MENU_ records" + } + } ); + } ); + ++++// Language and options change + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sLengthMenu": 'Display records' + } + } ); + } );+- <static> sLoadingRecords :string
When using Ajax sourced data and during the first draw when DataTables is +gathering the data, this message is shown in an empty row in the table to +indicate to the end user the the data is being loaded. Note that this +parameter is not used when loading data by server-side processing, just +Ajax sourced data with client-side processing.
-
+
+
Extended from:
Example
+++$(document).ready( function() { + $('#example').dataTable( { + "oLanguage": { + "sLoadingRecords": "Please wait - loading..." + } + } ); + } );+- <static> sProcessing :string
Text which is displayed when the table is processing a user action +(usually a sort command or similar).
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sProcessing": "DataTables is currently busy" + } + } ); + } );+- <static> sSearch :string
Details the actions that will be taken when the user types into the +filtering input text box. The variable "_INPUT_", if used in the string, +is replaced with the HTML text box for the filtering input allowing +control over where it appears in the string. If "_INPUT_" is not given +then the input box is appended to the string automatically.
-
+
+
Extended from:
Examples
+++ +// Input text box will be appended at the end automatically + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sSearch": "Filter records:" + } + } ); + } ); + ++++// Specify where the filter should appear + $(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sSearch": "Apply filter _INPUT_ to table" + } + } ); + } );+- <static> sUrl :string
All of the language information can be stored in a file on the +server-side, which DataTables will look up if this parameter is passed. +It must store the URL of the language file, which is in a JSON format, +and the object has the same properties as the oLanguage object in the +initialiser object (i.e. the above parameters). Please refer to one of +the example language files to see how this works in action.
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sUrl": "http://www.sprymedia.co.uk/dataTables/lang.txt" + } + } ); + } );+- <static> sZeroRecords :string
Text shown inside the table records when the is no information to be +displayed after filtering. sEmptyTable is shown when there is simply no +information in the table at all (regardless of filtering).
-
+
+
Extended from:
Example
+++$(document).ready(function() { + $('#example').dataTable( { + "oLanguage": { + "sZeroRecords": "No records to display" + } + } ); + } );+
+
+
+
+ Namespace: oScroll - documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Namespace: oPreviousSearch
+Ancestry: DataTable ยป .models ยป .oSettings. ยป oPreviousSearch
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oScroll.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oScroll.html
new file mode 100644
index 0000000..c734356
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/DataTable.models.oSettings.oScroll.html
@@ -0,0 +1,167 @@
+
+
+
+
+
+
+
+
+
+ Store the applied global search information in case we want to force a +research or compare the old search to a new one. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
Extends
+ + +
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> bCaseInsensitive :boolean
- Flag to indicate if the filtering should be case insensitive or not
- <static> bRegex :boolean
- Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
- <static> bSmart :boolean
- Flag to indicate if DataTables is to use its smart filtering or not.
- <static> sSearch :string
- Applied search term
+
+
+
+
+
+ Details
+Properties
+-
+
- <static> bCaseInsensitive :boolean
Flag to indicate if the filtering should be case insensitive or not
- <static> bRegex :boolean
Flag to indicate if the search term should be interpreted as a +regular expression (true) or not (false) and therefore and special +regex characters escaped.
- <static> bSmart :boolean
Flag to indicate if DataTables is to use its smart filtering or not.
- <static> sSearch :string
Applied search term
+
+
+
+ Table of Contents - documentation
+
+
+
+
+
+
+
+
+
+ )[^>]*$|#([\w\-]+)$)/,
+
+ // Check if a string has a non-whitespace character in it
+ rnotwhite = /\S/,
+
+ // Used for trimming whitespace
+ trimLeft = /^\s+/,
+ trimRight = /\s+$/,
+
+ // Check for digits
+ rdigit = /\d/,
+
+ // Match a standalone tag
+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
+
+ // JSON RegExp
+ rvalidchars = /^[\],:{}\s]*$/,
+ rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
+ rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+
+ // Useragent RegExp
+ rwebkit = /(webkit)[ \/]([\w.]+)/,
+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
+ rmsie = /(msie) ([\w.]+)/,
+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
+
+ // Keep a UserAgent string for use with jQuery.browser
+ userAgent = navigator.userAgent,
+
+ // For matching the engine and version of the browser
+ browserMatch,
+
+ // Has the ready events already been bound?
+ readyBound = false,
+
+ // The deferred used on DOM ready
+ readyList,
+
+ // Promise methods
+ promiseMethods = "then done fail isResolved isRejected promise".split( " " ),
+
+ // The ready event handler
+ DOMContentLoaded,
+
+ // Save a reference to some core methods
+ toString = Object.prototype.toString,
+ hasOwn = Object.prototype.hasOwnProperty,
+ push = Array.prototype.push,
+ slice = Array.prototype.slice,
+ trim = String.prototype.trim,
+ indexOf = Array.prototype.indexOf,
+
+ // [[Class]] -> type pairs
+ class2type = {};
+
+jQuery.fn = jQuery.prototype = {
+ constructor: jQuery,
+ init: function( selector, context, rootjQuery ) {
+ var match, elem, ret, doc;
+
+ // Handle $(""), $(null), or $(undefined)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Handle $(DOMElement)
+ if ( selector.nodeType ) {
+ this.context = this[0] = selector;
+ this.length = 1;
+ return this;
+ }
+
+ // The body element only exists once, optimize finding it
+ if ( selector === "body" && !context && document.body ) {
+ this.context = document;
+ this[0] = document.body;
+ this.selector = "body";
+ this.length = 1;
+ return this;
+ }
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ // Are we dealing with HTML string or an ID?
+ match = quickExpr.exec( selector );
+
+ // Verify a match, and that no context was specified for #id
+ if ( match && (match[1] || !context) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[1] ) {
+ context = context instanceof jQuery ? context[0] : context;
+ doc = (context ? context.ownerDocument || context : document);
+
+ // If a single string is passed in and it's a single tag
+ // just do a createElement and skip the rest
+ ret = rsingleTag.exec( selector );
+
+ if ( ret ) {
+ if ( jQuery.isPlainObject( context ) ) {
+ selector = [ document.createElement( ret[1] ) ];
+ jQuery.fn.attr.call( selector, context, true );
+
+ } else {
+ selector = [ doc.createElement( ret[1] ) ];
+ }
+
+ } else {
+ ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
+ selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
+ }
+
+ return jQuery.merge( this, selector );
+
+ // HANDLE: $("#id")
+ } else {
+ elem = document.getElementById( match[2] );
+
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if ( elem && elem.parentNode ) {
+ // Handle the case where IE and Opera return items
+ // by name instead of ID
+ if ( elem.id !== match[2] ) {
+ return rootjQuery.find( selector );
+ }
+
+ // Otherwise, we inject the element directly into the jQuery object
+ this.length = 1;
+ this[0] = elem;
+ }
+
+ this.context = document;
+ this.selector = selector;
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return (context || rootjQuery).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( jQuery.isFunction( selector ) ) {
+ return rootjQuery.ready( selector );
+ }
+
+ if (selector.selector !== undefined) {
+ this.selector = selector.selector;
+ this.context = selector.context;
+ }
+
+ return jQuery.makeArray( selector, this );
+ },
+
+ // Start with an empty selector
+ selector: "",
+
+ // The current version of jQuery being used
+ jquery: "1.5.1",
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ // The number of elements contained in the matched element set
+ size: function() {
+ return this.length;
+ },
+
+ toArray: function() {
+ return slice.call( this, 0 );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+ return num == null ?
+
+ // Return a 'clean' array
+ this.toArray() :
+
+ // Return just the object
+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems, name, selector ) {
+ // Build a new jQuery matched element set
+ var ret = this.constructor();
+
+ if ( jQuery.isArray( elems ) ) {
+ push.apply( ret, elems );
+
+ } else {
+ jQuery.merge( ret, elems );
+ }
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ ret.context = this.context;
+
+ if ( name === "find" ) {
+ ret.selector = this.selector + (this.selector ? " " : "") + selector;
+ } else if ( name ) {
+ ret.selector = this.selector + "." + name + "(" + selector + ")";
+ }
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ // (You can seed the arguments with an array of args, but this is
+ // only used internally.)
+ each: function( callback, args ) {
+ return jQuery.each( this, callback, args );
+ },
+
+ ready: function( fn ) {
+ // Attach the listeners
+ jQuery.bindReady();
+
+ // Add the callback
+ readyList.done( fn );
+
+ return this;
+ },
+
+ eq: function( i ) {
+ return i === -1 ?
+ this.slice( i ) :
+ this.slice( i, +i + 1 );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ slice: function() {
+ return this.pushStack( slice.apply( this, arguments ),
+ "slice", slice.call(arguments).join(",") );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map(this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ }));
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor(null);
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: push,
+ sort: [].sort,
+ splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if ( length === i ) {
+ target = this;
+ --i;
+ }
+
+ for ( ; i < length; i++ ) {
+ // Only deal with non-null/undefined values
+ if ( (options = arguments[ i ]) != null ) {
+ // Extend the base object
+ for ( name in options ) {
+ src = target[ name ];
+ copy = options[ name ];
+
+ // Prevent never-ending loop
+ if ( target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
+ if ( copyIsArray ) {
+ copyIsArray = false;
+ clone = src && jQuery.isArray(src) ? src : [];
+
+ } else {
+ clone = src && jQuery.isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend({
+ noConflict: function( deep ) {
+ window.$ = _$;
+
+ if ( deep ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+ },
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+ // A third-party is pushing the ready event forwards
+ if ( wait === true ) {
+ jQuery.readyWait--;
+ }
+
+ // Make sure that the DOM is not already loaded
+ if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if ( !document.body ) {
+ return setTimeout( jQuery.ready, 1 );
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+
+ // Trigger any bound ready events
+ if ( jQuery.fn.trigger ) {
+ jQuery( document ).trigger( "ready" ).unbind( "ready" );
+ }
+ }
+ },
+
+ bindReady: function() {
+ if ( readyBound ) {
+ return;
+ }
+
+ readyBound = true;
+
+ // Catch cases where $(document).ready() is called after the
+ // browser event has already occurred.
+ if ( document.readyState === "complete" ) {
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ return setTimeout( jQuery.ready, 1 );
+ }
+
+ // Mozilla, Opera and webkit nightlies currently support this event
+ if ( document.addEventListener ) {
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", jQuery.ready, false );
+
+ // If IE event model is used
+ } else if ( document.attachEvent ) {
+ // ensure firing before onload,
+ // maybe late but safe also for iframes
+ document.attachEvent("onreadystatechange", DOMContentLoaded);
+
+ // A fallback to window.onload, that will always work
+ window.attachEvent( "onload", jQuery.ready );
+
+ // If IE and not a frame
+ // continually check to see if the document is ready
+ var toplevel = false;
+
+ try {
+ toplevel = window.frameElement == null;
+ } catch(e) {}
+
+ if ( document.documentElement.doScroll && toplevel ) {
+ doScrollCheck();
+ }
+ }
+ },
+
+ // See test/unit/core.js for details concerning isFunction.
+ // Since version 1.3, DOM methods and functions like alert
+ // aren't supported. They return false on IE (#2968).
+ isFunction: function( obj ) {
+ return jQuery.type(obj) === "function";
+ },
+
+ isArray: Array.isArray || function( obj ) {
+ return jQuery.type(obj) === "array";
+ },
+
+ // A crude way of determining if an object is a window
+ isWindow: function( obj ) {
+ return obj && typeof obj === "object" && "setInterval" in obj;
+ },
+
+ isNaN: function( obj ) {
+ return obj == null || !rdigit.test( obj ) || isNaN( obj );
+ },
+
+ type: function( obj ) {
+ return obj == null ?
+ String( obj ) :
+ class2type[ toString.call(obj) ] || "object";
+ },
+
+ isPlainObject: function( obj ) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+ return false;
+ }
+
+ // Not own constructor property must be Object
+ if ( obj.constructor &&
+ !hasOwn.call(obj, "constructor") &&
+ !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+
+ var key;
+ for ( key in obj ) {}
+
+ return key === undefined || hasOwn.call( obj, key );
+ },
+
+ isEmptyObject: function( obj ) {
+ for ( var name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ error: function( msg ) {
+ throw msg;
+ },
+
+ parseJSON: function( data ) {
+ if ( typeof data !== "string" || !data ) {
+ return null;
+ }
+
+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
+ data = jQuery.trim( data );
+
+ // Make sure the incoming data is actual JSON
+ // Logic borrowed from http://json.org/json2.js
+ if ( rvalidchars.test(data.replace(rvalidescape, "@")
+ .replace(rvalidtokens, "]")
+ .replace(rvalidbraces, "")) ) {
+
+ // Try to use the native JSON parser first
+ return window.JSON && window.JSON.parse ?
+ window.JSON.parse( data ) :
+ (new Function("return " + data))();
+
+ } else {
+ jQuery.error( "Invalid JSON: " + data );
+ }
+ },
+
+ // Cross-browser xml parsing
+ // (xml & tmp used internally)
+ parseXML: function( data , xml , tmp ) {
+
+ if ( window.DOMParser ) { // Standard
+ tmp = new DOMParser();
+ xml = tmp.parseFromString( data , "text/xml" );
+ } else { // IE
+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
+ xml.async = "false";
+ xml.loadXML( data );
+ }
+
+ tmp = xml.documentElement;
+
+ if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
+ jQuery.error( "Invalid XML: " + data );
+ }
+
+ return xml;
+ },
+
+ noop: function() {},
+
+ // Evalulates a script in a global context
+ globalEval: function( data ) {
+ if ( data && rnotwhite.test(data) ) {
+ // Inspired by code by Andrea Giammarchi
+ // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
+ var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement,
+ script = document.createElement( "script" );
+
+ if ( jQuery.support.scriptEval() ) {
+ script.appendChild( document.createTextNode( data ) );
+ } else {
+ script.text = data;
+ }
+
+ // Use insertBefore instead of appendChild to circumvent an IE6 bug.
+ // This arises when a base node is used (#2709).
+ head.insertBefore( script, head.firstChild );
+ head.removeChild( script );
+ }
+ },
+
+ nodeName: function( elem, name ) {
+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
+ },
+
+ // args is for internal usage only
+ each: function( object, callback, args ) {
+ var name, i = 0,
+ length = object.length,
+ isObj = length === undefined || jQuery.isFunction(object);
+
+ if ( args ) {
+ if ( isObj ) {
+ for ( name in object ) {
+ if ( callback.apply( object[ name ], args ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( ; i < length; ) {
+ if ( callback.apply( object[ i++ ], args ) === false ) {
+ break;
+ }
+ }
+ }
+
+ // A special, fast, case for the most common use of each
+ } else {
+ if ( isObj ) {
+ for ( name in object ) {
+ if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( var value = object[0];
+ i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
+ }
+ }
+
+ return object;
+ },
+
+ // Use native String.trim function wherever possible
+ trim: trim ?
+ function( text ) {
+ return text == null ?
+ "" :
+ trim.call( text );
+ } :
+
+ // Otherwise use our own trimming functionality
+ function( text ) {
+ return text == null ?
+ "" :
+ text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
+ },
+
+ // results is for internal usage only
+ makeArray: function( array, results ) {
+ var ret = results || [];
+
+ if ( array != null ) {
+ // The window, strings (and functions) also have 'length'
+ // The extra typeof function check is to prevent crashes
+ // in Safari 2 (See: #3039)
+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+ var type = jQuery.type(array);
+
+ if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
+ push.call( ret, array );
+ } else {
+ jQuery.merge( ret, array );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, array ) {
+ if ( array.indexOf ) {
+ return array.indexOf( elem );
+ }
+
+ for ( var i = 0, length = array.length; i < length; i++ ) {
+ if ( array[ i ] === elem ) {
+ return i;
+ }
+ }
+
+ return -1;
+ },
+
+ merge: function( first, second ) {
+ var i = first.length,
+ j = 0;
+
+ if ( typeof second.length === "number" ) {
+ for ( var l = second.length; j < l; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+
+ } else {
+ while ( second[j] !== undefined ) {
+ first[ i++ ] = second[ j++ ];
+ }
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, inv ) {
+ var ret = [], retVal;
+ inv = !!inv;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( var i = 0, length = elems.length; i < length; i++ ) {
+ retVal = !!callback( elems[ i ], i );
+ if ( inv !== retVal ) {
+ ret.push( elems[ i ] );
+ }
+ }
+
+ return ret;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var ret = [], value;
+
+ // Go through the array, translating each of the items to their
+ // new value (or values).
+ for ( var i = 0, length = elems.length; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret[ ret.length ] = value;
+ }
+ }
+
+ // Flatten any nested arrays
+ return ret.concat.apply( [], ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ proxy: function( fn, proxy, thisObject ) {
+ if ( arguments.length === 2 ) {
+ if ( typeof proxy === "string" ) {
+ thisObject = fn;
+ fn = thisObject[ proxy ];
+ proxy = undefined;
+
+ } else if ( proxy && !jQuery.isFunction( proxy ) ) {
+ thisObject = proxy;
+ proxy = undefined;
+ }
+ }
+
+ if ( !proxy && fn ) {
+ proxy = function() {
+ return fn.apply( thisObject || this, arguments );
+ };
+ }
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ if ( fn ) {
+ proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
+ }
+
+ // So proxy can be declared as an argument
+ return proxy;
+ },
+
+ // Mutifunctional method to get and set values to a collection
+ // The value/s can be optionally by executed if its a function
+ access: function( elems, key, value, exec, fn, pass ) {
+ var length = elems.length;
+
+ // Setting many attributes
+ if ( typeof key === "object" ) {
+ for ( var k in key ) {
+ jQuery.access( elems, k, key[k], exec, fn, value );
+ }
+ return elems;
+ }
+
+ // Setting one attribute
+ if ( value !== undefined ) {
+ // Optionally, function values get executed if exec is true
+ exec = !pass && exec && jQuery.isFunction(value);
+
+ for ( var i = 0; i < length; i++ ) {
+ fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
+ }
+
+ return elems;
+ }
+
+ // Getting an attribute
+ return length ? fn( elems[0], key ) : undefined;
+ },
+
+ now: function() {
+ return (new Date()).getTime();
+ },
+
+ // Create a simple deferred (one callbacks list)
+ _Deferred: function() {
+ var // callbacks list
+ callbacks = [],
+ // stored [ context , args ]
+ fired,
+ // to avoid firing when already doing so
+ firing,
+ // flag to know if the deferred has been cancelled
+ cancelled,
+ // the deferred itself
+ deferred = {
+
+ // done( f1, f2, ...)
+ done: function() {
+ if ( !cancelled ) {
+ var args = arguments,
+ i,
+ length,
+ elem,
+ type,
+ _fired;
+ if ( fired ) {
+ _fired = fired;
+ fired = 0;
+ }
+ for ( i = 0, length = args.length; i < length; i++ ) {
+ elem = args[ i ];
+ type = jQuery.type( elem );
+ if ( type === "array" ) {
+ deferred.done.apply( deferred, elem );
+ } else if ( type === "function" ) {
+ callbacks.push( elem );
+ }
+ }
+ if ( _fired ) {
+ deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
+ }
+ }
+ return this;
+ },
+
+ // resolve with given context and args
+ resolveWith: function( context, args ) {
+ if ( !cancelled && !fired && !firing ) {
+ firing = 1;
+ try {
+ while( callbacks[ 0 ] ) {
+ callbacks.shift().apply( context, args );
+ }
+ }
+ // We have to add a catch block for
+ // IE prior to 8 or else the finally
+ // block will never get executed
+ catch (e) {
+ throw e;
+ }
+ finally {
+ fired = [ context, args ];
+ firing = 0;
+ }
+ }
+ return this;
+ },
+
+ // resolve with this as context and given arguments
+ resolve: function() {
+ deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
+ return this;
+ },
+
+ // Has this deferred been resolved?
+ isResolved: function() {
+ return !!( firing || fired );
+ },
+
+ // Cancel
+ cancel: function() {
+ cancelled = 1;
+ callbacks = [];
+ return this;
+ }
+ };
+
+ return deferred;
+ },
+
+ // Full fledged deferred (two callbacks list)
+ Deferred: function( func ) {
+ var deferred = jQuery._Deferred(),
+ failDeferred = jQuery._Deferred(),
+ promise;
+ // Add errorDeferred methods, then and promise
+ jQuery.extend( deferred, {
+ then: function( doneCallbacks, failCallbacks ) {
+ deferred.done( doneCallbacks ).fail( failCallbacks );
+ return this;
+ },
+ fail: failDeferred.done,
+ rejectWith: failDeferred.resolveWith,
+ reject: failDeferred.resolve,
+ isRejected: failDeferred.isResolved,
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ if ( obj == null ) {
+ if ( promise ) {
+ return promise;
+ }
+ promise = obj = {};
+ }
+ var i = promiseMethods.length;
+ while( i-- ) {
+ obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
+ }
+ return obj;
+ }
+ } );
+ // Make sure only one callback list will be used
+ deferred.done( failDeferred.cancel ).fail( deferred.cancel );
+ // Unexpose cancel
+ delete deferred.cancel;
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( object ) {
+ var lastIndex = arguments.length,
+ deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ?
+ object :
+ jQuery.Deferred(),
+ promise = deferred.promise();
+
+ if ( lastIndex > 1 ) {
+ var array = slice.call( arguments, 0 ),
+ count = lastIndex,
+ iCallback = function( index ) {
+ return function( value ) {
+ array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
+ if ( !( --count ) ) {
+ deferred.resolveWith( promise, array );
+ }
+ };
+ };
+ while( ( lastIndex-- ) ) {
+ object = array[ lastIndex ];
+ if ( object && jQuery.isFunction( object.promise ) ) {
+ object.promise().then( iCallback(lastIndex), deferred.reject );
+ } else {
+ --count;
+ }
+ }
+ if ( !count ) {
+ deferred.resolveWith( promise, array );
+ }
+ } else if ( deferred !== object ) {
+ deferred.resolve( object );
+ }
+ return promise;
+ },
+
+ // Use of jQuery.browser is frowned upon.
+ // More details: http://docs.jquery.com/Utilities/jQuery.browser
+ uaMatch: function( ua ) {
+ ua = ua.toLowerCase();
+
+ var match = rwebkit.exec( ua ) ||
+ ropera.exec( ua ) ||
+ rmsie.exec( ua ) ||
+ ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
+ [];
+
+ return { browser: match[1] || "", version: match[2] || "0" };
+ },
+
+ sub: function() {
+ function jQuerySubclass( selector, context ) {
+ return new jQuerySubclass.fn.init( selector, context );
+ }
+ jQuery.extend( true, jQuerySubclass, this );
+ jQuerySubclass.superclass = this;
+ jQuerySubclass.fn = jQuerySubclass.prototype = this();
+ jQuerySubclass.fn.constructor = jQuerySubclass;
+ jQuerySubclass.subclass = this.subclass;
+ jQuerySubclass.fn.init = function init( selector, context ) {
+ if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
+ context = jQuerySubclass(context);
+ }
+
+ return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
+ };
+ jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
+ var rootjQuerySubclass = jQuerySubclass(document);
+ return jQuerySubclass;
+ },
+
+ browser: {}
+});
+
+// Create readyList deferred
+readyList = jQuery._Deferred();
+
+// Populate the class2type map
+jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+});
+
+browserMatch = jQuery.uaMatch( userAgent );
+if ( browserMatch.browser ) {
+ jQuery.browser[ browserMatch.browser ] = true;
+ jQuery.browser.version = browserMatch.version;
+}
+
+// Deprecated, use jQuery.browser.webkit instead
+if ( jQuery.browser.webkit ) {
+ jQuery.browser.safari = true;
+}
+
+if ( indexOf ) {
+ jQuery.inArray = function( elem, array ) {
+ return indexOf.call( array, elem );
+ };
+}
+
+// IE doesn't match non-breaking spaces with \s
+if ( rnotwhite.test( "\xA0" ) ) {
+ trimLeft = /^[\s\xA0]+/;
+ trimRight = /[\s\xA0]+$/;
+}
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+
+// Cleanup functions for the document ready method
+if ( document.addEventListener ) {
+ DOMContentLoaded = function() {
+ document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+ jQuery.ready();
+ };
+
+} else if ( document.attachEvent ) {
+ DOMContentLoaded = function() {
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if ( document.readyState === "complete" ) {
+ document.detachEvent( "onreadystatechange", DOMContentLoaded );
+ jQuery.ready();
+ }
+ };
+}
+
+// The DOM ready check for Internet Explorer
+function doScrollCheck() {
+ if ( jQuery.isReady ) {
+ return;
+ }
+
+ try {
+ // If IE is used, use the trick by Diego Perini
+ // http://javascript.nwbox.com/IEContentLoaded/
+ document.documentElement.doScroll("left");
+ } catch(e) {
+ setTimeout( doScrollCheck, 1 );
+ return;
+ }
+
+ // and execute any waiting functions
+ jQuery.ready();
+}
+
+// Expose jQuery to the global object
+return jQuery;
+
+})();
+
+
+(function() {
+
+ jQuery.support = {};
+
+ var div = document.createElement("div");
+
+ div.style.display = "none";
+ div.innerHTML = "
a";
+
+ var all = div.getElementsByTagName("*"),
+ a = div.getElementsByTagName("a")[0],
+ select = document.createElement("select"),
+ opt = select.appendChild( document.createElement("option") ),
+ input = div.getElementsByTagName("input")[0];
+
+ // Can't get basic test support
+ if ( !all || !all.length || !a ) {
+ return;
+ }
+
+ jQuery.support = {
+ // IE strips leading whitespace when .innerHTML is used
+ leadingWhitespace: div.firstChild.nodeType === 3,
+
+ // Make sure that tbody elements aren't automatically inserted
+ // IE will insert them into empty tables
+ tbody: !div.getElementsByTagName("tbody").length,
+
+ // Make sure that link elements get serialized correctly by innerHTML
+ // This requires a wrapper element in IE
+ htmlSerialize: !!div.getElementsByTagName("link").length,
+
+ // Get the style information from getAttribute
+ // (IE uses .cssText insted)
+ style: /red/.test( a.getAttribute("style") ),
+
+ // Make sure that URLs aren't manipulated
+ // (IE normalizes it by default)
+ hrefNormalized: a.getAttribute("href") === "/a",
+
+ // Make sure that element opacity exists
+ // (IE uses filter instead)
+ // Use a regex to work around a WebKit issue. See #5145
+ opacity: /^0.55$/.test( a.style.opacity ),
+
+ // Verify style float existence
+ // (IE uses styleFloat instead of cssFloat)
+ cssFloat: !!a.style.cssFloat,
+
+ // Make sure that if no value is specified for a checkbox
+ // that it defaults to "on".
+ // (WebKit defaults to "" instead)
+ checkOn: input.value === "on",
+
+ // Make sure that a selected-by-default option has a working selected property.
+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+ optSelected: opt.selected,
+
+ // Will be defined later
+ deleteExpando: true,
+ optDisabled: false,
+ checkClone: false,
+ noCloneEvent: true,
+ noCloneChecked: true,
+ boxModel: null,
+ inlineBlockNeedsLayout: false,
+ shrinkWrapBlocks: false,
+ reliableHiddenOffsets: true
+ };
+
+ input.checked = true;
+ jQuery.support.noCloneChecked = input.cloneNode( true ).checked;
+
+ // Make sure that the options inside disabled selects aren't marked as disabled
+ // (WebKit marks them as diabled)
+ select.disabled = true;
+ jQuery.support.optDisabled = !opt.disabled;
+
+ var _scriptEval = null;
+ jQuery.support.scriptEval = function() {
+ if ( _scriptEval === null ) {
+ var root = document.documentElement,
+ script = document.createElement("script"),
+ id = "script" + jQuery.now();
+
+ try {
+ script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
+ } catch(e) {}
+
+ root.insertBefore( script, root.firstChild );
+
+ // Make sure that the execution of code works by injecting a script
+ // tag with appendChild/createTextNode
+ // (IE doesn't support this, fails, and uses .text instead)
+ if ( window[ id ] ) {
+ _scriptEval = true;
+ delete window[ id ];
+ } else {
+ _scriptEval = false;
+ }
+
+ root.removeChild( script );
+ // release memory in IE
+ root = script = id = null;
+ }
+
+ return _scriptEval;
+ };
+
+ // Test to see if it's possible to delete an expando from an element
+ // Fails in Internet Explorer
+ try {
+ delete div.test;
+
+ } catch(e) {
+ jQuery.support.deleteExpando = false;
+ }
+
+ if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
+ div.attachEvent("onclick", function click() {
+ // Cloning a node shouldn't copy over any
+ // bound event handlers (IE does this)
+ jQuery.support.noCloneEvent = false;
+ div.detachEvent("onclick", click);
+ });
+ div.cloneNode(true).fireEvent("onclick");
+ }
+
+ div = document.createElement("div");
+ div.innerHTML = "";
+
+ var fragment = document.createDocumentFragment();
+ fragment.appendChild( div.firstChild );
+
+ // WebKit doesn't clone checked state correctly in fragments
+ jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
+
+ // Figure out if the W3C box model works as expected
+ // document.body must exist before we can do this
+ jQuery(function() {
+ var div = document.createElement("div"),
+ body = document.getElementsByTagName("body")[0];
+
+ // Frameset documents with no body should not run this code
+ if ( !body ) {
+ return;
+ }
+
+ div.style.width = div.style.paddingLeft = "1px";
+ body.appendChild( div );
+ jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
+
+ if ( "zoom" in div.style ) {
+ // Check if natively block-level elements act like inline-block
+ // elements when setting their display to 'inline' and giving
+ // them layout
+ // (IE < 8 does this)
+ div.style.display = "inline";
+ div.style.zoom = 1;
+ jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
+
+ // Check if elements with layout shrink-wrap their children
+ // (IE 6 does this)
+ div.style.display = "";
+ div.innerHTML = "";
+ jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
+ }
+
+ div.innerHTML = "
";
+ var tds = div.getElementsByTagName("td");
+
+ // Check if table cells still have offsetWidth/Height when they are set
+ // to display:none and there are still other visible table cells in a
+ // table row; if so, offsetWidth/Height are not reliable for use when
+ // determining if an element has been hidden directly using
+ // display:none (it is still safe to use offsets if a parent element is
+ // hidden; don safety goggles and see bug #4512 for more information).
+ // (only IE 8 fails this test)
+ jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
+
+ tds[0].style.display = "";
+ tds[1].style.display = "none";
+
+ // Check if empty table cells still have offsetWidth/Height
+ // (IE < 8 fail this test)
+ jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
+ div.innerHTML = "";
+
+ body.removeChild( div ).style.display = "none";
+ div = tds = null;
+ });
+
+ // Technique from Juriy Zaytsev
+ // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+ var eventSupported = function( eventName ) {
+ var el = document.createElement("div");
+ eventName = "on" + eventName;
+
+ // We only care about the case where non-standard event systems
+ // are used, namely in IE. Short-circuiting here helps us to
+ // avoid an eval call (in setAttribute) which can cause CSP
+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+ if ( !el.attachEvent ) {
+ return true;
+ }
+
+ var isSupported = (eventName in el);
+ if ( !isSupported ) {
+ el.setAttribute(eventName, "return;");
+ isSupported = typeof el[eventName] === "function";
+ }
+ el = null;
+
+ return isSupported;
+ };
+
+ jQuery.support.submitBubbles = eventSupported("submit");
+ jQuery.support.changeBubbles = eventSupported("change");
+
+ // release memory in IE
+ div = all = a = null;
+})();
+
+
+
+var rbrace = /^(?:\{.*\}|\[.*\])$/;
+
+jQuery.extend({
+ cache: {},
+
+ // Please use with caution
+ uuid: 0,
+
+ // Unique for each copy of jQuery on the page
+ // Non-digits removed to match rinlinejQuery
+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
+
+ // The following elements throw uncatchable exceptions if you
+ // attempt to add expando properties to them.
+ noData: {
+ "embed": true,
+ // Ban all objects except for Flash (which handle expandos)
+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+ "applet": true
+ },
+
+ hasData: function( elem ) {
+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+
+ return !!elem && !isEmptyDataObject( elem );
+ },
+
+ data: function( elem, name, data, pvt /* Internal Use Only */ ) {
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
+
+ // We have to handle DOM nodes and JS objects differently because IE6-7
+ // can't GC object references properly across the DOM-JS boundary
+ isNode = elem.nodeType,
+
+ // Only DOM nodes need the global jQuery cache; JS object data is
+ // attached directly to the object so GC can occur automatically
+ cache = isNode ? jQuery.cache : elem,
+
+ // Only defining an ID for JS objects if its cache already exists allows
+ // the code to shortcut on the same path as a DOM node with no cache
+ id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
+
+ // Avoid doing any more work than we need to when trying to get data on an
+ // object that has no data at all
+ if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
+ return;
+ }
+
+ if ( !id ) {
+ // Only DOM nodes need a new unique ID for each element since their data
+ // ends up in the global cache
+ if ( isNode ) {
+ elem[ jQuery.expando ] = id = ++jQuery.uuid;
+ } else {
+ id = jQuery.expando;
+ }
+ }
+
+ if ( !cache[ id ] ) {
+ cache[ id ] = {};
+
+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
+ // metadata on plain JS objects when the object is serialized using
+ // JSON.stringify
+ if ( !isNode ) {
+ cache[ id ].toJSON = jQuery.noop;
+ }
+ }
+
+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
+ // shallow copied over onto the existing cache
+ if ( typeof name === "object" || typeof name === "function" ) {
+ if ( pvt ) {
+ cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
+ } else {
+ cache[ id ] = jQuery.extend(cache[ id ], name);
+ }
+ }
+
+ thisCache = cache[ id ];
+
+ // Internal jQuery data is stored in a separate object inside the object's data
+ // cache in order to avoid key collisions between internal data and user-defined
+ // data
+ if ( pvt ) {
+ if ( !thisCache[ internalKey ] ) {
+ thisCache[ internalKey ] = {};
+ }
+
+ thisCache = thisCache[ internalKey ];
+ }
+
+ if ( data !== undefined ) {
+ thisCache[ name ] = data;
+ }
+
+ // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
+ // not attempt to inspect the internal events object using jQuery.data, as this
+ // internal data object is undocumented and subject to change.
+ if ( name === "events" && !thisCache[name] ) {
+ return thisCache[ internalKey ] && thisCache[ internalKey ].events;
+ }
+
+ return getByName ? thisCache[ name ] : thisCache;
+ },
+
+ removeData: function( elem, name, pvt /* Internal Use Only */ ) {
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var internalKey = jQuery.expando, isNode = elem.nodeType,
+
+ // See jQuery.data for more information
+ cache = isNode ? jQuery.cache : elem,
+
+ // See jQuery.data for more information
+ id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+ // If there is already no cache entry for this object, there is no
+ // purpose in continuing
+ if ( !cache[ id ] ) {
+ return;
+ }
+
+ if ( name ) {
+ var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
+
+ if ( thisCache ) {
+ delete thisCache[ name ];
+
+ // If there is no data left in the cache, we want to continue
+ // and let the cache object itself get destroyed
+ if ( !isEmptyDataObject(thisCache) ) {
+ return;
+ }
+ }
+ }
+
+ // See jQuery.data for more information
+ if ( pvt ) {
+ delete cache[ id ][ internalKey ];
+
+ // Don't destroy the parent cache unless the internal data object
+ // had been the only thing left in it
+ if ( !isEmptyDataObject(cache[ id ]) ) {
+ return;
+ }
+ }
+
+ var internalCache = cache[ id ][ internalKey ];
+
+ // Browsers that fail expando deletion also refuse to delete expandos on
+ // the window, but it will allow it on all other JS objects; other browsers
+ // don't care
+ if ( jQuery.support.deleteExpando || cache != window ) {
+ delete cache[ id ];
+ } else {
+ cache[ id ] = null;
+ }
+
+ // We destroyed the entire user cache at once because it's faster than
+ // iterating through each key, but we need to continue to persist internal
+ // data if it existed
+ if ( internalCache ) {
+ cache[ id ] = {};
+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
+ // metadata on plain JS objects when the object is serialized using
+ // JSON.stringify
+ if ( !isNode ) {
+ cache[ id ].toJSON = jQuery.noop;
+ }
+
+ cache[ id ][ internalKey ] = internalCache;
+
+ // Otherwise, we need to eliminate the expando on the node to avoid
+ // false lookups in the cache for entries that no longer exist
+ } else if ( isNode ) {
+ // IE does not allow us to delete expando properties from nodes,
+ // nor does it have a removeAttribute function on Document nodes;
+ // we must handle all of these cases
+ if ( jQuery.support.deleteExpando ) {
+ delete elem[ jQuery.expando ];
+ } else if ( elem.removeAttribute ) {
+ elem.removeAttribute( jQuery.expando );
+ } else {
+ elem[ jQuery.expando ] = null;
+ }
+ }
+ },
+
+ // For internal use only.
+ _data: function( elem, name, data ) {
+ return jQuery.data( elem, name, data, true );
+ },
+
+ // A method for determining if a DOM node can handle the data expando
+ acceptData: function( elem ) {
+ if ( elem.nodeName ) {
+ var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+ if ( match ) {
+ return !(match === true || elem.getAttribute("classid") !== match);
+ }
+ }
+
+ return true;
+ }
+});
+
+jQuery.fn.extend({
+ data: function( key, value ) {
+ var data = null;
+
+ if ( typeof key === "undefined" ) {
+ if ( this.length ) {
+ data = jQuery.data( this[0] );
+
+ if ( this[0].nodeType === 1 ) {
+ var attr = this[0].attributes, name;
+ for ( var i = 0, l = attr.length; i < l; i++ ) {
+ name = attr[i].name;
+
+ if ( name.indexOf( "data-" ) === 0 ) {
+ name = name.substr( 5 );
+ dataAttr( this[0], name, data[ name ] );
+ }
+ }
+ }
+ }
+
+ return data;
+
+ } else if ( typeof key === "object" ) {
+ return this.each(function() {
+ jQuery.data( this, key );
+ });
+ }
+
+ var parts = key.split(".");
+ parts[1] = parts[1] ? "." + parts[1] : "";
+
+ if ( value === undefined ) {
+ data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
+
+ // Try to fetch any internally stored data first
+ if ( data === undefined && this.length ) {
+ data = jQuery.data( this[0], key );
+ data = dataAttr( this[0], key, data );
+ }
+
+ return data === undefined && parts[1] ?
+ this.data( parts[0] ) :
+ data;
+
+ } else {
+ return this.each(function() {
+ var $this = jQuery( this ),
+ args = [ parts[0], value ];
+
+ $this.triggerHandler( "setData" + parts[1] + "!", args );
+ jQuery.data( this, key, value );
+ $this.triggerHandler( "changeData" + parts[1] + "!", args );
+ });
+ }
+ },
+
+ removeData: function( key ) {
+ return this.each(function() {
+ jQuery.removeData( this, key );
+ });
+ }
+});
+
+function dataAttr( elem, key, data ) {
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+ data = elem.getAttribute( "data-" + key );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = data === "true" ? true :
+ data === "false" ? false :
+ data === "null" ? null :
+ !jQuery.isNaN( data ) ? parseFloat( data ) :
+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
+ data;
+ } catch( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ jQuery.data( elem, key, data );
+
+ } else {
+ data = undefined;
+ }
+ }
+
+ return data;
+}
+
+// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
+// property to be considered empty objects; this property always exists in
+// order to make sure JSON.stringify does not expose internal metadata
+function isEmptyDataObject( obj ) {
+ for ( var name in obj ) {
+ if ( name !== "toJSON" ) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+
+
+jQuery.extend({
+ queue: function( elem, type, data ) {
+ if ( !elem ) {
+ return;
+ }
+
+ type = (type || "fx") + "queue";
+ var q = jQuery._data( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( !data ) {
+ return q || [];
+ }
+
+ if ( !q || jQuery.isArray(data) ) {
+ q = jQuery._data( elem, type, jQuery.makeArray(data) );
+
+ } else {
+ q.push( data );
+ }
+
+ return q;
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ fn = queue.shift();
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ }
+
+ if ( fn ) {
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift("inprogress");
+ }
+
+ fn.call(elem, function() {
+ jQuery.dequeue(elem, type);
+ });
+ }
+
+ if ( !queue.length ) {
+ jQuery.removeData( elem, type + "queue", true );
+ }
+ }
+});
+
+jQuery.fn.extend({
+ queue: function( type, data ) {
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ }
+
+ if ( data === undefined ) {
+ return jQuery.queue( this[0], type );
+ }
+ return this.each(function( i ) {
+ var queue = jQuery.queue( this, type, data );
+
+ if ( type === "fx" && queue[0] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ });
+ },
+ dequeue: function( type ) {
+ return this.each(function() {
+ jQuery.dequeue( this, type );
+ });
+ },
+
+ // Based off of the plugin by Clint Helfers, with permission.
+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
+ delay: function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function() {
+ var elem = this;
+ setTimeout(function() {
+ jQuery.dequeue( elem, type );
+ }, time );
+ });
+ },
+
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ }
+});
+
+
+
+
+var rclass = /[\n\t\r]/g,
+ rspaces = /\s+/,
+ rreturn = /\r/g,
+ rspecialurl = /^(?:href|src|style)$/,
+ rtype = /^(?:button|input)$/i,
+ rfocusable = /^(?:button|input|object|select|textarea)$/i,
+ rclickable = /^a(?:rea)?$/i,
+ rradiocheck = /^(?:radio|checkbox)$/i;
+
+jQuery.props = {
+ "for": "htmlFor",
+ "class": "className",
+ readonly: "readOnly",
+ maxlength: "maxLength",
+ cellspacing: "cellSpacing",
+ rowspan: "rowSpan",
+ colspan: "colSpan",
+ tabindex: "tabIndex",
+ usemap: "useMap",
+ frameborder: "frameBorder"
+};
+
+jQuery.fn.extend({
+ attr: function( name, value ) {
+ return jQuery.access( this, name, value, true, jQuery.attr );
+ },
+
+ removeAttr: function( name, fn ) {
+ return this.each(function(){
+ jQuery.attr( this, name, "" );
+ if ( this.nodeType === 1 ) {
+ this.removeAttribute( name );
+ }
+ });
+ },
+
+ addClass: function( value ) {
+ if ( jQuery.isFunction(value) ) {
+ return this.each(function(i) {
+ var self = jQuery(this);
+ self.addClass( value.call(this, i, self.attr("class")) );
+ });
+ }
+
+ if ( value && typeof value === "string" ) {
+ var classNames = (value || "").split( rspaces );
+
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ var elem = this[i];
+
+ if ( elem.nodeType === 1 ) {
+ if ( !elem.className ) {
+ elem.className = value;
+
+ } else {
+ var className = " " + elem.className + " ",
+ setClass = elem.className;
+
+ for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
+ if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
+ setClass += " " + classNames[c];
+ }
+ }
+ elem.className = jQuery.trim( setClass );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ if ( jQuery.isFunction(value) ) {
+ return this.each(function(i) {
+ var self = jQuery(this);
+ self.removeClass( value.call(this, i, self.attr("class")) );
+ });
+ }
+
+ if ( (value && typeof value === "string") || value === undefined ) {
+ var classNames = (value || "").split( rspaces );
+
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ var elem = this[i];
+
+ if ( elem.nodeType === 1 && elem.className ) {
+ if ( value ) {
+ var className = (" " + elem.className + " ").replace(rclass, " ");
+ for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
+ className = className.replace(" " + classNames[c] + " ", " ");
+ }
+ elem.className = jQuery.trim( className );
+
+ } else {
+ elem.className = "";
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value,
+ isBool = typeof stateVal === "boolean";
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function(i) {
+ var self = jQuery(this);
+ self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
+ });
+ }
+
+ return this.each(function() {
+ if ( type === "string" ) {
+ // toggle individual class names
+ var className,
+ i = 0,
+ self = jQuery( this ),
+ state = stateVal,
+ classNames = value.split( rspaces );
+
+ while ( (className = classNames[ i++ ]) ) {
+ // check each className given, space seperated list
+ state = isBool ? state : !self.hasClass( className );
+ self[ state ? "addClass" : "removeClass" ]( className );
+ }
+
+ } else if ( type === "undefined" || type === "boolean" ) {
+ if ( this.className ) {
+ // store className if set
+ jQuery._data( this, "__className__", this.className );
+ }
+
+ // toggle whole className
+ this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+ }
+ });
+ },
+
+ hasClass: function( selector ) {
+ var className = " " + selector + " ";
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ val: function( value ) {
+ if ( !arguments.length ) {
+ var elem = this[0];
+
+ if ( elem ) {
+ if ( jQuery.nodeName( elem, "option" ) ) {
+ // attributes.value is undefined in Blackberry 4.7 but
+ // uses .value. See #6932
+ var val = elem.attributes.value;
+ return !val || val.specified ? elem.value : elem.text;
+ }
+
+ // We need to handle select boxes special
+ if ( jQuery.nodeName( elem, "select" ) ) {
+ var index = elem.selectedIndex,
+ values = [],
+ options = elem.options,
+ one = elem.type === "select-one";
+
+ // Nothing was selected
+ if ( index < 0 ) {
+ return null;
+ }
+
+ // Loop through all the selected options
+ for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
+ var option = options[ i ];
+
+ // Don't return options that are disabled or in a disabled optgroup
+ if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
+ (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
+
+ // Get the specific value for the option
+ value = jQuery(option).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
+ if ( one && !values.length && options.length ) {
+ return jQuery( options[ index ] ).val();
+ }
+
+ return values;
+ }
+
+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+ if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
+ return elem.getAttribute("value") === null ? "on" : elem.value;
+ }
+
+ // Everything else, we just grab the value
+ return (elem.value || "").replace(rreturn, "");
+
+ }
+
+ return undefined;
+ }
+
+ var isFunction = jQuery.isFunction(value);
+
+ return this.each(function(i) {
+ var self = jQuery(this), val = value;
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( isFunction ) {
+ val = value.call(this, i, self.val());
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+ } else if ( typeof val === "number" ) {
+ val += "";
+ } else if ( jQuery.isArray(val) ) {
+ val = jQuery.map(val, function (value) {
+ return value == null ? "" : value + "";
+ });
+ }
+
+ if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
+ this.checked = jQuery.inArray( self.val(), val ) >= 0;
+
+ } else if ( jQuery.nodeName( this, "select" ) ) {
+ var values = jQuery.makeArray(val);
+
+ jQuery( "option", this ).each(function() {
+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+ });
+
+ if ( !values.length ) {
+ this.selectedIndex = -1;
+ }
+
+ } else {
+ this.value = val;
+ }
+ });
+ }
+});
+
+jQuery.extend({
+ attrFn: {
+ val: true,
+ css: true,
+ html: true,
+ text: true,
+ data: true,
+ width: true,
+ height: true,
+ offset: true
+ },
+
+ attr: function( elem, name, value, pass ) {
+ // don't get/set attributes on text, comment and attribute nodes
+ if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
+ return undefined;
+ }
+
+ if ( pass && name in jQuery.attrFn ) {
+ return jQuery(elem)[name](value);
+ }
+
+ var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
+ // Whether we are setting (or getting)
+ set = value !== undefined;
+
+ // Try to normalize/fix the name
+ name = notxml && jQuery.props[ name ] || name;
+
+ // Only do all the following if this is a node (faster for style)
+ if ( elem.nodeType === 1 ) {
+ // These attributes require special treatment
+ var special = rspecialurl.test( name );
+
+ // Safari mis-reports the default selected property of an option
+ // Accessing the parent's selectedIndex property fixes it
+ if ( name === "selected" && !jQuery.support.optSelected ) {
+ var parent = elem.parentNode;
+ if ( parent ) {
+ parent.selectedIndex;
+
+ // Make sure that it also works with optgroups, see #5701
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ }
+
+ // If applicable, access the attribute via the DOM 0 way
+ // 'in' checks fail in Blackberry 4.7 #6931
+ if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
+ if ( set ) {
+ // We can't allow the type property to be changed (since it causes problems in IE)
+ if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
+ jQuery.error( "type property can't be changed" );
+ }
+
+ if ( value === null ) {
+ if ( elem.nodeType === 1 ) {
+ elem.removeAttribute( name );
+ }
+
+ } else {
+ elem[ name ] = value;
+ }
+ }
+
+ // browsers index elements by id/name on forms, give priority to attributes.
+ if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
+ return elem.getAttributeNode( name ).nodeValue;
+ }
+
+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ if ( name === "tabIndex" ) {
+ var attributeNode = elem.getAttributeNode( "tabIndex" );
+
+ return attributeNode && attributeNode.specified ?
+ attributeNode.value :
+ rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+ 0 :
+ undefined;
+ }
+
+ return elem[ name ];
+ }
+
+ if ( !jQuery.support.style && notxml && name === "style" ) {
+ if ( set ) {
+ elem.style.cssText = "" + value;
+ }
+
+ return elem.style.cssText;
+ }
+
+ if ( set ) {
+ // convert the value to a string (all browsers do this but IE) see #1070
+ elem.setAttribute( name, "" + value );
+ }
+
+ // Ensure that missing attributes return undefined
+ // Blackberry 4.7 returns "" from getAttribute #6938
+ if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
+ return undefined;
+ }
+
+ var attr = !jQuery.support.hrefNormalized && notxml && special ?
+ // Some attributes require a special call on IE
+ elem.getAttribute( name, 2 ) :
+ elem.getAttribute( name );
+
+ // Non-existent attributes return null, we normalize to undefined
+ return attr === null ? undefined : attr;
+ }
+ // Handle everything which isn't a DOM element node
+ if ( set ) {
+ elem[ name ] = value;
+ }
+ return elem[ name ];
+ }
+});
+
+
+
+
+var rnamespaces = /\.(.*)$/,
+ rformElems = /^(?:textarea|input|select)$/i,
+ rperiod = /\./g,
+ rspace = / /g,
+ rescape = /[^\w\s.|`]/g,
+ fcleanup = function( nm ) {
+ return nm.replace(rescape, "\\$&");
+ };
+
+/*
+ * A number of helper functions used for managing events.
+ * Many of the ideas behind this code originated from
+ * Dean Edwards' addEvent library.
+ */
+jQuery.event = {
+
+ // Bind an event to an element
+ // Original by Dean Edwards
+ add: function( elem, types, handler, data ) {
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ // TODO :: Use a try/catch until it's safe to pull this out (likely 1.6)
+ // Minor release fix for bug #8018
+ try {
+ // For whatever reason, IE has trouble passing the window object
+ // around, causing it to be cloned in the process
+ if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
+ elem = window;
+ }
+ }
+ catch ( e ) {}
+
+ if ( handler === false ) {
+ handler = returnFalse;
+ } else if ( !handler ) {
+ // Fixes bug #7229. Fix recommended by jdalton
+ return;
+ }
+
+ var handleObjIn, handleObj;
+
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ }
+
+ // Make sure that the function being executed has a unique ID
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure
+ var elemData = jQuery._data( elem );
+
+ // If no elemData is found then we must be trying to bind to one of the
+ // banned noData elements
+ if ( !elemData ) {
+ return;
+ }
+
+ var events = elemData.events,
+ eventHandle = elemData.handle;
+
+ if ( !events ) {
+ elemData.events = events = {};
+ }
+
+ if ( !eventHandle ) {
+ elemData.handle = eventHandle = function() {
+ // Handle the second event of a trigger and when
+ // an event is called after a page has unloaded
+ return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
+ jQuery.event.handle.apply( eventHandle.elem, arguments ) :
+ undefined;
+ };
+ }
+
+ // Add elem as a property of the handle function
+ // This is to prevent a memory leak with non-native events in IE.
+ eventHandle.elem = elem;
+
+ // Handle multiple events separated by a space
+ // jQuery(...).bind("mouseover mouseout", fn);
+ types = types.split(" ");
+
+ var type, i = 0, namespaces;
+
+ while ( (type = types[ i++ ]) ) {
+ handleObj = handleObjIn ?
+ jQuery.extend({}, handleObjIn) :
+ { handler: handler, data: data };
+
+ // Namespaced event handlers
+ if ( type.indexOf(".") > -1 ) {
+ namespaces = type.split(".");
+ type = namespaces.shift();
+ handleObj.namespace = namespaces.slice(0).sort().join(".");
+
+ } else {
+ namespaces = [];
+ handleObj.namespace = "";
+ }
+
+ handleObj.type = type;
+ if ( !handleObj.guid ) {
+ handleObj.guid = handler.guid;
+ }
+
+ // Get the current list of functions bound to this event
+ var handlers = events[ type ],
+ special = jQuery.event.special[ type ] || {};
+
+ // Init the event handler queue
+ if ( !handlers ) {
+ handlers = events[ type ] = [];
+
+ // Check for a special event handler
+ // Only use addEventListener/attachEvent if the special
+ // events handler returns false
+ if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+ // Bind the global event handler to the element
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle, false );
+
+ } else if ( elem.attachEvent ) {
+ elem.attachEvent( "on" + type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add the function to the element's handler list
+ handlers.push( handleObj );
+
+ // Keep track of which events have been used, for global triggering
+ jQuery.event.global[ type ] = true;
+ }
+
+ // Nullify elem to prevent memory leaks in IE
+ elem = null;
+ },
+
+ global: {},
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, pos ) {
+ // don't do events on text and comment nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return;
+ }
+
+ if ( handler === false ) {
+ handler = returnFalse;
+ }
+
+ var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
+ elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
+ events = elemData && elemData.events;
+
+ if ( !elemData || !events ) {
+ return;
+ }
+
+ // types is actually an event object here
+ if ( types && types.type ) {
+ handler = types.handler;
+ types = types.type;
+ }
+
+ // Unbind all events for the element
+ if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
+ types = types || "";
+
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types );
+ }
+
+ return;
+ }
+
+ // Handle multiple events separated by a space
+ // jQuery(...).unbind("mouseover mouseout", fn);
+ types = types.split(" ");
+
+ while ( (type = types[ i++ ]) ) {
+ origType = type;
+ handleObj = null;
+ all = type.indexOf(".") < 0;
+ namespaces = [];
+
+ if ( !all ) {
+ // Namespaced event handlers
+ namespaces = type.split(".");
+ type = namespaces.shift();
+
+ namespace = new RegExp("(^|\\.)" +
+ jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
+ }
+
+ eventType = events[ type ];
+
+ if ( !eventType ) {
+ continue;
+ }
+
+ if ( !handler ) {
+ for ( j = 0; j < eventType.length; j++ ) {
+ handleObj = eventType[ j ];
+
+ if ( all || namespace.test( handleObj.namespace ) ) {
+ jQuery.event.remove( elem, origType, handleObj.handler, j );
+ eventType.splice( j--, 1 );
+ }
+ }
+
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+
+ for ( j = pos || 0; j < eventType.length; j++ ) {
+ handleObj = eventType[ j ];
+
+ if ( handler.guid === handleObj.guid ) {
+ // remove the given handler for the given type
+ if ( all || namespace.test( handleObj.namespace ) ) {
+ if ( pos == null ) {
+ eventType.splice( j--, 1 );
+ }
+
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+
+ if ( pos != null ) {
+ break;
+ }
+ }
+ }
+
+ // remove generic event handler if no more handlers exist
+ if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
+ if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ ret = null;
+ delete events[ type ];
+ }
+ }
+
+ // Remove the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ var handle = elemData.handle;
+ if ( handle ) {
+ handle.elem = null;
+ }
+
+ delete elemData.events;
+ delete elemData.handle;
+
+ if ( jQuery.isEmptyObject( elemData ) ) {
+ jQuery.removeData( elem, undefined, true );
+ }
+ }
+ },
+
+ // bubbling is internal
+ trigger: function( event, data, elem /*, bubbling */ ) {
+ // Event object or event type
+ var type = event.type || event,
+ bubbling = arguments[3];
+
+ if ( !bubbling ) {
+ event = typeof event === "object" ?
+ // jQuery.Event object
+ event[ jQuery.expando ] ? event :
+ // Object literal
+ jQuery.extend( jQuery.Event(type), event ) :
+ // Just the event type (string)
+ jQuery.Event(type);
+
+ if ( type.indexOf("!") >= 0 ) {
+ event.type = type = type.slice(0, -1);
+ event.exclusive = true;
+ }
+
+ // Handle a global trigger
+ if ( !elem ) {
+ // Don't bubble custom events when global (to avoid too much overhead)
+ event.stopPropagation();
+
+ // Only trigger if we've ever bound an event for it
+ if ( jQuery.event.global[ type ] ) {
+ // XXX This code smells terrible. event.js should not be directly
+ // inspecting the data cache
+ jQuery.each( jQuery.cache, function() {
+ // internalKey variable is just used to make it easier to find
+ // and potentially change this stuff later; currently it just
+ // points to jQuery.expando
+ var internalKey = jQuery.expando,
+ internalCache = this[ internalKey ];
+ if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
+ jQuery.event.trigger( event, data, internalCache.handle.elem );
+ }
+ });
+ }
+ }
+
+ // Handle triggering a single element
+
+ // don't do events on text and comment nodes
+ if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
+ return undefined;
+ }
+
+ // Clean up in case it is reused
+ event.result = undefined;
+ event.target = elem;
+
+ // Clone the incoming data, if any
+ data = jQuery.makeArray( data );
+ data.unshift( event );
+ }
+
+ event.currentTarget = elem;
+
+ // Trigger the event, it is assumed that "handle" is a function
+ var handle = jQuery._data( elem, "handle" );
+
+ if ( handle ) {
+ handle.apply( elem, data );
+ }
+
+ var parent = elem.parentNode || elem.ownerDocument;
+
+ // Trigger an inline bound script
+ try {
+ if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
+ if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
+ event.result = false;
+ event.preventDefault();
+ }
+ }
+
+ // prevent IE from throwing an error for some elements with some event types, see #3533
+ } catch (inlineError) {}
+
+ if ( !event.isPropagationStopped() && parent ) {
+ jQuery.event.trigger( event, data, parent, true );
+
+ } else if ( !event.isDefaultPrevented() ) {
+ var old,
+ target = event.target,
+ targetType = type.replace( rnamespaces, "" ),
+ isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
+ special = jQuery.event.special[ targetType ] || {};
+
+ if ( (!special._default || special._default.call( elem, event ) === false) &&
+ !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
+
+ try {
+ if ( target[ targetType ] ) {
+ // Make sure that we don't accidentally re-trigger the onFOO events
+ old = target[ "on" + targetType ];
+
+ if ( old ) {
+ target[ "on" + targetType ] = null;
+ }
+
+ jQuery.event.triggered = true;
+ target[ targetType ]();
+ }
+
+ // prevent IE from throwing an error for some elements with some event types, see #3533
+ } catch (triggerError) {}
+
+ if ( old ) {
+ target[ "on" + targetType ] = old;
+ }
+
+ jQuery.event.triggered = false;
+ }
+ }
+ },
+
+ handle: function( event ) {
+ var all, handlers, namespaces, namespace_re, events,
+ namespace_sort = [],
+ args = jQuery.makeArray( arguments );
+
+ event = args[0] = jQuery.event.fix( event || window.event );
+ event.currentTarget = this;
+
+ // Namespaced event handlers
+ all = event.type.indexOf(".") < 0 && !event.exclusive;
+
+ if ( !all ) {
+ namespaces = event.type.split(".");
+ event.type = namespaces.shift();
+ namespace_sort = namespaces.slice(0).sort();
+ namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
+ }
+
+ event.namespace = event.namespace || namespace_sort.join(".");
+
+ events = jQuery._data(this, "events");
+
+ handlers = (events || {})[ event.type ];
+
+ if ( events && handlers ) {
+ // Clone the handlers to prevent manipulation
+ handlers = handlers.slice(0);
+
+ for ( var j = 0, l = handlers.length; j < l; j++ ) {
+ var handleObj = handlers[ j ];
+
+ // Filter the functions by class
+ if ( all || namespace_re.test( handleObj.namespace ) ) {
+ // Pass in a reference to the handler function itself
+ // So that we can later remove it
+ event.handler = handleObj.handler;
+ event.data = handleObj.data;
+ event.handleObj = handleObj;
+
+ var ret = handleObj.handler.apply( this, args );
+
+ if ( ret !== undefined ) {
+ event.result = ret;
+ if ( ret === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+
+ if ( event.isImmediatePropagationStopped() ) {
+ break;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
+
+ fix: function( event ) {
+ if ( event[ jQuery.expando ] ) {
+ return event;
+ }
+
+ // store a copy of the original event object
+ // and "clone" to set read-only properties
+ var originalEvent = event;
+ event = jQuery.Event( originalEvent );
+
+ for ( var i = this.props.length, prop; i; ) {
+ prop = this.props[ --i ];
+ event[ prop ] = originalEvent[ prop ];
+ }
+
+ // Fix target property, if necessary
+ if ( !event.target ) {
+ // Fixes #1925 where srcElement might not be defined either
+ event.target = event.srcElement || document;
+ }
+
+ // check if target is a textnode (safari)
+ if ( event.target.nodeType === 3 ) {
+ event.target = event.target.parentNode;
+ }
+
+ // Add relatedTarget, if necessary
+ if ( !event.relatedTarget && event.fromElement ) {
+ event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
+ }
+
+ // Calculate pageX/Y if missing and clientX/Y available
+ if ( event.pageX == null && event.clientX != null ) {
+ var doc = document.documentElement,
+ body = document.body;
+
+ event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
+ event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
+ }
+
+ // Add which for key events
+ if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
+ event.which = event.charCode != null ? event.charCode : event.keyCode;
+ }
+
+ // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
+ if ( !event.metaKey && event.ctrlKey ) {
+ event.metaKey = event.ctrlKey;
+ }
+
+ // Add which for click: 1 === left; 2 === middle; 3 === right
+ // Note: button is not normalized, so don't use it
+ if ( !event.which && event.button !== undefined ) {
+ event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
+ }
+
+ return event;
+ },
+
+ // Deprecated, use jQuery.guid instead
+ guid: 1E8,
+
+ // Deprecated, use jQuery.proxy instead
+ proxy: jQuery.proxy,
+
+ special: {
+ ready: {
+ // Make sure the ready event is setup
+ setup: jQuery.bindReady,
+ teardown: jQuery.noop
+ },
+
+ live: {
+ add: function( handleObj ) {
+ jQuery.event.add( this,
+ liveConvert( handleObj.origType, handleObj.selector ),
+ jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
+ },
+
+ remove: function( handleObj ) {
+ jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
+ }
+ },
+
+ beforeunload: {
+ setup: function( data, namespaces, eventHandle ) {
+ // We only want to do this special case on windows
+ if ( jQuery.isWindow( this ) ) {
+ this.onbeforeunload = eventHandle;
+ }
+ },
+
+ teardown: function( namespaces, eventHandle ) {
+ if ( this.onbeforeunload === eventHandle ) {
+ this.onbeforeunload = null;
+ }
+ }
+ }
+ }
+};
+
+jQuery.removeEvent = document.removeEventListener ?
+ function( elem, type, handle ) {
+ if ( elem.removeEventListener ) {
+ elem.removeEventListener( type, handle, false );
+ }
+ } :
+ function( elem, type, handle ) {
+ if ( elem.detachEvent ) {
+ elem.detachEvent( "on" + type, handle );
+ }
+ };
+
+jQuery.Event = function( src ) {
+ // Allow instantiation without the 'new' keyword
+ if ( !this.preventDefault ) {
+ return new jQuery.Event( src );
+ }
+
+ // Event object
+ if ( src && src.type ) {
+ this.originalEvent = src;
+ this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
+ src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
+
+ // Event type
+ } else {
+ this.type = src;
+ }
+
+ // timeStamp is buggy for some events on Firefox(#3843)
+ // So we won't rely on the native value
+ this.timeStamp = jQuery.now();
+
+ // Mark it as fixed
+ this[ jQuery.expando ] = true;
+};
+
+function returnFalse() {
+ return false;
+}
+function returnTrue() {
+ return true;
+}
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+ preventDefault: function() {
+ this.isDefaultPrevented = returnTrue;
+
+ var e = this.originalEvent;
+ if ( !e ) {
+ return;
+ }
+
+ // if preventDefault exists run it on the original event
+ if ( e.preventDefault ) {
+ e.preventDefault();
+
+ // otherwise set the returnValue property of the original event to false (IE)
+ } else {
+ e.returnValue = false;
+ }
+ },
+ stopPropagation: function() {
+ this.isPropagationStopped = returnTrue;
+
+ var e = this.originalEvent;
+ if ( !e ) {
+ return;
+ }
+ // if stopPropagation exists run it on the original event
+ if ( e.stopPropagation ) {
+ e.stopPropagation();
+ }
+ // otherwise set the cancelBubble property of the original event to true (IE)
+ e.cancelBubble = true;
+ },
+ stopImmediatePropagation: function() {
+ this.isImmediatePropagationStopped = returnTrue;
+ this.stopPropagation();
+ },
+ isDefaultPrevented: returnFalse,
+ isPropagationStopped: returnFalse,
+ isImmediatePropagationStopped: returnFalse
+};
+
+// Checks if an event happened on an element within another element
+// Used in jQuery.event.special.mouseenter and mouseleave handlers
+var withinElement = function( event ) {
+ // Check if mouse(over|out) are still within the same parent element
+ var parent = event.relatedTarget;
+
+ // Firefox sometimes assigns relatedTarget a XUL element
+ // which we cannot access the parentNode property of
+ try {
+
+ // Chrome does something similar, the parentNode property
+ // can be accessed but is null.
+ if ( parent !== document && !parent.parentNode ) {
+ return;
+ }
+ // Traverse up the tree
+ while ( parent && parent !== this ) {
+ parent = parent.parentNode;
+ }
+
+ if ( parent !== this ) {
+ // set the correct event type
+ event.type = event.data;
+
+ // handle event if we actually just moused on to a non sub-element
+ jQuery.event.handle.apply( this, arguments );
+ }
+
+ // assuming we've left the element since we most likely mousedover a xul element
+ } catch(e) { }
+},
+
+// In case of event delegation, we only need to rename the event.type,
+// liveHandler will take care of the rest.
+delegate = function( event ) {
+ event.type = event.data;
+ jQuery.event.handle.apply( this, arguments );
+};
+
+// Create mouseenter and mouseleave events
+jQuery.each({
+ mouseenter: "mouseover",
+ mouseleave: "mouseout"
+}, function( orig, fix ) {
+ jQuery.event.special[ orig ] = {
+ setup: function( data ) {
+ jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
+ },
+ teardown: function( data ) {
+ jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
+ }
+ };
+});
+
+// submit delegation
+if ( !jQuery.support.submitBubbles ) {
+
+ jQuery.event.special.submit = {
+ setup: function( data, namespaces ) {
+ if ( this.nodeName && this.nodeName.toLowerCase() !== "form" ) {
+ jQuery.event.add(this, "click.specialSubmit", function( e ) {
+ var elem = e.target,
+ type = elem.type;
+
+ if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
+ trigger( "submit", this, arguments );
+ }
+ });
+
+ jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
+ var elem = e.target,
+ type = elem.type;
+
+ if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
+ trigger( "submit", this, arguments );
+ }
+ });
+
+ } else {
+ return false;
+ }
+ },
+
+ teardown: function( namespaces ) {
+ jQuery.event.remove( this, ".specialSubmit" );
+ }
+ };
+
+}
+
+// change delegation, happens here so we have bind.
+if ( !jQuery.support.changeBubbles ) {
+
+ var changeFilters,
+
+ getVal = function( elem ) {
+ var type = elem.type, val = elem.value;
+
+ if ( type === "radio" || type === "checkbox" ) {
+ val = elem.checked;
+
+ } else if ( type === "select-multiple" ) {
+ val = elem.selectedIndex > -1 ?
+ jQuery.map( elem.options, function( elem ) {
+ return elem.selected;
+ }).join("-") :
+ "";
+
+ } else if ( elem.nodeName.toLowerCase() === "select" ) {
+ val = elem.selectedIndex;
+ }
+
+ return val;
+ },
+
+ testChange = function testChange( e ) {
+ var elem = e.target, data, val;
+
+ if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
+ return;
+ }
+
+ data = jQuery._data( elem, "_change_data" );
+ val = getVal(elem);
+
+ // the current data will be also retrieved by beforeactivate
+ if ( e.type !== "focusout" || elem.type !== "radio" ) {
+ jQuery._data( elem, "_change_data", val );
+ }
+
+ if ( data === undefined || val === data ) {
+ return;
+ }
+
+ if ( data != null || val ) {
+ e.type = "change";
+ e.liveFired = undefined;
+ jQuery.event.trigger( e, arguments[1], elem );
+ }
+ };
+
+ jQuery.event.special.change = {
+ filters: {
+ focusout: testChange,
+
+ beforedeactivate: testChange,
+
+ click: function( e ) {
+ var elem = e.target, type = elem.type;
+
+ if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
+ testChange.call( this, e );
+ }
+ },
+
+ // Change has to be called before submit
+ // Keydown will be called before keypress, which is used in submit-event delegation
+ keydown: function( e ) {
+ var elem = e.target, type = elem.type;
+
+ if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
+ (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
+ type === "select-multiple" ) {
+ testChange.call( this, e );
+ }
+ },
+
+ // Beforeactivate happens also before the previous element is blurred
+ // with this event you can't trigger a change event, but you can store
+ // information
+ beforeactivate: function( e ) {
+ var elem = e.target;
+ jQuery._data( elem, "_change_data", getVal(elem) );
+ }
+ },
+
+ setup: function( data, namespaces ) {
+ if ( this.type === "file" ) {
+ return false;
+ }
+
+ for ( var type in changeFilters ) {
+ jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
+ }
+
+ return rformElems.test( this.nodeName );
+ },
+
+ teardown: function( namespaces ) {
+ jQuery.event.remove( this, ".specialChange" );
+
+ return rformElems.test( this.nodeName );
+ }
+ };
+
+ changeFilters = jQuery.event.special.change.filters;
+
+ // Handle when the input is .focus()'d
+ changeFilters.focus = changeFilters.beforeactivate;
+}
+
+function trigger( type, elem, args ) {
+ // Piggyback on a donor event to simulate a different one.
+ // Fake originalEvent to avoid donor's stopPropagation, but if the
+ // simulated event prevents default then we do the same on the donor.
+ // Don't pass args or remember liveFired; they apply to the donor event.
+ var event = jQuery.extend( {}, args[ 0 ] );
+ event.type = type;
+ event.originalEvent = {};
+ event.liveFired = undefined;
+ jQuery.event.handle.call( elem, event );
+ if ( event.isDefaultPrevented() ) {
+ args[ 0 ].preventDefault();
+ }
+}
+
+// Create "bubbling" focus and blur events
+if ( document.addEventListener ) {
+ jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+ this.addEventListener( orig, handler, true );
+ },
+ teardown: function() {
+ this.removeEventListener( orig, handler, true );
+ }
+ };
+
+ function handler( e ) {
+ e = jQuery.event.fix( e );
+ e.type = fix;
+ return jQuery.event.handle.call( this, e );
+ }
+ });
+}
+
+jQuery.each(["bind", "one"], function( i, name ) {
+ jQuery.fn[ name ] = function( type, data, fn ) {
+ // Handle object literals
+ if ( typeof type === "object" ) {
+ for ( var key in type ) {
+ this[ name ](key, data, type[key], fn);
+ }
+ return this;
+ }
+
+ if ( jQuery.isFunction( data ) || data === false ) {
+ fn = data;
+ data = undefined;
+ }
+
+ var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
+ jQuery( this ).unbind( event, handler );
+ return fn.apply( this, arguments );
+ }) : fn;
+
+ if ( type === "unload" && name !== "one" ) {
+ this.one( type, data, fn );
+
+ } else {
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ jQuery.event.add( this[i], type, handler, data );
+ }
+ }
+
+ return this;
+ };
+});
+
+jQuery.fn.extend({
+ unbind: function( type, fn ) {
+ // Handle object literals
+ if ( typeof type === "object" && !type.preventDefault ) {
+ for ( var key in type ) {
+ this.unbind(key, type[key]);
+ }
+
+ } else {
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ jQuery.event.remove( this[i], type, fn );
+ }
+ }
+
+ return this;
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.live( types, data, fn, selector );
+ },
+
+ undelegate: function( selector, types, fn ) {
+ if ( arguments.length === 0 ) {
+ return this.unbind( "live" );
+
+ } else {
+ return this.die( types, null, fn, selector );
+ }
+ },
+
+ trigger: function( type, data ) {
+ return this.each(function() {
+ jQuery.event.trigger( type, data, this );
+ });
+ },
+
+ triggerHandler: function( type, data ) {
+ if ( this[0] ) {
+ var event = jQuery.Event( type );
+ event.preventDefault();
+ event.stopPropagation();
+ jQuery.event.trigger( event, data, this[0] );
+ return event.result;
+ }
+ },
+
+ toggle: function( fn ) {
+ // Save reference to arguments for access in closure
+ var args = arguments,
+ i = 1;
+
+ // link all the functions, so any of them can unbind this click handler
+ while ( i < args.length ) {
+ jQuery.proxy( fn, args[ i++ ] );
+ }
+
+ return this.click( jQuery.proxy( fn, function( event ) {
+ // Figure out which function to execute
+ var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
+ jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
+
+ // Make sure that clicks stop
+ event.preventDefault();
+
+ // and execute the function
+ return args[ lastToggle ].apply( this, arguments ) || false;
+ }));
+ },
+
+ hover: function( fnOver, fnOut ) {
+ return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+ }
+});
+
+var liveMap = {
+ focus: "focusin",
+ blur: "focusout",
+ mouseenter: "mouseover",
+ mouseleave: "mouseout"
+};
+
+jQuery.each(["live", "die"], function( i, name ) {
+ jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
+ var type, i = 0, match, namespaces, preType,
+ selector = origSelector || this.selector,
+ context = origSelector ? this : jQuery( this.context );
+
+ if ( typeof types === "object" && !types.preventDefault ) {
+ for ( var key in types ) {
+ context[ name ]( key, data, types[key], selector );
+ }
+
+ return this;
+ }
+
+ if ( jQuery.isFunction( data ) ) {
+ fn = data;
+ data = undefined;
+ }
+
+ types = (types || "").split(" ");
+
+ while ( (type = types[ i++ ]) != null ) {
+ match = rnamespaces.exec( type );
+ namespaces = "";
+
+ if ( match ) {
+ namespaces = match[0];
+ type = type.replace( rnamespaces, "" );
+ }
+
+ if ( type === "hover" ) {
+ types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
+ continue;
+ }
+
+ preType = type;
+
+ if ( type === "focus" || type === "blur" ) {
+ types.push( liveMap[ type ] + namespaces );
+ type = type + namespaces;
+
+ } else {
+ type = (liveMap[ type ] || type) + namespaces;
+ }
+
+ if ( name === "live" ) {
+ // bind live handler
+ for ( var j = 0, l = context.length; j < l; j++ ) {
+ jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
+ { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
+ }
+
+ } else {
+ // unbind live handler
+ context.unbind( "live." + liveConvert( type, selector ), fn );
+ }
+ }
+
+ return this;
+ };
+});
+
+function liveHandler( event ) {
+ var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
+ elems = [],
+ selectors = [],
+ events = jQuery._data( this, "events" );
+
+ // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
+ if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
+ return;
+ }
+
+ if ( event.namespace ) {
+ namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
+ }
+
+ event.liveFired = this;
+
+ var live = events.live.slice(0);
+
+ for ( j = 0; j < live.length; j++ ) {
+ handleObj = live[j];
+
+ if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
+ selectors.push( handleObj.selector );
+
+ } else {
+ live.splice( j--, 1 );
+ }
+ }
+
+ match = jQuery( event.target ).closest( selectors, event.currentTarget );
+
+ for ( i = 0, l = match.length; i < l; i++ ) {
+ close = match[i];
+
+ for ( j = 0; j < live.length; j++ ) {
+ handleObj = live[j];
+
+ if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
+ elem = close.elem;
+ related = null;
+
+ // Those two events require additional checking
+ if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
+ event.type = handleObj.preType;
+ related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
+ }
+
+ if ( !related || related !== elem ) {
+ elems.push({ elem: elem, handleObj: handleObj, level: close.level });
+ }
+ }
+ }
+ }
+
+ for ( i = 0, l = elems.length; i < l; i++ ) {
+ match = elems[i];
+
+ if ( maxLevel && match.level > maxLevel ) {
+ break;
+ }
+
+ event.currentTarget = match.elem;
+ event.data = match.handleObj.data;
+ event.handleObj = match.handleObj;
+
+ ret = match.handleObj.origHandler.apply( match.elem, arguments );
+
+ if ( ret === false || event.isPropagationStopped() ) {
+ maxLevel = match.level;
+
+ if ( ret === false ) {
+ stop = false;
+ }
+ if ( event.isImmediatePropagationStopped() ) {
+ break;
+ }
+ }
+ }
+
+ return stop;
+}
+
+function liveConvert( type, selector ) {
+ return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
+}
+
+jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+ "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
+
+ // Handle event binding
+ jQuery.fn[ name ] = function( data, fn ) {
+ if ( fn == null ) {
+ fn = data;
+ data = null;
+ }
+
+ return arguments.length > 0 ?
+ this.bind( name, data, fn ) :
+ this.trigger( name );
+ };
+
+ if ( jQuery.attrFn ) {
+ jQuery.attrFn[ name ] = true;
+ }
+});
+
+
+/*!
+ * Sizzle CSS Selector Engine
+ * Copyright 2011, The Dojo Foundation
+ * Released under the MIT, BSD, and GPL Licenses.
+ * More information: http://sizzlejs.com/
+ */
+(function(){
+
+var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
+ done = 0,
+ toString = Object.prototype.toString,
+ hasDuplicate = false,
+ baseHasDuplicate = true,
+ rBackslash = /\\/g,
+ rNonWord = /\W/;
+
+// Here we check if the JavaScript engine is using some sort of
+// optimization where it does not always call our comparision
+// function. If that is the case, discard the hasDuplicate value.
+// Thus far that includes Google Chrome.
+[0, 0].sort(function() {
+ baseHasDuplicate = false;
+ return 0;
+});
+
+var Sizzle = function( selector, context, results, seed ) {
+ results = results || [];
+ context = context || document;
+
+ var origContext = context;
+
+ if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
+ return [];
+ }
+
+ if ( !selector || typeof selector !== "string" ) {
+ return results;
+ }
+
+ var m, set, checkSet, extra, ret, cur, pop, i,
+ prune = true,
+ contextXML = Sizzle.isXML( context ),
+ parts = [],
+ soFar = selector;
+
+ // Reset the position of the chunker regexp (start from head)
+ do {
+ chunker.exec( "" );
+ m = chunker.exec( soFar );
+
+ if ( m ) {
+ soFar = m[3];
+
+ parts.push( m[1] );
+
+ if ( m[2] ) {
+ extra = m[3];
+ break;
+ }
+ }
+ } while ( m );
+
+ if ( parts.length > 1 && origPOS.exec( selector ) ) {
+
+ if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
+ set = posProcess( parts[0] + parts[1], context );
+
+ } else {
+ set = Expr.relative[ parts[0] ] ?
+ [ context ] :
+ Sizzle( parts.shift(), context );
+
+ while ( parts.length ) {
+ selector = parts.shift();
+
+ if ( Expr.relative[ selector ] ) {
+ selector += parts.shift();
+ }
+
+ set = posProcess( selector, set );
+ }
+ }
+
+ } else {
+ // Take a shortcut and set the context if the root selector is an ID
+ // (but not if it'll be faster if the inner selector is an ID)
+ if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
+ Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
+
+ ret = Sizzle.find( parts.shift(), context, contextXML );
+ context = ret.expr ?
+ Sizzle.filter( ret.expr, ret.set )[0] :
+ ret.set[0];
+ }
+
+ if ( context ) {
+ ret = seed ?
+ { expr: parts.pop(), set: makeArray(seed) } :
+ Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
+
+ set = ret.expr ?
+ Sizzle.filter( ret.expr, ret.set ) :
+ ret.set;
+
+ if ( parts.length > 0 ) {
+ checkSet = makeArray( set );
+
+ } else {
+ prune = false;
+ }
+
+ while ( parts.length ) {
+ cur = parts.pop();
+ pop = cur;
+
+ if ( !Expr.relative[ cur ] ) {
+ cur = "";
+ } else {
+ pop = parts.pop();
+ }
+
+ if ( pop == null ) {
+ pop = context;
+ }
+
+ Expr.relative[ cur ]( checkSet, pop, contextXML );
+ }
+
+ } else {
+ checkSet = parts = [];
+ }
+ }
+
+ if ( !checkSet ) {
+ checkSet = set;
+ }
+
+ if ( !checkSet ) {
+ Sizzle.error( cur || selector );
+ }
+
+ if ( toString.call(checkSet) === "[object Array]" ) {
+ if ( !prune ) {
+ results.push.apply( results, checkSet );
+
+ } else if ( context && context.nodeType === 1 ) {
+ for ( i = 0; checkSet[i] != null; i++ ) {
+ if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
+ results.push( set[i] );
+ }
+ }
+
+ } else {
+ for ( i = 0; checkSet[i] != null; i++ ) {
+ if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
+ results.push( set[i] );
+ }
+ }
+ }
+
+ } else {
+ makeArray( checkSet, results );
+ }
+
+ if ( extra ) {
+ Sizzle( extra, origContext, results, seed );
+ Sizzle.uniqueSort( results );
+ }
+
+ return results;
+};
+
+Sizzle.uniqueSort = function( results ) {
+ if ( sortOrder ) {
+ hasDuplicate = baseHasDuplicate;
+ results.sort( sortOrder );
+
+ if ( hasDuplicate ) {
+ for ( var i = 1; i < results.length; i++ ) {
+ if ( results[i] === results[ i - 1 ] ) {
+ results.splice( i--, 1 );
+ }
+ }
+ }
+ }
+
+ return results;
+};
+
+Sizzle.matches = function( expr, set ) {
+ return Sizzle( expr, null, null, set );
+};
+
+Sizzle.matchesSelector = function( node, expr ) {
+ return Sizzle( expr, null, null, [node] ).length > 0;
+};
+
+Sizzle.find = function( expr, context, isXML ) {
+ var set;
+
+ if ( !expr ) {
+ return [];
+ }
+
+ for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
+ var match,
+ type = Expr.order[i];
+
+ if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
+ var left = match[1];
+ match.splice( 1, 1 );
+
+ if ( left.substr( left.length - 1 ) !== "\\" ) {
+ match[1] = (match[1] || "").replace( rBackslash, "" );
+ set = Expr.find[ type ]( match, context, isXML );
+
+ if ( set != null ) {
+ expr = expr.replace( Expr.match[ type ], "" );
+ break;
+ }
+ }
+ }
+ }
+
+ if ( !set ) {
+ set = typeof context.getElementsByTagName !== "undefined" ?
+ context.getElementsByTagName( "*" ) :
+ [];
+ }
+
+ return { set: set, expr: expr };
+};
+
+Sizzle.filter = function( expr, set, inplace, not ) {
+ var match, anyFound,
+ old = expr,
+ result = [],
+ curLoop = set,
+ isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
+
+ while ( expr && set.length ) {
+ for ( var type in Expr.filter ) {
+ if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
+ var found, item,
+ filter = Expr.filter[ type ],
+ left = match[1];
+
+ anyFound = false;
+
+ match.splice(1,1);
+
+ if ( left.substr( left.length - 1 ) === "\\" ) {
+ continue;
+ }
+
+ if ( curLoop === result ) {
+ result = [];
+ }
+
+ if ( Expr.preFilter[ type ] ) {
+ match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
+
+ if ( !match ) {
+ anyFound = found = true;
+
+ } else if ( match === true ) {
+ continue;
+ }
+ }
+
+ if ( match ) {
+ for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
+ if ( item ) {
+ found = filter( item, match, i, curLoop );
+ var pass = not ^ !!found;
+
+ if ( inplace && found != null ) {
+ if ( pass ) {
+ anyFound = true;
+
+ } else {
+ curLoop[i] = false;
+ }
+
+ } else if ( pass ) {
+ result.push( item );
+ anyFound = true;
+ }
+ }
+ }
+ }
+
+ if ( found !== undefined ) {
+ if ( !inplace ) {
+ curLoop = result;
+ }
+
+ expr = expr.replace( Expr.match[ type ], "" );
+
+ if ( !anyFound ) {
+ return [];
+ }
+
+ break;
+ }
+ }
+ }
+
+ // Improper expression
+ if ( expr === old ) {
+ if ( anyFound == null ) {
+ Sizzle.error( expr );
+
+ } else {
+ break;
+ }
+ }
+
+ old = expr;
+ }
+
+ return curLoop;
+};
+
+Sizzle.error = function( msg ) {
+ throw "Syntax error, unrecognized expression: " + msg;
+};
+
+var Expr = Sizzle.selectors = {
+ order: [ "ID", "NAME", "TAG" ],
+
+ match: {
+ ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
+ CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
+ NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
+ ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
+ TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
+ CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
+ POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
+ PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
+ },
+
+ leftMatch: {},
+
+ attrMap: {
+ "class": "className",
+ "for": "htmlFor"
+ },
+
+ attrHandle: {
+ href: function( elem ) {
+ return elem.getAttribute( "href" );
+ },
+ type: function( elem ) {
+ return elem.getAttribute( "type" );
+ }
+ },
+
+ relative: {
+ "+": function(checkSet, part){
+ var isPartStr = typeof part === "string",
+ isTag = isPartStr && !rNonWord.test( part ),
+ isPartStrNotTag = isPartStr && !isTag;
+
+ if ( isTag ) {
+ part = part.toLowerCase();
+ }
+
+ for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
+ if ( (elem = checkSet[i]) ) {
+ while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
+
+ checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
+ elem || false :
+ elem === part;
+ }
+ }
+
+ if ( isPartStrNotTag ) {
+ Sizzle.filter( part, checkSet, true );
+ }
+ },
+
+ ">": function( checkSet, part ) {
+ var elem,
+ isPartStr = typeof part === "string",
+ i = 0,
+ l = checkSet.length;
+
+ if ( isPartStr && !rNonWord.test( part ) ) {
+ part = part.toLowerCase();
+
+ for ( ; i < l; i++ ) {
+ elem = checkSet[i];
+
+ if ( elem ) {
+ var parent = elem.parentNode;
+ checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
+ }
+ }
+
+ } else {
+ for ( ; i < l; i++ ) {
+ elem = checkSet[i];
+
+ if ( elem ) {
+ checkSet[i] = isPartStr ?
+ elem.parentNode :
+ elem.parentNode === part;
+ }
+ }
+
+ if ( isPartStr ) {
+ Sizzle.filter( part, checkSet, true );
+ }
+ }
+ },
+
+ "": function(checkSet, part, isXML){
+ var nodeCheck,
+ doneName = done++,
+ checkFn = dirCheck;
+
+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
+ part = part.toLowerCase();
+ nodeCheck = part;
+ checkFn = dirNodeCheck;
+ }
+
+ checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
+ },
+
+ "~": function( checkSet, part, isXML ) {
+ var nodeCheck,
+ doneName = done++,
+ checkFn = dirCheck;
+
+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
+ part = part.toLowerCase();
+ nodeCheck = part;
+ checkFn = dirNodeCheck;
+ }
+
+ checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
+ }
+ },
+
+ find: {
+ ID: function( match, context, isXML ) {
+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
+ var m = context.getElementById(match[1]);
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ return m && m.parentNode ? [m] : [];
+ }
+ },
+
+ NAME: function( match, context ) {
+ if ( typeof context.getElementsByName !== "undefined" ) {
+ var ret = [],
+ results = context.getElementsByName( match[1] );
+
+ for ( var i = 0, l = results.length; i < l; i++ ) {
+ if ( results[i].getAttribute("name") === match[1] ) {
+ ret.push( results[i] );
+ }
+ }
+
+ return ret.length === 0 ? null : ret;
+ }
+ },
+
+ TAG: function( match, context ) {
+ if ( typeof context.getElementsByTagName !== "undefined" ) {
+ return context.getElementsByTagName( match[1] );
+ }
+ }
+ },
+ preFilter: {
+ CLASS: function( match, curLoop, inplace, result, not, isXML ) {
+ match = " " + match[1].replace( rBackslash, "" ) + " ";
+
+ if ( isXML ) {
+ return match;
+ }
+
+ for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
+ if ( elem ) {
+ if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
+ if ( !inplace ) {
+ result.push( elem );
+ }
+
+ } else if ( inplace ) {
+ curLoop[i] = false;
+ }
+ }
+ }
+
+ return false;
+ },
+
+ ID: function( match ) {
+ return match[1].replace( rBackslash, "" );
+ },
+
+ TAG: function( match, curLoop ) {
+ return match[1].replace( rBackslash, "" ).toLowerCase();
+ },
+
+ CHILD: function( match ) {
+ if ( match[1] === "nth" ) {
+ if ( !match[2] ) {
+ Sizzle.error( match[0] );
+ }
+
+ match[2] = match[2].replace(/^\+|\s*/g, '');
+
+ // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
+ var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
+ match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
+ !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
+
+ // calculate the numbers (first)n+(last) including if they are negative
+ match[2] = (test[1] + (test[2] || 1)) - 0;
+ match[3] = test[3] - 0;
+ }
+ else if ( match[2] ) {
+ Sizzle.error( match[0] );
+ }
+
+ // TODO: Move to normal caching system
+ match[0] = done++;
+
+ return match;
+ },
+
+ ATTR: function( match, curLoop, inplace, result, not, isXML ) {
+ var name = match[1] = match[1].replace( rBackslash, "" );
+
+ if ( !isXML && Expr.attrMap[name] ) {
+ match[1] = Expr.attrMap[name];
+ }
+
+ // Handle if an un-quoted value was used
+ match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
+
+ if ( match[2] === "~=" ) {
+ match[4] = " " + match[4] + " ";
+ }
+
+ return match;
+ },
+
+ PSEUDO: function( match, curLoop, inplace, result, not ) {
+ if ( match[1] === "not" ) {
+ // If we're dealing with a complex expression, or a simple one
+ if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
+ match[3] = Sizzle(match[3], null, null, curLoop);
+
+ } else {
+ var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
+
+ if ( !inplace ) {
+ result.push.apply( result, ret );
+ }
+
+ return false;
+ }
+
+ } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
+ return true;
+ }
+
+ return match;
+ },
+
+ POS: function( match ) {
+ match.unshift( true );
+
+ return match;
+ }
+ },
+
+ filters: {
+ enabled: function( elem ) {
+ return elem.disabled === false && elem.type !== "hidden";
+ },
+
+ disabled: function( elem ) {
+ return elem.disabled === true;
+ },
+
+ checked: function( elem ) {
+ return elem.checked === true;
+ },
+
+ selected: function( elem ) {
+ // Accessing this property makes selected-by-default
+ // options in Safari work properly
+ if ( elem.parentNode ) {
+ elem.parentNode.selectedIndex;
+ }
+
+ return elem.selected === true;
+ },
+
+ parent: function( elem ) {
+ return !!elem.firstChild;
+ },
+
+ empty: function( elem ) {
+ return !elem.firstChild;
+ },
+
+ has: function( elem, i, match ) {
+ return !!Sizzle( match[3], elem ).length;
+ },
+
+ header: function( elem ) {
+ return (/h\d/i).test( elem.nodeName );
+ },
+
+ text: function( elem ) {
+ // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
+ // use getAttribute instead to test this case
+ return "text" === elem.getAttribute( 'type' );
+ },
+ radio: function( elem ) {
+ return "radio" === elem.type;
+ },
+
+ checkbox: function( elem ) {
+ return "checkbox" === elem.type;
+ },
+
+ file: function( elem ) {
+ return "file" === elem.type;
+ },
+ password: function( elem ) {
+ return "password" === elem.type;
+ },
+
+ submit: function( elem ) {
+ return "submit" === elem.type;
+ },
+
+ image: function( elem ) {
+ return "image" === elem.type;
+ },
+
+ reset: function( elem ) {
+ return "reset" === elem.type;
+ },
+
+ button: function( elem ) {
+ return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
+ },
+
+ input: function( elem ) {
+ return (/input|select|textarea|button/i).test( elem.nodeName );
+ }
+ },
+ setFilters: {
+ first: function( elem, i ) {
+ return i === 0;
+ },
+
+ last: function( elem, i, match, array ) {
+ return i === array.length - 1;
+ },
+
+ even: function( elem, i ) {
+ return i % 2 === 0;
+ },
+
+ odd: function( elem, i ) {
+ return i % 2 === 1;
+ },
+
+ lt: function( elem, i, match ) {
+ return i < match[3] - 0;
+ },
+
+ gt: function( elem, i, match ) {
+ return i > match[3] - 0;
+ },
+
+ nth: function( elem, i, match ) {
+ return match[3] - 0 === i;
+ },
+
+ eq: function( elem, i, match ) {
+ return match[3] - 0 === i;
+ }
+ },
+ filter: {
+ PSEUDO: function( elem, match, i, array ) {
+ var name = match[1],
+ filter = Expr.filters[ name ];
+
+ if ( filter ) {
+ return filter( elem, i, match, array );
+
+ } else if ( name === "contains" ) {
+ return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
+
+ } else if ( name === "not" ) {
+ var not = match[3];
+
+ for ( var j = 0, l = not.length; j < l; j++ ) {
+ if ( not[j] === elem ) {
+ return false;
+ }
+ }
+
+ return true;
+
+ } else {
+ Sizzle.error( name );
+ }
+ },
+
+ CHILD: function( elem, match ) {
+ var type = match[1],
+ node = elem;
+
+ switch ( type ) {
+ case "only":
+ case "first":
+ while ( (node = node.previousSibling) ) {
+ if ( node.nodeType === 1 ) {
+ return false;
+ }
+ }
+
+ if ( type === "first" ) {
+ return true;
+ }
+
+ node = elem;
+
+ case "last":
+ while ( (node = node.nextSibling) ) {
+ if ( node.nodeType === 1 ) {
+ return false;
+ }
+ }
+
+ return true;
+
+ case "nth":
+ var first = match[2],
+ last = match[3];
+
+ if ( first === 1 && last === 0 ) {
+ return true;
+ }
+
+ var doneName = match[0],
+ parent = elem.parentNode;
+
+ if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
+ var count = 0;
+
+ for ( node = parent.firstChild; node; node = node.nextSibling ) {
+ if ( node.nodeType === 1 ) {
+ node.nodeIndex = ++count;
+ }
+ }
+
+ parent.sizcache = doneName;
+ }
+
+ var diff = elem.nodeIndex - last;
+
+ if ( first === 0 ) {
+ return diff === 0;
+
+ } else {
+ return ( diff % first === 0 && diff / first >= 0 );
+ }
+ }
+ },
+
+ ID: function( elem, match ) {
+ return elem.nodeType === 1 && elem.getAttribute("id") === match;
+ },
+
+ TAG: function( elem, match ) {
+ return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
+ },
+
+ CLASS: function( elem, match ) {
+ return (" " + (elem.className || elem.getAttribute("class")) + " ")
+ .indexOf( match ) > -1;
+ },
+
+ ATTR: function( elem, match ) {
+ var name = match[1],
+ result = Expr.attrHandle[ name ] ?
+ Expr.attrHandle[ name ]( elem ) :
+ elem[ name ] != null ?
+ elem[ name ] :
+ elem.getAttribute( name ),
+ value = result + "",
+ type = match[2],
+ check = match[4];
+
+ return result == null ?
+ type === "!=" :
+ type === "=" ?
+ value === check :
+ type === "*=" ?
+ value.indexOf(check) >= 0 :
+ type === "~=" ?
+ (" " + value + " ").indexOf(check) >= 0 :
+ !check ?
+ value && result !== false :
+ type === "!=" ?
+ value !== check :
+ type === "^=" ?
+ value.indexOf(check) === 0 :
+ type === "$=" ?
+ value.substr(value.length - check.length) === check :
+ type === "|=" ?
+ value === check || value.substr(0, check.length + 1) === check + "-" :
+ false;
+ },
+
+ POS: function( elem, match, i, array ) {
+ var name = match[2],
+ filter = Expr.setFilters[ name ];
+
+ if ( filter ) {
+ return filter( elem, i, match, array );
+ }
+ }
+ }
+};
+
+var origPOS = Expr.match.POS,
+ fescape = function(all, num){
+ return "\\" + (num - 0 + 1);
+ };
+
+for ( var type in Expr.match ) {
+ Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
+ Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
+}
+
+var makeArray = function( array, results ) {
+ array = Array.prototype.slice.call( array, 0 );
+
+ if ( results ) {
+ results.push.apply( results, array );
+ return results;
+ }
+
+ return array;
+};
+
+// Perform a simple check to determine if the browser is capable of
+// converting a NodeList to an array using builtin methods.
+// Also verifies that the returned array holds DOM nodes
+// (which is not the case in the Blackberry browser)
+try {
+ Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
+
+// Provide a fallback method if it does not work
+} catch( e ) {
+ makeArray = function( array, results ) {
+ var i = 0,
+ ret = results || [];
+
+ if ( toString.call(array) === "[object Array]" ) {
+ Array.prototype.push.apply( ret, array );
+
+ } else {
+ if ( typeof array.length === "number" ) {
+ for ( var l = array.length; i < l; i++ ) {
+ ret.push( array[i] );
+ }
+
+ } else {
+ for ( ; array[i]; i++ ) {
+ ret.push( array[i] );
+ }
+ }
+ }
+
+ return ret;
+ };
+}
+
+var sortOrder, siblingCheck;
+
+if ( document.documentElement.compareDocumentPosition ) {
+ sortOrder = function( a, b ) {
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
+ return a.compareDocumentPosition ? -1 : 1;
+ }
+
+ return a.compareDocumentPosition(b) & 4 ? -1 : 1;
+ };
+
+} else {
+ sortOrder = function( a, b ) {
+ var al, bl,
+ ap = [],
+ bp = [],
+ aup = a.parentNode,
+ bup = b.parentNode,
+ cur = aup;
+
+ // The nodes are identical, we can exit early
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+
+ // If the nodes are siblings (or identical) we can do a quick check
+ } else if ( aup === bup ) {
+ return siblingCheck( a, b );
+
+ // If no parents were found then the nodes are disconnected
+ } else if ( !aup ) {
+ return -1;
+
+ } else if ( !bup ) {
+ return 1;
+ }
+
+ // Otherwise they're somewhere else in the tree so we need
+ // to build up a full list of the parentNodes for comparison
+ while ( cur ) {
+ ap.unshift( cur );
+ cur = cur.parentNode;
+ }
+
+ cur = bup;
+
+ while ( cur ) {
+ bp.unshift( cur );
+ cur = cur.parentNode;
+ }
+
+ al = ap.length;
+ bl = bp.length;
+
+ // Start walking down the tree looking for a discrepancy
+ for ( var i = 0; i < al && i < bl; i++ ) {
+ if ( ap[i] !== bp[i] ) {
+ return siblingCheck( ap[i], bp[i] );
+ }
+ }
+
+ // We ended someplace up the tree so do a sibling check
+ return i === al ?
+ siblingCheck( a, bp[i], -1 ) :
+ siblingCheck( ap[i], b, 1 );
+ };
+
+ siblingCheck = function( a, b, ret ) {
+ if ( a === b ) {
+ return ret;
+ }
+
+ var cur = a.nextSibling;
+
+ while ( cur ) {
+ if ( cur === b ) {
+ return -1;
+ }
+
+ cur = cur.nextSibling;
+ }
+
+ return 1;
+ };
+}
+
+// Utility function for retreiving the text value of an array of DOM nodes
+Sizzle.getText = function( elems ) {
+ var ret = "", elem;
+
+ for ( var i = 0; elems[i]; i++ ) {
+ elem = elems[i];
+
+ // Get the text from text nodes and CDATA nodes
+ if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
+ ret += elem.nodeValue;
+
+ // Traverse everything else, except comment nodes
+ } else if ( elem.nodeType !== 8 ) {
+ ret += Sizzle.getText( elem.childNodes );
+ }
+ }
+
+ return ret;
+};
+
+// Check to see if the browser returns elements by name when
+// querying by getElementById (and provide a workaround)
+(function(){
+ // We're going to inject a fake input element with a specified name
+ var form = document.createElement("div"),
+ id = "script" + (new Date()).getTime(),
+ root = document.documentElement;
+
+ form.innerHTML = "";
+
+ // Inject it into the root element, check its status, and remove it quickly
+ root.insertBefore( form, root.firstChild );
+
+ // The workaround has to do additional checks after a getElementById
+ // Which slows things down for other browsers (hence the branching)
+ if ( document.getElementById( id ) ) {
+ Expr.find.ID = function( match, context, isXML ) {
+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
+ var m = context.getElementById(match[1]);
+
+ return m ?
+ m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
+ [m] :
+ undefined :
+ [];
+ }
+ };
+
+ Expr.filter.ID = function( elem, match ) {
+ var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
+
+ return elem.nodeType === 1 && node && node.nodeValue === match;
+ };
+ }
+
+ root.removeChild( form );
+
+ // release memory in IE
+ root = form = null;
+})();
+
+(function(){
+ // Check to see if the browser returns only elements
+ // when doing getElementsByTagName("*")
+
+ // Create a fake element
+ var div = document.createElement("div");
+ div.appendChild( document.createComment("") );
+
+ // Make sure no comments are found
+ if ( div.getElementsByTagName("*").length > 0 ) {
+ Expr.find.TAG = function( match, context ) {
+ var results = context.getElementsByTagName( match[1] );
+
+ // Filter out possible comments
+ if ( match[1] === "*" ) {
+ var tmp = [];
+
+ for ( var i = 0; results[i]; i++ ) {
+ if ( results[i].nodeType === 1 ) {
+ tmp.push( results[i] );
+ }
+ }
+
+ results = tmp;
+ }
+
+ return results;
+ };
+ }
+
+ // Check to see if an attribute returns normalized href attributes
+ div.innerHTML = "";
+
+ if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
+ div.firstChild.getAttribute("href") !== "#" ) {
+
+ Expr.attrHandle.href = function( elem ) {
+ return elem.getAttribute( "href", 2 );
+ };
+ }
+
+ // release memory in IE
+ div = null;
+})();
+
+if ( document.querySelectorAll ) {
+ (function(){
+ var oldSizzle = Sizzle,
+ div = document.createElement("div"),
+ id = "__sizzle__";
+
+ div.innerHTML = "";
+
+ // Safari can't handle uppercase or unicode characters when
+ // in quirks mode.
+ if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
+ return;
+ }
+
+ Sizzle = function( query, context, extra, seed ) {
+ context = context || document;
+
+ // Only use querySelectorAll on non-XML documents
+ // (ID selectors don't work in non-HTML documents)
+ if ( !seed && !Sizzle.isXML(context) ) {
+ // See if we find a selector to speed up
+ var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
+
+ if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
+ // Speed-up: Sizzle("TAG")
+ if ( match[1] ) {
+ return makeArray( context.getElementsByTagName( query ), extra );
+
+ // Speed-up: Sizzle(".CLASS")
+ } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
+ return makeArray( context.getElementsByClassName( match[2] ), extra );
+ }
+ }
+
+ if ( context.nodeType === 9 ) {
+ // Speed-up: Sizzle("body")
+ // The body element only exists once, optimize finding it
+ if ( query === "body" && context.body ) {
+ return makeArray( [ context.body ], extra );
+
+ // Speed-up: Sizzle("#ID")
+ } else if ( match && match[3] ) {
+ var elem = context.getElementById( match[3] );
+
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if ( elem && elem.parentNode ) {
+ // Handle the case where IE and Opera return items
+ // by name instead of ID
+ if ( elem.id === match[3] ) {
+ return makeArray( [ elem ], extra );
+ }
+
+ } else {
+ return makeArray( [], extra );
+ }
+ }
+
+ try {
+ return makeArray( context.querySelectorAll(query), extra );
+ } catch(qsaError) {}
+
+ // qSA works strangely on Element-rooted queries
+ // We can work around this by specifying an extra ID on the root
+ // and working up from there (Thanks to Andrew Dupont for the technique)
+ // IE 8 doesn't work on object elements
+ } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
+ var oldContext = context,
+ old = context.getAttribute( "id" ),
+ nid = old || id,
+ hasParent = context.parentNode,
+ relativeHierarchySelector = /^\s*[+~]/.test( query );
+
+ if ( !old ) {
+ context.setAttribute( "id", nid );
+ } else {
+ nid = nid.replace( /'/g, "\\$&" );
+ }
+ if ( relativeHierarchySelector && hasParent ) {
+ context = context.parentNode;
+ }
+
+ try {
+ if ( !relativeHierarchySelector || hasParent ) {
+ return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
+ }
+
+ } catch(pseudoError) {
+ } finally {
+ if ( !old ) {
+ oldContext.removeAttribute( "id" );
+ }
+ }
+ }
+ }
+
+ return oldSizzle(query, context, extra, seed);
+ };
+
+ for ( var prop in oldSizzle ) {
+ Sizzle[ prop ] = oldSizzle[ prop ];
+ }
+
+ // release memory in IE
+ div = null;
+ })();
+}
+
+(function(){
+ var html = document.documentElement,
+ matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
+ pseudoWorks = false;
+
+ try {
+ // This should fail with an exception
+ // Gecko does not error, returns false instead
+ matches.call( document.documentElement, "[test!='']:sizzle" );
+
+ } catch( pseudoError ) {
+ pseudoWorks = true;
+ }
+
+ if ( matches ) {
+ Sizzle.matchesSelector = function( node, expr ) {
+ // Make sure that attribute selectors are quoted
+ expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
+
+ if ( !Sizzle.isXML( node ) ) {
+ try {
+ if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
+ return matches.call( node, expr );
+ }
+ } catch(e) {}
+ }
+
+ return Sizzle(expr, null, null, [node]).length > 0;
+ };
+ }
+})();
+
+(function(){
+ var div = document.createElement("div");
+
+ div.innerHTML = "";
+
+ // Opera can't find a second classname (in 9.6)
+ // Also, make sure that getElementsByClassName actually exists
+ if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
+ return;
+ }
+
+ // Safari caches class attributes, doesn't catch changes (in 3.2)
+ div.lastChild.className = "e";
+
+ if ( div.getElementsByClassName("e").length === 1 ) {
+ return;
+ }
+
+ Expr.order.splice(1, 0, "CLASS");
+ Expr.find.CLASS = function( match, context, isXML ) {
+ if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
+ return context.getElementsByClassName(match[1]);
+ }
+ };
+
+ // release memory in IE
+ div = null;
+})();
+
+function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
+ var elem = checkSet[i];
+
+ if ( elem ) {
+ var match = false;
+
+ elem = elem[dir];
+
+ while ( elem ) {
+ if ( elem.sizcache === doneName ) {
+ match = checkSet[elem.sizset];
+ break;
+ }
+
+ if ( elem.nodeType === 1 && !isXML ){
+ elem.sizcache = doneName;
+ elem.sizset = i;
+ }
+
+ if ( elem.nodeName.toLowerCase() === cur ) {
+ match = elem;
+ break;
+ }
+
+ elem = elem[dir];
+ }
+
+ checkSet[i] = match;
+ }
+ }
+}
+
+function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
+ var elem = checkSet[i];
+
+ if ( elem ) {
+ var match = false;
+
+ elem = elem[dir];
+
+ while ( elem ) {
+ if ( elem.sizcache === doneName ) {
+ match = checkSet[elem.sizset];
+ break;
+ }
+
+ if ( elem.nodeType === 1 ) {
+ if ( !isXML ) {
+ elem.sizcache = doneName;
+ elem.sizset = i;
+ }
+
+ if ( typeof cur !== "string" ) {
+ if ( elem === cur ) {
+ match = true;
+ break;
+ }
+
+ } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
+ match = elem;
+ break;
+ }
+ }
+
+ elem = elem[dir];
+ }
+
+ checkSet[i] = match;
+ }
+ }
+}
+
+if ( document.documentElement.contains ) {
+ Sizzle.contains = function( a, b ) {
+ return a !== b && (a.contains ? a.contains(b) : true);
+ };
+
+} else if ( document.documentElement.compareDocumentPosition ) {
+ Sizzle.contains = function( a, b ) {
+ return !!(a.compareDocumentPosition(b) & 16);
+ };
+
+} else {
+ Sizzle.contains = function() {
+ return false;
+ };
+}
+
+Sizzle.isXML = function( elem ) {
+ // documentElement is verified for cases where it doesn't yet exist
+ // (such as loading iframes in IE - #4833)
+ var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
+
+ return documentElement ? documentElement.nodeName !== "HTML" : false;
+};
+
+var posProcess = function( selector, context ) {
+ var match,
+ tmpSet = [],
+ later = "",
+ root = context.nodeType ? [context] : context;
+
+ // Position selectors must be done after the filter
+ // And so must :not(positional) so we move all PSEUDOs to the end
+ while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
+ later += match[0];
+ selector = selector.replace( Expr.match.PSEUDO, "" );
+ }
+
+ selector = Expr.relative[selector] ? selector + "*" : selector;
+
+ for ( var i = 0, l = root.length; i < l; i++ ) {
+ Sizzle( selector, root[i], tmpSet );
+ }
+
+ return Sizzle.filter( later, tmpSet );
+};
+
+// EXPOSE
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+jQuery.expr[":"] = jQuery.expr.filters;
+jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+
+
+})();
+
+
+var runtil = /Until$/,
+ rparentsprev = /^(?:parents|prevUntil|prevAll)/,
+ // Note: This RegExp should be improved, or likely pulled from Sizzle
+ rmultiselector = /,/,
+ isSimple = /^.[^:#\[\.,]*$/,
+ slice = Array.prototype.slice,
+ POS = jQuery.expr.match.POS,
+ // methods guaranteed to produce a unique set when starting from a unique set
+ guaranteedUnique = {
+ children: true,
+ contents: true,
+ next: true,
+ prev: true
+ };
+
+jQuery.fn.extend({
+ find: function( selector ) {
+ var ret = this.pushStack( "", "find", selector ),
+ length = 0;
+
+ for ( var i = 0, l = this.length; i < l; i++ ) {
+ length = ret.length;
+ jQuery.find( selector, this[i], ret );
+
+ if ( i > 0 ) {
+ // Make sure that the results are unique
+ for ( var n = length; n < ret.length; n++ ) {
+ for ( var r = 0; r < length; r++ ) {
+ if ( ret[r] === ret[n] ) {
+ ret.splice(n--, 1);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return ret;
+ },
+
+ has: function( target ) {
+ var targets = jQuery( target );
+ return this.filter(function() {
+ for ( var i = 0, l = targets.length; i < l; i++ ) {
+ if ( jQuery.contains( this, targets[i] ) ) {
+ return true;
+ }
+ }
+ });
+ },
+
+ not: function( selector ) {
+ return this.pushStack( winnow(this, selector, false), "not", selector);
+ },
+
+ filter: function( selector ) {
+ return this.pushStack( winnow(this, selector, true), "filter", selector );
+ },
+
+ is: function( selector ) {
+ return !!selector && jQuery.filter( selector, this ).length > 0;
+ },
+
+ closest: function( selectors, context ) {
+ var ret = [], i, l, cur = this[0];
+
+ if ( jQuery.isArray( selectors ) ) {
+ var match, selector,
+ matches = {},
+ level = 1;
+
+ if ( cur && selectors.length ) {
+ for ( i = 0, l = selectors.length; i < l; i++ ) {
+ selector = selectors[i];
+
+ if ( !matches[selector] ) {
+ matches[selector] = jQuery.expr.match.POS.test( selector ) ?
+ jQuery( selector, context || this.context ) :
+ selector;
+ }
+ }
+
+ while ( cur && cur.ownerDocument && cur !== context ) {
+ for ( selector in matches ) {
+ match = matches[selector];
+
+ if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
+ ret.push({ selector: selector, elem: cur, level: level });
+ }
+ }
+
+ cur = cur.parentNode;
+ level++;
+ }
+ }
+
+ return ret;
+ }
+
+ var pos = POS.test( selectors ) ?
+ jQuery( selectors, context || this.context ) : null;
+
+ for ( i = 0, l = this.length; i < l; i++ ) {
+ cur = this[i];
+
+ while ( cur ) {
+ if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
+ ret.push( cur );
+ break;
+
+ } else {
+ cur = cur.parentNode;
+ if ( !cur || !cur.ownerDocument || cur === context ) {
+ break;
+ }
+ }
+ }
+ }
+
+ ret = ret.length > 1 ? jQuery.unique(ret) : ret;
+
+ return this.pushStack( ret, "closest", selectors );
+ },
+
+ // Determine the position of an element within
+ // the matched set of elements
+ index: function( elem ) {
+ if ( !elem || typeof elem === "string" ) {
+ return jQuery.inArray( this[0],
+ // If it receives a string, the selector is used
+ // If it receives nothing, the siblings are used
+ elem ? jQuery( elem ) : this.parent().children() );
+ }
+ // Locate the position of the desired element
+ return jQuery.inArray(
+ // If it receives a jQuery object, the first element is used
+ elem.jquery ? elem[0] : elem, this );
+ },
+
+ add: function( selector, context ) {
+ var set = typeof selector === "string" ?
+ jQuery( selector, context ) :
+ jQuery.makeArray( selector ),
+ all = jQuery.merge( this.get(), set );
+
+ return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
+ all :
+ jQuery.unique( all ) );
+ },
+
+ andSelf: function() {
+ return this.add( this.prevObject );
+ }
+});
+
+// A painfully simple check to see if an element is disconnected
+// from a document (should be improved, where feasible).
+function isDisconnected( node ) {
+ return !node || !node.parentNode || node.parentNode.nodeType === 11;
+}
+
+jQuery.each({
+ parent: function( elem ) {
+ var parent = elem.parentNode;
+ return parent && parent.nodeType !== 11 ? parent : null;
+ },
+ parents: function( elem ) {
+ return jQuery.dir( elem, "parentNode" );
+ },
+ parentsUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "parentNode", until );
+ },
+ next: function( elem ) {
+ return jQuery.nth( elem, 2, "nextSibling" );
+ },
+ prev: function( elem ) {
+ return jQuery.nth( elem, 2, "previousSibling" );
+ },
+ nextAll: function( elem ) {
+ return jQuery.dir( elem, "nextSibling" );
+ },
+ prevAll: function( elem ) {
+ return jQuery.dir( elem, "previousSibling" );
+ },
+ nextUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "nextSibling", until );
+ },
+ prevUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "previousSibling", until );
+ },
+ siblings: function( elem ) {
+ return jQuery.sibling( elem.parentNode.firstChild, elem );
+ },
+ children: function( elem ) {
+ return jQuery.sibling( elem.firstChild );
+ },
+ contents: function( elem ) {
+ return jQuery.nodeName( elem, "iframe" ) ?
+ elem.contentDocument || elem.contentWindow.document :
+ jQuery.makeArray( elem.childNodes );
+ }
+}, function( name, fn ) {
+ jQuery.fn[ name ] = function( until, selector ) {
+ var ret = jQuery.map( this, fn, until ),
+ // The variable 'args' was introduced in
+ // https://github.com/jquery/jquery/commit/52a0238
+ // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
+ // http://code.google.com/p/v8/issues/detail?id=1050
+ args = slice.call(arguments);
+
+ if ( !runtil.test( name ) ) {
+ selector = until;
+ }
+
+ if ( selector && typeof selector === "string" ) {
+ ret = jQuery.filter( selector, ret );
+ }
+
+ ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
+
+ if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
+ ret = ret.reverse();
+ }
+
+ return this.pushStack( ret, name, args.join(",") );
+ };
+});
+
+jQuery.extend({
+ filter: function( expr, elems, not ) {
+ if ( not ) {
+ expr = ":not(" + expr + ")";
+ }
+
+ return elems.length === 1 ?
+ jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
+ jQuery.find.matches(expr, elems);
+ },
+
+ dir: function( elem, dir, until ) {
+ var matched = [],
+ cur = elem[ dir ];
+
+ while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
+ if ( cur.nodeType === 1 ) {
+ matched.push( cur );
+ }
+ cur = cur[dir];
+ }
+ return matched;
+ },
+
+ nth: function( cur, result, dir, elem ) {
+ result = result || 1;
+ var num = 0;
+
+ for ( ; cur; cur = cur[dir] ) {
+ if ( cur.nodeType === 1 && ++num === result ) {
+ break;
+ }
+ }
+
+ return cur;
+ },
+
+ sibling: function( n, elem ) {
+ var r = [];
+
+ for ( ; n; n = n.nextSibling ) {
+ if ( n.nodeType === 1 && n !== elem ) {
+ r.push( n );
+ }
+ }
+
+ return r;
+ }
+});
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, keep ) {
+ if ( jQuery.isFunction( qualifier ) ) {
+ return jQuery.grep(elements, function( elem, i ) {
+ var retVal = !!qualifier.call( elem, i, elem );
+ return retVal === keep;
+ });
+
+ } else if ( qualifier.nodeType ) {
+ return jQuery.grep(elements, function( elem, i ) {
+ return (elem === qualifier) === keep;
+ });
+
+ } else if ( typeof qualifier === "string" ) {
+ var filtered = jQuery.grep(elements, function( elem ) {
+ return elem.nodeType === 1;
+ });
+
+ if ( isSimple.test( qualifier ) ) {
+ return jQuery.filter(qualifier, filtered, !keep);
+ } else {
+ qualifier = jQuery.filter( qualifier, filtered );
+ }
+ }
+
+ return jQuery.grep(elements, function( elem, i ) {
+ return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
+ });
+}
+
+
+
+
+var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
+ rleadingWhitespace = /^\s+/,
+ rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
+ rtagName = /<([\w:]+)/,
+ rtbody = /", "" ],
+ legend: [ 1, "" ],
+ thead: [ 1, "", "
" ],
+ tr: [ 2, "", "
" ],
+ td: [ 3, "
" ],
+ col: [ 2, "
" ],
+ area: [ 1, "" ],
+ _default: [ 0, "", "" ]
+ };
+
+wrapMap.optgroup = wrapMap.option;
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// IE can't serialize and
+
+
+
+
+
+
+
+
+
+ Namespace: oScroll
+Ancestry: DataTable ยป .models ยป .oSettings. ยป oScroll
+
+ DataTables v1.9.1 documentation
+
+
+
+
+ Navigation
+ +
+
+ Hiding private elements
+ (toggle)
+
+
+
+
+ Showing extended elements
+ (toggle)
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/index.html b/src/main/resources/web/scripts/DataTables-1.9.1/docs/index.html
new file mode 100644
index 0000000..419d010
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/index.html
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+ Scrolling settings for a table.
-
+
+
+
+
+
+
+
+
+
+ Summary
+ +Properties
+ +-
+
- <static> bAutoCss :boolean
- Indicate if DataTables should be allowed to set the padding / margin +etc for the scrolling header elements or not. Typically you will want +this. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bCollapse :boolean
- When the table is shorter in height than sScrollY, collapse the +table container down to the height of the table (when true). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> bInfinite :boolean
- Infinite scrolling enablement flag. Now deprecated in favour of +using the Scroller plug-in. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> iBarWidth :int
- Width of the scrollbar for the web-browser's platform. Calculated +during table initialisation.
- <static> iLoadGap :int
- Space (in pixels) between the bottom of the scrolling container and +the bottom of the scrolling viewport before the next page is loaded +when using infinite scrolling. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sX :string
- Viewport width for horizontal scrolling. Horizontal scrolling is +disabled if an empty string. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sXInner :string
- Width to expand the table to when using x-scrolling. Typically you +should not need to use this. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
- <static> sY :string
- Viewport height for vertical scrolling. Vertical scrolling is disabled +if an empty string. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults. +
+
+
+
+
+ Details
+Properties
+-
+
- <static> bAutoCss :boolean
Indicate if DataTables should be allowed to set the padding / margin +etc for the scrolling header elements or not. Typically you will want +this. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bCollapse :boolean
When the table is shorter in height than sScrollY, collapse the +table container down to the height of the table (when true). +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> bInfinite :boolean
Infinite scrolling enablement flag. Now deprecated in favour of +using the Scroller plug-in. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> iBarWidth :int
Width of the scrollbar for the web-browser's platform. Calculated +during table initialisation.
-
+
+
- <static> iLoadGap :int
Space (in pixels) between the bottom of the scrolling container and +the bottom of the scrolling viewport before the next page is loaded +when using infinite scrolling. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sX :string
Viewport width for horizontal scrolling. Horizontal scrolling is +disabled if an empty string. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
- <static> sXInner :string
Width to expand the table to when using x-scrolling. Typically you +should not need to use this. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
- Deprecated
- Yes +
- <static> sY :string
Viewport height for vertical scrolling. Vertical scrolling is disabled +if an empty string. +Note that this parameter will be set by the initialisation routine. To +set a default use DataTable.defaults.
-
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/doc.css b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/doc.css
new file mode 100644
index 0000000..aa39f09
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/doc.css
@@ -0,0 +1,316 @@
+/*
+Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 0.12.0
+*/
+body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,textarea,p,blockquote,th,td{margin:0;padding:0;}
+table{border-collapse:collapse;border-spacing:0;}
+fieldset,img{border:0;}
+address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}
+ol,ul {list-style:none;}
+caption,th {text-align:left;}
+h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}
+q:before,q:after{content:'';}
+abbr,acronym {border:0;}
+
+
+html, body {
+ margin: 0;
+ padding: 0;
+ width: 100%;
+ font: 14px/1.45em "Lucida Grande", Verdana, Arial, Helvetica, sans-serif;
+ color: #111;
+}
+
+div.fw_container {
+ width: 980px;
+ padding-top: 2em;
+ margin: 0 auto;
+}
+
+div.fw_header {
+ position: relative;
+}
+
+div.fw_content {
+ padding-top: 2em;
+}
+
+div.fw_footer {
+ padding-top: 4em;
+ font-size: 75%;
+ text-align: center;
+}
+
+
+
+.type-param {
+
+}
+
+.type-attr {
+ float: right;
+ color: #999;
+}
+
+.type-name {
+ font-weight: bold;
+}
+
+.type-sig {
+ color: #999;
+}
+
+.type-param {
+ color: #FF9999;
+}
+
+.type-return {
+ color: #FF8080;
+}
+
+.type-brace {
+ color: #111;
+}
+
+.example-code {
+ margin-left: 30px;
+}
+.example-code td.code {
+ border-top: 1px solid #4E6CA3 !important;
+}
+
+.type-augmented {
+ position: absolute;
+ left: 8px;
+ top: 0;
+}
+
+dt, dd {
+ padding: 0.4em 10px;
+}
+
+dt {
+ padding-bottom: 0 !important;
+}
+
+dd {
+ position: relative;
+ padding-top: 0 !important;
+ padding-left: 3em;
+}
+
+dt.even, dd.even {
+ background-color: white;
+}
+
+dt.odd, dd.odd {
+ background-color: #F2F2F2;
+}
+
+div.doc_overview dd, div.doc_overview dt {
+ padding-left: 0 !important;
+}
+
+
+
+.doc_details dt, .doc_details dd {
+ padding: 1em 10px;
+}
+
+.right_border div {
+ width: 20px;
+ padding: 2px 0.5em 2px 1em;
+ text-align: right;
+}
+.right_border {
+ border-right: 3px solid #4E6CA3;
+}
+.bottom_border {
+ border-bottom: 1px solid #4E6CA3;
+}
+
+
+a {
+ text-decoration: none;
+ color: #4E6CA3;
+}
+
+a:hover {
+ text-decoration: underline;
+ cursor: pointer;
+ *cursor: hand;
+}
+
+div.fw_content ul {
+ list-style-image: url('../images/arrow.jpg');
+ padding: 0.5em 0 0.5em 2em;
+}
+
+/*
+h2 {
+ font-size: 1.4em;
+ margin-top: 2em;
+ border-bottom: 3px solid #829ac6;
+ padding-left: 5px;
+}
+
+h3 {
+ font-size: 1.2em;
+ margin-top: 1em;
+ border-bottom: 1px solid #A4B5D5;
+ padding-left: 5px;
+}
+*/
+
+h1 {
+ font-size: 2em;
+}
+
+h2 {
+ font-size: 1.6em;
+ padding-top: 5px;
+}
+
+h2.ancestors {
+ font-size: 14px;
+ margin: 0;
+}
+
+h3 {
+ font-size: 1.3em;
+ padding-top: 5px;
+ margin-bottom: 5px;
+}
+
+h5 {
+ padding-top: 6px;
+}
+
+div.doc_summary, div.doc_details {
+ margin-top: 2em;
+ clear: both;
+}
+
+div.doc_group {
+ margin-top: 1em;
+ border-top: 1px solid #A4B5D5;
+ border-left: 1px solid #A4B5D5;
+ padding-left: 10px;
+}
+
+div.extended {
+ margin-left: 30px;
+}
+
+table.params {
+ margin-left: 30px;
+ width: 97%;
+}
+
+tr.odd {
+ background-color: white;
+}
+
+tr.even {
+ background-color: #F8F8F8;
+}
+
+th.name,
+td.name {
+ padding-left: 13px;
+}
+
+td.number {
+ background-color: white;
+ color: #5C5C5C;
+}
+
+dd.odd td.number {
+ background-color: #F2F2F2;
+}
+
+p.returns {
+ margin-left: 5%;
+}
+
+div.page-info {
+ position: absolute;
+ top: 0;
+ right: 0;
+}
+
+
+.private {
+ display: none;
+}
+
+
+
+
+div.fw_nav {
+ position: fixed;
+ top: 60px;
+ right: 30px;
+ width: 250px;
+ border: 1px solid #A4B5D5;
+ background-color: white;
+ padding: 10px;
+ z-index: 1001;
+ font-size: 12px;
+ overflow: hidden;
+}
+
+div.fw_nav h2 {
+ margin: -10px 0 10px -10px;
+ width: 250px;
+ padding: 5px 10px;
+ background-color: #A4B5D5;
+ font-size: 12px;
+ cursor: pointer;
+ *cursor: hand;
+}
+
+div.fw_nav ul>li>div {
+ padding: 0 0 0 1em;
+}
+
+div.nav_blocker {
+ float: right;
+}
+
+
+
+
+
+
+
+.css_clear {
+ clear: both;
+ height: 0;
+ line-height: 0;
+ visibility: hidden;
+}
+
+.css_right {
+ text-align: right;
+}
+
+.css_center {
+ text-align: center;
+}
+
+.css_spacing {
+ margin-top: 1.5em;
+}
+
+.css_small {
+ font-size: 75%;
+ line-height: 1.45em;
+}
+
+.css_vsmall {
+ font-size: 65%;
+ line-height: 1.45em;
+}
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shCore.css b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shCore.css
new file mode 100644
index 0000000..b0c4520
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shCore.css
@@ -0,0 +1,226 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ *
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+.syntaxhighlighter a,
+.syntaxhighlighter div,
+.syntaxhighlighter code,
+.syntaxhighlighter table,
+.syntaxhighlighter table td,
+.syntaxhighlighter table tr,
+.syntaxhighlighter table tbody,
+.syntaxhighlighter table thead,
+.syntaxhighlighter table caption,
+.syntaxhighlighter textarea {
+ -moz-border-radius: 0 0 0 0 !important;
+ -webkit-border-radius: 0 0 0 0 !important;
+ background: none !important;
+ border: 0 !important;
+ bottom: auto !important;
+ float: none !important;
+ height: auto !important;
+ left: auto !important;
+ line-height: 1.1em !important;
+ margin: 0 !important;
+ outline: 0 !important;
+ overflow: visible !important;
+ padding: 0 !important;
+ position: static !important;
+ right: auto !important;
+ text-align: left !important;
+ top: auto !important;
+ vertical-align: baseline !important;
+ width: auto !important;
+ box-sizing: content-box !important;
+ font-family: "Consolas","Monaco","Bitstream Vera Sans Mono","Courier New",Courier,monospace !important;
+ font-weight: normal !important;
+ font-style: normal !important;
+ font-size: 1em !important;
+ min-height: inherit !important;
+ min-height: auto !important;
+}
+
+.syntaxhighlighter {
+ width: 100% !important;
+ margin: 1em 0 1em 0 !important;
+ position: relative !important;
+ overflow: auto !important;
+ font-size: 1em !important;
+}
+.syntaxhighlighter.source {
+ overflow: hidden !important;
+}
+.syntaxhighlighter .bold {
+ font-weight: bold !important;
+}
+.syntaxhighlighter .italic {
+ font-style: italic !important;
+}
+.syntaxhighlighter .line {
+ white-space: pre !important;
+}
+.syntaxhighlighter table {
+ width: 100% !important;
+}
+.syntaxhighlighter table caption {
+ text-align: left !important;
+ padding: .5em 0 0.5em 1em !important;
+}
+.syntaxhighlighter table td.code {
+ width: 100% !important;
+}
+.syntaxhighlighter table td.code .container {
+ position: relative !important;
+}
+.syntaxhighlighter table td.code .container textarea {
+ box-sizing: border-box !important;
+ position: absolute !important;
+ left: 0 !important;
+ top: 0 !important;
+ width: 100% !important;
+ height: 100% !important;
+ border: none !important;
+ background: white !important;
+ padding-left: 1em !important;
+ overflow: hidden !important;
+ white-space: pre !important;
+}
+.syntaxhighlighter table td.gutter .line {
+ text-align: right !important;
+ padding: 2px 0.5em 2px 1em !important;
+}
+.syntaxhighlighter table td.code .line {
+ padding: 2px 1em !important;
+}
+.syntaxhighlighter.nogutter td.code .container textarea, .syntaxhighlighter.nogutter td.code .line {
+ padding-left: 0em !important;
+}
+.syntaxhighlighter.show {
+ display: block !important;
+}
+.syntaxhighlighter.collapsed table {
+ display: none !important;
+}
+.syntaxhighlighter.collapsed .toolbar {
+ padding: 0.1em 0.8em 0em 0.8em !important;
+ font-size: 1em !important;
+ position: static !important;
+ width: auto !important;
+ height: auto !important;
+}
+.syntaxhighlighter.collapsed .toolbar span {
+ display: inline !important;
+ margin-right: 1em !important;
+}
+.syntaxhighlighter.collapsed .toolbar span a {
+ padding: 0 !important;
+ display: none !important;
+}
+.syntaxhighlighter.collapsed .toolbar span a.expandSource {
+ display: inline !important;
+}
+.syntaxhighlighter .toolbar {
+ position: absolute !important;
+ right: 1px !important;
+ top: 1px !important;
+ width: 11px !important;
+ height: 11px !important;
+ font-size: 10px !important;
+ z-index: 10 !important;
+}
+.syntaxhighlighter .toolbar span.title {
+ display: inline !important;
+}
+.syntaxhighlighter .toolbar a {
+ display: block !important;
+ text-align: center !important;
+ text-decoration: none !important;
+ padding-top: 1px !important;
+}
+.syntaxhighlighter .toolbar a.expandSource {
+ display: none !important;
+}
+.syntaxhighlighter.ie {
+ font-size: .9em !important;
+ padding: 1px 0 1px 0 !important;
+}
+.syntaxhighlighter.ie .toolbar {
+ line-height: 8px !important;
+}
+.syntaxhighlighter.ie .toolbar a {
+ padding-top: 0px !important;
+}
+.syntaxhighlighter.printing .line.alt1 .content,
+.syntaxhighlighter.printing .line.alt2 .content,
+.syntaxhighlighter.printing .line.highlighted .number,
+.syntaxhighlighter.printing .line.highlighted.alt1 .content,
+.syntaxhighlighter.printing .line.highlighted.alt2 .content {
+ background: none !important;
+}
+.syntaxhighlighter.printing .line .number {
+ color: #bbbbbb !important;
+}
+.syntaxhighlighter.printing .line .content {
+ color: black !important;
+}
+.syntaxhighlighter.printing .toolbar {
+ display: none !important;
+}
+.syntaxhighlighter.printing a {
+ text-decoration: none !important;
+}
+.syntaxhighlighter.printing .plain, .syntaxhighlighter.printing .plain a {
+ color: black !important;
+}
+.syntaxhighlighter.printing .comments, .syntaxhighlighter.printing .comments a {
+ color: #008200 !important;
+}
+.syntaxhighlighter.printing .string, .syntaxhighlighter.printing .string a {
+ color: blue !important;
+}
+.syntaxhighlighter.printing .keyword {
+ color: #006699 !important;
+ font-weight: bold !important;
+}
+.syntaxhighlighter.printing .preprocessor {
+ color: gray !important;
+}
+.syntaxhighlighter.printing .variable {
+ color: #aa7700 !important;
+}
+.syntaxhighlighter.printing .value {
+ color: #009900 !important;
+}
+.syntaxhighlighter.printing .functions {
+ color: #ff1493 !important;
+}
+.syntaxhighlighter.printing .constants {
+ color: #0066cc !important;
+}
+.syntaxhighlighter.printing .script {
+ font-weight: bold !important;
+}
+.syntaxhighlighter.printing .color1, .syntaxhighlighter.printing .color1 a {
+ color: gray !important;
+}
+.syntaxhighlighter.printing .color2, .syntaxhighlighter.printing .color2 a {
+ color: #ff1493 !important;
+}
+.syntaxhighlighter.printing .color3, .syntaxhighlighter.printing .color3 a {
+ color: red !important;
+}
+.syntaxhighlighter.printing .break, .syntaxhighlighter.printing .break a {
+ color: black !important;
+}
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shThemeDataTables.css b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shThemeDataTables.css
new file mode 100644
index 0000000..7e9790a
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/css/shThemeDataTables.css
@@ -0,0 +1,128 @@
+/**
+ * SyntaxHighlighter
+ * http://alexgorbatchev.com/SyntaxHighlighter
+ *
+ * SyntaxHighlighter is donationware. If you are using it, please donate.
+ * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
+ *
+ * @version
+ * 3.0.83 (July 02 2010)
+ *
+ * @copyright
+ * Copyright (C) 2004-2010 Alex Gorbatchev.
+ *
+ * @license
+ * Dual licensed under the MIT and GPL licenses.
+ */
+.syntaxhighlighter {
+ background-color: white !important;
+ font-size: 14px !important;
+ overflow: visible !important;
+}
+.syntaxhighlighter .line.alt1 {
+ background-color: white !important;
+}
+.syntaxhighlighter .line.alt2 {
+ background-color: #F8F8F8 !important;
+}
+.syntaxhighlighter .line.highlighted.alt1, .syntaxhighlighter .line.highlighted.alt2 {
+ background-color: #e0e0e0 !important;
+}
+.syntaxhighlighter .line.highlighted.number {
+ color: black !important;
+}
+.syntaxhighlighter table caption {
+ color: black !important;
+}
+.syntaxhighlighter .gutter {
+}
+.syntaxhighlighter .gutter div {
+ color: #5C5C5C !important;
+ width: 20px !important;
+}
+.syntaxhighlighter .gutter .line.alt1, .syntaxhighlighter .gutter .line.alt2 {
+ background-color: white !important;
+}
+.odd .syntaxhighlighter .gutter .line.alt1, .odd .syntaxhighlighter .gutter .line.alt2 {
+ background-color: #F2F2F2 !important;
+}
+.syntaxhighlighter .gutter .line {
+ border-right: 3px solid #4E6CA3 !important;
+}
+.syntaxhighlighter .gutter .line.highlighted {
+ background-color: #4E6CA3 !important;
+ color: white !important;
+}
+.syntaxhighlighter.printing .line .content {
+ border: none !important;
+}
+.syntaxhighlighter.collapsed {
+ overflow: visible !important;
+}
+.syntaxhighlighter.collapsed .toolbar {
+ color: blue !important;
+ background: white !important;
+ border: 1px solid #4E6CA3 !important;
+}
+.syntaxhighlighter.collapsed .toolbar a {
+ color: blue !important;
+}
+.syntaxhighlighter.collapsed .toolbar a:hover {
+ color: red !important;
+}
+.syntaxhighlighter .toolbar {
+ color: white !important;
+ background: #4E6CA3 !important;
+ border: none !important;
+}
+.syntaxhighlighter .toolbar a {
+ color: white !important;
+}
+.syntaxhighlighter .toolbar a:hover {
+ color: black !important;
+}
+.syntaxhighlighter .plain, .syntaxhighlighter .plain a {
+ color: black !important;
+}
+.syntaxhighlighter .comments, .syntaxhighlighter .comments a {
+ color: #008200 !important;
+}
+.syntaxhighlighter .string, .syntaxhighlighter .string a {
+ color: blue !important;
+}
+.syntaxhighlighter .keyword {
+ color: #006699 !important;
+}
+.syntaxhighlighter .preprocessor {
+ color: gray !important;
+}
+.syntaxhighlighter .variable {
+ color: #aa7700 !important;
+}
+.syntaxhighlighter .value {
+ color: #009900 !important;
+}
+.syntaxhighlighter .functions {
+ color: #ff1493 !important;
+}
+.syntaxhighlighter .constants {
+ color: #0066cc !important;
+}
+.syntaxhighlighter .script {
+ font-weight: bold !important;
+ color: #006699 !important;
+ background-color: none !important;
+}
+.syntaxhighlighter .color1, .syntaxhighlighter .color1 a {
+ color: gray !important;
+}
+.syntaxhighlighter .color2, .syntaxhighlighter .color2 a {
+ color: #ff1493 !important;
+}
+.syntaxhighlighter .color3, .syntaxhighlighter .color3 a {
+ color: red !important;
+}
+
+.syntaxhighlighter .keyword {
+ font-weight: bold !important;
+}
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/arrow.jpg b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/arrow.jpg
new file mode 100644
index 0000000..eba85ea
Binary files /dev/null and b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/arrow.jpg differ
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/extended.png b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/extended.png
new file mode 100644
index 0000000..5dd01bf
Binary files /dev/null and b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/images/extended.png differ
diff --git a/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/js/doc.js b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/js/doc.js
new file mode 100644
index 0000000..932d7cf
--- /dev/null
+++ b/src/main/resources/web/scripts/DataTables-1.9.1/docs/media/js/doc.js
@@ -0,0 +1,121 @@
+
+(function() {
+
+var showingNav = true;
+
+$(document).ready( function () {
+ var jqNav = $('div.fw_nav');
+ jqNav.css('right', ($(window).width() - $('div.fw_container').width()) /2);
+
+ var n = $('div.nav_blocker')[0];
+ n.style.height = $(jqNav).outerHeight()+"px";
+ n.style.width = ($(jqNav).outerWidth()+20)+"px";
+
+ SyntaxHighlighter.highlight();
+
+ $('#private_toggle').click( function () {
+ if ( $('input[name=show_private]').val() == 0 ) {
+ $('input[name=show_private]').val( 1 );
+ $('#private_label').html('Showing');
+ $('.private').css('display', 'block');
+ } else {
+ $('input[name=show_private]').val( 0 );
+ $('#private_label').html('Hiding');
+ $('.private').css('display', 'none');
+ }
+ fnWriteCookie();
+ return false;
+ } );
+
+ $('#extended_toggle').click( function () {
+ if ( $('input[name=show_extended]').val() == 0 ) {
+ $('input[name=show_extended]').val( 1 );
+ $('#extended_label').html('Showing');
+ $('.augmented').css('display', 'block');
+ } else {
+ $('input[name=show_extended]').val( 0 );
+ $('#extended_label').html('Hiding');
+ $('.augmented').css('display', 'none');
+ }
+ fnWriteCookie();
+ return false;
+ } );
+
+ var savedHeight = $(jqNav).height();
+ $('div.fw_nav h2').click( function () {
+ if ( showingNav ) {
+ $('div.fw_nav').animate( {
+ "height": 10,
+ "opacity": 0.3
+ } );
+ showingNav = false;
+ } else {
+ $('div.fw_nav').animate( {
+ "height": savedHeight,
+ "opacity": 1
+ } );
+ showingNav = true;
+ }
+ fnWriteCookie();
+ } );
+
+ var cookie = fnReadCookie( 'SpryMedia_JSDoc' );
+ if ( cookie != null ) {
+ var a = cookie.split('-');
+ if ( a[0] == 1 ) {
+ $('#private_toggle').click();
+ }
+ if ( a[1] == 0 ) {
+ $('#extended_toggle').click();
+ }
+ if ( a[2] == 'false' ) {
+ $('div.fw_nav').css('height', 10).css('opacity', 0.3);
+ showingNav = false;
+ }
+ }
+} );
+
+
+function fnWriteCookie()
+{
+ var sVal =
+ $('input[name=show_private]').val()+'-'+
+ $('input[name=show_extended]').val()+'-'+
+ showingNav;
+
+ fnCreateCookie( 'SpryMedia_JSDoc', sVal );
+}
+
+
+function fnCreateCookie( sName, sValue )
+{
+ var iDays = 365;
+ var date = new Date();
+ date.setTime( date.getTime()+(iDays*24*60*60*1000) );
+ var sExpires = "; expires="+date.toGMTString();
+
+ document.cookie = sName+"="+sValue+sExpires+"; path=/";
+}
+
+
+function fnReadCookie( sName )
+{
+ var sNameEQ = sName + "=";
+ var sCookieContents = document.cookie.split(';');
+
+ for( var i=0 ; i
+
+
+
+
+ Table of Contents
+-
+
- DataTable
- DataTables is a plug-in for the jQuery Javascript library. It is a
+highly flexible tool, based upon the foundations of progressive
+enhancement, which will add advanced interaction controls to any
+HTML table. For a full list of features please refer to
+DataTables.net.
Note that the DataTable object is not a global variable but is +aliased to jQuery.fn.DataTable and jQuery.fn.dataTable through which +it may be accessed.
+
| t |
+
+
+
+ DataTables with column rendering
+
+
+ Preamble
+You may specify a function for each column to render the available data in a specific manner which will be called when the table is drawn. In this example I've appended the rendering engine version to the rendering engine name in the first column, and hidden the version column.
+ +Live example
+
+
+
+
+
+
+
+
+ | Rendering engine | +Browser | +Platform(s) | +Engine version | +CSS grade | +
|---|---|---|---|---|
| Trident | +Internet Explorer 4.0 | +Win 95+ | +4 | +X | +
| Trident | +Internet Explorer 5.0 | +Win 95+ | +5 | +C | +
| Trident | +Internet Explorer 5.5 | +Win 95+ | +5.5 | +A | +
| Trident | +Internet Explorer 6 | +Win 98+ | +6 | +A | +
| Trident | +Internet Explorer 7 | +Win XP SP2+ | +7 | +A | +
| Trident | +AOL browser (AOL desktop) | +Win XP | +6 | +A | +
| Gecko | +Firefox 1.0 | +Win 98+ / OSX.2+ | +1.7 | +A | +
| Gecko | +Firefox 1.5 | +Win 98+ / OSX.2+ | +1.8 | +A | +
| Gecko | +Firefox 2.0 | +Win 98+ / OSX.2+ | +1.8 | +A | +
| Gecko | +Firefox 3.0 | +Win 2k+ / OSX.3+ | +1.9 | +A | +
| Gecko | +Camino 1.0 | +OSX.2+ | +1.8 | +A | +
| Gecko | +Camino 1.5 | +OSX.3+ | +1.8 | +A | +
| Gecko | +Netscape 7.2 | +Win 95+ / Mac OS 8.6-9.2 | +1.7 | +A | +
| Gecko | +Netscape Browser 8 | +Win 98SE+ | +1.7 | +A | +
| Gecko | +Netscape Navigator 9 | +Win 98+ / OSX.2+ | +1.8 | +A | +
| Gecko | +Mozilla 1.0 | +Win 95+ / OSX.1+ | +1 | +A | +
| Gecko | +Mozilla 1.1 | +Win 95+ / OSX.1+ | +1.1 | +A | +
| Gecko | +Mozilla 1.2 | +Win 95+ / OSX.1+ | +1.2 | +A | +
| Gecko | +Mozilla 1.3 | +Win 95+ / OSX.1+ | +1.3 | +A | +
| Gecko | +Mozilla 1.4 | +Win 95+ / OSX.1+ | +1.4 | +A | +
| Gecko | +Mozilla 1.5 | +Win 95+ / OSX.1+ | +1.5 | +A | +
| Gecko | +Mozilla 1.6 | +Win 95+ / OSX.1+ | +1.6 | +A | +
| Gecko | +Mozilla 1.7 | +Win 98+ / OSX.1+ | +1.7 | +A | +
| Gecko | +Mozilla 1.8 | +Win 98+ / OSX.1+ | +1.8 | +A | +
| Gecko | +Seamonkey 1.1 | +Win 98+ / OSX.2+ | +1.8 | +A | +
| Gecko | +Epiphany 2.20 | +Gnome | +1.8 | +A | +
| Webkit | +Safari 1.2 | +OSX.3 | +125.5 | +A | +
| Webkit | +Safari 1.3 | +OSX.3 | +312.8 | +A | +
| Webkit | +Safari 2.0 | +OSX.4+ | +419.3 | +A | +
| Webkit | +Safari 3.0 | +OSX.4+ | +522.1 | +A | +
| Webkit | +OmniWeb 5.5 | +OSX.4+ | +420 | +A | +
| Webkit | +iPod Touch / iPhone | +iPod | +420.1 | +A | +
| Webkit | +S60 | +S60 | +413 | +A | +
| Presto | +Opera 7.0 | +Win 95+ / OSX.1+ | +- | +A | +
| Presto | +Opera 7.5 | +Win 95+ / OSX.2+ | +- | +A | +
| Presto | +Opera 8.0 | +Win 95+ / OSX.2+ | +- | +A | +
| Presto | +Opera 8.5 | +Win 95+ / OSX.2+ | +- | +A | +
| Presto | +Opera 9.0 | +Win 95+ / OSX.3+ | +- | +A | +
| Presto | +Opera 9.2 | +Win 88+ / OSX.3+ | +- | +A | +
| Presto | +Opera 9.5 | +Win 88+ / OSX.3+ | +- | +A | +
| Presto | +Opera for Wii | +Wii | +- | +A | +
| Presto | +Nokia N800 | +N800 | +- | +A | +
| Presto | +Nintendo DS browser | +Nintendo DS | +8.5 | +C/A1 | +
| KHTML | +Konqureror 3.1 | +KDE 3.1 | +3.1 | +C | +
| KHTML | +Konqureror 3.3 | +KDE 3.3 | +3.3 | +A | +
| KHTML | +Konqureror 3.5 | +KDE 3.5 | +3.5 | +A | +
| Tasman | +Internet Explorer 4.5 | +Mac OS 8-9 | +- | +X | +
| Tasman | +Internet Explorer 5.1 | +Mac OS 7.6-9 | +1 | +C | +
| Tasman | +Internet Explorer 5.2 | +Mac OS 8-X | +1 | +C | +
| Misc | +NetFront 3.1 | +Embedded devices | +- | +C | +
| Misc | +NetFront 3.4 | +Embedded devices | +- | +A | +
| Misc | +Dillo 0.8 | +Embedded devices | +- | +X | +
| Misc | +Links | +Text only | +- | +X | +
| Misc | +Lynx | +Text only | +- | +X | +
| Misc | +IE Mobile | +Windows Mobile 6 | +- | +C | +
| Misc | +PSP browser | +PSP | +- | +C | +
| Other browsers | +All others | +- | +- | +U | +
| Rendering engine | +Browser | +Platform(s) | +Engine version | +CSS grade | +
Initialisation code
+$(document).ready(function() {
+ $('#example').dataTable( {
+ "aoColumnDefs": [
+ {
+ "fnRender": function ( oObj, sVal ) {
+ return sVal +' '+ oObj.aData[3];
+ },
+ "aTargets": [ 0 ]
+ },
+ { "bVisible": false, "aTargets": [ 3 ] },
+ { "sClass": "center", "aTargets": [ 4 ] }
+ ]
+ } );
+} );
+
+
+
+
+ Other examples
+
+
+
+ Basic initialisation
+-
+
- Zero configuration +
- Feature enablement +
- Sorting data +
- Multi-column sorting +
- Multiple tables +
- Hidden columns +
- Complex headers - grouping with colspan +
- DOM positioning +
- Flexible table width +
- State saving +
- Alternative pagination styles +
- Scrolling:
+ Horizontal / + Vertical / + Both / + Themed / + Infinite +
+ - Change language information (internationalisation) +
- ThemeRoller themes (Smoothness) +
Advanced initialisation
+-
+
- Events:
+ Live events / + Pre-init / + Post-init +
+ - Column rendering +
- Sorting without HTML tags +
- Multiple table controls (sDom) +
- Defining length menu options +
- Complex headers and hidden columns +
- Custom toolbar (element) around table +
- Row highlighting with CSS +
- Row grouping +
- Row callback +
- Footer callback +
- Control sorting direction of columns +
- Change language information from a file (internationalisation) +
- Setting defaults +
- State saving with localStorage +
- Custom events +
API
+-
+
- Dynamically add a new row +
- Individual column filtering (using "input" elements) +
- Individual column filtering (using "select" elements) +
- Highlight rows and columns +
- Show and hide details about a particular record +
- User selectable rows (multiple rows) +
- User selectable rows (single row) and delete rows +
- Editable rows (with jEditable) +
- Submit form with elements in table +
- Index column (static number column) +
- Show and hide columns dynamically +
- API function use in initialisation object (callback) +
- DataTables scrolling and tabs +
- Regular expression filtering +
+
+
+
+
+ Data sources
+-
+
- DOM +
- Javascript array +
- Ajax source +
- Server side processing +
Server-side processing
+-
+
- Obtain server-side data +
- Add extra HTTP variables +
- Use HTTP POST +
- Automatic addition of IDs and classes to rows +
- Reading table data from objects +
- Show and hide details about a particular record +
- User selectable rows (multiple rows) +
- JSONP for a cross domain data source +
- jEditable integration with DataTables +
- Deferred loading of Ajax data +
- Pipelining data (reduce Ajax calls for paging) +
Ajax data source
+-
+
- Ajax sourced data (array of arrays) +
- Ajax sourced data (array of objects) +
- Deferred DOM creation for extra speed +
- Empty data source columns +
- Use a data source other than aaData (the default) +
- Read column data from sub-arrays +
- Read column data from deeply nested properties +