• Home
• de.larmic.butterfaces
• components
• 1.10.0
• source code
• butterfaces-js-bundle.js

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

META-INF.resources.butterfaces-dist-bundle-js.butterfaces-js-bundle.js Maven / Gradle / Ivy

/* Simple JavaScript Inheritance
 * By John Resig http://ejohn.org/
 * MIT Licensed.
 */
// Inspired by base2 and Prototype
(function(){
    var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

    // The base Class implementation (does nothing)
    this.Class = function(){};

    // Create a new Class that inherits from this class
    Class.extend = function(prop) {
        var _super = this.prototype;

        // Instantiate a base class (but only create the instance,
        // don't run the init constructor)
        initializing = true;
        var prototype = new this();
        initializing = false;

        // Copy the properties over onto the new prototype
        for (var name in prop) {
            // Check if we're overwriting an existing function
            prototype[name] = typeof prop[name] == "function" &&
            typeof _super[name] == "function" && fnTest.test(prop[name]) ?
                    (function(name, fn){
                        return function() {
                            var tmp = this._super;

                            // Add a new ._super() method that is the same method
                            // but on the super-class
                            this._super = _super[name];

                            // The method only need to be bound temporarily, so we
                            // remove it when we're done executing
                            var ret = fn.apply(this, arguments);
                            this._super = tmp;

                            return ret;
                        };
                    })(name, prop[name]) :
                    prop[name];
        }

        // The dummy class constructor
        function Class() {
            // All construction is actually done in the init method
            if ( !initializing && this.init )
                this.init.apply(this, arguments);
        }

        // Populate our constructed prototype object
        Class.prototype = prototype;

        // Enforce the constructor to be what we expect
        Class.prototype.constructor = Class;

        // And make this class extendable
        Class.extend = arguments.callee;

        return Class;
    };
})();
if (typeof butter === 'undefined') {
    butter = {};
}
butter.ajax = {};

butter.ajax.disableElementsOnRequest =  function(/* object */ data, /* array of string */ ids) {
    var status = data.status;

    // console.log(data);
    // console.log(ids);

    switch (status) {
        case "begin": // Before the ajax request is sent.
            // console.log('ajax request begin');

            for(i=0;i 0) {
                this._trySendJsfAjaxRequest();
            } else if ($autocomplete.is(":visible") && $autocomplete.find("li").length > 0) {
                if (this.$selectedOption === null) {
                    this._selectResultOptionElement($autocomplete.find("li")[0]);
                } else {
                    this._moveResultOptionElementSelectionCursor(
                            $autocomplete, event.which === this._keyCodes.arrow_up ? -1 : 1);
                }
            }
        },

        _handleEscapeKeyDown: function (event) {
            this._stopEvent(event);
            this._hideAutocompleteResultList();
        },

        _trySendJsfAjaxRequest: function () {
            var self = this;

            if (self.isRequestRunning) {
                // console.log("request is active, so remember that changes has been made while request was running");
                self.areChangesMadeWhileRequestWasRunning = true;
            }

            if (self.requestDelayTimerId !== null) {
                window.clearTimeout(self.requestDelayTimerId)
            }

            self.requestDelayTimerId = window.setTimeout(function () {
                self.requestDelayTimerId = null;
                self._sendJsfAjaxRequest();
            }, self.SEARCH_REQUEST_DELAY);
        },

        _sendJsfAjaxRequest: function () {
            var self = this;

            if (self.isRequestRunning) {
                // console.log("request is running, abort");
                return;
            }
            self.isRequestRunning = true;

            self.areChangesMadeWhileRequestWasRunning = false;
            self._showLoadingSpinner();

            // console.log("starting request");

            jsf.ajax.request(self.$input[0], "autocomplete", {
                "javax.faces.behavior.event": "autocomplete",
                render: self.autocompleteId,
                params: self.$input.val(),
                onevent: function (data) {
                    if (data.status === "success") {
                        // console.log("request finished");

                        // only show result if input field still has focus
                        if (self.$input.is(":focus")) {
                            self._handleAutocompleteResultListVisibility();
                        }
                        self._hideLoadingSpinner();
                        self.isRequestRunning = false;

                        if (self.areChangesMadeWhileRequestWasRunning) {
                            // console.log("changes made while request was running, start new request automatically");
                            self._sendJsfAjaxRequest();
                        }
                    }
                }
            });
        },

        _handleAutocompleteResultListVisibility: function () {
            var self = this;
            var $autocomplete = self._getAutocompleteElement();

            if ($autocomplete.find("li").length > 0) {
                self._initAndShowAutocompleteResultList();
            } else {
                self._hideAutocompleteResultList();
            }
        },

        _showLoadingSpinner: function () {
            $('
')
                    .appendTo(this.$input.parent());
        },

        _hideLoadingSpinner: function () {
            this.$input.parent().find(".butter-dropdownlist-spinner").remove();
        },

        _initAndShowAutocompleteResultList: function () {
            var self = this;
            var $autocomplete = self._getAutocompleteElement();
            $autocomplete
                    .show()
                    .css({
                        width: self.$input.innerWidth()
                    })
                    .highlight(self.$input.val());

            $autocomplete.find("ul")
                    .on("mouseleave", function () {
                        self._clearResultOptionSelection();
                    });

            $autocomplete.find("li")
                    .on("mousedown", function () {
                        self._setSelectedValue();
                    })
                    .on("mouseenter", function () {
                        self._selectResultOptionElement(this);
                    });
        },

        _selectResultOptionElement: function (optionElement) {
            this._clearResultOptionSelection();
            var $selectedOptionElement = $(optionElement);
            $selectedOptionElement.addClass("butter-dropdownlist-resultItem-selected");
            this.$selectedOption = $selectedOptionElement;
        },

        _clearResultOptionSelection: function () {
            this.$selectedOption = null;
            this._getAutocompleteElement()
                    .find(".butter-dropdownlist-resultItem-selected")
                    .removeClass("butter-dropdownlist-resultItem-selected");
        },

        _moveResultOptionElementSelectionCursor: function ($autocomplete, direction) {
            if (direction > 0) {
                var $next = this.$selectedOption.next();
                if ($next.length > 0) {
                    this._selectResultOptionElement($next[0]);
                } else {
                    //there is no next
                    this._selectResultOptionElement($autocomplete.find("li")[0]);
                }
            } else {
                var $prev = this.$selectedOption.prev();
                if ($prev.length > 0) {
                    this._selectResultOptionElement($prev[0]);
                } else {
                    //there is no previous
                    var resultListOptions = $autocomplete.find("li");
                    this._selectResultOptionElement(resultListOptions[resultListOptions.length - 1]);
                }
            }
        },

        _setSelectedValue: function () {
            if (this.$selectedOption !== null) {
                this.ignoreKeyupEvent = true;
                this.$input
                        .val(this.$selectedOption.attr("data-select-value"))
                        .change()
                        .focus()
                        .keyup();
                this._hideAutocompleteResultList();
            }
        },

        _hideAutocompleteResultList: function () {
            if (this.requestDelayTimerId !== null) {
                window.clearTimeout(this.requestDelayTimerId)
            }
            this.$selectedOption = null;
            this._getAutocompleteElement().hide();
        },

        _getAutocompleteElement: function () {
            return $(document.getElementById(this.autocompleteId));
        },

        _stopEvent: function (event) {
            event.stopPropagation();
            event.preventDefault();
        }
    });

}(jQuery));
/**
 * jQuery-Plugin to handle bootstrap fixes.
 * Works with at least jQuery 1.3.2.
 *
 * How to use:
 * jQuery("#someTreeSelector").fixBootstrapDropDown();
 */
(function ($) {
    $.fn.fixBootstrapDropDown = function () {

        return this.each(function () {
            $('.dropdown-menu').on('click', function(e) {
                if($(this).hasClass('dropdown-menu-form')) {
                    e.stopPropagation();
                }
            });
        });

    };
}(jQuery));
/**
 * butterItemFilterField is a jQuery plugin that filters html element with the css class filterable-item.
 * It is applied to the search field.

 * If no filter text is entered, then all filterable-items are displayed. Else the search field value is matched against all text contained by a filterable-item.
 *
 * How to use:
 * jQuery("#someInputSelector").butterItemFilterField();
 *
 * Author: Yann Massard
 */
(function ($) {
    var delay = (function () {
        var timer = 0;
        return function (callback, ms) {
            clearTimeout(timer);
            timer = setTimeout(callback, ms);
        };
    })();

    // extend jQuery --------------------------------------------------------------------
    $.fn.butterItemFilterField = function (filterableItemContainerSelector) {
        return this.each(function () {
            var $this = $(this);
            $this.keyup(function () {
                delay(function () {
                    var filterValue = $this.val();

                    // find container again every time, because it could have been rerendered.
                    var $filterableItemContainer;
                    if (filterableItemContainerSelector) {
                        $filterableItemContainer = $(filterableItemContainerSelector);
                    } else {
                        var containerSelector = $this.attr('data-filterable-item-container');
                        $filterableItemContainer = $(containerSelector);
                    }

                    $filterableItemContainer.find('.filterable-item').each(function () {
                        var $filterableItem = $(this);
                        if ($filterableItem.is(':containsIgnoreCase(' + filterValue + ')')) {
                            $filterableItem.removeClass("hidden");
                            $filterableItem.highlight(filterValue);
                        } else {
                            $filterableItem.addClass("hidden");
                        }

                    });
                }, 300);
            });
        });
    };
}(jQuery));

(function ($) {
    $.expr[":"].containsIgnoreCase = $.expr.createPseudo(function (arg) {
        return function (elem) {
            return !arg || $(elem).text().toUpperCase().indexOf(arg.toUpperCase()) >= 0;
        };
    });
}(jQuery));
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.butterCombobox = function () {
        return this.each(function () {
            new FilterableCombobox(this);
        });
    };

    // define objects --------------------------------------------------------------------

    /**
     * @class
     */
    var FilterableComboboxMouseEventListener = Class.extend({
        /**
         * Is called when a mouse down event is triggered on a result list option. Intended to be overridden.
         * @param {String} value the value of the result list option
         */
        onResultItemMouseDown: function (value) {
        },

        /**
         * Is called when a mouse enter event is triggered on a result list option. Intended to be overridden.
         * @param {String} value the value of the result list option
         */
        onResultItemMouseEnter: function (value) {
        }
    });

    /**
     * @class
     */
    var FilterableComboboxOption = Class.extend({
        /**
         * @constructs
         * @param {HTMLElement} optionElement
         * @param {FilterableComboboxMouseEventListener} mouseEventListener
         * @param {jQuery} $template
         */
        init: function (optionElement, mouseEventListener, $template) {
            this._$optionElement = $(optionElement);
            this._mouseEventListener = mouseEventListener;
            this._$resultElement;
            this._initResultItem($template);
        },

        _initResultItem: function ($template) {
            var self = this;
            var resultItemHtml = self._$optionElement.text();
            if ($template !== undefined) {
                var dataFields = self._$optionElement.data();
                // for the no selection option there are no data fields. don't take the template in this case!
                if(!$.isEmptyObject(dataFields)) {
                    resultItemHtml = $template;
                    $template.replace(/\{\{(.*?)\}\}/g, function (group0, group1) {
                        resultItemHtml = resultItemHtml.replace("{{" + group1 + "}}", dataFields[group1.toLowerCase()] || '')
                        return;
                    })
                }
            }

            self._$resultElement = $("
")
                .html(resultItemHtml)
                .addClass("butter-dropdownlist-resultItem");

            if (self._mouseEventListener !== undefined) {
                self._$resultElement.
                    on("mousedown", function () {
                        self._mouseEventListener.onResultItemMouseDown(self.getValue());
                    })
                    .on("mouseenter", function () {
                        self._mouseEventListener.onResultItemMouseEnter(self.getValue());
                    });
            }
        },

        /**
         * @returns {String} the option's value
         */
        getValue: function () {
            return this._$optionElement.val();
        },

        /**
         * @returns {String} the option's label text. This is the text between the option tags.
         */
        getLabel: function () {
            return this._$optionElement.text();
        },

        /**
         * @returns {jQuery} a jQuery extended HTML element
         */
        getResultElement: function () {
            return this._$resultElement;
        }
    });

    /**
     * @class
     */
    var FilterableComboboxEmtpyOption = FilterableComboboxOption.extend({
        /**
         * @constructs
         */
        init: function () {
            this._$optionElement = $("")
                .text(butter.message.get("combobox.noResultsFound"));
            this._$resultElement;
            this._initResultItem();
            this.getResultElement()
                .removeClass("butter-dropdownlist-resultItem")
                .addClass("butter-dropdownlist-noResultItem");
        },

        /**
         * @inheritDoc
         */
        getValue: function () {
            return "butter-noResultItem";
        },
    });

    /**
     * @class
     */
    var FilterableComboboxOptionList = Class.extend({
        /**
         * @constructs
         */
        init: function () {
            this._options = [];
            this._filteredOptions = [];
            this._selectedIndex = -1;
        },

        /**
         * @param {FilterableComboboxOption} resultOption
         */
        add: function (resultOption) {
            this._options.push(resultOption);
        },

        /**
         *
         * @param filter {String} the filter text
         * @returns {Array} the array with the filtered option elements
         */
        getFilteredOptions: function (filter) {
            //console.log("FilterableComboboxOptionList - getting filtered options for '%s'", filter);
            var self = this;
            self.unselect();
            self._filteredOptions = [];

            $.each(self._options, function (index, element) {
                element.getResultElement().highlight(filter);
                if (filter === undefined || filter === "") {
                    self._filteredOptions.push(element);
                } else if (element.getResultElement().find(".search-highlighted").length > 0) {
                    self._filteredOptions.push(element);
                }
            });

            if (this.hasResultOptions()) {
                //console.log("FilterableComboboxOptionList - returning %s results", self._filteredOptions.length);
                return self._filteredOptions;
            } else {
                //console.log("FilterableComboboxOptionList - found no result returning empty result option");
                return [new FilterableComboboxEmtpyOption()];
            }
        },

        /**
         *
         * @param {String} value the value of the options that should be selected
         */
        select: function (value) {
            if (!this.hasResultOptions()) {
                return;
            }

            this.unselect();
            for (var i = 0; i < this._filteredOptions.length; i++) {
                if (this._filteredOptions[i].getValue() === value) {
                    this._doSelectAndMarkElement(i);
                    break;
                }
            }
        },

        /**
         * Select the previous element in the filtered list. If there is no previous element the last will be selected.
         */
        selectPrevious: function () {
            if (!this.hasResultOptions()) {
                return;
            }

            this._unmarkSelectedElement();
            if (this.hasSelected()) {
                if (this._selectedIndex - 1 >= 0) {
                    this._doSelectAndMarkElement(this._selectedIndex - 1);
                } else {
                    this._doSelectAndMarkElement(this._filteredOptions.length - 1);
                }
            } else {
                this._doSelectAndMarkElement(0);
            }
        },

        /**
         * Select the nex element in the filtered list. If there is no next element the first will be selected.
         */
        selectNext: function () {
            if (!this.hasResultOptions()) {
                return;
            }

            this._unmarkSelectedElement();
            if (this.hasSelected()) {
                if (this._selectedIndex + 1 < this._filteredOptions.length) {
                    this._doSelectAndMarkElement(this._selectedIndex + 1);
                } else {
                    this._doSelectAndMarkElement(0);
                }
            } else {
                this._doSelectAndMarkElement(0);
            }
        },

        /**
         * Unselect possible selected option
         */
        unselect: function () {
            if (this.hasResultOptions()) {
                this._unmarkSelectedElement();
            }
            this._selectedIndex = -1;
        },

        _unmarkSelectedElement: function () {
            if (this.hasSelected()) {
                //console.log("FilterableComboboxOptionList - unmark selected element on position %s", this._selectedIndex);
                this.getSelected().getResultElement().removeClass("butter-dropdownlist-resultItem-selected");
            }
        },

        /**
         * * @returns {FilterableComboboxOption} the option that is selected
         */
        getSelected: function () {
            return this.hasSelected() ? this._filteredOptions[this._selectedIndex] : null;
        },

        /**
         * @returns {boolean} true if an element is selected
         */
        hasSelected: function () {
            return this._selectedIndex >= 0;
        },

        /**
         * @returns {boolean} true if there elements in the filtered list
         */
        hasResultOptions: function () {
            return this._filteredOptions.length > 0;
        },

        _doSelectAndMarkElement: function (index) {
            this._filteredOptions[index].getResultElement().addClass("butter-dropdownlist-resultItem-selected");
            this._selectedIndex = index;
        }
    });

    /**
     * @class
     */
    var FilterableCombobox = FilterableComboboxMouseEventListener.extend({
        /**
         * @constructs
         * @param {HTMLElement} rootElement
         */
        init: function (rootElement) {
            this.$select = $(rootElement).find("select");
            this.$template = this.$select.parent().siblings(".butter-component-combobox-template").html();
            this.$ghostInput = null;
            this.$resultContainer = null;
            this.$resultListContainer = null;
            this._optionList;
            this._hasFocus = false;
            this._disabled = this.$select.is('[disabled=disabled]');
            this._isMouseClickBlocked = false;
            this._isMouseEnterBlocked = false;

            this._keyCodes = {
                //backspace: 8,
                tab: 9,
                enter: 13,
                shift: 16,
                ctrl: 17,
                alt: 18,
                pause: 19,
                caps_lock: 20,
                escape: 27,
                page_up: 33,
                page_down: 34,
                end: 35,
                home: 36,
                arrow_left: 37,
                arrow_up: 38,
                arrow_right: 39,
                arrow_down: 40,
                insert: 45,
                // 'delete' is a reserved key word
                delete_key: 46,
                left_window_key: 91,
                right_window_key: 92,
                select_key: 93,
                num_lock: 144,
                scroll_lock: 145
            };

            this._initializeGhostElement();
            this._initializeDropDownButton();
            this._initializeOptionList();
        },

        _initializeGhostElement: function () {
            var self = this;
            self.$ghostInput = self.$select.parent().find(".butter-component-combobox-ghost")
                //.addClass($select.attr("class"))
                .val(self.$select.find("option:selected").text())
                .on("focus", function () {
                    self._hasFocus = true;
                    // automatically select whole text on focus
                    self._selectCompleteTextInGhostInput();
                })
                .on("mouseup", function (event) {
                    // in safari the mouseup event unselects the text, so we have to prevent this
                    self._stopEvent(event);
                })
                .on("blur", function () {
                    self._hasFocus = false;
                    // block next mouse click only if the result list is opened
                    self._isMouseClickBlocked = self.$resultContainer !== null;

                    window.setTimeout(function () {
                        self._isMouseClickBlocked = false;
                        if (!self._hasFocus) {
                            self._hideOptionResultList();
                            self._resetDisplayValue();
                        }
                    }, 200);
                })
                .on("keydown", function (event) {
                    if (event.which === self._keyCodes.enter) {
                        self._handleEnterKeyDown(event);
                    }else if (event.which === self._keyCodes.tab) {
                        self._handleTabKeyDown(event);
                    } else if (event.which === self._keyCodes.arrow_up || event.which === self._keyCodes.arrow_down) {
                        self._handleArrowUpAndDownKeyDown(event);
                    } else if (event.which === self._keyCodes.escape) {
                        self._handleEscapeKeyDown(event);
                    }
                })
                .on("keyup", function (event) {
                    // don't handle other keys than character keys
                    for (keyName in self._keyCodes) {
                        if (self._keyCodes[keyName] === event.which) {
                            self._stopEvent(event);
                            return;
                        }
                    }

                    var searchText = $(this).val();
                    self._showOptionResultList(searchText);
                });

            if (self._disabled) {
                self.$ghostInput.attr('disabled', 'disabled');
            }
        },

        _initializeOptionList: function () {
            var self = this;
            self._optionList = new FilterableComboboxOptionList();
            self.$select.find("option").each(function (index, element) {
                self._optionList.add(new FilterableComboboxOption(element, self, self.$template));
            });
        },

        _handleEnterKeyDown: function (event) {
            if (this._optionList.hasSelected() && this._isResultContainerShown()) {
                this._stopEvent(event);
                this._setSelectedValue();
                this._selectCompleteTextInGhostInput();
            } else if (!this._optionList.hasSelected() && this._isResultContainerShown()) {
                // deactivate enter key if result list is opened but nothing is selected
                this._stopEvent(event);
            } else {
                this._resetDisplayValue();
            }
        },

        _handleTabKeyDown: function (event) {
            if (this._optionList.hasSelected() && this._isResultContainerShown()) {
                // set selected value and allow tab event to bubble for tabbing to the next form field
                this._setSelectedValue();
                this._selectCompleteTextInGhostInput();
            } else if (!this._optionList.hasSelected() && this._isResultContainerShown()) {
                // deactivate tab key if result list is opened but nothing is selected
                this._stopEvent(event);
            } else {
                this._resetDisplayValue();
            }
        },

        _handleArrowUpAndDownKeyDown: function (event) {
            this._stopEvent(event);
            if (!this._isResultContainerShown()) {
                this._showOptionResultList();
            }

            this._moveResultOptionElementSelectionCursor(event.which === this._keyCodes.arrow_up ? -1 : 1);
        },

        _handleEscapeKeyDown: function (event) {
            if (this._isResultContainerShown()) {
                this._hideOptionResultList();
                this._resetDisplayValue();
                this._selectCompleteTextInGhostInput();
            } else {
                this.$ghostInput.blur();
            }
        },

        _initializeDropDownButton: function () {
            var self = this;
            if (!self._disabled) {
                self.$ghostInput.next()
                    .on("click", function (event) {
                        self._stopEvent(event);

                        if (self._isMouseClickBlocked) {
                            return;
                        }

                        self._showOptionResultList();
                        self.$ghostInput.focus();
                    });
            } else {
                self.$ghostInput.next().addClass('disabled');
            }
        },

        _showOptionResultList: function (searchText) {
            var self = this;

            // create container elements if necessary
            if (!self._isResultContainerShown()) {
                var $inputGroup = self.$ghostInput.parent();
                var inputGroupOffset = $inputGroup.offset();
                self.$resultContainer = $("
")
                    .addClass("butter-dropdownlist-container")
                    .addClass("butter-component-combobox-dropdownlist-container")
                    .css({
                        position: "absolute",
                        left: inputGroupOffset.left,
                        top: inputGroupOffset.top + $inputGroup.outerHeight(),
                        width: $inputGroup.innerWidth()
                    });

                self.$resultListContainer = $("
")
                    .addClass("butter-dropdownlist-resultList")
                    .on("mouseleave", function () {
                        self._optionList.unselect();
                    })
                    .appendTo(self.$resultContainer);
                $("body").append(self.$resultContainer);
            }

            self._detachResultListElements();
            self.$selectedOption = null;

            $.each(self._optionList.getFilteredOptions(searchText), function (index, element) {
                self.$resultListContainer.append(element.getResultElement());
            });
        },

        _hideOptionResultList: function () {
            var self = this;
            if (self._isResultContainerShown()) {
                self._detachResultListElements();
                self.$resultContainer.remove();
                self.$resultContainer = null;
                self.$resultListContainer = null;
                this._optionList.unselect();
            }
        },

        _detachResultListElements: function () {
            this._optionList.unselect();
            this.$resultListContainer.children().detach();
        },

        /**
         * @inheritdoc
         */
        onResultItemMouseDown: function (value) {
            this._setSelectedValue();
        },

        /**
         * @inheritdoc
         */
        onResultItemMouseEnter: function (value) {
            if (!this._isMouseEnterBlocked) {
                this._optionList.select(value);
            }
        },

        _moveResultOptionElementSelectionCursor: function (direction) {
            var self = this;

            if (direction > 0) {
                self._optionList.selectNext();
            } else {
                self._optionList.selectPrevious();
            }

            self._isMouseEnterBlocked = true;
            self._scrollToSelectedOptionElementIfNecessary();

            // this is necessary because if the mouse cursor is over a result item after the list has been scrolled a
            // mouse enter event will be triggered and the result item under the mouse cursor will be selected unintentionally.
            window.setTimeout(function () {
                self._isMouseEnterBlocked = false;
            }, 100);
        },

        _setSelectedValue: function () {
            if (this._optionList.hasSelected()) {
                var selectOption = this._optionList.getSelected();
                this.$select
                    .val(selectOption.getValue())
                    .change();
                this.$ghostInput.val(selectOption.getLabel());
                this._hideOptionResultList();
            }
        },

        _resetDisplayValue: function () {
            // set old value
            this.$ghostInput.val(this.$select.find("option:selected").text());
        },

        _stopEvent: function (event) {
            event.stopPropagation();
            event.preventDefault();
        },

        _selectCompleteTextInGhostInput: function () {
            this.$ghostInput[0].setSelectionRange(0, this.$ghostInput.val().length);
        },

        _isResultContainerShown: function () {
            return this.$resultContainer !== null;
        },

        _scrollToSelectedOptionElementIfNecessary: function () {
            if (this._optionList.hasSelected()) {
                var $item = this._optionList.getSelected().getResultElement();
                var containerHeight = this.$resultContainer.innerHeight();
                var containerScrollTop = this.$resultContainer.scrollTop();
                //console.log("FilterableCombobox - containerHeight: %s", containerHeight);
                //console.log("FilterableCombobox - containerScrollTop: %s", containerScrollTop);
                var itemHeight = $item.outerHeight();
                //console.log("FilterableCombobox - itemHeight: %s", itemHeight);
                var itemTop = $item.position().top;
                //console.log("FilterableCombobox - itemTop: %s", itemTop);

                if (itemTop < 0) {
                    // resultItem is scrolled out to top
                    this.$resultContainer.scrollTop(containerScrollTop + itemTop);
                } else if (itemTop + itemHeight > containerHeight) {
                    // resultItem is scrolled out to bottom
                    this.$resultContainer.scrollTop(containerScrollTop + ((itemTop + itemHeight) - containerHeight));
                }
            }
        }
    });
}(jQuery));
/**
 * jQuery-Plugin "Animate dots" for tree animation. Animates a waiting dot line (4 dots) in an interval of 200 millis
 * as html string in given component. Note: existing html code will be cleared.
 * Works with at least jQuery 1.3.2.
 *
 * How to use:
 * jQuery("#selector").startDots();
 * jQuery("#selector").stopDots();
 */
(function ($) {
    // extend jQuery --------------------------------------------------------------------

    var intervalTrigger = null;

    $.fn.startDots = function () {
        return this.each(function () {
            var $originalElement = $(this);

            $originalElement.html('');

            intervalTrigger = setInterval(function () {
                $originalElement.append('.');

                if ($originalElement.html().length > 5) {
                    $originalElement.html('');
                }
            }, 200);
        });
    };

    $.fn.stopDots = function () {
        return this.each(function () {
            var $originalElement = $(this);

            $originalElement.html('');
            window.clearInterval(intervalTrigger);
        });
    };

}(jQuery));
/**
 * jQuery-Plugin "Expanded TextAreas" for expandable text areas. It is used for the JSF-Component "b:textarea".
 * Works with at least jQuery 1.7.
 *
 * How to use:
 * jQuery("#someTextAreaSelector").butterExpandable();
 */
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.butterExpandable = function () {
        return this.each(function () {
            if ($(this).find("textarea").length > 0) {
                new TextareaExpandable(this);
            } else {
                new DivExpandable(this);
            }
        });
    };

    // define objects --------------------------------------------------------------------

    var _AbstractExpandable = Class.extend({
        init: function (rootElement) {
            this.EXPAND_HEIGHT = 250; //in px
            this.EXPAND_WIDTH = 500; //in px
            this.ANIMATION_DURATION = 200; //in ms
            this.REPOSITION_INTERVAL = 500; //in ms
            this.EASING = "swing";
            this.KEYCODE_ESCAPE = 27;

            this.$rootElement = $(rootElement);

            this.$ghostElement = null;
            this.$originalElement;
            this.initialHeight;
            this.initialWidth;
            this.initialOffset;
            this.positionTriggerInterval;

            this.initialize();
        },

        initialize: function () {
            // should intentionally be overridden
        },

        isExpansionEventIgnored: function (event) {
            // should intentionally be overridden
            return false;
        },

        onGhostElementCreated: function () {
            // should intentionally be overridden
        },

        onGhostElementCollapsed: function (isCancelled) {
            // should intentionally be overridden
        },

        transferValueToGhostElement: function () {
            // should intentionally be overridden
        },

        expandElement: function (event) {
            if (this.isExpansionEventIgnored(event)) {
                return;
            }

            // console.log("expanding element");

            this.initialHeight = this.$originalElement.outerHeight();
            this.initialWidth = this.$originalElement.outerWidth();
            this.initialOffset = this.$originalElement.offset();

            //create a ghost element that be animated on gets the focus
            var self = this;
            this.$ghostElement = this.createGhostElement();
            this.transferValueToGhostElement();
            this.$ghostElement.css("width", this.initialWidth)
                    .css("height", this.initialHeight)
                    .css("position", "absolute")
                    .css("top", this.initialOffset.top)
                    .css("left", this.initialOffset.left)
                    .css("z-index", 2000)
                    .css("box-shadow", "5px 5px 5px 0 #999")
                    .addClass("butter-component-expandable-ghost")
                    .appendTo($("body"))
                    .animate({
                        height: self.EXPAND_HEIGHT,
                        width: self.initialWidth > self.EXPAND_WIDTH ? self.initialWidth : self.EXPAND_WIDTH
                    }, self.ANIMATION_DURATION, self.EASING, function () {
                        $(document)
                                .on("click.expandable", function (event) {
                                    self._handleMouseClick(event);
                                })
                                .on("keydown.expandable", function (event) {
                                    self._handleEscapeKey(event);
                                });

                        $(window).on("resize.expandable", function (event) {
                            self._repositionGhostElement(event);
                        });

                        //keep track of the orginal element's position
                        self.positionTriggerInterval =
                                window.setInterval(self._repositionGhostElement, self.REPOSITION_INTERVAL);
                    });

            //make original invisible
            this.$originalElement
                    .css("visibility", "hidden")
                    .siblings()
                    .css("visibility", "hidden");

            this.onGhostElementCreated();
        },

        /**
         * @returns {*|HTMLElement}
         */
        createGhostElement: function () {
            // should intentionally be overridden
            return null;
        },

        /**
         * Collapses the ghost element and sets the value if not isCancelled
         * @param isCancelled
         */
        collapseElement: function (cancelled) {
            // console.log("collapsing element");

            // 'cancelled' can be an event object
            var isCancelled = typeof cancelled === "boolean" && cancelled;

            $(document)
                    .off("click.expandable")
                    .off("keydown.expandable");

            //make original visible again
            this.$originalElement
                    .css("visibility", "visible")
                    .siblings()
                    .css("visibility", "visible");

            var self = this;
            this.$ghostElement.animate({
                height: self.initialHeight,
                width: self.initialWidth
            }, self.ANIMATION_DURATION, self.EASING, function () {
                //on animation complete

                self.onGhostElementCollapsed(isCancelled);

                //delete the ghost element
                self.$ghostElement.remove();
                self.$ghostElement = null;

                //delete position trigger timeout and resize listener
                window.clearInterval(self.positionTriggerInterval);
                $(window).off("resize.expandable");
            });
        },

        _handleMouseClick: function (event) {
            // collapse ghost element if user clicks beside it
            if (!$(event.target).is(".butter-component-expandable-ghost")) {
                this.collapseElement(false);
            }
        },

        _handleEscapeKey: function (event) {
            if (event.which === this.KEYCODE_ESCAPE) {
                this.collapseElement(true);
            }
        },

        _repositionGhostElement: function () {
            //keep track of window resizing and reposition the ghost element
            if (this.$ghostElement !== undefined && this.$ghostElement != null) {
                this.initialOffset = this.$originalElement.offset();
                this.$ghostElement
                        .css("top", this.initialOffset.top)
                        .css("left", this.initialOffset.left);
            }
        }
    });

    var DivExpandable = _AbstractExpandable.extend({
        initialize: function () {
            this.$originalElement = this.$rootElement.find(".butter-component-value-readonly");
            this._rearrangeOriginalElementStructure();
        },

        _rearrangeOriginalElementStructure: function () {
            var self = this;
            var _label = this.$rootElement.find(".butter-component-label");

            this.$originalElement
                    .addClass("butter-component-expandable-original")
                    .click(function (event) {
                        self.expandElement(event);
                    })
                    .detach();

            var _container = $("
")
                    .addClass("butter-component-expandable-readonly-container")
                    .insertAfter(_label);

            var _icon = $("").addClass("glyphicon glyphicon-resize-full");

            this.$originalElement.appendTo(_container);
            $("
")
                    .addClass("butter-component-expandable-readonly-icon")
                    .append(_icon)
                    .appendTo(_container);
        },

        createGhostElement: function () {
            return $("
");
        },

        transferValueToGhostElement: function () {
            $("
")
                    .html(this.$originalElement.html())
                    .addClass("butter-component-expandable-ghost-readonlyContent")
                    .appendTo(this.$ghostElement);
        }
    });

    var TextareaExpandable = _AbstractExpandable.extend({
        initialize: function () {
            this.blockFocusEventOnOriginal = false;
            this.blockBlurEventOnOriginal = false;

            this.$originalElement = this.$rootElement.find("textarea");
            this.$originalElement.addClass("butter-component-expandable-original");

            var self = this;
            this.$originalElement.focus(function (event) {
                self.expandElement(event);
            });
            this.$originalElement.blur(function (event) {
                self._handleBlurEvent(event);
            });

            this._addInputGroupAddon();
        },

        _addInputGroupAddon: function () {
            this.$originalElement
                    .addClass("form-control")
                    .parent()
                    .addClass("input-group");
            $("")
                    .insertAfter(this.$originalElement);
        },

        _handleBlurEvent: function (event) {
            if (this.blockBlurEventOnOriginal) {
                // prevent blur event bubbling, so it will not be triggered in jsf
                event.preventDefault();
            }
        },

        createGhostElement: function () {
            return $("");
        },

        transferValueToGhostElement: function () {
            this.$ghostElement.val(this.$originalElement.val());
        },

        isExpansionEventIgnored: function (event) {
            this.blockBlurEventOnOriginal = true;
            if (this.blockFocusEventOnOriginal) {
                event.preventDefault();
                return true;
            } else {
                return false;
            }
        },

        onGhostElementCreated: function () {
            var self = this;
            this.$ghostElement
                    .blur(function (event) {
                        self.collapseElement(event);
                    })
                    .focus();
            this._moveCaretToEnd(this.$ghostElement);
        },

        onGhostElementCollapsed: function (isCancelled) {
            if (!isCancelled) {
                //transfer value back from ghost to original
                this.$originalElement.val(this.$ghostElement.val())

                // trigger blur and keyup event on original textarea and don't block
                // it for jsf
                this.blockBlurEventOnOriginal = false;
                this.blockFocusEventOnOriginal = true;
                // defer the events a little bit, look at
                // (http://stackoverflow.com/questions/8380759/why-isnt-this-textarea-focusing-with-focus#8380785)
                var self = this;
                window.setTimeout(function () {
                    self.$originalElement.trigger('keyup');
                    self.$originalElement.trigger('change');
                    self.$originalElement.trigger('blur');
                    self.blockFocusEventOnOriginal = false;
                }, 50);
            } else {
                this.blockBlurEventOnOriginal = true;
                this.blockFocusEventOnOriginal = false;
            }
        },

        _moveCaretToEnd: function (element) {
            if (typeof element.selectionStart == "number") {
                element.selectionStart = element.selectionEnd = element.value.length;
            } else if (typeof element.createTextRange !== "undefined") {
                var range = element.createTextRange();
                range.collapse(false);
                range.select();
            } else {
                var strLength= this.$ghostElement.val().length * 2;
                this.$ghostElement[0].setSelectionRange(strLength, strLength);
            }

        }
    });
}(jQuery));
(function ($) {
    $.fn.highlight = function (searchString) {
        var highlightClassName = "search-highlighted";
        var regex = new RegExp(searchString, "gi");

        var elements = this.find('*');
        this.each(function () {
            elements.push(this);
            $(this).find('.' + highlightClassName).contents().unwrap();
            this.normalize();
        });

        return elements.each(function () {
            var $this = $(this);

            if (searchString && searchString !== '') {
                $this.contents()
                    .filter(function () {
                        return this.nodeType === 3 && regex.test(this.nodeValue);
                    })
                    .replaceWith(function () {
                        return (this.nodeValue || "").replace(regex, function (match) {
                            return "<span class=\"" + highlightClassName + "\">" + match + "</span>";
                        });
                    });
            }
        });
    };
}(jQuery));
if (typeof butter === 'undefined') {
    butter = {};
}
butter.link = {};

butter.link.disableOnClick = function(data, showDots, linkText, linkProcessingText, linkGlyphicon, linkProcessingGlyphicon, hideGlyphicon, disableRenderRegionsIds) {
    var status = data.type === "error" ? "error" : data.status;

    // console.log(data.source.id);

    var $commandLink = $(document.getElementById(data.source.id));

    switch (status) {
        case "begin": // Before the ajax request is sent.
            // console.log('ajax request begin');
            $commandLink.addClass("disabled");

            var $glyphicon = $commandLink.find('.butter-component-glyphicon');

            if (hideGlyphicon) {
                $glyphicon.hide();
            }
            if (linkProcessingGlyphicon.length > 0) {
                $glyphicon.removeAttr('class');
                $glyphicon.addClass('butter-component-glyphicon');
                $glyphicon.addClass(linkProcessingGlyphicon);
                if (linkProcessingText.length > 0 && linkGlyphicon.length == 0) {
                    // glyphicon only appears on ajax request
                    $glyphicon.addClass('butter-component-glyphicon-width-margin');
                }
            }

            if (showDots) {
                $commandLink.find('.butter-component-glyphicon-processing').startDots();
                $commandLink.find('.butter-component-glyphicon-processing').css('display', 'inline-block');
                $commandLink.find('.butter-component-glyphicon-text').html(linkProcessingText);
            }
            if (disableRenderRegionsIds != 'undefined') {
                // console.log('Disable field');
                new ButterFaces.Overlay(0, false, disableRenderRegionsIds).show();
            }
            break;

        case "complete": // After the ajax response is arrived.
            // console.log('ajax request complete');
            break;

        case "success": // After update of HTML DOM based on ajax response..
        case "error": // After update of HTML DOM based on ajax response..
            // console.log('ajax request success');
            $commandLink.removeClass("disabled");
            if (showDots) {
                $commandLink.find('.butter-component-glyphicon-processing').stopDots();
                $commandLink.find('.butter-component-glyphicon-processing').css('display', 'none');
                $commandLink.find('.butter-component-glyphicon-text').html(linkText ? linkText : '');
            }

            var $glyphicon = $commandLink.find('.butter-component-glyphicon');
            $glyphicon.removeAttr('class');
            $glyphicon.addClass('butter-component-glyphicon');

            if (hideGlyphicon) {
                $glyphicon.show();
            }
            if (linkGlyphicon.length > 0) {
                $glyphicon.addClass(linkGlyphicon);
            }

            if (disableRenderRegionsIds != 'undefined') {
                // console.log('Enable field');
                new ButterFaces.Overlay(0, false, disableRenderRegionsIds).hide();
            }
            break;
    }
};
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.markdownReadonly = function () {
        var root = $(this);

        var $readonlyMarkdown = root.find('.butter-component-value-readonly-wrapper');
        var markdownText = $readonlyMarkdown.html().replace('>', '>');
        var markdownTextToHtml = markdown.toHTML(markdownText);

        $readonlyMarkdown.empty();
        $readonlyMarkdown.append(markdownTextToHtml);
    };
}(jQuery));
(function ($) {

    $.fn.butterMaxLength = function (options) {

        if (typeof options === "undefined" || typeof options.maxLength === "undefined") {
            throw new Error("no maxLength parameter is given!");
        }

        var ERROR_STYLE_CLASS = "has-error";

        return this.each(function () {
            //console.log("initializing max length");
            var root = $(this);
            var valueElement = root.find("textarea");
            var maxLength = root.find(".butter-component-maxlength-counter");

            if (maxLength.length > 0) {
                //console.log("found max length element");
                var hasInitialValidationError = root.hasClass(ERROR_STYLE_CLASS);

                var _checkValue = function () {
                    var value = valueElement.val();
                    // console.log("checking value");
                    // console.log(value);
                    if (typeof value !== 'undefined') {
                        var freeLetterCount = options.maxLength - value.length;
                        maxLength.text(freeLetterCount + " von " + options.maxLength + " Zeichen");

                        if (!hasInitialValidationError) {
                            if (freeLetterCount < 0) {
                                root.addClass(ERROR_STYLE_CLASS);
                            } else {
                                root.removeClass(ERROR_STYLE_CLASS);
                            }
                        }
                    }
                };

                valueElement.on("focus blur keyup cut paste", _checkValue);

                // initial check
                _checkValue();
            }
        });
    };
}(jQuery));
if (typeof butter === 'undefined') {
    butter = {};
}

/**
 * The object with all message properties for the different locales.
 *
 * ===============================
 * ENTER YOUR OWN MESSAGES HERE!
 * ===============================
 *
 * @private
 */
butter._msgProperties = {
    //this is the leading language local and is used as fallback!
    en: {
        "combobox.noResultsFound": "No entries found!"
    },

    de: {
        "combobox.noResultsFound": "Keine Einträge gefunden!"
    }
};

butter.message = {
    _fallbackLocale: "en",

    _locale: null,

    _detectBrowserLocale: function () {
        var detectedLocale = window.navigator.userLanguage || window.navigator.language;
        if (butter._msgProperties[detectedLocale] !== undefined) {
            //console.log("_detectBrowserLocale - found locale '%s' in message properties, setting it as locale", detectedLocale);
            butter.message._locale = detectedLocale;
        } else {
            // couldn't find locale in the exisiting message properties, setting to fallback locale
            //console.log("_detectBrowserLocale - couldn't find locale '%s 'in the exisiting message properties, setting to fallback locale", detectedLocale);
            butter.message._locale = butter.message._fallbackLocale;
        }
    },

    /**
     * Returns the localized message to the given key. If the key doesn't exist in the detected language it tries to
     * find the key in the fallback locale (en). Otherwise the key will be returned.
     *
     * @param {String} key the message key
     * @returns {String} the message to the key
     */
    get: function (key) {
        //try to get key from detected locale
        var message = butter._msgProperties[butter.message._locale][key];

        if (message === undefined) {
            //key not found in detected locale, try to get it from fallback locale
            message = butter._msgProperties[butter.message._fallbackLocale][key];
        }

        if (message === undefined) {
            //key not found in fallback locale returning key
            message = key;
        }

        return message;
    }
};

//run locale detection initally
butter.message._detectBrowserLocale();
if (typeof butter === 'undefined') {
    butter = {};
}
butter.modal = {};

butter.modal.open = function (/* string */ modalPanelId) {
    // console.log('Opening modal panel with data-modal-id ' + modalPanelId);
    $('.butter-modal[data-modal-id=' + modalPanelId + ']').modal({show: true, keyboard: false, backdrop: 'static'})
};

butter.modal.close = function (/* string */ modalPanelId) {
    // console.log('Closing modal panel with data-modal-id ' + modalPanelId);
    $('.butter-modal[data-modal-id=' + modalPanelId + ']').modal('hide');
};
if (typeof butter === 'undefined') {
    butter = {};
}
butter.fix = {};

butter.fix.updateMojarraScriptSourceId = function (/*String*/ innerInputComponentId, /* array of string */ eventNames) {
    //console.log('Fix mojarra script source id');
    //console.log(innerInputComponentId);
    //console.log(eventNames);

    if (eventNames !== undefined) {
        for (var i = 0; i < eventNames.length; i++) {
            var event = 'on' + eventNames[i];
            //console.log(event);

            var onEvent = $(document.getElementById(innerInputComponentId)).find('input[' + event + ']').attr(event)

            //console.log(onEvent);

            if (onEvent !== undefined && onEvent.indexOf('mojarra.ab') > -1) {
                var replacedFunction = onEvent.replace('mojarra.ab(this,', 'mojarra.ab(\'' + innerInputComponentId + '\',');

                if (onEvent.indexOf('butter.fix.chain') > -1) {
                    replacedFunction = onEvent.replace('mojarra.ab(this,', 'mojarra.ab(\\\'' + innerInputComponentId + '\\\',');
                }

                //console.log(replacedFunction);
                $(document.getElementById(innerInputComponentId)).find('input[' + event + ']').attr(event, replacedFunction);
            }
        }
    }
};

butter.fix.chain = function(source, event) {

    if (arguments.length < 3) {
        return true;
    }

    // RELEASE_PENDING rogerk - shouldn't this be getElementById instead of null
    var thisArg = (typeof source === 'object') ? source : null;

    // Call back any scripts that were passed in
    for (var i = 2; i < arguments.length; i++) {

        var f = new Function("event", arguments[i]);
        var returnValue = f.call(thisArg, event);

        if (returnValue === false) {
            return false;
        }
    }
    return true;

};
/**
 * jQuery-Plugin "Number Spinner" for input fields.
 * Works with at least jQuery 1.3.2.
 *
 * How to use:
 * jQuery("someButterComponentSelector").butterNumberSpinner();
 */
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.butterNumberSpinner = function (options) {
        return this.each(function () {
            new NumberSpinner(this, options);
        });
    };

    // define classes --------------------------------------------------------------------
    var NumberSpinner = Class.extend({
        init: function (element, options) {
            this.$input = $(element).find("input");
            this._initInput();
            this._initOptions(options);
            this._counter = null;
            this.setCounter(0);
            this._isValueSet = false;
            this._initButtons();
            this._initArrowKeys();
            this._initMouseWheel();
        },

        _initInput: function () {
            var self = this;
            this.$input
                .addClass("butter-component-number-input")
                .blur(function () {
                    self._setValueOnBlur();
                })
                .parent().addClass("input-group");
        },

        _initOptions: function (options) {
            var defaultOptions = {
                step: 1,
                disabled: false
            };
            this._options = $.extend({}, defaultOptions, options);

            // ensure that this values are numbers
            if (this._options.step !== undefined) {
                this._options.step = this._options.step * 1;
            }
            if (this._options.min !== undefined) {
                this._options.min = this._options.min * 1;
            }
            if (this._options.max !== undefined) {
                this._options.max = this._options.max * 1;
            }
        },

        _initButtons: function () {
            var $addon = $("<span>")
                .addClass("input-group-addon")
                .addClass("butter-component-number-buttons")
                .insertAfter(this.$input);

            var self = this;
            $("<span>")
                .addClass("glyphicon glyphicon-chevron-up")
                .addClass("butter-component-number-button")
                .addClass(function () {
                    return self._options.disabled ? "disabled" : "";
                })
                .click(function () {
                    if (!self._options.disabled) {
                        self.increaseCounter();
                    }
                })
                .appendTo($addon);

            $("<span>")
                .addClass("glyphicon glyphicon-chevron-down")
                .addClass("butter-component-number-button")
                .addClass(function () {
                    return self._options.disabled ? "disabled" : "";
                })
                .click(function () {
                    if (!self._options.disabled) {
                        self.decreaseCounter();
                    }
                })
                .appendTo($addon);
        },

        _initArrowKeys: function () {
            var self = this;
            this.$input.keydown(function (event) {
                if (event.which === 38) {
                    event.stopPropagation();
                    event.preventDefault();
                    self.increaseCounter();
                } else if (event.which === 40) {
                    event.stopPropagation();
                    event.preventDefault();
                    self.decreaseCounter();
                }
            });
        },

        _initMouseWheel: function () {
            var self = this;
            this.$input.on("mousewheel DOMMouseScroll", function (event) {
                if (!self.$input.is(':focus')) {
                    return;
                }

                var delta = event.originalEvent.wheelDelta || -event.originalEvent.deltaY || -event.originalEvent.detail;

                event.stopPropagation();
                event.preventDefault();

                if (delta < 0) {
                    self.decreaseCounter();
                } else {
                    self.increaseCounter();
                }
            });
        },

        _setValueOnBlur: function () {
            var value = this.$input.val();
            if (this._isStringEmpty(value)) {
                this.$input.val("");
                this.setCounter(0);
                this._isValueSet = false;
            } else {
                var parsedInt = parseInt(value);
                if (isNaN(parsedInt)) {
                    if (this._isValueSet) {
                        this.$input.val(this._counter);
                    } else {
                        this.$input.val("");
                        this.setCounter(0);
                        this._isValueSet = false;
                    }
                } else {
                    this.setCounter(parsedInt);
                    this.$input.val(this._counter);
                    this._isValueSet = true;
                }
            }
        },

        increaseCounter: function () {
            if (this._isValueSet) {
                this.setCounter(this._counter + this._options.step);
            } else {
                this._isValueSet = true;
            }
            this.$input.val(this._counter);
            this.$input.change();
        },

        decreaseCounter: function () {
            if (this._isValueSet) {
                this.setCounter(this._counter - this._options.step);
            } else {
                this._isValueSet = true;
            }
            this.$input.val(this._counter);
            this.$input.change();
        },

        _isStringEmpty: function (value) {
            return (value.length === 0 || !value.trim());
        },

        setCounter: function (value) {
            if (this._options.min !== undefined && value < this._options.min) {
                this._counter = this._options.min;
            } else if (this._options.max !== undefined && value > this._options.max) {
                this._counter = this._options.max;
            } else {
                this._counter = value;
            }
        }
    });
}(jQuery));
if (typeof butter === 'undefined') {
    butter = {};
}
butter.prettyprint = {};

/**
 * calls pretty print javascript framework and removes first and last empty children.
 */
butter.prettyprint.cleanup = function() {
    prettyPrint();

    jQuery('.butter-component-prettyprint').each(function () {
        var $firstPreChild = jQuery(this).find("pre span").first();
        var $lastPreChild = jQuery(this).find("pre span").last();


        if (!(typeof $firstPreChild.html() === "undefined")) {
            if (!$firstPreChild.html().trim()) {
                $firstPreChild.remove();
            }
        }
        if (!(typeof $lastPreChild.html() === "undefined")) {
            if (!$lastPreChild.html().trim()) {
                $lastPreChild.remove();
            }
        }
    });
};
/**
 * How to use:
 * jQuery("#someSelector").scrollToFirst() or jQuery("#someSelector").scrollToLast();
 */
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.butterScrollToFirst = function (/* int */ offset) {
        void 0;
        var _offset = offset === undefined ? $(this).first().offset().top : $(this).first().offset().top + offset;
        $('html, body').animate({scrollTop: _offset + 'px'}, 'fast');
    };

    $.fn.butterScrollToLast = function (/* int */ offset) {
        void 0;
        var _offset = offset === undefined ? $(this).last().offset().top : $(this).last().offset().top + offset;
        $('html, body').animate({scrollTop: _offset + 'px'}, 'fast');
    };
}(jQuery));
/**
 * jQuery-Plugin to handle selection style classes on JSF-Component "b:table".
 * Works with at least jQuery 1.3.2.
 *
 * How to use:
 * jQuery("#someTreeSelector").selectRow( {rowIndex: '6'} );
 */
(function ($) {
    // extend jQuery --------------------------------------------------------------------
    $.fn.selectRow = function (data) {

        return this.each(function () {
            var $originalElement = $(this);

            // console.log('Selected row: ' + data.rowIndex);
            // console.log($originalElement.find('tr[rowindex=' + data.rowIndex + ']'));

            $originalElement.find('tr').removeClass('butter-table-row-selected');
            var listItems = $originalElement.find('tr[rowindex=' + data.rowIndex + ']');
            $(listItems[listItems.length - 1]).addClass('butter-table-row-selected');
        });
    };

    $.fn.toggleColumnVisibilty = function (renderIds, disableRenderIds) {

        return this.each(function () {
            var $toolbar = $(this);

            var json = JSON.stringify(createColumnVisibilty($toolbar));
            butter.ajax.sendRequest($toolbar.attr('id'), 'toggle', renderIds, json, disableRenderIds);
        });

        function createColumnVisibilty($toolbar) {
            var columns = [];

            $toolbar.find('.butter-table-toolbar-column-option input[type=checkbox]').each(function (index, checkbox) {
                var $checkbox = $(checkbox).parent('.butter-table-toolbar-column-option');
                columns.push({
                    identifier: $checkbox.attr('data-column-model-identifier'),
                    visible: $checkbox.find('input[type=checkbox]').is(':checked')
                });
            });

            return columns;
        }
    };

    $.fn.sortRow = function (renderIds, disableRenderIds, columnNumber) {
        return this.each(function () {
            var $table = $(this);

            butter.ajax.sendRequest($table.attr('id'), 'sort_' + columnNumber, renderIds, columnNumber, disableRenderIds);
        });
    }

    $.fn.orderColumn = function (renderIds, disableRenderIds, toLeft, columnNumber) {

        return this.each(function () {
            var $toolbar = $(this);

            if (toLeft) {
                //console.log('order column ' + columnNumber + ' to left');
                orderColumnLeft($toolbar, columnNumber);
            } else {
                //console.log('order column ' + columnNumber + ' to right');
                orderColumnRight($toolbar, columnNumber);
            }

            var json = JSON.stringify(createColumnOrder($toolbar));
            butter.ajax.sendRequest($toolbar.attr('id'), 'order', renderIds, json, disableRenderIds);
        });

        function createColumnOrder($toolbar) {
            var columns = [];

            $toolbar.find('.butter-table-toolbar-column-option input[type=checkbox]').each(function (index, checkbox) {
                var $checkbox = $(checkbox).parent('.butter-table-toolbar-column-option');
                columns.push({
                    identifier: $checkbox.attr('data-column-model-identifier'),
                    position: index
                });
            });

            return columns;
        }

        function orderColumnLeft(/* jquery toolbar */ $toolbar, columnNumber) {
            //console.log($toolbar);

            var $column = $toolbar.find('li[data-original-column="' + columnNumber + '"]');
            var $nextColumn = $column.prev();

            //console.log($column);
            //console.log($nextColumn);

            var $detachtedColumn = $column.detach();
            $nextColumn.before($detachtedColumn);
        }

        function orderColumnRight(/* jquery toolbar */ $toolbar, columnNumber) {
            //console.log($toolbar);

            var $column = $toolbar.find('li[data-original-column="' + columnNumber + '"]');
            var $nextColumn = $column.next();

            //console.log($column);
            //console.log($nextColumn);

            var $detachtedColumn = $column.detach();
            $nextColumn.after($detachtedColumn);
        }
    };
}(jQuery));
(function ($) {

    $.fn._butterTagsInit = function () {
        var root = $(this);

        var _tagBoxWrapper = root.find('.tr-input-wrapper');
        _tagBoxWrapper.addClass("form-control");
    };

}(jQuery));
(function ($) {

    $.fn._butterTooltip = function (/* object */ data) {
        var root = $(this);

        //console.log(data);

        var content = jQuery('[name=' + data.contentByName + ']');

        var newData = {
            trigger: data.trigger,
            title: data.title,
            placement: data.placement,
            placementFunction: data.placementFunction,
            minVerticalOffset: data.minVerticalOffset,
            minHorizontalOffset: data.minHorizontalOffset,
            content: content.html().trim()
        };

        //console.log(newData);

        content.remove();

        root.butterTooltip(newData);
    };

    $.fn.butterTooltip = function (/* object */ data) {
        return this.each(function () {
            var root = $(this);
            var tooltip = new ButterFaces.Tooltip();
            var trigger = data.trigger ? data.trigger : 'hover';

            //console.log(data);
            //console.log('placement: ' + placement);
            //console.log('trigger: ' + trigger);
            //console.log('viewport: ' + data.viewport);

            if (data.minVerticalOffset) {
                root.attr('data-tooltip-min-vertical-offset', data.minVerticalOffset);
            }
            if (data.minHorizontalOffset) {
                root.attr('data-tooltip-min-horizontal-offset', data.minHorizontalOffset);
            }
            if (root.next().hasClass('popover')) {
                root.next().remove();
            }


            root.popover({
                trigger: trigger,
                placement: function(popover, source) {
                    return data.placement ? data.placement : (data.placementFunction ? data.placementFunction : new ButterFaces.Tooltip().calculateTooltipPosition(popover, source));
                },
                title: data.title,
                html: 'true',
                content: data.content,
                viewport: data.viewport
            });
        });
    };
}(jQuery));</code></pre>    <br/>
    <br/>
<div class='clear'></div>
<!--
    <aside class="related-items">
        <section>
            <div class="panel panel-primary">
                <div class="panel-heading margin-bottom">Related Artifacts</div>
                <div class="">
                                    </div>
            </div>
        </section>
        <section>
            <div class="panel panel-primary">
                <div class="panel-heading margin-bottom">Related Groups</div>
                <div class="">
                                    </div>
            </div>
        </section>
    </aside>
    <div class='clear'></div>
--></main>
</div>
<br/><br/>
    <div class="align-center">© 2015 - 2025 <a href="/legal-notice.php">Weber Informatics LLC</a> | <a href="/data-protection.php">Privacy Policy</a></div>
<br/><br/><br/><br/><br/><br/>
</body>
</html>