/** * provides the un-threaded super fire-method. see {@link EventController#fireEvent(Object)} * * @param e new event */ public void sendEvent(final Object e) { super.fireEvent(e); } }
@Override public EventController changeHandler() { if (eventController == null) { eventController = new EventController(); } return eventController; } }
public boolean add(Object o) { boolean r = c.add(o); changeHandler.fireValueChange(c, null, o, true); return r; };
public EProcess() { prc.getEventController().addListener(this, Object.class); }
/** * uses the information of {@link #attributeID} to inject the real {@link AttributeDefinition} into registered * change listeners * * @throws CloneNotSupportedException */ void injectAttributeOnChangeListeners(BeanDefinition beandef) { //provide dependency listeners their attribute-definition if (hasListeners()) { Collection<IListener> listener = changeHandler().getListeners(null); boolean isBean = beandef instanceof Bean; for (IListener l : listener) { if (l instanceof AbstractDependencyListener) { AbstractDependencyListener<?, ?> dl = (AbstractDependencyListener<?, ?>) l; if (isBean) {//create a specific listener instance for the given bean! LOG.debug(beandef.getId() + ": re-assigning dependency-listener-clone " + dl); dl = (AbstractDependencyListener<?, ?>) dl.clone(); Class eventType = changeHandler().getEventType(l); changeHandler().removeListener(l); changeHandler().addListener(dl, eventType); } if (dl.attributeID != null) { String name = StringUtil.substring(dl.attributeID, ".", null); LOG.debug(beandef.getId() + ": resetting value of attribute " + name); dl.setAttribute((AttributeDefinition) beandef.getAttribute(name)); } } } } }
/** * {@inheritDoc} */ @Override public void setValue(T object) { if (changeHandler == null || !changeHandler.hasListeners()) { this.value = object; } else { final T oldValue = getValue(); final ChangeEvent event = new ChangeEvent(this, false, false, oldValue, object); changeHandler.fireEvent(event); if (!event.breakEvent) { this.value = object; event.hasChanged = true; changeHandler.fireEvent(event); } } }
/** * looks for registered change handlers without creating an {@link EventController} instance. * * @return */ public boolean hasListeners() { return eventController != null && eventController.hasListeners(); }
/** * notify * * @param notification */ public void notify(Notification notification) { //sets the status to notified - the handle-runner will reset it to idle after finishing increaseStatus(); controller.handle(this, notification); }
/** * a new listener will be created to set the new value of this bean to the given beanvalue. * * @param anotherValue beanvalue to bind */ public void bind(final BeanValue<T> anotherValue) { // if (!getType().equals(anotherValue.getType())) // ManagedException.implementationError("binding beanvalues must have the same type", anotherValue.getType()); changeHandler().addListener(new IListener<ChangeEvent>() { @Override public void handleEvent(ChangeEvent changeEvent) { if (changeEvent.hasChanged) { anotherValue.setValue((T) changeEvent.newValue); } } }); }
/** * constructor * @param path for nodes to be notified * @param notification the notification content * @param response any node response * @param responseListener listeners to node responses */ public Notification(String path, Object notification, Map<String, Object> response, IListener<Notification> responseListener) { super(); this.notification = notification; this.path = path; this.response = response; if (responseListener != null) { getResponseController().addListener(responseListener); } }
/** * provides the un-threaded super fire-method. see {@link EventController#fireEvent(Object)} * * @param e new event */ public void sendEvent(final Object e) { super.fireEvent(e); } }
/** * {@inheritDoc} */ @Override public EventController changeHandler() { if (eventController == null) { eventController = new EventController(); } return eventController; }
public boolean remove(Object o) { boolean r = c.remove(o); changeHandler.fireValueChange(c, o, null, true); return r; }; }
private void createBinding() { firstValue.changeHandler().addListener(new IListener<ChangeEvent>() { @Override public void handleEvent(ChangeEvent changeEvent) { if (!updating && changeEvent.hasChanged) { try { updating = true; secondValue.setValue(converter.to((FIRST) changeEvent.newValue)); } finally { updating = false; } } } }); secondValue.changeHandler().addListener(new IListener<ChangeEvent>() { @Override public void handleEvent(ChangeEvent changeEvent) { if (!updating && changeEvent.hasChanged) { try { updating = true; firstValue.setValue(converter.from((SECOND) changeEvent.newValue)); } finally { updating = false; } } } }); }
/** * addResponse * @param srcPath path of responding node * @param aresponse response of a node */ public void addResponse(String srcPath, Object aresponse) { if (response == null) { response = new ConcurrentHashMap<String, Object>(); } //concurrenthashmap is not able to store null values! if (aresponse != null) { response.put(srcPath, aresponse); } if (responseController != null) { responseController.fireEvent(new Notification(srcPath, aresponse)); } }
/** * {@inheritDoc} */ @Override public EventController changeHandler() { if (eventController == null) { eventController = new EventController(); } return eventController; } }
/** * constructor * * @param ovalue orginal value to be bound to this wrapper instance. the value is holding an enum * @param enumValues enumeration values */ public OptionsWrapper(IValueAccess<E> ovalue, E[] enumValues) { super(); assert enumValues.length <= ATTR_NAMES.length : "maximum count of "+ ATTR_NAMES.length + " enumeration values exceeded"; this.enumerations = enumValues; this.ovalue = ovalue; /* * if the value was set from outside, we listen to it to refresh our wrapper and * perhaps other data-bound values */ ovalue.changeHandler().addListener(new IListener<ChangeEvent>() { @SuppressWarnings("unchecked") @Override public void handleEvent(ChangeEvent event) { if (!changingValue) { Object value = event.getSource(); BeanValue.getBeanValue(OptionsWrapper.this, ATTR_NAMES[indexOf((E) value)]).setValue(true); } } }); }
cons.addAll(evalTimedConsiliums(cons, timer.from, timer.until)); CommandManager cmdManager = new CommandManager(); getEventController().fireEvent(cons.size()); for (IConsilium c : cons) { if (stop.get()) { eventController.fireEvent(STOPPED); break; eventController.fireEvent(c); log("expired: " + c.getName() + " with timer: "+ c.getTimer()); cmdManager.doIt(c.getExsecutios().toArray(new ICommand[0])); c.setStatus(Status.ACTIVE); c.refreshSeal(ID); eventController.fireEvent(c); } catch (Exception ex) { LOG.error(ex); eventController.fireEvent(ex); eventController.fireEvent(FINISHED); log("processing finished"); log("------------------------------------------------------------------------------");
@Override public EventController changeHandler() { if (eventController == null) { eventController = new EventController(); } return eventController; }
/** * convenience method add a listener to all enumvalues. * * @param wrapper wrapper instance to have an instance using booleans for each enum type that was selected. * @param listener user defined listener to act on selection changes. * @param enumConstants enum constants */ protected void setEnumBooleanListener(OptionsWrapper<?> wrapper, IListener<ChangeEvent> listener, Enum[] enumConstants) { for (int i = 0; i < enumConstants.length; i++) { LOG.debug("adding valuechange-listener for attribute: " + OptionsWrapper.ATTR_NAMES[i]); BeanValue.getBeanValue(wrapper, OptionsWrapper.ATTR_NAMES[i]).changeHandler().addListener(listener); //TODO: listener bei dispose evtl. wieder abbauen! } }