/*
returns true if a post event listener was called.
544082
public static boolean notifyPostEventListenerProviders(IServletContext isc,AsyncContextImpl ac) {
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "RegisterEventListenerProvider notifyPostEventListenerProvider(IServletContext,AsyncContext). _PostEventListenerProviders:"+_PostEventListenerProviders);
        }
        boolean result = false;
        Iterator<PostEventListenerProvider> pelps = _PostEventListenerProviders.getServices();
        ArrayList<PostEventListenerProvider> reversePelps = new ArrayList<PostEventListenerProvider>();
               
        // reverse the order so highest ranked goes last
        while (pelps.hasNext()) {
            reversePelps.add(0,pelps.next());
        }
        if (!reversePelps.isEmpty()) {
            for (PostEventListenerProvider pelp : reversePelps) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "RegisterEventListenerProvider notifyPostEventListenerProvider(IServletContext,AsyncContext) notify listener.");
                }            
                pelp.registerListener(isc,ac);
            }    
            result=true;
        }
        return result;
    }
457480
private boolean ignoreEvent(CommentAdded event) {
        Account account = event.getAccount();
        if (account == null) {
            return false;
        }

        String accountEmail = account.getEmail();
        if (StringUtils.isEmpty(accountEmail)) {
            return false;
        }

        Provider provider = event.getProvider();
        if (provider != null) {
            String ignoreEMail = ignoreEMails.get(provider.getName());
            if (StringUtils.isNotEmpty(ignoreEMail) && accountEmail.endsWith(ignoreEMail)) {
                return true;
            }
        }
        return false;
    }
1210742
boolean onKeyDown(Event event) {
    if (listener != null) {
      listener.onKeyDown(event);
      return event.flags().getPreventDefault();
    }
    return false;
  }
223436
function (obj) {
        return Boolean(obj) && ((obj instanceof EventList) ||
            _.inSuperChain(obj.constructor, '_postman_propertyName', EventList._postman_propertyName));
    }
566467
public boolean onBackPressed() {
        if (subForm != null) {
            final boolean shouldDisplayPreviousForm = configuration.allowLogIn() || configuration.allowSignUp();
            if (shouldDisplayPreviousForm) {
                resetHeaderTitle();
                showSignUpTerms(subForm instanceof CustomFieldsFormView);
                removeSubForm();
                clearFocus();
                return true;
            }
        }

        return formLayout != null && formLayout.onBackPressed();
    }
1107012
@Override
    public boolean isPostback(FacesContext context)
    {
        return context.getExternalContext().getRequestParameterMap().containsKey(ResponseStateManager.VIEW_STATE_PARAM);
    }
380343
function(){
       var i; 
       for (i = 0; i < this._events.length; i++) {
           var evt = this._events[i];
           if (evt.eventType === "WorkflowExecutionCancelRequested") {
               return true;
           }
       }
       return false;

   }
1107220
public function wasSubmitted()
    {
        // If form was not (yet) populated, we can not use isChecked() so do this manually
        $request = $this->getRequest();
        if ($request->isPost() && strlen(trim($request->getPost($this->_submitFieldName)))) {
            return true;
        } else {
            return false;
        }
    }
438722
@RequestHandler(patterns = "/form,/form/**")
    public void onPost(Request.In.Post event, IOSubchannel channel) {
        FormContext ctx = channel
            .associated(this, FormContext::new);
        ctx.request = event.httpRequest();
        ctx.session = event.associated(Session.class).get();
        event.setResult(true);
        event.stop();
    }
898002
function () {
            if (this.validate()) {
                if (this.beforeSubmitEvent.fire()) {
                    this.doSubmit();
                    this.submitEvent.fire();
    
                    if (this.cfg.getProperty("hideaftersubmit")) {
                        this.hide();
                    }
    
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
133831
function() {
        if(this.active) {
            return false;
        }
        // register for event handlers defined on this class.
        var events = OpenLayers.Events.prototype.BROWSER_EVENTS;
        for (var i=0, len=events.length; i<len; i++) {
            if (this[events[i]]) {
                this.register(events[i], this[events[i]]); 
            }
        } 
        this.active = true;
        return true;
    }
335376
function triggerListeners(listeners, event, args)
  {
    if (listeners && event in listeners)
    {
      var eventListeners = listeners[ event ];
      var triggerGroup = ++triggerId;
      var next, node = eventListeners.next;

      while (node !== eventListeners)
      {
        next = node.next;
        node.trigger( triggerGroup, args, false );
        node = next;
      }

      node = eventListeners.next;

      while (node !== eventListeners)
      {
        next = node.next;
        node.trigger( triggerGroup, args, true );
        node = next;
      }
    }
  }
130312
function callListeners(listeners) {
        var current_event_idx = -1;

        // Make sure we have some data to pass to the listeners
        event_data = event_data || undefined;

        // If no bound listeners for this event, leave now
        if (listeners.length === 0) {
            emitComplete();
            return;
        }


        // Call the next listener in our array
        function nextListener() {
            var listener, event_obj;

            // We want the next listener
            current_event_idx++;

            // If we've ran out of listeners end this emit call
            if (!listeners[current_event_idx]) {
                emitComplete();
                return;
            }

            // Object the listener ammends to tell us what it's going to do
            event_obj = {
                // If changed to true, expect this listener is going to callback
                wait: false,

                // If wait is true, this callback must be called to continue running listeners
                callback: function () {
                    // Invalidate this callback incase a listener decides to call it again
                    event_obj.callback = undefined;

                    nextListener.apply(that);
                },

                // Prevents the default 'done' functions from executing
                preventDefault: function () {
                    prevented = true;
                }
            };


            listener = listeners[current_event_idx];
            listener[1].call(listener[2] || that, event_obj, event_data);

            // If the listener hasn't signalled it's going to wait, proceed to next listener
            if (!event_obj.wait) {
                // Invalidate the callback just incase a listener decides to call it anyway
                event_obj.callback = undefined;

                nextListener();
            }
        }

        nextListener();
    }
1181580
public function hasListener(EventListener $listener)
    {
        foreach ($this->listeners as $l) {
            if ($l === $listener) {
                return true;
            }
        }
        return false;
    }
726201
function searchFormSubmitted(e){
    e = e || window.event;
    e.preventDefault();

    // If there's no selected item, do nothing
    if(!selectedItem) return false;

    // Otherwise, jump to the page
    window.location.href = relativeDir + selectedItem.getAttribute('data-value');

    return false;
  }
618701
protected boolean onItemClicked() {

        if (isEnabled()) {
            m_overlay.closeSubMenus();

            if (hasSubMenu()) {
                openSubMenu();
                return false;
            } else {
                if (m_rootComponent.isHideAutomatically()) {
                    closeContextMenu();
                    return true;
                }
                return false;
            }
        }

        return false;
    }
233899
public boolean isEnlisted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isEnlisted");

        boolean retval = false;

        if (_currentTran != null)
        {
            retval = true;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isEnlisted", "return="+retval);
        return retval;
    }