Self hosted FLOSS fitness/workout, nutrition and weight tracker
Show last activity on gym member list
Roland Geidera897e4443f21
diff --git a/wger/core/helpers.py b/wger/core/helpers.pynew file mode 100644index 000000000..2b132ecd7--- /dev/null+++ b/wger/core/helpers.py@@ -0,0 +1,46 @@+# -*- coding: utf-8 -*-++# This file is part of wger Workout Manager.+#+# wger Workout Manager is free software: you can redistribute it and/or modify+# it under the terms of the GNU Affero General Public License as published by+# the Free Software Foundation, either version 3 of the License, or+# (at your option) any later version.+#+# wger Workout Manager is distributed in the hope that it will be useful,+# but WITHOUT ANY WARRANTY; without even the implied warranty of+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+# GNU General Public License for more details.+#+# You should have received a copy of the GNU Affero General Public License++from wger.manager.models import WorkoutLog+from wger.manager.models import WorkoutSession+++def get_user_last_activity(user):+ '''+ Find out when the user was last active. "Active" means in this context logging+ a weight, or saving a workout session.++ :param user: user object+ :return: a date or None if nothing was found+ '''++ # Check workout logs+ log_list = WorkoutLog.objects.filter(user=user).order_by('date')+ last_activity = None+ if log_list.exists():+ last_activity = log_list.last().date++ # Check workout sessions+ log_session = WorkoutSession.objects.filter(user=user).order_by('date')+ if log_session.exists():+ last_session = log_session.last().date+ if not last_activity:+ last_activity = last_session++ if last_activity < last_session:+ last_activity = last_session++ return last_activitydiff --git a/wger/core/static/css/jquery.dataTables.css b/wger/core/static/css/jquery.dataTables.cssnew file mode 100644index 000000000..4e6fbe38b--- /dev/null+++ b/wger/core/static/css/jquery.dataTables.css@@ -0,0 +1,476 @@+/*+ * Table styles+ */+table.dataTable {+ width: 100%;+ margin: 0 auto;+ clear: both;+ border-collapse: separate;+ border-spacing: 0;+ /*+ * Header and footer styles+ */+ /*+ * Body styles+ */+}+table.dataTable thead th,+table.dataTable tfoot th {+ font-weight: bold;+}+table.dataTable thead th,+table.dataTable thead td {+ padding: 10px 18px;+ border-bottom: 1px solid #111111;+}+table.dataTable thead th:active,+table.dataTable thead td:active {+ outline: none;+}+table.dataTable tfoot th,+table.dataTable tfoot td {+ padding: 10px 18px 6px 18px;+ border-top: 1px solid #111111;+}+table.dataTable thead .sorting_asc,+table.dataTable thead .sorting_desc,+table.dataTable thead .sorting {+ cursor: pointer;+ *cursor: hand;+}+table.dataTable thead .sorting {+ background: url("../images/sort_both.png") no-repeat center right;+}+table.dataTable thead .sorting_asc {+ background: url("../images/sort_asc.png") no-repeat center right;+}+table.dataTable thead .sorting_desc {+ background: url("../images/sort_desc.png") no-repeat center right;+}+table.dataTable thead .sorting_asc_disabled {+ background: url("../images/sort_asc_disabled.png") no-repeat center right;+}+table.dataTable thead .sorting_desc_disabled {+ background: url("../images/sort_desc_disabled.png") no-repeat center right;+}+table.dataTable tbody tr {+ background-color: white;+}+table.dataTable tbody tr.selected {+ background-color: #b0bed9;+}+table.dataTable tbody th,+table.dataTable tbody td {+ padding: 8px 10px;+}+table.dataTable.row-border tbody th, table.dataTable.row-border tbody td, table.dataTable.display tbody th, table.dataTable.display tbody td {+ border-top: 1px solid #dddddd;+}+table.dataTable.row-border tbody tr:first-child th,+table.dataTable.row-border tbody tr:first-child td, table.dataTable.display tbody tr:first-child th,+table.dataTable.display tbody tr:first-child td {+ border-top: none;+}+table.dataTable.cell-border tbody th, table.dataTable.cell-border tbody td {+ border-top: 1px solid #dddddd;+ border-right: 1px solid #dddddd;+}+table.dataTable.cell-border tbody tr th:first-child,+table.dataTable.cell-border tbody tr td:first-child {+ border-left: 1px solid #dddddd;+}+table.dataTable.cell-border tbody tr:first-child th,+table.dataTable.cell-border tbody tr:first-child td {+ border-top: none;+}+table.dataTable.stripe tbody tr.odd, table.dataTable.display tbody tr.odd {+ background-color: #f9f9f9;+}+table.dataTable.stripe tbody tr.odd.selected, table.dataTable.display tbody tr.odd.selected {+ background-color: #abb9d3;+}+table.dataTable.hover tbody tr:hover,+table.dataTable.hover tbody tr.odd:hover,+table.dataTable.hover tbody tr.even:hover, table.dataTable.display tbody tr:hover,+table.dataTable.display tbody tr.odd:hover,+table.dataTable.display tbody tr.even:hover {+ background-color: whitesmoke;+}+table.dataTable.hover tbody tr:hover.selected,+table.dataTable.hover tbody tr.odd:hover.selected,+table.dataTable.hover tbody tr.even:hover.selected, table.dataTable.display tbody tr:hover.selected,+table.dataTable.display tbody tr.odd:hover.selected,+table.dataTable.display tbody tr.even:hover.selected {+ background-color: #a9b7d1;+}+table.dataTable.order-column tbody tr > .sorting_1,+table.dataTable.order-column tbody tr > .sorting_2,+table.dataTable.order-column tbody tr > .sorting_3, table.dataTable.display tbody tr > .sorting_1,+table.dataTable.display tbody tr > .sorting_2,+table.dataTable.display tbody tr > .sorting_3 {+ background-color: #f9f9f9;+}+table.dataTable.order-column tbody tr.selected > .sorting_1,+table.dataTable.order-column tbody tr.selected > .sorting_2,+table.dataTable.order-column tbody tr.selected > .sorting_3, table.dataTable.display tbody tr.selected > .sorting_1,+table.dataTable.display tbody tr.selected > .sorting_2,+table.dataTable.display tbody tr.selected > .sorting_3 {+ background-color: #acbad4;+}+table.dataTable.display tbody tr.odd > .sorting_1, table.dataTable.order-column.stripe tbody tr.odd > .sorting_1 {+ background-color: #f1f1f1;+}+table.dataTable.display tbody tr.odd > .sorting_2, table.dataTable.order-column.stripe tbody tr.odd > .sorting_2 {+ background-color: #f3f3f3;+}+table.dataTable.display tbody tr.odd > .sorting_3, table.dataTable.order-column.stripe tbody tr.odd > .sorting_3 {+ background-color: whitesmoke;+}+table.dataTable.display tbody tr.odd.selected > .sorting_1, table.dataTable.order-column.stripe tbody tr.odd.selected > .sorting_1 {+ background-color: #a6b3cd;+}+table.dataTable.display tbody tr.odd.selected > .sorting_2, table.dataTable.order-column.stripe tbody tr.odd.selected > .sorting_2 {+ background-color: #a7b5ce;+}+table.dataTable.display tbody tr.odd.selected > .sorting_3, table.dataTable.order-column.stripe tbody tr.odd.selected > .sorting_3 {+ background-color: #a9b6d0;+}+table.dataTable.display tbody tr.even > .sorting_1, table.dataTable.order-column.stripe tbody tr.even > .sorting_1 {+ background-color: #f9f9f9;+}+table.dataTable.display tbody tr.even > .sorting_2, table.dataTable.order-column.stripe tbody tr.even > .sorting_2 {+ background-color: #fbfbfb;+}+table.dataTable.display tbody tr.even > .sorting_3, table.dataTable.order-column.stripe tbody tr.even > .sorting_3 {+ background-color: #fdfdfd;+}+table.dataTable.display tbody tr.even.selected > .sorting_1, table.dataTable.order-column.stripe tbody tr.even.selected > .sorting_1 {+ background-color: #acbad4;+}+table.dataTable.display tbody tr.even.selected > .sorting_2, table.dataTable.order-column.stripe tbody tr.even.selected > .sorting_2 {+ background-color: #adbbd6;+}+table.dataTable.display tbody tr.even.selected > .sorting_3, table.dataTable.order-column.stripe tbody tr.even.selected > .sorting_3 {+ background-color: #afbdd8;+}+table.dataTable.display tbody tr:hover > .sorting_1,+table.dataTable.display tbody tr.odd:hover > .sorting_1,+table.dataTable.display tbody tr.even:hover > .sorting_1, table.dataTable.order-column.hover tbody tr:hover > .sorting_1,+table.dataTable.order-column.hover tbody tr.odd:hover > .sorting_1,+table.dataTable.order-column.hover tbody tr.even:hover > .sorting_1 {+ background-color: #eaeaea;+}+table.dataTable.display tbody tr:hover > .sorting_2,+table.dataTable.display tbody tr.odd:hover > .sorting_2,+table.dataTable.display tbody tr.even:hover > .sorting_2, table.dataTable.order-column.hover tbody tr:hover > .sorting_2,+table.dataTable.order-column.hover tbody tr.odd:hover > .sorting_2,+table.dataTable.order-column.hover tbody tr.even:hover > .sorting_2 {+ background-color: #ebebeb;+}+table.dataTable.display tbody tr:hover > .sorting_3,+table.dataTable.display tbody tr.odd:hover > .sorting_3,+table.dataTable.display tbody tr.even:hover > .sorting_3, table.dataTable.order-column.hover tbody tr:hover > .sorting_3,+table.dataTable.order-column.hover tbody tr.odd:hover > .sorting_3,+table.dataTable.order-column.hover tbody tr.even:hover > .sorting_3 {+ background-color: #eeeeee;+}+table.dataTable.display tbody tr:hover.selected > .sorting_1,+table.dataTable.display tbody tr.odd:hover.selected > .sorting_1,+table.dataTable.display tbody tr.even:hover.selected > .sorting_1, table.dataTable.order-column.hover tbody tr:hover.selected > .sorting_1,+table.dataTable.order-column.hover tbody tr.odd:hover.selected > .sorting_1,+table.dataTable.order-column.hover tbody tr.even:hover.selected > .sorting_1 {+ background-color: #a1aec7;+}+table.dataTable.display tbody tr:hover.selected > .sorting_2,+table.dataTable.display tbody tr.odd:hover.selected > .sorting_2,+table.dataTable.display tbody tr.even:hover.selected > .sorting_2, table.dataTable.order-column.hover tbody tr:hover.selected > .sorting_2,+table.dataTable.order-column.hover tbody tr.odd:hover.selected > .sorting_2,+table.dataTable.order-column.hover tbody tr.even:hover.selected > .sorting_2 {+ background-color: #a2afc8;+}+table.dataTable.display tbody tr:hover.selected > .sorting_3,+table.dataTable.display tbody tr.odd:hover.selected > .sorting_3,+table.dataTable.display tbody tr.even:hover.selected > .sorting_3, table.dataTable.order-column.hover tbody tr:hover.selected > .sorting_3,+table.dataTable.order-column.hover tbody tr.odd:hover.selected > .sorting_3,+table.dataTable.order-column.hover tbody tr.even:hover.selected > .sorting_3 {+ background-color: #a4b2cb;+}+table.dataTable.no-footer {+ border-bottom: 1px solid #111111;+}+table.dataTable.nowrap th, table.dataTable.nowrap td {+ white-space: nowrap;+}+table.dataTable.compact thead th,+table.dataTable.compact thead td {+ padding: 5px 9px;+}+table.dataTable.compact tfoot th,+table.dataTable.compact tfoot td {+ padding: 5px 9px 3px 9px;+}+table.dataTable.compact tbody th,+table.dataTable.compact tbody td {+ padding: 4px 5px;+}+table.dataTable th.dt-left,+table.dataTable td.dt-left {+ text-align: left;+}+table.dataTable th.dt-center,+table.dataTable td.dt-center,+table.dataTable td.dataTables_empty {+ text-align: center;+}+table.dataTable th.dt-right,+table.dataTable td.dt-right {+ text-align: right;+}+table.dataTable th.dt-justify,+table.dataTable td.dt-justify {+ text-align: justify;+}+table.dataTable th.dt-nowrap,+table.dataTable td.dt-nowrap {+ white-space: nowrap;+}+table.dataTable thead th.dt-head-left,+table.dataTable thead td.dt-head-left,+table.dataTable tfoot th.dt-head-left,+table.dataTable tfoot td.dt-head-left {+ text-align: left;+}+table.dataTable thead th.dt-head-center,+table.dataTable thead td.dt-head-center,+table.dataTable tfoot th.dt-head-center,+table.dataTable tfoot td.dt-head-center {+ text-align: center;+}+table.dataTable thead th.dt-head-right,+table.dataTable thead td.dt-head-right,+table.dataTable tfoot th.dt-head-right,+table.dataTable tfoot td.dt-head-right {+ text-align: right;+}+table.dataTable thead th.dt-head-justify,+table.dataTable thead td.dt-head-justify,+table.dataTable tfoot th.dt-head-justify,+table.dataTable tfoot td.dt-head-justify {+ text-align: justify;+}+table.dataTable thead th.dt-head-nowrap,+table.dataTable thead td.dt-head-nowrap,+table.dataTable tfoot th.dt-head-nowrap,+table.dataTable tfoot td.dt-head-nowrap {+ white-space: nowrap;+}+table.dataTable tbody th.dt-body-left,+table.dataTable tbody td.dt-body-left {+ text-align: left;+}+table.dataTable tbody th.dt-body-center,+table.dataTable tbody td.dt-body-center {+ text-align: center;+}+table.dataTable tbody th.dt-body-right,+table.dataTable tbody td.dt-body-right {+ text-align: right;+}+table.dataTable tbody th.dt-body-justify,+table.dataTable tbody td.dt-body-justify {+ text-align: justify;+}+table.dataTable tbody th.dt-body-nowrap,+table.dataTable tbody td.dt-body-nowrap {+ white-space: nowrap;+}++table.dataTable,+table.dataTable th,+table.dataTable td {+ -webkit-box-sizing: content-box;+ -moz-box-sizing: content-box;+ box-sizing: content-box;+}++/*+ * Control feature layout+ */+.dataTables_wrapper {+ position: relative;+ clear: both;+ *zoom: 1;+ zoom: 1;+}+.dataTables_wrapper .dataTables_length {+ float: left;+}+.dataTables_wrapper .dataTables_filter {+ float: right;+ text-align: right;+}+.dataTables_wrapper .dataTables_filter input {+ margin-left: 0.5em;+}+.dataTables_wrapper .dataTables_info {+ clear: both;+ float: left;+ padding-top: 0.755em;+}+.dataTables_wrapper .dataTables_paginate {+ float: right;+ text-align: right;+ padding-top: 0.25em;+}+.dataTables_wrapper .dataTables_paginate .paginate_button {+ box-sizing: border-box;+ display: inline-block;+ min-width: 1.5em;+ padding: 0.5em 1em;+ margin-left: 2px;+ text-align: center;+ text-decoration: none !important;+ cursor: pointer;+ *cursor: hand;+ color: #333333 !important;+ border: 1px solid transparent;+}+.dataTables_wrapper .dataTables_paginate .paginate_button.current, .dataTables_wrapper .dataTables_paginate .paginate_button.current:hover {+ color: #333333 !important;+ border: 1px solid #cacaca;+ background-color: white;+ background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, white), color-stop(100%, gainsboro));+ /* Chrome,Safari4+ */+ background: -webkit-linear-gradient(top, white 0%, gainsboro 100%);+ /* Chrome10+,Safari5.1+ */+ background: -moz-linear-gradient(top, white 0%, gainsboro 100%);+ /* FF3.6+ */+ background: -ms-linear-gradient(top, white 0%, gainsboro 100%);+ /* IE10+ */+ background: -o-linear-gradient(top, white 0%, gainsboro 100%);+ /* Opera 11.10+ */+ background: linear-gradient(to bottom, white 0%, gainsboro 100%);+ /* W3C */+}+.dataTables_wrapper .dataTables_paginate .paginate_button.disabled, .dataTables_wrapper .dataTables_paginate .paginate_button.disabled:hover, .dataTables_wrapper .dataTables_paginate .paginate_button.disabled:active {+ cursor: default;+ color: #666 !important;+ border: 1px solid transparent;+ background: transparent;+ box-shadow: none;+}+.dataTables_wrapper .dataTables_paginate .paginate_button:hover {+ color: white !important;+ border: 1px solid #111111;+ background-color: #585858;+ background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #585858), color-stop(100%, #111111));+ /* Chrome,Safari4+ */+ background: -webkit-linear-gradient(top, #585858 0%, #111111 100%);+ /* Chrome10+,Safari5.1+ */+ background: -moz-linear-gradient(top, #585858 0%, #111111 100%);+ /* FF3.6+ */+ background: -ms-linear-gradient(top, #585858 0%, #111111 100%);+ /* IE10+ */+ background: -o-linear-gradient(top, #585858 0%, #111111 100%);+ /* Opera 11.10+ */+ background: linear-gradient(to bottom, #585858 0%, #111111 100%);+ /* W3C */+}+.dataTables_wrapper .dataTables_paginate .paginate_button:active {+ outline: none;+ background-color: #2b2b2b;+ background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #2b2b2b), color-stop(100%, #0c0c0c));+ /* Chrome,Safari4+ */+ background: -webkit-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);+ /* Chrome10+,Safari5.1+ */+ background: -moz-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);+ /* FF3.6+ */+ background: -ms-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);+ /* IE10+ */+ background: -o-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);+ /* Opera 11.10+ */+ background: linear-gradient(to bottom, #2b2b2b 0%, #0c0c0c 100%);+ /* W3C */+ box-shadow: inset 0 0 3px #111;+}+.dataTables_wrapper .dataTables_processing {+ position: absolute;+ top: 50%;+ left: 50%;+ width: 100%;+ height: 40px;+ margin-left: -50%;+ margin-top: -25px;+ padding-top: 20px;+ text-align: center;+ font-size: 1.2em;+ background-color: white;+ background: -webkit-gradient(linear, left top, right top, color-stop(0%, rgba(255, 255, 255, 0)), color-stop(25%, rgba(255, 255, 255, 0.9)), color-stop(75%, rgba(255, 255, 255, 0.9)), color-stop(100%, rgba(255, 255, 255, 0)));+ /* Chrome,Safari4+ */+ background: -webkit-linear-gradient(left, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.9) 25%, rgba(255, 255, 255, 0.9) 75%, rgba(255, 255, 255, 0) 100%);+ /* Chrome10+,Safari5.1+ */+ background: -moz-linear-gradient(left, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.9) 25%, rgba(255, 255, 255, 0.9) 75%, rgba(255, 255, 255, 0) 100%);+ /* FF3.6+ */+ background: -ms-linear-gradient(left, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.9) 25%, rgba(255, 255, 255, 0.9) 75%, rgba(255, 255, 255, 0) 100%);+ /* IE10+ */+ background: -o-linear-gradient(left, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.9) 25%, rgba(255, 255, 255, 0.9) 75%, rgba(255, 255, 255, 0) 100%);+ /* Opera 11.10+ */+ background: linear-gradient(to right, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.9) 25%, rgba(255, 255, 255, 0.9) 75%, rgba(255, 255, 255, 0) 100%);+ /* W3C */+}+.dataTables_wrapper .dataTables_length,+.dataTables_wrapper .dataTables_filter,+.dataTables_wrapper .dataTables_info,+.dataTables_wrapper .dataTables_processing,+.dataTables_wrapper .dataTables_paginate {+ color: #333333;+}+.dataTables_wrapper .dataTables_scroll {+ clear: both;+}+.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody {+ *margin-top: -1px;+ -webkit-overflow-scrolling: touch;+}+.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody th > div.dataTables_sizing,+.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody td > div.dataTables_sizing {+ height: 0;+ overflow: hidden;+ margin: 0 !important;+ padding: 0 !important;+}+.dataTables_wrapper.no-footer .dataTables_scrollBody {+ border-bottom: 1px solid #111111;+}+.dataTables_wrapper.no-footer div.dataTables_scrollHead table,+.dataTables_wrapper.no-footer div.dataTables_scrollBody table {+ border-bottom: none;+}+.dataTables_wrapper:after {+ visibility: hidden;+ display: block;+ content: "";+ clear: both;+ height: 0;+}++@media screen and (max-width: 767px) {+ .dataTables_wrapper .dataTables_info,+ .dataTables_wrapper .dataTables_paginate {+ float: none;+ text-align: center;+ }+ .dataTables_wrapper .dataTables_paginate {+ margin-top: 0.5em;+ }+}+@media screen and (max-width: 640px) {+ .dataTables_wrapper .dataTables_length,+ .dataTables_wrapper .dataTables_filter {+ float: none;+ text-align: center;+ }+ .dataTables_wrapper .dataTables_filter {+ margin-top: 0.5em;+ }+}diff --git a/wger/core/static/css/jquery.dataTables.min.css b/wger/core/static/css/jquery.dataTables.min.cssnew file mode 100644index 000000000..a2c5489c8--- /dev/null+++ b/wger/core/static/css/jquery.dataTables.min.css@@ -0,0 +1 @@+table.dataTable{width:100%;margin:0 auto;clear:both;border-collapse:separate;border-spacing:0}table.dataTable thead th,table.dataTable tfoot th{font-weight:bold}table.dataTable thead th,table.dataTable thead td{padding:10px 18px;border-bottom:1px solid #111}table.dataTable thead th:active,table.dataTable thead td:active{outline:none}table.dataTable tfoot th,table.dataTable tfoot td{padding:10px 18px 6px 18px;border-top:1px solid #111}table.dataTable thead .sorting_asc,table.dataTable thead .sorting_desc,table.dataTable thead .sorting{cursor:pointer;*cursor:hand}table.dataTable thead .sorting{background:url("../images/sort_both.png") no-repeat center right}table.dataTable thead .sorting_asc{background:url("../images/sort_asc.png") no-repeat center right}table.dataTable thead .sorting_desc{background:url("../images/sort_desc.png") no-repeat center right}table.dataTable thead .sorting_asc_disabled{background:url("../images/sort_asc_disabled.png") no-repeat center right}table.dataTable thead .sorting_desc_disabled{background:url("../images/sort_desc_disabled.png") no-repeat center right}table.dataTable tbody tr{background-color:#fff}table.dataTable tbody tr.selected{background-color:#b0bed9}table.dataTable tbody th,table.dataTable tbody td{padding:8px 10px}table.dataTable.row-border tbody th,table.dataTable.row-border tbody td,table.dataTable.display tbody th,table.dataTable.display tbody td{border-top:1px solid #ddd}table.dataTable.row-border tbody tr:first-child th,table.dataTable.row-border tbody tr:first-child td,table.dataTable.display tbody tr:first-child th,table.dataTable.display tbody tr:first-child td{border-top:none}table.dataTable.cell-border tbody th,table.dataTable.cell-border tbody td{border-top:1px solid #ddd;border-right:1px solid #ddd}table.dataTable.cell-border tbody tr th:first-child,table.dataTable.cell-border tbody tr td:first-child{border-left:1px solid #ddd}table.dataTable.cell-border tbody tr:first-child th,table.dataTable.cell-border tbody tr:first-child td{border-top:none}table.dataTable.stripe tbody tr.odd,table.dataTable.display tbody tr.odd{background-color:#f9f9f9}table.dataTable.stripe tbody tr.odd.selected,table.dataTable.display tbody tr.odd.selected{background-color:#abb9d3}table.dataTable.hover tbody tr:hover,table.dataTable.hover tbody tr.odd:hover,table.dataTable.hover tbody tr.even:hover,table.dataTable.display tbody tr:hover,table.dataTable.display tbody tr.odd:hover,table.dataTable.display tbody tr.even:hover{background-color:#f5f5f5}table.dataTable.hover tbody tr:hover.selected,table.dataTable.hover tbody tr.odd:hover.selected,table.dataTable.hover tbody tr.even:hover.selected,table.dataTable.display tbody tr:hover.selected,table.dataTable.display tbody tr.odd:hover.selected,table.dataTable.display tbody tr.even:hover.selected{background-color:#a9b7d1}table.dataTable.order-column tbody tr>.sorting_1,table.dataTable.order-column tbody tr>.sorting_2,table.dataTable.order-column tbody tr>.sorting_3,table.dataTable.display tbody tr>.sorting_1,table.dataTable.display tbody tr>.sorting_2,table.dataTable.display tbody tr>.sorting_3{background-color:#f9f9f9}table.dataTable.order-column tbody tr.selected>.sorting_1,table.dataTable.order-column tbody tr.selected>.sorting_2,table.dataTable.order-column tbody tr.selected>.sorting_3,table.dataTable.display tbody tr.selected>.sorting_1,table.dataTable.display tbody tr.selected>.sorting_2,table.dataTable.display tbody tr.selected>.sorting_3{background-color:#acbad4}table.dataTable.display tbody tr.odd>.sorting_1,table.dataTable.order-column.stripe tbody tr.odd>.sorting_1{background-color:#f1f1f1}table.dataTable.display tbody tr.odd>.sorting_2,table.dataTable.order-column.stripe tbody tr.odd>.sorting_2{background-color:#f3f3f3}table.dataTable.display tbody tr.odd>.sorting_3,table.dataTable.order-column.stripe tbody tr.odd>.sorting_3{background-color:#f5f5f5}table.dataTable.display tbody tr.odd.selected>.sorting_1,table.dataTable.order-column.stripe tbody tr.odd.selected>.sorting_1{background-color:#a6b3cd}table.dataTable.display tbody tr.odd.selected>.sorting_2,table.dataTable.order-column.stripe tbody tr.odd.selected>.sorting_2{background-color:#a7b5ce}table.dataTable.display tbody tr.odd.selected>.sorting_3,table.dataTable.order-column.stripe tbody tr.odd.selected>.sorting_3{background-color:#a9b6d0}table.dataTable.display tbody tr.even>.sorting_1,table.dataTable.order-column.stripe tbody tr.even>.sorting_1{background-color:#f9f9f9}table.dataTable.display tbody tr.even>.sorting_2,table.dataTable.order-column.stripe tbody tr.even>.sorting_2{background-color:#fbfbfb}table.dataTable.display tbody tr.even>.sorting_3,table.dataTable.order-column.stripe tbody tr.even>.sorting_3{background-color:#fdfdfd}table.dataTable.display tbody tr.even.selected>.sorting_1,table.dataTable.order-column.stripe tbody tr.even.selected>.sorting_1{background-color:#acbad4}table.dataTable.display tbody tr.even.selected>.sorting_2,table.dataTable.order-column.stripe tbody tr.even.selected>.sorting_2{background-color:#adbbd6}table.dataTable.display tbody tr.even.selected>.sorting_3,table.dataTable.order-column.stripe tbody tr.even.selected>.sorting_3{background-color:#afbdd8}table.dataTable.display tbody tr:hover>.sorting_1,table.dataTable.display tbody tr.odd:hover>.sorting_1,table.dataTable.display tbody tr.even:hover>.sorting_1,table.dataTable.order-column.hover tbody tr:hover>.sorting_1,table.dataTable.order-column.hover tbody tr.odd:hover>.sorting_1,table.dataTable.order-column.hover tbody tr.even:hover>.sorting_1{background-color:#eaeaea}table.dataTable.display tbody tr:hover>.sorting_2,table.dataTable.display tbody tr.odd:hover>.sorting_2,table.dataTable.display tbody tr.even:hover>.sorting_2,table.dataTable.order-column.hover tbody tr:hover>.sorting_2,table.dataTable.order-column.hover tbody tr.odd:hover>.sorting_2,table.dataTable.order-column.hover tbody tr.even:hover>.sorting_2{background-color:#ebebeb}table.dataTable.display tbody tr:hover>.sorting_3,table.dataTable.display tbody tr.odd:hover>.sorting_3,table.dataTable.display tbody tr.even:hover>.sorting_3,table.dataTable.order-column.hover tbody tr:hover>.sorting_3,table.dataTable.order-column.hover tbody tr.odd:hover>.sorting_3,table.dataTable.order-column.hover tbody tr.even:hover>.sorting_3{background-color:#eee}table.dataTable.display tbody tr:hover.selected>.sorting_1,table.dataTable.display tbody tr.odd:hover.selected>.sorting_1,table.dataTable.display tbody tr.even:hover.selected>.sorting_1,table.dataTable.order-column.hover tbody tr:hover.selected>.sorting_1,table.dataTable.order-column.hover tbody tr.odd:hover.selected>.sorting_1,table.dataTable.order-column.hover tbody tr.even:hover.selected>.sorting_1{background-color:#a1aec7}table.dataTable.display tbody tr:hover.selected>.sorting_2,table.dataTable.display tbody tr.odd:hover.selected>.sorting_2,table.dataTable.display tbody tr.even:hover.selected>.sorting_2,table.dataTable.order-column.hover tbody tr:hover.selected>.sorting_2,table.dataTable.order-column.hover tbody tr.odd:hover.selected>.sorting_2,table.dataTable.order-column.hover tbody tr.even:hover.selected>.sorting_2{background-color:#a2afc8}table.dataTable.display tbody tr:hover.selected>.sorting_3,table.dataTable.display tbody tr.odd:hover.selected>.sorting_3,table.dataTable.display tbody tr.even:hover.selected>.sorting_3,table.dataTable.order-column.hover tbody tr:hover.selected>.sorting_3,table.dataTable.order-column.hover tbody tr.odd:hover.selected>.sorting_3,table.dataTable.order-column.hover tbody tr.even:hover.selected>.sorting_3{background-color:#a4b2cb}table.dataTable.no-footer{border-bottom:1px solid #111}table.dataTable.nowrap th,table.dataTable.nowrap td{white-space:nowrap}table.dataTable.compact thead th,table.dataTable.compact thead td{padding:5px 9px}table.dataTable.compact tfoot th,table.dataTable.compact tfoot td{padding:5px 9px 3px 9px}table.dataTable.compact tbody th,table.dataTable.compact tbody td{padding:4px 5px}table.dataTable th.dt-left,table.dataTable td.dt-left{text-align:left}table.dataTable th.dt-center,table.dataTable td.dt-center,table.dataTable td.dataTables_empty{text-align:center}table.dataTable th.dt-right,table.dataTable td.dt-right{text-align:right}table.dataTable th.dt-justify,table.dataTable td.dt-justify{text-align:justify}table.dataTable th.dt-nowrap,table.dataTable td.dt-nowrap{white-space:nowrap}table.dataTable thead th.dt-head-left,table.dataTable thead td.dt-head-left,table.dataTable tfoot th.dt-head-left,table.dataTable tfoot td.dt-head-left{text-align:left}table.dataTable thead th.dt-head-center,table.dataTable thead td.dt-head-center,table.dataTable tfoot th.dt-head-center,table.dataTable tfoot td.dt-head-center{text-align:center}table.dataTable thead th.dt-head-right,table.dataTable thead td.dt-head-right,table.dataTable tfoot th.dt-head-right,table.dataTable tfoot td.dt-head-right{text-align:right}table.dataTable thead th.dt-head-justify,table.dataTable thead td.dt-head-justify,table.dataTable tfoot th.dt-head-justify,table.dataTable tfoot td.dt-head-justify{text-align:justify}table.dataTable thead th.dt-head-nowrap,table.dataTable thead td.dt-head-nowrap,table.dataTable tfoot th.dt-head-nowrap,table.dataTable tfoot td.dt-head-nowrap{white-space:nowrap}table.dataTable tbody th.dt-body-left,table.dataTable tbody td.dt-body-left{text-align:left}table.dataTable tbody th.dt-body-center,table.dataTable tbody td.dt-body-center{text-align:center}table.dataTable tbody th.dt-body-right,table.dataTable tbody td.dt-body-right{text-align:right}table.dataTable tbody th.dt-body-justify,table.dataTable tbody td.dt-body-justify{text-align:justify}table.dataTable tbody th.dt-body-nowrap,table.dataTable tbody td.dt-body-nowrap{white-space:nowrap}table.dataTable,table.dataTable th,table.dataTable td{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}.dataTables_wrapper{position:relative;clear:both;*zoom:1;zoom:1}.dataTables_wrapper .dataTables_length{float:left}.dataTables_wrapper .dataTables_filter{float:right;text-align:right}.dataTables_wrapper .dataTables_filter input{margin-left:0.5em}.dataTables_wrapper .dataTables_info{clear:both;float:left;padding-top:0.755em}.dataTables_wrapper .dataTables_paginate{float:right;text-align:right;padding-top:0.25em}.dataTables_wrapper .dataTables_paginate .paginate_button{box-sizing:border-box;display:inline-block;min-width:1.5em;padding:0.5em 1em;margin-left:2px;text-align:center;text-decoration:none !important;cursor:pointer;*cursor:hand;color:#333 !important;border:1px solid transparent}.dataTables_wrapper .dataTables_paginate .paginate_button.current,.dataTables_wrapper .dataTables_paginate .paginate_button.current:hover{color:#333 !important;border:1px solid #cacaca;background-color:#fff;background:-webkit-gradient(linear, left top, left bottom, color-stop(0%, #fff), color-stop(100%, #dcdcdc));background:-webkit-linear-gradient(top, #fff 0%, #dcdcdc 100%);background:-moz-linear-gradient(top, #fff 0%, #dcdcdc 100%);background:-ms-linear-gradient(top, #fff 0%, #dcdcdc 100%);background:-o-linear-gradient(top, #fff 0%, #dcdcdc 100%);background:linear-gradient(to bottom, #fff 0%, #dcdcdc 100%)}.dataTables_wrapper .dataTables_paginate .paginate_button.disabled,.dataTables_wrapper .dataTables_paginate .paginate_button.disabled:hover,.dataTables_wrapper .dataTables_paginate .paginate_button.disabled:active{cursor:default;color:#666 !important;border:1px solid transparent;background:transparent;box-shadow:none}.dataTables_wrapper .dataTables_paginate .paginate_button:hover{color:white !important;border:1px solid #111;background-color:#585858;background:-webkit-gradient(linear, left top, left bottom, color-stop(0%, #585858), color-stop(100%, #111));background:-webkit-linear-gradient(top, #585858 0%, #111 100%);background:-moz-linear-gradient(top, #585858 0%, #111 100%);background:-ms-linear-gradient(top, #585858 0%, #111 100%);background:-o-linear-gradient(top, #585858 0%, #111 100%);background:linear-gradient(to bottom, #585858 0%, #111 100%)}.dataTables_wrapper .dataTables_paginate .paginate_button:active{outline:none;background-color:#2b2b2b;background:-webkit-gradient(linear, left top, left bottom, color-stop(0%, #2b2b2b), color-stop(100%, #0c0c0c));background:-webkit-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);background:-moz-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);background:-ms-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);background:-o-linear-gradient(top, #2b2b2b 0%, #0c0c0c 100%);background:linear-gradient(to bottom, #2b2b2b 0%, #0c0c0c 100%);box-shadow:inset 0 0 3px #111}.dataTables_wrapper .dataTables_processing{position:absolute;top:50%;left:50%;width:100%;height:40px;margin-left:-50%;margin-top:-25px;padding-top:20px;text-align:center;font-size:1.2em;background-color:white;background:-webkit-gradient(linear, left top, right top, color-stop(0%, rgba(255,255,255,0)), color-stop(25%, rgba(255,255,255,0.9)), color-stop(75%, rgba(255,255,255,0.9)), color-stop(100%, rgba(255,255,255,0)));background:-webkit-linear-gradient(left, rgba(255,255,255,0) 0%, rgba(255,255,255,0.9) 25%, rgba(255,255,255,0.9) 75%, rgba(255,255,255,0) 100%);background:-moz-linear-gradient(left, rgba(255,255,255,0) 0%, rgba(255,255,255,0.9) 25%, rgba(255,255,255,0.9) 75%, rgba(255,255,255,0) 100%);background:-ms-linear-gradient(left, rgba(255,255,255,0) 0%, rgba(255,255,255,0.9) 25%, rgba(255,255,255,0.9) 75%, rgba(255,255,255,0) 100%);background:-o-linear-gradient(left, rgba(255,255,255,0) 0%, rgba(255,255,255,0.9) 25%, rgba(255,255,255,0.9) 75%, rgba(255,255,255,0) 100%);background:linear-gradient(to right, rgba(255,255,255,0) 0%, rgba(255,255,255,0.9) 25%, rgba(255,255,255,0.9) 75%, rgba(255,255,255,0) 100%)}.dataTables_wrapper .dataTables_length,.dataTables_wrapper .dataTables_filter,.dataTables_wrapper .dataTables_info,.dataTables_wrapper .dataTables_processing,.dataTables_wrapper .dataTables_paginate{color:#333}.dataTables_wrapper .dataTables_scroll{clear:both}.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody{*margin-top:-1px;-webkit-overflow-scrolling:touch}.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody th>div.dataTables_sizing,.dataTables_wrapper .dataTables_scroll div.dataTables_scrollBody td>div.dataTables_sizing{height:0;overflow:hidden;margin:0 !important;padding:0 !important}.dataTables_wrapper.no-footer .dataTables_scrollBody{border-bottom:1px solid #111}.dataTables_wrapper.no-footer div.dataTables_scrollHead table,.dataTables_wrapper.no-footer div.dataTables_scrollBody table{border-bottom:none}.dataTables_wrapper:after{visibility:hidden;display:block;content:"";clear:both;height:0}@media screen and (max-width: 767px){.dataTables_wrapper .dataTables_info,.dataTables_wrapper .dataTables_paginate{float:none;text-align:center}.dataTables_wrapper .dataTables_paginate{margin-top:0.5em}}@media screen and (max-width: 640px){.dataTables_wrapper .dataTables_length,.dataTables_wrapper .dataTables_filter{float:none;text-align:center}.dataTables_wrapper .dataTables_filter{margin-top:0.5em}}diff --git a/wger/core/static/images/sort_asc.png b/wger/core/static/images/sort_asc.pngnew file mode 100644index 000000000..a88d7975fBinary files /dev/null and b/wger/core/static/images/sort_asc.png differdiff --git a/wger/core/static/images/sort_asc_disabled.png b/wger/core/static/images/sort_asc_disabled.pngnew file mode 100644index 000000000..dcd7b7b8cBinary files /dev/null and b/wger/core/static/images/sort_asc_disabled.png differdiff --git a/wger/core/static/images/sort_both.png b/wger/core/static/images/sort_both.pngnew file mode 100644index 000000000..18670406bBinary files /dev/null and b/wger/core/static/images/sort_both.png differdiff --git a/wger/core/static/images/sort_desc.png b/wger/core/static/images/sort_desc.pngnew file mode 100644index 000000000..def071ed5Binary files /dev/null and b/wger/core/static/images/sort_desc.png differdiff --git a/wger/core/static/images/sort_desc_disabled.png b/wger/core/static/images/sort_desc_disabled.pngnew file mode 100644index 000000000..7824973ccBinary files /dev/null and b/wger/core/static/images/sort_desc_disabled.png differdiff --git a/wger/core/static/js/jquery.dataTables.js b/wger/core/static/js/jquery.dataTables.jsnew file mode 100644index 000000000..8ca3b5d0c--- /dev/null+++ b/wger/core/static/js/jquery.dataTables.js@@ -0,0 +1,14622 @@+/*! DataTables 1.10.2+ * ©2008-2014 SpryMedia Ltd - datatables.net/license+ */++/**+ * @summary DataTables+ * @description Paginate, search and order HTML tables+ * @version 1.10.2+ * @file jquery.dataTables.js+ * @author SpryMedia Ltd (www.sprymedia.co.uk)+ * @contact www.sprymedia.co.uk/contact+ * @copyright Copyright 2008-2014 SpryMedia Ltd.+ *+ * This source file is free software, available under the following license:+ * MIT license - http://datatables.net/license+ *+ * This source file is distributed in the hope that it will be useful, but+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY+ * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.+ *+ * For details please refer to: http://www.datatables.net+ */++/*jslint evil: true, undef: true, browser: true */+/*globals $,require,jQuery,define,_selector_run,_selector_opts,_selector_first,_selector_row_indexes,_ext,_Api,_api_register,_api_registerPlural,_re_new_lines,_re_html,_re_formatted_numeric,_re_escape_regex,_empty,_intVal,_numToDecimal,_isNumber,_isHtml,_htmlNumeric,_pluck,_pluck_order,_range,_stripHtml,_unique,_fnBuildAjax,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnAjaxDataSrc,_fnAddColumn,_fnColumnOptions,_fnAdjustColumnSizing,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnVisbleColumns,_fnGetColumns,_fnColumnTypes,_fnApplyColumnDefs,_fnHungarianMap,_fnCamelToHungarian,_fnLanguageCompat,_fnBrowserDetect,_fnAddData,_fnAddTr,_fnNodeToDataIndex,_fnNodeToColumnIndex,_fnGetCellData,_fnSetCellData,_fnSplitObjNotation,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnGetDataMaster,_fnClearTable,_fnDeleteIndex,_fnInvalidateRow,_fnGetRowElements,_fnCreateTr,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAddOptionsHtml,_fnDetectHeader,_fnGetUniqueThs,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnFilterCreateSearch,_fnEscapeRegex,_fnFilterData,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnInfoMacros,_fnInitialise,_fnInitComplete,_fnLengthChange,_fnFeatureHtmlLength,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnFeatureHtmlTable,_fnScrollDraw,_fnApplyToChildren,_fnCalculateColumnWidths,_fnThrottle,_fnConvertToWidth,_fnScrollingWidthAdjust,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnScrollBarWidth,_fnSortFlatten,_fnSort,_fnSortAria,_fnSortListener,_fnSortAttachListener,_fnSortingClasses,_fnSortData,_fnSaveState,_fnLoadState,_fnSettingsFromNode,_fnLog,_fnMap,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnLengthOverflow,_fnRenderer,_fnDataSource,_fnRowAttributes*/++(/** @lends <global> */function( window, document, undefined ) {++(function( factory ) {+ "use strict";++ if ( typeof define === 'function' && define.amd ) {+ // Define as an AMD module if possible+ define( 'datatables', ['jquery'], factory );+ }+ else if ( typeof exports === 'object' ) {+ // Node/CommonJS+ factory( require( 'jquery' ) );+ }+ else if ( jQuery && !jQuery.fn.dataTable ) {+ // Define using browser globals otherwise+ // Prevent multiple instantiations if the script is loaded twice+ factory( jQuery );+ }+}+(/** @lends <global> */function( $ ) {+ "use strict";++ /**+ * 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](href="http://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.+ *+ * @class+ * @param {object} [init={}] Configuration object for DataTables. Options+ * are defined by {@link DataTable.defaults}+ * @requires jQuery 1.7++ *+ * @example+ * // Basic initialisation+ * $(document).ready( function {+ * $('#example').dataTable();+ * } );+ *+ * @example+ * // Initialisation with configuration options - in this case, disable+ * // pagination and sorting.+ * $(document).ready( function {+ * $('#example').dataTable( {+ * "paginate": false,+ * "sort": false+ * } );+ * } );+ */+ var DataTable;+++ /*+ * It is useful to have variables which are scoped locally so only the+ * DataTables functions can access them and they don't leak into global space.+ * At the same time these functions are often useful over multiple files in the+ * core and API, so we list, or at least document, all variables which are used+ * by DataTables as private variables here. This also ensures that there is no+ * clashing of variable names and that they can easily referenced for reuse.+ */+++ // Defined else where+ // _selector_run+ // _selector_opts+ // _selector_first+ // _selector_row_indexes++ var _ext; // DataTable.ext+ var _Api; // DataTable.Api+ var _api_register; // DataTable.Api.register+ var _api_registerPlural; // DataTable.Api.registerPlural++ var _re_dic = {};+ var _re_new_lines = /[\r\n]/g;+ var _re_html = /<.*?>/g;+ var _re_date_start = /^[\w\+\-]/;+ var _re_date_end = /[\w\+\-]$/;++ // Escape regular expression special characters+ var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );++ // U+2009 is thin space and U+202F is narrow no-break space, both used in many+ // standards as thousands separators+ var _re_formatted_numeric = /[',$£€¥%\u2009\u202F]/g;+++ var _empty = function ( d ) {+ return !d || d === true || d === '-' ? true : false;+ };+++ var _intVal = function ( s ) {+ var integer = parseInt( s, 10 );+ return !isNaN(integer) && isFinite(s) ? integer : null;+ };++ // Convert from a formatted number with characters other than `.` as the+ // decimal place, to a Javascript number+ var _numToDecimal = function ( num, decimalPoint ) {+ // Cache created regular expressions for speed as this function is called often+ if ( ! _re_dic[ decimalPoint ] ) {+ _re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );+ }+ return typeof num === 'string' ?+ num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :+ num;+ };+++ var _isNumber = function ( d, decimalPoint, formatted ) {+ var strType = typeof d === 'string';++ if ( decimalPoint && strType ) {+ d = _numToDecimal( d, decimalPoint );+ }++ if ( formatted && strType ) {+ d = d.replace( _re_formatted_numeric, '' );+ }++ return _empty( d ) || (!isNaN( parseFloat(d) ) && isFinite( d ));+ };+++ // A string without HTML in it can be considered to be HTML still+ var _isHtml = function ( d ) {+ return _empty( d ) || typeof d === 'string';+ };+++ var _htmlNumeric = function ( d, decimalPoint, formatted ) {+ if ( _empty( d ) ) {+ return true;+ }++ var html = _isHtml( d );+ return ! html ?+ null :+ _isNumber( _stripHtml( d ), decimalPoint, formatted ) ?+ true :+ null;+ };+++ var _pluck = function ( a, prop, prop2 ) {+ var out = [];+ var i=0, ien=a.length;++ // Could have the test in the loop for slightly smaller code, but speed+ // is essential here+ if ( prop2 !== undefined ) {+ for ( ; i<ien ; i++ ) {+ if ( a[i] && a[i][ prop ] ) {+ out.push( a[i][ prop ][ prop2 ] );+ }+ }+ }+ else {+ for ( ; i<ien ; i++ ) {+ if ( a[i] ) {+ out.push( a[i][ prop ] );+ }+ }+ }++ return out;+ };+++ // Basically the same as _pluck, but rather than looping over `a` we use `order`+ // as the indexes to pick from `a`+ var _pluck_order = function ( a, order, prop, prop2 )+ {+ var out = [];+ var i=0, ien=order.length;++ // Could have the test in the loop for slightly smaller code, but speed+ // is essential here+ if ( prop2 !== undefined ) {+ for ( ; i<ien ; i++ ) {+ out.push( a[ order[i] ][ prop ][ prop2 ] );+ }+ }+ else {+ for ( ; i<ien ; i++ ) {+ out.push( a[ order[i] ][ prop ] );+ }+ }++ return out;+ };+++ var _range = function ( len, start )+ {+ var out = [];+ var end;++ if ( start === undefined ) {+ start = 0;+ end = len;+ }+ else {+ end = start;+ start = len;+ }++ for ( var i=start ; i<end ; i++ ) {+ out.push( i );+ }++ return out;+ };+++ var _stripHtml = function ( d ) {+ return d.replace( _re_html, '' );+ };+++ /**+ * Find the unique elements in a source array.+ *+ * @param {array} src Source array+ * @return {array} Array of unique items+ * @ignore+ */+ var _unique = function ( src )+ {+ // A faster unique method is to use object keys to identify used values,+ // but this doesn't work with arrays or objects, which we must also+ // consider. See jsperf.com/compare-array-unique-versions/4 for more+ // information.+ var+ out = [],+ val,+ i, ien=src.length,+ j, k=0;++ again: for ( i=0 ; i<ien ; i++ ) {+ val = src[i];++ for ( j=0 ; j<k ; j++ ) {+ if ( out[j] === val ) {+ continue again;+ }+ }++ out.push( val );+ k++;+ }++ return out;+ };++++ /**+ * Create a mapping object that allows camel case parameters to be looked up+ * for their Hungarian counterparts. The mapping is stored in a private+ * parameter called `_hungarianMap` which can be accessed on the source object.+ * @param {object} o+ * @memberof DataTable#oApi+ */+ function _fnHungarianMap ( o )+ {+ var+ hungarian = 'a aa ai ao as b fn i m o s ',+ match,+ newKey,+ map = {};++ $.each( o, function (key, val) {+ match = key.match(/^([^A-Z]+?)([A-Z])/);++ if ( match && hungarian.indexOf(match[1]+' ') !== -1 )+ {+ newKey = key.replace( match[0], match[2].toLowerCase() );+ map[ newKey ] = key;++ //console.log( key, match );+ if ( match[1] === 'o' )+ {+ _fnHungarianMap( o[key] );+ }+ }+ } );++ o._hungarianMap = map;+ }+++ /**+ * Convert from camel case parameters to Hungarian, based on a Hungarian map+ * created by _fnHungarianMap.+ * @param {object} src The model object which holds all parameters that can be+ * mapped.+ * @param {object} user The object to convert from camel case to Hungarian.+ * @param {boolean} force When set to `true`, properties which already have a+ * Hungarian value in the `user` object will be overwritten. Otherwise they+ * won't be.+ * @memberof DataTable#oApi+ */+ function _fnCamelToHungarian ( src, user, force )+ {+ if ( ! src._hungarianMap ) {+ _fnHungarianMap( src );+ }++ var hungarianKey;++ $.each( user, function (key, val) {+ hungarianKey = src._hungarianMap[ key ];++ if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )+ {+ // For objects, we need to buzz down into the object to copy parameters+ if ( hungarianKey.charAt(0) === 'o' )+ {+ // Copy the camelCase options over to the hungarian+ if ( ! user[ hungarianKey ] ) {+ user[ hungarianKey ] = {};+ }+ $.extend( true, user[hungarianKey], user[key] );++ _fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );+ }+ else {+ user[hungarianKey] = user[ key ];+ }+ }+ } );+ }+++ /**+ * 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.+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnLanguageCompat( lang )+ {+ var defaults = DataTable.defaults.oLanguage;+ var zeroRecords = lang.sZeroRecords;++ /* Backwards compatibility - if there is no sEmptyTable given, then use the same as+ * sZeroRecords - assuming that is given.+ */+ if ( ! lang.sEmptyTable && zeroRecords &&+ defaults.sEmptyTable === "No data available in table" )+ {+ _fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );+ }++ /* Likewise with loading records */+ if ( ! lang.sLoadingRecords && zeroRecords &&+ defaults.sLoadingRecords === "Loading..." )+ {+ _fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );+ }++ // Old parameter name of the thousands separator mapped onto the new+ if ( lang.sInfoThousands ) {+ lang.sThousands = lang.sInfoThousands;+ }++ var decimal = lang.sDecimal;+ if ( decimal ) {+ _addNumericSort( decimal );+ }+ }+++ /**+ * Map one parameter onto another+ * @param {object} o Object to map+ * @param {*} knew The new parameter name+ * @param {*} old The old parameter name+ */+ var _fnCompatMap = function ( o, knew, old ) {+ if ( o[ knew ] !== undefined ) {+ o[ old ] = o[ knew ];+ }+ };+++ /**+ * Provide backwards compatibility for the main DT options. Note that the new+ * options are mapped onto the old parameters, so this is an external interface+ * change only.+ * @param {object} init Object to map+ */+ function _fnCompatOpts ( init )+ {+ _fnCompatMap( init, 'ordering', 'bSort' );+ _fnCompatMap( init, 'orderMulti', 'bSortMulti' );+ _fnCompatMap( init, 'orderClasses', 'bSortClasses' );+ _fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );+ _fnCompatMap( init, 'order', 'aaSorting' );+ _fnCompatMap( init, 'orderFixed', 'aaSortingFixed' );+ _fnCompatMap( init, 'paging', 'bPaginate' );+ _fnCompatMap( init, 'pagingType', 'sPaginationType' );+ _fnCompatMap( init, 'pageLength', 'iDisplayLength' );+ _fnCompatMap( init, 'searching', 'bFilter' );++ // Column search objects are in an array, so it needs to be converted+ // element by element+ var searchCols = init.aoSearchCols;++ if ( searchCols ) {+ for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {+ if ( searchCols[i] ) {+ _fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );+ }+ }+ }+ }+++ /**+ * Provide backwards compatibility for column options. Note that the new options+ * are mapped onto the old parameters, so this is an external interface change+ * only.+ * @param {object} init Object to map+ */+ function _fnCompatCols ( init )+ {+ _fnCompatMap( init, 'orderable', 'bSortable' );+ _fnCompatMap( init, 'orderData', 'aDataSort' );+ _fnCompatMap( init, 'orderSequence', 'asSorting' );+ _fnCompatMap( init, 'orderDataType', 'sortDataType' );+ }+++ /**+ * Browser feature detection for capabilities, quirks+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnBrowserDetect( settings )+ {+ var browser = settings.oBrowser;++ // Scrolling feature / quirks detection+ var n = $('<div/>')+ .css( {+ position: 'absolute',+ top: 0,+ left: 0,+ height: 1,+ width: 1,+ overflow: 'hidden'+ } )+ .append(+ $('<div/>')+ .css( {+ position: 'absolute',+ top: 1,+ left: 1,+ width: 100,+ overflow: 'scroll'+ } )+ .append(+ $('<div class="test"/>')+ .css( {+ width: '100%',+ height: 10+ } )+ )+ )+ .appendTo( 'body' );++ var test = n.find('.test');++ // IE6/7 will oversize a width 100% element inside a scrolling element, to+ // include the width of the scrollbar, while other browsers ensure the inner+ // element is contained without forcing scrolling+ browser.bScrollOversize = test[0].offsetWidth === 100;++ // In rtl text layout, some browsers (most, but not all) will place the+ // scrollbar on the left, rather than the right.+ browser.bScrollbarLeft = test.offset().left !== 1;++ n.remove();+ }+++ /**+ * Array.prototype reduce[Right] method, used for browsers which don't support+ * JS 1.6. Done this way to reduce code size, since we iterate either way+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnReduce ( that, fn, init, start, end, inc )+ {+ var+ i = start,+ value,+ isSet = false;++ if ( init !== undefined ) {+ value = init;+ isSet = true;+ }++ while ( i !== end ) {+ if ( ! that.hasOwnProperty(i) ) {+ continue;+ }++ value = isSet ?+ fn( value, that[i], i, that ) :+ that[i];++ isSet = true;+ i += inc;+ }++ return value;+ }++ /**+ * Add a column to the list used for the table with default values+ * @param {object} oSettings dataTables settings object+ * @param {node} nTh The th element for this column+ * @memberof DataTable#oApi+ */+ function _fnAddColumn( oSettings, nTh )+ {+ // Add column to aoColumns array+ var oDefaults = DataTable.defaults.column;+ var iCol = oSettings.aoColumns.length;+ var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {+ "nTh": nTh ? nTh : document.createElement('th'),+ "sTitle": oDefaults.sTitle ? oDefaults.sTitle : nTh ? nTh.innerHTML : '',+ "aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],+ "mData": oDefaults.mData ? oDefaults.mData : iCol,+ idx: iCol+ } );+ oSettings.aoColumns.push( oCol );++ // Add search object for column specific search. Note that the `searchCols[ iCol ]`+ // passed into extend can be undefined. This allows the user to give a default+ // with only some of the parameters defined, and also not give a default+ var searchCols = oSettings.aoPreSearchCols;+ searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );++ // Use the default column options function to initialise classes etc+ _fnColumnOptions( oSettings, iCol, null );+ }+++ /**+ * Apply options for a column+ * @param {object} oSettings dataTables settings object+ * @param {int} iCol column index to consider+ * @param {object} oOptions object with sType, bVisible and bSearchable etc+ * @memberof DataTable#oApi+ */+ function _fnColumnOptions( oSettings, iCol, oOptions )+ {+ var oCol = oSettings.aoColumns[ iCol ];+ var oClasses = oSettings.oClasses;+ var th = $(oCol.nTh);++ // Try to get width information from the DOM. We can't get it from CSS+ // as we'd need to parse the CSS stylesheet. `width` option can override+ if ( ! oCol.sWidthOrig ) {+ // Width attribute+ oCol.sWidthOrig = th.attr('width') || null;++ // Style attribute+ var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);+ if ( t ) {+ oCol.sWidthOrig = t[1];+ }+ }++ /* User specified column options */+ if ( oOptions !== undefined && oOptions !== null )+ {+ // Backwards compatibility+ _fnCompatCols( oOptions );++ // Map camel case parameters to their Hungarian counterparts+ _fnCamelToHungarian( DataTable.defaults.column, oOptions );++ /* Backwards compatibility for mDataProp */+ if ( oOptions.mDataProp !== undefined && !oOptions.mData )+ {+ oOptions.mData = oOptions.mDataProp;+ }++ if ( oOptions.sType )+ {+ oCol._sManualType = oOptions.sType;+ }++ // `class` is a reserved word in Javascript, so we need to provide+ // the ability to use a valid name for the camel case input+ if ( oOptions.className && ! oOptions.sClass )+ {+ oOptions.sClass = oOptions.className;+ }++ $.extend( oCol, oOptions );+ _fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );++ /* iDataSort to be applied (backwards compatibility), but aDataSort will take+ * priority if defined+ */+ if ( typeof oOptions.iDataSort === 'number' )+ {+ oCol.aDataSort = [ oOptions.iDataSort ];+ }+ _fnMap( oCol, oOptions, "aDataSort" );+ }++ /* Cache the data get and set functions for speed */+ var mDataSrc = oCol.mData;+ var mData = _fnGetObjectDataFn( mDataSrc );+ var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;++ var attrTest = function( src ) {+ return typeof src === 'string' && src.indexOf('@') !== -1;+ };+ oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (+ attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)+ );++ oCol.fnGetData = function (rowData, type, meta) {+ var innerData = mData( rowData, type, undefined, meta );++ return mRender && type ?+ mRender( innerData, type, rowData, meta ) :+ innerData;+ };+ oCol.fnSetData = function ( rowData, val, meta ) {+ return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );+ };++ /* Feature sorting overrides column specific when off */+ if ( !oSettings.oFeatures.bSort )+ {+ oCol.bSortable = false;+ th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called+ }++ /* Check that the class assignment is correct for sorting */+ var bAsc = $.inArray('asc', oCol.asSorting) !== -1;+ var bDesc = $.inArray('desc', oCol.asSorting) !== -1;+ if ( !oCol.bSortable || (!bAsc && !bDesc) )+ {+ oCol.sSortingClass = oClasses.sSortableNone;+ oCol.sSortingClassJUI = "";+ }+ else if ( bAsc && !bDesc )+ {+ oCol.sSortingClass = oClasses.sSortableAsc;+ oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;+ }+ else if ( !bAsc && bDesc )+ {+ oCol.sSortingClass = oClasses.sSortableDesc;+ oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;+ }+ else+ {+ oCol.sSortingClass = oClasses.sSortable;+ oCol.sSortingClassJUI = oClasses.sSortJUI;+ }+ }+++ /**+ * Adjust the table column widths for new data. Note: you would probably want to+ * do a redraw after calling this function!+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnAdjustColumnSizing ( settings )+ {+ /* Not interested in doing column width calculation if auto-width is disabled */+ if ( settings.oFeatures.bAutoWidth !== false )+ {+ var columns = settings.aoColumns;++ _fnCalculateColumnWidths( settings );+ for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )+ {+ columns[i].nTh.style.width = columns[i].sWidth;+ }+ }++ var scroll = settings.oScroll;+ if ( scroll.sY !== '' || scroll.sX !== '')+ {+ _fnScrollDraw( settings );+ }++ _fnCallbackFire( settings, null, 'column-sizing', [settings] );+ }+++ /**+ * Covert the index of a visible column to the index in the data array (take account+ * of hidden columns)+ * @param {object} oSettings dataTables settings object+ * @param {int} iMatch Visible column index to lookup+ * @returns {int} i the data index+ * @memberof DataTable#oApi+ */+ function _fnVisibleToColumnIndex( oSettings, iMatch )+ {+ var aiVis = _fnGetColumns( oSettings, 'bVisible' );++ return typeof aiVis[iMatch] === 'number' ?+ aiVis[iMatch] :+ null;+ }+++ /**+ * Covert the index of an index in the data array and convert it to the visible+ * column index (take account of hidden columns)+ * @param {int} iMatch Column index to lookup+ * @param {object} oSettings dataTables settings object+ * @returns {int} i the data index+ * @memberof DataTable#oApi+ */+ function _fnColumnIndexToVisible( oSettings, iMatch )+ {+ var aiVis = _fnGetColumns( oSettings, 'bVisible' );+ var iPos = $.inArray( iMatch, aiVis );++ return iPos !== -1 ? iPos : null;+ }+++ /**+ * Get the number of visible columns+ * @param {object} oSettings dataTables settings object+ * @returns {int} i the number of visible columns+ * @memberof DataTable#oApi+ */+ function _fnVisbleColumns( oSettings )+ {+ return _fnGetColumns( oSettings, 'bVisible' ).length;+ }+++ /**+ * Get an array of column indexes that match a given property+ * @param {object} oSettings dataTables settings object+ * @param {string} sParam Parameter in aoColumns to look for - typically+ * bVisible or bSearchable+ * @returns {array} Array of indexes with matched properties+ * @memberof DataTable#oApi+ */+ function _fnGetColumns( oSettings, sParam )+ {+ var a = [];++ $.map( oSettings.aoColumns, function(val, i) {+ if ( val[sParam] ) {+ a.push( i );+ }+ } );++ return a;+ }+++ /**+ * Calculate the 'type' of a column+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnColumnTypes ( settings )+ {+ var columns = settings.aoColumns;+ var data = settings.aoData;+ var types = DataTable.ext.type.detect;+ var i, ien, j, jen, k, ken;+ var col, cell, detectedType, cache;++ // For each column, spin over the+ for ( i=0, ien=columns.length ; i<ien ; i++ ) {+ col = columns[i];+ cache = [];++ if ( ! col.sType && col._sManualType ) {+ col.sType = col._sManualType;+ }+ else if ( ! col.sType ) {+ for ( j=0, jen=types.length ; j<jen ; j++ ) {+ for ( k=0, ken=data.length ; k<ken ; k++ ) {+ // Use a cache array so we only need to get the type data+ // from the formatter once (when using multiple detectors)+ if ( cache[k] === undefined ) {+ cache[k] = _fnGetCellData( settings, k, i, 'type' );+ }++ detectedType = types[j]( cache[k], settings );++ // Doesn't match, so break early, since this type can't+ // apply to this column. Also, HTML is a special case since+ // it is so similar to `string`. Just a single match is+ // needed for a column to be html type+ if ( ! detectedType || detectedType === 'html' ) {+ break;+ }+ }++ // Type is valid for all data points in the column - use this+ // type+ if ( detectedType ) {+ col.sType = detectedType;+ break;+ }+ }++ // Fall back - if no type was detected, always use string+ if ( ! col.sType ) {+ col.sType = 'string';+ }+ }+ }+ }+++ /**+ * 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.+ * @param {object} oSettings dataTables settings object+ * @param {array} aoColDefs The aoColumnDefs array that is to be applied+ * @param {array} aoCols The aoColumns array that defines columns individually+ * @param {function} fn Callback function - takes two parameters, the calculated+ * column index and the definition for that column.+ * @memberof DataTable#oApi+ */+ function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )+ {+ var i, iLen, j, jLen, k, kLen, def;+ var columns = oSettings.aoColumns;++ // Column definitions with aTargets+ if ( aoColDefs )+ {+ /* Loop over the definitions array - loop in reverse so first instance has priority */+ for ( i=aoColDefs.length-1 ; i>=0 ; i-- )+ {+ def = aoColDefs[i];++ /* Each definition can target multiple columns, as it is an array */+ var aTargets = def.targets !== undefined ?+ def.targets :+ def.aTargets;++ if ( ! $.isArray( aTargets ) )+ {+ aTargets = [ aTargets ];+ }++ for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )+ {+ if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )+ {+ /* Add columns that we don't yet know about */+ while( columns.length <= aTargets[j] )+ {+ _fnAddColumn( oSettings );+ }++ /* Integer, basic index */+ fn( aTargets[j], def );+ }+ else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )+ {+ /* Negative integer, right to left column counting */+ fn( columns.length+aTargets[j], def );+ }+ else if ( typeof aTargets[j] === 'string' )+ {+ /* Class name matching on TH element */+ for ( k=0, kLen=columns.length ; k<kLen ; k++ )+ {+ if ( aTargets[j] == "_all" ||+ $(columns[k].nTh).hasClass( aTargets[j] ) )+ {+ fn( k, def );+ }+ }+ }+ }+ }+ }++ // Statically defined columns array+ if ( aoCols )+ {+ for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )+ {+ fn( i, aoCols[i] );+ }+ }+ }++ /**+ * 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.+ * @param {object} oSettings dataTables settings object+ * @param {array} aData data array to be added+ * @param {node} [nTr] TR element to add to the table - optional. If not given,+ * DataTables will create a row automatically+ * @param {array} [anTds] Array of TD|TH elements for the row - must be given+ * if nTr is.+ * @returns {int} >=0 if successful (index of new aoData entry), -1 if failed+ * @memberof DataTable#oApi+ */+ function _fnAddData ( oSettings, aDataIn, nTr, anTds )+ {+ /* Create the object for storing information about this new row */+ var iRow = oSettings.aoData.length;+ var oData = $.extend( true, {}, DataTable.models.oRow, {+ src: nTr ? 'dom' : 'data'+ } );++ oData._aData = aDataIn;+ oSettings.aoData.push( oData );++ /* Create the cells */+ var nTd, sThisType;+ var columns = oSettings.aoColumns;+ for ( var i=0, iLen=columns.length ; i<iLen ; i++ )+ {+ // When working with a row, the data source object must be populated. In+ // all other cases, the data source object is already populated, so we+ // don't overwrite it, which might break bindings etc+ if ( nTr ) {+ _fnSetCellData( oSettings, iRow, i, _fnGetCellData( oSettings, iRow, i ) );+ }+ columns[i].sType = null;+ }++ /* Add to the display array */+ oSettings.aiDisplayMaster.push( iRow );++ /* Create the DOM information, or register it if already present */+ if ( nTr || ! oSettings.oFeatures.bDeferRender )+ {+ _fnCreateTr( oSettings, iRow, nTr, anTds );+ }++ return iRow;+ }+++ /**+ * Add one or more TR elements to the table. Generally we'd expect to+ * use this for reading data from a DOM sourced table, but it could be+ * used for an TR element. Note that if a TR is given, it is used (i.e.+ * it is not cloned).+ * @param {object} settings dataTables settings object+ * @param {array|node|jQuery} trs The TR element(s) to add to the table+ * @returns {array} Array of indexes for the added rows+ * @memberof DataTable#oApi+ */+ function _fnAddTr( settings, trs )+ {+ var row;++ // Allow an individual node to be passed in+ if ( ! (trs instanceof $) ) {+ trs = $(trs);+ }++ return trs.map( function (i, el) {+ row = _fnGetRowElements( settings, el );+ return _fnAddData( settings, row.data, el, row.cells );+ } );+ }+++ /**+ * Take a TR element and convert it to an index in aoData+ * @param {object} oSettings dataTables settings object+ * @param {node} n the TR element to find+ * @returns {int} index if the node is found, null if not+ * @memberof DataTable#oApi+ */+ function _fnNodeToDataIndex( oSettings, n )+ {+ return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;+ }+++ /**+ * Take a TD element and convert it into a column data index (not the visible index)+ * @param {object} oSettings dataTables settings object+ * @param {int} iRow The row number the TD/TH can be found in+ * @param {node} n The TD/TH element to find+ * @returns {int} index if the node is found, -1 if not+ * @memberof DataTable#oApi+ */+ function _fnNodeToColumnIndex( oSettings, iRow, n )+ {+ return $.inArray( n, oSettings.aoData[ iRow ].anCells );+ }+++ /**+ * Get the data for a given cell from the internal cache, taking into account data mapping+ * @param {object} settings dataTables settings object+ * @param {int} rowIdx aoData row id+ * @param {int} colIdx Column index+ * @param {string} type data get type ('display', 'type' 'filter' 'sort')+ * @returns {*} Cell data+ * @memberof DataTable#oApi+ */+ function _fnGetCellData( settings, rowIdx, colIdx, type )+ {+ var draw = settings.iDraw;+ var col = settings.aoColumns[colIdx];+ var rowData = settings.aoData[rowIdx]._aData;+ var defaultContent = col.sDefaultContent;+ var cellData = col.fnGetData( rowData, type, {+ settings: settings,+ row: rowIdx,+ col: colIdx+ } );++ if ( cellData === undefined ) {+ if ( settings.iDrawError != draw && defaultContent === null ) {+ _fnLog( settings, 0, "Requested unknown parameter "++ (typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")++ " for row "+rowIdx, 4 );+ settings.iDrawError = draw;+ }+ return defaultContent;+ }++ /* When the data source is null, we can use default column data */+ if ( (cellData === rowData || cellData === null) && defaultContent !== null ) {+ cellData = defaultContent;+ }+ else if ( typeof cellData === 'function' ) {+ // If the data source is a function, then we run it and use the return,+ // executing in the scope of the data object (for instances)+ return cellData.call( rowData );+ }++ if ( cellData === null && type == 'display' ) {+ return '';+ }+ return cellData;+ }+++ /**+ * Set the value for a specific cell, into the internal data cache+ * @param {object} settings dataTables settings object+ * @param {int} rowIdx aoData row id+ * @param {int} colIdx Column index+ * @param {*} val Value to set+ * @memberof DataTable#oApi+ */+ function _fnSetCellData( settings, rowIdx, colIdx, val )+ {+ var col = settings.aoColumns[colIdx];+ var rowData = settings.aoData[rowIdx]._aData;++ col.fnSetData( rowData, val, {+ settings: settings,+ row: rowIdx,+ col: colIdx+ } );+ }+++ // Private variable that is used to match action syntax in the data property object+ var __reArray = /\[.*?\]$/;+ var __reFn = /\(\)$/;++ /**+ * Split string on periods, taking into account escaped periods+ * @param {string} str String to split+ * @return {array} Split string+ */+ function _fnSplitObjNotation( str )+ {+ return $.map( str.match(/(\\.|[^\.])+/g), function ( s ) {+ return s.replace(/\\./g, '.');+ } );+ }+++ /**+ * 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+ * @param {string|int|function} mSource The data source for the object+ * @returns {function} Data get function+ * @memberof DataTable#oApi+ */+ function _fnGetObjectDataFn( mSource )+ {+ if ( $.isPlainObject( mSource ) )+ {+ /* Build an object of get functions, and wrap them in a single call */+ var o = {};+ $.each( mSource, function (key, val) {+ if ( val ) {+ o[key] = _fnGetObjectDataFn( val );+ }+ } );++ return function (data, type, row, meta) {+ var t = o[type] || o._;+ return t !== undefined ?+ t(data, type, row, meta) :+ data;+ };+ }+ else if ( mSource === null )+ {+ /* Give an empty string for rendering / sorting etc */+ return function (data) { // type, row and meta also passed, but not used+ return data;+ };+ }+ else if ( typeof mSource === 'function' )+ {+ return function (data, type, row, meta) {+ return mSource( data, type, row, meta );+ };+ }+ else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||+ mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )+ {+ /* If there is a . in the source string then the data source is in a+ * nested object so we loop over the data for each level to get the next+ * level down. On each loop we test for undefined, and if found immediately+ * return. This allows entire objects to be missing and sDefaultContent to+ * be used if defined, rather than throwing an error+ */+ var fetchData = function (data, type, src) {+ var arrayNotation, funcNotation, out, innerSrc;++ if ( src !== "" )+ {+ var a = _fnSplitObjNotation( src );++ for ( var i=0, iLen=a.length ; i<iLen ; i++ )+ {+ // Check if we are dealing with special notation+ arrayNotation = a[i].match(__reArray);+ funcNotation = a[i].match(__reFn);++ if ( arrayNotation )+ {+ // Array notation+ a[i] = a[i].replace(__reArray, '');++ // Condition allows simply [] to be passed in+ if ( a[i] !== "" ) {+ data = data[ a[i] ];+ }+ out = [];++ // Get the remainder of the nested object to get+ a.splice( 0, i+1 );+ innerSrc = a.join('.');++ // Traverse each entry in the array getting the properties requested+ for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {+ out.push( fetchData( data[j], type, innerSrc ) );+ }++ // If a string is given in between the array notation indicators, that+ // is used to join the strings together, otherwise an array is returned+ var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);+ data = (join==="") ? out : out.join(join);++ // The inner call to fetchData has already traversed through the remainder+ // of the source requested, so we exit from the loop+ break;+ }+ else if ( funcNotation )+ {+ // Function call+ a[i] = a[i].replace(__reFn, '');+ data = data[ a[i] ]();+ continue;+ }++ if ( data === null || data[ a[i] ] === undefined )+ {+ return undefined;+ }+ data = data[ a[i] ];+ }+ }++ return data;+ };++ return function (data, type) { // row and meta also passed, but not used+ return fetchData( data, type, mSource );+ };+ }+ else+ {+ /* Array or flat object mapping */+ return function (data, type) { // row and meta also passed, but not used+ return data[mSource];+ };+ }+ }+++ /**+ * 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+ * @param {string|int|function} mSource The data source for the object+ * @returns {function} Data set function+ * @memberof DataTable#oApi+ */+ function _fnSetObjectDataFn( mSource )+ {+ if ( $.isPlainObject( mSource ) )+ {+ /* Unlike get, only the underscore (global) option is used for for+ * setting data since we don't know the type here. This is why an object+ * option is not documented for `mData` (which is read/write), but it is+ * for `mRender` which is read only.+ */+ return _fnSetObjectDataFn( mSource._ );+ }+ else if ( mSource === null )+ {+ /* Nothing to do when the data source is null */+ return function () {};+ }+ else if ( typeof mSource === 'function' )+ {+ return function (data, val, meta) {+ mSource( data, 'set', val, meta );+ };+ }+ else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||+ mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )+ {+ /* Like the get, we need to get data from a nested object */+ var setData = function (data, val, src) {+ var a = _fnSplitObjNotation( src ), b;+ var aLast = a[a.length-1];+ var arrayNotation, funcNotation, o, innerSrc;++ for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )+ {+ // Check if we are dealing with an array notation request+ arrayNotation = a[i].match(__reArray);+ funcNotation = a[i].match(__reFn);++ if ( arrayNotation )+ {+ a[i] = a[i].replace(__reArray, '');+ data[ a[i] ] = [];++ // Get the remainder of the nested object to set so we can recurse+ b = a.slice();+ b.splice( 0, i+1 );+ innerSrc = b.join('.');++ // Traverse each entry in the array setting the properties requested+ for ( var j=0, jLen=val.length ; j<jLen ; j++ )+ {+ o = {};+ setData( o, val[j], innerSrc );+ data[ a[i] ].push( o );+ }++ // The inner call to setData has already traversed through the remainder+ // of the source and has set the data, thus we can exit here+ return;+ }+ else if ( funcNotation )+ {+ // Function call+ a[i] = a[i].replace(__reFn, '');+ data = data[ a[i] ]( val );+ }++ // If the nested object doesn't currently exist - since we are+ // trying to set the value - create it+ if ( data[ a[i] ] === null || data[ a[i] ] === undefined )+ {+ data[ a[i] ] = {};+ }+ data = data[ a[i] ];+ }++ // Last item in the input - i.e, the actual set+ if ( aLast.match(__reFn ) )+ {+ // Function call+ data = data[ aLast.replace(__reFn, '') ]( val );+ }+ else+ {+ // If array notation is used, we just want to strip it and use the property name+ // and assign the value. If it isn't used, then we get the result we want anyway+ data[ aLast.replace(__reArray, '') ] = val;+ }+ };++ return function (data, val) { // meta is also passed in, but not used+ return setData( data, val, mSource );+ };+ }+ else+ {+ /* Array or flat object mapping */+ return function (data, val) { // meta is also passed in, but not used+ data[mSource] = val;+ };+ }+ }+++ /**+ * Return an array with the full table data+ * @param {object} oSettings dataTables settings object+ * @returns array {array} aData Master data array+ * @memberof DataTable#oApi+ */+ function _fnGetDataMaster ( settings )+ {+ return _pluck( settings.aoData, '_aData' );+ }+++ /**+ * Nuke the table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnClearTable( settings )+ {+ settings.aoData.length = 0;+ settings.aiDisplayMaster.length = 0;+ settings.aiDisplay.length = 0;+ }+++ /**+ * Take an array of integers (index array) and remove a target integer (value - not+ * the key!)+ * @param {array} a Index array to target+ * @param {int} iTarget value to find+ * @memberof DataTable#oApi+ */+ function _fnDeleteIndex( a, iTarget, splice )+ {+ var iTargetIndex = -1;++ for ( var i=0, iLen=a.length ; i<iLen ; i++ )+ {+ if ( a[i] == iTarget )+ {+ iTargetIndex = i;+ }+ else if ( a[i] > iTarget )+ {+ a[i]--;+ }+ }++ if ( iTargetIndex != -1 && splice === undefined )+ {+ a.splice( iTargetIndex, 1 );+ }+ }+++ /**+ * Mark cached data as invalid such that a re-read of the data will occur when+ * the cached data is next requested. Also update from the data source object.+ *+ * @param {object} settings DataTables settings object+ * @param {int} rowIdx Row index to invalidate+ * @memberof DataTable#oApi+ *+ * @todo For the modularisation of v1.11 this will need to become a callback, so+ * the sort and filter methods can subscribe to it. That will required+ * initialisation options for sorting, which is why it is not already baked in+ */+ function _fnInvalidateRow( settings, rowIdx, src, column )+ {+ var row = settings.aoData[ rowIdx ];+ var i, ien;++ // Are we reading last data from DOM or the data object?+ if ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {+ // Read the data from the DOM+ row._aData = _fnGetRowElements( settings, row ).data;+ }+ else {+ // Reading from data object, update the DOM+ var cells = row.anCells;+ var cell;++ if ( cells ) {+ for ( i=0, ien=cells.length ; i<ien ; i++ ) {+ cell = cells[i];++ // This is very frustrating, but in IE if you just write directly+ // to innerHTML, and elements that are overwritten are GC'ed,+ // even if there is a reference to them elsewhere+ while ( cell.childNodes.length ) {+ cell.removeChild( cell.firstChild );+ }++ cells[i].innerHTML = _fnGetCellData( settings, rowIdx, i, 'display' );+ }+ }+ }++ row._aSortData = null;+ row._aFilterData = null;++ // Invalidate the type for a specific column (if given) or all columns since+ // the data might have changed+ var cols = settings.aoColumns;+ if ( column !== undefined ) {+ cols[ column ].sType = null;+ }+ else {+ for ( i=0, ien=cols.length ; i<ien ; i++ ) {+ cols[i].sType = null;+ }+ }++ // Update DataTables special `DT_*` attributes for the row+ _fnRowAttributes( row );+ }+++ /**+ * Build a data source object from an HTML row, reading the contents of the+ * cells that are in the row.+ *+ * @param {object} settings DataTables settings object+ * @param {node|object} TR element from which to read data or existing row+ * object from which to re-read the data from the cells+ * @returns {object} Object with two parameters: `data` the data read, in+ * document order, and `cells` and array of nodes (they can be useful to the+ * caller, so rather than needing a second traversal to get them, just return+ * them from here).+ * @memberof DataTable#oApi+ */+ function _fnGetRowElements( settings, row )+ {+ var+ d = [],+ tds = [],+ td = row.firstChild,+ name, col, o, i=0, contents,+ columns = settings.aoColumns;++ var attr = function ( str, data, td ) {+ if ( typeof str === 'string' ) {+ var idx = str.indexOf('@');++ if ( idx !== -1 ) {+ var src = str.substring( idx+1 );+ o[ '@'+src ] = td.getAttribute( src );+ }+ }+ };++ var cellProcess = function ( cell ) {+ col = columns[i];+ contents = $.trim(cell.innerHTML);++ if ( col && col._bAttrSrc ) {+ o = {+ display: contents+ };++ attr( col.mData.sort, o, cell );+ attr( col.mData.type, o, cell );+ attr( col.mData.filter, o, cell );++ d.push( o );+ }+ else {+ d.push( contents );+ }++ i++;+ };++ if ( td ) {+ // `tr` element passed in+ while ( td ) {+ name = td.nodeName.toUpperCase();++ if ( name == "TD" || name == "TH" ) {+ cellProcess( td );+ tds.push( td );+ }++ td = td.nextSibling;+ }+ }+ else {+ // Existing row object passed in+ tds = row.anCells;++ for ( var j=0, jen=tds.length ; j<jen ; j++ ) {+ cellProcess( tds[j] );+ }+ }++ return {+ data: d,+ cells: tds+ };+ }+ /**+ * Create a new TR element (and it's TD children) for a row+ * @param {object} oSettings dataTables settings object+ * @param {int} iRow Row to consider+ * @param {node} [nTrIn] TR element to add to the table - optional. If not given,+ * DataTables will create a row automatically+ * @param {array} [anTds] Array of TD|TH elements for the row - must be given+ * if nTr is.+ * @memberof DataTable#oApi+ */+ function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )+ {+ var+ row = oSettings.aoData[iRow],+ rowData = row._aData,+ cells = [],+ nTr, nTd, oCol,+ i, iLen;++ if ( row.nTr === null )+ {+ nTr = nTrIn || document.createElement('tr');++ row.nTr = nTr;+ row.anCells = cells;++ /* Use a private property on the node to allow reserve mapping from the node+ * to the aoData array for fast look up+ */+ nTr._DT_RowIndex = iRow;++ /* Special parameters can be given by the data source to be used on the row */+ _fnRowAttributes( row );++ /* Process each column */+ for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )+ {+ oCol = oSettings.aoColumns[i];++ nTd = nTrIn ? anTds[i] : document.createElement( oCol.sCellType );+ cells.push( nTd );++ // Need to create the HTML if new, or if a rendering function is defined+ if ( !nTrIn || oCol.mRender || oCol.mData !== i )+ {+ nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );+ }++ /* Add user defined class */+ if ( oCol.sClass )+ {+ nTd.className += ' '+oCol.sClass;+ }++ // Visibility - add or remove as required+ if ( oCol.bVisible && ! nTrIn )+ {+ nTr.appendChild( nTd );+ }+ else if ( ! oCol.bVisible && nTrIn )+ {+ nTd.parentNode.removeChild( nTd );+ }++ if ( oCol.fnCreatedCell )+ {+ oCol.fnCreatedCell.call( oSettings.oInstance,+ nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i+ );+ }+ }++ _fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow] );+ }++ // Remove once webkit bug 131819 and Chromium bug 365619 have been resolved+ // and deployed+ row.nTr.setAttribute( 'role', 'row' );+ }+++ /**+ * Add attributes to a row based on the special `DT_*` parameters in a data+ * source object.+ * @param {object} DataTables row object for the row to be modified+ * @memberof DataTable#oApi+ */+ function _fnRowAttributes( row )+ {+ var tr = row.nTr;+ var data = row._aData;++ if ( tr ) {+ if ( data.DT_RowId ) {+ tr.id = data.DT_RowId;+ }++ if ( data.DT_RowClass ) {+ // Remove any classes added by DT_RowClass before+ var a = data.DT_RowClass.split(' ');+ row.__rowc = row.__rowc ?+ _unique( row.__rowc.concat( a ) ) :+ a;++ $(tr)+ .removeClass( row.__rowc.join(' ') )+ .addClass( data.DT_RowClass );+ }++ if ( data.DT_RowData ) {+ $(tr).data( data.DT_RowData );+ }+ }+ }+++ /**+ * Create the HTML header for the table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnBuildHead( oSettings )+ {+ var i, ien, cell, row, column;+ var thead = oSettings.nTHead;+ var tfoot = oSettings.nTFoot;+ var createHeader = $('th, td', thead).length === 0;+ var classes = oSettings.oClasses;+ var columns = oSettings.aoColumns;++ if ( createHeader ) {+ row = $('<tr/>').appendTo( thead );+ }++ for ( i=0, ien=columns.length ; i<ien ; i++ ) {+ column = columns[i];+ cell = $( column.nTh ).addClass( column.sClass );++ if ( createHeader ) {+ cell.appendTo( row );+ }++ // 1.11 move into sorting+ if ( oSettings.oFeatures.bSort ) {+ cell.addClass( column.sSortingClass );++ if ( column.bSortable !== false ) {+ cell+ .attr( 'tabindex', oSettings.iTabIndex )+ .attr( 'aria-controls', oSettings.sTableId );++ _fnSortAttachListener( oSettings, column.nTh, i );+ }+ }++ if ( column.sTitle != cell.html() ) {+ cell.html( column.sTitle );+ }++ _fnRenderer( oSettings, 'header' )(+ oSettings, cell, column, classes+ );+ }++ if ( createHeader ) {+ _fnDetectHeader( oSettings.aoHeader, thead );+ }++ /* ARIA role for the rows */+ $(thead).find('>tr').attr('role', 'row');++ /* Deal with the footer - add classes if required */+ $(thead).find('>tr>th, >tr>td').addClass( classes.sHeaderTH );+ $(tfoot).find('>tr>th, >tr>td').addClass( classes.sFooterTH );++ // Cache the footer cells. Note that we only take the cells from the first+ // row in the footer. If there is more than one row the user wants to+ // interact with, they need to use the table().foot() method. Note also this+ // allows cells to be used for multiple columns using colspan+ if ( tfoot !== null ) {+ var cells = oSettings.aoFooter[0];++ for ( i=0, ien=cells.length ; i<ien ; i++ ) {+ column = columns[i];+ column.nTf = cells[i].cell;++ if ( column.sClass ) {+ $(column.nTf).addClass( column.sClass );+ }+ }+ }+ }+++ /**+ * 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.+ * @param {object} oSettings dataTables settings object+ * @param array {objects} aoSource Layout array from _fnDetectHeader+ * @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,+ * @memberof DataTable#oApi+ */+ function _fnDrawHead( oSettings, aoSource, bIncludeHidden )+ {+ var i, iLen, j, jLen, k, kLen, n, nLocalTr;+ var aoLocal = [];+ var aApplied = [];+ var iColumns = oSettings.aoColumns.length;+ var iRowspan, iColspan;++ if ( ! aoSource )+ {+ return;+ }++ if ( bIncludeHidden === undefined )+ {+ bIncludeHidden = false;+ }++ /* Make a copy of the master layout array, but without the visible columns in it */+ for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )+ {+ aoLocal[i] = aoSource[i].slice();+ aoLocal[i].nTr = aoSource[i].nTr;++ /* Remove any columns which are currently hidden */+ for ( j=iColumns-1 ; j>=0 ; j-- )+ {+ if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )+ {+ aoLocal[i].splice( j, 1 );+ }+ }++ /* Prep the applied array - it needs an element for each row */+ aApplied.push( [] );+ }++ for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )+ {+ nLocalTr = aoLocal[i].nTr;++ /* All cells are going to be replaced, so empty out the row */+ if ( nLocalTr )+ {+ while( (n = nLocalTr.firstChild) )+ {+ nLocalTr.removeChild( n );+ }+ }++ for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )+ {+ iRowspan = 1;+ iColspan = 1;++ /* Check to see if there is already a cell (row/colspan) covering our target+ * insert point. If there is, then there is nothing to do.+ */+ if ( aApplied[i][j] === undefined )+ {+ nLocalTr.appendChild( aoLocal[i][j].cell );+ aApplied[i][j] = 1;++ /* Expand the cell to cover as many rows as needed */+ while ( aoLocal[i+iRowspan] !== undefined &&+ aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )+ {+ aApplied[i+iRowspan][j] = 1;+ iRowspan++;+ }++ /* Expand the cell to cover as many columns as needed */+ while ( aoLocal[i][j+iColspan] !== undefined &&+ aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )+ {+ /* Must update the applied array over the rows for the columns */+ for ( k=0 ; k<iRowspan ; k++ )+ {+ aApplied[i+k][j+iColspan] = 1;+ }+ iColspan++;+ }++ /* Do the actual expansion in the DOM */+ $(aoLocal[i][j].cell)+ .attr('rowspan', iRowspan)+ .attr('colspan', iColspan);+ }+ }+ }+ }+++ /**+ * Insert the required TR nodes into the table for display+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnDraw( oSettings )+ {+ /* Provide a pre-callback function which can be used to cancel the draw is false is returned */+ var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );+ if ( $.inArray( false, aPreDraw ) !== -1 )+ {+ _fnProcessingDisplay( oSettings, false );+ return;+ }++ var i, iLen, n;+ var anRows = [];+ var iRowCount = 0;+ var asStripeClasses = oSettings.asStripeClasses;+ var iStripes = asStripeClasses.length;+ var iOpenRows = oSettings.aoOpenRows.length;+ var oLang = oSettings.oLanguage;+ var iInitDisplayStart = oSettings.iInitDisplayStart;+ var bServerSide = _fnDataSource( oSettings ) == 'ssp';+ var aiDisplay = oSettings.aiDisplay;++ oSettings.bDrawing = true;++ /* Check and see if we have an initial draw position from state saving */+ if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )+ {+ oSettings._iDisplayStart = bServerSide ?+ iInitDisplayStart :+ iInitDisplayStart >= oSettings.fnRecordsDisplay() ?+ 0 :+ iInitDisplayStart;++ oSettings.iInitDisplayStart = -1;+ }++ var iDisplayStart = oSettings._iDisplayStart;+ var iDisplayEnd = oSettings.fnDisplayEnd();++ /* Server-side processing draw intercept */+ if ( oSettings.bDeferLoading )+ {+ oSettings.bDeferLoading = false;+ oSettings.iDraw++;+ _fnProcessingDisplay( oSettings, false );+ }+ else if ( !bServerSide )+ {+ oSettings.iDraw++;+ }+ else if ( !oSettings.bDestroying && !_fnAjaxUpdate( oSettings ) )+ {+ return;+ }++ if ( aiDisplay.length !== 0 )+ {+ var iStart = bServerSide ? 0 : iDisplayStart;+ var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;++ for ( var j=iStart ; j<iEnd ; j++ )+ {+ var iDataIndex = aiDisplay[j];+ var aoData = oSettings.aoData[ iDataIndex ];+ if ( aoData.nTr === null )+ {+ _fnCreateTr( oSettings, iDataIndex );+ }++ var nRow = aoData.nTr;++ /* Remove the old striping classes and then add the new one */+ if ( iStripes !== 0 )+ {+ var sStripe = asStripeClasses[ iRowCount % iStripes ];+ if ( aoData._sRowStripe != sStripe )+ {+ $(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );+ aoData._sRowStripe = sStripe;+ }+ }++ /* Row callback functions - might want to manipulate the row */+ _fnCallbackFire( oSettings, 'aoRowCallback', null,+ [nRow, aoData._aData, iRowCount, j] );++ anRows.push( nRow );+ iRowCount++;+ }+ }+ else+ {+ /* Table is empty - create a row with an empty message in it */+ var sZero = oLang.sZeroRecords;+ if ( oSettings.iDraw == 1 && _fnDataSource( oSettings ) == 'ajax' )+ {+ sZero = oLang.sLoadingRecords;+ }+ else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )+ {+ sZero = oLang.sEmptyTable;+ }++ anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )+ .append( $('<td />', {+ 'valign': 'top',+ 'colSpan': _fnVisbleColumns( oSettings ),+ 'class': oSettings.oClasses.sRowEmpty+ } ).html( sZero ) )[0];+ }++ /* Header and footer callbacks */+ _fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],+ _fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );++ _fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],+ _fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );++ var body = $(oSettings.nTBody);++ body.children().detach();+ body.append( $(anRows) );++ /* Call all required callback functions for the end of a draw */+ _fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );++ /* Draw is complete, sorting and filtering must be as well */+ oSettings.bSorted = false;+ oSettings.bFiltered = false;+ oSettings.bDrawing = false;+ }+++ /**+ * Redraw the table - taking account of the various features which are enabled+ * @param {object} oSettings dataTables settings object+ * @param {boolean} [holdPosition] Keep the current paging position. By default+ * the paging is reset to the first page+ * @memberof DataTable#oApi+ */+ function _fnReDraw( settings, holdPosition )+ {+ var+ features = settings.oFeatures,+ sort = features.bSort,+ filter = features.bFilter;++ if ( sort ) {+ _fnSort( settings );+ }++ if ( filter ) {+ _fnFilterComplete( settings, settings.oPreviousSearch );+ }+ else {+ // No filtering, so we want to just use the display master+ settings.aiDisplay = settings.aiDisplayMaster.slice();+ }++ if ( holdPosition !== true ) {+ settings._iDisplayStart = 0;+ }++ // Let any modules know about the draw hold position state (used by+ // scrolling internally)+ settings._drawHold = holdPosition;++ _fnDraw( settings );++ settings._drawHold = false;+ }+++ /**+ * Add the options to the page HTML for the table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnAddOptionsHtml ( oSettings )+ {+ var classes = oSettings.oClasses;+ var table = $(oSettings.nTable);+ var holding = $('<div/>').insertBefore( table ); // Holding element for speed+ var features = oSettings.oFeatures;++ // All DataTables are wrapped in a div+ var insert = $('<div/>', {+ id: oSettings.sTableId+'_wrapper',+ 'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)+ } );++ oSettings.nHolding = holding[0];+ oSettings.nTableWrapper = insert[0];+ oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;++ /* Loop over the user set positioning and place the elements as needed */+ var aDom = oSettings.sDom.split('');+ var featureNode, cOption, nNewNode, cNext, sAttr, j;+ for ( var i=0 ; i<aDom.length ; i++ )+ {+ featureNode = null;+ cOption = aDom[i];++ if ( cOption == '<' )+ {+ /* New container div */+ nNewNode = $('<div/>')[0];++ /* Check to see if we should append an id and/or a class name to the container */+ cNext = aDom[i+1];+ if ( cNext == "'" || cNext == '"' )+ {+ sAttr = "";+ j = 2;+ while ( aDom[i+j] != cNext )+ {+ sAttr += aDom[i+j];+ j++;+ }++ /* Replace jQuery UI constants @todo depreciated */+ if ( sAttr == "H" )+ {+ sAttr = classes.sJUIHeader;+ }+ else if ( sAttr == "F" )+ {+ sAttr = classes.sJUIFooter;+ }++ /* The attribute can be in the format of "#id.class", "#id" or "class" This logic+ * breaks the string into parts and applies them as needed+ */+ if ( sAttr.indexOf('.') != -1 )+ {+ var aSplit = sAttr.split('.');+ nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);+ nNewNode.className = aSplit[1];+ }+ else if ( sAttr.charAt(0) == "#" )+ {+ nNewNode.id = sAttr.substr(1, sAttr.length-1);+ }+ else+ {+ nNewNode.className = sAttr;+ }++ i += j; /* Move along the position array */+ }++ insert.append( nNewNode );+ insert = $(nNewNode);+ }+ else if ( cOption == '>' )+ {+ /* End container div */+ insert = insert.parent();+ }+ // @todo Move options into their own plugins?+ else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )+ {+ /* Length */+ featureNode = _fnFeatureHtmlLength( oSettings );+ }+ else if ( cOption == 'f' && features.bFilter )+ {+ /* Filter */+ featureNode = _fnFeatureHtmlFilter( oSettings );+ }+ else if ( cOption == 'r' && features.bProcessing )+ {+ /* pRocessing */+ featureNode = _fnFeatureHtmlProcessing( oSettings );+ }+ else if ( cOption == 't' )+ {+ /* Table */+ featureNode = _fnFeatureHtmlTable( oSettings );+ }+ else if ( cOption == 'i' && features.bInfo )+ {+ /* Info */+ featureNode = _fnFeatureHtmlInfo( oSettings );+ }+ else if ( cOption == 'p' && features.bPaginate )+ {+ /* Pagination */+ featureNode = _fnFeatureHtmlPaginate( oSettings );+ }+ else if ( DataTable.ext.feature.length !== 0 )+ {+ /* Plug-in features */+ var aoFeatures = DataTable.ext.feature;+ for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )+ {+ if ( cOption == aoFeatures[k].cFeature )+ {+ featureNode = aoFeatures[k].fnInit( oSettings );+ break;+ }+ }+ }++ /* Add to the 2D features array */+ if ( featureNode )+ {+ var aanFeatures = oSettings.aanFeatures;++ if ( ! aanFeatures[cOption] )+ {+ aanFeatures[cOption] = [];+ }++ aanFeatures[cOption].push( featureNode );+ insert.append( featureNode );+ }+ }++ /* Built our DOM structure - replace the holding div with what we want */+ holding.replaceWith( insert );+ }+++ /**+ * 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+ * @param array {object} aLayout Array to store the calculated layout in+ * @param {node} nThead The header/footer element for the table+ * @memberof DataTable#oApi+ */+ function _fnDetectHeader ( aLayout, nThead )+ {+ var nTrs = $(nThead).children('tr');+ var nTr, nCell;+ var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;+ var bUnique;+ var fnShiftCol = function ( a, i, j ) {+ var k = a[i];+ while ( k[j] ) {+ j++;+ }+ return j;+ };++ aLayout.splice( 0, aLayout.length );++ /* We know how many rows there are in the layout - so prep it */+ for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )+ {+ aLayout.push( [] );+ }++ /* Calculate a layout array */+ for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )+ {+ nTr = nTrs[i];+ iColumn = 0;++ /* For every cell in the row... */+ nCell = nTr.firstChild;+ while ( nCell ) {+ if ( nCell.nodeName.toUpperCase() == "TD" ||+ nCell.nodeName.toUpperCase() == "TH" )+ {+ /* Get the col and rowspan attributes from the DOM and sanitise them */+ iColspan = nCell.getAttribute('colspan') * 1;+ iRowspan = nCell.getAttribute('rowspan') * 1;+ iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;+ iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;++ /* There might be colspan cells already in this row, so shift our target+ * accordingly+ */+ iColShifted = fnShiftCol( aLayout, i, iColumn );++ /* Cache calculation for unique columns */+ bUnique = iColspan === 1 ? true : false;++ /* If there is col / rowspan, copy the information into the layout grid */+ for ( l=0 ; l<iColspan ; l++ )+ {+ for ( k=0 ; k<iRowspan ; k++ )+ {+ aLayout[i+k][iColShifted+l] = {+ "cell": nCell,+ "unique": bUnique+ };+ aLayout[i+k].nTr = nTr;+ }+ }+ }+ nCell = nCell.nextSibling;+ }+ }+ }+++ /**+ * Get an array of unique th elements, one for each column+ * @param {object} oSettings dataTables settings object+ * @param {node} nHeader automatically detect the layout from this node - optional+ * @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional+ * @returns array {node} aReturn list of unique th's+ * @memberof DataTable#oApi+ */+ function _fnGetUniqueThs ( oSettings, nHeader, aLayout )+ {+ var aReturn = [];+ if ( !aLayout )+ {+ aLayout = oSettings.aoHeader;+ if ( nHeader )+ {+ aLayout = [];+ _fnDetectHeader( aLayout, nHeader );+ }+ }++ for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )+ {+ for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )+ {+ if ( aLayout[i][j].unique &&+ (!aReturn[j] || !oSettings.bSortCellsTop) )+ {+ aReturn[j] = aLayout[i][j].cell;+ }+ }+ }++ return aReturn;+ }++++ /**+ * Create an Ajax call based on the table's settings, taking into account that+ * parameters can have multiple forms, and backwards compatibility.+ *+ * @param {object} oSettings dataTables settings object+ * @param {array} data Data to send to the server, required by+ * DataTables - may be augmented by developer callbacks+ * @param {function} fn Callback function to run when data is obtained+ */+ function _fnBuildAjax( oSettings, data, fn )+ {+ // Compatibility with 1.9-, allow fnServerData and event to manipulate+ _fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );++ // Convert to object based for 1.10+ if using the old array scheme which can+ // come from server-side processing or serverParams+ if ( data && $.isArray(data) ) {+ var tmp = {};+ var rbracket = /(.*?)\[\]$/;++ $.each( data, function (key, val) {+ var match = val.name.match(rbracket);++ if ( match ) {+ // Support for arrays+ var name = match[0];++ if ( ! tmp[ name ] ) {+ tmp[ name ] = [];+ }+ tmp[ name ].push( val.value );+ }+ else {+ tmp[val.name] = val.value;+ }+ } );+ data = tmp;+ }++ var ajaxData;+ var ajax = oSettings.ajax;+ var instance = oSettings.oInstance;++ if ( $.isPlainObject( ajax ) && ajax.data )+ {+ ajaxData = ajax.data;++ var newData = $.isFunction( ajaxData ) ?+ ajaxData( data ) : // fn can manipulate data or return an object+ ajaxData; // object or array to merge++ // If the function returned an object, use that alone+ data = $.isFunction( ajaxData ) && newData ?+ newData :+ $.extend( true, data, newData );++ // Remove the data property as we've resolved it already and don't want+ // jQuery to do it again (it is restored at the end of the function)+ delete ajax.data;+ }++ var baseAjax = {+ "data": data,+ "success": function (json) {+ var error = json.error || json.sError;+ if ( error ) {+ oSettings.oApi._fnLog( oSettings, 0, error );+ }++ oSettings.json = json;+ _fnCallbackFire( oSettings, null, 'xhr', [oSettings, json] );+ fn( json );+ },+ "dataType": "json",+ "cache": false,+ "type": oSettings.sServerMethod,+ "error": function (xhr, error, thrown) {+ var log = oSettings.oApi._fnLog;++ if ( error == "parsererror" ) {+ log( oSettings, 0, 'Invalid JSON response', 1 );+ }+ else if ( xhr.readyState === 4 ) {+ log( oSettings, 0, 'Ajax error', 7 );+ }++ _fnProcessingDisplay( oSettings, false );+ }+ };++ // Store the data submitted for the API+ oSettings.oAjaxData = data;++ // Allow plug-ins and external processes to modify the data+ _fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );++ if ( oSettings.fnServerData )+ {+ // DataTables 1.9- compatibility+ oSettings.fnServerData.call( instance,+ oSettings.sAjaxSource,+ $.map( data, function (val, key) { // Need to convert back to 1.9 trad format+ return { name: key, value: val };+ } ),+ fn,+ oSettings+ );+ }+ else if ( oSettings.sAjaxSource || typeof ajax === 'string' )+ {+ // DataTables 1.9- compatibility+ oSettings.jqXHR = $.ajax( $.extend( baseAjax, {+ url: ajax || oSettings.sAjaxSource+ } ) );+ }+ else if ( $.isFunction( ajax ) )+ {+ // Is a function - let the caller define what needs to be done+ oSettings.jqXHR = ajax.call( instance, data, fn, oSettings );+ }+ else+ {+ // Object to extend the base settings+ oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );++ // Restore for next time around+ ajax.data = ajaxData;+ }+ }+++ /**+ * Update the table using an Ajax call+ * @param {object} settings dataTables settings object+ * @returns {boolean} Block the table drawing or not+ * @memberof DataTable#oApi+ */+ function _fnAjaxUpdate( settings )+ {+ if ( settings.bAjaxDataGet ) {+ settings.iDraw++;+ _fnProcessingDisplay( settings, true );++ _fnBuildAjax(+ settings,+ _fnAjaxParameters( settings ),+ function(json) {+ _fnAjaxUpdateDraw( settings, json );+ }+ );++ return false;+ }+ return true;+ }+++ /**+ * Build up the parameters in an object needed for a server-side processing+ * request. Note that this is basically done twice, is different ways - a modern+ * method which is used by default in DataTables 1.10 which uses objects and+ * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if+ * the sAjaxSource option is used in the initialisation, or the legacyAjax+ * option is set.+ * @param {object} oSettings dataTables settings object+ * @returns {bool} block the table drawing or not+ * @memberof DataTable#oApi+ */+ function _fnAjaxParameters( settings )+ {+ var+ columns = settings.aoColumns,+ columnCount = columns.length,+ features = settings.oFeatures,+ preSearch = settings.oPreviousSearch,+ preColSearch = settings.aoPreSearchCols,+ i, data = [], dataProp, column, columnSearch,+ sort = _fnSortFlatten( settings ),+ displayStart = settings._iDisplayStart,+ displayLength = features.bPaginate !== false ?+ settings._iDisplayLength :+ -1;++ var param = function ( name, value ) {+ data.push( { 'name': name, 'value': value } );+ };++ // DataTables 1.9- compatible method+ param( 'sEcho', settings.iDraw );+ param( 'iColumns', columnCount );+ param( 'sColumns', _pluck( columns, 'sName' ).join(',') );+ param( 'iDisplayStart', displayStart );+ param( 'iDisplayLength', displayLength );++ // DataTables 1.10+ method+ var d = {+ draw: settings.iDraw,+ columns: [],+ order: [],+ start: displayStart,+ length: displayLength,+ search: {+ value: preSearch.sSearch,+ regex: preSearch.bRegex+ }+ };++ for ( i=0 ; i<columnCount ; i++ ) {+ column = columns[i];+ columnSearch = preColSearch[i];+ dataProp = typeof column.mData=="function" ? 'function' : column.mData ;++ d.columns.push( {+ data: dataProp,+ name: column.sName,+ searchable: column.bSearchable,+ orderable: column.bSortable,+ search: {+ value: columnSearch.sSearch,+ regex: columnSearch.bRegex+ }+ } );++ param( "mDataProp_"+i, dataProp );++ if ( features.bFilter ) {+ param( 'sSearch_'+i, columnSearch.sSearch );+ param( 'bRegex_'+i, columnSearch.bRegex );+ param( 'bSearchable_'+i, column.bSearchable );+ }++ if ( features.bSort ) {+ param( 'bSortable_'+i, column.bSortable );+ }+ }++ if ( features.bFilter ) {+ param( 'sSearch', preSearch.sSearch );+ param( 'bRegex', preSearch.bRegex );+ }++ if ( features.bSort ) {+ $.each( sort, function ( i, val ) {+ d.order.push( { column: val.col, dir: val.dir } );++ param( 'iSortCol_'+i, val.col );+ param( 'sSortDir_'+i, val.dir );+ } );++ param( 'iSortingCols', sort.length );+ }++ // If the legacy.ajax parameter is null, then we automatically decide which+ // form to use, based on sAjaxSource+ var legacy = DataTable.ext.legacy.ajax;+ if ( legacy === null ) {+ return settings.sAjaxSource ? data : d;+ }++ // Otherwise, if legacy has been specified then we use that to decide on the+ // form+ return legacy ? data : d;+ }+++ /**+ * Data the data from the server (nuking the old) and redraw the table+ * @param {object} oSettings dataTables settings object+ * @param {object} json json data return from the server.+ * @param {string} json.sEcho Tracking flag for DataTables to match requests+ * @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering+ * @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering+ * @param {array} json.aaData The data to display on this page+ * @param {string} [json.sColumns] Column ordering (sName, comma separated)+ * @memberof DataTable#oApi+ */+ function _fnAjaxUpdateDraw ( settings, json )+ {+ // v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.+ // Support both+ var compat = function ( old, modern ) {+ return json[old] !== undefined ? json[old] : json[modern];+ };++ var draw = compat( 'sEcho', 'draw' );+ var recordsTotal = compat( 'iTotalRecords', 'recordsTotal' );+ var rocordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );++ if ( draw ) {+ // Protect against out of sequence returns+ if ( draw*1 < settings.iDraw ) {+ return;+ }+ settings.iDraw = draw * 1;+ }++ _fnClearTable( settings );+ settings._iRecordsTotal = parseInt(recordsTotal, 10);+ settings._iRecordsDisplay = parseInt(rocordsFiltered, 10);++ var data = _fnAjaxDataSrc( settings, json );+ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ _fnAddData( settings, data[i] );+ }+ settings.aiDisplay = settings.aiDisplayMaster.slice();++ settings.bAjaxDataGet = false;+ _fnDraw( settings );++ if ( ! settings._bInitComplete ) {+ _fnInitComplete( settings, json );+ }++ settings.bAjaxDataGet = true;+ _fnProcessingDisplay( settings, false );+ }+++ /**+ * Get the data from the JSON data source to use for drawing a table. Using+ * `_fnGetObjectDataFn` allows the data to be sourced from a property of the+ * source object, or from a processing function.+ * @param {object} oSettings dataTables settings object+ * @param {object} json Data source object / array from the server+ * @return {array} Array of data to use+ */+ function _fnAjaxDataSrc ( oSettings, json )+ {+ var dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?+ oSettings.ajax.dataSrc :+ oSettings.sAjaxDataProp; // Compatibility with 1.9-.++ // Compatibility with 1.9-. In order to read from aaData, check if the+ // default has been changed, if not, check for aaData+ if ( dataSrc === 'data' ) {+ return json.aaData || json[dataSrc];+ }++ return dataSrc !== "" ?+ _fnGetObjectDataFn( dataSrc )( json ) :+ json;+ }+++ /**+ * Generate the node required for filtering text+ * @returns {node} Filter control element+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlFilter ( settings )+ {+ var classes = settings.oClasses;+ var tableId = settings.sTableId;+ var language = settings.oLanguage;+ var previousSearch = settings.oPreviousSearch;+ var features = settings.aanFeatures;+ var input = '<input type="search" class="'+classes.sFilterInput+'"/>';++ var str = language.sSearch;+ str = str.match(/_INPUT_/) ?+ str.replace('_INPUT_', input) :+ str+input;++ var filter = $('<div/>', {+ 'id': ! features.f ? tableId+'_filter' : null,+ 'class': classes.sFilter+ } )+ .append( $('<label/>' ).append( str ) );++ var searchFn = function() {+ /* Update all other filter input elements for the new display */+ var n = features.f;+ var val = !this.value ? "" : this.value; // mental IE8 fix :-(++ /* Now do the filter */+ if ( val != previousSearch.sSearch ) {+ _fnFilterComplete( settings, {+ "sSearch": val,+ "bRegex": previousSearch.bRegex,+ "bSmart": previousSearch.bSmart ,+ "bCaseInsensitive": previousSearch.bCaseInsensitive+ } );++ // Need to redraw, without resorting+ settings._iDisplayStart = 0;+ _fnDraw( settings );+ }+ };+ var jqFilter = $('input', filter)+ .val( previousSearch.sSearch )+ .attr( 'placeholder', language.sSearchPlaceholder )+ .bind(+ 'keyup.DT search.DT input.DT paste.DT cut.DT',+ _fnDataSource( settings ) === 'ssp' ?+ _fnThrottle( searchFn, 400 ):+ searchFn+ )+ .bind( 'keypress.DT', function(e) {+ /* Prevent form submission */+ if ( e.keyCode == 13 ) {+ return false;+ }+ } )+ .attr('aria-controls', tableId);++ // Update the input elements whenever the table is filtered+ $(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {+ if ( settings === s ) {+ // IE9 throws an 'unknown error' if document.activeElement is used+ // inside an iframe or frame...+ try {+ if ( jqFilter[0] !== document.activeElement ) {+ jqFilter.val( previousSearch.sSearch );+ }+ }+ catch ( e ) {}+ }+ } );++ return filter[0];+ }+++ /**+ * Filter the table using both the global filter and column based filtering+ * @param {object} oSettings dataTables settings object+ * @param {object} oSearch search information+ * @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)+ * @memberof DataTable#oApi+ */+ function _fnFilterComplete ( oSettings, oInput, iForce )+ {+ var oPrevSearch = oSettings.oPreviousSearch;+ var aoPrevSearch = oSettings.aoPreSearchCols;+ var fnSaveFilter = function ( oFilter ) {+ /* Save the filtering values */+ oPrevSearch.sSearch = oFilter.sSearch;+ oPrevSearch.bRegex = oFilter.bRegex;+ oPrevSearch.bSmart = oFilter.bSmart;+ oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;+ };+ var fnRegex = function ( o ) {+ // Backwards compatibility with the bEscapeRegex option+ return o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;+ };++ // Resolve any column types that are unknown due to addition or invalidation+ // @todo As per sort - can this be moved into an event handler?+ _fnColumnTypes( oSettings );++ /* In server-side processing all filtering is done by the server, so no point hanging around here */+ if ( _fnDataSource( oSettings ) != 'ssp' )+ {+ /* Global filter */+ _fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive );+ fnSaveFilter( oInput );++ /* Now do the individual column filter */+ for ( var i=0 ; i<aoPrevSearch.length ; i++ )+ {+ _fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),+ aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );+ }++ /* Custom filtering */+ _fnFilterCustom( oSettings );+ }+ else+ {+ fnSaveFilter( oInput );+ }++ /* Tell the draw function we have been filtering */+ oSettings.bFiltered = true;+ _fnCallbackFire( oSettings, null, 'search', [oSettings] );+ }+++ /**+ * Apply custom filtering functions+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnFilterCustom( settings )+ {+ var filters = DataTable.ext.search;+ var displayRows = settings.aiDisplay;+ var row, rowIdx;++ for ( var i=0, ien=filters.length ; i<ien ; i++ ) {+ var rows = [];++ // Loop over each row and see if it should be included+ for ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {+ rowIdx = displayRows[ j ];+ row = settings.aoData[ rowIdx ];++ if ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {+ rows.push( rowIdx );+ }+ }++ // So the array reference doesn't break set the results into the+ // existing array+ displayRows.length = 0;+ displayRows.push.apply( displayRows, rows );+ }+ }+++ /**+ * Filter the table on a per-column basis+ * @param {object} oSettings dataTables settings object+ * @param {string} sInput string to filter on+ * @param {int} iColumn column to filter+ * @param {bool} bRegex treat search string as a regular expression or not+ * @param {bool} bSmart use smart filtering or not+ * @param {bool} bCaseInsensitive Do case insenstive matching or not+ * @memberof DataTable#oApi+ */+ function _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )+ {+ if ( searchStr === '' ) {+ return;+ }++ var data;+ var display = settings.aiDisplay;+ var rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );++ for ( var i=display.length-1 ; i>=0 ; i-- ) {+ data = settings.aoData[ display[i] ]._aFilterData[ colIdx ];++ if ( ! rpSearch.test( data ) ) {+ display.splice( i, 1 );+ }+ }+ }+++ /**+ * Filter the data table based on user input and draw the table+ * @param {object} settings dataTables settings object+ * @param {string} input string to filter on+ * @param {int} force optional - force a research of the master array (1) or not (undefined or 0)+ * @param {bool} regex treat as a regular expression or not+ * @param {bool} smart perform smart filtering or not+ * @param {bool} caseInsensitive Do case insenstive matching or not+ * @memberof DataTable#oApi+ */+ function _fnFilter( settings, input, force, regex, smart, caseInsensitive )+ {+ var rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );+ var prevSearch = settings.oPreviousSearch.sSearch;+ var displayMaster = settings.aiDisplayMaster;+ var display, invalidated, i;++ // Need to take account of custom filtering functions - always filter+ if ( DataTable.ext.search.length !== 0 ) {+ force = true;+ }++ // Check if any of the rows were invalidated+ invalidated = _fnFilterData( settings );++ // If the input is blank - we just want the full data set+ if ( input.length <= 0 ) {+ settings.aiDisplay = displayMaster.slice();+ }+ else {+ // New search - start from the master array+ if ( invalidated ||+ force ||+ prevSearch.length > input.length ||+ input.indexOf(prevSearch) !== 0 ||+ settings.bSorted // On resort, the display master needs to be+ // re-filtered since indexes will have changed+ ) {+ settings.aiDisplay = displayMaster.slice();+ }++ // Search the display array+ display = settings.aiDisplay;++ for ( i=display.length-1 ; i>=0 ; i-- ) {+ if ( ! rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {+ display.splice( i, 1 );+ }+ }+ }+ }+++ /**+ * Build a regular expression object suitable for searching a table+ * @param {string} sSearch string to search for+ * @param {bool} bRegex treat as a regular expression or not+ * @param {bool} bSmart perform smart filtering or not+ * @param {bool} bCaseInsensitive Do case insensitive matching or not+ * @returns {RegExp} constructed object+ * @memberof DataTable#oApi+ */+ function _fnFilterCreateSearch( search, regex, smart, caseInsensitive )+ {+ search = regex ?+ search :+ _fnEscapeRegex( search );++ if ( smart ) {+ /* For smart filtering we want to allow the search to work regardless of+ * word order. We also want double quoted text to be preserved, so word+ * order is important - a la google. So this is what we want to+ * generate:+ *+ * ^(?=.*?\bone\b)(?=.*?\btwo three\b)(?=.*?\bfour\b).*$+ */+ var a = $.map( search.match( /"[^"]+"|[^ ]+/g ) || '', function ( word ) {+ return word.charAt(0) === '"' ?+ word.match( /^"(.*)"$/ )[1] :+ word;+ } );++ search = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';+ }++ return new RegExp( search, caseInsensitive ? 'i' : '' );+ }+++ /**+ * scape a string such that it can be used in a regular expression+ * @param {string} sVal string to escape+ * @returns {string} escaped string+ * @memberof DataTable#oApi+ */+ function _fnEscapeRegex ( sVal )+ {+ return sVal.replace( _re_escape_regex, '\\$1' );+ }++++ var __filter_div = $('<div>')[0];+ var __filter_div_textContent = __filter_div.textContent !== undefined;++ // Update the filtering data for each row if needed (by invalidation or first run)+ function _fnFilterData ( settings )+ {+ var columns = settings.aoColumns;+ var column;+ var i, j, ien, jen, filterData, cellData, row;+ var fomatters = DataTable.ext.type.search;+ var wasInvalidated = false;++ for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {+ row = settings.aoData[i];++ if ( ! row._aFilterData ) {+ filterData = [];++ for ( j=0, jen=columns.length ; j<jen ; j++ ) {+ column = columns[j];++ if ( column.bSearchable ) {+ cellData = _fnGetCellData( settings, i, j, 'filter' );++ if ( fomatters[ column.sType ] ) {+ cellData = fomatters[ column.sType ]( cellData );+ }++ // Search in DataTables 1.10 is string based. In 1.11 this+ // should be altered to also allow strict type checking.+ if ( cellData === null ) {+ cellData = '';+ }++ if ( typeof cellData !== 'string' && cellData.toString ) {+ cellData = cellData.toString();+ }+ }+ else {+ cellData = '';+ }++ // If it looks like there is an HTML entity in the string,+ // attempt to decode it so sorting works as expected. Note that+ // we could use a single line of jQuery to do this, but the DOM+ // method used here is much faster http://jsperf.com/html-decode+ if ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {+ __filter_div.innerHTML = cellData;+ cellData = __filter_div_textContent ?+ __filter_div.textContent :+ __filter_div.innerText;+ }++ if ( cellData.replace ) {+ cellData = cellData.replace(/[\r\n]/g, '');+ }++ filterData.push( cellData );+ }++ row._aFilterData = filterData;+ row._sFilterRow = filterData.join(' ');+ wasInvalidated = true;+ }+ }++ return wasInvalidated;+ }+++ /**+ * Convert from the internal Hungarian notation to camelCase for external+ * interaction+ * @param {object} obj Object to convert+ * @returns {object} Inverted object+ * @memberof DataTable#oApi+ */+ function _fnSearchToCamel ( obj )+ {+ return {+ search: obj.sSearch,+ smart: obj.bSmart,+ regex: obj.bRegex,+ caseInsensitive: obj.bCaseInsensitive+ };+ }++++ /**+ * Convert from camelCase notation to the internal Hungarian. We could use the+ * Hungarian convert function here, but this is cleaner+ * @param {object} obj Object to convert+ * @returns {object} Inverted object+ * @memberof DataTable#oApi+ */+ function _fnSearchToHung ( obj )+ {+ return {+ sSearch: obj.search,+ bSmart: obj.smart,+ bRegex: obj.regex,+ bCaseInsensitive: obj.caseInsensitive+ };+ }++ /**+ * Generate the node required for the info display+ * @param {object} oSettings dataTables settings object+ * @returns {node} Information element+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlInfo ( settings )+ {+ var+ tid = settings.sTableId,+ nodes = settings.aanFeatures.i,+ n = $('<div/>', {+ 'class': settings.oClasses.sInfo,+ 'id': ! nodes ? tid+'_info' : null+ } );++ if ( ! nodes ) {+ // Update display on each draw+ settings.aoDrawCallback.push( {+ "fn": _fnUpdateInfo,+ "sName": "information"+ } );++ n+ .attr( 'role', 'status' )+ .attr( 'aria-live', 'polite' );++ // Table is described by our info div+ $(settings.nTable).attr( 'aria-describedby', tid+'_info' );+ }++ return n[0];+ }+++ /**+ * Update the information elements in the display+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnUpdateInfo ( settings )+ {+ /* Show information about the table */+ var nodes = settings.aanFeatures.i;+ if ( nodes.length === 0 ) {+ return;+ }++ var+ lang = settings.oLanguage,+ start = settings._iDisplayStart+1,+ end = settings.fnDisplayEnd(),+ max = settings.fnRecordsTotal(),+ total = settings.fnRecordsDisplay(),+ out = total ?+ lang.sInfo :+ lang.sInfoEmpty;++ if ( total !== max ) {+ /* Record set after filtering */+ out += ' ' + lang.sInfoFiltered;+ }++ // Convert the macros+ out += lang.sInfoPostFix;+ out = _fnInfoMacros( settings, out );++ var callback = lang.fnInfoCallback;+ if ( callback !== null ) {+ out = callback.call( settings.oInstance,+ settings, start, end, max, total, out+ );+ }++ $(nodes).html( out );+ }+++ function _fnInfoMacros ( settings, str )+ {+ // When infinite scrolling, we are always starting at 1. _iDisplayStart is used only+ // internally+ var+ formatter = settings.fnFormatNumber,+ start = settings._iDisplayStart+1,+ len = settings._iDisplayLength,+ vis = settings.fnRecordsDisplay(),+ all = len === -1;++ return str.+ replace(/_START_/g, formatter.call( settings, start ) ).+ replace(/_END_/g, formatter.call( settings, settings.fnDisplayEnd() ) ).+ replace(/_MAX_/g, formatter.call( settings, settings.fnRecordsTotal() ) ).+ replace(/_TOTAL_/g, formatter.call( settings, vis ) ).+ replace(/_PAGE_/g, formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).+ replace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );+ }++++ /**+ * Draw the table for the first time, adding all required features+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnInitialise ( settings )+ {+ var i, iLen, iAjaxStart=settings.iInitDisplayStart;+ var columns = settings.aoColumns, column;+ var features = settings.oFeatures;++ /* Ensure that the table data is fully initialised */+ if ( ! settings.bInitialised ) {+ setTimeout( function(){ _fnInitialise( settings ); }, 200 );+ return;+ }++ /* Show the display HTML options */+ _fnAddOptionsHtml( settings );++ /* Build and draw the header / footer for the table */+ _fnBuildHead( settings );+ _fnDrawHead( settings, settings.aoHeader );+ _fnDrawHead( settings, settings.aoFooter );++ /* Okay to show that something is going on now */+ _fnProcessingDisplay( settings, true );++ /* Calculate sizes for columns */+ if ( features.bAutoWidth ) {+ _fnCalculateColumnWidths( settings );+ }++ for ( i=0, iLen=columns.length ; i<iLen ; i++ ) {+ column = columns[i];++ if ( column.sWidth ) {+ column.nTh.style.width = _fnStringToCss( column.sWidth );+ }+ }++ // If there is default sorting required - let's do it. The sort function+ // will do the drawing for us. Otherwise we draw the table regardless of the+ // Ajax source - this allows the table to look initialised for Ajax sourcing+ // data (show 'loading' message possibly)+ _fnReDraw( settings );++ // Server-side processing init complete is done by _fnAjaxUpdateDraw+ var dataSrc = _fnDataSource( settings );+ if ( dataSrc != 'ssp' ) {+ // if there is an ajax source load the data+ if ( dataSrc == 'ajax' ) {+ _fnBuildAjax( settings, [], function(json) {+ var aData = _fnAjaxDataSrc( settings, json );++ // Got the data - add it to the table+ for ( i=0 ; i<aData.length ; i++ ) {+ _fnAddData( settings, aData[i] );+ }++ // Reset the init display for cookie saving. We've already done+ // a filter, and therefore cleared it before. So we need to make+ // it appear 'fresh'+ settings.iInitDisplayStart = iAjaxStart;++ _fnReDraw( settings );++ _fnProcessingDisplay( settings, false );+ _fnInitComplete( settings, json );+ }, settings );+ }+ else {+ _fnProcessingDisplay( settings, false );+ _fnInitComplete( settings );+ }+ }+ }+++ /**+ * Draw the table for the first time, adding all required features+ * @param {object} oSettings dataTables settings object+ * @param {object} [json] JSON from the server that completed the table, if using Ajax source+ * with client-side processing (optional)+ * @memberof DataTable#oApi+ */+ function _fnInitComplete ( settings, json )+ {+ settings._bInitComplete = true;++ // On an Ajax load we now have data and therefore want to apply the column+ // sizing+ if ( json ) {+ _fnAdjustColumnSizing( settings );+ }++ _fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );+ }+++ function _fnLengthChange ( settings, val )+ {+ var len = parseInt( val, 10 );+ settings._iDisplayLength = len;++ _fnLengthOverflow( settings );++ // Fire length change event+ _fnCallbackFire( settings, null, 'length', [settings, len] );+ }+++ /**+ * Generate the node required for user display length changing+ * @param {object} settings dataTables settings object+ * @returns {node} Display length feature node+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlLength ( settings )+ {+ var+ classes = settings.oClasses,+ tableId = settings.sTableId,+ menu = settings.aLengthMenu,+ d2 = $.isArray( menu[0] ),+ lengths = d2 ? menu[0] : menu,+ language = d2 ? menu[1] : menu;++ var select = $('<select/>', {+ 'name': tableId+'_length',+ 'aria-controls': tableId,+ 'class': classes.sLengthSelect+ } );++ for ( var i=0, ien=lengths.length ; i<ien ; i++ ) {+ select[0][ i ] = new Option( language[i], lengths[i] );+ }++ var div = $('<div><label/></div>').addClass( classes.sLength );+ if ( ! settings.aanFeatures.l ) {+ div[0].id = tableId+'_length';+ }++ div.children().append(+ settings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )+ );++ // Can't use `select` variable as user might provide their own and the+ // reference is broken by the use of outerHTML+ $('select', div)+ .val( settings._iDisplayLength )+ .bind( 'change.DT', function(e) {+ _fnLengthChange( settings, $(this).val() );+ _fnDraw( settings );+ } );++ // Update node value whenever anything changes the table's length+ $(settings.nTable).bind( 'length.dt.DT', function (e, s, len) {+ if ( settings === s ) {+ $('select', div).val( len );+ }+ } );++ return div[0];+ }++++ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *+ * Note that most of the paging logic is done in+ * DataTable.ext.pager+ */++ /**+ * Generate the node required for default pagination+ * @param {object} oSettings dataTables settings object+ * @returns {node} Pagination feature node+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlPaginate ( settings )+ {+ var+ type = settings.sPaginationType,+ plugin = DataTable.ext.pager[ type ],+ modern = typeof plugin === 'function',+ redraw = function( settings ) {+ _fnDraw( settings );+ },+ node = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],+ features = settings.aanFeatures;++ if ( ! modern ) {+ plugin.fnInit( settings, node, redraw );+ }++ /* Add a draw callback for the pagination on first instance, to update the paging display */+ if ( ! features.p )+ {+ node.id = settings.sTableId+'_paginate';++ settings.aoDrawCallback.push( {+ "fn": function( settings ) {+ if ( modern ) {+ var+ start = settings._iDisplayStart,+ len = settings._iDisplayLength,+ visRecords = settings.fnRecordsDisplay(),+ all = len === -1,+ page = all ? 0 : Math.ceil( start / len ),+ pages = all ? 1 : Math.ceil( visRecords / len ),+ buttons = plugin(page, pages),+ i, ien;++ for ( i=0, ien=features.p.length ; i<ien ; i++ ) {+ _fnRenderer( settings, 'pageButton' )(+ settings, features.p[i], i, buttons, page, pages+ );+ }+ }+ else {+ plugin.fnUpdate( settings, redraw );+ }+ },+ "sName": "pagination"+ } );+ }++ return node;+ }+++ /**+ * Alter the display settings to change the page+ * @param {object} settings DataTables settings object+ * @param {string|int} action Paging action to take: "first", "previous",+ * "next" or "last" or page number to jump to (integer)+ * @param [bool] redraw Automatically draw the update or not+ * @returns {bool} true page has changed, false - no change+ * @memberof DataTable#oApi+ */+ function _fnPageChange ( settings, action, redraw )+ {+ var+ start = settings._iDisplayStart,+ len = settings._iDisplayLength,+ records = settings.fnRecordsDisplay();++ if ( records === 0 || len === -1 )+ {+ start = 0;+ }+ else if ( typeof action === "number" )+ {+ start = action * len;++ if ( start > records )+ {+ start = 0;+ }+ }+ else if ( action == "first" )+ {+ start = 0;+ }+ else if ( action == "previous" )+ {+ start = len >= 0 ?+ start - len :+ 0;++ if ( start < 0 )+ {+ start = 0;+ }+ }+ else if ( action == "next" )+ {+ if ( start + len < records )+ {+ start += len;+ }+ }+ else if ( action == "last" )+ {+ start = Math.floor( (records-1) / len) * len;+ }+ else+ {+ _fnLog( settings, 0, "Unknown paging action: "+action, 5 );+ }++ var changed = settings._iDisplayStart !== start;+ settings._iDisplayStart = start;++ if ( changed ) {+ _fnCallbackFire( settings, null, 'page', [settings] );++ if ( redraw ) {+ _fnDraw( settings );+ }+ }++ return changed;+ }++++ /**+ * Generate the node required for the processing node+ * @param {object} settings dataTables settings object+ * @returns {node} Processing element+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlProcessing ( settings )+ {+ return $('<div/>', {+ 'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,+ 'class': settings.oClasses.sProcessing+ } )+ .html( settings.oLanguage.sProcessing )+ .insertBefore( settings.nTable )[0];+ }+++ /**+ * Display or hide the processing indicator+ * @param {object} settings dataTables settings object+ * @param {bool} show Show the processing indicator (true) or not (false)+ * @memberof DataTable#oApi+ */+ function _fnProcessingDisplay ( settings, show )+ {+ if ( settings.oFeatures.bProcessing ) {+ $(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );+ }++ _fnCallbackFire( settings, null, 'processing', [settings, show] );+ }++ /**+ * Add any control elements for the table - specifically scrolling+ * @param {object} settings dataTables settings object+ * @returns {node} Node to add to the DOM+ * @memberof DataTable#oApi+ */+ function _fnFeatureHtmlTable ( settings )+ {+ var table = $(settings.nTable);++ // Add the ARIA grid role to the table+ table.attr( 'role', 'grid' );++ // Scrolling from here on in+ var scroll = settings.oScroll;++ if ( scroll.sX === '' && scroll.sY === '' ) {+ return settings.nTable;+ }++ var scrollX = scroll.sX;+ var scrollY = scroll.sY;+ var classes = settings.oClasses;+ var caption = table.children('caption');+ var captionSide = caption.length ? caption[0]._captionSide : null;+ var headerClone = $( table[0].cloneNode(false) );+ var footerClone = $( table[0].cloneNode(false) );+ var footer = table.children('tfoot');+ var _div = '<div/>';+ var size = function ( s ) {+ return !s ? null : _fnStringToCss( s );+ };++ // This is fairly messy, but with x scrolling enabled, if the table has a+ // width attribute, regardless of any width applied using the column width+ // options, the browser will shrink or grow the table as needed to fit into+ // that 100%. That would make the width options useless. So we remove it.+ // This is okay, under the assumption that width:100% is applied to the+ // table in CSS (it is in the default stylesheet) which will set the table+ // width as appropriate (the attribute and css behave differently...)+ if ( scroll.sX && table.attr('width') === '100%' ) {+ table.removeAttr('width');+ }++ if ( ! footer.length ) {+ footer = null;+ }++ /*+ * The HTML structure that we want to generate in this function is:+ * div - scroller+ * div - scroll head+ * div - scroll head inner+ * table - scroll head table+ * thead - thead+ * div - scroll body+ * table - table (master table)+ * thead - thead clone for sizing+ * tbody - tbody+ * div - scroll foot+ * div - scroll foot inner+ * table - scroll foot table+ * tfoot - tfoot+ */+ var scroller = $( _div, { 'class': classes.sScrollWrapper } )+ .append(+ $(_div, { 'class': classes.sScrollHead } )+ .css( {+ overflow: 'hidden',+ position: 'relative',+ border: 0,+ width: scrollX ? size(scrollX) : '100%'+ } )+ .append(+ $(_div, { 'class': classes.sScrollHeadInner } )+ .css( {+ 'box-sizing': 'content-box',+ width: scroll.sXInner || '100%'+ } )+ .append(+ headerClone+ .removeAttr('id')+ .css( 'margin-left', 0 )+ .append(+ table.children('thead')+ )+ )+ )+ .append( captionSide === 'top' ? caption : null )+ )+ .append(+ $(_div, { 'class': classes.sScrollBody } )+ .css( {+ overflow: 'auto',+ height: size( scrollY ),+ width: size( scrollX )+ } )+ .append( table )+ );++ if ( footer ) {+ scroller.append(+ $(_div, { 'class': classes.sScrollFoot } )+ .css( {+ overflow: 'hidden',+ border: 0,+ width: scrollX ? size(scrollX) : '100%'+ } )+ .append(+ $(_div, { 'class': classes.sScrollFootInner } )+ .append(+ footerClone+ .removeAttr('id')+ .css( 'margin-left', 0 )+ .append(+ table.children('tfoot')+ )+ )+ )+ .append( captionSide === 'bottom' ? caption : null )+ );+ }++ var children = scroller.children();+ var scrollHead = children[0];+ var scrollBody = children[1];+ var scrollFoot = footer ? children[2] : null;++ // When the body is scrolled, then we also want to scroll the headers+ if ( scrollX ) {+ $(scrollBody).scroll( function (e) {+ var scrollLeft = this.scrollLeft;++ scrollHead.scrollLeft = scrollLeft;++ if ( footer ) {+ scrollFoot.scrollLeft = scrollLeft;+ }+ } );+ }++ settings.nScrollHead = scrollHead;+ settings.nScrollBody = scrollBody;+ settings.nScrollFoot = scrollFoot;++ // On redraw - align columns+ settings.aoDrawCallback.push( {+ "fn": _fnScrollDraw,+ "sName": "scrolling"+ } );++ return scroller[0];+ }++++ /**+ * Update the header, footer and body tables for resizing - i.e. column+ * alignment.+ *+ * Welcome to the most horrible function DataTables. The process that this+ * function follows is basically:+ * 1. Re-create the table inside the scrolling div+ * 2. Take live measurements from the DOM+ * 3. Apply the measurements to align the columns+ * 4. Clean up+ *+ * @param {object} settings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnScrollDraw ( settings )+ {+ // Given that this is such a monster function, a lot of variables are use+ // to try and keep the minimised size as small as possible+ var+ scroll = settings.oScroll,+ scrollX = scroll.sX,+ scrollXInner = scroll.sXInner,+ scrollY = scroll.sY,+ barWidth = scroll.iBarWidth,+ divHeader = $(settings.nScrollHead),+ divHeaderStyle = divHeader[0].style,+ divHeaderInner = divHeader.children('div'),+ divHeaderInnerStyle = divHeaderInner[0].style,+ divHeaderTable = divHeaderInner.children('table'),+ divBodyEl = settings.nScrollBody,+ divBody = $(divBodyEl),+ divBodyStyle = divBodyEl.style,+ divFooter = $(settings.nScrollFoot),+ divFooterInner = divFooter.children('div'),+ divFooterTable = divFooterInner.children('table'),+ header = $(settings.nTHead),+ table = $(settings.nTable),+ tableEl = table[0],+ tableStyle = tableEl.style,+ footer = settings.nTFoot ? $(settings.nTFoot) : null,+ browser = settings.oBrowser,+ ie67 = browser.bScrollOversize,+ headerTrgEls, footerTrgEls,+ headerSrcEls, footerSrcEls,+ headerCopy, footerCopy,+ headerWidths=[], footerWidths=[],+ headerContent=[],+ idx, correction, sanityWidth,+ zeroOut = function(nSizer) {+ var style = nSizer.style;+ style.paddingTop = "0";+ style.paddingBottom = "0";+ style.borderTopWidth = "0";+ style.borderBottomWidth = "0";+ style.height = 0;+ };++ /*+ * 1. Re-create the table inside the scrolling div+ */++ // Remove the old minimised thead and tfoot elements in the inner table+ table.children('thead, tfoot').remove();++ // Clone the current header and footer elements and then place it into the inner table+ headerCopy = header.clone().prependTo( table );+ headerTrgEls = header.find('tr'); // original header is in its own table+ headerSrcEls = headerCopy.find('tr');+ headerCopy.find('th, td').removeAttr('tabindex');++ if ( footer ) {+ footerCopy = footer.clone().prependTo( table );+ footerTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized+ footerSrcEls = footerCopy.find('tr');+ }+++ /*+ * 2. Take live measurements from the DOM - do not alter the DOM itself!+ */++ // Remove old sizing and apply the calculated column widths+ // Get the unique column headers in the newly created (cloned) header. We want to apply the+ // calculated sizes to this header+ if ( ! scrollX )+ {+ divBodyStyle.width = '100%';+ divHeader[0].style.width = '100%';+ }++ $.each( _fnGetUniqueThs( settings, headerCopy ), function ( i, el ) {+ idx = _fnVisibleToColumnIndex( settings, i );+ el.style.width = settings.aoColumns[idx].sWidth;+ } );++ if ( footer ) {+ _fnApplyToChildren( function(n) {+ n.style.width = "";+ }, footerSrcEls );+ }++ // If scroll collapse is enabled, when we put the headers back into the body for sizing, we+ // will end up forcing the scrollbar to appear, making our measurements wrong for when we+ // then hide it (end of this function), so add the header height to the body scroller.+ if ( scroll.bCollapse && scrollY !== "" ) {+ divBodyStyle.height = (divBody[0].offsetHeight + header[0].offsetHeight)+"px";+ }++ // Size the table as a whole+ sanityWidth = table.outerWidth();+ if ( scrollX === "" ) {+ // No x scrolling+ tableStyle.width = "100%";++ // IE7 will make the width of the table when 100% include the scrollbar+ // - which is shouldn't. When there is a scrollbar we need to take this+ // into account.+ if ( ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight ||+ divBody.css('overflow-y') == "scroll")+ ) {+ tableStyle.width = _fnStringToCss( table.outerWidth() - barWidth);+ }+ }+ else+ {+ // x scrolling+ if ( scrollXInner !== "" ) {+ // x scroll inner has been given - use it+ tableStyle.width = _fnStringToCss(scrollXInner);+ }+ else if ( sanityWidth == divBody.width() && divBody.height() < table.height() ) {+ // There is y-scrolling - try to take account of the y scroll bar+ tableStyle.width = _fnStringToCss( sanityWidth-barWidth );+ if ( table.outerWidth() > sanityWidth-barWidth ) {+ // Not possible to take account of it+ tableStyle.width = _fnStringToCss( sanityWidth );+ }+ }+ else {+ // When all else fails+ tableStyle.width = _fnStringToCss( sanityWidth );+ }+ }++ // Recalculate the sanity width - now that we've applied the required width,+ // before it was a temporary variable. This is required because the column+ // width calculation is done before this table DOM is created.+ sanityWidth = table.outerWidth();++ // Hidden header should have zero height, so remove padding and borders. Then+ // set the width based on the real headers++ // Apply all styles in one pass+ _fnApplyToChildren( zeroOut, headerSrcEls );++ // Read all widths in next pass+ _fnApplyToChildren( function(nSizer) {+ headerContent.push( nSizer.innerHTML );+ headerWidths.push( _fnStringToCss( $(nSizer).css('width') ) );+ }, headerSrcEls );++ // Apply all widths in final pass+ _fnApplyToChildren( function(nToSize, i) {+ nToSize.style.width = headerWidths[i];+ }, headerTrgEls );++ $(headerSrcEls).height(0);++ /* Same again with the footer if we have one */+ if ( footer )+ {+ _fnApplyToChildren( zeroOut, footerSrcEls );++ _fnApplyToChildren( function(nSizer) {+ footerWidths.push( _fnStringToCss( $(nSizer).css('width') ) );+ }, footerSrcEls );++ _fnApplyToChildren( function(nToSize, i) {+ nToSize.style.width = footerWidths[i];+ }, footerTrgEls );++ $(footerSrcEls).height(0);+ }+++ /*+ * 3. Apply the measurements+ */++ // "Hide" the header and footer that we used for the sizing. We need to keep+ // the content of the cell so that the width applied to the header and body+ // both match, but we want to hide it completely. We want to also fix their+ // width to what they currently are+ _fnApplyToChildren( function(nSizer, i) {+ nSizer.innerHTML = '<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+headerContent[i]+'</div>';+ nSizer.style.width = headerWidths[i];+ }, headerSrcEls );++ if ( footer )+ {+ _fnApplyToChildren( function(nSizer, i) {+ nSizer.innerHTML = "";+ nSizer.style.width = footerWidths[i];+ }, footerSrcEls );+ }++ // Sanity check that the table is of a sensible width. If not then we are going to get+ // misalignment - try to prevent this by not allowing the table to shrink below its min width+ if ( table.outerWidth() < sanityWidth )+ {+ // The min width depends upon if we have a vertical scrollbar visible or not */+ correction = ((divBodyEl.scrollHeight > divBodyEl.offsetHeight ||+ divBody.css('overflow-y') == "scroll")) ?+ sanityWidth+barWidth :+ sanityWidth;++ // IE6/7 are a law unto themselves...+ if ( ie67 && (divBodyEl.scrollHeight >+ divBodyEl.offsetHeight || divBody.css('overflow-y') == "scroll")+ ) {+ tableStyle.width = _fnStringToCss( correction-barWidth );+ }++ // And give the user a warning that we've stopped the table getting too small+ if ( scrollX === "" || scrollXInner !== "" ) {+ _fnLog( settings, 1, 'Possible column misalignment', 6 );+ }+ }+ else+ {+ correction = '100%';+ }++ // Apply to the container elements+ divBodyStyle.width = _fnStringToCss( correction );+ divHeaderStyle.width = _fnStringToCss( correction );++ if ( footer ) {+ settings.nScrollFoot.style.width = _fnStringToCss( correction );+ }+++ /*+ * 4. Clean up+ */+ if ( ! scrollY ) {+ /* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting+ * the scrollbar height from the visible display, rather than adding it on. We need to+ * set the height in order to sort this. Don't want to do it in any other browsers.+ */+ if ( ie67 ) {+ divBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+barWidth );+ }+ }++ if ( scrollY && scroll.bCollapse ) {+ divBodyStyle.height = _fnStringToCss( scrollY );++ var iExtra = (scrollX && tableEl.offsetWidth > divBodyEl.offsetWidth) ?+ barWidth :+ 0;++ if ( tableEl.offsetHeight < divBodyEl.offsetHeight ) {+ divBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+iExtra );+ }+ }++ /* Finally set the width's of the header and footer tables */+ var iOuterWidth = table.outerWidth();+ divHeaderTable[0].style.width = _fnStringToCss( iOuterWidth );+ divHeaderInnerStyle.width = _fnStringToCss( iOuterWidth );++ // Figure out if there are scrollbar present - if so then we need a the header and footer to+ // provide a bit more space to allow "overflow" scrolling (i.e. past the scrollbar)+ var bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == "scroll";+ var padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );+ divHeaderInnerStyle[ padding ] = bScrolling ? barWidth+"px" : "0px";++ if ( footer ) {+ divFooterTable[0].style.width = _fnStringToCss( iOuterWidth );+ divFooterInner[0].style.width = _fnStringToCss( iOuterWidth );+ divFooterInner[0].style[padding] = bScrolling ? barWidth+"px" : "0px";+ }++ /* Adjust the position of the header in case we loose the y-scrollbar */+ divBody.scroll();++ // If sorting or filtering has occurred, jump the scrolling back to the top+ // only if we aren't holding the position+ if ( (settings.bSorted || settings.bFiltered) && ! settings._drawHold ) {+ divBodyEl.scrollTop = 0;+ }+ }++++ /**+ * Apply a given function to the display child nodes of an element array (typically+ * TD children of TR rows+ * @param {function} fn Method to apply to the objects+ * @param array {nodes} an1 List of elements to look through for display children+ * @param array {nodes} an2 Another list (identical structure to the first) - optional+ * @memberof DataTable#oApi+ */+ function _fnApplyToChildren( fn, an1, an2 )+ {+ var index=0, i=0, iLen=an1.length;+ var nNode1, nNode2;++ while ( i < iLen ) {+ nNode1 = an1[i].firstChild;+ nNode2 = an2 ? an2[i].firstChild : null;++ while ( nNode1 ) {+ if ( nNode1.nodeType === 1 ) {+ if ( an2 ) {+ fn( nNode1, nNode2, index );+ }+ else {+ fn( nNode1, index );+ }++ index++;+ }++ nNode1 = nNode1.nextSibling;+ nNode2 = an2 ? nNode2.nextSibling : null;+ }++ i++;+ }+ }++++ var __re_html_remove = /<.*?>/g;+++ /**+ * Calculate the width of columns for the table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnCalculateColumnWidths ( oSettings )+ {+ var+ table = oSettings.nTable,+ columns = oSettings.aoColumns,+ scroll = oSettings.oScroll,+ scrollY = scroll.sY,+ scrollX = scroll.sX,+ scrollXInner = scroll.sXInner,+ columnCount = columns.length,+ visibleColumns = _fnGetColumns( oSettings, 'bVisible' ),+ headerCells = $('th', oSettings.nTHead),+ tableWidthAttr = table.getAttribute('width'),+ tableContainer = table.parentNode,+ userInputs = false,+ i, column, columnIdx, width, outerWidth;++ /* Convert any user input sizes into pixel sizes */+ for ( i=0 ; i<visibleColumns.length ; i++ ) {+ column = columns[ visibleColumns[i] ];++ if ( column.sWidth !== null ) {+ column.sWidth = _fnConvertToWidth( column.sWidthOrig, tableContainer );++ userInputs = true;+ }+ }++ /* If the number of columns in the DOM equals the number that we have to+ * process in DataTables, then we can use the offsets that are created by+ * the web- browser. No custom sizes can be set in order for this to happen,+ * nor scrolling used+ */+ if ( ! userInputs && ! scrollX && ! scrollY &&+ columnCount == _fnVisbleColumns( oSettings ) &&+ columnCount == headerCells.length+ ) {+ for ( i=0 ; i<columnCount ; i++ ) {+ columns[i].sWidth = _fnStringToCss( headerCells.eq(i).width() );+ }+ }+ else+ {+ // Otherwise construct a single row table with the widest node in the+ // data, assign any user defined widths, then insert it into the DOM and+ // allow the browser to do all the hard work of calculating table widths+ var tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table+ .empty()+ .css( 'visibility', 'hidden' )+ .removeAttr( 'id' )+ .append( $(oSettings.nTHead).clone( false ) )+ .append( $(oSettings.nTFoot).clone( false ) )+ .append( $('<tbody><tr/></tbody>') );++ // Remove any assigned widths from the footer (from scrolling)+ tmpTable.find('tfoot th, tfoot td').css('width', '');++ var tr = tmpTable.find( 'tbody tr' );++ // Apply custom sizing to the cloned header+ headerCells = _fnGetUniqueThs( oSettings, tmpTable.find('thead')[0] );++ for ( i=0 ; i<visibleColumns.length ; i++ ) {+ column = columns[ visibleColumns[i] ];++ headerCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ?+ _fnStringToCss( column.sWidthOrig ) :+ '';+ }++ // Find the widest cell for each column and put it into the table+ if ( oSettings.aoData.length ) {+ for ( i=0 ; i<visibleColumns.length ; i++ ) {+ columnIdx = visibleColumns[i];+ column = columns[ columnIdx ];++ $( _fnGetWidestNode( oSettings, columnIdx ) )+ .clone( false )+ .append( column.sContentPadding )+ .appendTo( tr );+ }+ }++ // Table has been built, attach to the document so we can work with it+ tmpTable.appendTo( tableContainer );++ // When scrolling (X or Y) we want to set the width of the table as+ // appropriate. However, when not scrolling leave the table width as it+ // is. This results in slightly different, but I think correct behaviour+ if ( scrollX && scrollXInner ) {+ tmpTable.width( scrollXInner );+ }+ else if ( scrollX ) {+ tmpTable.css( 'width', 'auto' );++ if ( tmpTable.width() < tableContainer.offsetWidth ) {+ tmpTable.width( tableContainer.offsetWidth );+ }+ }+ else if ( scrollY ) {+ tmpTable.width( tableContainer.offsetWidth );+ }+ else if ( tableWidthAttr ) {+ tmpTable.width( tableWidthAttr );+ }++ // Take into account the y scrollbar+ _fnScrollingWidthAdjust( oSettings, tmpTable[0] );++ // Browsers need a bit of a hand when a width is assigned to any columns+ // when x-scrolling as they tend to collapse the table to the min-width,+ // even if we sent the column widths. So we need to keep track of what+ // the table width should be by summing the user given values, and the+ // automatic values+ if ( scrollX )+ {+ var total = 0;++ for ( i=0 ; i<visibleColumns.length ; i++ ) {+ column = columns[ visibleColumns[i] ];+ outerWidth = $(headerCells[i]).outerWidth();++ total += column.sWidthOrig === null ?+ outerWidth :+ parseInt( column.sWidth, 10 ) + outerWidth - $(headerCells[i]).width();+ }++ tmpTable.width( _fnStringToCss( total ) );+ table.style.width = _fnStringToCss( total );+ }++ // Get the width of each column in the constructed table+ for ( i=0 ; i<visibleColumns.length ; i++ ) {+ column = columns[ visibleColumns[i] ];+ width = $(headerCells[i]).width();++ if ( width ) {+ column.sWidth = _fnStringToCss( width );+ }+ }++ table.style.width = _fnStringToCss( tmpTable.css('width') );++ // Finished with the table - ditch it+ tmpTable.remove();+ }++ // If there is a width attr, we want to attach an event listener which+ // allows the table sizing to automatically adjust when the window is+ // resized. Use the width attr rather than CSS, since we can't know if the+ // CSS is a relative value or absolute - DOM read is always px.+ if ( tableWidthAttr ) {+ table.style.width = _fnStringToCss( tableWidthAttr );+ }++ if ( (tableWidthAttr || scrollX) && ! oSettings._reszEvt ) {+ $(window).bind('resize.DT-'+oSettings.sInstance, _fnThrottle( function () {+ _fnAdjustColumnSizing( oSettings );+ } ) );++ oSettings._reszEvt = true;+ }+ }+++ /**+ * Throttle the calls to a function. Arguments and context are maintained for+ * the throttled function+ * @param {function} fn Function to be called+ * @param {int} [freq=200] call frequency in mS+ * @returns {function} wrapped function+ * @memberof DataTable#oApi+ */+ function _fnThrottle( fn, freq ) {+ var+ frequency = freq || 200,+ last,+ timer;++ return function () {+ var+ that = this,+ now = +new Date(),+ args = arguments;++ if ( last && now < last + frequency ) {+ clearTimeout( timer );++ timer = setTimeout( function () {+ last = undefined;+ fn.apply( that, args );+ }, frequency );+ }+ else if ( last ) {+ last = now;+ fn.apply( that, args );+ }+ else {+ last = now;+ }+ };+ }+++ /**+ * Convert a CSS unit width to pixels (e.g. 2em)+ * @param {string} width width to be converted+ * @param {node} parent parent to get the with for (required for relative widths) - optional+ * @returns {int} width in pixels+ * @memberof DataTable#oApi+ */+ function _fnConvertToWidth ( width, parent )+ {+ if ( ! width ) {+ return 0;+ }++ var n = $('<div/>')+ .css( 'width', _fnStringToCss( width ) )+ .appendTo( parent || document.body );++ var val = n[0].offsetWidth;+ n.remove();++ return val;+ }+++ /**+ * Adjust a table's width to take account of vertical scroll bar+ * @param {object} oSettings dataTables settings object+ * @param {node} n table node+ * @memberof DataTable#oApi+ */++ function _fnScrollingWidthAdjust ( settings, n )+ {+ var scroll = settings.oScroll;++ if ( scroll.sX || scroll.sY ) {+ // When y-scrolling only, we want to remove the width of the scroll bar+ // so the table + scroll bar will fit into the area available, otherwise+ // we fix the table at its current size with no adjustment+ var correction = ! scroll.sX ? scroll.iBarWidth : 0;+ n.style.width = _fnStringToCss( $(n).outerWidth() - correction );+ }+ }+++ /**+ * Get the widest node+ * @param {object} settings dataTables settings object+ * @param {int} colIdx column of interest+ * @returns {node} widest table node+ * @memberof DataTable#oApi+ */+ function _fnGetWidestNode( settings, colIdx )+ {+ var idx = _fnGetMaxLenString( settings, colIdx );+ if ( idx < 0 ) {+ return null;+ }++ var data = settings.aoData[ idx ];+ return ! data.nTr ? // Might not have been created when deferred rendering+ $('<td/>').html( _fnGetCellData( settings, idx, colIdx, 'display' ) )[0] :+ data.anCells[ colIdx ];+ }+++ /**+ * Get the maximum strlen for each data column+ * @param {object} settings dataTables settings object+ * @param {int} colIdx column of interest+ * @returns {string} max string length for each column+ * @memberof DataTable#oApi+ */+ function _fnGetMaxLenString( settings, colIdx )+ {+ var s, max=-1, maxIdx = -1;++ for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {+ s = _fnGetCellData( settings, i, colIdx, 'display' )+'';+ s = s.replace( __re_html_remove, '' );++ if ( s.length > max ) {+ max = s.length;+ maxIdx = i;+ }+ }++ return maxIdx;+ }+++ /**+ * Append a CSS unit (only if required) to a string+ * @param {string} value to css-ify+ * @returns {string} value with css unit+ * @memberof DataTable#oApi+ */+ function _fnStringToCss( s )+ {+ if ( s === null ) {+ return '0px';+ }++ if ( typeof s == 'number' ) {+ return s < 0 ?+ '0px' :+ s+'px';+ }++ // Check it has a unit character already+ return s.match(/\d$/) ?+ s+'px' :+ s;+ }+++ /**+ * Get the width of a scroll bar in this browser being used+ * @returns {int} width in pixels+ * @memberof DataTable#oApi+ */+ function _fnScrollBarWidth ()+ {+ // On first run a static variable is set, since this is only needed once.+ // Subsequent runs will just use the previously calculated value+ if ( ! DataTable.__scrollbarWidth ) {+ var inner = $('<p/>').css( {+ width: '100%',+ height: 200,+ padding: 0+ } )[0];++ var outer = $('<div/>')+ .css( {+ position: 'absolute',+ top: 0,+ left: 0,+ width: 200,+ height: 150,+ padding: 0,+ overflow: 'hidden',+ visibility: 'hidden'+ } )+ .append( inner )+ .appendTo( 'body' );++ var w1 = inner.offsetWidth;+ outer.css( 'overflow', 'scroll' );+ var w2 = inner.offsetWidth;++ if ( w1 === w2 ) {+ w2 = outer[0].clientWidth;+ }++ outer.remove();++ DataTable.__scrollbarWidth = w1 - w2;+ }++ return DataTable.__scrollbarWidth;+ }++++ function _fnSortFlatten ( settings )+ {+ var+ i, iLen, k, kLen,+ aSort = [],+ aiOrig = [],+ aoColumns = settings.aoColumns,+ aDataSort, iCol, sType, srcCol,+ fixed = settings.aaSortingFixed,+ fixedObj = $.isPlainObject( fixed ),+ nestedSort = [],+ add = function ( a ) {+ if ( a.length && ! $.isArray( a[0] ) ) {+ // 1D array+ nestedSort.push( a );+ }+ else {+ // 2D array+ nestedSort.push.apply( nestedSort, a );+ }+ };++ // Build the sort array, with pre-fix and post-fix options if they have been+ // specified+ if ( $.isArray( fixed ) ) {+ add( fixed );+ }++ if ( fixedObj && fixed.pre ) {+ add( fixed.pre );+ }++ add( settings.aaSorting );++ if (fixedObj && fixed.post ) {+ add( fixed.post );+ }++ for ( i=0 ; i<nestedSort.length ; i++ )+ {+ srcCol = nestedSort[i][0];+ aDataSort = aoColumns[ srcCol ].aDataSort;++ for ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )+ {+ iCol = aDataSort[k];+ sType = aoColumns[ iCol ].sType || 'string';++ aSort.push( {+ src: srcCol,+ col: iCol,+ dir: nestedSort[i][1],+ index: nestedSort[i][2],+ type: sType,+ formatter: DataTable.ext.type.order[ sType+"-pre" ]+ } );+ }+ }++ return aSort;+ }++ /**+ * Change the order of the table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ * @todo This really needs split up!+ */+ function _fnSort ( oSettings )+ {+ var+ i, ien, iLen, j, jLen, k, kLen,+ sDataType, nTh,+ aiOrig = [],+ oExtSort = DataTable.ext.type.order,+ aoData = oSettings.aoData,+ aoColumns = oSettings.aoColumns,+ aDataSort, data, iCol, sType, oSort,+ formatters = 0,+ sortCol,+ displayMaster = oSettings.aiDisplayMaster,+ aSort;++ // Resolve any column types that are unknown due to addition or invalidation+ // @todo Can this be moved into a 'data-ready' handler which is called when+ // data is going to be used in the table?+ _fnColumnTypes( oSettings );++ aSort = _fnSortFlatten( oSettings );++ for ( i=0, ien=aSort.length ; i<ien ; i++ ) {+ sortCol = aSort[i];++ // Track if we can use the fast sort algorithm+ if ( sortCol.formatter ) {+ formatters++;+ }++ // Load the data needed for the sort, for each cell+ _fnSortData( oSettings, sortCol.col );+ }++ /* No sorting required if server-side or no sorting array */+ if ( _fnDataSource( oSettings ) != 'ssp' && aSort.length !== 0 )+ {+ // Create a value - key array of the current row positions such that we can use their+ // current position during the sort, if values match, in order to perform stable sorting+ for ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {+ aiOrig[ displayMaster[i] ] = i;+ }++ /* Do the sort - here we want multi-column sorting based on a given data source (column)+ * and sorting function (from oSort) in a certain direction. It's reasonably complex to+ * follow on it's own, but this is what we want (example two column sorting):+ * fnLocalSorting = function(a,b){+ * var iTest;+ * iTest = oSort['string-asc']('data11', 'data12');+ * if (iTest !== 0)+ * return iTest;+ * iTest = oSort['numeric-desc']('data21', 'data22');+ * if (iTest !== 0)+ * return iTest;+ * return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );+ * }+ * Basically we have a test for each sorting column, if the data in that column is equal,+ * test the next column. If all columns match, then we use a numeric sort on the row+ * positions in the original data array to provide a stable sort.+ *+ * Note - I know it seems excessive to have two sorting methods, but the first is around+ * 15% faster, so the second is only maintained for backwards compatibility with sorting+ * methods which do not have a pre-sort formatting function.+ */+ if ( formatters === aSort.length ) {+ // All sort types have formatting functions+ displayMaster.sort( function ( a, b ) {+ var+ x, y, k, test, sort,+ len=aSort.length,+ dataA = aoData[a]._aSortData,+ dataB = aoData[b]._aSortData;++ for ( k=0 ; k<len ; k++ ) {+ sort = aSort[k];++ x = dataA[ sort.col ];+ y = dataB[ sort.col ];++ test = x<y ? -1 : x>y ? 1 : 0;+ if ( test !== 0 ) {+ return sort.dir === 'asc' ? test : -test;+ }+ }++ x = aiOrig[a];+ y = aiOrig[b];+ return x<y ? -1 : x>y ? 1 : 0;+ } );+ }+ else {+ // Depreciated - remove in 1.11 (providing a plug-in option)+ // Not all sort types have formatting methods, so we have to call their sorting+ // methods.+ displayMaster.sort( function ( a, b ) {+ var+ x, y, k, l, test, sort, fn,+ len=aSort.length,+ dataA = aoData[a]._aSortData,+ dataB = aoData[b]._aSortData;++ for ( k=0 ; k<len ; k++ ) {+ sort = aSort[k];++ x = dataA[ sort.col ];+ y = dataB[ sort.col ];++ fn = oExtSort[ sort.type+"-"+sort.dir ] || oExtSort[ "string-"+sort.dir ];+ test = fn( x, y );+ if ( test !== 0 ) {+ return test;+ }+ }++ x = aiOrig[a];+ y = aiOrig[b];+ return x<y ? -1 : x>y ? 1 : 0;+ } );+ }+ }++ /* Tell the draw function that we have sorted the data */+ oSettings.bSorted = true;+ }+++ function _fnSortAria ( settings )+ {+ var label;+ var nextSort;+ var columns = settings.aoColumns;+ var aSort = _fnSortFlatten( settings );+ var oAria = settings.oLanguage.oAria;++ // ARIA attributes - need to loop all columns, to update all (removing old+ // attributes as needed)+ for ( var i=0, iLen=columns.length ; i<iLen ; i++ )+ {+ var col = columns[i];+ var asSorting = col.asSorting;+ var sTitle = col.sTitle.replace( /<.*?>/g, "" );+ var th = col.nTh;++ // IE7 is throwing an error when setting these properties with jQuery's+ // attr() and removeAttr() methods...+ th.removeAttribute('aria-sort');++ /* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */+ if ( col.bSortable ) {+ if ( aSort.length > 0 && aSort[0].col == i ) {+ th.setAttribute('aria-sort', aSort[0].dir=="asc" ? "ascending" : "descending" );+ nextSort = asSorting[ aSort[0].index+1 ] || asSorting[0];+ }+ else {+ nextSort = asSorting[0];+ }++ label = sTitle + ( nextSort === "asc" ?+ oAria.sSortAscending :+ oAria.sSortDescending+ );+ }+ else {+ label = sTitle;+ }++ th.setAttribute('aria-label', label);+ }+ }+++ /**+ * Function to run on user sort request+ * @param {object} settings dataTables settings object+ * @param {node} attachTo node to attach the handler to+ * @param {int} colIdx column sorting index+ * @param {boolean} [append=false] Append the requested sort to the existing+ * sort if true (i.e. multi-column sort)+ * @param {function} [callback] callback function+ * @memberof DataTable#oApi+ */+ function _fnSortListener ( settings, colIdx, append, callback )+ {+ var col = settings.aoColumns[ colIdx ];+ var sorting = settings.aaSorting;+ var asSorting = col.asSorting;+ var nextSortIdx;+ var next = function ( a ) {+ var idx = a._idx;+ if ( idx === undefined ) {+ idx = $.inArray( a[1], asSorting );+ }++ return idx+1 >= asSorting.length ? 0 : idx+1;+ };++ // Convert to 2D array if needed+ if ( typeof sorting[0] === 'number' ) {+ sorting = settings.aaSorting = [ sorting ];+ }++ // If appending the sort then we are multi-column sorting+ if ( append && settings.oFeatures.bSortMulti ) {+ // Are we already doing some kind of sort on this column?+ var sortIdx = $.inArray( colIdx, _pluck(sorting, '0') );++ if ( sortIdx !== -1 ) {+ // Yes, modify the sort+ nextSortIdx = next( sorting[sortIdx] );++ sorting[sortIdx][1] = asSorting[ nextSortIdx ];+ sorting[sortIdx]._idx = nextSortIdx;+ }+ else {+ // No sort on this column yet+ sorting.push( [ colIdx, asSorting[0], 0 ] );+ sorting[sorting.length-1]._idx = 0;+ }+ }+ else if ( sorting.length && sorting[0][0] == colIdx ) {+ // Single column - already sorting on this column, modify the sort+ nextSortIdx = next( sorting[0] );++ sorting.length = 1;+ sorting[0][1] = asSorting[ nextSortIdx ];+ sorting[0]._idx = nextSortIdx;+ }+ else {+ // Single column - sort only on this column+ sorting.length = 0;+ sorting.push( [ colIdx, asSorting[0] ] );+ sorting[0]._idx = 0;+ }++ // Run the sort by calling a full redraw+ _fnReDraw( settings );++ // callback used for async user interaction+ if ( typeof callback == 'function' ) {+ callback( settings );+ }+ }+++ /**+ * Attach a sort handler (click) to a node+ * @param {object} settings dataTables settings object+ * @param {node} attachTo node to attach the handler to+ * @param {int} colIdx column sorting index+ * @param {function} [callback] callback function+ * @memberof DataTable#oApi+ */+ function _fnSortAttachListener ( settings, attachTo, colIdx, callback )+ {+ var col = settings.aoColumns[ colIdx ];++ _fnBindAction( attachTo, {}, function (e) {+ /* If the column is not sortable - don't to anything */+ if ( col.bSortable === false ) {+ return;+ }++ // If processing is enabled use a timeout to allow the processing+ // display to be shown - otherwise to it synchronously+ if ( settings.oFeatures.bProcessing ) {+ _fnProcessingDisplay( settings, true );++ setTimeout( function() {+ _fnSortListener( settings, colIdx, e.shiftKey, callback );++ // In server-side processing, the draw callback will remove the+ // processing display+ if ( _fnDataSource( settings ) !== 'ssp' ) {+ _fnProcessingDisplay( settings, false );+ }+ }, 0 );+ }+ else {+ _fnSortListener( settings, colIdx, e.shiftKey, callback );+ }+ } );+ }+++ /**+ * Set the sorting classes on table's body, Note: it is safe to call this function+ * when bSort and bSortClasses are false+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnSortingClasses( settings )+ {+ var oldSort = settings.aLastSort;+ var sortClass = settings.oClasses.sSortColumn;+ var sort = _fnSortFlatten( settings );+ var features = settings.oFeatures;+ var i, ien, colIdx;++ if ( features.bSort && features.bSortClasses ) {+ // Remove old sorting classes+ for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {+ colIdx = oldSort[i].src;++ // Remove column sorting+ $( _pluck( settings.aoData, 'anCells', colIdx ) )+ .removeClass( sortClass + (i<2 ? i+1 : 3) );+ }++ // Add new column sorting+ for ( i=0, ien=sort.length ; i<ien ; i++ ) {+ colIdx = sort[i].src;++ $( _pluck( settings.aoData, 'anCells', colIdx ) )+ .addClass( sortClass + (i<2 ? i+1 : 3) );+ }+ }++ settings.aLastSort = sort;+ }+++ // Get the data to sort a column, be it from cache, fresh (populating the+ // cache), or from a sort formatter+ function _fnSortData( settings, idx )+ {+ // Custom sorting function - provided by the sort data type+ var column = settings.aoColumns[ idx ];+ var customSort = DataTable.ext.order[ column.sSortDataType ];+ var customData;++ if ( customSort ) {+ customData = customSort.call( settings.oInstance, settings, idx,+ _fnColumnIndexToVisible( settings, idx )+ );+ }++ // Use / populate cache+ var row, cellData;+ var formatter = DataTable.ext.type.order[ column.sType+"-pre" ];++ for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {+ row = settings.aoData[i];++ if ( ! row._aSortData ) {+ row._aSortData = [];+ }++ if ( ! row._aSortData[idx] || customSort ) {+ cellData = customSort ?+ customData[i] : // If there was a custom sort function, use data from there+ _fnGetCellData( settings, i, idx, 'sort' );++ row._aSortData[ idx ] = formatter ?+ formatter( cellData ) :+ cellData;+ }+ }+ }++++ /**+ * Save the state of a table+ * @param {object} oSettings dataTables settings object+ * @memberof DataTable#oApi+ */+ function _fnSaveState ( settings )+ {+ if ( !settings.oFeatures.bStateSave || settings.bDestroying )+ {+ return;+ }++ /* Store the interesting variables */+ var state = {+ time: +new Date(),+ start: settings._iDisplayStart,+ length: settings._iDisplayLength,+ order: $.extend( true, [], settings.aaSorting ),+ search: _fnSearchToCamel( settings.oPreviousSearch ),+ columns: $.map( settings.aoColumns, function ( col, i ) {+ return {+ visible: col.bVisible,+ search: _fnSearchToCamel( settings.aoPreSearchCols[i] )+ };+ } )+ };++ _fnCallbackFire( settings, "aoStateSaveParams", 'stateSaveParams', [settings, state] );++ settings.oSavedState = state;+ settings.fnStateSaveCallback.call( settings.oInstance, settings, state );+ }+++ /**+ * Attempt to load a saved table state+ * @param {object} oSettings dataTables settings object+ * @param {object} oInit DataTables init object so we can override settings+ * @memberof DataTable#oApi+ */+ function _fnLoadState ( settings, oInit )+ {+ var i, ien;+ var columns = settings.aoColumns;++ if ( ! settings.oFeatures.bStateSave ) {+ return;+ }++ var state = settings.fnStateLoadCallback.call( settings.oInstance, settings );+ if ( ! state || ! state.time ) {+ return;+ }++ /* Allow custom and plug-in manipulation functions to alter the saved data set and+ * cancelling of loading by returning false+ */+ var abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, state] );+ if ( $.inArray( false, abStateLoad ) !== -1 ) {+ return;+ }++ /* Reject old data */+ var duration = settings.iStateDuration;+ if ( duration > 0 && state.time < +new Date() - (duration*1000) ) {+ return;+ }++ // Number of columns have changed - all bets are off, no restore of settings+ if ( columns.length !== state.columns.length ) {+ return;+ }++ // Store the saved state so it might be accessed at any time+ settings.oLoadedState = $.extend( true, {}, state );++ // Restore key features - todo - for 1.11 this needs to be done by+ // subscribed events+ settings._iDisplayStart = state.start;+ settings.iInitDisplayStart = state.start;+ settings._iDisplayLength = state.length;+ settings.aaSorting = [];++ // Order+ $.each( state.order, function ( i, col ) {+ settings.aaSorting.push( col[0] >= columns.length ?+ [ 0, col[1] ] :+ col+ );+ } );++ // Search+ $.extend( settings.oPreviousSearch, _fnSearchToHung( state.search ) );++ // Columns+ for ( i=0, ien=state.columns.length ; i<ien ; i++ ) {+ var col = state.columns[i];++ // Visibility+ columns[i].bVisible = col.visible;++ // Search+ $.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );+ }++ _fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, state] );+ }+++ /**+ * Return the settings object for a particular table+ * @param {node} table table we are using as a dataTable+ * @returns {object} Settings object - or null if not found+ * @memberof DataTable#oApi+ */+ function _fnSettingsFromNode ( table )+ {+ var settings = DataTable.settings;+ var idx = $.inArray( table, _pluck( settings, 'nTable' ) );++ return idx !== -1 ?+ settings[ idx ] :+ null;+ }+++ /**+ * Log an error message+ * @param {object} settings dataTables settings object+ * @param {int} level log error messages, or display them to the user+ * @param {string} msg error message+ * @param {int} tn Technical note id to get more information about the error.+ * @memberof DataTable#oApi+ */+ function _fnLog( settings, level, msg, tn )+ {+ msg = 'DataTables warning: '++ (settings!==null ? 'table id='+settings.sTableId+' - ' : '')+msg;++ if ( tn ) {+ msg += '. For more information about this error, please see '++ 'http://datatables.net/tn/'+tn;+ }++ if ( ! level ) {+ // Backwards compatibility pre 1.10+ var ext = DataTable.ext;+ var type = ext.sErrMode || ext.errMode;++ if ( type == 'alert' ) {+ alert( msg );+ }+ else {+ throw new Error(msg);+ }+ }+ else if ( window.console && console.log ) {+ console.log( msg );+ }+ }+++ /**+ * See if a property is defined on one object, if so assign it to the other object+ * @param {object} ret target object+ * @param {object} src source object+ * @param {string} name property+ * @param {string} [mappedName] name to map too - optional, name used if not given+ * @memberof DataTable#oApi+ */+ function _fnMap( ret, src, name, mappedName )+ {+ if ( $.isArray( name ) ) {+ $.each( name, function (i, val) {+ if ( $.isArray( val ) ) {+ _fnMap( ret, src, val[0], val[1] );+ }+ else {+ _fnMap( ret, src, val );+ }+ } );++ return;+ }++ if ( mappedName === undefined ) {+ mappedName = name;+ }++ if ( src[name] !== undefined ) {+ ret[mappedName] = src[name];+ }+ }+++ /**+ * 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.+ * @param {object} out Object to extend+ * @param {object} extender Object from which the properties will be applied to+ * out+ * @param {boolean} breakRefs If true, then arrays will be sliced to take an+ * independent copy with the exception of the `data` or `aaData` parameters+ * if they are present. This is so you can pass in a collection to+ * DataTables and have that used as your data source without breaking the+ * references+ * @returns {object} out Reference, just for convenience - out === the return.+ * @memberof DataTable#oApi+ * @todo This doesn't take account of arrays inside the deep copied objects.+ */+ function _fnExtend( out, extender, breakRefs )+ {+ var val;++ for ( var prop in extender ) {+ if ( extender.hasOwnProperty(prop) ) {+ val = extender[prop];++ if ( $.isPlainObject( val ) ) {+ if ( ! $.isPlainObject( out[prop] ) ) {+ out[prop] = {};+ }+ $.extend( true, out[prop], val );+ }+ else if ( breakRefs && prop !== 'data' && prop !== 'aaData' && $.isArray(val) ) {+ out[prop] = val.slice();+ }+ else {+ out[prop] = val;+ }+ }+ }++ return out;+ }+++ /**+ * Bind an event handers to allow a click or return key to activate the callback.+ * This is good for accessibility since a return on the keyboard will have the+ * same effect as a click, if the element has focus.+ * @param {element} n Element to bind the action to+ * @param {object} oData Data object to pass to the triggered function+ * @param {function} fn Callback function for when the event is triggered+ * @memberof DataTable#oApi+ */+ function _fnBindAction( n, oData, fn )+ {+ $(n)+ .bind( 'click.DT', oData, function (e) {+ n.blur(); // Remove focus outline for mouse users+ fn(e);+ } )+ .bind( 'keypress.DT', oData, function (e){+ if ( e.which === 13 ) {+ e.preventDefault();+ fn(e);+ }+ } )+ .bind( 'selectstart.DT', function () {+ /* Take the brutal approach to cancelling text selection */+ return false;+ } );+ }+++ /**+ * 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.+ * @param {object} oSettings dataTables settings object+ * @param {string} sStore Name of the array storage for the callbacks in oSettings+ * @param {function} fn Function to be called back+ * @param {string} sName Identifying name for the callback (i.e. a label)+ * @memberof DataTable#oApi+ */+ function _fnCallbackReg( oSettings, sStore, fn, sName )+ {+ if ( fn )+ {+ oSettings[sStore].push( {+ "fn": fn,+ "sName": sName+ } );+ }+ }+++ /**+ * 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.+ * @param {object} settings dataTables settings object+ * @param {string} callbackArr Name of the array storage for the callbacks in+ * oSettings+ * @param {string} event Name of the jQuery custom event to trigger. If null no+ * trigger is fired+ * @param {array} args Array of arguments to pass to the callback function /+ * trigger+ * @memberof DataTable#oApi+ */+ function _fnCallbackFire( settings, callbackArr, e, args )+ {+ var ret = [];++ if ( callbackArr ) {+ ret = $.map( settings[callbackArr].slice().reverse(), function (val, i) {+ return val.fn.apply( settings.oInstance, args );+ } );+ }++ if ( e !== null ) {+ $(settings.nTable).trigger( e+'.dt', args );+ }++ return ret;+ }+++ function _fnLengthOverflow ( settings )+ {+ var+ start = settings._iDisplayStart,+ end = settings.fnDisplayEnd(),+ len = settings._iDisplayLength;++ /* If we have space to show extra rows (backing up from the end point - then do so */+ if ( end === settings.fnRecordsDisplay() )+ {+ start = end - len;+ }++ if ( len === -1 || start < 0 )+ {+ start = 0;+ }++ settings._iDisplayStart = start;+ }+++ function _fnRenderer( settings, type )+ {+ var renderer = settings.renderer;+ var host = DataTable.ext.renderer[type];++ if ( $.isPlainObject( renderer ) && renderer[type] ) {+ // Specific renderer for this type. If available use it, otherwise use+ // the default.+ return host[renderer[type]] || host._;+ }+ else if ( typeof renderer === 'string' ) {+ // Common renderer - if there is one available for this type use it,+ // otherwise use the default+ return host[renderer] || host._;+ }++ // Use the default+ return host._;+ }+++ /**+ * Detect the data source being used for the table. Used to simplify the code+ * a little (ajax) and to make it compress a little smaller.+ *+ * @param {object} settings dataTables settings object+ * @returns {string} Data source+ * @memberof DataTable#oApi+ */+ function _fnDataSource ( settings )+ {+ if ( settings.oFeatures.bServerSide ) {+ return 'ssp';+ }+ else if ( settings.ajax || settings.sAjaxSource ) {+ return 'ajax';+ }+ return 'dom';+ }+++ DataTable = function( options )+ {+ /**+ * Perform a jQuery selector action on the table's TR elements (from the tbody) and+ * return the resulting jQuery object.+ * @param {string|node|jQuery} sSelector jQuery selector or node collection to act on+ * @param {object} [oOpts] Optional parameters for modifying the rows to be included+ * @param {string} [oOpts.filter=none] Select TR elements that meet the current filter+ * criterion ("applied") or all TR elements (i.e. no filter).+ * @param {string} [oOpts.order=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.+ * @param {string} [oOpts.page=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 {object} jQuery object, filtered by the given selector.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Highlight every second row+ * oTable.$('tr:odd').css('backgroundColor', 'blue');+ * } );+ *+ * @example+ * $(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', {"search": "applied"}).css('backgroundColor', 'blue');+ * oTable.fnFilter('');+ * } );+ */+ this.$ = function ( sSelector, oOpts )+ {+ return this.api(true).$( sSelector, oOpts );+ };+++ /**+ * 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 descendants, 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 in-combination with $ where both functions are given the+ * same parameters and the array indexes will match identically.+ * @param {string|node|jQuery} sSelector jQuery selector or node collection to act on+ * @param {object} [oOpts] Optional parameters for modifying the rows to be included+ * @param {string} [oOpts.filter=none] Select elements that meet the current filter+ * criterion ("applied") or all elements (i.e. no filter).+ * @param {string} [oOpts.order=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.+ * @param {string} [oOpts.page=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 {array} 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.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(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] );+ * } );+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Filter to 'Webkit' and get all data for+ * oTable.fnFilter('Webkit');+ * var data = oTable._('tr', {"search": "applied"});+ *+ * // Do something with the data+ * alert( data.length+" rows matched the search" );+ * } );+ */+ this._ = function ( sSelector, oOpts )+ {+ return this.api(true).rows( sSelector, oOpts ).data();+ };+++ /**+ * Create a DataTables Api instance, with the currently selected tables for+ * the Api's context.+ * @param {boolean} [traditional=false] Set the API instance's context to be+ * only the table referred to by the `DataTable.ext.iApiIndex` option, as was+ * used in the API presented by DataTables 1.9- (i.e. the traditional mode),+ * or if all tables captured in the jQuery object should be used.+ * @return {DataTables.Api}+ */+ this.api = function ( traditional )+ {+ return traditional ?+ new _Api(+ _fnSettingsFromNode( this[ _ext.iApiIndex ] )+ ) :+ new _Api( this );+ };+++ /**+ * 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.+ * @param {array|object} data The data to be added to the table. This can be:+ * <ul>+ * <li>1D array of data - add a single row with the data provided</li>+ * <li>2D array of arrays - add multiple rows in a single call</li>+ * <li>object - data object when using <i>mData</i></li>+ * <li>array of objects - multiple data objects when using <i>mData</i></li>+ * </ul>+ * @param {bool} [redraw=true] redraw the table or not+ * @returns {array} An array of integers, representing the list of indexes in+ * <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to+ * the table.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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++;+ * }+ */+ this.fnAddData = function( data, redraw )+ {+ var api = this.api( true );++ /* Check if we want to add multiple rows or not */+ var rows = $.isArray(data) && ( $.isArray(data[0]) || $.isPlainObject(data[0]) ) ?+ api.rows.add( data ) :+ api.row.add( data );++ if ( redraw === undefined || redraw ) {+ api.draw();+ }++ return rows.flatten().toArray();+ };+++ /**+ * 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).+ * @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable( {+ * "sScrollY": "200px",+ * "bPaginate": false+ * } );+ *+ * $(window).bind('resize', function () {+ * oTable.fnAdjustColumnSizing();+ * } );+ * } );+ */+ this.fnAdjustColumnSizing = function ( bRedraw )+ {+ var api = this.api( true ).columns.adjust();+ var settings = api.settings()[0];+ var scroll = settings.oScroll;++ if ( bRedraw === undefined || bRedraw ) {+ api.draw( false );+ }+ else if ( scroll.sX !== "" || scroll.sY !== "" ) {+ /* If not redrawing, but scrolling, we want to apply the new column sizes anyway */+ _fnScrollDraw( settings );+ }+ };+++ /**+ * Quickly and simply clear a table+ * @param {bool} [bRedraw=true] redraw the table or not+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)+ * oTable.fnClearTable();+ * } );+ */+ this.fnClearTable = function( bRedraw )+ {+ var api = this.api( true ).clear();++ if ( bRedraw === undefined || bRedraw ) {+ api.draw();+ }+ };+++ /**+ * The exact opposite of 'opening' a row, this function will close any rows which+ * are currently 'open'.+ * @param {node} nTr the table row to 'close'+ * @returns {int} 0 on success, or 1 if failed (can't find the row)+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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();+ * } );+ */+ this.fnClose = function( nTr )+ {+ this.api( true ).row( nTr ).child.hide();+ };+++ /**+ * Remove a row for the table+ * @param {mixed} target The index of the row from aoData to be deleted, or+ * the TR element you want to delete+ * @param {function|null} [callBack] Callback function+ * @param {bool} [redraw=true] Redraw the table or not+ * @returns {array} The row that was deleted+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Immediately remove the first row+ * oTable.fnDeleteRow( 0 );+ * } );+ */+ this.fnDeleteRow = function( target, callback, redraw )+ {+ var api = this.api( true );+ var rows = api.rows( target );+ var settings = rows.settings()[0];+ var data = settings.aoData[ rows[0][0] ];++ rows.remove();++ if ( callback ) {+ callback.call( this, settings, data );+ }++ if ( redraw === undefined || redraw ) {+ api.draw();+ }++ return data;+ };+++ /**+ * 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.+ * @param {boolean} [remove=false] Completely remove the table from the DOM+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * // This example is fairly pointless in reality, but shows how fnDestroy can be used+ * var oTable = $('#example').dataTable();+ * oTable.fnDestroy();+ * } );+ */+ this.fnDestroy = function ( remove )+ {+ this.api( true ).destroy( remove );+ };+++ /**+ * Redraw the table+ * @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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();+ * } );+ */+ this.fnDraw = function( complete )+ {+ // Note that this isn't an exact match to the old call to _fnDraw - it takes+ // into account the new data, but can old position.+ this.api( true ).draw( ! complete );+ };+++ /**+ * Filter the input based on data+ * @param {string} sInput String to filter the table on+ * @param {int|null} [iColumn] Column to limit filtering to+ * @param {bool} [bRegex=false] Treat as regular expression or not+ * @param {bool} [bSmart=true] Perform smart filtering or not+ * @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)+ * @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Sometime later - filter...+ * oTable.fnFilter( 'test string' );+ * } );+ */+ this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )+ {+ var api = this.api( true );++ if ( iColumn === null || iColumn === undefined ) {+ api.search( sInput, bRegex, bSmart, bCaseInsensitive );+ }+ else {+ api.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );+ }++ api.draw();+ };+++ /**+ * Get the data for the whole table, an individual row or an individual cell based on the+ * provided parameters.+ * @param {int|node} [src] 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.+ * @param {int} [col] Optional column index that you want the data of.+ * @returns {array|object|string} 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.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * // 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+ * } );+ * } );+ *+ * @example+ * // 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 );+ * } );+ * } );+ */+ this.fnGetData = function( src, col )+ {+ var api = this.api( true );++ if ( src !== undefined ) {+ var type = src.nodeName ? src.nodeName.toLowerCase() : '';++ return col !== undefined || type == 'td' || type == 'th' ?+ api.cell( src, col ).data() :+ api.row( src ).data() || null;+ }++ return api.data().toArray();+ };+++ /**+ * 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.+ * @param {int} [iRow] Optional row index for the TR element you want+ * @returns {array|node} 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.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Get the nodes from the table+ * var nNodes = oTable.fnGetNodes( );+ * } );+ */+ this.fnGetNodes = function( iRow )+ {+ var api = this.api( true );++ return iRow !== undefined ?+ api.row( iRow ).node() :+ api.rows().nodes().flatten().toArray();+ };+++ /**+ * Get the array indexes of a particular cell from it's DOM element+ * and column index including hidden columns+ * @param {node} node this can either be a TR, TD or TH in the table's body+ * @returns {int} 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),+ * column index (all)] is given.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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();+ * } );+ */+ this.fnGetPosition = function( node )+ {+ var api = this.api( true );+ var nodeName = node.nodeName.toUpperCase();++ if ( nodeName == 'TR' ) {+ return api.row( node ).index();+ }+ else if ( nodeName == 'TD' || nodeName == 'TH' ) {+ var cell = api.cell( node ).index();++ return [+ cell.row,+ cell.columnVisible,+ cell.column+ ];+ }+ return null;+ };+++ /**+ * Check to see if a row is 'open' or not.+ * @param {node} nTr the table row to check+ * @returns {boolean} true if the row is currently open, false otherwise+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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();+ * } );+ */+ this.fnIsOpen = function( nTr )+ {+ return this.api( true ).row( nTr ).child.isShown();+ };+++ /**+ * 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.+ * @param {node} nTr The table row to 'open'+ * @param {string|node|jQuery} mHtml The HTML to put into the row+ * @param {string} sClass Class to give the new TD cell+ * @returns {node} 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.+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @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();+ * } );+ */+ this.fnOpen = function( nTr, mHtml, sClass )+ {+ return this.api( true )+ .row( nTr )+ .child( mHtml, sClass )+ .show()+ .child()[0];+ };+++ /**+ * 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.+ * @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"+ * or page number to jump to (integer), note that page 0 is the first page.+ * @param {bool} [bRedraw=true] Redraw the table or not+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ * oTable.fnPageChange( 'next' );+ * } );+ */+ this.fnPageChange = function ( mAction, bRedraw )+ {+ var api = this.api( true ).page( mAction );++ if ( bRedraw === undefined || bRedraw ) {+ api.draw(false);+ }+ };+++ /**+ * Show a particular column+ * @param {int} iCol The column whose display should be changed+ * @param {bool} bShow Show (true) or hide (false) the column+ * @param {bool} [bRedraw=true] Redraw the table or not+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Hide the second column after initialisation+ * oTable.fnSetColumnVis( 1, false );+ * } );+ */+ this.fnSetColumnVis = function ( iCol, bShow, bRedraw )+ {+ var api = this.api( true ).column( iCol ).visible( bShow );++ if ( bRedraw === undefined || bRedraw ) {+ api.columns.adjust().draw();+ }+ };+++ /**+ * Get the settings for a particular table for external manipulation+ * @returns {object} DataTables settings object. See+ * {@link DataTable.models.oSettings}+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ * var oSettings = oTable.fnSettings();+ *+ * // Show an example parameter from the settings+ * alert( oSettings._iDisplayStart );+ * } );+ */+ this.fnSettings = function()+ {+ return _fnSettingsFromNode( this[_ext.iApiIndex] );+ };+++ /**+ * Sort the table by a particular column+ * @param {int} iCol the data index to sort on. Note that this will not match the+ * 'display index' if you have hidden data entries+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Sort immediately with columns 0 and 1+ * oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );+ * } );+ */+ this.fnSort = function( aaSort )+ {+ this.api( true ).order( aaSort ).draw();+ };+++ /**+ * Attach a sort listener to an element for a given column+ * @param {node} nNode the element to attach the sort listener to+ * @param {int} iColumn the column that a click on this node will sort on+ * @param {function} [fnCallback] callback function when sort is run+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ *+ * // Sort on column 1, when 'sorter' is clicked on+ * oTable.fnSortListener( document.getElementById('sorter'), 1 );+ * } );+ */+ this.fnSortListener = function( nNode, iColumn, fnCallback )+ {+ this.api( true ).order.listener( nNode, iColumn, fnCallback );+ };+++ /**+ * 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.+ * @param {object|array|string} mData Data to update the cell/row with+ * @param {node|int} mRow TR element you want to update or the aoData index+ * @param {int} [iColumn] The column to update, give as null or undefined to+ * update a whole row.+ * @param {bool} [bRedraw=true] Redraw the table or not+ * @param {bool} [bAction=true] Perform pre-draw actions or not+ * @returns {int} 0 on success, 1 on error+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ * oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell+ * oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row+ * } );+ */+ this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )+ {+ var api = this.api( true );++ if ( iColumn === undefined || iColumn === null ) {+ api.row( mRow ).data( mData );+ }+ else {+ api.cell( mRow, iColumn ).data( mData );+ }++ if ( bAction === undefined || bAction ) {+ api.columns.adjust();+ }++ if ( bRedraw === undefined || bRedraw ) {+ api.draw();+ }+ return 0;+ };+++ /**+ * Provide a common method for plug-ins to check the version of DataTables being used, in order+ * to ensure compatibility.+ * @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the+ * formats "X" and "X.Y" are also acceptable.+ * @returns {boolean} true if this version of DataTables is greater or equal to the required+ * version, or false if this version of DataTales is not suitable+ * @method+ * @dtopt API+ * @deprecated Since v1.10+ *+ * @example+ * $(document).ready(function() {+ * var oTable = $('#example').dataTable();+ * alert( oTable.fnVersionCheck( '1.9.0' ) );+ * } );+ */+ this.fnVersionCheck = _ext.fnVersionCheck;+++ var _that = this;+ var emptyInit = options === undefined;+ var len = this.length;++ if ( emptyInit ) {+ options = {};+ }++ this.oApi = this.internal = _ext.internal;++ // Extend with old style plug-in API methods+ for ( var fn in DataTable.ext.internal ) {+ if ( fn ) {+ this[fn] = _fnExternApiFunc(fn);+ }+ }++ this.each(function() {+ // For each initialisation we want to give it a clean initialisation+ // object that can be bashed around+ var o = {};+ var oInit = len > 1 ? // optimisation for single table case+ _fnExtend( o, options, true ) :+ options;++ /*global oInit,_that,emptyInit*/+ var i=0, iLen, j, jLen, k, kLen;+ var sId = this.getAttribute( 'id' );+ var bInitHandedOff = false;+ var defaults = DataTable.defaults;+++ /* Sanity check */+ if ( this.nodeName.toLowerCase() != 'table' )+ {+ _fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );+ return;+ }++ /* Backwards compatibility for the defaults */+ _fnCompatOpts( defaults );+ _fnCompatCols( defaults.column );++ /* Convert the camel-case defaults to Hungarian */+ _fnCamelToHungarian( defaults, defaults, true );+ _fnCamelToHungarian( defaults.column, defaults.column, true );++ /* Setting up the initialisation object */+ _fnCamelToHungarian( defaults, oInit );++ /* Check to see if we are re-initialising a table */+ var allSettings = DataTable.settings;+ for ( i=0, iLen=allSettings.length ; i<iLen ; i++ )+ {+ /* Base check on table node */+ if ( allSettings[i].nTable == this )+ {+ var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;+ var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;++ if ( emptyInit || bRetrieve )+ {+ return allSettings[i].oInstance;+ }+ else if ( bDestroy )+ {+ allSettings[i].oInstance.fnDestroy();+ break;+ }+ else+ {+ _fnLog( allSettings[i], 0, 'Cannot reinitialise DataTable', 3 );+ return;+ }+ }++ /* If the element we are initialising has the same ID as a table which was previously+ * initialised, but the table nodes don't match (from before) then we destroy the old+ * instance by simply deleting it. This is under the assumption that the table has been+ * destroyed by other methods. Anyone using non-id selectors will need to do this manually+ */+ if ( allSettings[i].sTableId == this.id )+ {+ allSettings.splice( i, 1 );+ break;+ }+ }++ /* Ensure the table has an ID - required for accessibility */+ if ( sId === null || sId === "" )+ {+ sId = "DataTables_Table_"+(DataTable.ext._unique++);+ this.id = sId;+ }++ /* Create the settings object for this table and set some of the default parameters */+ var oSettings = $.extend( true, {}, DataTable.models.oSettings, {+ "nTable": this,+ "oApi": _that.internal,+ "oInit": oInit,+ "sDestroyWidth": $(this)[0].style.width,+ "sInstance": sId,+ "sTableId": sId+ } );+ allSettings.push( oSettings );++ // Need to add the instance after the instance after the settings object has been added+ // to the settings array, so we can self reference the table instance if more than one+ oSettings.oInstance = (_that.length===1) ? _that : $(this).dataTable();++ // Backwards compatibility, before we apply all the defaults+ _fnCompatOpts( oInit );++ if ( oInit.oLanguage )+ {+ _fnLanguageCompat( oInit.oLanguage );+ }++ // If the length menu is given, but the init display length is not, use the length menu+ if ( oInit.aLengthMenu && ! oInit.iDisplayLength )+ {+ oInit.iDisplayLength = $.isArray( oInit.aLengthMenu[0] ) ?+ oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];+ }++ // Apply the defaults and init options to make a single init object will all+ // options defined from defaults and instance options.+ oInit = _fnExtend( $.extend( true, {}, defaults ), oInit );+++ // Map the initialisation options onto the settings object+ _fnMap( oSettings.oFeatures, oInit, [+ "bPaginate",+ "bLengthChange",+ "bFilter",+ "bSort",+ "bSortMulti",+ "bInfo",+ "bProcessing",+ "bAutoWidth",+ "bSortClasses",+ "bServerSide",+ "bDeferRender"+ ] );+ _fnMap( oSettings, oInit, [+ "asStripeClasses",+ "ajax",+ "fnServerData",+ "fnFormatNumber",+ "sServerMethod",+ "aaSorting",+ "aaSortingFixed",+ "aLengthMenu",+ "sPaginationType",+ "sAjaxSource",+ "sAjaxDataProp",+ "iStateDuration",+ "sDom",+ "bSortCellsTop",+ "iTabIndex",+ "fnStateLoadCallback",+ "fnStateSaveCallback",+ "renderer",+ [ "iCookieDuration", "iStateDuration" ], // backwards compat+ [ "oSearch", "oPreviousSearch" ],+ [ "aoSearchCols", "aoPreSearchCols" ],+ [ "iDisplayLength", "_iDisplayLength" ],+ [ "bJQueryUI", "bJUI" ]+ ] );+ _fnMap( oSettings.oScroll, oInit, [+ [ "sScrollX", "sX" ],+ [ "sScrollXInner", "sXInner" ],+ [ "sScrollY", "sY" ],+ [ "bScrollCollapse", "bCollapse" ]+ ] );+ _fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );++ /* Callback functions which are array driven */+ _fnCallbackReg( oSettings, 'aoDrawCallback', oInit.fnDrawCallback, 'user' );+ _fnCallbackReg( oSettings, 'aoServerParams', oInit.fnServerParams, 'user' );+ _fnCallbackReg( oSettings, 'aoStateSaveParams', oInit.fnStateSaveParams, 'user' );+ _fnCallbackReg( oSettings, 'aoStateLoadParams', oInit.fnStateLoadParams, 'user' );+ _fnCallbackReg( oSettings, 'aoStateLoaded', oInit.fnStateLoaded, 'user' );+ _fnCallbackReg( oSettings, 'aoRowCallback', oInit.fnRowCallback, 'user' );+ _fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow, 'user' );+ _fnCallbackReg( oSettings, 'aoHeaderCallback', oInit.fnHeaderCallback, 'user' );+ _fnCallbackReg( oSettings, 'aoFooterCallback', oInit.fnFooterCallback, 'user' );+ _fnCallbackReg( oSettings, 'aoInitComplete', oInit.fnInitComplete, 'user' );+ _fnCallbackReg( oSettings, 'aoPreDrawCallback', oInit.fnPreDrawCallback, 'user' );++ var oClasses = oSettings.oClasses;++ // @todo Remove in 1.11+ if ( oInit.bJQueryUI )+ {+ /* Use the JUI classes object for display. You could clone the oStdClasses object if+ * you want to have multiple tables with multiple independent classes+ */+ $.extend( oClasses, DataTable.ext.oJUIClasses, oInit.oClasses );++ if ( oInit.sDom === defaults.sDom && defaults.sDom === "lfrtip" )+ {+ /* Set the DOM to use a layout suitable for jQuery UI's theming */+ oSettings.sDom = '<"H"lfr>t<"F"ip>';+ }++ if ( ! oSettings.renderer ) {+ oSettings.renderer = 'jqueryui';+ }+ else if ( $.isPlainObject( oSettings.renderer ) && ! oSettings.renderer.header ) {+ oSettings.renderer.header = 'jqueryui';+ }+ }+ else+ {+ $.extend( oClasses, DataTable.ext.classes, oInit.oClasses );+ }+ $(this).addClass( oClasses.sTable );++ /* Calculate the scroll bar width and cache it for use later on */+ if ( oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "" )+ {+ oSettings.oScroll.iBarWidth = _fnScrollBarWidth();+ }+ if ( oSettings.oScroll.sX === true ) { // Easy initialisation of x-scrolling+ oSettings.oScroll.sX = '100%';+ }++ if ( oSettings.iInitDisplayStart === undefined )+ {+ /* Display start point, taking into account the save saving */+ oSettings.iInitDisplayStart = oInit.iDisplayStart;+ oSettings._iDisplayStart = oInit.iDisplayStart;+ }++ if ( oInit.iDeferLoading !== null )+ {+ oSettings.bDeferLoading = true;+ var tmp = $.isArray( oInit.iDeferLoading );+ oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;+ oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;+ }++ /* Language definitions */+ if ( oInit.oLanguage.sUrl !== "" )+ {+ /* Get the language definitions from a file - because this Ajax call makes the language+ * get async to the remainder of this function we use bInitHandedOff to indicate that+ * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor+ */+ oSettings.oLanguage.sUrl = oInit.oLanguage.sUrl;+ $.getJSON( oSettings.oLanguage.sUrl, null, function( json ) {+ _fnLanguageCompat( json );+ _fnCamelToHungarian( defaults.oLanguage, json );+ $.extend( true, oSettings.oLanguage, oInit.oLanguage, json );+ _fnInitialise( oSettings );+ } );+ bInitHandedOff = true;+ }+ else+ {+ $.extend( true, oSettings.oLanguage, oInit.oLanguage );+ }+++ /*+ * Stripes+ */+ if ( oInit.asStripeClasses === null )+ {+ oSettings.asStripeClasses =[+ oClasses.sStripeOdd,+ oClasses.sStripeEven+ ];+ }++ /* Remove row stripe classes if they are already on the table row */+ var stripeClasses = oSettings.asStripeClasses;+ var rowOne = $('tbody tr:eq(0)', this);+ if ( $.inArray( true, $.map( stripeClasses, function(el, i) {+ return rowOne.hasClass(el);+ } ) ) !== -1 ) {+ $('tbody tr', this).removeClass( stripeClasses.join(' ') );+ oSettings.asDestroyStripes = stripeClasses.slice();+ }++ /*+ * Columns+ * See if we should load columns automatically or use defined ones+ */+ var anThs = [];+ var aoColumnsInit;+ var nThead = this.getElementsByTagName('thead');+ if ( nThead.length !== 0 )+ {+ _fnDetectHeader( oSettings.aoHeader, nThead[0] );+ anThs = _fnGetUniqueThs( oSettings );+ }++ /* If not given a column array, generate one with nulls */+ if ( oInit.aoColumns === null )+ {+ aoColumnsInit = [];+ for ( i=0, iLen=anThs.length ; i<iLen ; i++ )+ {+ aoColumnsInit.push( null );+ }+ }+ else+ {+ aoColumnsInit = oInit.aoColumns;+ }++ /* Add the columns */+ for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )+ {+ _fnAddColumn( oSettings, anThs ? anThs[i] : null );+ }++ /* Apply the column definitions */+ _fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {+ _fnColumnOptions( oSettings, iCol, oDef );+ } );++ /* HTML5 attribute detection - build an mData object automatically if the+ * attributes are found+ */+ if ( rowOne.length ) {+ var a = function ( cell, name ) {+ return cell.getAttribute( 'data-'+name ) ? name : null;+ };++ $.each( _fnGetRowElements( oSettings, rowOne[0] ).cells, function (i, cell) {+ var col = oSettings.aoColumns[i];++ if ( col.mData === i ) {+ var sort = a( cell, 'sort' ) || a( cell, 'order' );+ var filter = a( cell, 'filter' ) || a( cell, 'search' );++ if ( sort !== null || filter !== null ) {+ col.mData = {+ _: i+'.display',+ sort: sort !== null ? i+'.@data-'+sort : undefined,+ type: sort !== null ? i+'.@data-'+sort : undefined,+ filter: filter !== null ? i+'.@data-'+filter : undefined+ };++ _fnColumnOptions( oSettings, i );+ }+ }+ } );+ }++ var features = oSettings.oFeatures;++ /* Must be done after everything which can be overridden by the state saving! */+ if ( oInit.bStateSave )+ {+ features.bStateSave = true;+ _fnLoadState( oSettings, oInit );+ _fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );+ }+++ /*+ * Sorting+ * @todo For modularisation (1.11) this needs to do into a sort start up handler+ */++ // If aaSorting is not defined, then we use the first indicator in asSorting+ // in case that has been altered, so the default sort reflects that option+ if ( oInit.aaSorting === undefined )+ {+ var sorting = oSettings.aaSorting;+ for ( i=0, iLen=sorting.length ; i<iLen ; i++ )+ {+ sorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];+ }+ }++ /* Do a first pass on the sorting classes (allows any size changes to be taken into+ * account, and also will apply sorting disabled classes if disabled+ */+ _fnSortingClasses( oSettings );++ if ( features.bSort )+ {+ _fnCallbackReg( oSettings, 'aoDrawCallback', function () {+ if ( oSettings.bSorted ) {+ var aSort = _fnSortFlatten( oSettings );+ var sortedColumns = {};++ $.each( aSort, function (i, val) {+ sortedColumns[ val.src ] = val.dir;+ } );++ _fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );+ _fnSortAria( oSettings );+ }+ } );+ }++ _fnCallbackReg( oSettings, 'aoDrawCallback', function () {+ if ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {+ _fnSortingClasses( oSettings );+ }+ }, 'sc' );+++ /*+ * Final init+ * Cache the header, body and footer as required, creating them if needed+ */++ /* Browser support detection */+ _fnBrowserDetect( oSettings );++ // Work around for Webkit bug 83867 - store the caption-side before removing from doc+ var captions = $(this).children('caption').each( function () {+ this._captionSide = $(this).css('caption-side');+ } );++ var thead = $(this).children('thead');+ if ( thead.length === 0 )+ {+ thead = $('<thead/>').appendTo(this);+ }+ oSettings.nTHead = thead[0];++ var tbody = $(this).children('tbody');+ if ( tbody.length === 0 )+ {+ tbody = $('<tbody/>').appendTo(this);+ }+ oSettings.nTBody = tbody[0];++ var tfoot = $(this).children('tfoot');+ if ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "") )+ {+ // If we are a scrolling table, and no footer has been given, then we need to create+ // a tfoot element for the caption element to be appended to+ tfoot = $('<tfoot/>').appendTo(this);+ }++ if ( tfoot.length === 0 || tfoot.children().length === 0 ) {+ $(this).addClass( oClasses.sNoFooter );+ }+ else if ( tfoot.length > 0 ) {+ oSettings.nTFoot = tfoot[0];+ _fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );+ }++ /* Check if there is data passing into the constructor */+ if ( oInit.aaData )+ {+ for ( i=0 ; i<oInit.aaData.length ; i++ )+ {+ _fnAddData( oSettings, oInit.aaData[ i ] );+ }+ }+ else if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' )+ {+ /* Grab the data from the page - only do this when deferred loading or no Ajax+ * source since there is no point in reading the DOM data if we are then going+ * to replace it with Ajax data+ */+ _fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );+ }++ /* Copy the data index array */+ oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();++ /* Initialisation complete - table can be drawn */+ oSettings.bInitialised = true;++ /* Check if we need to initialise the table (it might not have been handed off to the+ * language processor)+ */+ if ( bInitHandedOff === false )+ {+ _fnInitialise( oSettings );+ }+ } );+ _that = null;+ return this;+ };++++ /**+ * Computed structure of the DataTables API, defined by the options passed to+ * `DataTable.Api.register()` when building the API.+ *+ * The structure is built in order to speed creation and extension of the Api+ * objects since the extensions are effectively pre-parsed.+ *+ * The array is an array of objects with the following structure, where this+ * base array represents the Api prototype base:+ *+ * [+ * {+ * name: 'data' -- string - Property name+ * val: function () {}, -- function - Api method (or undefined if just an object+ * methodExt: [ ... ], -- array - Array of Api object definitions to extend the method result+ * propExt: [ ... ] -- array - Array of Api object definitions to extend the property+ * },+ * {+ * name: 'row'+ * val: {},+ * methodExt: [ ... ],+ * propExt: [+ * {+ * name: 'data'+ * val: function () {},+ * methodExt: [ ... ],+ * propExt: [ ... ]+ * },+ * ...+ * ]+ * }+ * ]+ *+ * @type {Array}+ * @ignore+ */+ var __apiStruct = [];+++ /**+ * `Array.prototype` reference.+ *+ * @type object+ * @ignore+ */+ var __arrayProto = Array.prototype;+++ /**+ * Abstraction for `context` parameter of the `Api` constructor to allow it to+ * take several different forms for ease of use.+ *+ * Each of the input parameter types will be converted to a DataTables settings+ * object where possible.+ *+ * @param {string|node|jQuery|object} mixed DataTable identifier. Can be one+ * of:+ *+ * * `string` - jQuery selector. Any DataTables' matching the given selector+ * with be found and used.+ * * `node` - `TABLE` node which has already been formed into a DataTable.+ * * `jQuery` - A jQuery object of `TABLE` nodes.+ * * `object` - DataTables settings object+ * * `DataTables.Api` - API instance+ * @return {array|null} Matching DataTables settings objects. `null` or+ * `undefined` is returned if no matching DataTable is found.+ * @ignore+ */+ var _toSettings = function ( mixed )+ {+ var idx, jq;+ var settings = DataTable.settings;+ var tables = $.map( settings, function (el, i) {+ return el.nTable;+ } );++ if ( ! mixed ) {+ return [];+ }+ else if ( mixed.nTable && mixed.oApi ) {+ // DataTables settings object+ return [ mixed ];+ }+ else if ( mixed.nodeName && mixed.nodeName.toLowerCase() === 'table' ) {+ // Table node+ idx = $.inArray( mixed, tables );+ return idx !== -1 ? [ settings[idx] ] : null;+ }+ else if ( mixed && typeof mixed.settings === 'function' ) {+ return mixed.settings().toArray();+ }+ else if ( typeof mixed === 'string' ) {+ // jQuery selector+ jq = $(mixed);+ }+ else if ( mixed instanceof $ ) {+ // jQuery object (also DataTables instance)+ jq = mixed;+ }++ if ( jq ) {+ return jq.map( function(i) {+ idx = $.inArray( this, tables );+ return idx !== -1 ? settings[idx] : null;+ } ).toArray();+ }+ };+++ /**+ * DataTables API class - used to control and interface with one or more+ * DataTables enhanced tables.+ *+ * The API class is heavily based on jQuery, presenting a chainable interface+ * that you can use to interact with tables. Each instance of the API class has+ * a "context" - i.e. the tables that it will operate on. This could be a single+ * table, all tables on a page or a sub-set thereof.+ *+ * Additionally the API is designed to allow you to easily work with the data in+ * the tables, retrieving and manipulating it as required. This is done by+ * presenting the API class as an array like interface. The contents of the+ * array depend upon the actions requested by each method (for example+ * `rows().nodes()` will return an array of nodes, while `rows().data()` will+ * return an array of objects or arrays depending upon your table's+ * configuration). The API object has a number of array like methods (`push`,+ * `pop`, `reverse` etc) as well as additional helper methods (`each`, `pluck`,+ * `unique` etc) to assist your working with the data held in a table.+ *+ * Most methods (those which return an Api instance) are chainable, which means+ * the return from a method call also has all of the methods available that the+ * top level object had. For example, these two calls are equivalent:+ *+ * // Not chained+ * api.row.add( {...} );+ * api.draw();+ *+ * // Chained+ * api.row.add( {...} ).draw();+ *+ * @class DataTable.Api+ * @param {array|object|string|jQuery} context DataTable identifier. This is+ * used to define which DataTables enhanced tables this API will operate on.+ * Can be one of:+ *+ * * `string` - jQuery selector. Any DataTables' matching the given selector+ * with be found and used.+ * * `node` - `TABLE` node which has already been formed into a DataTable.+ * * `jQuery` - A jQuery object of `TABLE` nodes.+ * * `object` - DataTables settings object+ * @param {array} [data] Data to initialise the Api instance with.+ *+ * @example+ * // Direct initialisation during DataTables construction+ * var api = $('#example').DataTable();+ *+ * @example+ * // Initialisation using a DataTables jQuery object+ * var api = $('#example').dataTable().api();+ *+ * @example+ * // Initialisation as a constructor+ * var api = new $.fn.DataTable.Api( 'table.dataTable' );+ */+ _Api = function ( context, data )+ {+ if ( ! this instanceof _Api ) {+ throw 'DT API must be constructed as a new object';+ // or should it do the 'new' for the caller?+ // return new _Api.apply( this, arguments );+ }++ var settings = [];+ var ctxSettings = function ( o ) {+ var a = _toSettings( o );+ if ( a ) {+ settings.push.apply( settings, a );+ }+ };++ if ( $.isArray( context ) ) {+ for ( var i=0, ien=context.length ; i<ien ; i++ ) {+ ctxSettings( context[i] );+ }+ }+ else {+ ctxSettings( context );+ }++ // Remove duplicates+ this.context = _unique( settings );++ // Initial data+ if ( data ) {+ this.push.apply( this, data.toArray ? data.toArray() : data );+ }++ // selector+ this.selector = {+ rows: null,+ cols: null,+ opts: null+ };++ _Api.extend( this, this, __apiStruct );+ };++ DataTable.Api = _Api;++ _Api.prototype = /** @lends DataTables.Api */{+ /**+ * Return a new Api instance, comprised of the data held in the current+ * instance, join with the other array(s) and/or value(s).+ *+ * An alias for `Array.prototype.concat`.+ *+ * @type method+ * @param {*} value1 Arrays and/or values to concatenate.+ * @param {*} [...] Additional arrays and/or values to concatenate.+ * @returns {DataTables.Api} New API instance, comprising of the combined+ * array.+ */+ concat: __arrayProto.concat,+++ context: [], // array of table settings objects+++ each: function ( fn )+ {+ for ( var i=0, ien=this.length ; i<ien; i++ ) {+ fn.call( this, this[i], i, this );+ }++ return this;+ },+++ eq: function ( idx )+ {+ var ctx = this.context;++ return ctx.length > idx ?+ new _Api( ctx[idx], this[idx] ) :+ null;+ },+++ filter: function ( fn )+ {+ var a = [];++ if ( __arrayProto.filter ) {+ a = __arrayProto.filter.call( this, fn, this );+ }+ else {+ // Compatibility for browsers without EMCA-252-5 (JS 1.6)+ for ( var i=0, ien=this.length ; i<ien ; i++ ) {+ if ( fn.call( this, this[i], i, this ) ) {+ a.push( this[i] );+ }+ }+ }++ return new _Api( this.context, a );+ },+++ flatten: function ()+ {+ var a = [];+ return new _Api( this.context, a.concat.apply( a, this.toArray() ) );+ },+++ join: __arrayProto.join,+++ indexOf: __arrayProto.indexOf || function (obj, start)+ {+ for ( var i=(start || 0), ien=this.length ; i<ien ; i++ ) {+ if ( this[i] === obj ) {+ return i;+ }+ }+ return -1;+ },++ // Internal only at the moment - relax?+ iterator: function ( flatten, type, fn ) {+ var+ a = [], ret,+ i, ien, j, jen,+ context = this.context,+ rows, items, item,+ selector = this.selector;++ // Argument shifting+ if ( typeof flatten === 'string' ) {+ fn = type;+ type = flatten;+ flatten = false;+ }++ for ( i=0, ien=context.length ; i<ien ; i++ ) {+ if ( type === 'table' ) {+ ret = fn( context[i], i );++ if ( ret !== undefined ) {+ a.push( ret );+ }+ }+ else if ( type === 'columns' || type === 'rows' ) {+ // this has same length as context - one entry for each table+ ret = fn( context[i], this[i], i );++ if ( ret !== undefined ) {+ a.push( ret );+ }+ }+ else if ( type === 'column' || type === 'column-rows' || type === 'row' || type === 'cell' ) {+ // columns and rows share the same structure.+ // 'this' is an array of column indexes for each context+ items = this[i];++ if ( type === 'column-rows' ) {+ rows = _selector_row_indexes( context[i], selector.opts );+ }++ for ( j=0, jen=items.length ; j<jen ; j++ ) {+ item = items[j];++ if ( type === 'cell' ) {+ ret = fn( context[i], item.row, item.column, i, j );+ }+ else {+ ret = fn( context[i], item, i, j, rows );+ }++ if ( ret !== undefined ) {+ a.push( ret );+ }+ }+ }+ }++ if ( a.length ) {+ var api = new _Api( context, flatten ? a.concat.apply( [], a ) : a );+ var apiSelector = api.selector;+ apiSelector.rows = selector.rows;+ apiSelector.cols = selector.cols;+ apiSelector.opts = selector.opts;+ return api;+ }+ return this;+ },+++ lastIndexOf: __arrayProto.lastIndexOf || function (obj, start)+ {+ // Bit cheeky...+ return this.indexOf.apply( this.toArray.reverse(), arguments );+ },+++ length: 0,+++ map: function ( fn )+ {+ var a = [];++ if ( __arrayProto.map ) {+ a = __arrayProto.map.call( this, fn, this );+ }+ else {+ // Compatibility for browsers without EMCA-252-5 (JS 1.6)+ for ( var i=0, ien=this.length ; i<ien ; i++ ) {+ a.push( fn.call( this, this[i], i ) );+ }+ }++ return new _Api( this.context, a );+ },+++ pluck: function ( prop )+ {+ return this.map( function ( el ) {+ return el[ prop ];+ } );+ },++ pop: __arrayProto.pop,+++ push: __arrayProto.push,+++ // Does not return an API instance+ reduce: __arrayProto.reduce || function ( fn, init )+ {+ return _fnReduce( this, fn, init, 0, this.length, 1 );+ },+++ reduceRight: __arrayProto.reduceRight || function ( fn, init )+ {+ return _fnReduce( this, fn, init, this.length-1, -1, -1 );+ },+++ reverse: __arrayProto.reverse,+++ // Object with rows, columns and opts+ selector: null,+++ shift: __arrayProto.shift,+++ sort: __arrayProto.sort, // ? name - order?+++ splice: __arrayProto.splice,+++ toArray: function ()+ {+ return __arrayProto.slice.call( this );+ },+++ to$: function ()+ {+ return $( this );+ },+++ toJQuery: function ()+ {+ return $( this );+ },+++ unique: function ()+ {+ return new _Api( this.context, _unique(this) );+ },+++ unshift: __arrayProto.unshift+ };+++ _Api.extend = function ( scope, obj, ext )+ {+ // Only extend API instances and static properties of the API+ if ( ! obj || ( ! (obj instanceof _Api) && ! obj.__dt_wrapper ) ) {+ return;+ }++ var+ i, ien,+ j, jen,+ struct, inner,+ methodScoping = function ( scope, fn, struc ) {+ return function () {+ var ret = fn.apply( scope, arguments );++ // Method extension+ _Api.extend( ret, ret, struc.methodExt );+ return ret;+ };+ };++ for ( i=0, ien=ext.length ; i<ien ; i++ ) {+ struct = ext[i];++ // Value+ obj[ struct.name ] = typeof struct.val === 'function' ?+ methodScoping( scope, struct.val, struct ) :+ $.isPlainObject( struct.val ) ?+ {} :+ struct.val;++ obj[ struct.name ].__dt_wrapper = true;++ // Property extension+ _Api.extend( scope, obj[ struct.name ], struct.propExt );+ }+ };+++ // @todo - Is there need for an augment function?+ // _Api.augment = function ( inst, name )+ // {+ // // Find src object in the structure from the name+ // var parts = name.split('.');++ // _Api.extend( inst, obj );+ // };+++ // [+ // {+ // name: 'data' -- string - Property name+ // val: function () {}, -- function - Api method (or undefined if just an object+ // methodExt: [ ... ], -- array - Array of Api object definitions to extend the method result+ // propExt: [ ... ] -- array - Array of Api object definitions to extend the property+ // },+ // {+ // name: 'row'+ // val: {},+ // methodExt: [ ... ],+ // propExt: [+ // {+ // name: 'data'+ // val: function () {},+ // methodExt: [ ... ],+ // propExt: [ ... ]+ // },+ // ...+ // ]+ // }+ // ]++ _Api.register = _api_register = function ( name, val )+ {+ if ( $.isArray( name ) ) {+ for ( var j=0, jen=name.length ; j<jen ; j++ ) {+ _Api.register( name[j], val );+ }+ return;+ }++ var+ i, ien,+ heir = name.split('.'),+ struct = __apiStruct,+ key, method;++ var find = function ( src, name ) {+ for ( var i=0, ien=src.length ; i<ien ; i++ ) {+ if ( src[i].name === name ) {+ return src[i];+ }+ }+ return null;+ };++ for ( i=0, ien=heir.length ; i<ien ; i++ ) {+ method = heir[i].indexOf('()') !== -1;+ key = method ?+ heir[i].replace('()', '') :+ heir[i];++ var src = find( struct, key );+ if ( ! src ) {+ src = {+ name: key,+ val: {},+ methodExt: [],+ propExt: []+ };+ struct.push( src );+ }++ if ( i === ien-1 ) {+ src.val = val;+ }+ else {+ struct = method ?+ src.methodExt :+ src.propExt;+ }+ }+ };+++ _Api.registerPlural = _api_registerPlural = function ( pluralName, singularName, val ) {+ _Api.register( pluralName, val );++ _Api.register( singularName, function () {+ var ret = val.apply( this, arguments );++ if ( ret === this ) {+ // Returned item is the API instance that was passed in, return it+ return this;+ }+ else if ( ret instanceof _Api ) {+ // New API instance returned, want the value from the first item+ // in the returned array for the singular result.+ return ret.length ?+ $.isArray( ret[0] ) ?+ new _Api( ret.context, ret[0] ) : // Array results are 'enhanced'+ ret[0] :+ undefined;+ }++ // Non-API return - just fire it back+ return ret;+ } );+ };+++ /**+ * Selector for HTML tables. Apply the given selector to the give array of+ * DataTables settings objects.+ *+ * @param {string|integer} [selector] jQuery selector string or integer+ * @param {array} Array of DataTables settings objects to be filtered+ * @return {array}+ * @ignore+ */+ var __table_selector = function ( selector, a )+ {+ // Integer is used to pick out a table by index+ if ( typeof selector === 'number' ) {+ return [ a[ selector ] ];+ }++ // Perform a jQuery selector on the table nodes+ var nodes = $.map( a, function (el, i) {+ return el.nTable;+ } );++ return $(nodes)+ .filter( selector )+ .map( function (i) {+ // Need to translate back from the table node to the settings+ var idx = $.inArray( this, nodes );+ return a[ idx ];+ } )+ .toArray();+ };++++ /**+ * Context selector for the API's context (i.e. the tables the API instance+ * refers to.+ *+ * @name DataTable.Api#tables+ * @param {string|integer} [selector] Selector to pick which tables the iterator+ * should operate on. If not given, all tables in the current context are+ * used. This can be given as a jQuery selector (for example `':gt(0)'`) to+ * select multiple tables or as an integer to select a single table.+ * @returns {DataTable.Api} Returns a new API instance if a selector is given.+ */+ _api_register( 'tables()', function ( selector ) {+ // A new instance is created if there was a selector specified+ return selector ?+ new _Api( __table_selector( selector, this.context ) ) :+ this;+ } );+++ _api_register( 'table()', function ( selector ) {+ var tables = this.tables( selector );+ var ctx = tables.context;++ // Truncate to the first matched table+ return ctx.length ?+ new _Api( ctx[0] ) :+ tables;+ } );+++ _api_registerPlural( 'tables().nodes()', 'table().node()' , function () {+ return this.iterator( 'table', function ( ctx ) {+ return ctx.nTable;+ } );+ } );+++ _api_registerPlural( 'tables().body()', 'table().body()' , function () {+ return this.iterator( 'table', function ( ctx ) {+ return ctx.nTBody;+ } );+ } );+++ _api_registerPlural( 'tables().header()', 'table().header()' , function () {+ return this.iterator( 'table', function ( ctx ) {+ return ctx.nTHead;+ } );+ } );+++ _api_registerPlural( 'tables().footer()', 'table().footer()' , function () {+ return this.iterator( 'table', function ( ctx ) {+ return ctx.nTFoot;+ } );+ } );+++ _api_registerPlural( 'tables().containers()', 'table().container()' , function () {+ return this.iterator( 'table', function ( ctx ) {+ return ctx.nTableWrapper;+ } );+ } );++++ /**+ * Redraw the tables in the current context.+ *+ * @param {boolean} [reset=true] Reset (default) or hold the current paging+ * position. A full re-sort and re-filter is performed when this method is+ * called, which is why the pagination reset is the default action.+ * @returns {DataTables.Api} this+ */+ _api_register( 'draw()', function ( resetPaging ) {+ return this.iterator( 'table', function ( settings ) {+ _fnReDraw( settings, resetPaging===false );+ } );+ } );++++ /**+ * Get the current page index.+ *+ * @return {integer} Current page index (zero based)+ *//**+ * Set the current page.+ *+ * Note that if you attempt to show a page which does not exist, DataTables will+ * not throw an error, but rather reset the paging.+ *+ * @param {integer|string} action The paging action to take. This can be one of:+ * * `integer` - The page index to jump to+ * * `string` - An action to take:+ * * `first` - Jump to first page.+ * * `next` - Jump to the next page+ * * `previous` - Jump to previous page+ * * `last` - Jump to the last page.+ * @returns {DataTables.Api} this+ */+ _api_register( 'page()', function ( action ) {+ if ( action === undefined ) {+ return this.page.info().page; // not an expensive call+ }++ // else, have an action to take on all tables+ return this.iterator( 'table', function ( settings ) {+ _fnPageChange( settings, action );+ } );+ } );+++ /**+ * Paging information for the first table in the current context.+ *+ * If you require paging information for another table, use the `table()` method+ * with a suitable selector.+ *+ * @return {object} Object with the following properties set:+ * * `page` - Current page index (zero based - i.e. the first page is `0`)+ * * `pages` - Total number of pages+ * * `start` - Display index for the first record shown on the current page+ * * `end` - Display index for the last record shown on the current page+ * * `length` - Display length (number of records). Note that generally `start+ * + length = end`, but this is not always true, for example if there are+ * only 2 records to show on the final page, with a length of 10.+ * * `recordsTotal` - Full data set length+ * * `recordsDisplay` - Data set length once the current filtering criterion+ * are applied.+ */+ _api_register( 'page.info()', function ( action ) {+ if ( this.context.length === 0 ) {+ return undefined;+ }++ var+ settings = this.context[0],+ start = settings._iDisplayStart,+ len = settings._iDisplayLength,+ visRecords = settings.fnRecordsDisplay(),+ all = len === -1;++ return {+ "page": all ? 0 : Math.floor( start / len ),+ "pages": all ? 1 : Math.ceil( visRecords / len ),+ "start": start,+ "end": settings.fnDisplayEnd(),+ "length": len,+ "recordsTotal": settings.fnRecordsTotal(),+ "recordsDisplay": visRecords+ };+ } );+++ /**+ * Get the current page length.+ *+ * @return {integer} Current page length. Note `-1` indicates that all records+ * are to be shown.+ *//**+ * Set the current page length.+ *+ * @param {integer} Page length to set. Use `-1` to show all records.+ * @returns {DataTables.Api} this+ */+ _api_register( 'page.len()', function ( len ) {+ // Note that we can't call this function 'length()' because `length`+ // is a Javascript property of functions which defines how many arguments+ // the function expects.+ if ( len === undefined ) {+ return this.context.length !== 0 ?+ this.context[0]._iDisplayLength :+ undefined;+ }++ // else, set the page length+ return this.iterator( 'table', function ( settings ) {+ _fnLengthChange( settings, len );+ } );+ } );++++ var __reload = function ( settings, holdPosition, callback ) {+ if ( _fnDataSource( settings ) == 'ssp' ) {+ _fnReDraw( settings, holdPosition );+ }+ else {+ // Trigger xhr+ _fnProcessingDisplay( settings, true );++ _fnBuildAjax( settings, [], function( json ) {+ _fnClearTable( settings );++ var data = _fnAjaxDataSrc( settings, json );+ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ _fnAddData( settings, data[i] );+ }++ _fnReDraw( settings, holdPosition );+ _fnProcessingDisplay( settings, false );+ } );+ }++ // Use the draw event to trigger a callback, regardless of if it is an async+ // or sync draw+ if ( callback ) {+ var api = new _Api( settings );++ api.one( 'draw', function () {+ callback( api.ajax.json() );+ } );+ }+ };+++ /**+ * Get the JSON response from the last Ajax request that DataTables made to the+ * server. Note that this returns the JSON from the first table in the current+ * context.+ *+ * @return {object} JSON received from the server.+ */+ _api_register( 'ajax.json()', function () {+ var ctx = this.context;++ if ( ctx.length > 0 ) {+ return ctx[0].json;+ }++ // else return undefined;+ } );+++ /**+ * Get the data submitted in the last Ajax request+ */+ _api_register( 'ajax.params()', function () {+ var ctx = this.context;++ if ( ctx.length > 0 ) {+ return ctx[0].oAjaxData;+ }++ // else return undefined;+ } );+++ /**+ * Reload tables from the Ajax data source. Note that this function will+ * automatically re-draw the table when the remote data has been loaded.+ *+ * @param {boolean} [reset=true] Reset (default) or hold the current paging+ * position. A full re-sort and re-filter is performed when this method is+ * called, which is why the pagination reset is the default action.+ * @returns {DataTables.Api} this+ */+ _api_register( 'ajax.reload()', function ( callback, resetPaging ) {+ return this.iterator( 'table', function (settings) {+ __reload( settings, resetPaging===false, callback );+ } );+ } );+++ /**+ * Get the current Ajax URL. Note that this returns the URL from the first+ * table in the current context.+ *+ * @return {string} Current Ajax source URL+ *//**+ * Set the Ajax URL. Note that this will set the URL for all tables in the+ * current context.+ *+ * @param {string} url URL to set.+ * @returns {DataTables.Api} this+ */+ _api_register( 'ajax.url()', function ( url ) {+ var ctx = this.context;++ if ( url === undefined ) {+ // get+ if ( ctx.length === 0 ) {+ return undefined;+ }+ ctx = ctx[0];++ return ctx.ajax ?+ $.isPlainObject( ctx.ajax ) ?+ ctx.ajax.url :+ ctx.ajax :+ ctx.sAjaxSource;+ }++ // set+ return this.iterator( 'table', function ( settings ) {+ if ( $.isPlainObject( settings.ajax ) ) {+ settings.ajax.url = url;+ }+ else {+ settings.ajax = url;+ }+ // No need to consider sAjaxSource here since DataTables gives priority+ // to `ajax` over `sAjaxSource`. So setting `ajax` here, renders any+ // value of `sAjaxSource` redundant.+ } );+ } );+++ /**+ * Load data from the newly set Ajax URL. Note that this method is only+ * available when `ajax.url()` is used to set a URL. Additionally, this method+ * has the same effect as calling `ajax.reload()` but is provided for+ * convenience when setting a new URL. Like `ajax.reload()` it will+ * automatically redraw the table once the remote data has been loaded.+ *+ * @returns {DataTables.Api} this+ */+ _api_register( 'ajax.url().load()', function ( callback, resetPaging ) {+ // Same as a reload, but makes sense to present it for easy access after a+ // url change+ return this.iterator( 'table', function ( ctx ) {+ __reload( ctx, resetPaging===false, callback );+ } );+ } );+++++ var _selector_run = function ( selector, select )+ {+ var+ out = [], res,+ a, i, ien, j, jen;++ // Can't just check for isArray here, as an API or jQuery instance might be+ // given with their array like look+ if ( ! selector || typeof selector === 'string' || selector.length === undefined ) {+ selector = [ selector ];+ }++ for ( i=0, ien=selector.length ; i<ien ; i++ ) {+ a = selector[i] && selector[i].split ?+ selector[i].split(',') :+ [ selector[i] ];++ for ( j=0, jen=a.length ; j<jen ; j++ ) {+ res = select( typeof a[j] === 'string' ? $.trim(a[j]) : a[j] );++ if ( res && res.length ) {+ out.push.apply( out, res );+ }+ }+ }++ return out;+ };+++ var _selector_opts = function ( opts )+ {+ if ( ! opts ) {+ opts = {};+ }++ // Backwards compatibility for 1.9- which used the terminology filter rather+ // than search+ if ( opts.filter && ! opts.search ) {+ opts.search = opts.filter;+ }++ return {+ search: opts.search || 'none',+ order: opts.order || 'current',+ page: opts.page || 'all'+ };+ };+++ var _selector_first = function ( inst )+ {+ // Reduce the API instance to the first item found+ for ( var i=0, ien=inst.length ; i<ien ; i++ ) {+ if ( inst[i].length > 0 ) {+ // Assign the first element to the first item in the instance+ // and truncate the instance and context+ inst[0] = inst[i];+ inst.length = 1;+ inst.context = [ inst.context[i] ];++ return inst;+ }+ }++ // Not found - return an empty instance+ inst.length = 0;+ return inst;+ };+++ var _selector_row_indexes = function ( settings, opts )+ {+ var+ i, ien, tmp, a=[],+ displayFiltered = settings.aiDisplay,+ displayMaster = settings.aiDisplayMaster;++ var+ search = opts.search, // none, applied, removed+ order = opts.order, // applied, current, index (original - compatibility with 1.9)+ page = opts.page; // all, current++ if ( _fnDataSource( settings ) == 'ssp' ) {+ // In server-side processing mode, most options are irrelevant since+ // rows not shown don't exist and the index order is the applied order+ // Removed is a special case - for consistency just return an empty+ // array+ return search === 'removed' ?+ [] :+ _range( 0, displayMaster.length );+ }+ else if ( page == 'current' ) {+ // Current page implies that order=current and fitler=applied, since it is+ // fairly senseless otherwise, regardless of what order and search actually+ // are+ for ( i=settings._iDisplayStart, ien=settings.fnDisplayEnd() ; i<ien ; i++ ) {+ a.push( displayFiltered[i] );+ }+ }+ else if ( order == 'current' || order == 'applied' ) {+ a = search == 'none' ?+ displayMaster.slice() : // no search+ search == 'applied' ?+ displayFiltered.slice() : // applied search+ $.map( displayMaster, function (el, i) { // removed search+ return $.inArray( el, displayFiltered ) === -1 ? el : null;+ } );+ }+ else if ( order == 'index' || order == 'original' ) {+ for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {+ if ( search == 'none' ) {+ a.push( i );+ }+ else { // applied | removed+ tmp = $.inArray( i, displayFiltered );++ if ((tmp === -1 && search == 'removed') ||+ (tmp >= 0 && search == 'applied') )+ {+ a.push( i );+ }+ }+ }+ }++ return a;+ };+++ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *+ * Rows+ *+ * {} - no selector - use all available rows+ * {integer} - row aoData index+ * {node} - TR node+ * {string} - jQuery selector to apply to the TR elements+ * {array} - jQuery array of nodes, or simply an array of TR nodes+ *+ */+++ var __row_selector = function ( settings, selector, opts )+ {+ return _selector_run( selector, function ( sel ) {+ var selInt = _intVal( sel );++ // Short cut - selector is a number and no options provided (default is+ // all records, so no need to check if the index is in there, since it+ // must be - dev error if the index doesn't exist).+ if ( selInt !== null && ! opts ) {+ return [ selInt ];+ }++ var rows = _selector_row_indexes( settings, opts );++ if ( selInt !== null && $.inArray( selInt, rows ) !== -1 ) {+ // Selector - integer+ return [ selInt ];+ }+ else if ( ! sel ) {+ // Selector - none+ return rows;+ }++ // Get nodes in the order from the `rows` array (can't use `pluck`) @todo - use pluck_order+ var nodes = [];+ for ( var i=0, ien=rows.length ; i<ien ; i++ ) {+ nodes.push( settings.aoData[ rows[i] ].nTr );+ }++ if ( sel.nodeName ) {+ // Selector - node+ if ( $.inArray( sel, nodes ) !== -1 ) {+ return [ sel._DT_RowIndex ];// sel is a TR node that is in the table+ // and DataTables adds a prop for fast lookup+ }+ }++ // Selector - jQuery selector string, array of nodes or jQuery object/+ // As jQuery's .filter() allows jQuery objects to be passed in filter,+ // it also allows arrays, so this will cope with all three options+ return $(nodes)+ .filter( sel )+ .map( function () {+ return this._DT_RowIndex;+ } )+ .toArray();+ } );+ };+++ /**+ *+ */+ _api_register( 'rows()', function ( selector, opts ) {+ // argument shifting+ if ( selector === undefined ) {+ selector = '';+ }+ else if ( $.isPlainObject( selector ) ) {+ opts = selector;+ selector = '';+ }++ opts = _selector_opts( opts );++ var inst = this.iterator( 'table', function ( settings ) {+ return __row_selector( settings, selector, opts );+ } );++ // Want argument shifting here and in __row_selector?+ inst.selector.rows = selector;+ inst.selector.opts = opts;++ return inst;+ } );+++ _api_register( 'rows().nodes()', function () {+ return this.iterator( 'row', function ( settings, row ) {+ return settings.aoData[ row ].nTr || undefined;+ } );+ } );++ _api_register( 'rows().data()', function () {+ return this.iterator( true, 'rows', function ( settings, rows ) {+ return _pluck_order( settings.aoData, rows, '_aData' );+ } );+ } );++ _api_registerPlural( 'rows().cache()', 'row().cache()', function ( type ) {+ return this.iterator( 'row', function ( settings, row ) {+ var r = settings.aoData[ row ];+ return type === 'search' ? r._aFilterData : r._aSortData;+ } );+ } );++ _api_registerPlural( 'rows().invalidate()', 'row().invalidate()', function ( src ) {+ return this.iterator( 'row', function ( settings, row ) {+ _fnInvalidateRow( settings, row, src );+ } );+ } );++ _api_registerPlural( 'rows().indexes()', 'row().index()', function () {+ return this.iterator( 'row', function ( settings, row ) {+ return row;+ } );+ } );++ _api_registerPlural( 'rows().remove()', 'row().remove()', function () {+ var that = this;++ return this.iterator( 'row', function ( settings, row, thatIdx ) {+ var data = settings.aoData;++ data.splice( row, 1 );++ // Update the _DT_RowIndex parameter on all rows in the table+ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ if ( data[i].nTr !== null ) {+ data[i].nTr._DT_RowIndex = i;+ }+ }++ // Remove the target row from the search array+ var displayIndex = $.inArray( row, settings.aiDisplay );++ // Delete from the display arrays+ _fnDeleteIndex( settings.aiDisplayMaster, row );+ _fnDeleteIndex( settings.aiDisplay, row );+ _fnDeleteIndex( that[ thatIdx ], row, false ); // maintain local indexes++ // Check for an 'overflow' they case for displaying the table+ _fnLengthOverflow( settings );+ } );+ } );+++ _api_register( 'rows.add()', function ( rows ) {+ var newRows = this.iterator( 'table', function ( settings ) {+ var row, i, ien;+ var out = [];++ for ( i=0, ien=rows.length ; i<ien ; i++ ) {+ row = rows[i];++ if ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {+ out.push( _fnAddTr( settings, row )[0] );+ }+ else {+ out.push( _fnAddData( settings, row ) );+ }+ }++ return out;+ } );++ // Return an Api.rows() extended instance, so rows().nodes() etc can be used+ var modRows = this.rows( -1 );+ modRows.pop();+ modRows.push.apply( modRows, newRows.toArray() );++ return modRows;+ } );++++++ /**+ *+ */+ _api_register( 'row()', function ( selector, opts ) {+ return _selector_first( this.rows( selector, opts ) );+ } );+++ _api_register( 'row().data()', function ( data ) {+ var ctx = this.context;++ if ( data === undefined ) {+ // Get+ return ctx.length && this.length ?+ ctx[0].aoData[ this[0] ]._aData :+ undefined;+ }++ // Set+ ctx[0].aoData[ this[0] ]._aData = data;++ // Automatically invalidate+ _fnInvalidateRow( ctx[0], this[0], 'data' );++ return this;+ } );+++ _api_register( 'row().node()', function () {+ var ctx = this.context;++ return ctx.length && this.length ?+ ctx[0].aoData[ this[0] ].nTr || null :+ null;+ } );+++ _api_register( 'row.add()', function ( row ) {+ // Allow a jQuery object to be passed in - only a single row is added from+ // it though - the first element in the set+ if ( row instanceof $ && row.length ) {+ row = row[0];+ }++ var rows = this.iterator( 'table', function ( settings ) {+ if ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {+ return _fnAddTr( settings, row )[0];+ }+ return _fnAddData( settings, row );+ } );++ // Return an Api.rows() extended instance, with the newly added row selected+ return this.row( rows[0] );+ } );++++ var __details_add = function ( ctx, row, data, klass )+ {+ // Convert to array of TR elements+ var rows = [];+ var addRow = function ( r, k ) {+ // If we get a TR element, then just add it directly - up to the dev+ // to add the correct number of columns etc+ if ( r.nodeName && r.nodeName.toLowerCase() === 'tr' ) {+ rows.push( r );+ }+ else {+ // Otherwise create a row with a wrapper+ var created = $('<tr><td/></tr>').addClass( k );+ $('td', created)+ .addClass( k )+ .html( r )+ [0].colSpan = _fnVisbleColumns( ctx );++ rows.push( created[0] );+ }+ };++ if ( $.isArray( data ) || data instanceof $ ) {+ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ addRow( data[i], klass );+ }+ }+ else {+ addRow( data, klass );+ }++ if ( row._details ) {+ row._details.remove();+ }++ row._details = $(rows);++ // If the children were already shown, that state should be retained+ if ( row._detailsShow ) {+ row._details.insertAfter( row.nTr );+ }+ };+++ var __details_remove = function ( api )+ {+ var ctx = api.context;++ if ( ctx.length && api.length ) {+ var row = ctx[0].aoData[ api[0] ];++ if ( row._details ) {+ row._details.remove();++ row._detailsShow = undefined;+ row._details = undefined;+ }+ }+ };+++ var __details_display = function ( api, show ) {+ var ctx = api.context;++ if ( ctx.length && api.length ) {+ var row = ctx[0].aoData[ api[0] ];++ if ( row._details ) {+ row._detailsShow = show;++ if ( show ) {+ row._details.insertAfter( row.nTr );+ }+ else {+ row._details.detach();+ }++ __details_events( ctx[0] );+ }+ }+ };+++ var __details_events = function ( settings )+ {+ var api = new _Api( settings );+ var namespace = '.dt.DT_details';+ var drawEvent = 'draw'+namespace;+ var colvisEvent = 'column-visibility'+namespace;+ var destroyEvent = 'destroy'+namespace;+ var data = settings.aoData;++ api.off( drawEvent +' '+ colvisEvent +' '+ destroyEvent );++ if ( _pluck( data, '_details' ).length > 0 ) {+ // On each draw, insert the required elements into the document+ api.on( drawEvent, function ( e, ctx ) {+ if ( settings !== ctx ) {+ return;+ }++ api.rows( {page:'current'} ).eq(0).each( function (idx) {+ // Internal data grab+ var row = data[ idx ];++ if ( row._detailsShow ) {+ row._details.insertAfter( row.nTr );+ }+ } );+ } );++ // Column visibility change - update the colspan+ api.on( colvisEvent, function ( e, ctx, idx, vis ) {+ if ( settings !== ctx ) {+ return;+ }++ // Update the colspan for the details rows (note, only if it already has+ // a colspan)+ var row, visible = _fnVisbleColumns( ctx );++ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ row = data[i];++ if ( row._details ) {+ row._details.children('td[colspan]').attr('colspan', visible );+ }+ }+ } );++ // Table destroyed - nuke any child rows+ api.on( destroyEvent, function ( e, ctx ) {+ if ( settings !== ctx ) {+ return;+ }++ for ( var i=0, ien=data.length ; i<ien ; i++ ) {+ if ( data[i]._details ) {+ __details_remove( data[i] );+ }+ }+ } );+ }+ };++ // Strings for the method names to help minification+ var _emp = '';+ var _child_obj = _emp+'row().child';+ var _child_mth = _child_obj+'()';++ // data can be:+ // tr+ // string+ // jQuery or array of any of the above+ _api_register( _child_mth, function ( data, klass ) {+ var ctx = this.context;++ if ( data === undefined ) {+ // get+ return ctx.length && this.length ?+ ctx[0].aoData[ this[0] ]._details :+ undefined;+ }+ else if ( data === true ) {+ // show+ this.child.show();+ }+ else if ( data === false ) {+ // remove+ __details_remove( this );+ }+ else if ( ctx.length && this.length ) {+ // set+ __details_add( ctx[0], ctx[0].aoData[ this[0] ], data, klass );+ }++ return this;+ } );+++ _api_register( [+ _child_obj+'.show()',+ _child_mth+'.show()' // only when `child()` was called with parameters (without+ ], function ( show ) { // it returns an object and this method is not executed)+ __details_display( this, true );+ return this;+ } );+++ _api_register( [+ _child_obj+'.hide()',+ _child_mth+'.hide()' // only when `child()` was called with parameters (without+ ], function () { // it returns an object and this method is not executed)+ __details_display( this, false );+ return this;+ } );+++ _api_register( [+ _child_obj+'.remove()',+ _child_mth+'.remove()' // only when `child()` was called with parameters (without+ ], function () { // it returns an object and this method is not executed)+ __details_remove( this );+ return this;+ } );+++ _api_register( _child_obj+'.isShown()', function () {+ var ctx = this.context;++ if ( ctx.length && this.length ) {+ // _detailsShown as false or undefined will fall through to return false+ return ctx[0].aoData[ this[0] ]._detailsShow || false;+ }+ return false;+ } );++++ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *+ * Columns+ *+ * {integer} - column index (>=0 count from left, <0 count from right)+ * "{integer}:visIdx" - visible column index (i.e. translate to column index) (>=0 count from left, <0 count from right)+ * "{integer}:visible" - alias for {integer}:visIdx (>=0 count from left, <0 count from right)+ * "{string}:name" - column name+ * "{string}" - jQuery selector on column header nodes+ *+ */++ // can be an array of these items, comma separated list, or an array of comma+ // separated lists++ var __re_column_selector = /^(.+):(name|visIdx|visible)$/;++ var __column_selector = function ( settings, selector, opts )+ {+ var+ columns = settings.aoColumns,+ names = _pluck( columns, 'sName' ),+ nodes = _pluck( columns, 'nTh' );++ return _selector_run( selector, function ( s ) {+ var selInt = _intVal( s );++ if ( s === '' ) {+ // All columns+ return _range( columns.length );+ }+ else if ( selInt !== null ) {+ // Integer selector+ return [ selInt >= 0 ?+ selInt : // Count from left+ columns.length + selInt // Count from right (+ because its a negative value)+ ];+ }+ else {+ var match = typeof s === 'string' ?+ s.match( __re_column_selector ) :+ '';++ if ( match ) {+ switch( match[2] ) {+ case 'visIdx':+ case 'visible':+ var idx = parseInt( match[1], 10 );+ // Visible index given, convert to column index+ if ( idx < 0 ) {+ // Counting from the right+ var visColumns = $.map( columns, function (col,i) {+ return col.bVisible ? i : null;+ } );+ return [ visColumns[ visColumns.length + idx ] ];+ }+ // Counting from the left+ return [ _fnVisibleToColumnIndex( settings, idx ) ];++ case 'name':+ // match by name. `names` is column index complete and in order+ return $.map( names, function (name, i) {+ return name === match[1] ? i : null;+ } );+ }+ }+ else {+ // jQuery selector on the TH elements for the columns+ return $( nodes )+ .filter( s )+ .map( function () {+ return $.inArray( this, nodes ); // `nodes` is column index complete and in order+ } )+ .toArray();+ }+ }+ } );+ };++++++ var __setColumnVis = function ( settings, column, vis, recalc ) {+ var+ cols = settings.aoColumns,+ col = cols[ column ],+ data = settings.aoData,+ row, cells, i, ien, tr;++ // Get+ if ( vis === undefined ) {+ return col.bVisible;+ }++ // Set+ // No change+ if ( col.bVisible === vis ) {+ return;+ }++ if ( vis ) {+ // Insert column+ // Need to decide if we should use appendChild or insertBefore+ var insertBefore = $.inArray( true, _pluck(cols, 'bVisible'), column+1 );++ for ( i=0, ien=data.length ; i<ien ; i++ ) {+ tr = data[i].nTr;+ cells = data[i].anCells;++ if ( tr ) {+ // insertBefore can act like appendChild if 2nd arg is null+ tr.insertBefore( cells[ column ], cells[ insertBefore ] || null );+ }+ }+ }+ else {+ // Remove column+ $( _pluck( settings.aoData, 'anCells', column ) ).detach();+ }++ // Common actions+ col.bVisible = vis;+ _fnDrawHead( settings, settings.aoHeader );+ _fnDrawHead( settings, settings.aoFooter );++ if ( recalc === undefined || recalc ) {+ // Automatically adjust column sizing+ _fnAdjustColumnSizing( settings );++ // Realign columns for scrolling+ if ( settings.oScroll.sX || settings.oScroll.sY ) {+ _fnScrollDraw( settings );+ }+ }++ _fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis] );++ _fnSaveState( settings );+ };+++ /**+ *+ */+ _api_register( 'columns()', function ( selector, opts ) {+ // argument shifting+ if ( selector === undefined ) {+ selector = '';+ }+ else if ( $.isPlainObject( selector ) ) {+ opts = selector;+ selector = '';+ }++ opts = _selector_opts( opts );++ var inst = this.iterator( 'table', function ( settings ) {+ return __column_selector( settings, selector, opts );+ } );++ // Want argument shifting here and in _row_selector?+ inst.selector.cols = selector;+ inst.selector.opts = opts;++ return inst;+ } );+++ /**+ *+ */+ _api_registerPlural( 'columns().header()', 'column().header()', function ( selector, opts ) {+ return this.iterator( 'column', function ( settings, column ) {+ return settings.aoColumns[column].nTh;+ } );+ } );+++ /**+ *+ */+ _api_registerPlural( 'columns().footer()', 'column().footer()', function ( selector, opts ) {+ return this.iterator( 'column', function ( settings, column ) {+ return settings.aoColumns[column].nTf;+ } );+ } );+++ /**+ *+ */+ _api_registerPlural( 'columns().data()', 'column().data()', function () {+ return this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {+ var a = [];+ for ( var row=0, ien=rows.length ; row<ien ; row++ ) {+ a.push( _fnGetCellData( settings, rows[row], column, '' ) );+ }+ return a;+ } );+ } );+++ _api_registerPlural( 'columns().cache()', 'column().cache()', function ( type ) {+ return this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {+ return _pluck_order( settings.aoData, rows,+ type === 'search' ? '_aFilterData' : '_aSortData', column+ );+ } );+ } );+++ _api_registerPlural( 'columns().nodes()', 'column().nodes()', function () {+ return this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {+ return _pluck_order( settings.aoData, rows, 'anCells', column ) ;+ } );+ } );++++ _api_registerPlural( 'columns().visible()', 'column().visible()', function ( vis, calc ) {+ return this.iterator( 'column', function ( settings, column ) {+ return vis === undefined ?+ settings.aoColumns[ column ].bVisible :+ __setColumnVis( settings, column, vis, calc );+ } );+ } );++++ _api_registerPlural( 'columns().indexes()', 'column().index()', function ( type ) {+ return this.iterator( 'column', function ( settings, column ) {+ return type === 'visible' ?+ _fnColumnIndexToVisible( settings, column ) :+ column;+ } );+ } );+++ // _api_register( 'columns().show()', function () {+ // var selector = this.selector;+ // return this.columns( selector.cols, selector.opts ).visible( true );+ // } );+++ // _api_register( 'columns().hide()', function () {+ // var selector = this.selector;+ // return this.columns( selector.cols, selector.opts ).visible( false );+ // } );++++ _api_register( 'columns.adjust()', function () {+ return this.iterator( 'table', function ( settings ) {+ _fnAdjustColumnSizing( settings );+ } );+ } );+++ // Convert from one column index type, to another type+ _api_register( 'column.index()', function ( type, idx ) {+ if ( this.context.length !== 0 ) {+ var ctx = this.context[0];++ if ( type === 'fromVisible' || type === 'toData' ) {+ return _fnVisibleToColumnIndex( ctx, idx );+ }+ else if ( type === 'fromData' || type === 'toVisible' ) {+ return _fnColumnIndexToVisible( ctx, idx );+ }+ }+ } );+++ _api_register( 'column()', function ( selector, opts ) {+ return _selector_first( this.columns( selector, opts ) );+ } );+++++ var __cell_selector = function ( settings, selector, opts )+ {+ var data = settings.aoData;+ var rows = _selector_row_indexes( settings, opts );+ var cells = _pluck_order( data, rows, 'anCells' );+ var allCells = $( [].concat.apply([], cells) );+ var row;+ var columns = settings.aoColumns.length;+ var a, i, ien, j;++ return _selector_run( selector, function ( s ) {+ if ( s === null || s === undefined ) {+ // All cells+ a = [];++ for ( i=0, ien=rows.length ; i<ien ; i++ ) {+ row = rows[i];++ for ( j=0 ; j<columns ; j++ ) {+ a.push( {+ row: row,+ column: j+ } );+ }+ }++ return a;+ }+ else if ( $.isPlainObject( s ) ) {+ return [s];+ }++ // jQuery filtered cells+ return allCells+ .filter( s )+ .map( function (i, el) {+ row = el.parentNode._DT_RowIndex;++ return {+ row: row,+ column: $.inArray( el, data[ row ].anCells )+ };+ } )+ .toArray();+ } );+ };+++++ _api_register( 'cells()', function ( rowSelector, columnSelector, opts ) {+ // Argument shifting+ if ( $.isPlainObject( rowSelector ) ) {+ // Indexes+ if ( typeof rowSelector.row !== undefined ) {+ opts = columnSelector;+ columnSelector = null;+ }+ else {+ opts = rowSelector;+ rowSelector = null;+ }+ }+ if ( $.isPlainObject( columnSelector ) ) {+ opts = columnSelector;+ columnSelector = null;+ }++ // Cell selector+ if ( columnSelector === null || columnSelector === undefined ) {+ return this.iterator( 'table', function ( settings ) {+ return __cell_selector( settings, rowSelector, _selector_opts( opts ) );+ } );+ }++ // Row + column selector+ var columns = this.columns( columnSelector, opts );+ var rows = this.rows( rowSelector, opts );+ var a, i, ien, j, jen;++ var cells = this.iterator( 'table', function ( settings, idx ) {+ a = [];++ for ( i=0, ien=rows[idx].length ; i<ien ; i++ ) {+ for ( j=0, jen=columns[idx].length ; j<jen ; j++ ) {+ a.push( {+ row: rows[idx][i],+ column: columns[idx][j]+ } );+ }+ }++ return a;+ } );++ $.extend( cells.selector, {+ cols: columnSelector,+ rows: rowSelector,+ opts: opts+ } );++ return cells;+ } );+++ _api_registerPlural( 'cells().nodes()', 'cell().node()', function () {+ return this.iterator( 'cell', function ( settings, row, column ) {+ return settings.aoData[ row ].anCells[ column ];+ } );+ } );+++ _api_register( 'cells().data()', function () {+ return this.iterator( 'cell', function ( settings, row, column ) {+ return _fnGetCellData( settings, row, column );+ } );+ } );+++ _api_registerPlural( 'cells().cache()', 'cell().cache()', function ( type ) {+ type = type === 'search' ? '_aFilterData' : '_aSortData';++ return this.iterator( 'cell', function ( settings, row, column ) {+ return settings.aoData[ row ][ type ][ column ];+ } );+ } );+++ _api_registerPlural( 'cells().indexes()', 'cell().index()', function () {+ return this.iterator( 'cell', function ( settings, row, column ) {+ return {+ row: row,+ column: column,+ columnVisible: _fnColumnIndexToVisible( settings, column )+ };+ } );+ } );+++ _api_register( [+ 'cells().invalidate()',+ 'cell().invalidate()'+ ], function ( src ) {+ var selector = this.selector;++ // Use the rows method of the instance to perform the invalidation, rather+ // than doing it here. This avoids needing to handle duplicate rows from+ // the cells.+ this.rows( selector.rows, selector.opts ).invalidate( src );++ return this;+ } );+++++ _api_register( 'cell()', function ( rowSelector, columnSelector, opts ) {+ return _selector_first( this.cells( rowSelector, columnSelector, opts ) );+ } );++++ _api_register( 'cell().data()', function ( data ) {+ var ctx = this.context;+ var cell = this[0];++ if ( data === undefined ) {+ // Get+ return ctx.length && cell.length ?+ _fnGetCellData( ctx[0], cell[0].row, cell[0].column ) :+ undefined;+ }++ // Set+ _fnSetCellData( ctx[0], cell[0].row, cell[0].column, data );+ _fnInvalidateRow( ctx[0], cell[0].row, 'data', cell[0].column );++ return this;+ } );++++ /**+ * Get current ordering (sorting) that has been applied to the table.+ *+ * @returns {array} 2D array containing the sorting information for the first+ * table in the current context. Each element in the parent array represents+ * a column being sorted upon (i.e. multi-sorting with two columns would have+ * 2 inner arrays). The inner arrays may have 2 or 3 elements. The first is+ * the column index that the sorting condition applies to, the second is the+ * direction of the sort (`desc` or `asc`) and, optionally, the third is the+ * index of the sorting order from the `column.sorting` initialisation array.+ *//**+ * Set the ordering for the table.+ *+ * @param {integer} order Column index to sort upon.+ * @param {string} direction Direction of the sort to be applied (`asc` or `desc`)+ * @returns {DataTables.Api} this+ *//**+ * Set the ordering for the table.+ *+ * @param {array} order 1D array of sorting information to be applied.+ * @param {array} [...] Optional additional sorting conditions+ * @returns {DataTables.Api} this+ *//**+ * Set the ordering for the table.+ *+ * @param {array} order 2D array of sorting information to be applied.+ * @returns {DataTables.Api} this+ */+ _api_register( 'order()', function ( order, dir ) {+ var ctx = this.context;++ if ( order === undefined ) {+ // get+ return ctx.length !== 0 ?+ ctx[0].aaSorting :+ undefined;+ }++ // set+ if ( typeof order === 'number' ) {+ // Simple column / direction passed in+ order = [ [ order, dir ] ];+ }+ else if ( ! $.isArray( order[0] ) ) {+ // Arguments passed in (list of 1D arrays)+ order = Array.prototype.slice.call( arguments );+ }+ // otherwise a 2D array was passed in++ return this.iterator( 'table', function ( settings ) {+ settings.aaSorting = order.slice();+ } );+ } );+++ /**+ * Attach a sort listener to an element for a given column+ *+ * @param {node|jQuery|string} node Identifier for the element(s) to attach the+ * listener to. This can take the form of a single DOM node, a jQuery+ * collection of nodes or a jQuery selector which will identify the node(s).+ * @param {integer} column the column that a click on this node will sort on+ * @param {function} [callback] callback function when sort is run+ * @returns {DataTables.Api} this+ */+ _api_register( 'order.listener()', function ( node, column, callback ) {+ return this.iterator( 'table', function ( settings ) {+ _fnSortAttachListener( settings, node, column, callback );+ } );+ } );+++ // Order by the selected column(s)+ _api_register( [+ 'columns().order()',+ 'column().order()'+ ], function ( dir ) {+ var that = this;++ return this.iterator( 'table', function ( settings, i ) {+ var sort = [];++ $.each( that[i], function (j, col) {+ sort.push( [ col, dir ] );+ } );++ settings.aaSorting = sort;+ } );+ } );++++ _api_register( 'search()', function ( input, regex, smart, caseInsen ) {+ var ctx = this.context;++ if ( input === undefined ) {+ // get+ return ctx.length !== 0 ?+ ctx[0].oPreviousSearch.sSearch :+ undefined;+ }++ // set+ return this.iterator( 'table', function ( settings ) {+ if ( ! settings.oFeatures.bFilter ) {+ return;+ }++ _fnFilterComplete( settings, $.extend( {}, settings.oPreviousSearch, {+ "sSearch": input+"",+ "bRegex": regex === null ? false : regex,+ "bSmart": smart === null ? true : smart,+ "bCaseInsensitive": caseInsen === null ? true : caseInsen+ } ), 1 );+ } );+ } );+++ _api_registerPlural(+ 'columns().search()',+ 'column().search()',+ function ( input, regex, smart, caseInsen ) {+ return this.iterator( 'column', function ( settings, column ) {+ var preSearch = settings.aoPreSearchCols;++ if ( input === undefined ) {+ // get+ return preSearch[ column ].sSearch;+ }++ // set+ if ( ! settings.oFeatures.bFilter ) {+ return;+ }++ $.extend( preSearch[ column ], {+ "sSearch": input+"",+ "bRegex": regex === null ? false : regex,+ "bSmart": smart === null ? true : smart,+ "bCaseInsensitive": caseInsen === null ? true : caseInsen+ } );++ _fnFilterComplete( settings, settings.oPreviousSearch, 1 );+ } );+ }+ );++ /*+ * State API methods+ */++ _api_register( 'state()', function () {+ return this.context.length ?+ this.context[0].oSavedState :+ null;+ } );+++ _api_register( 'state.clear()', function () {+ return this.iterator( 'table', function ( settings ) {+ // Save an empty object+ settings.fnStateSaveCallback.call( settings.oInstance, settings, {} );+ } );+ } );+++ _api_register( 'state.loaded()', function () {+ return this.context.length ?+ this.context[0].oLoadedState :+ null;+ } );+++ _api_register( 'state.save()', function () {+ return this.iterator( 'table', function ( settings ) {+ _fnSaveState( settings );+ } );+ } );++++ /**+ * Provide a common method for plug-ins to check the version of DataTables being+ * used, in order to ensure compatibility.+ *+ * @param {string} version Version string to check for, in the format "X.Y.Z".+ * Note that the formats "X" and "X.Y" are also acceptable.+ * @returns {boolean} true if this version of DataTables is greater or equal to+ * the required version, or false if this version of DataTales is not+ * suitable+ * @static+ * @dtopt API-Static+ *+ * @example+ * alert( $.fn.dataTable.versionCheck( '1.9.0' ) );+ */+ DataTable.versionCheck = DataTable.fnVersionCheck = function( version )+ {+ var aThis = DataTable.version.split('.');+ var aThat = version.split('.');+ var iThis, iThat;++ for ( var i=0, iLen=aThat.length ; i<iLen ; i++ ) {+ iThis = parseInt( aThis[i], 10 ) || 0;+ iThat = parseInt( aThat[i], 10 ) || 0;++ // Parts are the same, keep comparing+ if (iThis === iThat) {+ continue;+ }++ // Parts are different, return immediately+ return iThis > iThat;+ }++ return true;+ };+++ /**+ * Check if a `<table>` node is a DataTable table already or not.+ *+ * @param {node|jquery|string} table Table node, jQuery object or jQuery+ * selector for the table to test. Note that if more than more than one+ * table is passed on, only the first will be checked+ * @returns {boolean} true the table given is a DataTable, or false otherwise+ * @static+ * @dtopt API-Static+ *+ * @example+ * if ( ! $.fn.DataTable.isDataTable( '#example' ) ) {+ * $('#example').dataTable();+ * }+ */+ DataTable.isDataTable = DataTable.fnIsDataTable = function ( table )+ {+ var t = $(table).get(0);+ var is = false;++ $.each( DataTable.settings, function (i, o) {+ if ( o.nTable === t || o.nScrollHead === t || o.nScrollFoot === t ) {+ is = true;+ }+ } );++ return is;+ };+++ /**+ * Get all DataTable tables that have been initialised - optionally you can+ * select to get only currently visible tables.+ *+ * @param {boolean} [visible=false] Flag to indicate if you want all (default)+ * or visible tables only.+ * @returns {array} Array of `table` nodes (not DataTable instances) which are+ * DataTables+ * @static+ * @dtopt API-Static+ *+ * @example+ * $.each( $.fn.dataTable.tables(true), function () {+ * $(table).DataTable().columns.adjust();+ * } );+ */+ DataTable.tables = DataTable.fnTables = function ( visible )+ {+ return jQuery.map( DataTable.settings, function (o) {+ if ( !visible || (visible && $(o.nTable).is(':visible')) ) {+ return o.nTable;+ }+ } );+ };+++ /**+ * Convert from camel case parameters to Hungarian notation. This is made public+ * for the extensions to provide the same ability as DataTables core to accept+ * either the 1.9 style Hungarian notation, or the 1.10+ style camelCase+ * parameters.+ *+ * @param {object} src The model object which holds all parameters that can be+ * mapped.+ * @param {object} user The object to convert from camel case to Hungarian.+ * @param {boolean} force When set to `true`, properties which already have a+ * Hungarian value in the `user` object will be overwritten. Otherwise they+ * won't be.+ */+ DataTable.camelToHungarian = _fnCamelToHungarian;++++ /**+ *+ */+ _api_register( '$()', function ( selector, opts ) {+ var+ rows = this.rows( opts ).nodes(), // Get all rows+ jqRows = $(rows);++ return $( [].concat(+ jqRows.filter( selector ).toArray(),+ jqRows.find( selector ).toArray()+ ) );+ } );+++ // jQuery functions to operate on the tables+ $.each( [ 'on', 'one', 'off' ], function (i, key) {+ _api_register( key+'()', function ( /* event, handler */ ) {+ var args = Array.prototype.slice.call(arguments);++ // Add the `dt` namespace automatically if it isn't already present+ if ( ! args[0].match(/\.dt\b/) ) {+ args[0] += '.dt';+ }++ var inst = $( this.tables().nodes() );+ inst[key].apply( inst, args );+ return this;+ } );+ } );+++ _api_register( 'clear()', function () {+ return this.iterator( 'table', function ( settings ) {+ _fnClearTable( settings );+ } );+ } );+++ _api_register( 'settings()', function () {+ return new _Api( this.context, this.context );+ } );+++ _api_register( 'data()', function () {+ return this.iterator( 'table', function ( settings ) {+ return _pluck( settings.aoData, '_aData' );+ } ).flatten();+ } );+++ _api_register( 'destroy()', function ( remove ) {+ remove = remove || false;++ return this.iterator( 'table', function ( settings ) {+ var orig = settings.nTableWrapper.parentNode;+ var classes = settings.oClasses;+ var table = settings.nTable;+ var tbody = settings.nTBody;+ var thead = settings.nTHead;+ var tfoot = settings.nTFoot;+ var jqTable = $(table);+ var jqTbody = $(tbody);+ var jqWrapper = $(settings.nTableWrapper);+ var rows = $.map( settings.aoData, function (r) { return r.nTr; } );+ var i, ien;++ // Flag to note that the table is currently being destroyed - no action+ // should be taken+ settings.bDestroying = true;++ // Fire off the destroy callbacks for plug-ins etc+ _fnCallbackFire( settings, "aoDestroyCallback", "destroy", [settings] );++ // If not being removed from the document, make all columns visible+ if ( ! remove ) {+ new _Api( settings ).columns().visible( true );+ }++ // Blitz all `DT` namespaced events (these are internal events, the+ // lowercase, `dt` events are user subscribed and they are responsible+ // for removing them+ jqWrapper.unbind('.DT').find(':not(tbody *)').unbind('.DT');+ $(window).unbind('.DT-'+settings.sInstance);++ // When scrolling we had to break the table up - restore it+ if ( table != thead.parentNode ) {+ jqTable.children('thead').detach();+ jqTable.append( thead );+ }++ if ( tfoot && table != tfoot.parentNode ) {+ jqTable.children('tfoot').detach();+ jqTable.append( tfoot );+ }++ // Remove the DataTables generated nodes, events and classes+ jqTable.detach();+ jqWrapper.detach();++ settings.aaSorting = [];+ settings.aaSortingFixed = [];+ _fnSortingClasses( settings );++ $( rows ).removeClass( settings.asStripeClasses.join(' ') );++ $('th, td', thead).removeClass( classes.sSortable+' '++ classes.sSortableAsc+' '+classes.sSortableDesc+' '+classes.sSortableNone+ );++ if ( settings.bJUI ) {+ $('th span.'+classes.sSortIcon+ ', td span.'+classes.sSortIcon, thead).detach();+ $('th, td', thead).each( function () {+ var wrapper = $('div.'+classes.sSortJUIWrapper, this);+ $(this).append( wrapper.contents() );+ wrapper.detach();+ } );+ }++ if ( ! remove && orig ) {+ // insertBefore acts like appendChild if !arg[1]+ orig.insertBefore( table, settings.nTableReinsertBefore );+ }++ // Add the TR elements back into the table in their original order+ jqTbody.children().detach();+ jqTbody.append( rows );++ // Restore the width of the original table - was read from the style property,+ // so we can restore directly to that+ jqTable+ .css( 'width', settings.sDestroyWidth )+ .removeClass( classes.sTable );++ // If the were originally stripe classes - then we add them back here.+ // Note this is not fool proof (for example if not all rows had stripe+ // classes - but it's a good effort without getting carried away+ ien = settings.asDestroyStripes.length;++ if ( ien ) {+ jqTbody.children().each( function (i) {+ $(this).addClass( settings.asDestroyStripes[i % ien] );+ } );+ }++ /* Remove the settings object from the settings array */+ var idx = $.inArray( settings, DataTable.settings );+ if ( idx !== -1 ) {+ DataTable.settings.splice( idx, 1 );+ }+ } );+ } );+++ /**+ * Version string for plug-ins to check compatibility. Allowed format is+ * `a.b.c-d` where: a:int, b:int, c:int, d:string(dev|beta|alpha). `d` is used+ * only for non-release builds. See http://semver.org/ for more information.+ * @member+ * @type string+ * @default Version number+ */+ DataTable.version = "1.10.2";++ /**+ * Private data store, containing all of the settings objects that are+ * created for the tables on a given page.+ *+ * Note that the `DataTable.settings` object is aliased to+ * `jQuery.fn.dataTableExt` through which it may be accessed and+ * manipulated, or `jQuery.fn.dataTable.settings`.+ * @member+ * @type array+ * @default []+ * @private+ */+ DataTable.settings = [];++ /**+ * 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.+ * @namespace+ */+ DataTable.models = {};++++ /**+ * Template object for the way in which DataTables holds information about+ * search information for the global filter and individual column filters.+ * @namespace+ */+ DataTable.models.oSearch = {+ /**+ * Flag to indicate if the filtering should be case insensitive or not+ * @type boolean+ * @default true+ */+ "bCaseInsensitive": true,++ /**+ * Applied search term+ * @type string+ * @default <i>Empty string</i>+ */+ "sSearch": "",++ /**+ * 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.+ * @type boolean+ * @default false+ */+ "bRegex": false,++ /**+ * Flag to indicate if DataTables is to use its smart filtering or not.+ * @type boolean+ * @default true+ */+ "bSmart": true+ };+++++ /**+ * 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.+ * @namespace+ */+ DataTable.models.oRow = {+ /**+ * TR element for the row+ * @type node+ * @default null+ */+ "nTr": null,++ /**+ * Array of TD elements for each row. This is null until the row has been+ * created.+ * @type array nodes+ * @default []+ */+ "anCells": null,++ /**+ * 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 mData 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.+ * @type array|object+ * @default []+ */+ "_aData": [],++ /**+ * Sorting data cache - this array is ostensibly the same length as the+ * number of columns (although each index is generated only as it is+ * needed), and holds the data that is used for sorting each column in the+ * row. We do this cache generation at the start of the sort in order that+ * the formatting of the sort data need be done only once for each cell+ * per sort. This array should not be read from or written to by anything+ * other than the master sorting methods.+ * @type array+ * @default null+ * @private+ */+ "_aSortData": null,++ /**+ * Per cell filtering data cache. As per the sort data cache, used to+ * increase the performance of the filtering in DataTables+ * @type array+ * @default null+ * @private+ */+ "_aFilterData": null,++ /**+ * Filtering data cache. This is the same as the cell filtering cache, but+ * in this case a string rather than an array. This is easily computed with+ * a join on `_aFilterData`, but is provided as a cache so the join isn't+ * needed on every search (memory traded for performance)+ * @type array+ * @default null+ * @private+ */+ "_sFilterRow": null,++ /**+ * Cache of the class name that DataTables has applied to the row, so we+ * can quickly look at this variable rather than needing to do a DOM check+ * on className for the nTr property.+ * @type string+ * @default <i>Empty string</i>+ * @private+ */+ "_sRowStripe": "",++ /**+ * Denote if the original data source was from the DOM, or the data source+ * object. This is used for invalidating data, so DataTables can+ * automatically read data from the original source, unless uninstructed+ * otherwise.+ * @type string+ * @default null+ * @private+ */+ "src": null+ };+++ /**+ * 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 {@link DataTable.defaults.column}+ * 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+ */+ DataTable.models.oColumn = {+ /**+ * Column index. This could be worked out on-the-fly with $.inArray, but it+ * is faster to just hold it as a variable+ * @type integer+ * @default null+ */+ "idx": null,++ /**+ * 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).+ * @type array+ */+ "aDataSort": null,++ /**+ * 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.+ * @type array+ */+ "asSorting": null,++ /**+ * Flag to indicate if the column is searchable, and thus should be included+ * in the filtering or not.+ * @type boolean+ */+ "bSearchable": null,++ /**+ * Flag to indicate if the column is sortable or not.+ * @type boolean+ */+ "bSortable": null,++ /**+ * Flag to indicate if the column is currently visible in the table or not+ * @type boolean+ */+ "bVisible": null,++ /**+ * Store for manual type assignment using the `column.type` option. This+ * is held in store so we can manipulate the column's `sType` property.+ * @type string+ * @default null+ * @private+ */+ "_sManualType": null,++ /**+ * Flag to indicate if HTML5 data attributes should be used as the data+ * source for filtering or sorting. True is either are.+ * @type boolean+ * @default false+ * @private+ */+ "_bAttrSrc": false,++ /**+ * 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 mRender+ * allowing you to modify the DOM element (add background colour for example) when the+ * element is available.+ * @type function+ * @param {element} nTd The TD node that has been created+ * @param {*} sData The Data for the cell+ * @param {array|object} oData The data for the whole row+ * @param {int} iRow The row index for the aoData data store+ * @default null+ */+ "fnCreatedCell": null,++ /**+ * Function to get data from a cell in a column. You should <b>never</b>+ * access data directly through _aData internally in DataTables - always use+ * the method attached to this property. It allows mData to function as+ * required. This function is automatically assigned by the column+ * initialisation method+ * @type function+ * @param {array|object} oData The data array/object for the array+ * (i.e. aoData[]._aData)+ * @param {string} sSpecific The specific data type you want to get -+ * 'display', 'type' 'filter' 'sort'+ * @returns {*} The data for the cell from the given row's data+ * @default null+ */+ "fnGetData": null,++ /**+ * Function to set data for a cell in the column. You should <b>never</b>+ * set the data directly to _aData internally in DataTables - always use+ * this method. It allows mData to function as required. This function+ * is automatically assigned by the column initialisation method+ * @type function+ * @param {array|object} oData The data array/object for the array+ * (i.e. aoData[]._aData)+ * @param {*} sValue Value to set+ * @default null+ */+ "fnSetData": 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.+ * @type function|int|string|null+ * @default null+ */+ "mData": null,++ /**+ * Partner property to mData which is used (only when defined) to get+ * the data - i.e. it is basically the same as mData, but without the+ * 'set' option, and also the data fed to it is the result from mData.+ * This is the rendering method to match the data method of mData.+ * @type function|int|string|null+ * @default null+ */+ "mRender": null,++ /**+ * Unique header TH/TD element for this column - this is what the sorting+ * listener is attached to (if sorting is enabled.)+ * @type node+ * @default null+ */+ "nTh": null,++ /**+ * 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.+ * @type node+ * @default null+ */+ "nTf": null,++ /**+ * The class to apply to all TD elements in the table's TBODY for the column+ * @type string+ * @default null+ */+ "sClass": null,++ /**+ * 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.+ * @type string+ */+ "sContentPadding": null,++ /**+ * 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 mData+ * is set to null, or because the data source itself is null).+ * @type string+ * @default null+ */+ "sDefaultContent": null,++ /**+ * Name for the column, allowing reference to the column by name as well as+ * by index (needs a lookup to work by name).+ * @type string+ */+ "sName": null,++ /**+ * Custom sorting data type - defines which of the available plug-ins in+ * afnSortData the custom sorting will use - if any is defined.+ * @type string+ * @default std+ */+ "sSortDataType": 'std',++ /**+ * Class to be applied to the header element when sorting on this column+ * @type string+ * @default null+ */+ "sSortingClass": null,++ /**+ * Class to be applied to the header element when sorting on this column -+ * when jQuery UI theming is used.+ * @type string+ * @default null+ */+ "sSortingClassJUI": null,++ /**+ * Title of the column - what is seen in the TH element (nTh).+ * @type string+ */+ "sTitle": null,++ /**+ * Column sorting and filtering type+ * @type string+ * @default null+ */+ "sType": null,++ /**+ * Width of the column+ * @type string+ * @default null+ */+ "sWidth": null,++ /**+ * Width of the column when it was first "encountered"+ * @type string+ * @default null+ */+ "sWidthOrig": null+ };+++ /*+ * Developer note: The properties of the object below are given in Hungarian+ * notation, that was used as the interface for DataTables prior to v1.10, however+ * from v1.10 onwards the primary interface is camel case. In order to avoid+ * breaking backwards compatibility utterly with this change, the Hungarian+ * version is still, internally the primary interface, but is is not documented+ * - hence the @name tags in each doc comment. This allows a Javascript function+ * to create a map from Hungarian notation to camel case (going the other direction+ * would require each property to be listed, which would at around 3K to the size+ * of DataTables, while this method is about a 0.5K hit.+ *+ * Ultimately this does pave the way for Hungarian notation to be dropped+ * completely, but that is a massive amount of work and will break current+ * installs (therefore is on-hold until v2).+ */++ /**+ * Initialisation options that can be given to DataTables at initialisation+ * time.+ * @namespace+ */+ DataTable.defaults = {+ /**+ * 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.+ * @type array+ * @default null+ *+ * @dtopt Option+ * @name DataTable.defaults.data+ *+ * @example+ * // Using a 2D array data source+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "data": [+ * ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],+ * ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],+ * ],+ * "columns": [+ * { "title": "Engine" },+ * { "title": "Browser" },+ * { "title": "Platform" },+ * { "title": "Version" },+ * { "title": "Grade" }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using an array of objects as a data source (`data`)+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "data": [+ * {+ * "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"+ * }+ * ],+ * "columns": [+ * { "title": "Engine", "data": "engine" },+ * { "title": "Browser", "data": "browser" },+ * { "title": "Platform", "data": "platform" },+ * { "title": "Version", "data": "version" },+ * { "title": "Grade", "data": "grade" }+ * ]+ * } );+ * } );+ */+ "aaData": null,+++ /**+ * If ordering 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 `sorting` array+ * should contain an array for each column to be sorted initially containing+ * the column's index and a direction string ('asc' or 'desc').+ * @type array+ * @default [[0,'asc']]+ *+ * @dtopt Option+ * @name DataTable.defaults.order+ *+ * @example+ * // Sort by 3rd column first, and then 4th column+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "order": [[2,'asc'], [3,'desc']]+ * } );+ * } );+ *+ * // No initial sorting+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "order": []+ * } );+ * } );+ */+ "aaSorting": [[0,'asc']],+++ /**+ * This parameter is basically identical to the `sorting` 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.+ * @type array+ * @default null+ *+ * @dtopt Option+ * @name DataTable.defaults.orderFixed+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "orderFixed": [[0,'asc']]+ * } );+ * } )+ */+ "aaSortingFixed": [],+++ /**+ * DataTables can be instructed to load data to display in the table from a+ * Ajax source. This option defines how that Ajax call is made and where to.+ *+ * The `ajax` property has three different modes of operation, depending on+ * how it is defined. These are:+ *+ * * `string` - Set the URL from where the data should be loaded from.+ * * `object` - Define properties for `jQuery.ajax`.+ * * `function` - Custom data get function+ *+ * `string`+ * --------+ *+ * As a string, the `ajax` property simply defines the URL from which+ * DataTables will load data.+ *+ * `object`+ * --------+ *+ * As an object, the parameters in the object are passed to+ * [jQuery.ajax](http://api.jquery.com/jQuery.ajax/) allowing fine control+ * of the Ajax request. DataTables has a number of default parameters which+ * you can override using this option. Please refer to the jQuery+ * documentation for a full description of the options available, although+ * the following parameters provide additional options in DataTables or+ * require special consideration:+ *+ * * `data` - As with jQuery, `data` can be provided as an object, but it+ * can also be used as a function to manipulate the data DataTables sends+ * to the server. The function takes a single parameter, an object of+ * parameters with the values that DataTables has readied for sending. An+ * object may be returned which will be merged into the DataTables+ * defaults, or you can add the items to the object that was passed in and+ * not return anything from the function. This supersedes `fnServerParams`+ * from DataTables 1.9-.+ *+ * * `dataSrc` - By default DataTables will look for the property `data` (or+ * `aaData` for compatibility with DataTables 1.9-) 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, or+ * it my be used as a function. As a function it takes a single parameter,+ * the JSON returned from the server, which can be manipulated as+ * required, with the returned value being that used by DataTables as the+ * data source for the table. This supersedes `sAjaxDataProp` from+ * DataTables 1.9-.+ *+ * * `success` - Should not be overridden it is used internally in+ * DataTables. To manipulate / transform the data returned by the server+ * use `ajax.dataSrc`, or use `ajax` as a function (see below).+ *+ * `function`+ * ----------+ *+ * As a function, making the Ajax call is left up to yourself allowing+ * complete control of the Ajax request. Indeed, if desired, a method other+ * than Ajax could be used to obtain the required data, such as Web storage+ * or an AIR database.+ *+ * The function is given four parameters and no return is required. The+ * parameters are:+ *+ * 1. _object_ - Data to send to the server+ * 2. _function_ - Callback function that must be executed when the required+ * data has been obtained. That data should be passed into the callback+ * as the only parameter+ * 3. _object_ - DataTables settings object for the table+ *+ * Note that this supersedes `fnServerData` from DataTables 1.9-.+ *+ * @type string|object|function+ * @default null+ *+ * @dtopt Option+ * @name DataTable.defaults.ajax+ * @since 1.10.0+ *+ * @example+ * // Get JSON data from a file via Ajax.+ * // Note DataTables expects data in the form `{ data: [ ...data... ] }` by default).+ * $('#example').dataTable( {+ * "ajax": "data.json"+ * } );+ *+ * @example+ * // Get JSON data from a file via Ajax, using `dataSrc` to change+ * // `data` to `tableData` (i.e. `{ tableData: [ ...data... ] }`)+ * $('#example').dataTable( {+ * "ajax": {+ * "url": "data.json",+ * "dataSrc": "tableData"+ * }+ * } );+ *+ * @example+ * // Get JSON data from a file via Ajax, using `dataSrc` to read data+ * // from a plain array rather than an array in an object+ * $('#example').dataTable( {+ * "ajax": {+ * "url": "data.json",+ * "dataSrc": ""+ * }+ * } );+ *+ * @example+ * // Manipulate the data returned from the server - add a link to data+ * // (note this can, should, be done using `render` for the column - this+ * // is just a simple example of how the data can be manipulated).+ * $('#example').dataTable( {+ * "ajax": {+ * "url": "data.json",+ * "dataSrc": function ( json ) {+ * for ( var i=0, ien=json.length ; i<ien ; i++ ) {+ * json[i][0] = '<a href="/message/'+json[i][0]+'>View message</a>';+ * }+ * return json;+ * }+ * }+ * } );+ *+ * @example+ * // Add data to the request+ * $('#example').dataTable( {+ * "ajax": {+ * "url": "data.json",+ * "data": function ( d ) {+ * return {+ * "extra_search": $('#extra').val()+ * };+ * }+ * }+ * } );+ *+ * @example+ * // Send request as POST+ * $('#example').dataTable( {+ * "ajax": {+ * "url": "data.json",+ * "type": "POST"+ * }+ * } );+ *+ * @example+ * // Get the data from localStorage (could interface with a form for+ * // adding, editing and removing rows).+ * $('#example').dataTable( {+ * "ajax": function (data, callback, settings) {+ * callback(+ * JSON.parse( localStorage.getItem('dataTablesData') )+ * );+ * }+ * } );+ */+ "ajax": null,+++ /**+ * 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').+ *+ * Note that the `pageLength` property will be automatically set to the+ * first value given in this array, unless `pageLength` is also provided.+ * @type array+ * @default [ 10, 25, 50, 100 ]+ *+ * @dtopt Option+ * @name DataTable.defaults.lengthMenu+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "lengthMenu": [[10, 25, 50, -1], [10, 25, 50, "All"]]+ * } );+ * } );+ */+ "aLengthMenu": [ 10, 25, 50, 100 ],+++ /**+ * The `columns` 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+ * {@link DataTable.defaults.column}. Note that if you use `columns` 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).+ * @member+ *+ * @name DataTable.defaults.column+ */+ "aoColumns": null,++ /**+ * Very similar to `columns`, `columnDefs` allows you to target a specific+ * column, multiple columns, or all columns, using the `targets` property of+ * each object in the array. This allows great flexibility when creating+ * tables, as the `columnDefs` arrays can be of any length, targeting the+ * columns you specifically want. `columnDefs` may use any of the column+ * options available: {@link DataTable.defaults.column}, but it _must_+ * have `targets` defined in each object in the array. Values in the `targets`+ * array may be:+ * <ul>+ * <li>a string - class name will be matched on the TH for the column</li>+ * <li>0 or a positive integer - column index counting from the left</li>+ * <li>a negative integer - column index counting from the right</li>+ * <li>the string "_all" - all columns (i.e. assign a default)</li>+ * </ul>+ * @member+ *+ * @name DataTable.defaults.columnDefs+ */+ "aoColumnDefs": null,+++ /**+ * Basically the same as `search`, 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+ * `search` and `escapeRegex` (the latter is optional). 'null' is also+ * accepted and the default will be used.+ * @type array+ * @default []+ *+ * @dtopt Option+ * @name DataTable.defaults.searchCols+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "searchCols": [+ * null,+ * { "search": "My filter" },+ * null,+ * { "search": "^[0-9]", "escapeRegex": false }+ * ]+ * } );+ * } )+ */+ "aoSearchCols": [],+++ /**+ * 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.+ * @type array+ * @default null <i>Will take the values determined by the `oClasses.stripe*`+ * options</i>+ *+ * @dtopt Option+ * @name DataTable.defaults.stripeClasses+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stripeClasses": [ 'strip1', 'strip2', 'strip3' ]+ * } );+ * } )+ */+ "asStripeClasses": null,+++ /**+ * 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 `columns`.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.autoWidth+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "autoWidth": false+ * } );+ * } );+ */+ "bAutoWidth": true,+++ /**+ * 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.+ * @type boolean+ * @default false+ *+ * @dtopt Features+ * @name DataTable.defaults.deferRender+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "ajax": "sources/arrays.txt",+ * "deferRender": true+ * } );+ * } );+ */+ "bDeferRender": false,+++ /**+ * 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.+ * @type boolean+ * @default false+ *+ * @dtopt Options+ * @name DataTable.defaults.destroy+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "srollY": "200px",+ * "paginate": false+ * } );+ *+ * // Some time later....+ * $('#example').dataTable( {+ * "filter": false,+ * "destroy": true+ * } );+ * } );+ */+ "bDestroy": false,+++ /**+ * 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+ * {@link DataTable.defaults.dom}.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.searching+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "searching": false+ * } );+ * } );+ */+ "bFilter": true,+++ /**+ * 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.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.info+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "info": false+ * } );+ * } );+ */+ "bInfo": true,+++ /**+ * Enable jQuery UI ThemeRoller support (required as ThemeRoller requires some+ * slightly different and additional mark-up from what DataTables has+ * traditionally used).+ * @type boolean+ * @default false+ *+ * @dtopt Features+ * @name DataTable.defaults.jQueryUI+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "jQueryUI": true+ * } );+ * } );+ */+ "bJQueryUI": false,+++ /**+ * 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 (`paginate`).+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.lengthChange+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "lengthChange": false+ * } );+ * } );+ */+ "bLengthChange": true,+++ /**+ * Enable or disable pagination.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.paging+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "paging": false+ * } );+ * } );+ */+ "bPaginate": true,+++ /**+ * 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.+ * @type boolean+ * @default false+ *+ * @dtopt Features+ * @name DataTable.defaults.processing+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "processing": true+ * } );+ * } );+ */+ "bProcessing": false,+++ /**+ * 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). `destroy` can be used to reinitialise a table if+ * you need.+ * @type boolean+ * @default false+ *+ * @dtopt Options+ * @name DataTable.defaults.retrieve+ *+ * @example+ * $(document).ready( function() {+ * initTable();+ * tableActions();+ * } );+ *+ * function initTable ()+ * {+ * return $('#example').dataTable( {+ * "scrollY": "200px",+ * "paginate": false,+ * "retrieve": true+ * } );+ * }+ *+ * function tableActions ()+ * {+ * var table = initTable();+ * // perform API operations with oTable+ * }+ */+ "bRetrieve": false,+++ /**+ * 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.+ * @type boolean+ * @default false+ *+ * @dtopt Options+ * @name DataTable.defaults.scrollCollapse+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "scrollY": "200",+ * "scrollCollapse": true+ * } );+ * } );+ */+ "bScrollCollapse": false,+++ /**+ * Configure DataTables to use server-side processing. Note that the+ * `ajax` parameter must also be given in order to give DataTables a+ * source to obtain the required data for each draw.+ * @type boolean+ * @default false+ *+ * @dtopt Features+ * @dtopt Server-side+ * @name DataTable.defaults.serverSide+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "serverSide": true,+ * "ajax": "xhr.php"+ * } );+ * } );+ */+ "bServerSide": false,+++ /**+ * Enable or disable sorting of columns. Sorting of individual columns can be+ * disabled by the `sortable` option for each column.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.ordering+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "ordering": false+ * } );+ * } );+ */+ "bSort": true,+++ /**+ * Enable or display DataTables' ability to sort multiple columns at the+ * same time (activated by shift-click by the user).+ * @type boolean+ * @default true+ *+ * @dtopt Options+ * @name DataTable.defaults.orderMulti+ *+ * @example+ * // Disable multiple column sorting ability+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "orderMulti": false+ * } );+ * } );+ */+ "bSortMulti": true,+++ /**+ * 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.+ * @type boolean+ * @default false+ *+ * @dtopt Options+ * @name DataTable.defaults.orderCellsTop+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "orderCellsTop": true+ * } );+ * } );+ */+ "bSortCellsTop": false,+++ /**+ * 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.+ * @type boolean+ * @default true+ *+ * @dtopt Features+ * @name DataTable.defaults.orderClasses+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "orderClasses": false+ * } );+ * } );+ */+ "bSortClasses": true,+++ /**+ * Enable or disable state saving. When enabled HTML5 `localStorage` 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.+ *+ * Due to the use of `localStorage` the default state saving is not supported+ * in IE6 or 7. If state saving is required in those browsers, use+ * `stateSaveCallback` to provide a storage solution such as cookies.+ * @type boolean+ * @default false+ *+ * @dtopt Features+ * @name DataTable.defaults.stateSave+ *+ * @example+ * $(document).ready( function () {+ * $('#example').dataTable( {+ * "stateSave": true+ * } );+ * } );+ */+ "bStateSave": false,+++ /**+ * 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).+ * @type function+ * @param {node} row "TR" element for the current row+ * @param {array} data Raw data array for this row+ * @param {int} dataIndex The index of this row in the internal aoData array+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.createdRow+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "createdRow": function( row, data, dataIndex ) {+ * // Bold the grade for all 'A' grade browsers+ * if ( data[4] == "A" )+ * {+ * $('td:eq(4)', row).html( '<b>A</b>' );+ * }+ * }+ * } );+ * } );+ */+ "fnCreatedRow": null,+++ /**+ * This function is called on every 'draw' event, and allows you to+ * dynamically modify any aspect you want about the created DOM.+ * @type function+ * @param {object} settings DataTables settings object+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.drawCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "drawCallback": function( settings ) {+ * alert( 'DataTables has redrawn the table' );+ * }+ * } );+ * } );+ */+ "fnDrawCallback": null,+++ /**+ * Identical to fnHeaderCallback() but for the table footer this function+ * allows you to modify the table footer on every 'draw' event.+ * @type function+ * @param {node} foot "TR" element for the footer+ * @param {array} data Full table data (as derived from the original HTML)+ * @param {int} start Index for the current display starting point in the+ * display array+ * @param {int} end Index for the current display ending point in the+ * display array+ * @param {array int} display Index array to translate the visual position+ * to the full data array+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.footerCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "footerCallback": function( tfoot, data, start, end, display ) {+ * tfoot.getElementsByTagName('th')[0].innerHTML = "Starting index is "+start;+ * }+ * } );+ * } )+ */+ "fnFooterCallback": null,+++ /**+ * 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.+ * @type function+ * @member+ * @param {int} toFormat number to be formatted+ * @returns {string} formatted string for DataTables to show the number+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.formatNumber+ *+ * @example+ * // Format a number using a single quote for the separator (note that+ * // this can also be done with the language.thousands option)+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "formatNumber": function ( toFormat ) {+ * return toFormat.toString().replace(+ * /\B(?=(\d{3})+(?!\d))/g, "'"+ * );+ * };+ * } );+ * } );+ */+ "fnFormatNumber": function ( toFormat ) {+ return toFormat.toString().replace(+ /\B(?=(\d{3})+(?!\d))/g,+ this.oLanguage.sThousands+ );+ },+++ /**+ * 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.+ * @type function+ * @param {node} head "TR" element for the header+ * @param {array} data Full table data (as derived from the original HTML)+ * @param {int} start Index for the current display starting point in the+ * display array+ * @param {int} end Index for the current display ending point in the+ * display array+ * @param {array int} display Index array to translate the visual position+ * to the full data array+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.headerCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "fheaderCallback": function( head, data, start, end, display ) {+ * head.getElementsByTagName('th')[0].innerHTML = "Displaying "+(end-start)+" records";+ * }+ * } );+ * } )+ */+ "fnHeaderCallback": null,+++ /**+ * 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.+ * @type function+ * @param {object} oSettings DataTables settings object+ * @param {int} start Starting position in data for the draw+ * @param {int} end End position in data for the draw+ * @param {int} max Total number of rows in the table (regardless of+ * filtering)+ * @param {int} total Total number of rows in the data set, after filtering+ * @param {string} pre The string that DataTables has formatted using it's+ * own rules+ * @returns {string} The string to be displayed in the information element.+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.infoCallback+ *+ * @example+ * $('#example').dataTable( {+ * "infoCallback": function( settings, start, end, max, total, pre ) {+ * return start +" to "+ end;+ * }+ * } );+ */+ "fnInfoCallback": null,+++ /**+ * 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.+ * @type function+ * @param {object} settings DataTables settings object+ * @param {object} json The JSON object request from the server - only+ * present if client-side Ajax sourced data is used+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.initComplete+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "initComplete": function(settings, json) {+ * alert( 'DataTables has finished its initialisation.' );+ * }+ * } );+ * } )+ */+ "fnInitComplete": null,+++ /**+ * 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).+ * @type function+ * @param {object} settings DataTables settings object+ * @returns {boolean} False will cancel the draw, anything else (including no+ * return) will allow it to complete.+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.preDrawCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "preDrawCallback": function( settings ) {+ * if ( $('#test').val() == 1 ) {+ * return false;+ * }+ * }+ * } );+ * } );+ */+ "fnPreDrawCallback": null,+++ /**+ * 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.+ * @type function+ * @param {node} row "TR" element for the current row+ * @param {array} data Raw data array for this row+ * @param {int} displayIndex The display index for the current table draw+ * @param {int} displayIndexFull The index of the data in the full list of+ * rows (after filtering)+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.rowCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "rowCallback": function( row, data, displayIndex, displayIndexFull ) {+ * // Bold the grade for all 'A' grade browsers+ * if ( data[4] == "A" ) {+ * $('td:eq(4)', row).html( '<b>A</b>' );+ * }+ * }+ * } );+ * } );+ */+ "fnRowCallback": null,+++ /**+ * __Deprecated__ The functionality provided by this parameter has now been+ * superseded by that provided through `ajax`, which should be used instead.+ *+ * This parameter allows you to override the default function which obtains+ * the data from the server so something more suitable for your application.+ * For example you could use POST data, or pull information from a Gears or+ * AIR database.+ * @type function+ * @member+ * @param {string} source HTTP source to obtain the data from (`ajax`)+ * @param {array} data A key/value pair object containing the data to send+ * to the server+ * @param {function} callback to be called on completion of the data get+ * process that will draw the data on the page.+ * @param {object} settings DataTables settings object+ *+ * @dtopt Callbacks+ * @dtopt Server-side+ * @name DataTable.defaults.serverData+ *+ * @deprecated 1.10. Please use `ajax` for this functionality now.+ */+ "fnServerData": null,+++ /**+ * __Deprecated__ The functionality provided by this parameter has now been+ * superseded by that provided through `ajax`, which should be used instead.+ *+ * 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.+ * @type function+ * @param {array} data 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 {undefined} Ensure that you modify the data array passed in,+ * as this is passed by reference.+ *+ * @dtopt Callbacks+ * @dtopt Server-side+ * @name DataTable.defaults.serverParams+ *+ * @deprecated 1.10. Please use `ajax` for this functionality now.+ */+ "fnServerParams": null,+++ /**+ * 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 `localStorage`+ * but you might wish to use a server-side database or cookies.+ * @type function+ * @member+ * @param {object} settings DataTables settings object+ * @return {object} The DataTables state object to be loaded+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.stateLoadCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateLoadCallback": function (settings) {+ * 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;+ * }+ * } );+ * } );+ */+ "fnStateLoadCallback": function ( settings ) {+ try {+ return JSON.parse(+ (settings.iStateDuration === -1 ? sessionStorage : localStorage).getItem(+ 'DataTables_'+settings.sInstance+'_'+location.pathname+ )+ );+ } catch (e) {}+ },+++ /**+ * 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.+ * @type function+ * @param {object} settings DataTables settings object+ * @param {object} data The state object that is to be loaded+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.stateLoadParams+ *+ * @example+ * // Remove a saved filter, so filtering is never loaded+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateLoadParams": function (settings, data) {+ * data.oSearch.sSearch = "";+ * }+ * } );+ * } );+ *+ * @example+ * // Disallow state loading by returning false+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateLoadParams": function (settings, data) {+ * return false;+ * }+ * } );+ * } );+ */+ "fnStateLoadParams": null,+++ /**+ * 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.+ * @type function+ * @param {object} settings DataTables settings object+ * @param {object} data The state object that was loaded+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.stateLoaded+ *+ * @example+ * // Show an alert with the filtering value that was saved+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateLoaded": function (settings, data) {+ * alert( 'Saved filter was: '+data.oSearch.sSearch );+ * }+ * } );+ * } );+ */+ "fnStateLoaded": null,+++ /**+ * Save the table state. This function allows you to define where and how the state+ * information for the table is stored By default DataTables will use `localStorage`+ * but you might wish to use a server-side database or cookies.+ * @type function+ * @member+ * @param {object} settings DataTables settings object+ * @param {object} data The state object to be saved+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.stateSaveCallback+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateSaveCallback": function (settings, data) {+ * // Send an Ajax request to the server with the state object+ * $.ajax( {+ * "url": "/state_save",+ * "data": data,+ * "dataType": "json",+ * "method": "POST"+ * "success": function () {}+ * } );+ * }+ * } );+ * } );+ */+ "fnStateSaveCallback": function ( settings, data ) {+ try {+ (settings.iStateDuration === -1 ? sessionStorage : localStorage).setItem(+ 'DataTables_'+settings.sInstance+'_'+location.pathname,+ JSON.stringify( data )+ );+ } catch (e) {}+ },+++ /**+ * 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.+ * @type function+ * @param {object} settings DataTables settings object+ * @param {object} data The state object to be saved+ *+ * @dtopt Callbacks+ * @name DataTable.defaults.stateSaveParams+ *+ * @example+ * // Remove a saved filter, so filtering is never saved+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateSave": true,+ * "stateSaveParams": function (settings, data) {+ * data.oSearch.sSearch = "";+ * }+ * } );+ * } );+ */+ "fnStateSaveParams": null,+++ /**+ * Duration for which the saved state information is considered valid. After this period+ * has elapsed the state will be returned to the default.+ * Value is given in seconds.+ * @type int+ * @default 7200 <i>(2 hours)</i>+ *+ * @dtopt Options+ * @name DataTable.defaults.stateDuration+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "stateDuration": 60*60*24; // 1 day+ * } );+ * } )+ */+ "iStateDuration": 7200,+++ /**+ * 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. `deferLoading`+ * 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).+ * @type int | array+ * @default null+ *+ * @dtopt Options+ * @name DataTable.defaults.deferLoading+ *+ * @example+ * // 57 records available in the table, no filtering applied+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "serverSide": true,+ * "ajax": "scripts/server_processing.php",+ * "deferLoading": 57+ * } );+ * } );+ *+ * @example+ * // 57 records after filtering, 100 without filtering (an initial filter applied)+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "serverSide": true,+ * "ajax": "scripts/server_processing.php",+ * "deferLoading": [ 57, 100 ],+ * "search": {+ * "search": "my_filter"+ * }+ * } );+ * } );+ */+ "iDeferLoading": null,+++ /**+ * Number of rows to display on a single page when using pagination. If+ * feature enabled (`lengthChange`) then the end user will be able to override+ * this to a custom setting using a pop-up menu.+ * @type int+ * @default 10+ *+ * @dtopt Options+ * @name DataTable.defaults.pageLength+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "pageLength": 50+ * } );+ * } )+ */+ "iDisplayLength": 10,+++ /**+ * 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".+ * @type int+ * @default 0+ *+ * @dtopt Options+ * @name DataTable.defaults.displayStart+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "displayStart": 20+ * } );+ * } )+ */+ "iDisplayStart": 0,+++ /**+ * 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.+ * @type int+ * @default 0+ *+ * @dtopt Options+ * @name DataTable.defaults.tabIndex+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "tabIndex": 1+ * } );+ * } );+ */+ "iTabIndex": 0,+++ /**+ * Classes that DataTables assigns to the various components and features+ * that it adds to the HTML table. This allows classes to be configured+ * during initialisation in addition to through the static+ * {@link DataTable.ext.oStdClasses} object).+ * @namespace+ * @name DataTable.defaults.classes+ */+ "oClasses": {},+++ /**+ * 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.+ * @namespace+ * @name DataTable.defaults.language+ */+ "oLanguage": {+ /**+ * 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).+ * @namespace+ * @name DataTable.defaults.language.aria+ */+ "oAria": {+ /**+ * 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.+ * @type string+ * @default : activate to sort column ascending+ *+ * @dtopt Language+ * @name DataTable.defaults.language.aria.sortAscending+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "aria": {+ * "sortAscending": " - click/return to sort ascending"+ * }+ * }+ * } );+ * } );+ */+ "sSortAscending": ": activate to sort column ascending",++ /**+ * 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.+ * @type string+ * @default : activate to sort column ascending+ *+ * @dtopt Language+ * @name DataTable.defaults.language.aria.sortDescending+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "aria": {+ * "sortDescending": " - click/return to sort descending"+ * }+ * }+ * } );+ * } );+ */+ "sSortDescending": ": activate to sort column descending"+ },++ /**+ * Pagination string used by DataTables for the built-in pagination+ * control types.+ * @namespace+ * @name DataTable.defaults.language.paginate+ */+ "oPaginate": {+ /**+ * Text to use when using the 'full_numbers' type of pagination for the+ * button to take the user to the first page.+ * @type string+ * @default First+ *+ * @dtopt Language+ * @name DataTable.defaults.language.paginate.first+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "paginate": {+ * "first": "First page"+ * }+ * }+ * } );+ * } );+ */+ "sFirst": "First",+++ /**+ * Text to use when using the 'full_numbers' type of pagination for the+ * button to take the user to the last page.+ * @type string+ * @default Last+ *+ * @dtopt Language+ * @name DataTable.defaults.language.paginate.last+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "paginate": {+ * "last": "Last page"+ * }+ * }+ * } );+ * } );+ */+ "sLast": "Last",+++ /**+ * Text to use for the 'next' pagination button (to take the user to the+ * next page).+ * @type string+ * @default Next+ *+ * @dtopt Language+ * @name DataTable.defaults.language.paginate.next+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "paginate": {+ * "next": "Next page"+ * }+ * }+ * } );+ * } );+ */+ "sNext": "Next",+++ /**+ * Text to use for the 'previous' pagination button (to take the user to+ * the previous page).+ * @type string+ * @default Previous+ *+ * @dtopt Language+ * @name DataTable.defaults.language.paginate.previous+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "paginate": {+ * "previous": "Previous page"+ * }+ * }+ * } );+ * } );+ */+ "sPrevious": "Previous"+ },++ /**+ * This string is shown in preference to `zeroRecords` 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 `zeroRecords` will be used+ * instead (either the default or given value).+ * @type string+ * @default No data available in table+ *+ * @dtopt Language+ * @name DataTable.defaults.language.emptyTable+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "emptyTable": "No data available in table"+ * }+ * } );+ * } );+ */+ "sEmptyTable": "No data available in table",+++ /**+ * This string gives information to the end user about the information+ * that is current on display on the page. The following tokens can be+ * used in the string and will be dynamically replaced as the table+ * display updates. This tokens can be placed anywhere in the string, or+ * removed as needed by the language requires:+ *+ * * `\_START\_` - Display index of the first record on the current page+ * * `\_END\_` - Display index of the last record on the current page+ * * `\_TOTAL\_` - Number of records in the table after filtering+ * * `\_MAX\_` - Number of records in the table without filtering+ * * `\_PAGE\_` - Current page number+ * * `\_PAGES\_` - Total number of pages of data in the table+ *+ * @type string+ * @default Showing _START_ to _END_ of _TOTAL_ entries+ *+ * @dtopt Language+ * @name DataTable.defaults.language.info+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "info": "Showing page _PAGE_ of _PAGES_"+ * }+ * } );+ * } );+ */+ "sInfo": "Showing _START_ to _END_ of _TOTAL_ entries",+++ /**+ * Display information string for when the table is empty. Typically the+ * format of this string should match `info`.+ * @type string+ * @default Showing 0 to 0 of 0 entries+ *+ * @dtopt Language+ * @name DataTable.defaults.language.infoEmpty+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "infoEmpty": "No entries to show"+ * }+ * } );+ * } );+ */+ "sInfoEmpty": "Showing 0 to 0 of 0 entries",+++ /**+ * When a user filters the information in a table, this string is appended+ * to the information (`info`) to give an idea of how strong the filtering+ * is. The variable _MAX_ is dynamically updated.+ * @type string+ * @default (filtered from _MAX_ total entries)+ *+ * @dtopt Language+ * @name DataTable.defaults.language.infoFiltered+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "infoFiltered": " - filtering from _MAX_ records"+ * }+ * } );+ * } );+ */+ "sInfoFiltered": "(filtered from _MAX_ total entries)",+++ /**+ * 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 `info` (`infoEmpty` and `infoFiltered` in whatever combination they are+ * being used) at all times.+ * @type string+ * @default <i>Empty string</i>+ *+ * @dtopt Language+ * @name DataTable.defaults.language.infoPostFix+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "infoPostFix": "All records shown are derived from real information."+ * }+ * } );+ * } );+ */+ "sInfoPostFix": "",+++ /**+ * This decimal place operator is a little different from the other+ * language options since DataTables doesn't output floating point+ * numbers, so it won't ever use this for display of a number. Rather,+ * what this parameter does is modify the sort methods of the table so+ * that numbers which are in a format which has a character other than+ * a period (`.`) as a decimal place will be sorted numerically.+ *+ * Note that numbers with different decimal places cannot be shown in+ * the same table and still be sortable, the table must be consistent.+ * However, multiple different tables on the page can use different+ * decimal place characters.+ * @type string+ * @default+ *+ * @dtopt Language+ * @name DataTable.defaults.language.decimal+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "decimal": ","+ * "thousands": "."+ * }+ * } );+ * } );+ */+ "sDecimal": "",+++ /**+ * DataTables has a build in number formatter (`formatNumber`) 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.+ * @type string+ * @default ,+ *+ * @dtopt Language+ * @name DataTable.defaults.language.thousands+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "thousands": "'"+ * }+ * } );+ * } );+ */+ "sThousands": ",",+++ /**+ * 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.+ * @type string+ * @default Show _MENU_ entries+ *+ * @dtopt Language+ * @name DataTable.defaults.language.lengthMenu+ *+ * @example+ * // Language change only+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "lengthMenu": "Display _MENU_ records"+ * }+ * } );+ * } );+ *+ * @example+ * // Language and options change+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "lengthMenu": 'Display <select>'++ * '<option value="10">10</option>'++ * '<option value="20">20</option>'++ * '<option value="30">30</option>'++ * '<option value="40">40</option>'++ * '<option value="50">50</option>'++ * '<option value="-1">All</option>'++ * '</select> records'+ * }+ * } );+ * } );+ */+ "sLengthMenu": "Show _MENU_ entries",+++ /**+ * 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.+ * @type string+ * @default Loading...+ *+ * @dtopt Language+ * @name DataTable.defaults.language.loadingRecords+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "loadingRecords": "Please wait - loading..."+ * }+ * } );+ * } );+ */+ "sLoadingRecords": "Loading...",+++ /**+ * Text which is displayed when the table is processing a user action+ * (usually a sort command or similar).+ * @type string+ * @default Processing...+ *+ * @dtopt Language+ * @name DataTable.defaults.language.processing+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "processing": "DataTables is currently busy"+ * }+ * } );+ * } );+ */+ "sProcessing": "Processing...",+++ /**+ * 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.+ * @type string+ * @default Search:+ *+ * @dtopt Language+ * @name DataTable.defaults.language.search+ *+ * @example+ * // Input text box will be appended at the end automatically+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "search": "Filter records:"+ * }+ * } );+ * } );+ *+ * @example+ * // Specify where the filter should appear+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "search": "Apply filter _INPUT_ to table"+ * }+ * } );+ * } );+ */+ "sSearch": "Search:",+++ /**+ * Assign a `placeholder` attribute to the search `input` element+ * @type string+ * @default+ *+ * @dtopt Language+ * @name DataTable.defaults.language.searchPlaceholder+ */+ "sSearchPlaceholder": "",+++ /**+ * 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.+ * @type string+ * @default <i>Empty string - i.e. disabled</i>+ *+ * @dtopt Language+ * @name DataTable.defaults.language.url+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "url": "http://www.sprymedia.co.uk/dataTables/lang.txt"+ * }+ * } );+ * } );+ */+ "sUrl": "",+++ /**+ * Text shown inside the table records when the is no information to be+ * displayed after filtering. `emptyTable` is shown when there is simply no+ * information in the table at all (regardless of filtering).+ * @type string+ * @default No matching records found+ *+ * @dtopt Language+ * @name DataTable.defaults.language.zeroRecords+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "language": {+ * "zeroRecords": "No records to display"+ * }+ * } );+ * } );+ */+ "sZeroRecords": "No matching records found"+ },+++ /**+ * This parameter allows you to have define the global filtering state at+ * initialisation time. As an object the `search` parameter must be+ * defined, but all other parameters are optional. When `regex` is true,+ * the search string will be treated as a regular expression, when false+ * (default) it will be treated as a straight string. When `smart`+ * DataTables will use it's smart filtering methods (to word match at+ * any point in the data), when false this will not be done.+ * @namespace+ * @extends DataTable.models.oSearch+ *+ * @dtopt Options+ * @name DataTable.defaults.search+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "search": {"search": "Initial search"}+ * } );+ * } )+ */+ "oSearch": $.extend( {}, DataTable.models.oSearch ),+++ /**+ * __Deprecated__ The functionality provided by this parameter has now been+ * superseded by that provided through `ajax`, which should be used instead.+ *+ * By default DataTables will look for the property `data` (or `aaData` for+ * compatibility with DataTables 1.9-) 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.+ * @type string+ * @default data+ *+ * @dtopt Options+ * @dtopt Server-side+ * @name DataTable.defaults.ajaxDataProp+ *+ * @deprecated 1.10. Please use `ajax` for this functionality now.+ */+ "sAjaxDataProp": "data",+++ /**+ * __Deprecated__ The functionality provided by this parameter has now been+ * superseded by that provided through `ajax`, which should be used instead.+ *+ * 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.+ * @type string+ * @default null+ *+ * @dtopt Options+ * @dtopt Server-side+ * @name DataTable.defaults.ajaxSource+ *+ * @deprecated 1.10. Please use `ajax` for this functionality now.+ */+ "sAjaxSource": null,+++ /**+ * 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:+ * <ul>+ * <li>The following options are allowed:+ * <ul>+ * <li>'l' - Length changing</li>+ * <li>'f' - Filtering input</li>+ * <li>'t' - The table!</li>+ * <li>'i' - Information</li>+ * <li>'p' - Pagination</li>+ * <li>'r' - pRocessing</li>+ * </ul>+ * </li>+ * <li>The following constants are allowed:+ * <ul>+ * <li>'H' - jQueryUI theme "header" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>+ * <li>'F' - jQueryUI theme "footer" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>+ * </ul>+ * </li>+ * <li>The following syntax is expected:+ * <ul>+ * <li>'<' and '>' - div elements</li>+ * <li>'<"class" and '>' - div with a class</li>+ * <li>'<"#id" and '>' - div with an ID</li>+ * </ul>+ * </li>+ * <li>Examples:+ * <ul>+ * <li>'<"wrapper"flipt>'</li>+ * <li>'<lf<t>ip>'</li>+ * </ul>+ * </li>+ * </ul>+ * @type string+ * @default lfrtip <i>(when `jQueryUI` is false)</i> <b>or</b>+ * <"H"lfr>t<"F"ip> <i>(when `jQueryUI` is true)</i>+ *+ * @dtopt Options+ * @name DataTable.defaults.dom+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "dom": '<"top"i>rt<"bottom"flp><"clear">'+ * } );+ * } );+ */+ "sDom": "lfrtip",+++ /**+ * DataTables features four different built-in options for the buttons to+ * display for pagination control:+ *+ * * `simple` - 'Previous' and 'Next' buttons only+ * * 'simple_numbers` - 'Previous' and 'Next' buttons, plus page numbers+ * * `full` - 'First', 'Previous', 'Next' and 'Last' buttons+ * * `full_numbers` - 'First', 'Previous', 'Next' and 'Last' buttons, plus+ * page numbers+ *+ * Further methods can be added using {@link DataTable.ext.oPagination}.+ * @type string+ * @default simple_numbers+ *+ * @dtopt Options+ * @name DataTable.defaults.pagingType+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "pagingType": "full_numbers"+ * } );+ * } )+ */+ "sPaginationType": "simple_numbers",+++ /**+ * 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 `true` which will allow the table to+ * scroll horizontally when needed, or any CSS unit, or a number (in which+ * case it will be treated as a pixel measurement). Setting as simply `true`+ * is recommended.+ * @type boolean|string+ * @default <i>blank string - i.e. disabled</i>+ *+ * @dtopt Features+ * @name DataTable.defaults.scrollX+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "scrollX": true,+ * "scrollCollapse": true+ * } );+ * } );+ */+ "sScrollX": "",+++ /**+ * 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).+ * @type string+ * @default <i>blank string - i.e. disabled</i>+ *+ * @dtopt Options+ * @name DataTable.defaults.scrollXInner+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "scrollX": "100%",+ * "scrollXInner": "110%"+ * } );+ * } );+ */+ "sScrollXInner": "",+++ /**+ * 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).+ * @type string+ * @default <i>blank string - i.e. disabled</i>+ *+ * @dtopt Features+ * @name DataTable.defaults.scrollY+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "scrollY": "200px",+ * "paginate": false+ * } );+ * } );+ */+ "sScrollY": "",+++ /**+ * __Deprecated__ The functionality provided by this parameter has now been+ * superseded by that provided through `ajax`, which should be used instead.+ *+ * Set the HTTP method that is used to make the Ajax call for server-side+ * processing or Ajax sourced data.+ * @type string+ * @default GET+ *+ * @dtopt Options+ * @dtopt Server-side+ * @name DataTable.defaults.serverMethod+ *+ * @deprecated 1.10. Please use `ajax` for this functionality now.+ */+ "sServerMethod": "GET",+++ /**+ * DataTables makes use of renderers when displaying HTML elements for+ * a table. These renderers can be added or modified by plug-ins to+ * generate suitable mark-up for a site. For example the Bootstrap+ * integration plug-in for DataTables uses a paging button renderer to+ * display pagination buttons in the mark-up required by Bootstrap.+ *+ * For further information about the renderers available see+ * DataTable.ext.renderer+ * @type string|object+ * @default null+ *+ * @name DataTable.defaults.renderer+ *+ */+ "renderer": null+ };++ _fnHungarianMap( DataTable.defaults );++++ /*+ * Developer note - See note in model.defaults.js about the use of Hungarian+ * notation and camel case.+ */++ /**+ * Column options that can be given to DataTables at initialisation time.+ * @namespace+ */+ DataTable.defaults.column = {+ /**+ * Define which column(s) an order will occur on for this column. This+ * allows a column's ordering to take multiple columns into account when+ * doing a sort or use the data from a different column. For example first+ * name / last name columns make sense to do a multi-column sort over the+ * two columns.+ * @type array|int+ * @default null <i>Takes the value of the column index automatically</i>+ *+ * @name DataTable.defaults.column.orderData+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "orderData": [ 0, 1 ], "targets": [ 0 ] },+ * { "orderData": [ 1, 0 ], "targets": [ 1 ] },+ * { "orderData": 2, "targets": [ 2 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "orderData": [ 0, 1 ] },+ * { "orderData": [ 1, 0 ] },+ * { "orderData": 2 },+ * null,+ * null+ * ]+ * } );+ * } );+ */+ "aDataSort": null,+ "iDataSort": -1,+++ /**+ * You can control the default ordering direction, and even alter the+ * behaviour of the sort handler (i.e. only allow ascending ordering etc)+ * using this parameter.+ * @type array+ * @default [ 'asc', 'desc' ]+ *+ * @name DataTable.defaults.column.orderSequence+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "orderSequence": [ "asc" ], "targets": [ 1 ] },+ * { "orderSequence": [ "desc", "asc", "asc" ], "targets": [ 2 ] },+ * { "orderSequence": [ "desc" ], "targets": [ 3 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * null,+ * { "orderSequence": [ "asc" ] },+ * { "orderSequence": [ "desc", "asc", "asc" ] },+ * { "orderSequence": [ "desc" ] },+ * null+ * ]+ * } );+ * } );+ */+ "asSorting": [ 'asc', 'desc' ],+++ /**+ * Enable or disable filtering on the data in this column.+ * @type boolean+ * @default true+ *+ * @name DataTable.defaults.column.searchable+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "searchable": false, "targets": [ 0 ] }+ * ] } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "searchable": false },+ * null,+ * null,+ * null,+ * null+ * ] } );+ * } );+ */+ "bSearchable": true,+++ /**+ * Enable or disable ordering on this column.+ * @type boolean+ * @default true+ *+ * @name DataTable.defaults.column.orderable+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "orderable": false, "targets": [ 0 ] }+ * ] } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "orderable": false },+ * null,+ * null,+ * null,+ * null+ * ] } );+ * } );+ */+ "bSortable": true,+++ /**+ * Enable or disable the display of this column.+ * @type boolean+ * @default true+ *+ * @name DataTable.defaults.column.visible+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "visible": false, "targets": [ 0 ] }+ * ] } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "visible": false },+ * null,+ * null,+ * null,+ * null+ * ] } );+ * } );+ */+ "bVisible": true,+++ /**+ * 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 mRender+ * allowing you to modify the DOM element (add background colour for example) when the+ * element is available.+ * @type function+ * @param {element} td The TD node that has been created+ * @param {*} cellData The Data for the cell+ * @param {array|object} rowData The data for the whole row+ * @param {int} row The row index for the aoData data store+ * @param {int} col The column index for aoColumns+ *+ * @name DataTable.defaults.column.createdCell+ * @dtopt Columns+ *+ * @example+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [3],+ * "createdCell": function (td, cellData, rowData, row, col) {+ * if ( cellData == "1.7" ) {+ * $(td).css('color', 'blue')+ * }+ * }+ * } ]+ * });+ * } );+ */+ "fnCreatedCell": null,+++ /**+ * This parameter has been replaced by `data` in DataTables to ensure naming+ * consistency. `dataProp` can still be used, as there is backwards+ * compatibility in DataTables for this option, but it is strongly+ * recommended that you use `data` in preference to `dataProp`.+ * @name DataTable.defaults.column.dataProp+ */+++ /**+ * This property can be used to read data from any data source property,+ * including deeply nested objects / properties. `data` 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. There are+ * three 'special' options that can be used in the string to alter how+ * DataTables reads the data from the source object:+ * * `.` - Dotted Javascript notation. Just as you use a `.` in+ * Javascript to read from nested objects, so to can the options+ * specified in `data`. For example: `browser.version` or+ * `browser.name`. If your object parameter name contains a period, use+ * `\\` to escape it - i.e. `first\\.name`.+ * * `[]` - Array notation. DataTables can automatically combine data+ * from and array source, joining the data with the characters provided+ * between the two brackets. For example: `name[, ]` would provide a+ * comma-space separated list from the source array. If no characters+ * are provided between the brackets, the original array source is+ * returned.+ * * `()` - Function notation. Adding `()` to the end of a parameter will+ * execute a function of the name given. For example: `browser()` for a+ * simple function on the data source, `browser.version()` for a+ * function in a nested property or even `browser().version` to get an+ * object property if the function called returns an object. Note that+ * function notation is recommended for use in `render` rather than+ * `data` as it is much simpler to use as a renderer.+ * * `null` - use the original data source for the row rather than plucking+ * data directly from it. This action has effects on two other+ * initialisation options:+ * * `defaultContent` - When null is given as the `data` option and+ * `defaultContent` is specified for the column, the value defined by+ * `defaultContent` will be used for the cell.+ * * `render` - When null is used for the `data` option and the `render`+ * option is specified for the column, the whole data source for the+ * row is used for the renderer.+ * * `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:+ * * 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'.+ * * Return:+ * * The return value from the function is not required when 'set' is+ * the type of call, but otherwise the return is what will be used+ * for the data requested.+ *+ * Note that `data` is a getter and setter option. If you just require+ * formatting of data for output, you will likely want to use `render` which+ * is simply a getter and thus simpler to use.+ *+ * Note that prior to DataTables 1.9.2 `data` was called `mDataProp`. The+ * name change reflects the flexibility of this property and is consistent+ * with the naming of mRender. If 'mDataProp' is given, then it will still+ * be used by DataTables, as it automatically maps the old name to the new+ * if required.+ *+ * @type string|int|function|null+ * @default null <i>Use automatically calculated column index</i>+ *+ * @name DataTable.defaults.column.data+ * @dtopt Columns+ *+ * @example+ * // Read table data from objects+ * // JSON structure for each row:+ * // {+ * // "engine": {value},+ * // "browser": {value},+ * // "platform": {value},+ * // "version": {value},+ * // "grade": {value}+ * // }+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "ajaxSource": "sources/objects.txt",+ * "columns": [+ * { "data": "engine" },+ * { "data": "browser" },+ * { "data": "platform" },+ * { "data": "version" },+ * { "data": "grade" }+ * ]+ * } );+ * } );+ *+ * @example+ * // Read information from deeply nested objects+ * // JSON structure for each row:+ * // {+ * // "engine": {value},+ * // "browser": {value},+ * // "platform": {+ * // "inner": {value}+ * // },+ * // "details": [+ * // {value}, {value}+ * // ]+ * // }+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "ajaxSource": "sources/deep.txt",+ * "columns": [+ * { "data": "engine" },+ * { "data": "browser" },+ * { "data": "platform.inner" },+ * { "data": "platform.details.0" },+ * { "data": "platform.details.1" }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `data` as a function to provide different information for+ * // sorting, filtering and display. In this case, currency (price)+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": 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;+ * }+ * } ]+ * } );+ * } );+ *+ * @example+ * // Using default content+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": null,+ * "defaultContent": "Click to edit"+ * } ]+ * } );+ * } );+ *+ * @example+ * // Using array notation - outputting a list from an array+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": "name[, ]"+ * } ]+ * } );+ * } );+ *+ */+ "mData": null,+++ /**+ * This property is the rendering partner to `data` and it is suggested that+ * when you want to manipulate data for display (including filtering,+ * sorting etc) without altering the underlying data for the table, use this+ * property. `render` can be considered to be the the read only companion to+ * `data` which is read / write (then as such more complex). Like `data`+ * this option can be given in a number of different ways to 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. There are+ * three 'special' options that can be used in the string to alter how+ * DataTables reads the data from the source object:+ * * `.` - Dotted Javascript notation. Just as you use a `.` in+ * Javascript to read from nested objects, so to can the options+ * specified in `data`. For example: `browser.version` or+ * `browser.name`. If your object parameter name contains a period, use+ * `\\` to escape it - i.e. `first\\.name`.+ * * `[]` - Array notation. DataTables can automatically combine data+ * from and array source, joining the data with the characters provided+ * between the two brackets. For example: `name[, ]` would provide a+ * comma-space separated list from the source array. If no characters+ * are provided between the brackets, the original array source is+ * returned.+ * * `()` - Function notation. Adding `()` to the end of a parameter will+ * execute a function of the name given. For example: `browser()` for a+ * simple function on the data source, `browser.version()` for a+ * function in a nested property or even `browser().version` to get an+ * object property if the function called returns an object.+ * * `object` - use different data for the different data types requested by+ * DataTables ('filter', 'display', 'type' or 'sort'). The property names+ * of the object is the data type the property refers to and the value can+ * defined using an integer, string or function using the same rules as+ * `render` normally does. Note that an `_` option _must_ be specified.+ * This is the default value to use if you haven't specified a value for+ * the data type requested by DataTables.+ * * `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:+ * * Parameters:+ * * {array|object} The data source for the row (based on `data`)+ * * {string} The type call data requested - this will be 'filter',+ * 'display', 'type' or 'sort'.+ * * {array|object} The full data source for the row (not based on+ * `data`)+ * * Return:+ * * The return value from the function is what will be used for the+ * data requested.+ *+ * @type string|int|function|object|null+ * @default null Use the data source value.+ *+ * @name DataTable.defaults.column.render+ * @dtopt Columns+ *+ * @example+ * // Create a comma separated list from an array of objects+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "ajaxSource": "sources/deep.txt",+ * "columns": [+ * { "data": "engine" },+ * { "data": "browser" },+ * {+ * "data": "platform",+ * "render": "[, ].name"+ * }+ * ]+ * } );+ * } );+ *+ * @example+ * // Execute a function to obtain data+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": null, // Use the full data source object for the renderer's source+ * "render": "browserName()"+ * } ]+ * } );+ * } );+ *+ * @example+ * // As an object, extracting different data for the different types+ * // This would be used with a data source such as:+ * // { "phone": 5552368, "phone_filter": "5552368 555-2368", "phone_display": "555-2368" }+ * // Here the `phone` integer is used for sorting and type detection, while `phone_filter`+ * // (which has both forms) is used for filtering for if a user inputs either format, while+ * // the formatted phone number is the one that is shown in the table.+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": null, // Use the full data source object for the renderer's source+ * "render": {+ * "_": "phone",+ * "filter": "phone_filter",+ * "display": "phone_display"+ * }+ * } ]+ * } );+ * } );+ *+ * @example+ * // Use as a function to create a link from the data source+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "data": "download_link",+ * "render": function ( data, type, full ) {+ * return '<a href="'+data+'">Download</a>';+ * }+ * } ]+ * } );+ * } );+ */+ "mRender": null,+++ /**+ * 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).+ * @type string+ * @default td+ *+ * @name DataTable.defaults.column.cellType+ * @dtopt Columns+ *+ * @example+ * // Make the first column use TH cells+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [ {+ * "targets": [ 0 ],+ * "cellType": "th"+ * } ]+ * } );+ * } );+ */+ "sCellType": "td",+++ /**+ * Class to give to each cell in this column.+ * @type string+ * @default <i>Empty string</i>+ *+ * @name DataTable.defaults.column.class+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "class": "my_class", "targets": [ 0 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "class": "my_class" },+ * null,+ * null,+ * null,+ * null+ * ]+ * } );+ * } );+ */+ "sClass": "",++ /**+ * 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!+ * @type string+ * @default <i>Empty string<i>+ *+ * @name DataTable.defaults.column.contentPadding+ * @dtopt Columns+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * null,+ * null,+ * null,+ * {+ * "contentPadding": "mmm"+ * }+ * ]+ * } );+ * } );+ */+ "sContentPadding": "",+++ /**+ * 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 `data`+ * is set to null, or because the data source itself is null).+ * @type string+ * @default null+ *+ * @name DataTable.defaults.column.defaultContent+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * {+ * "data": null,+ * "defaultContent": "Edit",+ * "targets": [ -1 ]+ * }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * null,+ * null,+ * null,+ * {+ * "data": null,+ * "defaultContent": "Edit"+ * }+ * ]+ * } );+ * } );+ */+ "sDefaultContent": null,+++ /**+ * 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).+ * @type string+ * @default <i>Empty string</i>+ *+ * @name DataTable.defaults.column.name+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "name": "engine", "targets": [ 0 ] },+ * { "name": "browser", "targets": [ 1 ] },+ * { "name": "platform", "targets": [ 2 ] },+ * { "name": "version", "targets": [ 3 ] },+ * { "name": "grade", "targets": [ 4 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "name": "engine" },+ * { "name": "browser" },+ * { "name": "platform" },+ * { "name": "version" },+ * { "name": "grade" }+ * ]+ * } );+ * } );+ */+ "sName": "",+++ /**+ * Defines a data source type for the ordering which can be used to read+ * real-time information from the table (updating the internally cached+ * version) prior to ordering. This allows ordering to occur on user+ * editable elements such as form inputs.+ * @type string+ * @default std+ *+ * @name DataTable.defaults.column.orderDataType+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "orderDataType": "dom-text", "targets": [ 2, 3 ] },+ * { "type": "numeric", "targets": [ 3 ] },+ * { "orderDataType": "dom-select", "targets": [ 4 ] },+ * { "orderDataType": "dom-checkbox", "targets": [ 5 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * null,+ * null,+ * { "orderDataType": "dom-text" },+ * { "orderDataType": "dom-text", "type": "numeric" },+ * { "orderDataType": "dom-select" },+ * { "orderDataType": "dom-checkbox" }+ * ]+ * } );+ * } );+ */+ "sSortDataType": "std",+++ /**+ * The title of this column.+ * @type string+ * @default null <i>Derived from the 'TH' value for this column in the+ * original HTML table.</i>+ *+ * @name DataTable.defaults.column.title+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "title": "My column title", "targets": [ 0 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "title": "My column title" },+ * null,+ * null,+ * null,+ * null+ * ]+ * } );+ * } );+ */+ "sTitle": null,+++ /**+ * The type allows you to specify how the data for this column will be+ * ordered. Four types (string, numeric, date and html (which will strip+ * HTML tags before ordering)) 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.+ * @type string+ * @default null <i>Auto-detected from raw data</i>+ *+ * @name DataTable.defaults.column.type+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "type": "html", "targets": [ 0 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "type": "html" },+ * null,+ * null,+ * null,+ * null+ * ]+ * } );+ * } );+ */+ "sType": null,+++ /**+ * Defining the width of the column, this parameter may take any CSS value+ * (3em, 20px etc). DataTables applies 'smart' widths to columns which have not+ * been given a specific width through this interface ensuring that the table+ * remains readable.+ * @type string+ * @default null <i>Automatic</i>+ *+ * @name DataTable.defaults.column.width+ * @dtopt Columns+ *+ * @example+ * // Using `columnDefs`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columnDefs": [+ * { "width": "20%", "targets": [ 0 ] }+ * ]+ * } );+ * } );+ *+ * @example+ * // Using `columns`+ * $(document).ready( function() {+ * $('#example').dataTable( {+ * "columns": [+ * { "width": "20%" },+ * null,+ * null,+ * null,+ * null+ * ]+ * } );+ * } );+ */+ "sWidth": null+ };++ _fnHungarianMap( DataTable.defaults.column );++++ /**+ * 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 {@link 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+ * @todo Really should attach the settings object to individual instances so we+ * don't need to create new instances on each $().dataTable() call (if the+ * table already exists). It would also save passing oSettings around and+ * into every single function. However, this is a very significant+ * architecture change for DataTables and will almost certainly break+ * backwards compatibility with older installations. This is something that+ * will be done in 2.0.+ */+ DataTable.models.oSettings = {+ /**+ * Primary features of DataTables and their enablement state.+ * @namespace+ */+ "oFeatures": {++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bAutoWidth": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bDeferRender": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bFilter": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bInfo": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bLengthChange": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bPaginate": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bProcessing": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bServerSide": null,++ /**+ * Sorting enablement flag.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type boolean+ */+ "bSort": null,++ /**+ * Multi-column sorting+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type boolean+ */+ "bSortMulti": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bSortClasses": null,++ /**+ * State saving enablement flag.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type boolean+ */+ "bStateSave": null+ },+++ /**+ * Scrolling settings for a table.+ * @namespace+ */+ "oScroll": {+ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bCollapse": null,++ /**+ * Width of the scrollbar for the web-browser's platform. Calculated+ * during table initialisation.+ * @type int+ * @default 0+ */+ "iBarWidth": 0,++ /**+ * 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 {@link DataTable.defaults}.+ * @type string+ */+ "sX": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type string+ * @deprecated+ */+ "sXInner": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type string+ */+ "sY": null+ },++ /**+ * Language information for the table.+ * @namespace+ * @extends DataTable.defaults.oLanguage+ */+ "oLanguage": {+ /**+ * Information callback function. See+ * {@link DataTable.defaults.fnInfoCallback}+ * @type function+ * @default null+ */+ "fnInfoCallback": null+ },++ /**+ * Browser support parameters+ * @namespace+ */+ "oBrowser": {+ /**+ * Indicate if the browser incorrectly calculates width:100% inside a+ * scrolling element (IE6/7)+ * @type boolean+ * @default false+ */+ "bScrollOversize": false,++ /**+ * Determine if the vertical scrollbar is on the right or left of the+ * scrolling container - needed for rtl language layout, although not+ * all browsers move the scrollbar (Safari).+ * @type boolean+ * @default false+ */+ "bScrollbarLeft": false+ },+++ "ajax": null,+++ /**+ * Array referencing the nodes which are used for the features. The+ * parameters of this object match what is allowed by sDom - i.e.+ * <ul>+ * <li>'l' - Length changing</li>+ * <li>'f' - Filtering input</li>+ * <li>'t' - The table!</li>+ * <li>'i' - Information</li>+ * <li>'p' - Pagination</li>+ * <li>'r' - pRocessing</li>+ * </ul>+ * @type array+ * @default []+ */+ "aanFeatures": [],++ /**+ * Store data information - see {@link DataTable.models.oRow} for detailed+ * information.+ * @type array+ * @default []+ */+ "aoData": [],++ /**+ * Array of indexes which are in the current display (after filtering etc)+ * @type array+ * @default []+ */+ "aiDisplay": [],++ /**+ * Array of indexes for display - no filtering+ * @type array+ * @default []+ */+ "aiDisplayMaster": [],++ /**+ * Store information about each column that is in use+ * @type array+ * @default []+ */+ "aoColumns": [],++ /**+ * Store information about the table's header+ * @type array+ * @default []+ */+ "aoHeader": [],++ /**+ * Store information about the table's footer+ * @type array+ * @default []+ */+ "aoFooter": [],++ /**+ * 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 {@link DataTable.defaults}.+ * @namespace+ * @extends DataTable.models.oSearch+ */+ "oPreviousSearch": {},++ /**+ * Store the applied search for each column - see+ * {@link DataTable.models.oSearch} for the format that is used for the+ * filtering information for each column.+ * @type array+ * @default []+ */+ "aoPreSearchCols": [],++ /**+ * Sorting that is applied to the table. Note that the inner arrays are+ * used in the following manner:+ * <ul>+ * <li>Index 0 - column number</li>+ * <li>Index 1 - current sorting direction</li>+ * </ul>+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type array+ * @todo These inner arrays should really be objects+ */+ "aaSorting": 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 {@link DataTable.defaults}.+ * @type array+ * @default []+ */+ "aaSortingFixed": [],++ /**+ * 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 {@link DataTable.defaults}.+ * @type array+ * @default []+ */+ "asStripeClasses": null,++ /**+ * If restoring a table - we should restore its striping classes as well+ * @type array+ * @default []+ */+ "asDestroyStripes": [],++ /**+ * If restoring a table - we should restore its width+ * @type int+ * @default 0+ */+ "sDestroyWidth": 0,++ /**+ * Callback functions array for every time a row is inserted (i.e. on a draw).+ * @type array+ * @default []+ */+ "aoRowCallback": [],++ /**+ * Callback functions for the header on each draw.+ * @type array+ * @default []+ */+ "aoHeaderCallback": [],++ /**+ * Callback function for the footer on each draw.+ * @type array+ * @default []+ */+ "aoFooterCallback": [],++ /**+ * Array of callback functions for draw callback functions+ * @type array+ * @default []+ */+ "aoDrawCallback": [],++ /**+ * Array of callback functions for row created function+ * @type array+ * @default []+ */+ "aoRowCreatedCallback": [],++ /**+ * Callback functions for just before the table is redrawn. A return of+ * false will be used to cancel the draw.+ * @type array+ * @default []+ */+ "aoPreDrawCallback": [],++ /**+ * Callback functions for when the table has been initialised.+ * @type array+ * @default []+ */+ "aoInitComplete": [],+++ /**+ * Callbacks for modifying the settings to be stored for state saving, prior to+ * saving state.+ * @type array+ * @default []+ */+ "aoStateSaveParams": [],++ /**+ * Callbacks for modifying the settings that have been stored for state saving+ * prior to using the stored values to restore the state.+ * @type array+ * @default []+ */+ "aoStateLoadParams": [],++ /**+ * Callbacks for operating on the settings object once the saved state has been+ * loaded+ * @type array+ * @default []+ */+ "aoStateLoaded": [],++ /**+ * Cache the table ID for quick access+ * @type string+ * @default <i>Empty string</i>+ */+ "sTableId": "",++ /**+ * The TABLE node for the main table+ * @type node+ * @default null+ */+ "nTable": null,++ /**+ * Permanent ref to the thead element+ * @type node+ * @default null+ */+ "nTHead": null,++ /**+ * Permanent ref to the tfoot element - if it exists+ * @type node+ * @default null+ */+ "nTFoot": null,++ /**+ * Permanent ref to the tbody element+ * @type node+ * @default null+ */+ "nTBody": null,++ /**+ * Cache the wrapper node (contains all DataTables controlled elements)+ * @type node+ * @default null+ */+ "nTableWrapper": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ * @default false+ */+ "bDeferLoading": false,++ /**+ * Indicate if all required information has been read in+ * @type boolean+ * @default false+ */+ "bInitialised": false,++ /**+ * Information about open rows. Each object in the array has the parameters+ * 'nTr' and 'nParent'+ * @type array+ * @default []+ */+ "aoOpenRows": [],++ /**+ * Dictate the positioning of DataTables' control elements - see+ * {@link DataTable.model.oInit.sDom}.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type string+ * @default null+ */+ "sDom": null,++ /**+ * Which type of pagination should be used.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type string+ * @default two_button+ */+ "sPaginationType": "two_button",++ /**+ * The state duration (for `stateSave`) in seconds.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type int+ * @default 0+ */+ "iStateDuration": 0,++ /**+ * Array of callback functions for state saving. Each array element is an+ * object with the following parameters:+ * <ul>+ * <li>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]')</li>+ * <li>string:sName - name of callback</li>+ * </ul>+ * @type array+ * @default []+ */+ "aoStateSave": [],++ /**+ * Array of callback functions for state loading. Each array element is an+ * object with the following parameters:+ * <ul>+ * <li>function:fn - function to call. Takes two parameters, oSettings+ * and the object stored. May return false to cancel state loading</li>+ * <li>string:sName - name of callback</li>+ * </ul>+ * @type array+ * @default []+ */+ "aoStateLoad": [],++ /**+ * State that was saved. Useful for back reference+ * @type object+ * @default null+ */+ "oSavedState": null,++ /**+ * State that was loaded. Useful for back reference+ * @type object+ * @default null+ */+ "oLoadedState": null,++ /**+ * Source url for AJAX data for the table.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type string+ * @default null+ */+ "sAjaxSource": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type string+ */+ "sAjaxDataProp": null,++ /**+ * Note if draw should be blocked while getting data+ * @type boolean+ * @default true+ */+ "bAjaxDataGet": true,++ /**+ * 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+ * @type object+ * @default null+ */+ "jqXHR": null,++ /**+ * JSON returned from the server in the last Ajax request+ * @type object+ * @default undefined+ */+ "json": undefined,++ /**+ * Data submitted as part of the last Ajax request+ * @type object+ * @default undefined+ */+ "oAjaxData": undefined,++ /**+ * Function to get the server-side data.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type function+ */+ "fnServerData": null,++ /**+ * Functions which are called prior to sending an Ajax request so extra+ * parameters can easily be sent to the server+ * @type array+ * @default []+ */+ "aoServerParams": [],++ /**+ * 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 {@link DataTable.defaults}.+ * @type string+ */+ "sServerMethod": null,++ /**+ * Format numbers for display.+ * Note that this parameter will be set by the initialisation routine. To+ * set a default use {@link DataTable.defaults}.+ * @type function+ */+ "fnFormatNumber": null,++ /**+ * 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 {@link DataTable.defaults}.+ * @type array+ * @default []+ */+ "aLengthMenu": null,++ /**+ * Counter for the draws that the table does. Also used as a tracker for+ * server-side processing+ * @type int+ * @default 0+ */+ "iDraw": 0,++ /**+ * Indicate if a redraw is being done - useful for Ajax+ * @type boolean+ * @default false+ */+ "bDrawing": false,++ /**+ * Draw index (iDraw) of the last error when parsing the returned data+ * @type int+ * @default -1+ */+ "iDrawError": -1,++ /**+ * Paging display length+ * @type int+ * @default 10+ */+ "_iDisplayLength": 10,++ /**+ * Paging start point - aiDisplay index+ * @type int+ * @default 0+ */+ "_iDisplayStart": 0,++ /**+ * Server-side processing - number of records in the result set+ * (i.e. before filtering), Use fnRecordsTotal rather than+ * this property to get the value of the number of records, regardless of+ * the server-side processing setting.+ * @type int+ * @default 0+ * @private+ */+ "_iRecordsTotal": 0,++ /**+ * Server-side processing - number of records in the current display set+ * (i.e. after filtering). Use fnRecordsDisplay rather than+ * this property to get the value of the number of records, regardless of+ * the server-side processing setting.+ * @type boolean+ * @default 0+ * @private+ */+ "_iRecordsDisplay": 0,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bJUI": null,++ /**+ * The classes to use for the table+ * @type object+ * @default {}+ */+ "oClasses": {},++ /**+ * 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.+ * @type boolean+ * @default false+ * @deprecated+ */+ "bFiltered": false,++ /**+ * 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.+ * @type boolean+ * @default false+ * @deprecated+ */+ "bSorted": false,++ /**+ * 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 {@link DataTable.defaults}.+ * @type boolean+ */+ "bSortCellsTop": null,++ /**+ * Initialisation object that is used for the table+ * @type object+ * @default null+ */+ "oInit": null,++ /**+ * Destroy callback functions - for plug-ins to attach themselves to the+ * destroy so they can clean up markup and events.+ * @type array+ * @default []+ */+ "aoDestroyCallback": [],+++ /**+ * Get the number of records in the current record set, before filtering+ * @type function+ */+ "fnRecordsTotal": function ()+ {+ return _fnDataSource( this ) == 'ssp' ?+ this._iRecordsTotal * 1 :+ this.aiDisplayMaster.length;+ },++ /**+ * Get the number of records in the current record set, after filtering+ * @type function+ */+ "fnRecordsDisplay": function ()+ {+ return _fnDataSource( this ) == 'ssp' ?+ this._iRecordsDisplay * 1 :+ this.aiDisplay.length;+ },++ /**+ * Get the display end point - aiDisplay index+ * @type function+ */+ "fnDisplayEnd": function ()+ {+ var+ len = this._iDisplayLength,+ start = this._iDisplayStart,+ calc = start + len,+ records = this.aiDisplay.length,+ features = this.oFeatures,+ paginate = features.bPaginate;++ if ( features.bServerSide ) {+ return paginate === false || len === -1 ?+ start + records :+ Math.min( start+len, this._iRecordsDisplay );+ }+ else {+ return ! paginate || calc>records || len===-1 ?+ records :+ calc;+ }+ },++ /**+ * The DataTables object for this table+ * @type object+ * @default null+ */+ "oInstance": null,++ /**+ * 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.+ * @type string+ * @default null+ */+ "sInstance": null,++ /**+ * tabindex attribute value that is added to DataTables control elements, allowing+ * keyboard navigation of the table and its controls.+ */+ "iTabIndex": 0,++ /**+ * DIV container for the footer scrolling table if scrolling+ */+ "nScrollHead": null,++ /**+ * DIV container for the footer scrolling table if scrolling+ */+ "nScrollFoot": null,++ /**+ * Last applied sort+ * @type array+ * @default []+ */+ "aLastSort": [],++ /**+ * Stored plug-in instances+ * @type object+ * @default {}+ */+ "oPlugins": {}+ };++ /**+ * 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.+ * @namespace+ * @extends DataTable.models.ext+ */+++ /**+ * DataTables extensions+ *+ * This namespace acts as a collection area for plug-ins that can be used to+ * extend DataTables capabilities. 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` for legacy+ * reasons+ *+ * @namespace+ */+ DataTable.ext = _ext = {+ /**+ * Element class names+ *+ * @type object+ * @default {}+ */+ classes: {},+++ /**+ * Error reporting.+ *+ * How should DataTables report an error. Can take the value 'alert' or+ * 'throw'+ *+ * @type string+ * @default alert+ */+ errMode: "alert",+++ /**+ * 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 then available for+ * use through the `dom` initialisation option.+ *+ * Each feature plug-in is described by an object which must have the+ * following properties:+ *+ * * `fnInit` - function that is used to initialise the plug-in,+ * * `cFeature` - a character so the feature can be enabled by the `dom`+ * instillation option. This is case sensitive.+ *+ * The `fnInit` function has the following input parameters:+ *+ * 1. `{object}` DataTables settings object: see+ * {@link DataTable.models.oSettings}+ *+ * And the following return is expected:+ *+ * * {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 (`dom`) - for example this might+ * be useful when developing a plug-in which allows table control via+ * keyboard entry+ *+ * @type array+ *+ * @example+ * $.fn.dataTable.ext.features.push( {+ * "fnInit": function( oSettings ) {+ * return new TableTools( { "oDTSettings": oSettings } );+ * },+ * "cFeature": "T"+ * } );+ */+ feature: [],+++ /**+ * Row searching.+ *+ * This method of searching is complimentary to the default type based+ * searching, and a lot more comprehensive as it allows you complete control+ * over the searching 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 searching data set+ * or not.+ *+ * Searching functions have the following input parameters:+ *+ * 1. `{object}` DataTables settings object: see+ * {@link DataTable.models.oSettings}+ * 2. `{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+ * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which+ * can be useful to retrieve the `TR` element if you need DOM interaction.+ *+ * And the following return is expected:+ *+ * * {boolean} Include the row in the searched result set (true) or not+ * (false)+ *+ * Note that as with the main search ability in DataTables, technically this+ * is "filtering", since it is subtractive. However, for consistency in+ * naming we call it searching here.+ *+ * @type array+ * @default []+ *+ * @example+ * // The following example shows custom search being applied to the+ * // fourth column (i.e. the data[3] index) based on two input values+ * // from the end-user, matching the data in a certain range.+ * $.fn.dataTable.ext.search.push(+ * function( settings, data, dataIndex ) {+ * var min = document.getElementById('min').value * 1;+ * var max = document.getElementById('max').value * 1;+ * var version = data[3] == "-" ? 0 : data[3]*1;+ *+ * if ( min == "" && max == "" ) {+ * return true;+ * }+ * else if ( min == "" && version < max ) {+ * return true;+ * }+ * else if ( min < version && "" == max ) {+ * return true;+ * }+ * else if ( min < version && version < max ) {+ * return true;+ * }+ * return false;+ * }+ * );+ */+ search: [],+++ /**+ * Internal functions, exposed for used in plug-ins.+ *+ * Please note that you should not need to use the internal methods for+ * anything other than a plug-in (and even then, try to avoid if possible).+ * The internal function may change between releases.+ *+ * @type object+ * @default {}+ */+ internal: {},+++ /**+ * Legacy configuration options. Enable and disable legacy options that+ * are available in DataTables.+ *+ * @type object+ */+ legacy: {+ /**+ * Enable / disable DataTables 1.9 compatible server-side processing+ * requests+ *+ * @type boolean+ * @default null+ */+ ajax: null+ },+++ /**+ * Pagination plug-in methods.+ *+ * Each entry in this object is a function and defines which buttons should+ * be shown by the pagination rendering method that is used for the table:+ * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the+ * buttons are displayed in the document, while the functions here tell it+ * what buttons to display. This is done by returning an array of button+ * descriptions (what each button will do).+ *+ * Pagination types (the four built in options and any additional plug-in+ * options defined here) can be used through the `paginationType`+ * initialisation parameter.+ *+ * The functions defined take two parameters:+ *+ * 1. `{int} page` The current page index+ * 2. `{int} pages` The number of pages in the table+ *+ * Each function is expected to return an array where each element of the+ * array can be one of:+ *+ * * `first` - Jump to first page when activated+ * * `last` - Jump to last page when activated+ * * `previous` - Show previous page when activated+ * * `next` - Show next page when activated+ * * `{int}` - Show page of the index given+ * * `{array}` - A nested array containing the above elements to add a+ * containing 'DIV' element (might be useful for styling).+ *+ * Note that DataTables v1.9- used this object slightly differently whereby+ * an object with two functions would be defined for each plug-in. That+ * ability is still supported by DataTables 1.10+ to provide backwards+ * compatibility, but this option of use is now decremented and no longer+ * documented in DataTables 1.10+.+ *+ * @type object+ * @default {}+ *+ * @example+ * // Show previous, next and current page buttons only+ * $.fn.dataTableExt.oPagination.current = function ( page, pages ) {+ * return [ 'previous', page, 'next' ];+ * };+ */+ pager: {},+++ renderer: {+ pageButton: {},+ header: {}+ },+++ /**+ * Ordering plug-ins - custom data source+ *+ * The extension options for ordering of data available here is complimentary+ * to the default type based ordering that DataTables typically uses. It+ * allows much greater control over the the data that is being used to+ * order a column, but is necessarily therefore more complex.+ *+ * This type of ordering is useful if you want to do ordering based on data+ * live from the DOM (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 ordering for the column in question and then return that+ * array. The data in the array much be in the index order of the rows in+ * the table (not the currently ordering order!). Which order data gathering+ * function is run here depends on the `dt-init columns.orderDataType`+ * parameter that is used for the column (if any).+ *+ * The functions defined take two parameters:+ *+ * 1. `{object}` DataTables settings object: see+ * {@link DataTable.models.oSettings}+ * 2. `{int}` Target column index+ *+ * Each function is expected to return an array:+ *+ * * `{array}` Data for the column to be ordering upon+ *+ * @type array+ *+ * @example+ * // Ordering using `input` node values+ * $.fn.dataTable.ext.order['dom-text'] = function ( settings, col )+ * {+ * return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {+ * return $('input', td).val();+ * } );+ * }+ */+ order: {},+++ /**+ * Type based plug-ins.+ *+ * Each column in DataTables has a type assigned to it, either by automatic+ * detection or by direct assignment using the `type` option for the column.+ * The type of a column will effect how it is ordering and search (plug-ins+ * can also make use of the column type if required).+ *+ * @namespace+ */+ type: {+ /**+ * Type detection functions.+ *+ * The functions defined in this object are used to automatically detect+ * a column's type, making initialisation of DataTables super easy, even+ * when complex data is in the table.+ *+ * The functions defined take two parameters:+ *+ * 1. `{*}` Data from the column cell to be analysed+ * 2. `{settings}` DataTables settings object. This can be used to+ * perform context specific type detection - for example detection+ * based on language settings such as using a comma for a decimal+ * place. Generally speaking the options from the settings will not+ * be required+ *+ * Each function is expected to return:+ *+ * * `{string|null}` Data type detected, or null if unknown (and thus+ * pass it on to the other type detection functions.+ *+ * @type array+ *+ * @example+ * // Currency type detection plug-in:+ * $.fn.dataTable.ext.type.detect.push(+ * function ( data, settings ) {+ * // Check the numeric part+ * if ( ! $.isNumeric( data.substring(1) ) ) {+ * return null;+ * }+ *+ * // Check prefixed by currency+ * if ( data.charAt(0) == '$' || data.charAt(0) == '£' ) {+ * return 'currency';+ * }+ * return null;+ * }+ * );+ */+ detect: [],+++ /**+ * Type based search formatting.+ *+ * The type based searching functions can be used to pre-format the+ * data to be search on. For example, it can be used to strip HTML+ * tags or to de-format telephone numbers for numeric only searching.+ *+ * Note that is a search is not defined for a column of a given type,+ * no search formatting will be performed.+ *+ * Pre-processing of searching 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 searching+ * by allowing you to pre-processing the data and returning the data in+ * the format that should be searched 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 <i>afnSortData</i>+ * for searching data.+ *+ * The functions defined take a single parameter:+ *+ * 1. `{*}` Data from the column cell to be prepared for searching+ *+ * Each function is expected to return:+ *+ * * `{string|null}` Formatted string that will be used for the searching.+ *+ * @type object+ * @default {}+ *+ * @example+ * $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {+ * return d.replace(/\n/g," ").replace( /<.*?>/g, "" );+ * }+ */+ search: {},+++ /**+ * Type based ordering.+ *+ * The column type tells DataTables what ordering to apply to the table+ * when a column is sorted upon. The order for each type that is defined,+ * is defined by the functions available in this object.+ *+ * Each ordering option can be described by three properties added to+ * this object:+ *+ * * `{type}-pre` - Pre-formatting function+ * * `{type}-asc` - Ascending order function+ * * `{type}-desc` - Descending order function+ *+ * All three can be used together, only `{type}-pre` or only+ * `{type}-asc` and `{type}-desc` together. It is generally recommended+ * that only `{type}-pre` is used, as this provides the optimal+ * implementation in terms of speed, although the others are provided+ * for compatibility with existing Javascript sort functions.+ *+ * `{type}-pre`: Functions defined take a single parameter:+ *+ * 1. `{*}` Data from the column cell to be prepared for ordering+ *+ * And return:+ *+ * * `{*}` Data to be sorted upon+ *+ * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort+ * functions, taking two parameters:+ *+ * 1. `{*}` Data to compare to the second parameter+ * 2. `{*}` Data to compare to the first parameter+ *+ * And returning:+ *+ * * `{*}` Ordering 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.+ *+ * @type object+ * @default {}+ *+ * @example+ * // Numeric ordering of formatted numbers with a pre-formatter+ * $.extend( $.fn.dataTable.ext.type.order, {+ * "string-pre": function(x) {+ * a = (a === "-" || a === "") ? 0 : a.replace( /[^\d\-\.]/g, "" );+ * return parseFloat( a );+ * }+ * } );+ *+ * @example+ * // Case-sensitive string ordering, with no pre-formatting method+ * $.extend( $.fn.dataTable.ext.order, {+ * "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));+ * }+ * } );+ */+ order: {}+ },++ /**+ * Unique DataTables instance counter+ *+ * @type int+ * @private+ */+ _unique: 0,+++ //+ // Depreciated+ // The following properties are retained for backwards compatiblity only.+ // The should not be used in new projects and will be removed in a future+ // version+ //++ /**+ * Version check function.+ * @type function+ * @depreciated Since 1.10+ */+ fnVersionCheck: DataTable.fnVersionCheck,+++ /**+ * Index for what 'this' index API functions should use+ * @type int+ * @deprecated Since v1.10+ */+ iApiIndex: 0,+++ /**+ * jQuery UI class container+ * @type object+ * @deprecated Since v1.10+ */+ oJUIClasses: {},+++ /**+ * Software version+ * @type string+ * @deprecated Since v1.10+ */+ sVersion: DataTable.version+ };+++ //+ // Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts+ //+ $.extend( _ext, {+ afnFiltering: _ext.search,+ aTypes: _ext.type.detect,+ ofnSearch: _ext.type.search,+ oSort: _ext.type.order,+ afnSortData: _ext.order,+ aoFeatures: _ext.feature,+ oApi: _ext.internal,+ oStdClasses: _ext.classes,+ oPagination: _ext.pager+ } );+++ $.extend( DataTable.ext.classes, {+ "sTable": "dataTable",+ "sNoFooter": "no-footer",++ /* Paging buttons */+ "sPageButton": "paginate_button",+ "sPageButtonActive": "current",+ "sPageButtonDisabled": "disabled",++ /* Striping classes */+ "sStripeOdd": "odd",+ "sStripeEven": "even",++ /* Empty row */+ "sRowEmpty": "dataTables_empty",++ /* Features */+ "sWrapper": "dataTables_wrapper",+ "sFilter": "dataTables_filter",+ "sInfo": "dataTables_info",+ "sPaging": "dataTables_paginate paging_", /* Note that the type is postfixed */+ "sLength": "dataTables_length",+ "sProcessing": "dataTables_processing",++ /* Sorting */+ "sSortAsc": "sorting_asc",+ "sSortDesc": "sorting_desc",+ "sSortable": "sorting", /* Sortable in both directions */+ "sSortableAsc": "sorting_asc_disabled",+ "sSortableDesc": "sorting_desc_disabled",+ "sSortableNone": "sorting_disabled",+ "sSortColumn": "sorting_", /* Note that an int is postfixed for the sorting order */++ /* Filtering */+ "sFilterInput": "",++ /* Page length */+ "sLengthSelect": "",++ /* Scrolling */+ "sScrollWrapper": "dataTables_scroll",+ "sScrollHead": "dataTables_scrollHead",+ "sScrollHeadInner": "dataTables_scrollHeadInner",+ "sScrollBody": "dataTables_scrollBody",+ "sScrollFoot": "dataTables_scrollFoot",+ "sScrollFootInner": "dataTables_scrollFootInner",++ /* Misc */+ "sHeaderTH": "",+ "sFooterTH": "",++ // Deprecated+ "sSortJUIAsc": "",+ "sSortJUIDesc": "",+ "sSortJUI": "",+ "sSortJUIAscAllowed": "",+ "sSortJUIDescAllowed": "",+ "sSortJUIWrapper": "",+ "sSortIcon": "",+ "sJUIHeader": "",+ "sJUIFooter": ""+ } );+++ (function() {++ // Reused strings for better compression. Closure compiler appears to have a+ // weird edge case where it is trying to expand strings rather than use the+ // variable version. This results in about 200 bytes being added, for very+ // little preference benefit since it this run on script load only.+ var _empty = '';+ _empty = '';++ var _stateDefault = _empty + 'ui-state-default';+ var _sortIcon = _empty + 'css_right ui-icon ui-icon-';+ var _headerFooter = _empty + 'fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix';++ $.extend( DataTable.ext.oJUIClasses, DataTable.ext.classes, {+ /* Full numbers paging buttons */+ "sPageButton": "fg-button ui-button "+_stateDefault,+ "sPageButtonActive": "ui-state-disabled",+ "sPageButtonDisabled": "ui-state-disabled",++ /* Features */+ "sPaging": "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi "++ "ui-buttonset-multi paging_", /* Note that the type is postfixed */++ /* Sorting */+ "sSortAsc": _stateDefault+" sorting_asc",+ "sSortDesc": _stateDefault+" sorting_desc",+ "sSortable": _stateDefault+" sorting",+ "sSortableAsc": _stateDefault+" sorting_asc_disabled",+ "sSortableDesc": _stateDefault+" sorting_desc_disabled",+ "sSortableNone": _stateDefault+" sorting_disabled",+ "sSortJUIAsc": _sortIcon+"triangle-1-n",+ "sSortJUIDesc": _sortIcon+"triangle-1-s",+ "sSortJUI": _sortIcon+"carat-2-n-s",+ "sSortJUIAscAllowed": _sortIcon+"carat-1-n",+ "sSortJUIDescAllowed": _sortIcon+"carat-1-s",+ "sSortJUIWrapper": "DataTables_sort_wrapper",+ "sSortIcon": "DataTables_sort_icon",++ /* Scrolling */+ "sScrollHead": "dataTables_scrollHead "+_stateDefault,+ "sScrollFoot": "dataTables_scrollFoot "+_stateDefault,++ /* Misc */+ "sHeaderTH": _stateDefault,+ "sFooterTH": _stateDefault,+ "sJUIHeader": _headerFooter+" ui-corner-tl ui-corner-tr",+ "sJUIFooter": _headerFooter+" ui-corner-bl ui-corner-br"+ } );++ }());++++ var extPagination = DataTable.ext.pager;++ function _numbers ( page, pages ) {+ var+ numbers = [],+ buttons = extPagination.numbers_length,+ half = Math.floor( buttons / 2 ),+ i = 1;++ if ( pages <= buttons ) {+ numbers = _range( 0, pages );+ }+ else if ( page <= half ) {+ numbers = _range( 0, buttons-2 );+ numbers.push( 'ellipsis' );+ numbers.push( pages-1 );+ }+ else if ( page >= pages - 1 - half ) {+ numbers = _range( pages-(buttons-2), pages );+ numbers.splice( 0, 0, 'ellipsis' ); // no unshift in ie6+ numbers.splice( 0, 0, 0 );+ }+ else {+ numbers = _range( page-1, page+2 );+ numbers.push( 'ellipsis' );+ numbers.push( pages-1 );+ numbers.splice( 0, 0, 'ellipsis' );+ numbers.splice( 0, 0, 0 );+ }++ numbers.DT_el = 'span';+ return numbers;+ }+++ $.extend( extPagination, {+ simple: function ( page, pages ) {+ return [ 'previous', 'next' ];+ },++ full: function ( page, pages ) {+ return [ 'first', 'previous', 'next', 'last' ];+ },++ simple_numbers: function ( page, pages ) {+ return [ 'previous', _numbers(page, pages), 'next' ];+ },++ full_numbers: function ( page, pages ) {+ return [ 'first', 'previous', _numbers(page, pages), 'next', 'last' ];+ },++ // For testing and plug-ins to use+ _numbers: _numbers,+ numbers_length: 7+ } );+++ $.extend( true, DataTable.ext.renderer, {+ pageButton: {+ _: function ( settings, host, idx, buttons, page, pages ) {+ var classes = settings.oClasses;+ var lang = settings.oLanguage.oPaginate;+ var btnDisplay, btnClass, counter=0;++ var attach = function( container, buttons ) {+ var i, ien, node, button;+ var clickHandler = function ( e ) {+ _fnPageChange( settings, e.data.action, true );+ };++ for ( i=0, ien=buttons.length ; i<ien ; i++ ) {+ button = buttons[i];++ if ( $.isArray( button ) ) {+ var inner = $( '<'+(button.DT_el || 'div')+'/>' )+ .appendTo( container );+ attach( inner, button );+ }+ else {+ btnDisplay = '';+ btnClass = '';++ switch ( button ) {+ case 'ellipsis':+ container.append('<span>…</span>');+ break;++ case 'first':+ btnDisplay = lang.sFirst;+ btnClass = button + (page > 0 ?+ '' : ' '+classes.sPageButtonDisabled);+ break;++ case 'previous':+ btnDisplay = lang.sPrevious;+ btnClass = button + (page > 0 ?+ '' : ' '+classes.sPageButtonDisabled);+ break;++ case 'next':+ btnDisplay = lang.sNext;+ btnClass = button + (page < pages-1 ?+ '' : ' '+classes.sPageButtonDisabled);+ break;++ case 'last':+ btnDisplay = lang.sLast;+ btnClass = button + (page < pages-1 ?+ '' : ' '+classes.sPageButtonDisabled);+ break;++ default:+ btnDisplay = button + 1;+ btnClass = page === button ?+ classes.sPageButtonActive : '';+ break;+ }++ if ( btnDisplay ) {+ node = $('<a>', {+ 'class': classes.sPageButton+' '+btnClass,+ 'aria-controls': settings.sTableId,+ 'data-dt-idx': counter,+ 'tabindex': settings.iTabIndex,+ 'id': idx === 0 && typeof button === 'string' ?+ settings.sTableId +'_'+ button :+ null+ } )+ .html( btnDisplay )+ .appendTo( container );++ _fnBindAction(+ node, {action: button}, clickHandler+ );++ counter++;+ }+ }+ }+ };++ // IE9 throws an 'unknown error' if document.activeElement is used+ // inside an iframe or frame. Try / catch the error. Not good for+ // accessibility, but neither are frames.+ try {+ // Because this approach is destroying and recreating the paging+ // elements, focus is lost on the select button which is bad for+ // accessibility. So we want to restore focus once the draw has+ // completed+ var activeEl = $(document.activeElement).data('dt-idx');++ attach( $(host).empty(), buttons );++ if ( activeEl !== null ) {+ $(host).find( '[data-dt-idx='+activeEl+']' ).focus();+ }+ }+ catch (e) {}+ }+ }+ } );++++ var __numericReplace = function ( d, decimalPlace, re1, re2 ) {+ if ( !d || d === '-' ) {+ return -Infinity;+ }++ // If a decimal place other than `.` is used, it needs to be given to the+ // function so we can detect it and replace with a `.` which is the only+ // decimal place Javascript recognises - it is not locale aware.+ if ( decimalPlace ) {+ d = _numToDecimal( d, decimalPlace );+ }++ if ( d.replace ) {+ if ( re1 ) {+ d = d.replace( re1, '' );+ }++ if ( re2 ) {+ d = d.replace( re2, '' );+ }+ }++ return d * 1;+ };+++ // Add the numeric 'deformatting' functions for sorting. This is done in a+ // function to provide an easy ability for the language options to add+ // additional methods if a non-period decimal place is used.+ function _addNumericSort ( decimalPlace ) {+ $.each(+ {+ // Plain numbers+ "num": function ( d ) {+ return __numericReplace( d, decimalPlace );+ },++ // Formatted numbers+ "num-fmt": function ( d ) {+ return __numericReplace( d, decimalPlace, _re_formatted_numeric );+ },++ // HTML numeric+ "html-num": function ( d ) {+ return __numericReplace( d, decimalPlace, _re_html );+ },++ // HTML numeric, formatted+ "html-num-fmt": function ( d ) {+ return __numericReplace( d, decimalPlace, _re_html, _re_formatted_numeric );+ }+ },+ function ( key, fn ) {+ _ext.type.order[ key+decimalPlace+'-pre' ] = fn;+ }+ );+ }+++ // Default sort methods+ $.extend( _ext.type.order, {+ // Dates+ "date-pre": function ( d ) {+ return Date.parse( d ) || 0;+ },++ // html+ "html-pre": function ( a ) {+ return _empty(a) ?+ '' :+ a.replace ?+ a.replace( /<.*?>/g, "" ).toLowerCase() :+ a+'';+ },++ // string+ "string-pre": function ( a ) {+ // This is a little complex, but faster than always calling toString,+ // http://jsperf.com/tostring-v-check+ return _empty(a) ?+ '' :+ typeof a === 'string' ?+ a.toLowerCase() :+ ! a.toString ?+ '' :+ a.toString();+ },++ // string-asc and -desc are retained only for compatibility with the old+ // sort methods+ "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));+ }+ } );+++ // Numeric sorting types - order doesn't matter here+ _addNumericSort( '' );+++ // Built in type detection. See model.ext.aTypes for information about+ // what is required from this methods.+ $.extend( DataTable.ext.type.detect, [+ // Plain numbers - first since V8 detects some plain numbers as dates+ // e.g. Date.parse('55') (but not all, e.g. Date.parse('22')...).+ function ( d, settings )+ {+ var decimal = settings.oLanguage.sDecimal;+ return _isNumber( d, decimal ) ? 'num'+decimal : null;+ },++ // Dates (only those recognised by the browser's Date.parse)+ function ( d, settings )+ {+ // V8 will remove any unknown characters at the start and end of the+ // expression, leading to false matches such as `$245.12` or `10%` being+ // a valid date. See forum thread 18941 for detail.+ if ( d && ( ! _re_date_start.test(d) || ! _re_date_end.test(d) ) ) {+ return null;+ }+ var parsed = Date.parse(d);+ return (parsed !== null && !isNaN(parsed)) || _empty(d) ? 'date' : null;+ },++ // Formatted numbers+ function ( d, settings )+ {+ var decimal = settings.oLanguage.sDecimal;+ return _isNumber( d, decimal, true ) ? 'num-fmt'+decimal : null;+ },++ // HTML numeric+ function ( d, settings )+ {+ var decimal = settings.oLanguage.sDecimal;+ return _htmlNumeric( d, decimal ) ? 'html-num'+decimal : null;+ },++ // HTML numeric, formatted+ function ( d, settings )+ {+ var decimal = settings.oLanguage.sDecimal;+ return _htmlNumeric( d, decimal, true ) ? 'html-num-fmt'+decimal : null;+ },++ // HTML (this is strict checking - there must be html)+ function ( d, settings )+ {+ return _empty( d ) || (typeof d === 'string' && d.indexOf('<') !== -1) ?+ 'html' : null;+ }+ ] );++++ // Filter formatting functions. See model.ext.ofnSearch for information about+ // what is required from these methods.+++ $.extend( DataTable.ext.type.search, {+ html: function ( data ) {+ return _empty(data) ?+ data :+ typeof data === 'string' ?+ data+ .replace( _re_new_lines, " " )+ .replace( _re_html, "" ) :+ '';+ },++ string: function ( data ) {+ return _empty(data) ?+ data :+ typeof data === 'string' ?+ data.replace( _re_new_lines, " " ) :+ data;+ }+ } );++++ $.extend( true, DataTable.ext.renderer, {+ header: {+ _: function ( settings, cell, column, classes ) {+ // No additional mark-up required+ // Attach a sort listener to update on sort - note that using the+ // `DT` namespace will allow the event to be removed automatically+ // on destroy, while the `dt` namespaced event is the one we are+ // listening for+ $(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {+ if ( settings !== ctx ) { // need to check this this is the host+ return; // table, not a nested one+ }++ var colIdx = column.idx;++ cell+ .removeClass(+ column.sSortingClass +' '++ classes.sSortAsc +' '++ classes.sSortDesc+ )+ .addClass( columns[ colIdx ] == 'asc' ?+ classes.sSortAsc : columns[ colIdx ] == 'desc' ?+ classes.sSortDesc :+ column.sSortingClass+ );+ } );+ },++ jqueryui: function ( settings, cell, column, classes ) {+ var colIdx = column.idx;++ $('<div/>')+ .addClass( classes.sSortJUIWrapper )+ .append( cell.contents() )+ .append( $('<span/>')+ .addClass( classes.sSortIcon+' '+column.sSortingClassJUI )+ )+ .appendTo( cell );++ // Attach a sort listener to update on sort+ $(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {+ if ( settings !== ctx ) {+ return;+ }++ cell+ .removeClass( classes.sSortAsc +" "+classes.sSortDesc )+ .addClass( columns[ colIdx ] == 'asc' ?+ classes.sSortAsc : columns[ colIdx ] == 'desc' ?+ classes.sSortDesc :+ column.sSortingClass+ );++ cell+ .find( 'span.'+classes.sSortIcon )+ .removeClass(+ classes.sSortJUIAsc +" "++ classes.sSortJUIDesc +" "++ classes.sSortJUI +" "++ classes.sSortJUIAscAllowed +" "++ classes.sSortJUIDescAllowed+ )+ .addClass( columns[ colIdx ] == 'asc' ?+ classes.sSortJUIAsc : columns[ colIdx ] == 'desc' ?+ classes.sSortJUIDesc :+ column.sSortingClassJUI+ );+ } );+ }+ }+ } );++ /*+ * Public helper functions. These aren't used internally by DataTables, or+ * called by any of the options passed into DataTables, but they can be used+ * externally by developers working with DataTables. They are helper functions+ * to make working with DataTables a little bit easier.+ */++ /**+ * Helpers for `columns.render`.+ *+ * The options defined here can be used with the `columns.render` initialisation+ * option to provide a display renderer. The following functions are defined:+ *+ * * `number` - Will format numeric data (defined by `columns.data`) for+ * display, retaining the original unformatted data for sorting and filtering.+ * It takes 4 parameters:+ * * `string` - Thousands grouping separator+ * * `string` - Decimal point indicator+ * * `integer` - Number of decimal points to show+ * * `string` (optional) - Prefix.+ *+ * @example+ * // Column definition using the number renderer+ * {+ * data: "salary",+ * render: $.fn.dataTable.render.number( '\'', '.', 0, '$' )+ * }+ *+ * @namespace+ */+ DataTable.render = {+ number: function ( thousands, decimal, precision, prefix ) {+ return {+ display: function ( d ) {+ var negative = d < 0 ? '-' : '';+ d = Math.abs( parseFloat( d ) );++ var intPart = parseInt( d, 10 );+ var floatPart = precision ?+ decimal+(d - intPart).toFixed( precision ).substring( 2 ):+ '';++ return negative + (prefix||'') ++ intPart.toString().replace(+ /\B(?=(\d{3})+(?!\d))/g, thousands+ ) ++ floatPart;+ }+ };+ }+ };+++ /*+ * This is really a good bit rubbish this method of exposing the internal methods+ * publicly... - To be fixed in 2.0 using methods on the prototype+ */+++ /**+ * Create a wrapper function for exporting an internal functions to an external API.+ * @param {string} fn API function name+ * @returns {function} wrapped function+ * @memberof DataTable#internal+ */+ function _fnExternApiFunc (fn)+ {+ return function() {+ var args = [_fnSettingsFromNode( this[DataTable.ext.iApiIndex] )].concat(+ Array.prototype.slice.call(arguments)+ );+ return DataTable.ext.internal[fn].apply( this, args );+ };+ }+++ /**+ * 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.+ * @namespace+ */+ $.extend( DataTable.ext.internal, {+ _fnExternApiFunc: _fnExternApiFunc,+ _fnBuildAjax: _fnBuildAjax,+ _fnAjaxUpdate: _fnAjaxUpdate,+ _fnAjaxParameters: _fnAjaxParameters,+ _fnAjaxUpdateDraw: _fnAjaxUpdateDraw,+ _fnAjaxDataSrc: _fnAjaxDataSrc,+ _fnAddColumn: _fnAddColumn,+ _fnColumnOptions: _fnColumnOptions,+ _fnAdjustColumnSizing: _fnAdjustColumnSizing,+ _fnVisibleToColumnIndex: _fnVisibleToColumnIndex,+ _fnColumnIndexToVisible: _fnColumnIndexToVisible,+ _fnVisbleColumns: _fnVisbleColumns,+ _fnGetColumns: _fnGetColumns,+ _fnColumnTypes: _fnColumnTypes,+ _fnApplyColumnDefs: _fnApplyColumnDefs,+ _fnHungarianMap: _fnHungarianMap,+ _fnCamelToHungarian: _fnCamelToHungarian,+ _fnLanguageCompat: _fnLanguageCompat,+ _fnBrowserDetect: _fnBrowserDetect,+ _fnAddData: _fnAddData,+ _fnAddTr: _fnAddTr,+ _fnNodeToDataIndex: _fnNodeToDataIndex,+ _fnNodeToColumnIndex: _fnNodeToColumnIndex,+ _fnGetCellData: _fnGetCellData,+ _fnSetCellData: _fnSetCellData,+ _fnSplitObjNotation: _fnSplitObjNotation,+ _fnGetObjectDataFn: _fnGetObjectDataFn,+ _fnSetObjectDataFn: _fnSetObjectDataFn,+ _fnGetDataMaster: _fnGetDataMaster,+ _fnClearTable: _fnClearTable,+ _fnDeleteIndex: _fnDeleteIndex,+ _fnInvalidateRow: _fnInvalidateRow,+ _fnGetRowElements: _fnGetRowElements,+ _fnCreateTr: _fnCreateTr,+ _fnBuildHead: _fnBuildHead,+ _fnDrawHead: _fnDrawHead,+ _fnDraw: _fnDraw,+ _fnReDraw: _fnReDraw,+ _fnAddOptionsHtml: _fnAddOptionsHtml,+ _fnDetectHeader: _fnDetectHeader,+ _fnGetUniqueThs: _fnGetUniqueThs,+ _fnFeatureHtmlFilter: _fnFeatureHtmlFilter,+ _fnFilterComplete: _fnFilterComplete,+ _fnFilterCustom: _fnFilterCustom,+ _fnFilterColumn: _fnFilterColumn,+ _fnFilter: _fnFilter,+ _fnFilterCreateSearch: _fnFilterCreateSearch,+ _fnEscapeRegex: _fnEscapeRegex,+ _fnFilterData: _fnFilterData,+ _fnFeatureHtmlInfo: _fnFeatureHtmlInfo,+ _fnUpdateInfo: _fnUpdateInfo,+ _fnInfoMacros: _fnInfoMacros,+ _fnInitialise: _fnInitialise,+ _fnInitComplete: _fnInitComplete,+ _fnLengthChange: _fnLengthChange,+ _fnFeatureHtmlLength: _fnFeatureHtmlLength,+ _fnFeatureHtmlPaginate: _fnFeatureHtmlPaginate,+ _fnPageChange: _fnPageChange,+ _fnFeatureHtmlProcessing: _fnFeatureHtmlProcessing,+ _fnProcessingDisplay: _fnProcessingDisplay,+ _fnFeatureHtmlTable: _fnFeatureHtmlTable,+ _fnScrollDraw: _fnScrollDraw,+ _fnApplyToChildren: _fnApplyToChildren,+ _fnCalculateColumnWidths: _fnCalculateColumnWidths,+ _fnThrottle: _fnThrottle,+ _fnConvertToWidth: _fnConvertToWidth,+ _fnScrollingWidthAdjust: _fnScrollingWidthAdjust,+ _fnGetWidestNode: _fnGetWidestNode,+ _fnGetMaxLenString: _fnGetMaxLenString,+ _fnStringToCss: _fnStringToCss,+ _fnScrollBarWidth: _fnScrollBarWidth,+ _fnSortFlatten: _fnSortFlatten,+ _fnSort: _fnSort,+ _fnSortAria: _fnSortAria,+ _fnSortListener: _fnSortListener,+ _fnSortAttachListener: _fnSortAttachListener,+ _fnSortingClasses: _fnSortingClasses,+ _fnSortData: _fnSortData,+ _fnSaveState: _fnSaveState,+ _fnLoadState: _fnLoadState,+ _fnSettingsFromNode: _fnSettingsFromNode,+ _fnLog: _fnLog,+ _fnMap: _fnMap,+ _fnBindAction: _fnBindAction,+ _fnCallbackReg: _fnCallbackReg,+ _fnCallbackFire: _fnCallbackFire,+ _fnLengthOverflow: _fnLengthOverflow,+ _fnRenderer: _fnRenderer,+ _fnDataSource: _fnDataSource,+ _fnRowAttributes: _fnRowAttributes,+ _fnCalculateEnd: function () {} // Used by a lot of plug-ins, but redundant+ // in 1.10, so this dead-end function is+ // added to prevent errors+ } );+++ // jQuery access+ $.fn.dataTable = DataTable;++ // Legacy aliases+ $.fn.dataTableSettings = DataTable.settings;+ $.fn.dataTableExt = DataTable.ext;++ // With a capital `D` we return a DataTables API instance rather than a+ // jQuery object+ $.fn.DataTable = function ( opts ) {+ return $(this).dataTable( opts ).api();+ };++ // All properties that are available to $.fn.dataTable should also be+ // available on $.fn.DataTable+ $.each( DataTable, function ( prop, val ) {+ $.fn.DataTable[ prop ] = val;+ } );+++ // Information about events fired by DataTables - for documentation.+ /**+ * 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.+ * @name DataTable#draw.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * Search event, fired when the searching applied to the table (using the+ * built-in global search, or column filters) is altered.+ * @name DataTable#search.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * Page change event, fired when the paging of the table is altered.+ * @name DataTable#page.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * Order event, fired when the ordering applied to the table is altered.+ * @name DataTable#order.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * DataTables initialisation complete event, fired when the table is fully+ * drawn, including Ajax data loaded, if Ajax data is required.+ * @name DataTable#init.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} oSettings DataTables settings object+ * @param {object} json The JSON object request from the server - only+ * present if client-side Ajax sourced data is used</li></ol>+ */++ /**+ * State save event, fired when the table has changed state a new state save+ * is required. This event 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.+ * @name DataTable#stateSaveParams.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} oSettings DataTables settings object+ * @param {object} json The state information to be saved+ */++ /**+ * 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.+ * @name DataTable#stateLoadParams.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} oSettings DataTables settings object+ * @param {object} json The saved state information+ */++ /**+ * State loaded event, fired when state has been loaded from stored data and+ * the settings object has been modified by the loaded data.+ * @name DataTable#stateLoaded.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} oSettings DataTables settings object+ * @param {object} json The saved state information+ */++ /**+ * Processing event, fired when DataTables is doing some kind of processing+ * (be it, order, searcg or anything else). It can be used to indicate to+ * the end user that there is something happening, or that something has+ * finished.+ * @name DataTable#processing.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} oSettings DataTables settings object+ * @param {boolean} bShow Flag for if DataTables is doing processing or not+ */++ /**+ * Ajax (XHR) event, fired whenever an Ajax request is completed from a+ * request to made to the server for new data. This event is called before+ * DataTables processed the returned data, so it can also be used to pre-+ * process the data returned from the server, if needed.+ *+ * 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.+ * @name DataTable#xhr.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ * @param {object} json JSON returned from the server+ *+ * @example+ * // Use a custom property returned from the server in another DOM element+ * $('#table').dataTable().on('xhr.dt', function (e, settings, json) {+ * $('#status').html( json.status );+ * } );+ *+ * @example+ * // Pre-process the data returned from the server+ * $('#table').dataTable().on('xhr.dt', function (e, settings, json) {+ * for ( var i=0, ien=json.aaData.length ; i<ien ; i++ ) {+ * json.aaData[i].sum = json.aaData[i].one + json.aaData[i].two;+ * }+ * // Note no return - manipulate the data directly in the JSON object.+ * } );+ */++ /**+ * 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.+ * @name DataTable#destroy.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * Page length change event, fired when number of records to show on each+ * page (the length) is changed.+ * @name DataTable#length.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ * @param {integer} len New length+ */++ /**+ * Column sizing has changed.+ * @name DataTable#column-sizing.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ */++ /**+ * Column visibility has changed.+ * @name DataTable#column-visibility.dt+ * @event+ * @param {event} e jQuery event object+ * @param {object} o DataTables settings object {@link DataTable.models.oSettings}+ * @param {int} column Column index+ * @param {bool} vis `false` if column now hidden, or `true` if visible+ */++ return $.fn.dataTable;+}));++}(window, document));+diff --git a/wger/core/static/js/jquery.dataTables.min.js b/wger/core/static/js/jquery.dataTables.min.jsnew file mode 100644index 000000000..3248d7490--- /dev/null+++ b/wger/core/static/js/jquery.dataTables.min.js@@ -0,0 +1,155 @@+/*! DataTables 1.10.2+ * ©2008-2014 SpryMedia Ltd - datatables.net/license+ */+(function(za,O,l){var N=function(h){function T(a){var b,c,d={};h.each(a,function(e){if((b=e.match(/^([^A-Z]+?)([A-Z])/))&&-1!=="a aa ai ao as b fn i m o s ".indexOf(b[1]+" "))c=e.replace(b[0],b[2].toLowerCase()),d[c]=e,"o"===b[1]&&T(a[e])});a._hungarianMap=d}function G(a,b,c){a._hungarianMap||T(a);var d;h.each(b,function(e){d=a._hungarianMap[e];if(d!==l&&(c||b[d]===l))"o"===d.charAt(0)?(b[d]||(b[d]={}),h.extend(!0,b[d],b[e]),G(a[d],b[d],c)):b[d]=b[e]})}function N(a){var b=p.defaults.oLanguage,c=a.sZeroRecords;+!a.sEmptyTable&&(c&&"No data available in table"===b.sEmptyTable)&&D(a,a,"sZeroRecords","sEmptyTable");!a.sLoadingRecords&&(c&&"Loading..."===b.sLoadingRecords)&&D(a,a,"sZeroRecords","sLoadingRecords");a.sInfoThousands&&(a.sThousands=a.sInfoThousands);(a=a.sDecimal)&&cb(a)}function db(a){w(a,"ordering","bSort");w(a,"orderMulti","bSortMulti");w(a,"orderClasses","bSortClasses");w(a,"orderCellsTop","bSortCellsTop");w(a,"order","aaSorting");w(a,"orderFixed","aaSortingFixed");w(a,"paging","bPaginate");+w(a,"pagingType","sPaginationType");w(a,"pageLength","iDisplayLength");w(a,"searching","bFilter");if(a=a.aoSearchCols)for(var b=0,c=a.length;b<c;b++)a[b]&&G(p.models.oSearch,a[b])}function eb(a){w(a,"orderable","bSortable");w(a,"orderData","aDataSort");w(a,"orderSequence","asSorting");w(a,"orderDataType","sortDataType")}function fb(a){var a=a.oBrowser,b=h("<div/>").css({position:"absolute",top:0,left:0,height:1,width:1,overflow:"hidden"}).append(h("<div/>").css({position:"absolute",top:1,left:1,width:100,+overflow:"scroll"}).append(h('<div class="test"/>').css({width:"100%",height:10}))).appendTo("body"),c=b.find(".test");a.bScrollOversize=100===c[0].offsetWidth;a.bScrollbarLeft=1!==c.offset().left;b.remove()}function gb(a,b,c,d,e,f){var g,j=!1;c!==l&&(g=c,j=!0);for(;d!==e;)a.hasOwnProperty(d)&&(g=j?b(g,a[d],d,a):a[d],j=!0,d+=f);return g}function Aa(a,b){var c=p.defaults.column,d=a.aoColumns.length,c=h.extend({},p.models.oColumn,c,{nTh:b?b:O.createElement("th"),sTitle:c.sTitle?c.sTitle:b?b.innerHTML:+"",aDataSort:c.aDataSort?c.aDataSort:[d],mData:c.mData?c.mData:d,idx:d});a.aoColumns.push(c);c=a.aoPreSearchCols;c[d]=h.extend({},p.models.oSearch,c[d]);fa(a,d,null)}function fa(a,b,c){var b=a.aoColumns[b],d=a.oClasses,e=h(b.nTh);if(!b.sWidthOrig){b.sWidthOrig=e.attr("width")||null;var f=(e.attr("style")||"").match(/width:\s*(\d+[pxem%]+)/);f&&(b.sWidthOrig=f[1])}c!==l&&null!==c&&(eb(c),G(p.defaults.column,c),c.mDataProp!==l&&!c.mData&&(c.mData=c.mDataProp),c.sType&&(b._sManualType=c.sType),c.className&&+!c.sClass&&(c.sClass=c.className),h.extend(b,c),D(b,c,"sWidth","sWidthOrig"),"number"===typeof c.iDataSort&&(b.aDataSort=[c.iDataSort]),D(b,c,"aDataSort"));var g=b.mData,j=U(g),i=b.mRender?U(b.mRender):null,c=function(a){return"string"===typeof a&&-1!==a.indexOf("@")};b._bAttrSrc=h.isPlainObject(g)&&(c(g.sort)||c(g.type)||c(g.filter));b.fnGetData=function(a,b,c){var d=j(a,b,l,c);return i&&b?i(d,b,a,c):d};b.fnSetData=function(a,b,c){return Ba(g)(a,b,c)};a.oFeatures.bSort||(b.bSortable=!1,e.addClass(d.sSortableNone));+a=-1!==h.inArray("asc",b.asSorting);c=-1!==h.inArray("desc",b.asSorting);!b.bSortable||!a&&!c?(b.sSortingClass=d.sSortableNone,b.sSortingClassJUI=""):a&&!c?(b.sSortingClass=d.sSortableAsc,b.sSortingClassJUI=d.sSortJUIAscAllowed):!a&&c?(b.sSortingClass=d.sSortableDesc,b.sSortingClassJUI=d.sSortJUIDescAllowed):(b.sSortingClass=d.sSortable,b.sSortingClassJUI=d.sSortJUI)}function V(a){if(!1!==a.oFeatures.bAutoWidth){var b=a.aoColumns;Ca(a);for(var c=0,d=b.length;c<d;c++)b[c].nTh.style.width=b[c].sWidth}b=+a.oScroll;(""!==b.sY||""!==b.sX)&&W(a);u(a,null,"column-sizing",[a])}function ga(a,b){var c=X(a,"bVisible");return"number"===typeof c[b]?c[b]:null}function Y(a,b){var c=X(a,"bVisible"),c=h.inArray(b,c);return-1!==c?c:null}function Z(a){return X(a,"bVisible").length}function X(a,b){var c=[];h.map(a.aoColumns,function(a,e){a[b]&&c.push(e)});return c}function Da(a){var b=a.aoColumns,c=a.aoData,d=p.ext.type.detect,e,f,g,j,i,h,m,o,k;e=0;for(f=b.length;e<f;e++)if(m=b[e],k=[],!m.sType&&m._sManualType)m.sType=+m._sManualType;else if(!m.sType){g=0;for(j=d.length;g<j;g++){i=0;for(h=c.length;i<h&&!(k[i]===l&&(k[i]=A(a,i,e,"type")),o=d[g](k[i],a),!o||"html"===o);i++);if(o){m.sType=o;break}}m.sType||(m.sType="string")}}function hb(a,b,c,d){var e,f,g,j,i,n,m=a.aoColumns;if(b)for(e=b.length-1;0<=e;e--){n=b[e];var o=n.targets!==l?n.targets:n.aTargets;h.isArray(o)||(o=[o]);f=0;for(g=o.length;f<g;f++)if("number"===typeof o[f]&&0<=o[f]){for(;m.length<=o[f];)Aa(a);d(o[f],n)}else if("number"===typeof o[f]&&0>o[f])d(m.length++o[f],n);else if("string"===typeof o[f]){j=0;for(i=m.length;j<i;j++)("_all"==o[f]||h(m[j].nTh).hasClass(o[f]))&&d(j,n)}}if(c){e=0;for(a=c.length;e<a;e++)d(e,c[e])}}function I(a,b,c,d){var e=a.aoData.length,f=h.extend(!0,{},p.models.oRow,{src:c?"dom":"data"});f._aData=b;a.aoData.push(f);for(var b=a.aoColumns,f=0,g=b.length;f<g;f++)c&&Ea(a,e,f,A(a,e,f)),b[f].sType=null;a.aiDisplayMaster.push(e);(c||!a.oFeatures.bDeferRender)&&Fa(a,e,c,d);return e}function ha(a,b){var c;b instanceof h||(b=h(b));return b.map(function(b,+e){c=ia(a,e);return I(a,c.data,e,c.cells)})}function A(a,b,c,d){var e=a.iDraw,f=a.aoColumns[c],g=a.aoData[b]._aData,j=f.sDefaultContent,c=f.fnGetData(g,d,{settings:a,row:b,col:c});if(c===l)return a.iDrawError!=e&&null===j&&(P(a,0,"Requested unknown parameter "+("function"==typeof f.mData?"{function}":"'"+f.mData+"'")+" for row "+b,4),a.iDrawError=e),j;if((c===g||null===c)&&null!==j)c=j;else if("function"===typeof c)return c.call(g);return null===c&&"display"==d?"":c}function Ea(a,b,c,d){a.aoColumns[c].fnSetData(a.aoData[b]._aData,+d,{settings:a,row:b,col:c})}function Ga(a){return h.map(a.match(/(\\.|[^\.])+/g),function(a){return a.replace(/\\./g,".")})}function U(a){if(h.isPlainObject(a)){var b={};h.each(a,function(a,c){c&&(b[a]=U(c))});return function(a,c,f,g){var j=b[c]||b._;return j!==l?j(a,c,f,g):a}}if(null===a)return function(a){return a};if("function"===typeof a)return function(b,c,f,g){return a(b,c,f,g)};if("string"===typeof a&&(-1!==a.indexOf(".")||-1!==a.indexOf("[")||-1!==a.indexOf("("))){var c=function(a,b,f){var g,+j;if(""!==f){j=Ga(f);for(var i=0,h=j.length;i<h;i++){f=j[i].match($);g=j[i].match(Q);if(f){j[i]=j[i].replace($,"");""!==j[i]&&(a=a[j[i]]);g=[];j.splice(0,i+1);j=j.join(".");i=0;for(h=a.length;i<h;i++)g.push(c(a[i],b,j));a=f[0].substring(1,f[0].length-1);a=""===a?g:g.join(a);break}else if(g){j[i]=j[i].replace(Q,"");a=a[j[i]]();continue}if(null===a||a[j[i]]===l)return l;a=a[j[i]]}}return a};return function(b,e){return c(b,e,a)}}return function(b){return b[a]}}function Ba(a){if(h.isPlainObject(a))return Ba(a._);+if(null===a)return function(){};if("function"===typeof a)return function(b,d,e){a(b,"set",d,e)};if("string"===typeof a&&(-1!==a.indexOf(".")||-1!==a.indexOf("[")||-1!==a.indexOf("("))){var b=function(a,d,e){var e=Ga(e),f;f=e[e.length-1];for(var g,j,i=0,h=e.length-1;i<h;i++){g=e[i].match($);j=e[i].match(Q);if(g){e[i]=e[i].replace($,"");a[e[i]]=[];f=e.slice();f.splice(0,i+1);g=f.join(".");j=0;for(h=d.length;j<h;j++)f={},b(f,d[j],g),a[e[i]].push(f);return}j&&(e[i]=e[i].replace(Q,""),a=a[e[i]](d));if(null===+a[e[i]]||a[e[i]]===l)a[e[i]]={};a=a[e[i]]}if(f.match(Q))a[f.replace(Q,"")](d);else a[f.replace($,"")]=d};return function(c,d){return b(c,d,a)}}return function(b,d){b[a]=d}}function Ha(a){return C(a.aoData,"_aData")}function ja(a){a.aoData.length=0;a.aiDisplayMaster.length=0;a.aiDisplay.length=0}function ka(a,b,c){for(var d=-1,e=0,f=a.length;e<f;e++)a[e]==b?d=e:a[e]>b&&a[e]--; -1!=d&&c===l&&a.splice(d,1)}function la(a,b,c,d){var e=a.aoData[b],f;if("dom"===c||(!c||"auto"===c)&&"dom"===e.src)e._aData=+ia(a,e).data;else{var g=e.anCells,j;if(g){c=0;for(f=g.length;c<f;c++){for(j=g[c];j.childNodes.length;)j.removeChild(j.firstChild);g[c].innerHTML=A(a,b,c,"display")}}}e._aSortData=null;e._aFilterData=null;a=a.aoColumns;if(d!==l)a[d].sType=null;else{c=0;for(f=a.length;c<f;c++)a[c].sType=null}Ia(e)}function ia(a,b){var c=[],d=[],e=b.firstChild,f,g,j,i=0,n,m=a.aoColumns,o=function(a,b,c){"string"===typeof a&&(b=a.indexOf("@"),-1!==b&&(a=a.substring(b+1),j["@"+a]=c.getAttribute(a)))},k=function(a){g=m[i];+n=h.trim(a.innerHTML);g&&g._bAttrSrc?(j={display:n},o(g.mData.sort,j,a),o(g.mData.type,j,a),o(g.mData.filter,j,a),c.push(j)):c.push(n);i++};if(e)for(;e;){f=e.nodeName.toUpperCase();if("TD"==f||"TH"==f)k(e),d.push(e);e=e.nextSibling}else{d=b.anCells;e=0;for(f=d.length;e<f;e++)k(d[e])}return{data:c,cells:d}}function Fa(a,b,c,d){var e=a.aoData[b],f=e._aData,g=[],j,i,h,m,o;if(null===e.nTr){j=c||O.createElement("tr");e.nTr=j;e.anCells=g;j._DT_RowIndex=b;Ia(e);m=0;for(o=a.aoColumns.length;m<o;m++){h=a.aoColumns[m];+i=c?d[m]:O.createElement(h.sCellType);g.push(i);if(!c||h.mRender||h.mData!==m)i.innerHTML=A(a,b,m,"display");h.sClass&&(i.className+=" "+h.sClass);h.bVisible&&!c?j.appendChild(i):!h.bVisible&&c&&i.parentNode.removeChild(i);h.fnCreatedCell&&h.fnCreatedCell.call(a.oInstance,i,A(a,b,m),f,b,m)}u(a,"aoRowCreatedCallback",null,[j,f,b])}e.nTr.setAttribute("role","row")}function Ia(a){var b=a.nTr,c=a._aData;if(b){c.DT_RowId&&(b.id=c.DT_RowId);if(c.DT_RowClass){var d=c.DT_RowClass.split(" ");a.__rowc=a.__rowc?+Ja(a.__rowc.concat(d)):d;h(b).removeClass(a.__rowc.join(" ")).addClass(c.DT_RowClass)}c.DT_RowData&&h(b).data(c.DT_RowData)}}function ib(a){var b,c,d,e,f,g=a.nTHead,j=a.nTFoot,i=0===h("th, td",g).length,n=a.oClasses,m=a.aoColumns;i&&(e=h("<tr/>").appendTo(g));b=0;for(c=m.length;b<c;b++)f=m[b],d=h(f.nTh).addClass(f.sClass),i&&d.appendTo(e),a.oFeatures.bSort&&(d.addClass(f.sSortingClass),!1!==f.bSortable&&(d.attr("tabindex",a.iTabIndex).attr("aria-controls",a.sTableId),Ka(a,f.nTh,b))),f.sTitle!=d.html()&&+d.html(f.sTitle),La(a,"header")(a,d,f,n);i&&aa(a.aoHeader,g);h(g).find(">tr").attr("role","row");h(g).find(">tr>th, >tr>td").addClass(n.sHeaderTH);h(j).find(">tr>th, >tr>td").addClass(n.sFooterTH);if(null!==j){a=a.aoFooter[0];b=0;for(c=a.length;b<c;b++)f=m[b],f.nTf=a[b].cell,f.sClass&&h(f.nTf).addClass(f.sClass)}}function ba(a,b,c){var d,e,f,g=[],j=[],i=a.aoColumns.length,n;if(b){c===l&&(c=!1);d=0;for(e=b.length;d<e;d++){g[d]=b[d].slice();g[d].nTr=b[d].nTr;for(f=i-1;0<=f;f--)!a.aoColumns[f].bVisible&&+!c&&g[d].splice(f,1);j.push([])}d=0;for(e=g.length;d<e;d++){if(a=g[d].nTr)for(;f=a.firstChild;)a.removeChild(f);f=0;for(b=g[d].length;f<b;f++)if(n=i=1,j[d][f]===l){a.appendChild(g[d][f].cell);for(j[d][f]=1;g[d+i]!==l&&g[d][f].cell==g[d+i][f].cell;)j[d+i][f]=1,i++;for(;g[d][f+n]!==l&&g[d][f].cell==g[d][f+n].cell;){for(c=0;c<i;c++)j[d+c][f+n]=1;n++}h(g[d][f].cell).attr("rowspan",i).attr("colspan",n)}}}}function K(a){var b=u(a,"aoPreDrawCallback","preDraw",[a]);if(-1!==h.inArray(!1,b))B(a,!1);else{var b=+[],c=0,d=a.asStripeClasses,e=d.length,f=a.oLanguage,g=a.iInitDisplayStart,j="ssp"==z(a),i=a.aiDisplay;a.bDrawing=!0;g!==l&&-1!==g&&(a._iDisplayStart=j?g:g>=a.fnRecordsDisplay()?0:g,a.iInitDisplayStart=-1);var g=a._iDisplayStart,n=a.fnDisplayEnd();if(a.bDeferLoading)a.bDeferLoading=!1,a.iDraw++,B(a,!1);else if(j){if(!a.bDestroying&&!jb(a))return}else a.iDraw++;if(0!==i.length){f=j?a.aoData.length:n;for(j=j?0:g;j<f;j++){var m=i[j],o=a.aoData[m];null===o.nTr&&Fa(a,m);m=o.nTr;if(0!==e){var k=d[c%e];o._sRowStripe!=+k&&(h(m).removeClass(o._sRowStripe).addClass(k),o._sRowStripe=k)}u(a,"aoRowCallback",null,[m,o._aData,c,j]);b.push(m);c++}}else c=f.sZeroRecords,1==a.iDraw&&"ajax"==z(a)?c=f.sLoadingRecords:f.sEmptyTable&&0===a.fnRecordsTotal()&&(c=f.sEmptyTable),b[0]=h("<tr/>",{"class":e?d[0]:""}).append(h("<td />",{valign:"top",colSpan:Z(a),"class":a.oClasses.sRowEmpty}).html(c))[0];u(a,"aoHeaderCallback","header",[h(a.nTHead).children("tr")[0],Ha(a),g,n,i]);u(a,"aoFooterCallback","footer",[h(a.nTFoot).children("tr")[0],+Ha(a),g,n,i]);d=h(a.nTBody);d.children().detach();d.append(h(b));u(a,"aoDrawCallback","draw",[a]);a.bSorted=!1;a.bFiltered=!1;a.bDrawing=!1}}function L(a,b){var c=a.oFeatures,d=c.bFilter;c.bSort&&kb(a);d?ca(a,a.oPreviousSearch):a.aiDisplay=a.aiDisplayMaster.slice();!0!==b&&(a._iDisplayStart=0);a._drawHold=b;K(a);a._drawHold=!1}function lb(a){var b=a.oClasses,c=h(a.nTable),c=h("<div/>").insertBefore(c),d=a.oFeatures,e=h("<div/>",{id:a.sTableId+"_wrapper","class":b.sWrapper+(a.nTFoot?"":" "+b.sNoFooter)});+a.nHolding=c[0];a.nTableWrapper=e[0];a.nTableReinsertBefore=a.nTable.nextSibling;for(var f=a.sDom.split(""),g,j,i,n,m,o,k=0;k<f.length;k++){g=null;j=f[k];if("<"==j){i=h("<div/>")[0];n=f[k+1];if("'"==n||'"'==n){m="";for(o=2;f[k+o]!=n;)m+=f[k+o],o++;"H"==m?m=b.sJUIHeader:"F"==m&&(m=b.sJUIFooter);-1!=m.indexOf(".")?(n=m.split("."),i.id=n[0].substr(1,n[0].length-1),i.className=n[1]):"#"==m.charAt(0)?i.id=m.substr(1,m.length-1):i.className=m;k+=o}e.append(i);e=h(i)}else if(">"==j)e=e.parent();else if("l"==+j&&d.bPaginate&&d.bLengthChange)g=mb(a);else if("f"==j&&d.bFilter)g=nb(a);else if("r"==j&&d.bProcessing)g=ob(a);else if("t"==j)g=pb(a);else if("i"==j&&d.bInfo)g=qb(a);else if("p"==j&&d.bPaginate)g=rb(a);else if(0!==p.ext.feature.length){i=p.ext.feature;o=0;for(n=i.length;o<n;o++)if(j==i[o].cFeature){g=i[o].fnInit(a);break}}g&&(i=a.aanFeatures,i[j]||(i[j]=[]),i[j].push(g),e.append(g))}c.replaceWith(e)}function aa(a,b){var c=h(b).children("tr"),d,e,f,g,j,i,n,m,o,k;a.splice(0,a.length);f=0;for(i=c.length;f<+i;f++)a.push([]);f=0;for(i=c.length;f<i;f++){d=c[f];for(e=d.firstChild;e;){if("TD"==e.nodeName.toUpperCase()||"TH"==e.nodeName.toUpperCase()){m=1*e.getAttribute("colspan");o=1*e.getAttribute("rowspan");m=!m||0===m||1===m?1:m;o=!o||0===o||1===o?1:o;g=0;for(j=a[f];j[g];)g++;n=g;k=1===m?!0:!1;for(j=0;j<m;j++)for(g=0;g<o;g++)a[f+g][n+j]={cell:e,unique:k},a[f+g].nTr=d}e=e.nextSibling}}}function ma(a,b,c){var d=[];c||(c=a.aoHeader,b&&(c=[],aa(c,b)));for(var b=0,e=c.length;b<e;b++)for(var f=0,g=c[b].length;f<+g;f++)if(c[b][f].unique&&(!d[f]||!a.bSortCellsTop))d[f]=c[b][f].cell;return d}function na(a,b,c){u(a,"aoServerParams","serverParams",[b]);if(b&&h.isArray(b)){var d={},e=/(.*?)\[\]$/;h.each(b,function(a,b){var c=b.name.match(e);c?(c=c[0],d[c]||(d[c]=[]),d[c].push(b.value)):d[b.name]=b.value});b=d}var f,g=a.ajax,j=a.oInstance;if(h.isPlainObject(g)&&g.data){f=g.data;var i=h.isFunction(f)?f(b):f,b=h.isFunction(f)&&i?i:h.extend(!0,b,i);delete g.data}i={data:b,success:function(b){var d=b.error||b.sError;+d&&a.oApi._fnLog(a,0,d);a.json=b;u(a,null,"xhr",[a,b]);c(b)},dataType:"json",cache:!1,type:a.sServerMethod,error:function(b,c){var d=a.oApi._fnLog;"parsererror"==c?d(a,0,"Invalid JSON response",1):4===b.readyState&&d(a,0,"Ajax error",7);B(a,!1)}};a.oAjaxData=b;u(a,null,"preXhr",[a,b]);a.fnServerData?a.fnServerData.call(j,a.sAjaxSource,h.map(b,function(a,b){return{name:b,value:a}}),c,a):a.sAjaxSource||"string"===typeof g?a.jqXHR=h.ajax(h.extend(i,{url:g||a.sAjaxSource})):h.isFunction(g)?a.jqXHR=g.call(j,+b,c,a):(a.jqXHR=h.ajax(h.extend(i,g)),g.data=f)}function jb(a){return a.bAjaxDataGet?(a.iDraw++,B(a,!0),na(a,sb(a),function(b){tb(a,b)}),!1):!0}function sb(a){var b=a.aoColumns,c=b.length,d=a.oFeatures,e=a.oPreviousSearch,f=a.aoPreSearchCols,g,j=[],i,n,m,o=R(a);g=a._iDisplayStart;i=!1!==d.bPaginate?a._iDisplayLength:-1;var k=function(a,b){j.push({name:a,value:b})};k("sEcho",a.iDraw);k("iColumns",c);k("sColumns",C(b,"sName").join(","));k("iDisplayStart",g);k("iDisplayLength",i);var l={draw:a.iDraw,+columns:[],order:[],start:g,length:i,search:{value:e.sSearch,regex:e.bRegex}};for(g=0;g<c;g++)n=b[g],m=f[g],i="function"==typeof n.mData?"function":n.mData,l.columns.push({data:i,name:n.sName,searchable:n.bSearchable,orderable:n.bSortable,search:{value:m.sSearch,regex:m.bRegex}}),k("mDataProp_"+g,i),d.bFilter&&(k("sSearch_"+g,m.sSearch),k("bRegex_"+g,m.bRegex),k("bSearchable_"+g,n.bSearchable)),d.bSort&&k("bSortable_"+g,n.bSortable);d.bFilter&&(k("sSearch",e.sSearch),k("bRegex",e.bRegex));d.bSort&&+(h.each(o,function(a,b){l.order.push({column:b.col,dir:b.dir});k("iSortCol_"+a,b.col);k("sSortDir_"+a,b.dir)}),k("iSortingCols",o.length));b=p.ext.legacy.ajax;return null===b?a.sAjaxSource?j:l:b?j:l}function tb(a,b){var c=b.sEcho!==l?b.sEcho:b.draw,d=b.iTotalRecords!==l?b.iTotalRecords:b.recordsTotal,e=b.iTotalDisplayRecords!==l?b.iTotalDisplayRecords:b.recordsFiltered;if(c){if(1*c<a.iDraw)return;a.iDraw=1*c}ja(a);a._iRecordsTotal=parseInt(d,10);a._iRecordsDisplay=parseInt(e,10);c=oa(a,b);d=0;for(e=+c.length;d<e;d++)I(a,c[d]);a.aiDisplay=a.aiDisplayMaster.slice();a.bAjaxDataGet=!1;K(a);a._bInitComplete||pa(a,b);a.bAjaxDataGet=!0;B(a,!1)}function oa(a,b){var c=h.isPlainObject(a.ajax)&&a.ajax.dataSrc!==l?a.ajax.dataSrc:a.sAjaxDataProp;return"data"===c?b.aaData||b[c]:""!==c?U(c)(b):b}function nb(a){var b=a.oClasses,c=a.sTableId,d=a.oLanguage,e=a.oPreviousSearch,f=a.aanFeatures,g='<input type="search" class="'+b.sFilterInput+'"/>',j=d.sSearch,j=j.match(/_INPUT_/)?j.replace("_INPUT_",g):j+g,b=h("<div/>",+{id:!f.f?c+"_filter":null,"class":b.sFilter}).append(h("<label/>").append(j)),f=function(){var b=!this.value?"":this.value;b!=e.sSearch&&(ca(a,{sSearch:b,bRegex:e.bRegex,bSmart:e.bSmart,bCaseInsensitive:e.bCaseInsensitive}),a._iDisplayStart=0,K(a))},i=h("input",b).val(e.sSearch).attr("placeholder",d.sSearchPlaceholder).bind("keyup.DT search.DT input.DT paste.DT cut.DT","ssp"===z(a)?Ma(f,400):f).bind("keypress.DT",function(a){if(13==a.keyCode)return!1}).attr("aria-controls",c);h(a.nTable).on("search.dt.DT",+function(b,c){if(a===c)try{i[0]!==O.activeElement&&i.val(e.sSearch)}catch(d){}});return b[0]}function ca(a,b,c){var d=a.oPreviousSearch,e=a.aoPreSearchCols,f=function(a){d.sSearch=a.sSearch;d.bRegex=a.bRegex;d.bSmart=a.bSmart;d.bCaseInsensitive=a.bCaseInsensitive};Da(a);if("ssp"!=z(a)){ub(a,b.sSearch,c,b.bEscapeRegex!==l?!b.bEscapeRegex:b.bRegex,b.bSmart,b.bCaseInsensitive);f(b);for(b=0;b<e.length;b++)vb(a,e[b].sSearch,b,e[b].bEscapeRegex!==l?!e[b].bEscapeRegex:e[b].bRegex,e[b].bSmart,e[b].bCaseInsensitive);+wb(a)}else f(b);a.bFiltered=!0;u(a,null,"search",[a])}function wb(a){for(var b=p.ext.search,c=a.aiDisplay,d,e,f=0,g=b.length;f<g;f++){for(var j=[],i=0,h=c.length;i<h;i++)e=c[i],d=a.aoData[e],b[f](a,d._aFilterData,e,d._aData,i)&&j.push(e);c.length=0;c.push.apply(c,j)}}function vb(a,b,c,d,e,f){if(""!==b)for(var g=a.aiDisplay,d=Na(b,d,e,f),e=g.length-1;0<=e;e--)b=a.aoData[g[e]]._aFilterData[c],d.test(b)||g.splice(e,1)}function ub(a,b,c,d,e,f){var d=Na(b,d,e,f),e=a.oPreviousSearch.sSearch,f=a.aiDisplayMaster,+g;0!==p.ext.search.length&&(c=!0);g=xb(a);if(0>=b.length)a.aiDisplay=f.slice();else{if(g||c||e.length>b.length||0!==b.indexOf(e)||a.bSorted)a.aiDisplay=f.slice();b=a.aiDisplay;for(c=b.length-1;0<=c;c--)d.test(a.aoData[b[c]]._sFilterRow)||b.splice(c,1)}}function Na(a,b,c,d){a=b?a:Oa(a);c&&(a="^(?=.*?"+h.map(a.match(/"[^"]+"|[^ ]+/g)||"",function(a){return'"'===a.charAt(0)?a.match(/^"(.*)"$/)[1]:a}).join(")(?=.*?")+").*$");return RegExp(a,d?"i":"")}function Oa(a){return a.replace(Vb,"\\$1")}function xb(a){var b=+a.aoColumns,c,d,e,f,g,j,i,h,m=p.ext.type.search;c=!1;d=0;for(f=a.aoData.length;d<f;d++)if(h=a.aoData[d],!h._aFilterData){j=[];e=0;for(g=b.length;e<g;e++)c=b[e],c.bSearchable?(i=A(a,d,e,"filter"),m[c.sType]&&(i=m[c.sType](i)),null===i&&(i=""),"string"!==typeof i&&i.toString&&(i=i.toString())):i="",i.indexOf&&-1!==i.indexOf("&")&&(qa.innerHTML=i,i=Wb?qa.textContent:qa.innerText),i.replace&&(i=i.replace(/[\r\n]/g,"")),j.push(i);h._aFilterData=j;h._sFilterRow=j.join(" ");c=!0}return c}function yb(a){return{search:a.sSearch,+smart:a.bSmart,regex:a.bRegex,caseInsensitive:a.bCaseInsensitive}}function zb(a){return{sSearch:a.search,bSmart:a.smart,bRegex:a.regex,bCaseInsensitive:a.caseInsensitive}}function qb(a){var b=a.sTableId,c=a.aanFeatures.i,d=h("<div/>",{"class":a.oClasses.sInfo,id:!c?b+"_info":null});c||(a.aoDrawCallback.push({fn:Ab,sName:"information"}),d.attr("role","status").attr("aria-live","polite"),h(a.nTable).attr("aria-describedby",b+"_info"));return d[0]}function Ab(a){var b=a.aanFeatures.i;if(0!==b.length){var c=+a.oLanguage,d=a._iDisplayStart+1,e=a.fnDisplayEnd(),f=a.fnRecordsTotal(),g=a.fnRecordsDisplay(),j=g?c.sInfo:c.sInfoEmpty;g!==f&&(j+=" "+c.sInfoFiltered);j+=c.sInfoPostFix;j=Bb(a,j);c=c.fnInfoCallback;null!==c&&(j=c.call(a.oInstance,a,d,e,f,g,j));h(b).html(j)}}function Bb(a,b){var c=a.fnFormatNumber,d=a._iDisplayStart+1,e=a._iDisplayLength,f=a.fnRecordsDisplay(),g=-1===e;return b.replace(/_START_/g,c.call(a,d)).replace(/_END_/g,c.call(a,a.fnDisplayEnd())).replace(/_MAX_/g,c.call(a,a.fnRecordsTotal())).replace(/_TOTAL_/g,+c.call(a,f)).replace(/_PAGE_/g,c.call(a,g?1:Math.ceil(d/e))).replace(/_PAGES_/g,c.call(a,g?1:Math.ceil(f/e)))}function ra(a){var b,c,d=a.iInitDisplayStart,e=a.aoColumns,f;c=a.oFeatures;if(a.bInitialised){lb(a);ib(a);ba(a,a.aoHeader);ba(a,a.aoFooter);B(a,!0);c.bAutoWidth&&Ca(a);b=0;for(c=e.length;b<c;b++)f=e[b],f.sWidth&&(f.nTh.style.width=s(f.sWidth));L(a);e=z(a);"ssp"!=e&&("ajax"==e?na(a,[],function(c){var f=oa(a,c);for(b=0;b<f.length;b++)I(a,f[b]);a.iInitDisplayStart=d;L(a);B(a,!1);pa(a,c)},a):+(B(a,!1),pa(a)))}else setTimeout(function(){ra(a)},200)}function pa(a,b){a._bInitComplete=!0;b&&V(a);u(a,"aoInitComplete","init",[a,b])}function Pa(a,b){var c=parseInt(b,10);a._iDisplayLength=c;Qa(a);u(a,null,"length",[a,c])}function mb(a){for(var b=a.oClasses,c=a.sTableId,d=a.aLengthMenu,e=h.isArray(d[0]),f=e?d[0]:d,d=e?d[1]:d,e=h("<select/>",{name:c+"_length","aria-controls":c,"class":b.sLengthSelect}),g=0,j=f.length;g<j;g++)e[0][g]=new Option(d[g],f[g]);var i=h("<div><label/></div>").addClass(b.sLength);+a.aanFeatures.l||(i[0].id=c+"_length");i.children().append(a.oLanguage.sLengthMenu.replace("_MENU_",e[0].outerHTML));h("select",i).val(a._iDisplayLength).bind("change.DT",function(){Pa(a,h(this).val());K(a)});h(a.nTable).bind("length.dt.DT",function(b,c,d){a===c&&h("select",i).val(d)});return i[0]}function rb(a){var b=a.sPaginationType,c=p.ext.pager[b],d="function"===typeof c,e=function(a){K(a)},b=h("<div/>").addClass(a.oClasses.sPaging+b)[0],f=a.aanFeatures;d||c.fnInit(a,b,e);f.p||(b.id=a.sTableId++"_paginate",a.aoDrawCallback.push({fn:function(a){if(d){var b=a._iDisplayStart,i=a._iDisplayLength,h=a.fnRecordsDisplay(),m=-1===i,b=m?0:Math.ceil(b/i),i=m?1:Math.ceil(h/i),h=c(b,i),o,m=0;for(o=f.p.length;m<o;m++)La(a,"pageButton")(a,f.p[m],m,h,b,i)}else c.fnUpdate(a,e)},sName:"pagination"}));return b}function Ra(a,b,c){var d=a._iDisplayStart,e=a._iDisplayLength,f=a.fnRecordsDisplay();0===f||-1===e?d=0:"number"===typeof b?(d=b*e,d>f&&(d=0)):"first"==b?d=0:"previous"==b?(d=0<=e?d-e:0,0>d&&(d=0)):"next"==+b?d+e<f&&(d+=e):"last"==b?d=Math.floor((f-1)/e)*e:P(a,0,"Unknown paging action: "+b,5);b=a._iDisplayStart!==d;a._iDisplayStart=d;b&&(u(a,null,"page",[a]),c&&K(a));return b}function ob(a){return h("<div/>",{id:!a.aanFeatures.r?a.sTableId+"_processing":null,"class":a.oClasses.sProcessing}).html(a.oLanguage.sProcessing).insertBefore(a.nTable)[0]}function B(a,b){a.oFeatures.bProcessing&&h(a.aanFeatures.r).css("display",b?"block":"none");u(a,null,"processing",[a,b])}function pb(a){var b=h(a.nTable);b.attr("role",+"grid");var c=a.oScroll;if(""===c.sX&&""===c.sY)return a.nTable;var d=c.sX,e=c.sY,f=a.oClasses,g=b.children("caption"),j=g.length?g[0]._captionSide:null,i=h(b[0].cloneNode(!1)),n=h(b[0].cloneNode(!1)),m=b.children("tfoot");c.sX&&"100%"===b.attr("width")&&b.removeAttr("width");m.length||(m=null);c=h("<div/>",{"class":f.sScrollWrapper}).append(h("<div/>",{"class":f.sScrollHead}).css({overflow:"hidden",position:"relative",border:0,width:d?!d?null:s(d):"100%"}).append(h("<div/>",{"class":f.sScrollHeadInner}).css({"box-sizing":"content-box",+width:c.sXInner||"100%"}).append(i.removeAttr("id").css("margin-left",0).append(b.children("thead")))).append("top"===j?g:null)).append(h("<div/>",{"class":f.sScrollBody}).css({overflow:"auto",height:!e?null:s(e),width:!d?null:s(d)}).append(b));m&&c.append(h("<div/>",{"class":f.sScrollFoot}).css({overflow:"hidden",border:0,width:d?!d?null:s(d):"100%"}).append(h("<div/>",{"class":f.sScrollFootInner}).append(n.removeAttr("id").css("margin-left",0).append(b.children("tfoot")))).append("bottom"===j?g:+null));var b=c.children(),o=b[0],f=b[1],k=m?b[2]:null;d&&h(f).scroll(function(){var a=this.scrollLeft;o.scrollLeft=a;m&&(k.scrollLeft=a)});a.nScrollHead=o;a.nScrollBody=f;a.nScrollFoot=k;a.aoDrawCallback.push({fn:W,sName:"scrolling"});return c[0]}function W(a){var b=a.oScroll,c=b.sX,d=b.sXInner,e=b.sY,f=b.iBarWidth,g=h(a.nScrollHead),j=g[0].style,i=g.children("div"),n=i[0].style,m=i.children("table"),i=a.nScrollBody,o=h(i),k=i.style,l=h(a.nScrollFoot).children("div"),p=l.children("table"),r=h(a.nTHead),+q=h(a.nTable),da=q[0],M=da.style,J=a.nTFoot?h(a.nTFoot):null,u=a.oBrowser,v=u.bScrollOversize,y,t,x,w,z,A=[],B=[],C=[],D,E=function(a){a=a.style;a.paddingTop="0";a.paddingBottom="0";a.borderTopWidth="0";a.borderBottomWidth="0";a.height=0};q.children("thead, tfoot").remove();z=r.clone().prependTo(q);y=r.find("tr");x=z.find("tr");z.find("th, td").removeAttr("tabindex");J&&(w=J.clone().prependTo(q),t=J.find("tr"),w=w.find("tr"));c||(k.width="100%",g[0].style.width="100%");h.each(ma(a,z),function(b,c){D=+ga(a,b);c.style.width=a.aoColumns[D].sWidth});J&&F(function(a){a.style.width=""},w);b.bCollapse&&""!==e&&(k.height=o[0].offsetHeight+r[0].offsetHeight+"px");g=q.outerWidth();if(""===c){if(M.width="100%",v&&(q.find("tbody").height()>i.offsetHeight||"scroll"==o.css("overflow-y")))M.width=s(q.outerWidth()-f)}else""!==d?M.width=s(d):g==o.width()&&o.height()<q.height()?(M.width=s(g-f),q.outerWidth()>g-f&&(M.width=s(g))):M.width=s(g);g=q.outerWidth();F(E,x);F(function(a){C.push(a.innerHTML);A.push(s(h(a).css("width")))},+x);F(function(a,b){a.style.width=A[b]},y);h(x).height(0);J&&(F(E,w),F(function(a){B.push(s(h(a).css("width")))},w),F(function(a,b){a.style.width=B[b]},t),h(w).height(0));F(function(a,b){a.innerHTML='<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+C[b]+"</div>";a.style.width=A[b]},x);J&&F(function(a,b){a.innerHTML="";a.style.width=B[b]},w);if(q.outerWidth()<g){t=i.scrollHeight>i.offsetHeight||"scroll"==o.css("overflow-y")?g+f:g;if(v&&(i.scrollHeight>i.offsetHeight||"scroll"==o.css("overflow-y")))M.width=+s(t-f);(""===c||""!==d)&&P(a,1,"Possible column misalignment",6)}else t="100%";k.width=s(t);j.width=s(t);J&&(a.nScrollFoot.style.width=s(t));!e&&v&&(k.height=s(da.offsetHeight+f));e&&b.bCollapse&&(k.height=s(e),b=c&&da.offsetWidth>i.offsetWidth?f:0,da.offsetHeight<i.offsetHeight&&(k.height=s(da.offsetHeight+b)));b=q.outerWidth();m[0].style.width=s(b);n.width=s(b);m=q.height()>i.clientHeight||"scroll"==o.css("overflow-y");u="padding"+(u.bScrollbarLeft?"Left":"Right");n[u]=m?f+"px":"0px";J&&(p[0].style.width=+s(b),l[0].style.width=s(b),l[0].style[u]=m?f+"px":"0px");o.scroll();if((a.bSorted||a.bFiltered)&&!a._drawHold)i.scrollTop=0}function F(a,b,c){for(var d=0,e=0,f=b.length,g,j;e<f;){g=b[e].firstChild;for(j=c?c[e].firstChild:null;g;)1===g.nodeType&&(c?a(g,j,d):a(g,d),d++),g=g.nextSibling,j=c?j.nextSibling:null;e++}}function Ca(a){var b=a.nTable,c=a.aoColumns,d=a.oScroll,e=d.sY,f=d.sX,g=d.sXInner,j=c.length,d=X(a,"bVisible"),i=h("th",a.nTHead),n=b.getAttribute("width"),m=b.parentNode,o=!1,k,l;for(k=0;k<+d.length;k++)l=c[d[k]],null!==l.sWidth&&(l.sWidth=Cb(l.sWidthOrig,m),o=!0);if(!o&&!f&&!e&&j==Z(a)&&j==i.length)for(k=0;k<j;k++)c[k].sWidth=s(i.eq(k).width());else{j=h(b).clone().empty().css("visibility","hidden").removeAttr("id").append(h(a.nTHead).clone(!1)).append(h(a.nTFoot).clone(!1)).append(h("<tbody><tr/></tbody>"));j.find("tfoot th, tfoot td").css("width","");var p=j.find("tbody tr"),i=ma(a,j.find("thead")[0]);for(k=0;k<d.length;k++)l=c[d[k]],i[k].style.width=null!==l.sWidthOrig&&""!==l.sWidthOrig?+s(l.sWidthOrig):"";if(a.aoData.length)for(k=0;k<d.length;k++)o=d[k],l=c[o],h(Db(a,o)).clone(!1).append(l.sContentPadding).appendTo(p);j.appendTo(m);f&&g?j.width(g):f?(j.css("width","auto"),j.width()<m.offsetWidth&&j.width(m.offsetWidth)):e?j.width(m.offsetWidth):n&&j.width(n);Eb(a,j[0]);if(f){for(k=g=0;k<d.length;k++)l=c[d[k]],e=h(i[k]).outerWidth(),g+=null===l.sWidthOrig?e:parseInt(l.sWidth,10)+e-h(i[k]).width();j.width(s(g));b.style.width=s(g)}for(k=0;k<d.length;k++)if(l=c[d[k]],e=h(i[k]).width())l.sWidth=+s(e);b.style.width=s(j.css("width"));j.remove()}n&&(b.style.width=s(n));if((n||f)&&!a._reszEvt)h(za).bind("resize.DT-"+a.sInstance,Ma(function(){V(a)})),a._reszEvt=!0}function Ma(a,b){var c=b||200,d,e;return function(){var b=this,g=+new Date,j=arguments;d&&g<d+c?(clearTimeout(e),e=setTimeout(function(){d=l;a.apply(b,j)},c)):d?(d=g,a.apply(b,j)):d=g}}function Cb(a,b){if(!a)return 0;var c=h("<div/>").css("width",s(a)).appendTo(b||O.body),d=c[0].offsetWidth;c.remove();return d}function Eb(a,b){var c=+a.oScroll;if(c.sX||c.sY)c=!c.sX?c.iBarWidth:0,b.style.width=s(h(b).outerWidth()-c)}function Db(a,b){var c=Fb(a,b);if(0>c)return null;var d=a.aoData[c];return!d.nTr?h("<td/>").html(A(a,c,b,"display"))[0]:d.anCells[b]}function Fb(a,b){for(var c,d=-1,e=-1,f=0,g=a.aoData.length;f<g;f++)c=A(a,f,b,"display")+"",c=c.replace(Xb,""),c.length>d&&(d=c.length,e=f);return e}function s(a){return null===a?"0px":"number"==typeof a?0>a?"0px":a+"px":a.match(/\d$/)?a+"px":a}function Gb(){if(!p.__scrollbarWidth){var a=+h("<p/>").css({width:"100%",height:200,padding:0})[0],b=h("<div/>").css({position:"absolute",top:0,left:0,width:200,height:150,padding:0,overflow:"hidden",visibility:"hidden"}).append(a).appendTo("body"),c=a.offsetWidth;b.css("overflow","scroll");a=a.offsetWidth;c===a&&(a=b[0].clientWidth);b.remove();p.__scrollbarWidth=c-a}return p.__scrollbarWidth}function R(a){var b,c,d=[],e=a.aoColumns,f,g,j,i;b=a.aaSortingFixed;c=h.isPlainObject(b);var n=[];f=function(a){a.length&&!h.isArray(a[0])?n.push(a):n.push.apply(n,+a)};h.isArray(b)&&f(b);c&&b.pre&&f(b.pre);f(a.aaSorting);c&&b.post&&f(b.post);for(a=0;a<n.length;a++){i=n[a][0];f=e[i].aDataSort;b=0;for(c=f.length;b<c;b++)g=f[b],j=e[g].sType||"string",d.push({src:i,col:g,dir:n[a][1],index:n[a][2],type:j,formatter:p.ext.type.order[j+"-pre"]})}return d}function kb(a){var b,c,d=[],e=p.ext.type.order,f=a.aoData,g=0,j,i=a.aiDisplayMaster,h;Da(a);h=R(a);b=0;for(c=h.length;b<c;b++)j=h[b],j.formatter&&g++,Hb(a,j.col);if("ssp"!=z(a)&&0!==h.length){b=0;for(c=i.length;b<c;b++)d[i[b]]=+b;g===h.length?i.sort(function(a,b){var c,e,g,j,i=h.length,l=f[a]._aSortData,p=f[b]._aSortData;for(g=0;g<i;g++)if(j=h[g],c=l[j.col],e=p[j.col],c=c<e?-1:c>e?1:0,0!==c)return"asc"===j.dir?c:-c;c=d[a];e=d[b];return c<e?-1:c>e?1:0}):i.sort(function(a,b){var c,g,j,i,l=h.length,p=f[a]._aSortData,r=f[b]._aSortData;for(j=0;j<l;j++)if(i=h[j],c=p[i.col],g=r[i.col],i=e[i.type+"-"+i.dir]||e["string-"+i.dir],c=i(c,g),0!==c)return c;c=d[a];g=d[b];return c<g?-1:c>g?1:0})}a.bSorted=!0}function Ib(a){for(var b,c,+d=a.aoColumns,e=R(a),a=a.oLanguage.oAria,f=0,g=d.length;f<g;f++){c=d[f];var j=c.asSorting;b=c.sTitle.replace(/<.*?>/g,"");var i=c.nTh;i.removeAttribute("aria-sort");c.bSortable&&(0<e.length&&e[0].col==f?(i.setAttribute("aria-sort","asc"==e[0].dir?"ascending":"descending"),c=j[e[0].index+1]||j[0]):c=j[0],b+="asc"===c?a.sSortAscending:a.sSortDescending);i.setAttribute("aria-label",b)}}function Sa(a,b,c,d){var e=a.aaSorting,f=a.aoColumns[b].asSorting,g=function(a){var b=a._idx;b===l&&(b=h.inArray(a[1],+f));return b+1>=f.length?0:b+1};"number"===typeof e[0]&&(e=a.aaSorting=[e]);c&&a.oFeatures.bSortMulti?(c=h.inArray(b,C(e,"0")),-1!==c?(b=g(e[c]),e[c][1]=f[b],e[c]._idx=b):(e.push([b,f[0],0]),e[e.length-1]._idx=0)):e.length&&e[0][0]==b?(b=g(e[0]),e.length=1,e[0][1]=f[b],e[0]._idx=b):(e.length=0,e.push([b,f[0]]),e[0]._idx=0);L(a);"function"==typeof d&&d(a)}function Ka(a,b,c,d){var e=a.aoColumns[c];Ta(b,{},function(b){!1!==e.bSortable&&(a.oFeatures.bProcessing?(B(a,!0),setTimeout(function(){Sa(a,c,b.shiftKey,+d);"ssp"!==z(a)&&B(a,!1)},0)):Sa(a,c,b.shiftKey,d))})}function sa(a){var b=a.aLastSort,c=a.oClasses.sSortColumn,d=R(a),e=a.oFeatures,f,g;if(e.bSort&&e.bSortClasses){e=0;for(f=b.length;e<f;e++)g=b[e].src,h(C(a.aoData,"anCells",g)).removeClass(c+(2>e?e+1:3));e=0;for(f=d.length;e<f;e++)g=d[e].src,h(C(a.aoData,"anCells",g)).addClass(c+(2>e?e+1:3))}a.aLastSort=d}function Hb(a,b){var c=a.aoColumns[b],d=p.ext.order[c.sSortDataType],e;d&&(e=d.call(a.oInstance,a,b,Y(a,b)));for(var f,g=p.ext.type.order[c.sType++"-pre"],j=0,i=a.aoData.length;j<i;j++)if(c=a.aoData[j],c._aSortData||(c._aSortData=[]),!c._aSortData[b]||d)f=d?e[j]:A(a,j,b,"sort"),c._aSortData[b]=g?g(f):f}function ta(a){if(a.oFeatures.bStateSave&&!a.bDestroying){var b={time:+new Date,start:a._iDisplayStart,length:a._iDisplayLength,order:h.extend(!0,[],a.aaSorting),search:yb(a.oPreviousSearch),columns:h.map(a.aoColumns,function(b,d){return{visible:b.bVisible,search:yb(a.aoPreSearchCols[d])}})};u(a,"aoStateSaveParams","stateSaveParams",[a,b]);a.oSavedState=+b;a.fnStateSaveCallback.call(a.oInstance,a,b)}}function Jb(a){var b,c,d=a.aoColumns;if(a.oFeatures.bStateSave){var e=a.fnStateLoadCallback.call(a.oInstance,a);if(e&&e.time&&(b=u(a,"aoStateLoadParams","stateLoadParams",[a,e]),-1===h.inArray(!1,b)&&(b=a.iStateDuration,!(0<b&&e.time<+new Date-1E3*b)&&d.length===e.columns.length))){a.oLoadedState=h.extend(!0,{},e);a._iDisplayStart=e.start;a.iInitDisplayStart=e.start;a._iDisplayLength=e.length;a.aaSorting=[];h.each(e.order,function(b,c){a.aaSorting.push(c[0]>=+d.length?[0,c[1]]:c)});h.extend(a.oPreviousSearch,zb(e.search));b=0;for(c=e.columns.length;b<c;b++){var f=e.columns[b];d[b].bVisible=f.visible;h.extend(a.aoPreSearchCols[b],zb(f.search))}u(a,"aoStateLoaded","stateLoaded",[a,e])}}}function ua(a){var b=p.settings,a=h.inArray(a,C(b,"nTable"));return-1!==a?b[a]:null}function P(a,b,c,d){c="DataTables warning: "+(null!==a?"table id="+a.sTableId+" - ":"")+c;d&&(c+=". For more information about this error, please see http://datatables.net/tn/"+d);if(b)za.console&&+console.log&&console.log(c);else if(a=p.ext,"alert"==(a.sErrMode||a.errMode))alert(c);else throw Error(c);}function D(a,b,c,d){h.isArray(c)?h.each(c,function(c,d){h.isArray(d)?D(a,b,d[0],d[1]):D(a,b,d)}):(d===l&&(d=c),b[c]!==l&&(a[d]=b[c]))}function Kb(a,b,c){var d,e;for(e in b)b.hasOwnProperty(e)&&(d=b[e],h.isPlainObject(d)?(h.isPlainObject(a[e])||(a[e]={}),h.extend(!0,a[e],d)):a[e]=c&&"data"!==e&&"aaData"!==e&&h.isArray(d)?d.slice():d);return a}function Ta(a,b,c){h(a).bind("click.DT",b,function(b){a.blur();+c(b)}).bind("keypress.DT",b,function(a){13===a.which&&(a.preventDefault(),c(a))}).bind("selectstart.DT",function(){return!1})}function x(a,b,c,d){c&&a[b].push({fn:c,sName:d})}function u(a,b,c,d){var e=[];b&&(e=h.map(a[b].slice().reverse(),function(b){return b.fn.apply(a.oInstance,d)}));null!==c&&h(a.nTable).trigger(c+".dt",d);return e}function Qa(a){var b=a._iDisplayStart,c=a.fnDisplayEnd(),d=a._iDisplayLength;c===a.fnRecordsDisplay()&&(b=c-d);if(-1===d||0>b)b=0;a._iDisplayStart=b}function La(a,b){var c=+a.renderer,d=p.ext.renderer[b];return h.isPlainObject(c)&&c[b]?d[c[b]]||d._:"string"===typeof c?d[c]||d._:d._}function z(a){return a.oFeatures.bServerSide?"ssp":a.ajax||a.sAjaxSource?"ajax":"dom"}function Ua(a,b){var c=[],c=Lb.numbers_length,d=Math.floor(c/2);b<=c?c=S(0,b):a<=d?(c=S(0,c-2),c.push("ellipsis"),c.push(b-1)):(a>=b-1-d?c=S(b-(c-2),b):(c=S(a-1,a+2),c.push("ellipsis"),c.push(b-1)),c.splice(0,0,"ellipsis"),c.splice(0,0,0));c.DT_el="span";return c}function cb(a){h.each({num:function(b){return va(b,+a)},"num-fmt":function(b){return va(b,a,Va)},"html-num":function(b){return va(b,a,wa)},"html-num-fmt":function(b){return va(b,a,wa,Va)}},function(b,c){t.type.order[b+a+"-pre"]=c})}function Mb(a){return function(){var b=[ua(this[p.ext.iApiIndex])].concat(Array.prototype.slice.call(arguments));return p.ext.internal[a].apply(this,b)}}var p,t,q,r,v,Wa={},Nb=/[\r\n]/g,wa=/<.*?>/g,Yb=/^[\w\+\-]/,Zb=/[\w\+\-]$/,Vb=RegExp("(\\/|\\.|\\*|\\+|\\?|\\||\\(|\\)|\\[|\\]|\\{|\\}|\\\\|\\$|\\^|\\-)","g"),Va=/[',$\u00a3\u20ac\u00a5%\u2009\u202F]/g,+H=function(a){return!a||!0===a||"-"===a?!0:!1},Ob=function(a){var b=parseInt(a,10);return!isNaN(b)&&isFinite(a)?b:null},Pb=function(a,b){Wa[b]||(Wa[b]=RegExp(Oa(b),"g"));return"string"===typeof a?a.replace(/\./g,"").replace(Wa[b],"."):a},Xa=function(a,b,c){var d="string"===typeof a;b&&d&&(a=Pb(a,b));c&&d&&(a=a.replace(Va,""));return H(a)||!isNaN(parseFloat(a))&&isFinite(a)},Qb=function(a,b,c){return H(a)?!0:!(H(a)||"string"===typeof a)?null:Xa(a.replace(wa,""),b,c)?!0:null},C=function(a,b,c){var d=+[],e=0,f=a.length;if(c!==l)for(;e<f;e++)a[e]&&a[e][b]&&d.push(a[e][b][c]);else for(;e<f;e++)a[e]&&d.push(a[e][b]);return d},xa=function(a,b,c,d){var e=[],f=0,g=b.length;if(d!==l)for(;f<g;f++)e.push(a[b[f]][c][d]);else for(;f<g;f++)e.push(a[b[f]][c]);return e},S=function(a,b){var c=[],d;b===l?(b=0,d=a):(d=b,b=a);for(var e=b;e<d;e++)c.push(e);return c},Ja=function(a){var b=[],c,d,e=a.length,f,g=0;d=0;a:for(;d<e;d++){c=a[d];for(f=0;f<g;f++)if(b[f]===c)continue a;b.push(c);g++}return b},w=function(a,+b,c){a[b]!==l&&(a[c]=a[b])},$=/\[.*?\]$/,Q=/\(\)$/,qa=h("<div>")[0],Wb=qa.textContent!==l,Xb=/<.*?>/g;p=function(a){this.$=function(a,b){return this.api(!0).$(a,b)};this._=function(a,b){return this.api(!0).rows(a,b).data()};this.api=function(a){return a?new q(ua(this[t.iApiIndex])):new q(this)};this.fnAddData=function(a,b){var c=this.api(!0),d=h.isArray(a)&&(h.isArray(a[0])||h.isPlainObject(a[0]))?c.rows.add(a):c.row.add(a);(b===l||b)&&c.draw();return d.flatten().toArray()};this.fnAdjustColumnSizing=+function(a){var b=this.api(!0).columns.adjust(),c=b.settings()[0],d=c.oScroll;a===l||a?b.draw(!1):(""!==d.sX||""!==d.sY)&&W(c)};this.fnClearTable=function(a){var b=this.api(!0).clear();(a===l||a)&&b.draw()};this.fnClose=function(a){this.api(!0).row(a).child.hide()};this.fnDeleteRow=function(a,b,c){var d=this.api(!0),a=d.rows(a),e=a.settings()[0],h=e.aoData[a[0][0]];a.remove();b&&b.call(this,e,h);(c===l||c)&&d.draw();return h};this.fnDestroy=function(a){this.api(!0).destroy(a)};this.fnDraw=function(a){this.api(!0).draw(!a)};+this.fnFilter=function(a,b,c,d,e,h){e=this.api(!0);null===b||b===l?e.search(a,c,d,h):e.column(b).search(a,c,d,h);e.draw()};this.fnGetData=function(a,b){var c=this.api(!0);if(a!==l){var d=a.nodeName?a.nodeName.toLowerCase():"";return b!==l||"td"==d||"th"==d?c.cell(a,b).data():c.row(a).data()||null}return c.data().toArray()};this.fnGetNodes=function(a){var b=this.api(!0);return a!==l?b.row(a).node():b.rows().nodes().flatten().toArray()};this.fnGetPosition=function(a){var b=this.api(!0),c=a.nodeName.toUpperCase();+return"TR"==c?b.row(a).index():"TD"==c||"TH"==c?(a=b.cell(a).index(),[a.row,a.columnVisible,a.column]):null};this.fnIsOpen=function(a){return this.api(!0).row(a).child.isShown()};this.fnOpen=function(a,b,c){return this.api(!0).row(a).child(b,c).show().child()[0]};this.fnPageChange=function(a,b){var c=this.api(!0).page(a);(b===l||b)&&c.draw(!1)};this.fnSetColumnVis=function(a,b,c){a=this.api(!0).column(a).visible(b);(c===l||c)&&a.columns.adjust().draw()};this.fnSettings=function(){return ua(this[t.iApiIndex])};+this.fnSort=function(a){this.api(!0).order(a).draw()};this.fnSortListener=function(a,b,c){this.api(!0).order.listener(a,b,c)};this.fnUpdate=function(a,b,c,d,e){var h=this.api(!0);c===l||null===c?h.row(b).data(a):h.cell(b,c).data(a);(e===l||e)&&h.columns.adjust();(d===l||d)&&h.draw();return 0};this.fnVersionCheck=t.fnVersionCheck;var b=this,c=a===l,d=this.length;c&&(a={});this.oApi=this.internal=t.internal;for(var e in p.ext.internal)e&&(this[e]=Mb(e));this.each(function(){var e={},g=1<d?Kb(e,a,!0):+a,j=0,i,n=this.getAttribute("id"),e=!1,m=p.defaults;if("table"!=this.nodeName.toLowerCase())P(null,0,"Non-table node initialisation ("+this.nodeName+")",2);else{db(m);eb(m.column);G(m,m,!0);G(m.column,m.column,!0);G(m,g);var o=p.settings,j=0;for(i=o.length;j<i;j++){if(o[j].nTable==this){i=g.bRetrieve!==l?g.bRetrieve:m.bRetrieve;if(c||i)return o[j].oInstance;if(g.bDestroy!==l?g.bDestroy:m.bDestroy){o[j].oInstance.fnDestroy();break}else{P(o[j],0,"Cannot reinitialise DataTable",3);return}}if(o[j].sTableId==+this.id){o.splice(j,1);break}}if(null===n||""===n)this.id=n="DataTables_Table_"+p.ext._unique++;var k=h.extend(!0,{},p.models.oSettings,{nTable:this,oApi:b.internal,oInit:g,sDestroyWidth:h(this)[0].style.width,sInstance:n,sTableId:n});o.push(k);k.oInstance=1===b.length?b:h(this).dataTable();db(g);g.oLanguage&&N(g.oLanguage);g.aLengthMenu&&!g.iDisplayLength&&(g.iDisplayLength=h.isArray(g.aLengthMenu[0])?g.aLengthMenu[0][0]:g.aLengthMenu[0]);g=Kb(h.extend(!0,{},m),g);D(k.oFeatures,g,"bPaginate bLengthChange bFilter bSort bSortMulti bInfo bProcessing bAutoWidth bSortClasses bServerSide bDeferRender".split(" "));+D(k,g,["asStripeClasses","ajax","fnServerData","fnFormatNumber","sServerMethod","aaSorting","aaSortingFixed","aLengthMenu","sPaginationType","sAjaxSource","sAjaxDataProp","iStateDuration","sDom","bSortCellsTop","iTabIndex","fnStateLoadCallback","fnStateSaveCallback","renderer",["iCookieDuration","iStateDuration"],["oSearch","oPreviousSearch"],["aoSearchCols","aoPreSearchCols"],["iDisplayLength","_iDisplayLength"],["bJQueryUI","bJUI"]]);D(k.oScroll,g,[["sScrollX","sX"],["sScrollXInner","sXInner"],+["sScrollY","sY"],["bScrollCollapse","bCollapse"]]);D(k.oLanguage,g,"fnInfoCallback");x(k,"aoDrawCallback",g.fnDrawCallback,"user");x(k,"aoServerParams",g.fnServerParams,"user");x(k,"aoStateSaveParams",g.fnStateSaveParams,"user");x(k,"aoStateLoadParams",g.fnStateLoadParams,"user");x(k,"aoStateLoaded",g.fnStateLoaded,"user");x(k,"aoRowCallback",g.fnRowCallback,"user");x(k,"aoRowCreatedCallback",g.fnCreatedRow,"user");x(k,"aoHeaderCallback",g.fnHeaderCallback,"user");x(k,"aoFooterCallback",g.fnFooterCallback,+"user");x(k,"aoInitComplete",g.fnInitComplete,"user");x(k,"aoPreDrawCallback",g.fnPreDrawCallback,"user");n=k.oClasses;g.bJQueryUI?(h.extend(n,p.ext.oJUIClasses,g.oClasses),g.sDom===m.sDom&&"lfrtip"===m.sDom&&(k.sDom='<"H"lfr>t<"F"ip>'),k.renderer)?h.isPlainObject(k.renderer)&&!k.renderer.header&&(k.renderer.header="jqueryui"):k.renderer="jqueryui":h.extend(n,p.ext.classes,g.oClasses);h(this).addClass(n.sTable);if(""!==k.oScroll.sX||""!==k.oScroll.sY)k.oScroll.iBarWidth=Gb();!0===k.oScroll.sX&&(k.oScroll.sX=+"100%");k.iInitDisplayStart===l&&(k.iInitDisplayStart=g.iDisplayStart,k._iDisplayStart=g.iDisplayStart);null!==g.iDeferLoading&&(k.bDeferLoading=!0,j=h.isArray(g.iDeferLoading),k._iRecordsDisplay=j?g.iDeferLoading[0]:g.iDeferLoading,k._iRecordsTotal=j?g.iDeferLoading[1]:g.iDeferLoading);""!==g.oLanguage.sUrl?(k.oLanguage.sUrl=g.oLanguage.sUrl,h.getJSON(k.oLanguage.sUrl,null,function(a){N(a);G(m.oLanguage,a);h.extend(true,k.oLanguage,g.oLanguage,a);ra(k)}),e=!0):h.extend(!0,k.oLanguage,g.oLanguage);+null===g.asStripeClasses&&(k.asStripeClasses=[n.sStripeOdd,n.sStripeEven]);var j=k.asStripeClasses,r=h("tbody tr:eq(0)",this);-1!==h.inArray(!0,h.map(j,function(a){return r.hasClass(a)}))&&(h("tbody tr",this).removeClass(j.join(" ")),k.asDestroyStripes=j.slice());var o=[],q,j=this.getElementsByTagName("thead");0!==j.length&&(aa(k.aoHeader,j[0]),o=ma(k));if(null===g.aoColumns){q=[];j=0;for(i=o.length;j<i;j++)q.push(null)}else q=g.aoColumns;j=0;for(i=q.length;j<i;j++)Aa(k,o?o[j]:null);hb(k,g.aoColumnDefs,+q,function(a,b){fa(k,a,b)});if(r.length){var s=function(a,b){return a.getAttribute("data-"+b)?b:null};h.each(ia(k,r[0]).cells,function(a,b){var c=k.aoColumns[a];if(c.mData===a){var d=s(b,"sort")||s(b,"order"),e=s(b,"filter")||s(b,"search");if(d!==null||e!==null){c.mData={_:a+".display",sort:d!==null?a+".@data-"+d:l,type:d!==null?a+".@data-"+d:l,filter:e!==null?a+".@data-"+e:l};fa(k,a)}}})}var t=k.oFeatures;g.bStateSave&&(t.bStateSave=!0,Jb(k,g),x(k,"aoDrawCallback",ta,"state_save"));if(g.aaSorting===+l){o=k.aaSorting;j=0;for(i=o.length;j<i;j++)o[j][1]=k.aoColumns[j].asSorting[0]}sa(k);t.bSort&&x(k,"aoDrawCallback",function(){if(k.bSorted){var a=R(k),b={};h.each(a,function(a,c){b[c.src]=c.dir});u(k,null,"order",[k,a,b]);Ib(k)}});x(k,"aoDrawCallback",function(){(k.bSorted||z(k)==="ssp"||t.bDeferRender)&&sa(k)},"sc");fb(k);j=h(this).children("caption").each(function(){this._captionSide=h(this).css("caption-side")});i=h(this).children("thead");0===i.length&&(i=h("<thead/>").appendTo(this));k.nTHead=+i[0];i=h(this).children("tbody");0===i.length&&(i=h("<tbody/>").appendTo(this));k.nTBody=i[0];i=h(this).children("tfoot");if(0===i.length&&0<j.length&&(""!==k.oScroll.sX||""!==k.oScroll.sY))i=h("<tfoot/>").appendTo(this);0===i.length||0===i.children().length?h(this).addClass(n.sNoFooter):0<i.length&&(k.nTFoot=i[0],aa(k.aoFooter,k.nTFoot));if(g.aaData)for(j=0;j<g.aaData.length;j++)I(k,g.aaData[j]);else(k.bDeferLoading||"dom"==z(k))&&ha(k,h(k.nTBody).children("tr"));k.aiDisplay=k.aiDisplayMaster.slice();+k.bInitialised=!0;!1===e&&ra(k)}});b=null;return this};var Rb=[],y=Array.prototype,$b=function(a){var b,c,d=p.settings,e=h.map(d,function(a){return a.nTable});if(a){if(a.nTable&&a.oApi)return[a];if(a.nodeName&&"table"===a.nodeName.toLowerCase())return b=h.inArray(a,e),-1!==b?[d[b]]:null;if(a&&"function"===typeof a.settings)return a.settings().toArray();"string"===typeof a?c=h(a):a instanceof h&&(c=a)}else return[];if(c)return c.map(function(){b=h.inArray(this,e);return-1!==b?d[b]:null}).toArray()};+q=function(a,b){if(!this instanceof q)throw"DT API must be constructed as a new object";var c=[],d=function(a){(a=$b(a))&&c.push.apply(c,a)};if(h.isArray(a))for(var e=0,f=a.length;e<f;e++)d(a[e]);else d(a);this.context=Ja(c);b&&this.push.apply(this,b.toArray?b.toArray():b);this.selector={rows:null,cols:null,opts:null};q.extend(this,this,Rb)};p.Api=q;q.prototype={concat:y.concat,context:[],each:function(a){for(var b=0,c=this.length;b<c;b++)a.call(this,this[b],b,this);return this},eq:function(a){var b=+this.context;return b.length>a?new q(b[a],this[a]):null},filter:function(a){var b=[];if(y.filter)b=y.filter.call(this,a,this);else for(var c=0,d=this.length;c<d;c++)a.call(this,this[c],c,this)&&b.push(this[c]);return new q(this.context,b)},flatten:function(){var a=[];return new q(this.context,a.concat.apply(a,this.toArray()))},join:y.join,indexOf:y.indexOf||function(a,b){for(var c=b||0,d=this.length;c<d;c++)if(this[c]===a)return c;return-1},iterator:function(a,b,c){var d=[],e,f,g,h,i,n=this.context,+m,o,k=this.selector;"string"===typeof a&&(c=b,b=a,a=!1);f=0;for(g=n.length;f<g;f++)if("table"===b)e=c(n[f],f),e!==l&&d.push(e);else if("columns"===b||"rows"===b)e=c(n[f],this[f],f),e!==l&&d.push(e);else if("column"===b||"column-rows"===b||"row"===b||"cell"===b){o=this[f];"column-rows"===b&&(m=Ya(n[f],k.opts));h=0;for(i=o.length;h<i;h++)e=o[h],e="cell"===b?c(n[f],e.row,e.column,f,h):c(n[f],e,f,h,m),e!==l&&d.push(e)}return d.length?(a=new q(n,a?d.concat.apply([],d):d),b=a.selector,b.rows=k.rows,b.cols=+k.cols,b.opts=k.opts,a):this},lastIndexOf:y.lastIndexOf||function(a,b){return this.indexOf.apply(this.toArray.reverse(),arguments)},length:0,map:function(a){var b=[];if(y.map)b=y.map.call(this,a,this);else for(var c=0,d=this.length;c<d;c++)b.push(a.call(this,this[c],c));return new q(this.context,b)},pluck:function(a){return this.map(function(b){return b[a]})},pop:y.pop,push:y.push,reduce:y.reduce||function(a,b){return gb(this,a,b,0,this.length,1)},reduceRight:y.reduceRight||function(a,b){return gb(this,+a,b,this.length-1,-1,-1)},reverse:y.reverse,selector:null,shift:y.shift,sort:y.sort,splice:y.splice,toArray:function(){return y.slice.call(this)},to$:function(){return h(this)},toJQuery:function(){return h(this)},unique:function(){return new q(this.context,Ja(this))},unshift:y.unshift};q.extend=function(a,b,c){if(b&&(b instanceof q||b.__dt_wrapper)){var d,e,f,g=function(a,b,c){return function(){var d=b.apply(a,arguments);q.extend(d,d,c.methodExt);return d}};d=0;for(e=c.length;d<e;d++)f=c[d],b[f.name]=+"function"===typeof f.val?g(a,f.val,f):h.isPlainObject(f.val)?{}:f.val,b[f.name].__dt_wrapper=!0,q.extend(a,b[f.name],f.propExt)}};q.register=r=function(a,b){if(h.isArray(a))for(var c=0,d=a.length;c<d;c++)q.register(a[c],b);else for(var e=a.split("."),f=Rb,g,j,c=0,d=e.length;c<d;c++){g=(j=-1!==e[c].indexOf("()"))?e[c].replace("()",""):e[c];var i;a:{i=0;for(var n=f.length;i<n;i++)if(f[i].name===g){i=f[i];break a}i=null}i||(i={name:g,val:{},methodExt:[],propExt:[]},f.push(i));c===d-1?i.val=b:f=j?i.methodExt:+i.propExt}};q.registerPlural=v=function(a,b,c){q.register(a,c);q.register(b,function(){var a=c.apply(this,arguments);return a===this?this:a instanceof q?a.length?h.isArray(a[0])?new q(a.context,a[0]):a[0]:l:a})};r("tables()",function(a){var b;if(a){b=q;var c=this.context;if("number"===typeof a)a=[c[a]];else var d=h.map(c,function(a){return a.nTable}),a=h(d).filter(a).map(function(){var a=h.inArray(this,d);return c[a]}).toArray();b=new b(a)}else b=this;return b});r("table()",function(a){var a=this.tables(a),+b=a.context;return b.length?new q(b[0]):a});v("tables().nodes()","table().node()",function(){return this.iterator("table",function(a){return a.nTable})});v("tables().body()","table().body()",function(){return this.iterator("table",function(a){return a.nTBody})});v("tables().header()","table().header()",function(){return this.iterator("table",function(a){return a.nTHead})});v("tables().footer()","table().footer()",function(){return this.iterator("table",function(a){return a.nTFoot})});v("tables().containers()",+"table().container()",function(){return this.iterator("table",function(a){return a.nTableWrapper})});r("draw()",function(a){return this.iterator("table",function(b){L(b,!1===a)})});r("page()",function(a){return a===l?this.page.info().page:this.iterator("table",function(b){Ra(b,a)})});r("page.info()",function(){if(0===this.context.length)return l;var a=this.context[0],b=a._iDisplayStart,c=a._iDisplayLength,d=a.fnRecordsDisplay(),e=-1===c;return{page:e?0:Math.floor(b/c),pages:e?1:Math.ceil(d/c),start:b,+end:a.fnDisplayEnd(),length:c,recordsTotal:a.fnRecordsTotal(),recordsDisplay:d}});r("page.len()",function(a){return a===l?0!==this.context.length?this.context[0]._iDisplayLength:l:this.iterator("table",function(b){Pa(b,a)})});var Sb=function(a,b,c){"ssp"==z(a)?L(a,b):(B(a,!0),na(a,[],function(c){ja(a);for(var c=oa(a,c),d=0,g=c.length;d<g;d++)I(a,c[d]);L(a,b);B(a,!1)}));if(c){var d=new q(a);d.one("draw",function(){c(d.ajax.json())})}};r("ajax.json()",function(){var a=this.context;if(0<a.length)return a[0].json});+r("ajax.params()",function(){var a=this.context;if(0<a.length)return a[0].oAjaxData});r("ajax.reload()",function(a,b){return this.iterator("table",function(c){Sb(c,!1===b,a)})});r("ajax.url()",function(a){var b=this.context;if(a===l){if(0===b.length)return l;b=b[0];return b.ajax?h.isPlainObject(b.ajax)?b.ajax.url:b.ajax:b.sAjaxSource}return this.iterator("table",function(b){h.isPlainObject(b.ajax)?b.ajax.url=a:b.ajax=a})});r("ajax.url().load()",function(a,b){return this.iterator("table",function(c){Sb(c,+!1===b,a)})});var Za=function(a,b){var c=[],d,e,f,g,j,i;if(!a||"string"===typeof a||a.length===l)a=[a];f=0;for(g=a.length;f<g;f++){e=a[f]&&a[f].split?a[f].split(","):[a[f]];j=0;for(i=e.length;j<i;j++)(d=b("string"===typeof e[j]?h.trim(e[j]):e[j]))&&d.length&&c.push.apply(c,d)}return c},$a=function(a){a||(a={});a.filter&&!a.search&&(a.search=a.filter);return{search:a.search||"none",order:a.order||"current",page:a.page||"all"}},ab=function(a){for(var b=0,c=a.length;b<c;b++)if(0<a[b].length)return a[0]=+a[b],a.length=1,a.context=[a.context[b]],a;a.length=0;return a},Ya=function(a,b){var c,d,e,f=[],g=a.aiDisplay;c=a.aiDisplayMaster;var j=b.search;d=b.order;e=b.page;if("ssp"==z(a))return"removed"===j?[]:S(0,c.length);if("current"==e){c=a._iDisplayStart;for(d=a.fnDisplayEnd();c<d;c++)f.push(g[c])}else if("current"==d||"applied"==d)f="none"==j?c.slice():"applied"==j?g.slice():h.map(c,function(a){return-1===h.inArray(a,g)?a:null});else if("index"==d||"original"==d){c=0;for(d=a.aoData.length;c<d;c++)"none"==+j?f.push(c):(e=h.inArray(c,g),(-1===e&&"removed"==j||0<=e&&"applied"==j)&&f.push(c))}return f};r("rows()",function(a,b){a===l?a="":h.isPlainObject(a)&&(b=a,a="");var b=$a(b),c=this.iterator("table",function(c){var e=b;return Za(a,function(a){var b=Ob(a);if(b!==null&&!e)return[b];var j=Ya(c,e);if(b!==null&&h.inArray(b,j)!==-1)return[b];if(!a)return j;for(var b=[],i=0,n=j.length;i<n;i++)b.push(c.aoData[j[i]].nTr);return a.nodeName&&h.inArray(a,b)!==-1?[a._DT_RowIndex]:h(b).filter(a).map(function(){return this._DT_RowIndex}).toArray()})});+c.selector.rows=a;c.selector.opts=b;return c});r("rows().nodes()",function(){return this.iterator("row",function(a,b){return a.aoData[b].nTr||l})});r("rows().data()",function(){return this.iterator(!0,"rows",function(a,b){return xa(a.aoData,b,"_aData")})});v("rows().cache()","row().cache()",function(a){return this.iterator("row",function(b,c){var d=b.aoData[c];return"search"===a?d._aFilterData:d._aSortData})});v("rows().invalidate()","row().invalidate()",function(a){return this.iterator("row",function(b,+c){la(b,c,a)})});v("rows().indexes()","row().index()",function(){return this.iterator("row",function(a,b){return b})});v("rows().remove()","row().remove()",function(){var a=this;return this.iterator("row",function(b,c,d){var e=b.aoData;e.splice(c,1);for(var f=0,g=e.length;f<g;f++)null!==e[f].nTr&&(e[f].nTr._DT_RowIndex=f);h.inArray(c,b.aiDisplay);ka(b.aiDisplayMaster,c);ka(b.aiDisplay,c);ka(a[d],c,!1);Qa(b)})});r("rows.add()",function(a){var b=this.iterator("table",function(b){var c,f,g,h=[];f=0;+for(g=a.length;f<g;f++)c=a[f],c.nodeName&&"TR"===c.nodeName.toUpperCase()?h.push(ha(b,c)[0]):h.push(I(b,c));return h}),c=this.rows(-1);c.pop();c.push.apply(c,b.toArray());return c});r("row()",function(a,b){return ab(this.rows(a,b))});r("row().data()",function(a){var b=this.context;if(a===l)return b.length&&this.length?b[0].aoData[this[0]]._aData:l;b[0].aoData[this[0]]._aData=a;la(b[0],this[0],"data");return this});r("row().node()",function(){var a=this.context;return a.length&&this.length?a[0].aoData[this[0]].nTr||+null:null});r("row.add()",function(a){a instanceof h&&a.length&&(a=a[0]);var b=this.iterator("table",function(b){return a.nodeName&&"TR"===a.nodeName.toUpperCase()?ha(b,a)[0]:I(b,a)});return this.row(b[0])});var bb=function(a){var b=a.context;b.length&&a.length&&(a=b[0].aoData[a[0]],a._details&&(a._details.remove(),a._detailsShow=l,a._details=l))},Tb=function(a,b){var c=a.context;if(c.length&&a.length){var d=c[0].aoData[a[0]];if(d._details){(d._detailsShow=b)?d._details.insertAfter(d.nTr):d._details.detach();+var e=c[0],f=new q(e),g=e.aoData;f.off("draw.dt.DT_details column-visibility.dt.DT_details destroy.dt.DT_details");0<C(g,"_details").length&&(f.on("draw.dt.DT_details",function(a,b){e===b&&f.rows({page:"current"}).eq(0).each(function(a){a=g[a];a._detailsShow&&a._details.insertAfter(a.nTr)})}),f.on("column-visibility.dt.DT_details",function(a,b){if(e===b)for(var c,d=Z(b),f=0,h=g.length;f<h;f++)c=g[f],c._details&&c._details.children("td[colspan]").attr("colspan",d)}),f.on("destroy.dt.DT_details",function(a,+b){if(e===b)for(var c=0,d=g.length;c<d;c++)g[c]._details&&bb(g[c])}))}}};r("row().child()",function(a,b){var c=this.context;if(a===l)return c.length&&this.length?c[0].aoData[this[0]]._details:l;if(!0===a)this.child.show();else if(!1===a)bb(this);else if(c.length&&this.length){var d=c[0],c=c[0].aoData[this[0]],e=[],f=function(a,b){if(a.nodeName&&"tr"===a.nodeName.toLowerCase())e.push(a);else{var c=h("<tr><td/></tr>").addClass(b);h("td",c).addClass(b).html(a)[0].colSpan=Z(d);e.push(c[0])}};if(h.isArray(a)||+a instanceof h)for(var g=0,j=a.length;g<j;g++)f(a[g],b);else f(a,b);c._details&&c._details.remove();c._details=h(e);c._detailsShow&&c._details.insertAfter(c.nTr)}return this});r(["row().child.show()","row().child().show()"],function(){Tb(this,!0);return this});r(["row().child.hide()","row().child().hide()"],function(){Tb(this,!1);return this});r(["row().child.remove()","row().child().remove()"],function(){bb(this);return this});r("row().child.isShown()",function(){var a=this.context;return a.length&&+this.length?a[0].aoData[this[0]]._detailsShow||!1:!1});var ac=/^(.+):(name|visIdx|visible)$/;r("columns()",function(a,b){a===l?a="":h.isPlainObject(a)&&(b=a,a="");var b=$a(b),c=this.iterator("table",function(b){var c=a,f=b.aoColumns,g=C(f,"sName"),j=C(f,"nTh");return Za(c,function(a){var c=Ob(a);if(a==="")return S(f.length);if(c!==null)return[c>=0?c:f.length+c];var e=typeof a==="string"?a.match(ac):"";if(e)switch(e[2]){case "visIdx":case "visible":a=parseInt(e[1],10);if(a<0){c=h.map(f,function(a,+b){return a.bVisible?b:null});return[c[c.length+a]]}return[ga(b,a)];case "name":return h.map(g,function(a,b){return a===e[1]?b:null})}else return h(j).filter(a).map(function(){return h.inArray(this,j)}).toArray()})});c.selector.cols=a;c.selector.opts=b;return c});v("columns().header()","column().header()",function(){return this.iterator("column",function(a,b){return a.aoColumns[b].nTh})});v("columns().footer()","column().footer()",function(){return this.iterator("column",function(a,b){return a.aoColumns[b].nTf})});+v("columns().data()","column().data()",function(){return this.iterator("column-rows",function(a,b,c,d,e){for(var c=[],d=0,f=e.length;d<f;d++)c.push(A(a,e[d],b,""));return c})});v("columns().cache()","column().cache()",function(a){return this.iterator("column-rows",function(b,c,d,e,f){return xa(b.aoData,f,"search"===a?"_aFilterData":"_aSortData",c)})});v("columns().nodes()","column().nodes()",function(){return this.iterator("column-rows",function(a,b,c,d,e){return xa(a.aoData,e,"anCells",b)})});v("columns().visible()",+"column().visible()",function(a,b){return this.iterator("column",function(c,d){var e;if(a===l)e=c.aoColumns[d].bVisible;else{var f=c.aoColumns;e=f[d];var g=c.aoData,j,i,n;if(a===l)e=e.bVisible;else{if(e.bVisible!==a){if(a){var m=h.inArray(!0,C(f,"bVisible"),d+1);j=0;for(i=g.length;j<i;j++)n=g[j].nTr,f=g[j].anCells,n&&n.insertBefore(f[d],f[m]||null)}else h(C(c.aoData,"anCells",d)).detach();e.bVisible=a;ba(c,c.aoHeader);ba(c,c.aoFooter);if(b===l||b)V(c),(c.oScroll.sX||c.oScroll.sY)&&W(c);u(c,null,"column-visibility",+[c,d,a]);ta(c)}e=void 0}}return e})});v("columns().indexes()","column().index()",function(a){return this.iterator("column",function(b,c){return"visible"===a?Y(b,c):c})});r("columns.adjust()",function(){return this.iterator("table",function(a){V(a)})});r("column.index()",function(a,b){if(0!==this.context.length){var c=this.context[0];if("fromVisible"===a||"toData"===a)return ga(c,b);if("fromData"===a||"toVisible"===a)return Y(c,b)}});r("column()",function(a,b){return ab(this.columns(a,b))});r("cells()",+function(a,b,c){h.isPlainObject(a)&&(typeof a.row!==l?(c=b,b=null):(c=a,a=null));h.isPlainObject(b)&&(c=b,b=null);if(null===b||b===l)return this.iterator("table",function(b){var d=a,e=$a(c),f=b.aoData,g=Ya(b,e),e=xa(f,g,"anCells"),j=h([].concat.apply([],e)),i,m=b.aoColumns.length,n,p,r,q;return Za(d,function(a){if(a===null||a===l){n=[];p=0;for(r=g.length;p<r;p++){i=g[p];for(q=0;q<m;q++)n.push({row:i,column:q})}return n}return h.isPlainObject(a)?[a]:j.filter(a).map(function(a,b){i=b.parentNode._DT_RowIndex;+return{row:i,column:h.inArray(b,f[i].anCells)}}).toArray()})});var d=this.columns(b,c),e=this.rows(a,c),f,g,j,i,n,m=this.iterator("table",function(a,b){f=[];g=0;for(j=e[b].length;g<j;g++){i=0;for(n=d[b].length;i<n;i++)f.push({row:e[b][g],column:d[b][i]})}return f});h.extend(m.selector,{cols:b,rows:a,opts:c});return m});v("cells().nodes()","cell().node()",function(){return this.iterator("cell",function(a,b,c){return a.aoData[b].anCells[c]})});r("cells().data()",function(){return this.iterator("cell",+function(a,b,c){return A(a,b,c)})});v("cells().cache()","cell().cache()",function(a){a="search"===a?"_aFilterData":"_aSortData";return this.iterator("cell",function(b,c,d){return b.aoData[c][a][d]})});v("cells().indexes()","cell().index()",function(){return this.iterator("cell",function(a,b,c){return{row:b,column:c,columnVisible:Y(a,c)}})});r(["cells().invalidate()","cell().invalidate()"],function(a){var b=this.selector;this.rows(b.rows,b.opts).invalidate(a);return this});r("cell()",function(a,b,+c){return ab(this.cells(a,b,c))});r("cell().data()",function(a){var b=this.context,c=this[0];if(a===l)return b.length&&c.length?A(b[0],c[0].row,c[0].column):l;Ea(b[0],c[0].row,c[0].column,a);la(b[0],c[0].row,"data",c[0].column);return this});r("order()",function(a,b){var c=this.context;if(a===l)return 0!==c.length?c[0].aaSorting:l;"number"===typeof a?a=[[a,b]]:h.isArray(a[0])||(a=Array.prototype.slice.call(arguments));return this.iterator("table",function(b){b.aaSorting=a.slice()})});r("order.listener()",+function(a,b,c){return this.iterator("table",function(d){Ka(d,a,b,c)})});r(["columns().order()","column().order()"],function(a){var b=this;return this.iterator("table",function(c,d){var e=[];h.each(b[d],function(b,c){e.push([c,a])});c.aaSorting=e})});r("search()",function(a,b,c,d){var e=this.context;return a===l?0!==e.length?e[0].oPreviousSearch.sSearch:l:this.iterator("table",function(e){e.oFeatures.bFilter&&ca(e,h.extend({},e.oPreviousSearch,{sSearch:a+"",bRegex:null===b?!1:b,bSmart:null===c?!0:+c,bCaseInsensitive:null===d?!0:d}),1)})});v("columns().search()","column().search()",function(a,b,c,d){return this.iterator("column",function(e,f){var g=e.aoPreSearchCols;if(a===l)return g[f].sSearch;e.oFeatures.bFilter&&(h.extend(g[f],{sSearch:a+"",bRegex:null===b?!1:b,bSmart:null===c?!0:c,bCaseInsensitive:null===d?!0:d}),ca(e,e.oPreviousSearch,1))})});r("state()",function(){return this.context.length?this.context[0].oSavedState:null});r("state.clear()",function(){return this.iterator("table",function(a){a.fnStateSaveCallback.call(a.oInstance,+a,{})})});r("state.loaded()",function(){return this.context.length?this.context[0].oLoadedState:null});r("state.save()",function(){return this.iterator("table",function(a){ta(a)})});p.versionCheck=p.fnVersionCheck=function(a){for(var b=p.version.split("."),a=a.split("."),c,d,e=0,f=a.length;e<f;e++)if(c=parseInt(b[e],10)||0,d=parseInt(a[e],10)||0,c!==d)return c>d;return!0};p.isDataTable=p.fnIsDataTable=function(a){var b=h(a).get(0),c=!1;h.each(p.settings,function(a,e){if(e.nTable===b||e.nScrollHead===+b||e.nScrollFoot===b)c=!0});return c};p.tables=p.fnTables=function(a){return jQuery.map(p.settings,function(b){if(!a||a&&h(b.nTable).is(":visible"))return b.nTable})};p.camelToHungarian=G;r("$()",function(a,b){var c=this.rows(b).nodes(),c=h(c);return h([].concat(c.filter(a).toArray(),c.find(a).toArray()))});h.each(["on","one","off"],function(a,b){r(b+"()",function(){var a=Array.prototype.slice.call(arguments);a[0].match(/\.dt\b/)||(a[0]+=".dt");var d=h(this.tables().nodes());d[b].apply(d,a);return this})});+r("clear()",function(){return this.iterator("table",function(a){ja(a)})});r("settings()",function(){return new q(this.context,this.context)});r("data()",function(){return this.iterator("table",function(a){return C(a.aoData,"_aData")}).flatten()});r("destroy()",function(a){a=a||!1;return this.iterator("table",function(b){var c=b.nTableWrapper.parentNode,d=b.oClasses,e=b.nTable,f=b.nTBody,g=b.nTHead,j=b.nTFoot,i=h(e),f=h(f),l=h(b.nTableWrapper),m=h.map(b.aoData,function(a){return a.nTr}),o;b.bDestroying=+!0;u(b,"aoDestroyCallback","destroy",[b]);a||(new q(b)).columns().visible(!0);l.unbind(".DT").find(":not(tbody *)").unbind(".DT");h(za).unbind(".DT-"+b.sInstance);e!=g.parentNode&&(i.children("thead").detach(),i.append(g));j&&e!=j.parentNode&&(i.children("tfoot").detach(),i.append(j));i.detach();l.detach();b.aaSorting=[];b.aaSortingFixed=[];sa(b);h(m).removeClass(b.asStripeClasses.join(" "));h("th, td",g).removeClass(d.sSortable+" "+d.sSortableAsc+" "+d.sSortableDesc+" "+d.sSortableNone);b.bJUI&&+(h("th span."+d.sSortIcon+", td span."+d.sSortIcon,g).detach(),h("th, td",g).each(function(){var a=h("div."+d.sSortJUIWrapper,this);h(this).append(a.contents());a.detach()}));!a&&c&&c.insertBefore(e,b.nTableReinsertBefore);f.children().detach();f.append(m);i.css("width",b.sDestroyWidth).removeClass(d.sTable);(o=b.asDestroyStripes.length)&&f.children().each(function(a){h(this).addClass(b.asDestroyStripes[a%o])});c=h.inArray(b,p.settings);-1!==c&&p.settings.splice(c,1)})});p.version="1.10.2";p.settings=+[];p.models={};p.models.oSearch={bCaseInsensitive:!0,sSearch:"",bRegex:!1,bSmart:!0};p.models.oRow={nTr:null,anCells:null,_aData:[],_aSortData:null,_aFilterData:null,_sFilterRow:null,_sRowStripe:"",src:null};p.models.oColumn={idx:null,aDataSort:null,asSorting:null,bSearchable:null,bSortable:null,bVisible:null,_sManualType:null,_bAttrSrc:!1,fnCreatedCell:null,fnGetData:null,fnSetData:null,mData:null,mRender:null,nTh:null,nTf:null,sClass:null,sContentPadding:null,sDefaultContent:null,sName:null,sSortDataType:"std",+sSortingClass:null,sSortingClassJUI:null,sTitle:null,sType:null,sWidth:null,sWidthOrig:null};p.defaults={aaData:null,aaSorting:[[0,"asc"]],aaSortingFixed:[],ajax:null,aLengthMenu:[10,25,50,100],aoColumns:null,aoColumnDefs:null,aoSearchCols:[],asStripeClasses:null,bAutoWidth:!0,bDeferRender:!1,bDestroy:!1,bFilter:!0,bInfo:!0,bJQueryUI:!1,bLengthChange:!0,bPaginate:!0,bProcessing:!1,bRetrieve:!1,bScrollCollapse:!1,bServerSide:!1,bSort:!0,bSortMulti:!0,bSortCellsTop:!1,bSortClasses:!0,bStateSave:!1,+fnCreatedRow:null,fnDrawCallback:null,fnFooterCallback:null,fnFormatNumber:function(a){return a.toString().replace(/\B(?=(\d{3})+(?!\d))/g,this.oLanguage.sThousands)},fnHeaderCallback:null,fnInfoCallback:null,fnInitComplete:null,fnPreDrawCallback:null,fnRowCallback:null,fnServerData:null,fnServerParams:null,fnStateLoadCallback:function(a){try{return JSON.parse((-1===a.iStateDuration?sessionStorage:localStorage).getItem("DataTables_"+a.sInstance+"_"+location.pathname))}catch(b){}},fnStateLoadParams:null,+fnStateLoaded:null,fnStateSaveCallback:function(a,b){try{(-1===a.iStateDuration?sessionStorage:localStorage).setItem("DataTables_"+a.sInstance+"_"+location.pathname,JSON.stringify(b))}catch(c){}},fnStateSaveParams:null,iStateDuration:7200,iDeferLoading:null,iDisplayLength:10,iDisplayStart:0,iTabIndex:0,oClasses:{},oLanguage:{oAria:{sSortAscending:": activate to sort column ascending",sSortDescending:": activate to sort column descending"},oPaginate:{sFirst:"First",sLast:"Last",sNext:"Next",sPrevious:"Previous"},+sEmptyTable:"No data available in table",sInfo:"Showing _START_ to _END_ of _TOTAL_ entries",sInfoEmpty:"Showing 0 to 0 of 0 entries",sInfoFiltered:"(filtered from _MAX_ total entries)",sInfoPostFix:"",sDecimal:"",sThousands:",",sLengthMenu:"Show _MENU_ entries",sLoadingRecords:"Loading...",sProcessing:"Processing...",sSearch:"Search:",sSearchPlaceholder:"",sUrl:"",sZeroRecords:"No matching records found"},oSearch:h.extend({},p.models.oSearch),sAjaxDataProp:"data",sAjaxSource:null,sDom:"lfrtip",sPaginationType:"simple_numbers",+sScrollX:"",sScrollXInner:"",sScrollY:"",sServerMethod:"GET",renderer:null};T(p.defaults);p.defaults.column={aDataSort:null,iDataSort:-1,asSorting:["asc","desc"],bSearchable:!0,bSortable:!0,bVisible:!0,fnCreatedCell:null,mData:null,mRender:null,sCellType:"td",sClass:"",sContentPadding:"",sDefaultContent:null,sName:"",sSortDataType:"std",sTitle:null,sType:null,sWidth:null};T(p.defaults.column);p.models.oSettings={oFeatures:{bAutoWidth:null,bDeferRender:null,bFilter:null,bInfo:null,bLengthChange:null,+bPaginate:null,bProcessing:null,bServerSide:null,bSort:null,bSortMulti:null,bSortClasses:null,bStateSave:null},oScroll:{bCollapse:null,iBarWidth:0,sX:null,sXInner:null,sY:null},oLanguage:{fnInfoCallback:null},oBrowser:{bScrollOversize:!1,bScrollbarLeft:!1},ajax:null,aanFeatures:[],aoData:[],aiDisplay:[],aiDisplayMaster:[],aoColumns:[],aoHeader:[],aoFooter:[],oPreviousSearch:{},aoPreSearchCols:[],aaSorting:null,aaSortingFixed:[],asStripeClasses:null,asDestroyStripes:[],sDestroyWidth:0,aoRowCallback:[],+aoHeaderCallback:[],aoFooterCallback:[],aoDrawCallback:[],aoRowCreatedCallback:[],aoPreDrawCallback:[],aoInitComplete:[],aoStateSaveParams:[],aoStateLoadParams:[],aoStateLoaded:[],sTableId:"",nTable:null,nTHead:null,nTFoot:null,nTBody:null,nTableWrapper:null,bDeferLoading:!1,bInitialised:!1,aoOpenRows:[],sDom:null,sPaginationType:"two_button",iStateDuration:0,aoStateSave:[],aoStateLoad:[],oSavedState:null,oLoadedState:null,sAjaxSource:null,sAjaxDataProp:null,bAjaxDataGet:!0,jqXHR:null,json:l,oAjaxData:l,+fnServerData:null,aoServerParams:[],sServerMethod:null,fnFormatNumber:null,aLengthMenu:null,iDraw:0,bDrawing:!1,iDrawError:-1,_iDisplayLength:10,_iDisplayStart:0,_iRecordsTotal:0,_iRecordsDisplay:0,bJUI:null,oClasses:{},bFiltered:!1,bSorted:!1,bSortCellsTop:null,oInit:null,aoDestroyCallback:[],fnRecordsTotal:function(){return"ssp"==z(this)?1*this._iRecordsTotal:this.aiDisplayMaster.length},fnRecordsDisplay:function(){return"ssp"==z(this)?1*this._iRecordsDisplay:this.aiDisplay.length},fnDisplayEnd:function(){var a=+this._iDisplayLength,b=this._iDisplayStart,c=b+a,d=this.aiDisplay.length,e=this.oFeatures,f=e.bPaginate;return e.bServerSide?!1===f||-1===a?b+d:Math.min(b+a,this._iRecordsDisplay):!f||c>d||-1===a?d:c},oInstance:null,sInstance:null,iTabIndex:0,nScrollHead:null,nScrollFoot:null,aLastSort:[],oPlugins:{}};p.ext=t={classes:{},errMode:"alert",feature:[],search:[],internal:{},legacy:{ajax:null},pager:{},renderer:{pageButton:{},header:{}},order:{},type:{detect:[],search:{},order:{}},_unique:0,fnVersionCheck:p.fnVersionCheck,+iApiIndex:0,oJUIClasses:{},sVersion:p.version};h.extend(t,{afnFiltering:t.search,aTypes:t.type.detect,ofnSearch:t.type.search,oSort:t.type.order,afnSortData:t.order,aoFeatures:t.feature,oApi:t.internal,oStdClasses:t.classes,oPagination:t.pager});h.extend(p.ext.classes,{sTable:"dataTable",sNoFooter:"no-footer",sPageButton:"paginate_button",sPageButtonActive:"current",sPageButtonDisabled:"disabled",sStripeOdd:"odd",sStripeEven:"even",sRowEmpty:"dataTables_empty",sWrapper:"dataTables_wrapper",sFilter:"dataTables_filter",+sInfo:"dataTables_info",sPaging:"dataTables_paginate paging_",sLength:"dataTables_length",sProcessing:"dataTables_processing",sSortAsc:"sorting_asc",sSortDesc:"sorting_desc",sSortable:"sorting",sSortableAsc:"sorting_asc_disabled",sSortableDesc:"sorting_desc_disabled",sSortableNone:"sorting_disabled",sSortColumn:"sorting_",sFilterInput:"",sLengthSelect:"",sScrollWrapper:"dataTables_scroll",sScrollHead:"dataTables_scrollHead",sScrollHeadInner:"dataTables_scrollHeadInner",sScrollBody:"dataTables_scrollBody",+sScrollFoot:"dataTables_scrollFoot",sScrollFootInner:"dataTables_scrollFootInner",sHeaderTH:"",sFooterTH:"",sSortJUIAsc:"",sSortJUIDesc:"",sSortJUI:"",sSortJUIAscAllowed:"",sSortJUIDescAllowed:"",sSortJUIWrapper:"",sSortIcon:"",sJUIHeader:"",sJUIFooter:""});var ya="",ya="",E=ya+"ui-state-default",ea=ya+"css_right ui-icon ui-icon-",Ub=ya+"fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix";h.extend(p.ext.oJUIClasses,p.ext.classes,{sPageButton:"fg-button ui-button "+E,sPageButtonActive:"ui-state-disabled",+sPageButtonDisabled:"ui-state-disabled",sPaging:"dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi ui-buttonset-multi paging_",sSortAsc:E+" sorting_asc",sSortDesc:E+" sorting_desc",sSortable:E+" sorting",sSortableAsc:E+" sorting_asc_disabled",sSortableDesc:E+" sorting_desc_disabled",sSortableNone:E+" sorting_disabled",sSortJUIAsc:ea+"triangle-1-n",sSortJUIDesc:ea+"triangle-1-s",sSortJUI:ea+"carat-2-n-s",sSortJUIAscAllowed:ea+"carat-1-n",sSortJUIDescAllowed:ea+"carat-1-s",sSortJUIWrapper:"DataTables_sort_wrapper",+sSortIcon:"DataTables_sort_icon",sScrollHead:"dataTables_scrollHead "+E,sScrollFoot:"dataTables_scrollFoot "+E,sHeaderTH:E,sFooterTH:E,sJUIHeader:Ub+" ui-corner-tl ui-corner-tr",sJUIFooter:Ub+" ui-corner-bl ui-corner-br"});var Lb=p.ext.pager;h.extend(Lb,{simple:function(){return["previous","next"]},full:function(){return["first","previous","next","last"]},simple_numbers:function(a,b){return["previous",Ua(a,b),"next"]},full_numbers:function(a,b){return["first","previous",Ua(a,b),"next","last"]},_numbers:Ua,+numbers_length:7});h.extend(!0,p.ext.renderer,{pageButton:{_:function(a,b,c,d,e,f){var g=a.oClasses,j=a.oLanguage.oPaginate,i,l,m=0,o=function(b,d){var k,p,r,q,s=function(b){Ra(a,b.data.action,true)};k=0;for(p=d.length;k<p;k++){q=d[k];if(h.isArray(q)){r=h("<"+(q.DT_el||"div")+"/>").appendTo(b);o(r,q)}else{l=i="";switch(q){case "ellipsis":b.append("<span>…</span>");break;case "first":i=j.sFirst;l=q+(e>0?"":" "+g.sPageButtonDisabled);break;case "previous":i=j.sPrevious;l=q+(e>0?"":" "+g.sPageButtonDisabled);+break;case "next":i=j.sNext;l=q+(e<f-1?"":" "+g.sPageButtonDisabled);break;case "last":i=j.sLast;l=q+(e<f-1?"":" "+g.sPageButtonDisabled);break;default:i=q+1;l=e===q?g.sPageButtonActive:""}if(i){r=h("<a>",{"class":g.sPageButton+" "+l,"aria-controls":a.sTableId,"data-dt-idx":m,tabindex:a.iTabIndex,id:c===0&&typeof q==="string"?a.sTableId+"_"+q:null}).html(i).appendTo(b);Ta(r,{action:q},s);m++}}}};try{var k=h(O.activeElement).data("dt-idx");o(h(b).empty(),d);k!==null&&h(b).find("[data-dt-idx="+k+"]").focus()}catch(p){}}}});+var va=function(a,b,c,d){if(!a||"-"===a)return-Infinity;b&&(a=Pb(a,b));a.replace&&(c&&(a=a.replace(c,"")),d&&(a=a.replace(d,"")));return 1*a};h.extend(t.type.order,{"date-pre":function(a){return Date.parse(a)||0},"html-pre":function(a){return H(a)?"":a.replace?a.replace(/<.*?>/g,"").toLowerCase():a+""},"string-pre":function(a){return H(a)?"":"string"===typeof a?a.toLowerCase():!a.toString?"":a.toString()},"string-asc":function(a,b){return a<b?-1:a>b?1:0},"string-desc":function(a,b){return a<b?1:a>+b?-1:0}});cb("");h.extend(p.ext.type.detect,[function(a,b){var c=b.oLanguage.sDecimal;return Xa(a,c)?"num"+c:null},function(a){if(a&&(!Yb.test(a)||!Zb.test(a)))return null;var b=Date.parse(a);return null!==b&&!isNaN(b)||H(a)?"date":null},function(a,b){var c=b.oLanguage.sDecimal;return Xa(a,c,!0)?"num-fmt"+c:null},function(a,b){var c=b.oLanguage.sDecimal;return Qb(a,c)?"html-num"+c:null},function(a,b){var c=b.oLanguage.sDecimal;return Qb(a,c,!0)?"html-num-fmt"+c:null},function(a){return H(a)||"string"===+typeof a&&-1!==a.indexOf("<")?"html":null}]);h.extend(p.ext.type.search,{html:function(a){return H(a)?a:"string"===typeof a?a.replace(Nb," ").replace(wa,""):""},string:function(a){return H(a)?a:"string"===typeof a?a.replace(Nb," "):a}});h.extend(!0,p.ext.renderer,{header:{_:function(a,b,c,d){h(a.nTable).on("order.dt.DT",function(e,f,g,h){if(a===f){e=c.idx;b.removeClass(c.sSortingClass+" "+d.sSortAsc+" "+d.sSortDesc).addClass(h[e]=="asc"?d.sSortAsc:h[e]=="desc"?d.sSortDesc:c.sSortingClass)}})},jqueryui:function(a,+b,c,d){var e=c.idx;h("<div/>").addClass(d.sSortJUIWrapper).append(b.contents()).append(h("<span/>").addClass(d.sSortIcon+" "+c.sSortingClassJUI)).appendTo(b);h(a.nTable).on("order.dt.DT",function(f,g,h,i){if(a===g){b.removeClass(d.sSortAsc+" "+d.sSortDesc).addClass(i[e]=="asc"?d.sSortAsc:i[e]=="desc"?d.sSortDesc:c.sSortingClass);b.find("span."+d.sSortIcon).removeClass(d.sSortJUIAsc+" "+d.sSortJUIDesc+" "+d.sSortJUI+" "+d.sSortJUIAscAllowed+" "+d.sSortJUIDescAllowed).addClass(i[e]=="asc"?d.sSortJUIAsc:+i[e]=="desc"?d.sSortJUIDesc:c.sSortingClassJUI)}})}}});p.render={number:function(a,b,c,d){return{display:function(e){var f=0>e?"-":"",e=Math.abs(parseFloat(e)),g=parseInt(e,10),e=c?b+(e-g).toFixed(c).substring(2):"";return f+(d||"")+g.toString().replace(/\B(?=(\d{3})+(?!\d))/g,a)+e}}}};h.extend(p.ext.internal,{_fnExternApiFunc:Mb,_fnBuildAjax:na,_fnAjaxUpdate:jb,_fnAjaxParameters:sb,_fnAjaxUpdateDraw:tb,_fnAjaxDataSrc:oa,_fnAddColumn:Aa,_fnColumnOptions:fa,_fnAdjustColumnSizing:V,_fnVisibleToColumnIndex:ga,+_fnColumnIndexToVisible:Y,_fnVisbleColumns:Z,_fnGetColumns:X,_fnColumnTypes:Da,_fnApplyColumnDefs:hb,_fnHungarianMap:T,_fnCamelToHungarian:G,_fnLanguageCompat:N,_fnBrowserDetect:fb,_fnAddData:I,_fnAddTr:ha,_fnNodeToDataIndex:function(a,b){return b._DT_RowIndex!==l?b._DT_RowIndex:null},_fnNodeToColumnIndex:function(a,b,c){return h.inArray(c,a.aoData[b].anCells)},_fnGetCellData:A,_fnSetCellData:Ea,_fnSplitObjNotation:Ga,_fnGetObjectDataFn:U,_fnSetObjectDataFn:Ba,_fnGetDataMaster:Ha,_fnClearTable:ja,+_fnDeleteIndex:ka,_fnInvalidateRow:la,_fnGetRowElements:ia,_fnCreateTr:Fa,_fnBuildHead:ib,_fnDrawHead:ba,_fnDraw:K,_fnReDraw:L,_fnAddOptionsHtml:lb,_fnDetectHeader:aa,_fnGetUniqueThs:ma,_fnFeatureHtmlFilter:nb,_fnFilterComplete:ca,_fnFilterCustom:wb,_fnFilterColumn:vb,_fnFilter:ub,_fnFilterCreateSearch:Na,_fnEscapeRegex:Oa,_fnFilterData:xb,_fnFeatureHtmlInfo:qb,_fnUpdateInfo:Ab,_fnInfoMacros:Bb,_fnInitialise:ra,_fnInitComplete:pa,_fnLengthChange:Pa,_fnFeatureHtmlLength:mb,_fnFeatureHtmlPaginate:rb,+_fnPageChange:Ra,_fnFeatureHtmlProcessing:ob,_fnProcessingDisplay:B,_fnFeatureHtmlTable:pb,_fnScrollDraw:W,_fnApplyToChildren:F,_fnCalculateColumnWidths:Ca,_fnThrottle:Ma,_fnConvertToWidth:Cb,_fnScrollingWidthAdjust:Eb,_fnGetWidestNode:Db,_fnGetMaxLenString:Fb,_fnStringToCss:s,_fnScrollBarWidth:Gb,_fnSortFlatten:R,_fnSort:kb,_fnSortAria:Ib,_fnSortListener:Sa,_fnSortAttachListener:Ka,_fnSortingClasses:sa,_fnSortData:Hb,_fnSaveState:ta,_fnLoadState:Jb,_fnSettingsFromNode:ua,_fnLog:P,_fnMap:D,_fnBindAction:Ta,+_fnCallbackReg:x,_fnCallbackFire:u,_fnLengthOverflow:Qa,_fnRenderer:La,_fnDataSource:z,_fnRowAttributes:Ia,_fnCalculateEnd:function(){}});h.fn.dataTable=p;h.fn.dataTableSettings=p.settings;h.fn.dataTableExt=p.ext;h.fn.DataTable=function(a){return h(this).dataTable(a).api()};h.each(p,function(a,b){h.fn.DataTable[a]=b});return h.fn.dataTable};"function"===typeof define&&define.amd?define("datatables",["jquery"],N):"object"===typeof exports?N(require("jquery")):jQuery&&!jQuery.fn.dataTable&&N(jQuery)})(window,+document);diff --git a/wger/core/templates/gym/member_list.html b/wger/core/templates/gym/member_list.htmlindex 7b0ccde9b..7d38ef457 100644--- a/wger/core/templates/gym/member_list.html+++ b/wger/core/templates/gym/member_list.html@@ -6,14 +6,30 @@{% block title %}{{gym}}{% endblock %}+{% block header %}+<link rel="stylesheet" type="text/css" href="{% static 'css/jquery.dataTables.min.css' %}">+<script src="{% static 'js/jquery.dataTables.min.js' %}" ></script>+<script>+$(document).ready( function () {+ /* Make table sortable */+ $('#main_member_list').DataTable({+ paging: false,+ bFilter: false,+ bInfo : false+ });+});+</script>+{% endblock %}+{% block content %}{% if perms.core.manage_gym or perms.core.gym_trainer %}-<table class="table">+<table class="table" id="main_member_list"><thead><tr><th style="width: 10%;">{% trans "ID" %}</th>- <th style="width: 45%;">{% trans "Username" %}</th>+ <th style="width: 40%;">{% trans "Username" %}</th><th>{% trans "Name" %}</th>+ <th>{% trans "Last activity" %}</th></tr></thead><tbody>@@ -29,6 +45,9 @@<td>{{current_user.obj.get_full_name}}</td>+ <td data-order="{{current_user.last_log|date:'U'}}">+ {{current_user.last_log|default:'-/-'}}+ </td></tr>{% endif %}{% empty %}@@ -46,7 +65,7 @@<thead><tr><th style="width: 10%;">{% trans "ID" %}</th>- <th style="width: 45%;">{% trans "Username" %}</th>+ <th style="width: 40%;">{% trans "Username" %}</th><th>{% trans "Name" %}</th></tr></thead>diff --git a/wger/core/tests/test_user_last_activity.py b/wger/core/tests/test_user_last_activity.pynew file mode 100644index 000000000..688980aab--- /dev/null+++ b/wger/core/tests/test_user_last_activity.py@@ -0,0 +1,56 @@+# This file is part of wger Workout Manager.+#+# wger Workout Manager is free software: you can redistribute it and/or modify+# it under the terms of the GNU Affero General Public License as published by+# the Free Software Foundation, either version 3 of the License, or+# (at your option) any later version.+#+# wger Workout Manager is distributed in the hope that it will be useful,+# but WITHOUT ANY WARRANTY; without even the implied warranty of+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+# GNU General Public License for more details.+#+# You should have received a copy of the GNU Affero General Public License++import datetime++from django.contrib.auth.models import User++from wger.core.helpers import get_user_last_activity+from wger.manager.models import WorkoutSession, WorkoutLog+from wger.manager.tests.testcase import WorkoutManagerTestCase+++class UserLastActivityTestCase(WorkoutManagerTestCase):+ '''+ Test the helper function for last user activity+ '''++ def test_user_last_activity(self):+ '''+ Test the helper function for last user activity+ '''+ self.user_login('admin')+ user = User.objects.get(username='admin')+ log = WorkoutLog.objects.get(pk=1)+ session = WorkoutSession.objects.get(pk=1)++ self.assertEqual(get_user_last_activity(user), datetime.date(2014, 1, 30))++ # Log more recent than session+ log.date = datetime.date(2014, 10, 2)+ log.save()+ session.date = datetime.date(2014, 10, 1)+ session.save()+ self.assertEqual(get_user_last_activity(user), datetime.date(2014, 10, 2))++ # Session more recent than log+ log.date = datetime.date(2014, 9, 1)+ log.save()+ session.date = datetime.date(2014, 10, 5)+ session.save()+ self.assertEqual(get_user_last_activity(user), datetime.date(2014, 10, 5))++ # No logs, but session+ WorkoutLog.objects.filter(user=user).delete()+ self.assertEqual(get_user_last_activity(user), datetime.date(2014, 10, 5))diff --git a/wger/core/views/gym.py b/wger/core/views/gym.pyindex 44d9c5d22..1a2d9f176 100644--- a/wger/core/views/gym.py+++ b/wger/core/views/gym.py@@ -33,6 +33,7 @@ from django.views.generic import UpdateViewfrom wger.core.forms import GymUserAddFormfrom wger.core.models import Gym+from wger.core.helpers import get_user_last_activityfrom wger.utils.generic_views import WgerFormMixinfrom wger.utils.generic_views import WgerDeleteMixinfrom wger.utils.generic_views import WgerPermissionMixin@@ -64,9 +65,9 @@ class GymUserListView(WgerPermissionMixin, ListView):Only managers and trainers for this gym can access the members'''if request.user.has_perm('core.manage_gyms') \- or ((request.user.has_perm('core.manage_gym')- or request.user.has_perm('core.gym_trainer'))- and request.user.userprofile.gym_id == int(self.kwargs['pk'])):+ or ((request.user.has_perm('core.manage_gym')+ or request.user.has_perm('core.gym_trainer'))+ and request.user.userprofile.gym_id == int(self.kwargs['pk'])):return super(GymUserListView, self).dispatch(request, *args, **kwargs)return HttpResponseForbidden()@@ -77,6 +78,7 @@ class GymUserListView(WgerPermissionMixin, ListView):out = []for u in User.objects.filter(userprofile__gym_id=self.kwargs['pk']):out.append({'obj': u,+ 'last_log': get_user_last_activity(u),'perms': {'manage_gym': u.has_perm('core.manage_gym'),'manage_gyms': u.has_perm('core.manage_gyms'),'gym_trainer': u.has_perm('core.gym_trainer'),