/** Return true if the element is listening for the given eventBit or eventName. */
public boolean hasHandlers(int eventBits, String eventName) {
for (int i = 0, j = elementEvents.length(); i < j; i++) {
BindFunction function = elementEvents.get(i);
if (function.hasEventType(eventBits) || function.isTypeOf(eventName)) {
return true;
}
}
return false;
}
private void resultsBuild() {
selectItems = new SelectParser().parse(selectElement);
if (isMultiple && choices > 0) {
searchChoices.find("li." + css.searchChoice()).remove();
choices = 0;
} else if (!isMultiple) {
selectedItem.addClass(css.chznDefault()).find("span").text(defaultText);
if (selectElement.getOptions().getLength() <= options.getDisableSearchThreshold()) {
container.addClass(css.chznContainerSingleNoSearch());
} else {
container.removeClass(css.chznContainerSingleNoSearch());
}
}
SafeHtmlBuilder content = new SafeHtmlBuilder();
for (int i = 0; i < selectItems.length(); i++) {
SelectItem item = selectItems.get(i);
if (item.isGroup()) {
SafeHtml result = resultAddGroup((GroupItem) item);
if (result != null) {
content.append(result);
}
} else {
OptionItem optionItem = (OptionItem) item;
if (optionItem.isEmpty()) {
continue;
}
SafeHtml optionHtml = resultAddOption(optionItem);
if (optionHtml != null) {
content.append(optionHtml);
}
if (optionItem.isSelected() && isMultiple) {
choiceBuild(optionItem);
} else if (optionItem.isSelected() && !isMultiple) {
selectedItem.removeClass(css.chznDefault()).find("span").text(optionItem.getText());
if (allowSingleDeselect) {
singleDeselectControlBuild();
}
}
}
}
searchFieldDisabled();
showSearchFieldDefault();
searchFieldScale();
searchResults.html(content.toSafeHtml().asString());
}
/** Remove the BindFunction associated to this cssSelector. */
public void removeBindFunctionForSelector(String cssSelector, String nameSpace) {
if (nameSpace == null) {
bindFunctionBySelector.delete(cssSelector);
} else {
JsObjectArray<BindFunction> functions = bindFunctionBySelector.get(cssSelector);
if (functions == null || functions.length() == 0) {
return;
}
JsObjectArray<BindFunction> newFunctions = JsObjectArray.create();
for (int i = 0; i < functions.length(); i++) {
BindFunction f = functions.get(i);
if (nameSpace != null && !nameSpace.equals(f.nameSpace)) {
newFunctions.add(f);
}
}
bindFunctionBySelector.delete(cssSelector);
if (newFunctions.length() > 0) {
bindFunctionBySelector.put(cssSelector, newFunctions);
}
}
}
/** Dispatch an event in this element but changing the type, it's useful for special events. */
public void dispatchEvent(Event event, String eventName) {
int etype = Event.getTypeInt(eventName);
Object[] handlerData = $(element).data(EVENT_DATA);
for (int i = 0, l = elementEvents.length(); i < l; i++) {
BindFunction listener = elementEvents.get(i);
String namespace = JsUtils.prop(event, "namespace");
boolean matchEV =
listener != null && (listener.hasEventType(etype) || listener.isTypeOf(eventName));
boolean matchNS =
matchEV && (isNullOrEmpty(namespace) || listener.nameSpace.equals(namespace));
if (matchEV && matchNS) {
if (!listener.fire(event, handlerData)) {
event.stopPropagation();
event.preventDefault();
}
}
}
}
public void unbind(int eventbits, String namespace, String eventName, Function f) {
JsObjectArray<BindFunction> newList = JsObjectArray.createArray().cast();
for (int i = 0; i < elementEvents.length(); i++) {
BindFunction listener = elementEvents.get(i);
boolean matchNS = isNullOrEmpty(namespace) || listener.nameSpace.equals(namespace);
boolean matchEV = eventbits <= 0 || listener.hasEventType(eventbits);
boolean matchEVN = matchEV || listener.isTypeOf(eventName);
boolean matchFC = f == null || listener.isEquals(f);
if (matchNS && matchEV && matchEVN && matchFC) {
int currentEventbits = listener.unsink(eventbits);
if (currentEventbits == 0) {
// the BindFunction doesn't listen anymore on any events
continue;
}
}
newList.add(listener);
}
elementEvents = newList;
}
@Override
public boolean fire(Event event, Object[] eventData) {
if (isEmpty()) {
return true;
}
// first element where the event was fired
Element eventTarget = getEventTarget(event);
// last element where the event was dispatched on
Element liveContextElement = getCurrentEventTarget(event);
if (eventTarget == null || liveContextElement == null) {
return true;
}
// Compute the live selectors which respond to this event type
List<String> validSelectors = new ArrayList<String>();
for (String cssSelector : bindFunctionBySelector.keys()) {
JsObjectArray<BindFunction> bindFunctions = bindFunctionBySelector.get(cssSelector);
for (int i = 0; bindFunctions != null && i < bindFunctions.length(); i++) {
BindFunction f = bindFunctions.get(i);
if (f.hasEventType(event.getTypeInt()) || f.isTypeOf(event.getType())) {
validSelectors.add(cssSelector);
break;
}
}
}
// Create a structure of elements which matches the selectors
JsNamedArray<NodeList<Element>> realCurrentTargetBySelector =
$(eventTarget).closest(validSelectors.toArray(new String[0]), liveContextElement);
// nothing matches the selectors
if (realCurrentTargetBySelector.length() == 0) {
return true;
}
Element stopElement = null;
GqEvent gqEvent = GqEvent.create(event);
for (String cssSelector : realCurrentTargetBySelector.keys()) {
JsObjectArray<BindFunction> bindFunctions = bindFunctionBySelector.get(cssSelector);
for (int i = 0; bindFunctions != null && i < bindFunctions.length(); i++) {
BindFunction f = bindFunctions.get(i);
if (f.hasEventType(event.getTypeInt()) || f.isTypeOf(event.getType())) {
NodeList<Element> n = realCurrentTargetBySelector.get(cssSelector);
for (int j = 0; n != null && j < n.getLength(); j++) {
Element element = n.getItem(j);
// When an event fired in an element stops bubbling we have to fire also all other
// handlers for this element bound to this element
if (stopElement == null || element.equals(stopElement)) {
gqEvent.setCurrentElementTarget(element);
// data
eventData = $(element).data(EVENT_DATA);
if (!f.fire(gqEvent, eventData)) {
stopElement = element;
}
}
}
}
}
}
// trick to reset the right currentTarget on the original event on ie
gqEvent.setCurrentElementTarget(liveContextElement);
return stopElement == null;
}
public NodeList<Element> select(String sel, Node ctx) {
String selectors[] = sel.replace("\\s*(,)\\s*", "$1").split(",");
boolean identical = false;
JsNodeArray elm = JsNodeArray.create();
for (int a = 0, len = selectors.length; a < len; a++) {
if (a > 0) {
identical = false;
for (int b = 0, bl = a; b < bl; b++) {
if (JsUtils.eq(selectors[a], selectors[b])) {
identical = true;
break;
}
}
if (identical) {
continue;
}
}
String currentRule = selectors[a];
JsObjectArray<String> cssSelectors = selectorSplitRegExp.match(currentRule);
JsNodeArray prevElem = JsNodeArray.create(ctx);
for (int i = 0, slen = cssSelectors.length(); i < slen; i++) {
JsNodeArray matchingElms = JsNodeArray.create();
String rule = cssSelectors.get(i);
if (i > 0 && childOrSiblingRefRegExp.test(rule)) {
JsObjectArray<String> childOrSiblingRef = childOrSiblingRefRegExp.exec(rule);
if (JsUtils.truth(childOrSiblingRef)) {
JsObjectArray<String> nextTag = new JsRegexp("^\\w+").exec(cssSelectors.get(i + 1));
JsRegexp nextRegExp = null;
String nextTagStr = null;
if (JsUtils.truth(nextTag)) {
nextTagStr = nextTag.get(0);
nextRegExp = new JsRegexp("(^|\\s)" + nextTagStr + "(\\s|$)", "i");
}
for (int j = 0, jlen = prevElem.size(); j < jlen; j++) {
Node prevRef = prevElem.getNode(j);
String ref = childOrSiblingRef.get(0);
if (JsUtils.eq(">", ref)) {
getDescendantNodes(matchingElms, nextTagStr, prevRef);
} else if (JsUtils.eq("+", ref)) {
getSiblingNodes(matchingElms, nextTag, nextRegExp, prevRef);
} else if (JsUtils.eq("~", ref)) {
getGeneralSiblingNodes(matchingElms, nextTag, nextRegExp, prevRef);
}
}
prevElem = matchingElms;
clearAdded(prevElem);
rule = cssSelectors.get(++i);
if (new JsRegexp("^\\w+$").test(rule)) {
continue;
}
setSkipTag(prevElem, true);
}
}
JsObjectArray<String> cssSelector = cssSelectorRegExp.exec(rule);
SplitRule splitRule =
new SplitRule(
!JsUtils.truth(cssSelector.get(1)) || JsUtils.eq(cssSelector.get(3), "*")
? "*"
: cssSelector.get(1),
!JsUtils.eq(cssSelector.get(3), "*") ? cssSelector.get(2) : null,
cssSelector.get(4),
cssSelector.get(6),
cssSelector.get(10));
if (JsUtils.truth(splitRule.id)) {
Element domelem = Document.get().getElementById(splitRule.id.substring(1));
if (JsUtils.truth(domelem)) {
matchingElms = JsNodeArray.create(domelem);
}
prevElem = matchingElms;
} else if (JsUtils.truth(splitRule.tag) && !isSkipped(prevElem)) {
if (i == 0 && matchingElms.size() == 0 && prevElem.size() == 1) {
prevElem =
matchingElms =
JsNodeArray.create(getElementsByTagName(splitRule.tag, prevElem.getNode(0)));
} else {
NodeList<Element> tagCollectionMatches;
for (int l = 0, ll = prevElem.size(); l < ll; l++) {
tagCollectionMatches = getElementsByTagName(splitRule.tag, prevElem.getNode(l));
for (int m = 0, mlen = tagCollectionMatches.getLength(); m < mlen; m++) {
Node tagMatch = tagCollectionMatches.getItem(m);
if (!isAdded(tagMatch)) {
setAdded(tagMatch, true);
matchingElms.addNode(tagMatch);
}
}
}
prevElem = matchingElms;
clearAdded(prevElem);
}
if (matchingElms.size() == 0) {
break;
}
setSkipTag(prevElem, false);
if (JsUtils.truth(splitRule.allClasses)) {
String[] allClasses = splitRule.allClasses.replaceFirst("^\\.", "").split("\\.");
JsRegexp[] regExpClassNames = new JsRegexp[allClasses.length];
for (int n = 0, nl = allClasses.length; n < nl; n++) {
regExpClassNames[n] = new JsRegexp("(^|\\s)" + allClasses[n] + "(\\s|$)");
}
JsNodeArray matchingClassElms = JsNodeArray.create();
for (int o = 0, olen = prevElem.size(); o < olen; o++) {
Element current = prevElem.getElement(o);
String elmClass = current.getClassName();
boolean addElm = false;
if (JsUtils.truth(elmClass) && !isAdded(current)) {
for (int p = 0, pl = regExpClassNames.length; p < pl; p++) {
addElm = regExpClassNames[p].test(elmClass);
if (!addElm) {
break;
}
}
if (addElm) {
setAdded(current, true);
matchingClassElms.addNode(current);
}
}
}
clearAdded(prevElem);
prevElem = matchingElms = matchingClassElms;
}
if (JsUtils.truth(splitRule.allAttr)) {
JsObjectArray<String> allAttr = JsRegexp.match("\\[[^\\]]+\\]", "g", splitRule.allAttr);
JsRegexp[] regExpAttributes = new JsRegexp[allAttr.length()];
String[] regExpAttributesStr = new String[allAttr.length()];
JsRegexp attributeMatchRegExp =
new JsRegexp("(\\w+)(\\^|\\$|\\*|\\||~)?=?[\"']?([\\w\u00C0-\uFFFF\\s\\-_\\.]+)?");
for (int q = 0, ql = allAttr.length(); q < ql; q++) {
JsObjectArray<String> attributeMatch = attributeMatchRegExp.exec(allAttr.get(q));
String attributeValue =
JsUtils.truth(attributeMatch.get(3))
? attributeMatch.get(3).replaceAll("\\.", "\\.")
: null;
String attrVal =
attrToRegExp(attributeValue, (JsUtils.or(attributeMatch.get(2), null)));
regExpAttributes[q] = (JsUtils.truth(attrVal) ? new JsRegexp(attrVal) : null);
regExpAttributesStr[q] = attributeMatch.get(1);
}
JsNodeArray matchingAttributeElms = JsNodeArray.create();
for (int r = 0, rlen = matchingElms.size(); r < rlen; r++) {
Element current = matchingElms.getElement(r);
boolean addElm = false;
for (int s = 0, sl = regExpAttributes.length; s < sl; s++) {
addElm = false;
JsRegexp attributeRegexp = regExpAttributes[s];
String currentAttr = getAttr(current, regExpAttributesStr[s]);
if (JsUtils.truth(currentAttr) && currentAttr.length() != 0) {
if (attributeRegexp == null || attributeRegexp.test(currentAttr)) {
addElm = true;
}
}
if (!addElm) {
break;
}
}
if (addElm) {
matchingAttributeElms.addNode(current);
}
}
prevElem = matchingElms = matchingAttributeElms;
}
if (JsUtils.truth(splitRule.allPseudos)) {
JsRegexp pseudoSplitRegExp = new JsRegexp(":(\\w[\\w\\-]*)(\\(([^\\)]+)\\))?");
JsObjectArray<String> allPseudos =
JsRegexp.match("(:\\w+[\\w\\-]*)(\\([^\\)]+\\))?", "g", splitRule.allPseudos);
for (int t = 0, tl = allPseudos.length(); t < tl; t++) {
JsObjectArray<String> pseudo = pseudoSplitRegExp.match(allPseudos.get(t));
String pseudoClass =
JsUtils.truth(pseudo.get(1)) ? pseudo.get(1).toLowerCase() : null;
String pseudoValue = JsUtils.truth(pseudo.get(3)) ? pseudo.get(3) : null;
matchingElms = getElementsByPseudo(matchingElms, pseudoClass, pseudoValue);
clearAdded(matchingElms);
}
prevElem = matchingElms;
}
}
}
elm.pushAll(prevElem);
}
return JsUtils.unique(elm.<JsArray<Element>>cast()).cast();
}
private void winnowResults() {
noResultClear();
int results = 0;
String searchText = defaultText.equals(searchField.val()) ? "" : searchField.val().trim();
searchText = SafeHtmlUtils.htmlEscape(searchText);
String regexAnchor = options.isSearchContains() ? "" : "^";
// escape reg exp special chars
String escapedSearchText = regExpChars.replace(searchText, "\\$&");
String test2 = "test";
test2.substring(1);
RegExp regex = RegExp.compile(regexAnchor + escapedSearchText, "i");
RegExp zregex = RegExp.compile("(" + escapedSearchText + ")", "i");
for (int i = 0; i < selectItems.length(); i++) {
SelectItem item = selectItems.get(i);
if (item.isDisabled() || item.isEmpty()) {
continue;
}
if (item.isGroup()) {
$('#' + item.getDomId()).css("display", "none");
} else {
OptionItem option = (OptionItem) item;
if (!(isMultiple && option.isSelected())) {
boolean found = false;
String resultId = option.getDomId();
GQuery result = $("#" + resultId);
String optionContent = option.getHtml();
if (regex.test(optionContent)) {
found = true;
results++;
} else if (optionContent.indexOf(" ") >= 0 || optionContent.indexOf("[") == 0) {
String[] parts = optionContent.replaceAll("\\[|\\]", "").split(" ");
for (String part : parts) {
if (regex.test(part)) {
found = true;
results++;
}
}
}
if (found) {
String text;
if (searchText.length() > 0) {
text = zregex.replace(optionContent, "<em>$1</em>");
} else {
text = optionContent;
}
result.html(text);
resultActivate(result);
if (option.getGroupArrayIndex() != -1) {
$("#" + selectItems.get(option.getGroupArrayIndex()).getDomId())
.css("display", "list-item");
}
} else {
if (resultHighlight != null && resultId.equals(resultHighlight.attr("id"))) {
resultClearHighlight();
}
resultDeactivate(result);
}
}
}
}
if (results < 1 && searchText.length() > 0) {
noResults(searchText);
} else {
winnowResultsSetHighlight();
}
}
