1
0
mirror of https://github.com/DataTables/DataTables.git synced 2024-12-04 16:24:11 +01:00
Commit Graph

873 Commits

Author SHA1 Message Date
Allan Jardine
8e583a51b3 New: cells() and cell() API methods now accept a cell selector and options
- For consistency and completeness, the cell() and cells() methods now
  accept their own cell selector option (rather than just rows and
  columns) which is a jQuery selector, or no selector at all for all
  cells. Additionally it allows an options object to be passed in, to
  allow configuraiton of the order of data etc.

- The cells() method now has these calling options:
  - cells() - all cells
  - cells( opts ) - option configuration
  - cells( selector ) - cell selector
  - cells( selector, opts ) - cell selector + options
  - cells( rowSelector, columnSelector ) - row + column selector
  - cells( rowSelector, columnSelector, opts ) - row + column selector +
    opttions

- The cell() method as the same signature.
2013-05-23 19:07:30 +01:00
Allan Jardine
a30468a1f4 API: rows.add() and row.add() return a rows() (or row()) extended object
with newly added rows

- Looking at fnAddData, and about to replace it, I realised that
  fnAddData returned the indexes of the newly added row while the new
  methods didn't. It makes sense for row.add() to return a row()
  extended object with the newly added rows so row().node() etc can be
  used. Also the indexes are in the inst, so that information is also
  available. Likewise is done for its plural counterpart.

- Did consider creating an `augment` static method for the API, and
  might yet do this, but this is the only place to use it at the moment.
  Possibly it might be useful for plug-ins, but before adding, lets see
  how the new API is used.
2013-05-22 12:16:19 +01:00
Allan Jardine
fddc869390 API: Promote row().index() to work for plurals as well
- With the new plural option for registering API methods, there is no
  harm in adding rows().index() to get the indexes of the selected rows.
2013-05-20 08:55:42 +01:00
Allan Jardine
0ab8eb7ed0 Internal: Small enhancement to registerPlural to correctly deal with
same instance returns.
2013-05-20 08:45:12 +01:00
Allan Jardine
f5286dc130 Internal: Create registerPlural method to provide an easy way of working
with plurality

- There are four groupings of plural / singular methods in the new API:
  table(s), row(s), column(s) and cell(s). We need to provide similar
  methods for each, often leading to code duplication. To help reduce
  this code duplication I've created a new `registerPlural` method which
  allows both the singular and plural to be derived from a single
  function automatically. The plural form is given and wrapped up by a
  container function which extracts a singular return.

- Note that not all singular methods can use this approach, for example
  row().data() provides extra functionality over rows().data() in that
  it can be used as a setter as well as getter.
2013-05-20 08:37:19 +01:00
Allan Jardine
103e997db8 New: column() API methods for working with a single column
- To round off the API, this commit adds a column() method, for working
  with a single column, as with row/rows, cell/cells and table/tables.

- New methods:
  - column() - Column selector
  - column().data() - Get column data
  - column().header() - Get the column header cell
  - column().visible( set ) - Get / set the column visiblity
  - column().order( dir ) - Order the table by this column

- Note that I haven't implemented column().search() yet as I'm sure
  there must be a better way of dealing with the singular functions...
  Need to look at the four groups a bit more before this (and then the
  API :-) ) is finalised
2013-05-19 15:53:54 +01:00
Allan Jardine
1b4688cdf3 API: Consistency of data return for columns().data()
- The columns().data() method was flattening the returned array. While
  possibly okay on its own, that doesn't match the behaviour of how
  rows().data() works, where each row is an entry in the array, rather
  than the array being flattened. As such I've changed columns().data()
  to work work in the say way, for each column you select, you get an
  entry in the api instance - an array with the data for the that
  column.

- To allow for hte fact that some may want to work with the flattened
  data, I've added a `flatten()` method to the instance base, which is
  basically a shortcut call to `reduce`.
2013-05-19 09:54:46 +01:00
Allan Jardine
f0a73ce595 Dev: Removing row and column .cells() methods
- Now that we have the cells() / cell() methods, with the ability to
  select based on column and row, and the ability to get the whole row
  or column cells, the TD get methods on row / rows / columns were
  redundant and I think should be removed for berevity. It could also
  get confusing with the chaining since there are nested and top level
  methods with the same name.

- Removed:
  - rows().cells()
  - row().cells()
  - columns().cells()
2013-05-19 08:49:43 +01:00
Allan Jardine
1894b96a42 New: cell set data API method
- New API call:
  - cell().data( set ) - Ability to set data for a single cell. Will
    invalidate the whole row.
2013-05-19 08:47:33 +01:00
Allan Jardine
1590f41525 New: cell invalidation methods
- New API methods:
  - cell().invalidate() - Invalidate a single cell
  - cells().invalidate() - Invalidate multiple cells

- Note that the invalidation is actually row based, rather than cell
  based - i.e. the whole row is invalidated. This may change in future
  versions of DataTables, but I'm concerned that it would add a lot of
  code for little enhancement.
2013-05-19 08:43:45 +01:00
Allan Jardine
643930c33d Merge pull request #196 from timtucker/patch-38
Remove index from map call in pluck
2013-05-18 11:00:12 -07:00
Allan Jardine
623b24329a New: New cell based API methods
- New API methods:
  - cells( rowSelector, columnSelector, opts ) - Cell selector
  - cells( ... ).nodes() - Get the nodes for the selected cells
  - cells( ... ).data() - Get the data for the selected cells
  - cell( rowSelector, columnSelector, opts ) - Single cell selector
  - cell( ... ).node() - Get the cell node
  - cell( ... ).data() - Get the cell data

- There was a bug in `_selector_first` whereby it wasn't correctly
  reducing the set - was gatting away with it before, because it was
  reducing to a single element array, which has a toString() method
  which allowed it to appear to work for integers.
2013-05-18 18:56:04 +01:00
Allan Jardine
903d1219f3 New: table() API methods
- New API methods:
  - table() - select a single table
  - table().node() - get the table node for the table

- To be honest, these methods are not likely to be used particuarly
  often, so I think they are fairly low priority, but they could provide
  useful, and it is a public way to get the table node.
2013-05-18 17:39:03 +01:00
Tim Tucker
a74348f56a Remove index from map call in pluck
Pluck isn't using the index, so it's safe to remove the ", i" from the function call passed to map.  Not much, but at least a few fewer bytes.
2013-05-18 09:19:34 -03:00
Allan Jardine
d7b12bd83b New: Invalidation and data set methods.
- New API methods:
  - rows().invalidate() - Invalidate the matched rows
  - row().invalidate() - Invalidate the matched row
  - row().data( set ) - Set the data to use for the matched row

- This involves building upon the invalidation work done in the last few
  commits and creating an invalidation function. This new function will
  mark the cached data as invalid for re-reading by the sort and
  filtering methods (this will need to be abstracted into modules in
  1.11, but there is no infrastructure for that yet - that's what 1.11
  is all about). Additionally the invalidation method will update either
  the data held by DataTables (read from the DOM), or update the DOM if
  the data source was not the DOM. A flag allows an override to state
  the direction, although I think that generally speaking you might not
  want to use the override (you might nuke parts of your data source
  object if you read from the dom for example).
2013-05-18 11:49:48 +01:00
Allan Jardine
fbc28624ac Internal: Filtering invalidation
- Like sorting, for the new API we need to be able to invalidate data
  held for filtering in a fairly simple manner (it could be done before,
  but it was messy, see fnUpdate - you need to call the methods in the
  parent function, rather than just invalidating). This commit adds that
  ability to DataTables.

- Performance improvements:
  - The big one is that filtering data is only obtained and formatted
    when invalidated, rather than every full filter now.

  - Regular expressions for newline and HTML matching are variables,
    rather than redefined on every call.

  - DIV for reading text version of an HTML formatted string is a
    variable, rather than being recreated on every call.

- Type based formatters have been moved into the extension API ('string'
  and 'html'). They can be overridden there if wanted. Allows
  simplication of the call for the formatter.

- Fixes issue #158 as part of the refactoring.

- Smaller by 22 bytes (compressed)... Likely once invalidation is fully
  implemented that will be swallowed up...
2013-05-17 12:00:19 +01:00
Allan Jardine
6a6eed2db3 Internal: Refactor sorting classes for size and efficiency
- Refactoring _fnSortingClasses to be more efficient in how it operates
  and to compress better. This is done by looping first over the
  elements to have their classes removed, and then looping over only
  those to have them added. Previous all columns were operated upon.
  Also using _pluck and that fact that all cells fromt he tbody are
  stored makes the code much smaller, more readable and compressable.
  Only 0.5KiB saved in the refactor, but every little helps...

- Restored column sorting classes functionality that had been disabled
  earlier in the 1.10 development sequence.
2013-05-17 09:48:21 +01:00
Allan Jardine
9f1cae4528 Internal: Refactor sort listener
- Think this code was in DataTables 1.0 and has been relatively
  untouched! A refactor allows it to be more readable and smaller when
  compressed (about 450 bytes saved)
2013-05-16 18:13:37 +01:00
Allan Jardine
682aa73d56 Internal: Refactor ARIA sorting attributes
- How the Aria sorting attributes were controlled, was ugly! Was in bad
  need of a refactor, which has now had. About 150 bytes (compressed)
  saved.
2013-05-16 17:37:34 +01:00
Allan Jardine
4913226456 Internal: Refactoring the sort functions for invalidation
- invalidation is going to play an important part in the new API, with
  the ability to invalid the cached data for sorting, filtering, display
  etc so we need to be able tos upport this in the core.

- In fairness the sorting didn't actually need invalidation because it
  would always get data on every sort, which is bad for performance -
  proper invalidation and caching will resolve this. Which is what has
  been implemented here.

- I had expected (hoped) to be able to save a bit of space in the
  refactor, but only aorund 100 bytes (compressed) saved, which will
  probably be lost when the invalidation is fully implemented in the
  API. Still, better performance, tidier code, and no extra space...

Fix: Sorting classes now show multi column sorting when a column is
defined to sort over multiple columns (sortData). Previously it would
only show the first column.
2013-05-16 17:16:04 +01:00
Allan Jardine
67d19ac9e4 Dev: Fix issue with the last commit which introduced an error witht he
classes calculated for display
2013-05-16 17:15:14 +01:00
Allan Jardine
b12ffb1dab New: row.add() and rows.add() methods for the new API
- Two new methods for the new API to allow new data (rows) to be added
  to the table.

  - row.add() - Add a single row to the table. object, array, jQuery
    object or TR node can be passed in.

  - rows.add() - Add one or more rows to the table from a source array.
    An array or jQuery object must be passed in, containing objects,
    arrays, or TR nodes (or any combination thereof).

- Should be noted that this is iterated over all tables in the current
  API context, so care should be taken when adding a node to multiple
  tables, since it will be moved between them. Equally, when adding
  data, the original object reference is retained, so changing it in one
  table will change it in all!

- These two methods effectively replace fnAddData from the old API.
  fnAddData had a few issues with distingusihing a multiple row add and
  a single row add, since arrays could be used for both (indeed, it
  simply couldn't cope with something like using a single integer as
  reference for a data object, which can now be done in 1.10). The two
  new methods sidestep this problem by providing one method for multiple
  row add, and another for single row add - the developer needs to know
  that the plural has meaning here!
2013-05-16 10:26:08 +01:00
Allan Jardine
5548d09ecd Merge branch 'patch-35' of https://github.com/timtucker/DataTables into 1_10_wip 2013-05-15 15:09:23 +01:00
Allan Jardine
89b2404511 New: columns().order() method for the new API
- I think it makes intuative sense to be able to tell the table to order
  on the columns given by the selector, which is exactly what this
  method does.
2013-05-15 12:02:57 +01:00
Tim Tucker
aa70a483d4 Make fewer calls to $.inArray when assigning sort classes
Only call once each to check to see sort ascending / sort descending is is active.  (And only check for the descending class if we didn't find the ascending class)

Should also lead to smaller minified code.
2013-05-15 07:58:25 -03:00
Allan Jardine
d9119fc3cb New: destroy() method for the new API
- Addition of a destroy method for the new API, effectively replacing
  fnDestroy from the old API.

- The functionality is identical to fnDestroy, but it has been
  refactored to make better use of jQuery and allow for better
  compression (should be 1/4 - 1/2 KiB saved)
2013-05-15 11:34:40 +01:00
Allan Jardine
c211a74079 Dev: Tidy up new settings() method, doesn't actually need an iterator 2013-05-14 08:52:50 +01:00
Allan Jardine
d051a17926 New: $, clear, settings, on, one and off methods for new API
- $ - perform a jQuery selector on the nodes in the table (matching the
  $ method from the old API).

- clear - clear the table completely (replaces fnClearTable).

- settings - get an array of the settings objects for the tables used in
  the API instance.

- on - jQuery event listener proxy. Use for table specific events
  ('draw', 'xhr' etc).

- one - jQuery event listener proxy (single event).

- off - jQuery event unlistener proxy.
2013-05-14 08:47:06 +01:00
Allan Jardine
30c6a45067 Dev: Refector _fnGetDataMaster and _fnClearTable to be shorter and clearer 2013-05-14 08:46:21 +01:00
Allan Jardine
bd804fdcb8 New: child row API methods for showing / hiding child rows
- Showing and hiding details about a row in a child row is very useful
  and proven to be a popular part of DataTables. This commit provides
  that ability in the new API and extends it. It also fully modularises
  the child rows aspects, so it could be removed from the core without
  effecting any other aspects (it may be moved into a seperate file in
  future).

- This will effectively replace fnOpen, fnClose and fnIsOpen

- Added methods:
  - row( selector, opts ).child()
  - row( selector, opts ).child( str, class )
  - row( selector, opts ).child( str, class ).show()
  - row( selector, opts ).child( str, class ).hide()
  - row( selector, opts ).child.show()
  - row( selector, opts ).child.hide()
  - row( selector, opts ).child.isShown()

- Note that unlike the old API you need to specify the data first, and
  then use the show() method to show the child row. This allows the
  details rows to be configured before they are actually shown.

- Additionally multiple child rows can be attached to a parent (pass
  `str` (from above) as an array to use this feature. API plug-ins could
  use this ability to show fully nested tables.

- Not just a string can be passed in now, but also a TR node which will
  actually be used (rather than put into a nested row), any other type
  of node (which will be inserted into a wrapper row/cell) or a jQuery
  object.
2013-05-07 17:56:07 +01:00
Allan Jardine
ed34f7972d New: row() methods - operate on a single row.
- The rows() method allows operations on multiple rows with a single
  call, this new singualr option, `row()` performs operations on a
  single row, allowing fine grain control and easy access to certain
  aspects. For example. `rows().data()` will return an array of data
  objects, even if there is only one row as a result of the selector,
  while `row().data()` will return the data object directly.

- Impletemented thus far:

  - row()
  - row().node()
  - row().cells()
  - row().data() - get only as of yet
  - row().index()
  - row().remove()
2013-05-06 07:14:43 +01:00
Allan Jardine
955eb2cd99 Internal: Update the the filtering input control to update itself on filter
- Previously it was the domain of the filtering caller to update the
  global filtering input element (fnFilter or the keypress handler
  specifically), but in keeping with the drive towards modularity, it
  should be the control itself that updates when needed.

- This is done by listening for the `filter` event from the table and
  updating the display as needed. It is a touch less efficent since the
  same value might be written as what is already there, but it reduces
  code size and complexity.
2013-04-29 07:58:53 +01:00
Allan Jardine
d7058eb45d New: search() and columns().search() API methods
- Ability to filter the table through the new API.

- This effectively replaces the fnFilter method of the old API.

- Note that one capability which has been removed from the old API is the
  ability to not show the new filter on the filtering input elements. I
  can't see any use for that feature to be honest, so it has been
  dropped. The filtering inputs always show the global filter state now.

- Additionally, note that we've been forced to call this `search` here
  rather than `filter` since there is a `filter` method for the API
  collection instance. This might be revisted before release.
2013-04-29 07:51:41 +01:00
Allan Jardine
2b0a321dd2 New: rows().remove() API method
- Remove (delete) selected rows from the table.

- This effectively replaces the fnDeleteRow API method of the old API.
2013-04-29 07:50:43 +01:00
Allan Jardine
a767c05f1d New: column.index() API method for translating column indexes
- The fnVisibleToColumnIndex and fnColumnIndexToVisible plug-in API
  methods for the old API were very useful for transforming the visible
  column index to the actual index, and the return. This adds that
  capability to the new API.
2013-04-28 18:31:15 +01:00
Allan Jardine
7b6ebd63de New: columns.adjust() API method.
- Recalculate the "ideal" column sizes for the table. Might want this
  after a column visiblity change for example

- Replaces the fnAdjustColumnSizing method.
2013-04-28 10:23:43 +01:00
Allan Jardine
bbb423ee75 New: API method columns().visible() - get / set column visiblity
- This effectively replaces the old fnSetColumnVis method (a shim will
  be put in place along with the shim for the rest of the old API). It
  has added get abilities, and the option, like the rest of the new API
  to work on multiple tables / columns with a single call depending on
  the context and selector.
2013-04-28 10:14:04 +01:00
Allan Jardine
8e1bf972d4 New: columns().data() API method - get the data for the selected columns 2013-04-28 09:05:03 +01:00
Allan Jardine
68ea9af828 New - rows().cells(), columns.cells() API methods.
- row options for column selector

- Selectors (table, rows and columns) now held in a single file, sharing
  structure. A more unified API is used, with row options also being
  allow for columns, through the use of the second parameter for the
  columns() method, which will effect how a column function can act upon
  rows (for example, the order of the rows when getting data or nodes).

- Dev: tables() is no longer an iterator - using an `iterator()` method
  with options which are suitable for the different types of iteration
  the API needs.
2013-04-28 08:53:05 +01:00
Allan Jardine
638a1f6225 Fix #186 - Examples - fix typo 2013-04-23 17:15:29 +01:00
Allan Jardine
b1b4b58a9a Internal - remove _fnGetTrNodes
- Not used anywhere outside the old API, which is going to be shimed to
  the new one, so we can simply drop it.
2013-04-23 10:21:48 +01:00
Allan Jardine
01bc1f728d Internal - store cell reference | remove _fnGetTdNodes
- We use the cell nodes form the table body in a number of places, and
  increasing with the new API, so rather than just storing a reference
  to the hidden cells, we should just store a reference to all cells and
  use them, cleaning up a number of other areas - in particular
  _fnGetTdNodes which is no longer needed

- Should do something similar for _fnGetTrNodes

- Disabled sort classes for the moment as that can be rewritten to be
  more efficient. It did use _fnGetTdNodes, but doesn't need to now.

- API fnSetColumnVis and fnUpdate will be broken at the moment, until
  merged into the new API.
2013-04-23 09:50:59 +01:00
Allan Jardine
bb75f22233 Dev fix - Inverted logic for the information string 2013-04-23 09:50:23 +01:00
Allan Jardine
31b521291c Merge branches 'master' and '1_10_wip' into 1_10_wip 2013-04-23 09:36:40 +01:00
Allan Jardine
a3b90fd0cc New: API methods rows().nodes(), rows().data() and columns().header()
- rows().nodes() - Get the TR nodes for the selected rows
- rows().data() - Get the data for the selected rows
- columns().header() - Get the header cells for the selected columns

- This also introduces the `iterator` method to the API instance, which
  can be used to loop over selected columns / rows, for the context
  (tables), returning a flat array / API instance.
2013-04-23 08:49:06 +01:00
Allan Jardine
c53806feee Fix #184 - examples - typo in y scrolling example 2013-04-23 06:56:58 +01:00
Allan Jardine
b3509a84e8 Fix #183 - examples - typo in sDom example 2013-04-23 06:55:49 +01:00
Allan Jardine
6a5415fe34 Fix #182 - examples - typo in multiple tables example 2013-04-23 06:54:22 +01:00
Allan Jardine
fcc7d4a78d Internal - refactor of table information control 2013-04-22 18:56:20 +01:00
Allan Jardine
be611d0db8 Update: Header for the minified file has been reduced to save a bit of space 2013-04-22 18:55:50 +01:00