https://www.tricare.com.au/app/themes/pvtl-child/dist/js/vendor/bootstrap-multiselect.js?ver=1788928598

1/**
2 * Bootstrap Multiselect (http://davidstutz.de/bootstrap-multiselect/)
3 *
4 * Apache License, Version 2.0:
5 * Copyright (c) 2012 - 2018 David Stutz
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
8 * use this file except in compliance with the License. You may obtain a
9 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14 * License for the specific language governing permissions and limitations
15 * under the License.
16 *
17 * BSD 3-Clause License:
18 * Copyright (c) 2012 - 2018 David Stutz
19 * All rights reserved.
20 *
21 * Redistribution and use in source and binary forms, with or without
22 * modification, are permitted provided that the following conditions are met:
23 *    - Redistributions of source code must retain the above copyright notice,
24 *      this list of conditions and the following disclaimer.
25 *    - Redistributions in binary form must reproduce the above copyright notice,
26 *      this list of conditions and the following disclaimer in the documentation
27 *      and/or other materials provided with the distribution.
28 *    - Neither the name of David Stutz nor the names of its contributors may be
29 *      used to endorse or promote products derived from this software without
30 *      specific prior written permission.
31 *
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
33 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
34 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
35 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
36 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
37 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
38 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
39 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
40 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
41 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
42 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 */
44(function (root, factory) {
45  // check to see if 'knockout' AMD module is specified if using requirejs
46  if (typeof define === 'function' && define.amd &&
47    typeof require === 'function' && typeof require.specified === 'function' && require.specified('knockout')) {
48
49    // AMD. Register as an anonymous module.
50    define(['jquery', 'knockout'], factory);
51  } else {
52    // Browser globals
53    factory(root.jQuery, root.ko);
54  }
55})(this, function ($, ko) {
56  "use strict";// jshint ;_;
57
58  if (typeof ko !== 'undefined' && ko.bindingHandlers && !ko.bindingHandlers.multiselect) {
59    ko.bindingHandlers.multiselect = {
60      after: ['options', 'value', 'selectedOptions', 'enable', 'disable'],
61
62      init: function(element, valueAccessor, allBindings, viewModel, bindingContext) {
63        var $element = $(element);
64        var config = ko.toJS(valueAccessor());
65
66        $element.multiselect(config);
67
68        if (allBindings.has('options')) {
69          var options = allBindings.get('options');
70          if (ko.isObservable(options)) {
71            ko.computed({
72              read: function() {
73                options();
74                setTimeout(function() {
75                  var ms = $element.data('multiselect');
76                  if (ms)
77                    ms.updateOriginalOptions();//Not sure how beneficial this is.
78                  $element.multiselect('rebuild');
79                }, 1);
80              },
81              disposeWhenNodeIsRemoved: element
82            });
83          }
84        }
85
86        //value and selectedOptions are two-way, so these will be triggered even by our own actions.
87        //It needs some way to tell if they are triggered because of us or because of outside change.
88        //It doesn't loop but it's a waste of processing.
89        if (allBindings.has('value')) {
90          var value = allBindings.get('value');
91          if (ko.isObservable(value)) {
92            ko.computed({
93              read: function() {
94                value();
95                setTimeout(function() {
96                  $element.multiselect('refresh');
97                }, 1);
98              },
99              disposeWhenNodeIsRemoved: element
100            }).extend({ rateLimit: 100, notifyWhenChangesStop: true });
101          }
102        }
103
104        //Switched from arrayChange subscription to general subscription using 'refresh'.
105        //Not sure performance is any better using 'select' and 'deselect'.
106        if (allBindings.has('selectedOptions')) {
107          var selectedOptions = allBindings.get('selectedOptions');
108          if (ko.isObservable(selectedOptions)) {
109            ko.computed({
110              read: function() {
111                selectedOptions();
112                setTimeout(function() {
113                  $element.multiselect('refresh');
114                }, 1);
115              },
116              disposeWhenNodeIsRemoved: element
117            }).extend({ rateLimit: 100, notifyWhenChangesStop: true });
118          }
119        }
120
121        var setEnabled = function (enable) {
122          setTimeout(function () {
123            if (enable)
124              $element.multiselect('enable');
125            else
126              $element.multiselect('disable');
127          });
128        };
129
130        if (allBindings.has('enable')) {
131          var enable = allBindings.get('enable');
132          if (ko.isObservable(enable)) {
133            ko.computed({
134              read: function () {
135                setEnabled(enable());
136              },
137              disposeWhenNodeIsRemoved: element
138            }).extend({ rateLimit: 100, notifyWhenChangesStop: true });
139          } else {
140            setEnabled(enable);
141          }
142        }
143
144        if (allBindings.has('disable')) {
145          var disable = allBindings.get('disable');
146          if (ko.isObservable(disable)) {
147            ko.computed({
148              read: function () {
149                setEnabled(!disable());
150              },
151              disposeWhenNodeIsRemoved: element
152            }).extend({ rateLimit: 100, notifyWhenChangesStop: true });
153          } else {
154            setEnabled(!disable);
155          }
156        }
157
158        ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
159          $element.multiselect('destroy');
160        });
161      },
162
163      update: function(element, valueAccessor, allBindings, viewModel, bindingContext) {
164        var $element = $(element);
165        var config = ko.toJS(valueAccessor());
166
167        $element.multiselect('setOptions', config);
168        $element.multiselect('rebuild');
169      }
170    };
171  }
172
173  function forEach(array, callback) {
174    for (var index = 0; index < array.length; ++index) {
175      callback(array[index], index);
176    }
177  }
178
179  /**
180   * Constructor to create a new multiselect using the given select.
181   *
182   * @param {jQuery} select
183   * @param {Object} options
184   * @returns {Multiselect}
185   */
186  function Multiselect(select, options) {
187
188    this.$select = $(select);
189    this.options = this.mergeOptions($.extend({}, options, this.$select.data()));
190
191    // Placeholder via data attributes
192    if (this.$select.attr("data-placeholder")) {
193      this.options.nonSelectedText = this.$select.data("placeholder");
194    }
195
196    // Initialization.
197    // We have to clone to create a new reference.
198    this.originalOptions = this.$select.clone()[0].options;
199    this.query = '';
200    this.searchTimeout = null;
201    this.lastToggledInput = null;
202
203    this.options.multiple = this.$select.attr('multiple') === "multiple";
204    this.options.onChange = $.proxy(this.options.onChange, this);
205    this.options.onSelectAll = $.proxy(this.options.onSelectAll, this);
206    this.options.onDeselectAll = $.proxy(this.options.onDeselectAll, this);
207    this.options.onDropdownShow = $.proxy(this.options.onDropdownShow, this);
208    this.options.onDropdownHide = $.proxy(this.options.onDropdownHide, this);
209    this.options.onDropdownShown = $.proxy(this.options.onDropdownShown, this);
210    this.options.onDropdownHidden = $.proxy(this.options.onDropdownHidden, this);
211    this.options.onInitialized = $.proxy(this.options.onInitialized, this);
212    this.options.onFiltering = $.proxy(this.options.onFiltering, this);
213
214    // Build select all if enabled.
215    this.buildContainer();
216    this.buildButton();
217    this.buildDropdown();
218    this.buildReset();
219    this.buildSelectAll();
220    this.buildDropdownOptions();
221    this.buildFilter();
222
223    this.updateButtonText();
224    this.updateSelectAll(true);
225
226    if (this.options.enableClickableOptGroups && this.options.multiple) {
227      this.updateOptGroups();
228    }
229
230    this.options.wasDisabled = this.$select.prop('disabled');
231    if (this.options.disableIfEmpty && $('option', this.$select).length <= 0) {
232      this.disable();
233    }
234
235    this.$select.wrap('<span class="multiselect-native-select" />').after(this.$container);
236    this.options.onInitialized(this.$select, this.$container);
237  }
238
239  Multiselect.prototype = {
240
241    defaults: {
242      /**
243       * Default text function will either print 'None selected' in case no
244       * option is selected or a list of the selected options up to a length
245       * of 3 selected options.
246       *
247       * @param {jQuery} options
248       * @param {jQuery} select
249       * @returns {String}
250       */
251      buttonText: function(options, select) {
252        if (this.disabledText.length > 0
253          && (select.prop('disabled') || (options.length == 0 && this.disableIfEmpty)))  {
254
255          return this.disabledText;
256        }
257        else if (options.length === 0) {
258          return this.nonSelectedText;
259        }
260        else if (this.allSelectedText
261          && options.length === $('option', $(select)).length
262          && $('option', $(select)).length !== 1
263          && this.multiple) {
264
265          if (this.selectAllNumber) {
266            return this.allSelectedText + ' (' + options.length + ')';
267          }
268          else {
269            return this.allSelectedText;
270          }
271        }
272        else if (this.numberDisplayed != 0 && options.length > this.numberDisplayed) {
273          return options.length + ' ' + this.nSelectedText;
274        }
275        else {
276          var selected = '';
277          var delimiter = this.delimiterText;
278
279          options.each(function() {
280            var label = ($(this).attr('label') !== undefined) ? $(this).attr('label') : $(this).text();
281            selected += label + delimiter;
282          });
283
284          return selected.substr(0, selected.length - this.delimiterText.length);
285        }
286      },
287      /**
288       * Updates the title of the button similar to the buttonText function.
289       *
290       * @param {jQuery} options
291       * @param {jQuery} select
292       * @returns {@exp;selected@call;substr}
293       */
294      buttonTitle: function(options, select) {
295        if (options.length === 0) {
296          return this.nonSelectedText;
297        }
298        else {
299          var selected = '';
300          var delimiter = this.delimiterText;
301
302          options.each(function () {
303            var label = ($(this).attr('label') !== undefined) ? $(this).attr('label') : $(this).text();
304            selected += label + delimiter;
305          });
306          return selected.substr(0, selected.length - this.delimiterText.length);
307        }
308      },
309      checkboxName: function(option) {
310        return false; // no checkbox name
311      },
312      /**
313       * Create a label.
314       *
315       * @param {jQuery} element
316       * @returns {String}
317       */
318      optionLabel: function(element){
319        return $(element).attr('label') || $(element).text();
320      },
321      /**
322       * Create a class.
323       *
324       * @param {jQuery} element
325       * @returns {String}
326       */
327      optionClass: function(element) {
328        return $(element).attr('class') || '';
329      },
330      /**
331       * Triggered on change of the multiselect.
332       *
333       * Not triggered when selecting/deselecting options manually.
334       *
335       * @param {jQuery} option
336       * @param {Boolean} checked
337       */
338      onChange : function(option, checked) {
339
340      },
341      /**
342       * Triggered when the dropdown is shown.
343       *
344       * @param {jQuery} event
345       */
346      onDropdownShow: function(event) {
347
348      },
349      /**
350       * Triggered when the dropdown is hidden.
351       *
352       * @param {jQuery} event
353       */
354      onDropdownHide: function(event) {
355
356      },
357      /**
358       * Triggered after the dropdown is shown.
359       *
360       * @param {jQuery} event
361       */
362      onDropdownShown: function(event) {
363
364      },
365      /**
366       * Triggered after the dropdown is hidden.
367       *
368       * @param {jQuery} event
369       */
370      onDropdownHidden: function(event) {
371
372      },
373      /**
374       * Triggered on select all.
375       */
376      onSelectAll: function() {
377
378      },
379      /**
380       * Triggered on deselect all.
381       */
382      onDeselectAll: function() {
383
384      },
385      /**
386       * Triggered after initializing.
387       *
388       * @param {jQuery} $select
389       * @param {jQuery} $container
390       */
391      onInitialized: function($select, $container) {
392
393      },
394      /**
395       * Triggered on filtering.
396       *
397       * @param {jQuery} $filter
398       */
399      onFiltering: function($filter) {
400
401      },

1131
1132                    if (this.options.enableCaseInsensitiveFiltering) {
1133                      filterCandidate = filterCandidate.toLowerCase();
1134                      this.query = this.query.toLowerCase();
1135                    }
1136
1137                    if (this.options.enableFullValueFiltering && this.options.filterBehavior !== 'both') {
1138                      var valueToMatch = filterCandidate.trim().substring(0, this.query.length);
1139                      if (this.query.indexOf(valueToMatch) > -1) {
1140                        showElement = true;
1141                      }
1142                    }
1143                    else if (filterCandidate.indexOf(this.query) > -1) {
1144                      showElement = true;
1145                    }
1146
1147                    // Toggle current element (group or group item) according to showElement boolean.
1148                    if(!showElement){
1149                      $(element).css('display', 'none');
1150                      $(element).addClass('multiselect-filter-hidden');
1151                    }
1152                    if(showElement){
1153                      $(element).css('display', 'block');
1154                      $(element).removeClass('multiselect-filter-hidden');
1155                    }
1156
1157                    // Differentiate groups and group items.
1158                    if ($(element).hasClass('multiselect-group')) {
1159                      // Remember group status.
1160                      currentGroup = element;
1161                      currentGroupVisible = showElement;
1162                    }
1163                    else {
1164                      // Show group name when at least one of its items is visible.
1165                      if (showElement) {
1166                        $(currentGroup).show()
1167                          .removeClass('multiselect-filter-hidden');
1168                      }
1169
1170                      // Show all group items when group name satisfies filter.
1171                      if (!showElement && currentGroupVisible) {
1172                        $(element).show()
1173                          .removeClass('multiselect-filter-hidden');
1174                      }
1175                    }
1176                  }
1177                }, this));
1178              }
1179
1180              this.updateSelectAll();
1181
1182              if (this.options.enableClickableOptGroups && this.options.multiple) {
1183                this.updateOptGroups();
1184              }
1185
1186              this.options.onFiltering(event.target);
1187
1188            }, this), 300, this);
1189          }, this));
1190        }
1191      }
1192    },
1193
1194    /**
1195     * Unbinds the whole plugin.
1196     */
1197    destroy: function() {
1198      this.$container.remove();
1199      this.$select.show();
1200
1201      // reset original state
1202      this.$select.prop('disabled', this.options.wasDisabled);
1203
1204      this.$select.data('multiselect', null);
1205    },
1206
1207    /**
1208     * Refreshs the multiselect based on the selected options of the select.
1209     */
1210    refresh: function () {
1211      var inputs = {};
1212      $('li input', this.$ul).each(function() {
1213        inputs[$(this).val()] = $(this);
1214      });
1215
1216      $('option', this.$select).each($.proxy(function (index, element) {
1217        var $elem = $(element);
1218        var $input = inputs[$(element).val()];
1219
1220        if ($elem.is(':selected')) {
1221          $input.prop('checked', true);
1222
1223          if (this.options.selectedClass) {
1224            $input.closest('li')
1225              .addClass(this.options.selectedClass);
1226          }
1227        }
1228        else {
1229          $input.prop('checked', false);
1230
1231          if (this.options.selectedClass) {
1232            $input.closest('li')
1233              .removeClass(this.options.selectedClass);
1234          }
1235        }
1236
1237        if ($elem.is(":disabled")) {
1238          $input.attr('disabled', 'disabled')
1239            .prop('disabled', true)
1240            .closest('li')
1241            .addClass('disabled');
1242        }
1243        else {
1244          $input.prop('disabled', false)
1245            .closest('li')
1246            .removeClass('disabled');
1247        }
1248      }, this));
1249
1250      this.updateButtonText();
1251      this.updateSelectAll();
1252
1253      if (this.options.enableClickableOptGroups && this.options.multiple) {
1254        this.updateOptGroups();
1255      }
1256    },
1257
1258    /**
1259     * Select all options of the given values.
1260     *
1261     * If triggerOnChange is set to true, the on change event is triggered if
1262     * and only if one value is passed.
1263     *
1264     * @param {Array} selectValues
1265     * @param {Boolean} triggerOnChange
1266     */
1267    select: function(selectValues, triggerOnChange) {
1268      if(!$.isArray(selectValues)) {
1269        selectValues = [selectValues];
1270      }
1271
1272      for (var i = 0; i < selectValues.length; i++) {
1273        var value = selectValues[i];
1274
1275        if (value === null || value === undefined) {
1276          continue;
1277        }
1278
1279        var $option = this.getOptionByValue(value);
1280        var $checkbox = this.getInputByValue(value);
1281
1282        if($option === undefined || $checkbox === undefined) {
1283          continue;
1284        }
1285
1286        if (!this.options.multiple) {
1287          this.deselectAll(false);
1288        }
1289
1290        if (this.options.selectedClass) {
1291          $checkbox.closest('li')
1292            .addClass(this.options.selectedClass);
1293        }
1294
1295        $checkbox.prop('checked', true);
1296        $option.prop('selected', true);
1297
1298        if (triggerOnChange) {
1299          this.options.onChange($option, true);
1300        }
1301      }
1302
1303      this.updateButtonText();
1304      this.updateSelectAll();
1305
1306      if (this.options.enableClickableOptGroups && this.options.multiple) {
1307        this.updateOptGroups();
1308      }
1309    },
1310
1311    /**
1312     * Clears all selected items.
1313     */
1314    clearSelection: function () {
1315      this.deselectAll(false);
1316      this.updateButtonText();
1317      this.updateSelectAll();
1318
1319      if (this.options.enableClickableOptGroups && this.options.multiple) {
1320        this.updateOptGroups();
1321      }
1322    },
1323
1324    /**
1325     * Deselects all options of the given values.
1326     *
1327     * If triggerOnChange is set to true, the on change event is triggered, if
1328     * and only if one value is passed.
1329     *
1330     * @param {Array} deselectValues
1331     * @param {Boolean} triggerOnChange
1332     */
1333    deselect: function(deselectValues, triggerOnChange) {
1334      if(!$.isArray(deselectValues)) {
1335        deselectValues = [deselectValues];
1336      }
1337
1338      for (var i = 0; i < deselectValues.length; i++) {
1339        var value = deselectValues[i];
1340
1341        if (value === null || value === undefined) {
1342          continue;
1343        }
1344
1345        var $option = this.getOptionByValue(value);
1346        var $checkbox = this.getInputByValue(value);
1347
1348        if($option === undefined || $checkbox === undefined) {
1349          continue;
1350        }
1351
1352        if (this.options.selectedClass) {
1353          $checkbox.closest('li')
1354            .removeClass(this.options.selectedClass);
1355        }
1356
1357        $checkbox.prop('checked', false);
1358        $option.prop('selected', false);
1359
1360        if (triggerOnChange) {
1361          this.options.onChange($option, false);
1362        }
1363      }
1364
1365      this.updateButtonText();
1366      this.updateSelectAll();
1367
1368      if (this.options.enableClickableOptGroups && this.options.multiple) {
1369        this.updateOptGroups();
1370      }
1371    },
1372
1373    /**
1374     * Selects all enabled & visible options.
1375     *
1376     * If justVisible is true or not specified, only visible options are selected.
1377     *
1378     * @param {Boolean} justVisible
1379     * @param {Boolean} triggerOnSelectAll
1380     */
1381    selectAll: function (justVisible, triggerOnSelectAll) {
1382
1383      var justVisible = typeof justVisible === 'undefined' ? true : justVisible;
1384      var allLis = $("li:not(.divider):not(.disabled):not(.multiselect-group)", this.$ul);
1385      var visibleLis = $("li:not(.divider):not(.disabled):not(.multiselect-group):not(.multiselect-filter-hidden):not(.multiselect-collapisble-hidden)", this.$ul).filter(':visible');
1386
1387      if(justVisible) {
1388        $('input:enabled' , visibleLis).prop('checked', true);
1389        visibleLis.addClass(this.options.selectedClass);
1390
1391        $('input:enabled' , visibleLis).each($.proxy(function(index, element) {
1392          var value = $(element).val();
1393          var option = this.getOptionByValue(value);
1394          $(option).prop('selected', true);
1395        }, this));
1396      }
1397      else {
1398        $('input:enabled' , allLis).prop('checked', true);
1399        allLis.addClass(this.options.selectedClass);
1400
1401        $('input:enabled' , allLis).each($.proxy(function(index, element) {
1402          var value = $(element).val();
1403          var option = this.getOptionByValue(value);
1404          $(option).prop('selected', true);
1405        }, this));
1406      }
1407
1408      $('li input[value="' + this.options.selectAllValue + '"]', this.$ul).prop('checked', true);
1409
1410      if (this.options.enableClickableOptGroups && this.options.multiple) {
1411        this.updateOptGroups();
1412      }
1413
1414      if (triggerOnSelectAll) {
1415        this.options.onSelectAll();
1416      }
1417    },
1418
1419    /**
1420     * Deselects all options.
1421     *
1422     * If justVisible is true or not specified, only visible options are deselected.
1423     *
1424     * @param {Boolean} justVisible
1425     */
1426    deselectAll: function (justVisible, triggerOnDeselectAll) {
1427
1428      var justVisible = typeof justVisible === 'undefined' ? true : justVisible;
1429      var allLis = $("li:not(.divider):not(.disabled):not(.multiselect-group)", this.$ul);
1430      var visibleLis = $("li:not(.divider):not(.disabled):not(.multiselect-group):not(.multiselect-filter-hidden):not(.multiselect-collapisble-hidden)", this.$ul).filter(':visible');
1431
1432      if(justVisible) {
1433        $('input[type="checkbox"]:enabled' , visibleLis).prop('checked', false);
1434        visibleLis.removeClass(this.options.selectedClass);
1435
1436        $('input[type="checkbox"]:enabled' , visibleLis).each($.proxy(function(index, element) {
1437          var value = $(element).val();
1438          var option = this.getOptionByValue(value);
1439          $(option).prop('selected', false);
1440        }, this));
1441      }
1442      else {
1443        $('input[type="checkbox"]:enabled' , allLis).prop('checked', false);
1444        allLis.removeClass(this.options.selectedClass);
1445
1446        $('input[type="checkbox"]:enabled' , allLis).each($.proxy(function(index, element) {
1447          var value = $(element).val();
1448          var option = this.getOptionByValue(value);
1449          $(option).prop('selected', false);
1450        }, this));
1451      }
1452
1453      $('li input[value="' + this.options.selectAllValue + '"]', this.$ul).prop('checked', false);
1454
1455      if (this.options.enableClickableOptGroups && this.options.multiple) {
1456        this.updateOptGroups();
1457      }
1458
1459      if (triggerOnDeselectAll) {
1460        this.options.onDeselectAll();
1461      }
1462    },
1463
1464    /**
1465     * Rebuild the plugin.
1466     *
1467     * Rebuilds the dropdown, the filter and the select all option.
1468     */
1469    rebuild: function() {
1470      this.$ul.html('');
1471
1472      // Important to distinguish between radios and checkboxes.
1473      this.options.multiple = this.$select.attr('multiple') === "multiple";
1474
1475      this.buildSelectAll();
1476      this.buildDropdownOptions();
1477      this.buildFilter();
1478
1479      this.updateButtonText();
1480      this.updateSelectAll(true);
1481
1482      if (this.options.enableClickableOptGroups && this.options.multiple) {
1483        this.updateOptGroups();
1484      }
1485
1486      if (this.options.disableIfEmpty && $('option', this.$select).length <= 0) {
1487        this.disable();
1488      }
1489      else {
1490        this.enable();
1491      }
1492
1493      if (this.options.dropRight) {
1494        this.$ul.addClass('pull-right');
1495      }
1496    },
1497
1498    /**
1499     * The provided data will be used to build the dropdown.
1500     */
1501    dataprovider: function(dataprovider) {
1502
1503      var groupCounter = 0;
1504      var $select = this.$select.empty();
1505
1506      $.each(dataprovider, function (index, option) {
1507        var $tag;
1508
1509        if ($.isArray(option.children)) { // create optiongroup tag
1510          groupCounter++;
1511
1512          $tag = $('<optgroup/>').attr({
1513            label: option.label || 'Group ' + groupCounter,
1514            disabled: !!option.disabled,
1515            value: option.value
1516          });
1517
1518          forEach(option.children, function(subOption) { // add children option tags
1519            var attributes = {
1520              value: subOption.value,
1521              label: subOption.label || subOption.value,
1522              title: subOption.title,
1523              selected: !!subOption.selected,
1524              disabled: !!subOption.disabled
1525            };
1526
1527            //Loop through attributes object and add key-value for each attribute
1528            for (var key in subOption.attributes) {
1529              attributes['data-' + key] = subOption.attributes[key];
1530            }
1531            //Append original attributes + new data attributes to option
1532            $tag.append($('<option/>').attr(attributes));
1533          });
1534        }
1535        else {
1536
1537          var attributes = {
1538            'value': option.value,
1539            'label': option.label || option.value,
1540            'title': option.title,
1541            'class': option['class'],
1542            'selected': !!option['selected'],
1543            'disabled': !!option['disabled']
1544          };
1545          //Loop through attributes object and add key-value for each attribute
1546          for (var key in option.attributes) {
1547            attributes['data-' + key] = option.attributes[key];
1548          }
1549          //Append original attributes + new data attributes to option
1550          $tag = $('<option/>').attr(attributes);
1551
1552          $tag.text(option.label || option.value);
1553        }
1554
1555        $select.append($tag);
1556      });
1557
1558      this.rebuild();
1559    },
1560
1561    /**
1562     * Enable the multiselect.
1563     */
1564    enable: function() {
1565      this.$select.prop('disabled', false);
1566      this.$button.prop('disabled', false)
1567        .removeClass('disabled');
1568    },
1569
1570    /**
1571     * Disable the multiselect.
1572     */
1573    disable: function() {
1574      this.$select.prop('disabled', true);
1575      this.$button.prop('disabled', true)
1576        .addClass('disabled');
1577    },
1578
1579    /**
1580     * Set the options.
1581     *
1582     * @param {Array} options
1583     */
1584    setOptions: function(options) {
1585      this.options = this.mergeOptions(options);
1586    },
1587
1588    /**
1589     * Merges the given options with the default options.
1590     *
1591     * @param {Array} options
1592     * @returns {Array}
1593     */
1594    mergeOptions: function(options) {
1595      return $.extend(true, {}, this.defaults, this.options, options);
1596    },
1597
1598    /**
1599     * Checks whether a select all checkbox is present.
1600     *
1601     * @returns {Boolean}
1602     */
1603    hasSelectAll: function() {
1604      return $('li.multiselect-all', this.$ul).length > 0;
1605    },
1606
1607    /**
1608     * Update opt groups.
1609     */
1610    updateOptGroups: function() {
1611      var $groups = $('li.multiselect-group', this.$ul)
1612      var selectedClass = this.options.selectedClass;
1613
1614      $groups.each(function() {
1615        var $options = $(this).nextUntil('li.multiselect-group')
1616          .not('.multiselect-filter-hidden')
1617          .not('.disabled');
1618
1619        var checked = true;
1620        $options.each(function() {
1621          var $input = $('input', this);
1622
1623          if (!$input.prop('checked')) {
1624            checked = false;
1625          }
1626        });
1627
1628        if (selectedClass) {
1629          if (checked) {
1630            $(this).addClass(selectedClass);
1631          }
1632          else {
1633            $(this).removeClass(selectedClass);
1634          }
1635        }
1636
1637        $('input', this).prop('checked', checked);
1638      });
1639    },
1640
1641    /**
1642     * Updates the select all checkbox based on the currently displayed and selected checkboxes.
1643     */
1644    updateSelectAll: function(notTriggerOnSelectAll) {
1645      if (this.hasSelectAll()) {
1646        var allBoxes = $("li:not(.multiselect-item):not(.multiselect-filter-hidden):not(.multiselect-group):not(.disabled) input:enabled", this.$ul);
1647        var allBoxesLength = allBoxes.length;
1648        var checkedBoxesLength = allBoxes.filter(":checked").length;
1649        var selectAllLi  = $("li.multiselect-all", this.$ul);
1650        var selectAllInput = selectAllLi.find("input");
1651
1652        if (checkedBoxesLength > 0 && checkedBoxesLength === allBoxesLength) {
1653          selectAllInput.prop("checked", true);
1654          selectAllLi.addClass(this.options.selectedClass);
1655        }
1656        else {
1657          selectAllInput.prop("checked", false);
1658          selectAllLi.removeClass(this.options.selectedClass);
1659        }
1660      }
1661    },
1662
1663    /**
1664     * Update the button text and its title based on the currently selected options.
1665     */
1666    updateButtonText: function() {