Try to fire a given event on the Browser.

@param eventable the eventable to fire
@return true iff the event is fired
351726
private boolean fireEvent(Eventable eventable) {
		Eventable eventToFire = eventable;
		if (eventable.getIdentification().getHow().toString().equals("xpath")
				&& eventable.getRelatedFrame().equals("")) {
			eventToFire = resolveByXpath(eventable, eventToFire);
		}
		boolean isFired = false;
		try {
			isFired = browser.fireEventAndWait(eventToFire);
		} catch (ElementNotVisibleException | NoSuchElementException e) {
			if (crawlRules.isCrawlHiddenAnchors() && eventToFire.getElement() != null
					&& "A".equals(eventToFire.getElement().getTag())) {
				isFired = visitAnchorHrefIfPossible(eventToFire);
			} else {
				LOG.debug("Ignoring invisible element {}", eventToFire.getElement());
			}
		} catch (InterruptedException e) {
			LOG.debug("Interrupted during fire event");
			interruptThread();
			return false;
		}

		LOG.debug("Event fired={} for eventable {}", isFired, eventable);

		if (isFired) {
			// Let the controller execute its specified wait operation on the browser thread safe.
			waitConditionChecker.wait(browser);
			browser.closeOtherWindows();
			return true;
		} else {
			/*
			 * Execute the OnFireEventFailedPlugins with the current crawlPath with the crawlPath
			 * removed 1 state to represent the path TO here.
			 */
			plugins.runOnFireEventFailedPlugins(context, eventable,
					crawlpath.immutableCopyWithoutLast());
			return false; // no event fired
		}
	}
525557
@SuppressWarnings("unchecked")
    @Override
    public Boolean execute() {
        SmartFoxServer.getInstance()
                .getAPIManager()
                .getGameApi()
                .sendInvitation(CommandUtil.getSfsUser(inviter, api), 
                        CommandUtil.getSFSUserList(invitees, api), 
                        expirySeconds, 
                        createCallback(), 
                        MapUtill.map2SFSObject(context, params));
        return Boolean.TRUE;
    }
1103369
@Override
    public <T> Event<T> fire(Event<T> event, Channel... channels) {
        if (channels.length == 0) {
            channels = event.channels();
            if (channels.length == 0) {
                channels = new Channel[] { channel() };
            }
        }
        event.setChannels(channels);
        tree().fire(event, channels);
        return event;
    }
1090948
@Override
	public void onUncaughtException(Throwable throwable) {
		for (ErrorHandler handler : this.errorHandlers) {
			if (handler.handle(throwable)) {
				return;
			}
		}
		this.defaultHandler.handle(throwable);
	}
730979
function(eventName, args) {

      // Run interactions
      var fieldValue = args[0];
      var fieldInstance = args[1];
      this.runInteractions(fieldInstance,fieldValue);
      
      //this.setClassFromState();
      
      this.fireUpdatedEvt();
   }
146512
function fireEvent(sourceElement, eventData) {
    const isDisabled = !that.enabled;
    const noElements = !sourceElements.length || !targetElements.length;

    if (isDisabled || noElements) {
      return;
    }

    ignoreFiredEvents = true;
    targetElements.forEach(function(targetElement) {
      const targetIndex = targetElements.indexOf(targetElement);

      if (targetIndex === -1) {
        return;
      }

      const targetImageId = initialData.imageIds.targetElements[targetIndex];
      const sourceIndex = sourceElements.indexOf(sourceElement);

      if (sourceIndex === -1) {
        return;
      }

      const sourceImageId = initialData.imageIds.sourceElements[sourceIndex];

      let positionDifference;

      if (sourceImageId === targetImageId) {
        positionDifference = 0;
      } else if (initialData.distances[sourceImageId] !== undefined) {
        positionDifference =
          initialData.distances[sourceImageId][targetImageId];
      }

      eventHandler(
        that,
        sourceElement,
        targetElement,
        eventData,
        positionDifference
      );
    });
    ignoreFiredEvents = false;
  }
722992
public boolean tryClick(final By by) {
		LOGGER.info("Trying to click on {}", by);
		List<WebElement> elements = wef.timeout(2L).by(by).findAll();
		if (elements.size() > 0) {
			WebElement element = elements.get(0);
			checkTopmostElement(by);
			new Actions(webDriver).moveToElement(element).click().perform();
			LOGGER.info("Click successful");
			return true;
		}
		LOGGER.info("Click not successful");
		return false;
	}
954681
public static <T> Listener<T> createListenerToFire(Event<T> event) {
		return new Listener<T>() {
			@Override
			public void fire(T obj) {
				event.fire(obj);
			}
		};
	}
730610
protected void fireEvent(E event) {

    for (L listener : this.listeners) {
      try {
        fireEvent(event, listener);
      } catch (RuntimeException e) {
        handleListenerError(listener, event, e);
      }
    }
  }
825181
protected void fireChange(boolean force) {

        String value = getFormValueAsString();
        if (force || !value.equals(m_previousValue)) {
            m_previousValue = value;
            ValueChangeEvent.fire(this, value);
        }
    }
645182
@SuppressWarnings("unchecked")
    @Override
    public Boolean execute() {
        try {
            SmartFoxServer.getInstance()
                .getAPIManager().getBuddyApi()
                .goOnline(CommandUtil.getSfsUser(user, api), online, fireServerEvent);
        } catch (SFSBuddyListException e) {
            throw new IllegalStateException(e);
        }
        return Boolean.FALSE;
    }
813872
void fireEvent() {
        boolean useLock = !isReentrant();
        if (useLock) {
            lock.lock();
        }
        EventImpl event = eventQueue.poll();

        try {
            if (event != null) {
                fireEvent(event);
            }
        } finally {
            if (useLock) {
                lock.unlock();
            }
        }

    }
669758
protected boolean trigger(InteractionEvent.Type type, Throwable e) {
        return trigger(getAllListeners(), type, e);
    }
761258
public <V extends Event> B on(EventType<V, ?> type, EventCallbackFn<V> callback) {
        bind(get(), type, callback);
        return that();
    }
755776
def fire_event(self, event_name, service_name, default=None):
        
        service = self.get_service(service_name)
        callbacks = service.get(event_name, default)
        if not callbacks:
            return
        if not isinstance(callbacks, Iterable):
            callbacks = [callbacks]
        for callback in callbacks:
            if isinstance(callback, ManagerCallback):
                callback(self, service_name, event_name)
            else:
                callback(service_name)
1358090
@Override
    protected void handlingError(
            EventPipeline eventProcessor, Throwable throwable) {
        eventProcessor.fire(
            new HandlingError(this, throwable), channels());
    }
1005999
public boolean f(Event e, Object... arg) {
    setArguments(arg);
    setEvent(e);
    return f(e);
  }