selectBoxIt 0.1.0

data/app/assets/javascripts/selectBoxIt/modules/jquery.selectBoxIt.keyboardSearch.js

@@ -0,0 +1,209 @@
+
+    // Keyboard Search Module
+    // ======================
+
+    // _Set Current Search Option
+    // -------------------------
+    //      Sets the currently selected dropdown list search option
+
+    selectBoxIt._setCurrentSearchOption = function(currentOption) {
+
+        var self = this;
+
+        // Does not change the current option if `showFirstOption` is false and the matched search item is the hidden first option.
+        // Otherwise, the current option value is updated
+        if ((self.options["aggressiveChange"] || self.options["selectWhenHidden"] || self.listItems.eq(currentOption).is(":visible")) && self.listItems.eq(currentOption).data("disabled") !== true) {
+
+            // Calls the `blur` event of the currently selected dropdown list option
+            self.listItems.eq(self.currentFocus).blur();
+
+            // Sets `currentIndex` to the currently selected dropdown list option
+            self.currentIndex = currentOption;
+
+            // Sets `currentFocus` to the currently selected dropdown list option
+            self.currentFocus = currentOption;
+
+            // Focuses the currently selected dropdown list option
+            self.listItems.eq(self.currentFocus).focusin();
+
+            // Updates the scrollTop so that the currently selected dropdown list option is visible to the user
+            self._scrollToView("search");
+
+            // Triggers the custom `search` event on the original select box
+            self.triggerEvent("search");
+
+        }
+
+        // Maintains chainability
+        return self;
+
+    };
+
+    // _Search Algorithm
+    // -----------------
+    //      Uses regular expressions to find text matches
+    selectBoxIt._searchAlgorithm = function(currentIndex, alphaNumeric) {
+
+        var self = this,
+
+            // Boolean to determine if a pattern match exists
+            matchExists = false,
+
+            // Iteration variable used in the outermost for loop
+            x,
+
+            // Iteration variable used in the nested for loop
+            y,
+
+            // Variable used to cache the length of the text array (Small enhancement to speed up traversing)
+            arrayLength,
+
+            // Variable storing the current search
+            currentSearch,
+
+            // Variable storing the textArray property
+            textArray = self.textArray,
+
+            // Variable storing the current text property
+            currentText = self.currentText;
+
+        // Loops through the text array to find a pattern match
+        for (x = currentIndex, arrayLength = textArray.length; x < arrayLength; x += 1) {
+
+            currentSearch = textArray[x];
+
+            // Nested for loop to help search for a pattern match with the currently traversed array item
+            for (y = 0; y < arrayLength; y += 1) {
+
+                // Searches for a match
+                if (textArray[y].search(alphaNumeric) !== -1) {
+
+                    // `matchExists` is set to true if there is a match
+                    matchExists = true;
+
+                    // Exits the nested for loop
+                    y = arrayLength;
+
+                }
+
+            } // End nested for loop
+
+            // If a match does not exist
+            if (!matchExists) {
+
+                // Sets the current text to the last entered character
+                self.currentText = self.currentText.charAt(self.currentText.length - 1).
+
+                // Escapes the regular expression to make sure special characters are seen as literal characters instead of special commands
+                replace(/[|()\[{.+*?$\\]/g, "\\$0");
+
+                currentText = self.currentText;
+
+            }
+
+            // Resets the regular expression with the new value of `self.currentText`
+            alphaNumeric = new RegExp(currentText, "gi");
+
+            // Searches based on the first letter of the dropdown list options text if the currentText < 3 characters
+            if (currentText.length < 3) {
+
+                alphaNumeric = new RegExp(currentText.charAt(0), "gi");
+
+                // If there is a match based on the first character
+                if ((currentSearch.charAt(0).search(alphaNumeric) !== -1)) {
+
+                    // Sets properties of that dropdown list option to make it the currently selected option
+                    self._setCurrentSearchOption(x);
+
+                    if((currentSearch.substring(0, currentText.length).toLowerCase() !== currentText.toLowerCase()) || self.options["similarSearch"]) {
+
+                        // Increments the current index by one
+                        self.currentIndex += 1;
+
+                    }
+
+                    // Exits the search
+                    return false;
+
+                }
+
+            }
+
+            // If `self.currentText` > 1 character
+            else {
+
+                // If there is a match based on the entire string
+                if ((currentSearch.search(alphaNumeric) !== -1)) {
+
+                    // Sets properties of that dropdown list option to make it the currently selected option
+                    self._setCurrentSearchOption(x);
+
+                    // Exits the search
+                    return false;
+
+                }
+
+            }
+
+            // If the current text search is an exact match
+            if (currentSearch.toLowerCase() === self.currentText.toLowerCase()) {
+
+                // Sets properties of that dropdown list option to make it the currently selected option
+                self._setCurrentSearchOption(x);
+
+                // Resets the current text search to a blank string to start fresh again
+                self.currentText = "";
+
+                // Exits the search
+                return false;
+
+            }
+
+        }
+
+       // Returns true if there is not a match at all
+        return true;
+
+    };
+
+    // Search
+    // ------
+    //      Calls searchAlgorithm()
+    selectBoxIt.search = function(alphaNumericKey, callback, rememberPreviousSearch) {
+
+        var self = this;
+
+        // If the search method is being called internally by the plugin, and not externally as a method by a user
+        if (rememberPreviousSearch) {
+
+            // Continued search with history from past searches.  Properly escapes the regular expression
+            self.currentText += alphaNumericKey.replace(/[|()\[{.+*?$\\]/g, "\\$0");
+
+        }
+
+        else {
+
+            // Brand new search.  Properly escapes the regular expression
+            self.currentText = alphaNumericKey.replace(/[|()\[{.+*?$\\]/g, "\\$0");
+
+        }
+
+        // Searches globally
+        var searchResults = self._searchAlgorithm(self.currentIndex, new RegExp(self.currentText, "gi"));
+
+        // Searches the list again if a match is not found.  This is needed, because the first search started at the array indece of the currently selected dropdown list option, and does not search the options before the current array indece.
+        // If there are many similar dropdown list options, starting the search at the indece of the currently selected dropdown list option is needed to properly traverse the text array.
+        if (searchResults) {
+
+            // Searches the dropdown list values starting from the beginning of the text array
+            self._searchAlgorithm(0, self.currentText);
+
+        }
+
+        // Provide callback function support
+        self._callbackSupport(callback);
+
+        // Maintains chainability
+        return self;
+
+    };

data/app/assets/javascripts/selectBoxIt/modules/jquery.selectBoxIt.mobile.js

@@ -0,0 +1,158 @@
+
+    // Mobile Module
+    // =============
+
+    // Set Mobile Text
+    // ---------------
+    //      Updates the text of the drop down
+    selectBoxIt._updateMobileText = function() {
+
+        var self = this,
+            currentOption,
+            currentDataText,
+            currentText;
+
+        currentOption = self.selectBox.find("option").filter(":selected");
+
+        currentDataText = currentOption.attr("data-text");
+
+        currentText = currentDataText ? currentDataText: currentOption.text();
+
+        // Sets the new dropdown list text to the value of the original dropdown list
+        self._setText(self.dropdownText, currentText);
+
+        if(self.list.find('li[data-val="' + currentOption.val() + '"]').find("i").attr("class")) {
+
+           self.dropdownImage.attr("class", self.list.find('li[data-val="' + currentOption.val() + '"]').find("i").attr("class")).addClass("selectboxit-default-icon");
+
+        }
+
+    };
+
+    // Apply Native Select
+    // -------------------
+    //      Applies the original select box directly over the new drop down
+
+    selectBoxIt._applyNativeSelect = function() {
+
+        // Stores the plugin context inside of the self variable
+        var self = this;
+
+        // Appends the native select box to the drop down (allows for relative positioning using the position() method)
+        self.dropdownContainer.append(self.selectBox);
+
+        self.dropdown.attr("tabindex", "-1");
+
+        // Positions the original select box directly over top the new dropdown list using position absolute and "hides" the original select box using an opacity of 0.  This allows the mobile browser "wheel" interface for better usability.
+        self.selectBox.css({
+
+            "display": "block",
+
+            "visibility": "visible",
+
+            "width": self._realOuterWidth(self.dropdown),
+
+            "height": self.dropdown.outerHeight(),
+
+            "opacity": "0",
+
+            "position": "absolute",
+
+            "top": "0",
+
+            "left": "0",
+
+            "cursor": "pointer",
+
+            "z-index": "999999",
+
+            "margin": self.dropdown.css("margin"),
+
+            "padding": "0",
+
+            "-webkit-appearance": "menulist-button"
+
+        });
+
+        if(self.originalElem.disabled) {
+
+            self.triggerEvent("disable");
+
+        }
+
+        return this;
+
+    };
+
+    // Mobile Events
+    // -------------
+    //      Listens to mobile-specific events
+    selectBoxIt._mobileEvents = function() {
+
+        var self = this;
+
+        self.selectBox.on({
+
+            "changed.selectBoxIt": function() {
+
+                self.hasChanged = true;
+
+                self._updateMobileText();
+
+                // Triggers the `option-click` event on mobile
+                self.triggerEvent("option-click");
+
+            },
+
+            "mousedown.selectBoxIt": function() {
+
+                // If the select box has not been changed, the defaultText option is being used
+                if(!self.hasChanged && self.options.defaultText && !self.originalElem.disabled) {
+
+                    self._updateMobileText();
+
+                    self.triggerEvent("option-click");
+
+                }
+
+            },
+
+            "enable.selectBoxIt": function() {
+
+                // Moves SelectBoxIt onto the page
+                self.selectBox.removeClass('selectboxit-rendering');
+
+            },
+
+            "disable.selectBoxIt": function() {
+
+                // Moves SelectBoxIt off the page
+                self.selectBox.addClass('selectboxit-rendering');
+
+            }
+
+        });
+
+    };
+
+    // Mobile
+    // ------
+    //      Applies the native "wheel" interface when a mobile user is interacting with the dropdown
+
+    selectBoxIt._mobile = function(callback) {
+
+        // Stores the plugin context inside of the self variable
+        var self = this;
+
+            if(self.isMobile) {
+
+                self._applyNativeSelect();
+
+                self._mobileEvents();
+
+            }
+
+            // Maintains chainability
+            return this;
+
+    };

data/app/assets/javascripts/selectBoxIt/modules/jquery.selectBoxIt.remove.js

@@ -0,0 +1,90 @@
+
+    // Remove Options Module
+    // =====================
+
+    // remove
+    // ------
+    //    Removes drop down list options
+    //    using an index
+
+    selectBoxIt.remove = function(indexes, callback) {
+
+        var self = this,
+            dataType = $.type(indexes),
+            value,
+            x = 0,
+            dataLength,
+            elems = "";
+
+        // If an array is passed in
+        if(dataType === "array") {
+
+            // Loops through the array
+            for(dataLength = indexes.length; x <= dataLength - 1; x += 1) {
+
+                // Stores the currently traversed array item in the local `value` variable
+                value = indexes[x];
+
+                // If the currently traversed array item is an object literal
+                if($.type(value) === "number") {
+
+                    if(elems.length) {
+
+                        // Adds an element to the removal string
+                        elems += ", option:eq(" + value + ")";
+
+                    }
+
+                    else {
+
+                        // Adds an element to the removal string
+                        elems += "option:eq(" + value + ")";
+
+                    }
+
+                }
+
+            }
+
+            // Removes all of the appropriate options from the select box
+            self.selectBox.find(elems).remove();
+
+        }
+
+        // If a number is passed in
+        else if(dataType === "number") {
+
+            self.selectBox.find("option").eq(indexes).remove();
+
+        }
+
+        // If anything besides a number or array is passed in
+        else {
+
+            // Removes all of the options from the original select box
+            self.selectBox.find("option").remove();
+
+        }
+
+        // If the dropdown property exists
+        if(self.dropdown) {
+
+            // Rebuilds the dropdown
+            self.refresh(function() {
+
+                // Provide callback function support
+                self._callbackSupport(callback);
+
+            }, true);
+
+        } else {
+
+            // Provide callback function support
+            self._callbackSupport(callback);
+
+        }
+
+        // Maintains chainability
+        return self;
+
+    };