mirror of
https://github.com/jenkinsci/jenkins.git
synced 2026-11-16 05:22:22 +00:00
1) in onblur handler, simply restore old form.onsubmit rather than adding another wrapper to call the old handler (which can result in a deep call stack if several comboboxes are used prior to form submission). 2) in onsubmit handler when focused, only call the original onsubmit when the dropdown is not showing (ie don't call it when we intercept the submit to just select an item from the list and return false) I didn't figure out exactly why, but the current code could result in the original form.onsubmit handler not being called on form submission when multiple comboboxes are used. This simplification seems to resolve the issue. git-svn-id: https://hudson.dev.java.net/svn/hudson/trunk/hudson/main@29149 71c3de6d-444a-0410-be80-ed276b4c234a
397 lines
11 KiB
JavaScript
397 lines
11 KiB
JavaScript
/*
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2004-2010, Sun Microsystems, Inc., Kohsuke Kawaguchi
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
if (typeof UTILITIES_VERSION == "undefined" || UTILITIES_VERSION < 0.1) {
|
|
alert("A suitable version of the Utilities class is not available");
|
|
}
|
|
|
|
COMBOBOX_VERSION = 0.1;
|
|
|
|
/*
|
|
Sample CSS for the combobox
|
|
.comboBoxList {
|
|
padding: 0px;
|
|
border: 1px solid #999;
|
|
background-color: #f7f7ff;
|
|
overflow: visible;
|
|
}
|
|
.comboBoxItem {
|
|
margin: 0px;
|
|
padding: 2px 5px;
|
|
background-color: inherit;
|
|
cursor: default;
|
|
}
|
|
.comboBoxSelectedItem {
|
|
background-color: #ddf;
|
|
}
|
|
*/
|
|
|
|
/**
|
|
* I create a new combobox, using the specified text input field and
|
|
* population callback. The item list is styled with three CSS
|
|
* classes: comboBoxList, comboBoxItem, and comboBoxSelectedItem, which
|
|
* are for the containing DIV, the individial item DIVs, and for the
|
|
* currently selected item DIV. Note that the selected item has both
|
|
* the item and selectedItem classes applied. Sample CSS is available
|
|
* in a comment at the top of the implementation file.
|
|
*
|
|
* The 'config' argument allows passing of additional parameters that
|
|
* further govern the behaviour of the combo box. Supported parameters
|
|
* are listed here:
|
|
* allowMultipleValues - whether the form field should allow multiple
|
|
* values to be provided. Each individual value will get it's own
|
|
* separate dropdown with, so a field value such as "dog,ca" would
|
|
* operate as if the value were just "ca" (i.e. just "ca" would be
|
|
* passed to the callback, and a selection choice would only
|
|
* replace the "ca"). Defaults to false.
|
|
* valueDelimiter - if allowMultipleValues is set to true, this is the
|
|
* character used to delimit the values. Defaults to a comma.
|
|
*
|
|
* @param idOrField The ID of the text field the combobox is based around, or the field itself.
|
|
* @param callback The function to call when the typed value changes.
|
|
* The function will be passed the current value of the field, and
|
|
* must return an array of values to display in the dropdown.
|
|
* @param config additional config parameters, as explained above.
|
|
* @param config An object containing configuration parameters for the
|
|
* instance.
|
|
*/
|
|
function ComboBox(idOrField, callback, config) {
|
|
var self = this;
|
|
// instance variables
|
|
this.config = config || new Object();
|
|
this.callback = callback;
|
|
this.availableItems = new Array();
|
|
this.selectedItemIndex = -1;
|
|
this.field = typeof idOrField == "string" ? document.getElementById(idOrField) : idOrField;
|
|
if (typeof this.field == "undefined")
|
|
alert("You have specified an invalid id for the field you want to turn into a combo box");
|
|
this.dropdown = document.createElement("div");
|
|
this.isDropdownShowing = false;
|
|
|
|
// configure the dropdown div
|
|
this.dropdown.className = "comboBoxList";
|
|
document.body.appendChild(this.dropdown);
|
|
this.dropdown.style.position = 'absolute';
|
|
this.moveDropdown();
|
|
this.hideDropdown();
|
|
|
|
// initialize the field
|
|
this.field.comboBox = this;
|
|
this.field.oldValue = this.field.value;
|
|
this.field.onkeyup = ComboBox.onKeyUp;
|
|
this.field.moveCaretToEnd = function() {
|
|
if (this.createTextRange) {
|
|
var range = this.createTextRange();
|
|
range.collapse(false);
|
|
range.select();
|
|
} else if (this.setSelectionRange) {
|
|
this.focus();
|
|
var length = this.value.length;
|
|
this.setSelectionRange(length, length);
|
|
}
|
|
}
|
|
this.field.form.oldonsubmit = this.field.form.onsubmit;
|
|
this.field.onfocus = function() {
|
|
this.form.onsubmit = function() {
|
|
if (self.isDropdownShowing) return false;
|
|
if (this.oldonsubmit) this.oldonsubmit();
|
|
return true;
|
|
};
|
|
}
|
|
this.field.onblur = function() {
|
|
var cb = this.comboBox;
|
|
this.hideTimeout = setTimeout(function() { cb.hideDropdown(); }, 100);
|
|
this.form.onsubmit = this.form.oldonsubmit;
|
|
}
|
|
|
|
// privileged methods
|
|
this.getConfigParam = function(name, defVal) {
|
|
return self.config[name] || defVal;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am the onKeyDown listener that gets installed on the input field
|
|
* that is the core of the ComboBox. I handle action operations.
|
|
*
|
|
* @param e The event object on Mozilla browsers, null on IE
|
|
*/
|
|
ComboBox.onKeyDown = function(e) {
|
|
if (!e) e = window.event;
|
|
var capture = function() {
|
|
e.cancelBubble = true;
|
|
if (e.stopPropagation) e.stopPropagation();
|
|
}
|
|
switch (e.keyCode) {
|
|
case 13: // enter
|
|
case 9: // tab
|
|
this.comboBox.chooseSelection();
|
|
capture();
|
|
return false;
|
|
case 27: // escape
|
|
this.comboBox.hideDropdown();
|
|
capture();
|
|
case 38: // up arrow
|
|
this.comboBox.selectPrevious();
|
|
capture();
|
|
break;
|
|
case 40: // down arrow
|
|
this.comboBox.selectNext();
|
|
capture();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am the onKeyUp listener that gets installed on the input field
|
|
* that is the core of the ComboBox. I handle value-change operations.
|
|
*
|
|
* @param e The event object on Mozilla browsers, null on IE
|
|
*/
|
|
ComboBox.onKeyUp = function(e) {
|
|
if (!e) e = window.event;
|
|
var capture = function() {
|
|
e.cancelBubble = true;
|
|
if (e.stopPropagation) e.stopPropagation();
|
|
}
|
|
switch (e.keyCode) {
|
|
case 38: // up arrow
|
|
case 40: // down arrow
|
|
this.moveCaretToEnd();
|
|
capture();
|
|
break;
|
|
default:
|
|
if (this.value != this.oldValue) {
|
|
this.comboBox.valueChanged();
|
|
this.oldValue = this.value;
|
|
}
|
|
capture();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by the onKeyUp listener when the entered value changes,
|
|
* and am responsible for invoking the application callback function
|
|
* and repopulating the dropdown, if appropriate.
|
|
*/
|
|
ComboBox.prototype.valueChanged = function() {
|
|
var value = this.field.value;
|
|
if (this.getConfigParam("allowMultipleValues", false)) {
|
|
value = value.split(this.getConfigParam("valueDelimiter", ","));
|
|
value = value[value.length - 1].replace(/^ +/, "").replace(/ +$/, "");
|
|
}
|
|
var a = this.callback(value, this);
|
|
if (typeof a == "undefined") // to catch null returns
|
|
return;
|
|
this.setItems(a);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I can be called at any time with a new set of items to display in
|
|
* the dropdown.
|
|
*
|
|
* @param items The array of items that should be used for the dropdown
|
|
* values.
|
|
*/
|
|
ComboBox.prototype.setItems = function(items) {
|
|
if (typeof items != "object") {
|
|
alert("setItems wasn't passed a valid array: " + typeof a);
|
|
return;
|
|
}
|
|
this.availableItems = items;
|
|
this.populateDropdown();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called to repopulate the dropdown. There should never be a
|
|
* need to invoke me externally.
|
|
*/
|
|
ComboBox.prototype.populateDropdown = function() {
|
|
if (this.availableItems.length > 0) {
|
|
Utilities.removeChildren(this.dropdown);
|
|
for (var i = 0; i < this.availableItems.length; i++) {
|
|
var item = document.createElement("div");
|
|
item.className = "comboBoxItem";
|
|
item.innerHTML = this.availableItems[i];
|
|
item.id = "item_" + this.availableItems[i];
|
|
item.comboBox = this;
|
|
item.comboBoxIndex = i;
|
|
item.onmouseover = function() {this.comboBox.select(this.comboBoxIndex);};
|
|
item.onmousedown = function() {this.comboBox.choose(this.comboBoxIndex);};
|
|
this.dropdown.appendChild(item);
|
|
}
|
|
this.selectedItemIndex = 0;
|
|
this.updateSelection();
|
|
this.showDropdown();
|
|
} else {
|
|
this.selectedItemIndex = -1;
|
|
this.hideDropdown();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by a mouse listener on the dropdown items to choose a
|
|
* specific item straight away.
|
|
*
|
|
* @param index The index of the item to choose
|
|
*/
|
|
ComboBox.prototype.choose = function(index) {
|
|
if (this.select(index))
|
|
this.chooseSelection();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by the onKeyUp listener to indicate that the user wants
|
|
* to use the current selection as the new value of the field.
|
|
*/
|
|
ComboBox.prototype.chooseSelection = function() {
|
|
var i = this.selectedItemIndex;
|
|
var a = this.availableItems;
|
|
if (i >= 0 && i < a.length) {
|
|
var valueToAdd = a[i].replace(/<[^>]+>/g, "");
|
|
if (this.getConfigParam("allowMultipleValues", false)) {
|
|
var currentValue = "";
|
|
var delim = this.getConfigParam("valueDelimiter", ",");
|
|
values = this.field.value.split(delim);
|
|
for (var j = 0; j < values.length - 1; j++) {
|
|
currentValue = Utilities.listAppend(currentValue, values[j], delim);
|
|
}
|
|
this.field.value = Utilities.listAppend(currentValue, valueToAdd, delim);
|
|
} else {
|
|
this.field.value = valueToAdd;
|
|
}
|
|
|
|
this.field.oldValue = this.field.value;
|
|
this.field.focus();
|
|
this.field.moveCaretToEnd();
|
|
this.hideDropdown();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by a mouse listener on the dropdown items to select a
|
|
* specific item straight away.
|
|
*
|
|
* @param index The index of the item to select
|
|
* @return whether the selection happened (the index was valid)
|
|
*/
|
|
ComboBox.prototype.select = function(index) {
|
|
if (index < 0 || index >= this.availableItems.length)
|
|
return false;
|
|
this.selectedItemIndex = index;
|
|
this.updateSelection();
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by the onKeyUp listener to indicate that the user wants
|
|
* to select the next option in the dropdown.
|
|
*/
|
|
ComboBox.prototype.selectNext = function() {
|
|
if (this.selectedItemIndex >= this.availableItems.length - 1)
|
|
return false;
|
|
this.selectedItemIndex++;
|
|
this.updateSelection();
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I am called by the onKeyUp listener to indicate that the user wants
|
|
* to select the previous option in the dropdown.
|
|
*/
|
|
ComboBox.prototype.selectPrevious = function() {
|
|
if (this.selectedItemIndex <= 0)
|
|
return false;
|
|
this.selectedItemIndex--;
|
|
this.updateSelection();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I show the dropdown DIV.
|
|
*/
|
|
ComboBox.prototype.showDropdown = function() {
|
|
this.moveDropdown();
|
|
clearTimeout(this.field.hideTimeout);
|
|
this.dropdown.style.display = 'block';
|
|
this.field.onkeydown = ComboBox.onKeyDown;
|
|
this.isDropdownShowing = true;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I hide the dropdown DIV.
|
|
*/
|
|
ComboBox.prototype.hideDropdown = function() {
|
|
var self = this;
|
|
setTimeout(function() {self.isDropdownShowing = false;}, 100);
|
|
this.field.onkeydown = null;
|
|
this.dropdown.style.display = 'none';
|
|
}
|
|
|
|
ComboBox.prototype.moveDropdown = function() {
|
|
var offsets = Utilities.getOffsets(this.field);
|
|
this.dropdown.style.top = offsets.y + (this.field.offsetHeight ? this.field.offsetHeight : 22) + "px";
|
|
this.dropdown.style.left = offsets.x + "px";
|
|
this.dropdown.style.width = (this.field.offsetWidth ? this.field.offsetWidth : 100) + "px"
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* I update the dropdown so that the display reflects the internally
|
|
* selected item,
|
|
*/
|
|
ComboBox.prototype.updateSelection = function() {
|
|
for (var i = 0; i < this.dropdown.childNodes.length; i++) {
|
|
if (i == this.selectedItemIndex) {
|
|
this.dropdown.childNodes[i].className += " comboBoxSelectedItem";
|
|
} else {
|
|
this.dropdown.childNodes[i].className = this.dropdown.childNodes[i].className.replace(/ *comboBoxSelectedItem */g, "");
|
|
}
|
|
}
|
|
}
|