Refine search
/** * Get the name of this EventSet */ public String getName() { return descriptor.getName(); }
throw new GroovyRuntimeException("exception during bean introspection", pae.getException()); PropertyDescriptor[] descriptors = info.getPropertyDescriptors(); EventSetDescriptor[] eventDescriptors = info.getEventSetDescriptors(); for (EventSetDescriptor descriptor : eventDescriptors) { Method[] listenerMethods = descriptor.getListenerMethods(); for (Method listenerMethod : listenerMethods) { final MetaMethod metaMethod = CachedMethod.find(descriptor.getAddListenerMethod());
public EventSetDescriptor[] getEventSetDescriptors() { try { Method[] events = StrangeEventListener.class.getMethods(); Method addListener = StrangeBean.class.getMethod("addStrangeEventListener", new Class[] {StrangeEventListener.class}); Method removeListener = StrangeBean.class.getMethod("removeStrangeEventListener", new Class[] {StrangeEventListener.class}); Method getListeners = StrangeBean.class.getMethod("getStrangeEventListeners", new Class[0]); return new EventSetDescriptor[] { new EventSetDescriptor( "strangeEvent", StrangeEventListener.class, events, addListener, removeListener, getListeners) }; } catch (Exception e) { e.printStackTrace(System.out); return super.getEventSetDescriptors(); } } }
setNameSilently(getNameForBean()); BeanDescriptor descriptor = beanInfo.getBeanDescriptor(); String sd = descriptor.getShortDescription(); EventSetDescriptor[] eventSetDescriptors = beanInfo.getEventSetDescriptors(); int i; int k = eventSetDescriptors.length; method = eventSetDescriptors[i].getAddListenerMethod(); propertyChangeListener = new PropL(); method.invoke(o, new Object[] { WeakListeners.propertyChange(propertyChangeListener, o) }); removePCLMethod = eventSetDescriptors[i].getRemoveListenerMethod(); } catch (Exception e) { for (Enumeration e = beanInfo.getBeanDescriptor().attributeNames(); e.hasMoreElements();) { String aname = (String) e.nextElement(); setValue(aname, beanInfo.getBeanDescriptor().getValue(aname));
try { PropertyDescriptor actionDescriptor = null; PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (int i = 0; i < propertyDescriptors.length && actionDescriptor == null; i++) { if (propertyDescriptors[i].getName().equals("action")) //NOI18N new EventSetDescriptor("action", Action.class, //NOI18N new Method[] {Action.class.getMethod("action", new Class[] {})}, //NOI18N null, null); actionEventDescriptor.setDisplayName( DesignMessageUtil.getMessage(DesignUtil.class, "DesignUtil.event.action")); actionEventDescriptor.setValue(Constants.EventSetDescriptor.BINDING_PROPERTY, actionDescriptor); actionEventDescriptor.setShortDescription(actionDescriptor.getShortDescription()); return new EventSetDescriptor[] {actionEventDescriptor}; } catch (Exception e) {
EventSetDescriptor[] eventSets = info.getEventSetDescriptors(); EventSetDescriptor eventSet = (EventSetDescriptor) decodeObject(eventSets, eventSetId, FeatureDescriptorComparator.INSTANCE); Method[] methods = eventSet.getListenerMethods(); Method method = decodeObject(methods, methodId, MethodComparator.INSTANCE); return new EventSetDescriptor(eventSet.getName(), eventSet.getListenerType(), new Method[] {method}, eventSet.getAddListenerMethod(), eventSet.getRemoveListenerMethod(), eventSet.getGetListenerMethod());
/** * Get the descriptor for an event set of this bean indicated by the event set name. * * @param name the event set name to lookup * @return The EventSetDescriptor for the given event set */ public EventSetDescriptor getEventSetDescriptor(String name) { EventSetDescriptor[] esds = beanInfo.getEventSetDescriptors(); for (int i = 0; i < esds.length; i++) { if (esds[i].getName().equals(name)) return esds[i]; } return null; }
public static EventSetDescriptor getPropertyChangeListenerDescriptor(Class beanClass) { try { // check that the bean is listenable, otherwise, can't use // the validator on it BeanInfo infos = Introspector.getBeanInfo(beanClass); EventSetDescriptor[] events = infos.getEventSetDescriptors(); for (EventSetDescriptor event : events) { if ("propertyChange".equals(event.getName())) { if (event.getAddListenerMethod() == null) { // no property event listener, so can not use the validator throw new IllegalStateException("no addPropertyChangeListener method found for " + beanClass); } if (event.getRemoveListenerMethod() == null) { // no property event listener, so can not use the validator throw new IllegalStateException("no removePropertyChangeListener method found for " + beanClass); } return event; } } // no property event listener, so can not use the validator throw new IllegalStateException("no PropertyChangeListener access method found for " + beanClass); } catch (IntrospectionException ex) { throw new IllegalStateException("could not acquire PropertyChangeListener bean info for " + beanClass + " for reason " + ex.getMessage(), ex); } } }
/** * Start listening to the source object */ private void listenToSource() { try { if (source != null) { BeanInfo info = getBeanInfo(source.getClass(), source); EventSetDescriptor[] events = info.getEventSetDescriptors(); for (int i = 0; i < events.length; ++i) { EventSetDescriptor event = events[i]; Class listenerType = event.getListenerType(); Object listenerObj = this; if (listenerType.isInstance(listenerObj)) { Method method = event.getAddListenerMethod(); method.invoke(source, new Object[] { listenerObj }); } } } } catch (Exception err) { PropertyValueControl.theLogger.error("An error occurred", err); } }
public static EventSetDescriptor getDescriptor(BeanInfo beanInfo, String eventSetName, String listenerMethodName) { checkNotNull(beanInfo, "beanInfo"); checkNotNull(eventSetName, "eventSetName"); checkNotNull(listenerMethodName, "listenerMethodName"); EventSetDescriptor descriptor = getDescriptor(beanInfo, eventSetName); MethodDescriptor listenerMethodDescriptor = BeanUtils.getListenerMethodDescriptor(descriptor, listenerMethodName); Method[] listenerMethods = new Method[] {listenerMethodDescriptor.getMethod()}; try { return new EventSetDescriptor(descriptor.getName(), descriptor.getListenerType(), listenerMethods, descriptor.getAddListenerMethod(), descriptor.getRemoveListenerMethod(), descriptor.getGetListenerMethod()); } catch (IntrospectionException exception) { throw new BeanException("Cannot construct event set descriptor", exception); } }
boolean supportsPropertyChangeListener = false; BeanInfo info = Introspector.getBeanInfo(Bean.class); EventSetDescriptor[] descriptors = info.getEventSetDescriptors(); for (EventSetDescriptor descriptor : descriptors) { if (descriptor.getListenerType().equals(PropertyChangeListener.class)) { supportsPropertyChangeListener = true; } } System.out.println(supportsPropertyChangeListener);
/** * Get the descriptor for an event set of this bean indicated by the event set's adder method * name. * * @param adderName Event set adder method name. * @return The EventSetDescriptor for the given event set */ public EventSetDescriptor getEventSetDescriptorForAdder(String adderName) { EventSetDescriptor[] esds = beanInfo.getEventSetDescriptors(); for (int i = 0; i < esds.length; i++) { java.lang.reflect.Method m = esds[i].getAddListenerMethod(); if (m != null && m.getName().equals(adderName)) return esds[i]; } return null; }
/** * Stop listening to the source object */ private void stopListeningToSource() { try { if (source != null) { BeanInfo info = getBeanInfo(source.getClass(), source); EventSetDescriptor[] events = info.getEventSetDescriptors(); Object listenerObj = this; for (int i = 0; i < events.length; ++i) { EventSetDescriptor event = events[i]; Class listenerType = event.getListenerType(); if (listenerType.isInstance(listenerObj)) { Method method = event.getRemoveListenerMethod(); method.invoke(source, new Object[] { this }); } } } } catch (Exception err) { PropertyValueControl.theLogger.error("An error occurred", err); } }
builder.append("name=").append(descriptor.getName()); if (descriptor.getAddListenerMethod() != null) builder.append(",").append("addMethod=").append(descriptor.getAddListenerMethod().getName()); if (descriptor.getRemoveListenerMethod() != null) builder.append(",").append("removeMethod=").append(descriptor.getRemoveListenerMethod().getName()); if (descriptor.getGetListenerMethod() != null) builder.append(",").append("getMethod=").append(descriptor.getGetListenerMethod().getName()); Method[] listenerMethods = descriptor.getListenerMethods();
private int encodeEventSetDescriptor(EventSetDescriptor eventSet, Class<?> beanClass) { BeanInfo info = BeanUtils.getBeanInfo(beanClass); EventSetDescriptor[] eventSets = info.getEventSetDescriptors(); int eventSetId = encodeObject(eventSets, eventSet, FeatureDescriptorComparator.INSTANCE); if (eventSetId == -1) { return -1; } Method[] methods = eventSet.getListenerType().getMethods(); Method method = eventSet.getListenerMethods()[0]; int methodId = encodeObject(methods, method, MethodComparator.INSTANCE); if (methodId == -1) { return -1; } // TODO: allow customisation of number of bits return (eventSetId << 4) | methodId; }
m_target = target; m_eventName = esd.getName(); esd.getAddListenerMethod(); Object targetBean = m_target.getBean(); Class<?> listenerClass = esd.getListenerType(); if (listenerClass.isInstance(targetBean)) { try { ((BeanCommon) targetBean).connectionNotification(esd.getName(), m_source.getBean());
public static void removeListener(Object bean, EventSetDescriptor eventSetDescriptor, EventListener listener) { Method method = eventSetDescriptor.getRemoveListenerMethod(); try { method.invoke(bean, new Object[] {listener}); } catch (IllegalAccessException exception) { throw new BeanException("Cannot remove event set listener: " + eventSetDescriptor.getName(), exception); } catch (InvocationTargetException exception) { throw new BeanException("Cannot remove event set listener: " + eventSetDescriptor.getName(), exception); } }
public static boolean equals(EventSetDescriptor descriptor1, EventSetDescriptor descriptor2) { if (descriptor1 == descriptor2) { return true; } // TODO: check all properties return nullEquals(descriptor1.getAddListenerMethod(), descriptor2.getAddListenerMethod()) && nullEquals(descriptor1.getRemoveListenerMethod(), descriptor2.getRemoveListenerMethod()) && nullEquals(descriptor1.getGetListenerMethod(), descriptor2.getGetListenerMethod()) && Arrays.equals(descriptor1.getListenerMethods(), descriptor2.getListenerMethods()) && descriptor1.isUnicast() == descriptor2.isUnicast(); }
public static void addListener(Object bean, EventSetDescriptor eventSetDescriptor, EventListener listener) { Method method = eventSetDescriptor.getAddListenerMethod(); try { method.invoke(bean, listener); } catch (IllegalAccessException exception) { throw new BeanException("Cannot add event set listener: " + eventSetDescriptor.getName(), exception); } catch (InvocationTargetException exception) { throw new BeanException("Cannot add event set listener: " + eventSetDescriptor.getName(), exception); } }
Method eventMethod = eventSetDescriptor.getListenerMethods()[0]; throw new BeanException("Cannot fire event set: " + eventSetDescriptor.getName(), exception); throw new BeanException("Cannot fire event set: " + eventSetDescriptor.getName(), exception);