Source for java.beans.EventSetDescriptor

   1: /* java.beans.EventSetDescriptor
   2:  Copyright (C) 1998, 2006 Free Software Foundation, Inc.
   3: 
   4:  This file is part of GNU Classpath.
   5: 
   6:  GNU Classpath is free software; you can redistribute it and/or modify
   7:  it under the terms of the GNU General Public License as published by
   8:  the Free Software Foundation; either version 2, or (at your option)
   9:  any later version.
  10: 
  11:  GNU Classpath is distributed in the hope that it will be useful, but
  12:  WITHOUT ANY WARRANTY; without even the implied warranty of
  13:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14:  General Public License for more details.
  15: 
  16:  You should have received a copy of the GNU General Public License
  17:  along with GNU Classpath; see the file COPYING.  If not, write to the
  18:  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19:  02110-1301 USA.
  20: 
  21:  Linking this library statically or dynamically with other modules is
  22:  making a combined work based on this library.  Thus, the terms and
  23:  conditions of the GNU General Public License cover the whole
  24:  combination.
  25: 
  26:  As a special exception, the copyright holders of this library give you
  27:  permission to link this library with independent modules to produce an
  28:  executable, regardless of the license terms of these independent
  29:  modules, and to copy and distribute the resulting executable under
  30:  terms of your choice, provided that you also meet, for each linked
  31:  independent module, the terms and conditions of the license of that
  32:  module.  An independent module is a module which is not derived from
  33:  or based on this library.  If you modify this library, you may extend
  34:  this exception to your version of the library, but you are not
  35:  obligated to do so.  If you do not wish to do so, delete this
  36:  exception statement from your version. */
  37: 
  38: 
  39: package java.beans;
  40: 
  41: import gnu.java.lang.ClassHelper;
  42: 
  43: import java.lang.reflect.Method;
  44: import java.lang.reflect.Modifier;
  45: import java.util.Vector;
  46: 
  47: /**
  48:  * EventSetDescriptor describes the hookup between an event source class and
  49:  * an event listener class.
  50:  *
  51:  * <p>EventSets have several attributes: the listener class,
  52:  * the events that can be fired to the listener (methods in the listener
  53:  * class), and an add and remove listener method from the event firer's
  54:  * class.
  55:  * </p>
  56:  *
  57:  * <p>
  58:  * The methods have these constraints on them:
  59:  * <ul>
  60:  * <li>event firing methods: must have <code>void</code> return value. Any
  61:  * parameters and exceptions are allowed. May be public, protected or
  62:  * package-protected. (Don't ask me why that is, I'm just following the spec.
  63:  * The only place it is even mentioned is in the Java Beans white paper, and
  64:  * there it is only implied.)</li>
  65:  *
  66:  * <li>add listener method: must have <code>void</code> return value. Must
  67:  * take exactly one argument, of the listener class's type. May fire either
  68:  * zero exceptions, or one exception of type
  69:  * <code>java.util.TooManyListenersException</code>.
  70:  * Must be public.</li>
  71:  *
  72:  * <li>remove listener method: must have <code>void</code> return value. Must
  73:  * take exactly one argument, of the listener class's type. May not fire any
  74:  * exceptions. Must be public.</li>
  75:  * </ul>
  76:  *
  77:  * <p>
  78:  * A final constraint is that event listener classes must extend from
  79:  * EventListener.
  80:  * </p>
  81:  *
  82:  * <p>
  83:  * There are also various design patterns associated with some of the methods
  84:  * of construction. Those are explained in more detail in the appropriate
  85:  * constructors.
  86:  * </p>
  87:  *
  88:  * <p>
  89:  * <strong>Documentation Convention:</strong> for proper Internalization of
  90:  * Beans inside an RAD tool, sometimes there are two names for a property or
  91:  * method: a programmatic, or locale-independent name, which can be used
  92:  * anywhere, and a localized, display name, for ease of use. In the
  93:  * documentation I will specify different String values as either
  94:  * <em>programmatic</em> or <em>localized</em> to make this distinction clear.
  95:  *
  96:  * @author John Keiser
  97:  * @author Robert Schuster (robertschuster@fsfe.org)
  98:  * @since 1.1
  99:  */
 100: 
 101: public class EventSetDescriptor extends FeatureDescriptor
 102: {
 103:   private Method addListenerMethod;
 104: 
 105:   private Method removeListenerMethod;
 106: 
 107:   private Class listenerType;
 108: 
 109:   private MethodDescriptor[] listenerMethodDescriptors;
 110: 
 111:   private Method[] listenerMethods;
 112: 
 113:   private Method getListenerMethod;
 114: 
 115:   private boolean unicast;
 116: 
 117:   private boolean inDefaultEventSet = true;
 118: 
 119:   /**
 120:    * Creates a new <code>EventSetDescriptor</code<.
 121:    *
 122:    * <p>
 123:    * This version of the constructor enforces the rules imposed on the methods
 124:    * described at the top of this class, as well as searching for:
 125:    * </p>
 126:    *
 127:    * <ol>
 128:    * <li>
 129:    * The event-firing method must be non-private with signature <code>void
 130:    * &lt;listenerMethodName&gt;(&lt;eventSetName&gt;Event)</code> (where
 131:    * <code>&lt;eventSetName&gt;</code> has its first character capitalized
 132:    * by the constructor and the Event is a descendant of
 133:    * {@link java.util.EventObject}) in class <code>listenerType</code>
 134:    * (any exceptions may be thrown). <b>Implementation note:</b> Note that
 135:    * there could conceivably be multiple methods with this type of signature
 136:    * (example: <code>java.util.MouseEvent</code> vs.
 137:    * <code>my.very.own.MouseEvent</code>). In this implementation, all
 138:    * methods fitting the description will be put into the
 139:    * <code>EventSetDescriptor</code>, even though the spec says only one
 140:    * should be chosen (they probably weren't thinking as pathologically as I
 141:    * was). I don't like arbitrarily choosing things. If your class has only one
 142:    * such signature, as most do, you'll have no problems.</li>
 143:    *
 144:    * <li>The add and remove methods must be public and named <code>void
 145:    * add&lt;eventSetName&gt;Listener(&lt;listenerType&gt;)</code> and
 146:    * <code>void remove&lt;eventSetName&gt;Listener(&lt;listenerType&gt;)</code>
 147:    * in in class <code>eventSourceClass</code>, where
 148:    * <code>&lt;eventSetName&gt;</code> will have its first letter capitalized.
 149:    * Standard exception rules (see class description) apply.</li>
 150:    * </ol>
 151:    *
 152:    * @param eventSourceClass
 153:    *          the class containing the add/remove listener methods.
 154:    * @param eventSetName
 155:    *          the programmatic name of the event set, generally starting with a
 156:    *          lowercase letter (i.e. fooManChu instead of FooManChu). This will
 157:    *          be used to generate the name of the event object as well as the
 158:    *          names of the add and remove methods.
 159:    * @param listenerType
 160:    *          the class containing the event firing method.
 161:    * @param listenerMethodName
 162:    *          the name of the event firing method.
 163:    * @exception IntrospectionException
 164:    *              if listenerType is not an EventListener, or if methods are not
 165:    *              found or are invalid.
 166:    */
 167:   public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
 168:                             Class<?> listenerType, String listenerMethodName)
 169:       throws IntrospectionException
 170:   {
 171:     setName(eventSetName);
 172:     if (!java.util.EventListener.class.isAssignableFrom(listenerType))
 173:       {
 174:         throw new IntrospectionException(
 175:                   "Listener type is not an EventListener.");
 176:       }
 177: 
 178:     String[] names = new String[1];
 179:     names[0] = listenerMethodName;
 180: 
 181:     try
 182:       {
 183:         eventSetName = Character.toUpperCase(eventSetName.charAt(0))
 184:                        + eventSetName.substring(1);
 185:       }
 186:     catch (StringIndexOutOfBoundsException e)
 187:       {
 188:         eventSetName = "";
 189:       }
 190: 
 191:     findMethods(eventSourceClass, listenerType, names,
 192:                 "add" + eventSetName + "Listener",
 193:                 "remove" + eventSetName + "Listener", eventSetName + "Event");
 194:     this.listenerType = listenerType;
 195:     checkAddListenerUnicast();
 196:     if (this.removeListenerMethod.getExceptionTypes().length > 0)
 197:       {
 198:         throw new IntrospectionException(
 199:                   "Listener remove method throws exceptions.");
 200:       }
 201:   }
 202: 
 203:   /**
 204:    * Creates a new <code>EventSetDescriptor</code>.
 205:    *
 206:    * <p>This form of the constructor allows you to specify the names of the
 207:    * methods and adds no new constraints on top of the rules already described
 208:    * at the top of the class.
 209:    * </p>
 210:    *
 211:    * @param eventSourceClass
 212:    *          the class containing the add and remove listener methods.
 213:    * @param eventSetName
 214:    *          the programmatic name of the event set, generally starting with a
 215:    *          lowercase letter (i.e. fooManChu instead of FooManChu).
 216:    * @param listenerType
 217:    *          the class containing the event firing methods.
 218:    * @param listenerMethodNames
 219:    *          the names of the even firing methods.
 220:    * @param addListenerMethodName
 221:    *          the name of the add listener method.
 222:    * @param removeListenerMethodName
 223:    *          the name of the remove listener method.
 224:    * @exception IntrospectionException
 225:    *              if listenerType is not an EventListener or if methods are not
 226:    *              found or are invalid.
 227:    */
 228:   public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
 229:                             Class<?> listenerType, String[] listenerMethodNames,
 230:                             String addListenerMethodName,
 231:                             String removeListenerMethodName)
 232:       throws IntrospectionException
 233:   {
 234:     setName(eventSetName);
 235:     if (!java.util.EventListener.class.isAssignableFrom(listenerType))
 236:       {
 237:         throw new IntrospectionException(
 238:                   "Listener type is not an EventListener.");
 239:       }
 240: 
 241:     findMethods(eventSourceClass, listenerType, listenerMethodNames,
 242:                 addListenerMethodName, removeListenerMethodName, null);
 243:     this.listenerType = listenerType;
 244:     checkAddListenerUnicast();
 245:     if (this.removeListenerMethod.getExceptionTypes().length > 0)
 246:       {
 247:         throw new IntrospectionException(
 248:                   "Listener remove method throws exceptions.");
 249:       }
 250:   }
 251: 
 252:   /**
 253:    * Creates a new <code>EventSetDescriptor</code>.
 254:    *
 255:    * <p>
 256:    * This variant of the constructor allows you to specify the names of the
 257:    * methods and adds no new constraints on top of the rules already described
 258:    * at the top of the class.
 259:    * </p>
 260:    * <p>
 261:    * A valid GetListener method is public, flags no exceptions and has one
 262:    * argument which is of type <code>Class</code>
 263:    * {@link java.awt.Component#getListeners(Class)} is such a method.
 264:    * </p>
 265:    * <p>
 266:    * Note: The validity of the return value of the GetListener method is not
 267:    * checked.
 268:    * </p>
 269:    *
 270:    * @param eventSourceClass
 271:    *          the class containing the add and remove listener methods.
 272:    * @param eventSetName
 273:    *          the programmatic name of the event set, generally starting with a
 274:    *          lowercase letter (i.e. fooManChu instead of FooManChu).
 275:    * @param listenerType
 276:    *          the class containing the event firing methods.
 277:    * @param listenerMethodNames
 278:    *          the names of the even firing methods.
 279:    * @param addListenerMethodName
 280:    *          the name of the add listener method.
 281:    * @param removeListenerMethodName
 282:    *          the name of the remove listener method.
 283:    * @param getListenerMethodName
 284:    *          Name of a method which returns the array of listeners.
 285:    * @exception IntrospectionException
 286:    *              if listenerType is not an EventListener or if methods are not
 287:    *              found or are invalid.
 288:    * @since 1.4
 289:    */
 290:   public EventSetDescriptor(Class<?> eventSourceClass, String eventSetName,
 291:                             Class<?> listenerType, String[] listenerMethodNames,
 292:                             String addListenerMethodName,
 293:                             String removeListenerMethodName,
 294:                             String getListenerMethodName)
 295:       throws IntrospectionException
 296:   {
 297:     this(eventSourceClass, eventSetName, listenerType, listenerMethodNames,
 298:          addListenerMethodName, removeListenerMethodName);
 299: 
 300:     Method newGetListenerMethod = null;
 301: 
 302:     try
 303:       {
 304:         newGetListenerMethod
 305:           = eventSourceClass.getMethod(getListenerMethodName,
 306:                                        new Class[] { Class.class });
 307:       }
 308:     catch (NoSuchMethodException nsme)
 309:       {
 310:         throw (IntrospectionException)
 311:           new IntrospectionException("No method named " + getListenerMethodName
 312:                                       + " in class " + listenerType
 313:                                       + " which can be used as"
 314:                                       + " getListenerMethod.").initCause(nsme);
 315:       }
 316: 
 317:     // Note: This does not check the return value (which
 318:     // should be EventListener[]) but the JDK does not either.
 319: 
 320:     getListenerMethod = newGetListenerMethod;
 321: 
 322:   }
 323: 
 324:   /**
 325:    * Creates a new <code>EventSetDescriptor.</code>
 326:    *
 327:    * <p>
 328:    * This variant of the constructor allows you to specify the names of the
 329:    * methods and adds no new constraints on top of the rules already described
 330:    * at the top of the class.
 331:    * </p>
 332:    * <p>
 333:    * A valid GetListener method is public, flags no exceptions and has one
 334:    * argument which is of type <code>Class</code>
 335:    * {@link java.awt.Component#getListeners(Class)} is such a method.
 336:    * </p>
 337:    * <p>
 338:    * Note: The validity of the return value of the GetListener method is not
 339:    * checked.
 340:    * </p>
 341:    *
 342:    * @param eventSetName
 343:    *          the programmatic name of the event set, generally starting with a
 344:    *          lowercase letter (i.e. fooManChu instead of FooManChu).
 345:    * @param listenerType
 346:    *          the class containing the listenerMethods.
 347:    * @param listenerMethods
 348:    *          the event firing methods.
 349:    * @param addListenerMethod
 350:    *          the add listener method.
 351:    * @param removeListenerMethod
 352:    *          the remove listener method.
 353:    * @param getListenerMethod
 354:    *          The method which returns an array of the listeners.
 355:    * @exception IntrospectionException
 356:    *              if the listenerType is not an EventListener, or any of the
 357:    *              methods are invalid.
 358:    * @since 1.4
 359:    */
 360:   public EventSetDescriptor(String eventSetName, Class<?> listenerType,
 361:                             Method[] listenerMethods, Method addListenerMethod,
 362:                             Method removeListenerMethod,
 363:                             Method getListenerMethod)
 364:       throws IntrospectionException
 365:   {
 366:     this(eventSetName, listenerType, listenerMethods, addListenerMethod,
 367:          removeListenerMethod);
 368: 
 369:     // Do no checks if the getListenerMethod is null.
 370:     if (getListenerMethod.getParameterTypes().length != 1
 371:         || getListenerMethod.getParameterTypes()[0] != Class.class
 372:         || getListenerMethod.getExceptionTypes().length > 0
 373:         || !Modifier.isPublic(getListenerMethod.getModifiers()))
 374:       throw new IntrospectionException("GetListener method is invalid.");
 375: 
 376:     // Note: This does not check the return value (which
 377:     // should be EventListener[]) but the JDK does not either.
 378: 
 379:     this.getListenerMethod = getListenerMethod;
 380:   }
 381: 
 382:   /**
 383:    * Creates a new <code>EventSetDescriptor</code>.
 384:    *
 385:    * <p>This form of constructor allows you to explicitly say which methods
 386:    * do what, and no reflection is done by the <code>EventSetDescriptor</code>.
 387:    * The methods are, however, checked to ensure that they follow the rules
 388:    * set forth at the top of the class.
 389:    *
 390:    * @param eventSetName
 391:    *          the programmatic name of the event set, generally starting with a
 392:    *          lowercase letter (i.e. fooManChu instead of FooManChu).
 393:    * @param listenerType
 394:    *          the class containing the listenerMethods.
 395:    * @param listenerMethods
 396:    *          the event firing methods.
 397:    * @param addListenerMethod
 398:    *          the add listener method.
 399:    * @param removeListenerMethod
 400:    *          the remove listener method.
 401:    * @exception IntrospectionException
 402:    *              if the listenerType is not an EventListener, or any of the
 403:    *              methods are invalid.
 404:    */
 405:   public EventSetDescriptor(String eventSetName, Class<?> listenerType,
 406:                             Method[] listenerMethods, Method addListenerMethod,
 407:                             Method removeListenerMethod)
 408:       throws IntrospectionException
 409:   {
 410:     setName(eventSetName);
 411:     if (!java.util.EventListener.class.isAssignableFrom(listenerType))
 412:       {
 413:         throw new IntrospectionException(
 414:                   "Listener type is not an EventListener.");
 415:       }
 416: 
 417:     this.listenerMethods = listenerMethods;
 418:     this.addListenerMethod = addListenerMethod;
 419:     this.removeListenerMethod = removeListenerMethod;
 420:     this.listenerType = listenerType;
 421:     checkMethods();
 422:     checkAddListenerUnicast();
 423:     if (this.removeListenerMethod.getExceptionTypes().length > 0)
 424:       {
 425:         throw new IntrospectionException(
 426:                   "Listener remove method throws exceptions.");
 427:       }
 428:   }
 429: 
 430:   /** Creates a new <code>EventSetDescriptor</code>.
 431:    *
 432:    * <p>This form of constructor allows you to explicitly say which methods do
 433:    * what, and no reflection is done by the <code>EventSetDescriptor</code>.
 434:    * The methods are, however, checked to ensure that they follow the rules
 435:    * set forth at the top of the class.
 436:    *
 437:    * @param eventSetName
 438:    *          the programmatic name of the event set, generally starting with a
 439:    *          lowercase letter (i.e. fooManChu instead of FooManChu).
 440:    * @param listenerType
 441:    *          the class containing the listenerMethods.
 442:    * @param listenerMethodDescriptors
 443:    *          the event firing methods.
 444:    * @param addListenerMethod
 445:    *          the add listener method.
 446:    * @param removeListenerMethod
 447:    *          the remove listener method.
 448:    * @exception IntrospectionException
 449:    *              if the listenerType is not an EventListener, or any of the
 450:    *              methods are invalid.
 451:    */
 452:   public EventSetDescriptor(String eventSetName, Class<?> listenerType,
 453:                             MethodDescriptor[] listenerMethodDescriptors,
 454:                             Method addListenerMethod,
 455:                             Method removeListenerMethod)
 456:       throws IntrospectionException
 457:   {
 458:     setName(eventSetName);
 459:     if (!java.util.EventListener.class.isAssignableFrom(listenerType))
 460:       {
 461:         throw new IntrospectionException(
 462:                   "Listener type is not an EventListener.");
 463:       }
 464: 
 465:     this.listenerMethodDescriptors = listenerMethodDescriptors;
 466:     this.listenerMethods = new Method[listenerMethodDescriptors.length];
 467:     for (int i = 0; i < this.listenerMethodDescriptors.length; i++)
 468:       {
 469:         this.listenerMethods[i]
 470:            = this.listenerMethodDescriptors[i].getMethod();
 471:       }
 472: 
 473:     this.addListenerMethod = addListenerMethod;
 474:     this.removeListenerMethod = removeListenerMethod;
 475:     this.listenerType = listenerType;
 476:     checkMethods();
 477:     checkAddListenerUnicast();
 478:     if (this.removeListenerMethod.getExceptionTypes().length > 0)
 479:       {
 480:         throw new IntrospectionException(
 481:                   "Listener remove method throws exceptions.");
 482:       }
 483:   }
 484: 
 485:   /** Returns the class that contains the event firing methods.
 486:    */
 487:   public Class<?> getListenerType()
 488:   {
 489:     return listenerType;
 490:   }
 491: 
 492:   /** Returns the event firing methods.
 493:    */
 494:   public Method[] getListenerMethods()
 495:   {
 496:     return listenerMethods;
 497:   }
 498: 
 499:   /** Returns the event firing methods as {@link MethodDescriptor}.
 500:    */
 501:   public MethodDescriptor[] getListenerMethodDescriptors()
 502:   {
 503:     if (listenerMethodDescriptors == null)
 504:       {
 505:         listenerMethodDescriptors
 506:           = new MethodDescriptor[listenerMethods.length];
 507: 
 508:         for (int i = 0; i < listenerMethods.length; i++)
 509:           {
 510:             listenerMethodDescriptors[i]
 511:               = new MethodDescriptor(listenerMethods[i]);
 512:           }
 513:       }
 514: 
 515:     return listenerMethodDescriptors;
 516:   }
 517: 
 518:   /** Returns the add listener method.
 519:    */
 520:   public Method getAddListenerMethod()
 521:   {
 522:     return addListenerMethod;
 523:   }
 524: 
 525:   /* Returns the remove listener method.
 526:    */
 527:   public Method getRemoveListenerMethod()
 528:   {
 529:     return removeListenerMethod;
 530:   }
 531: 
 532:   /**
 533:    * Returns the method that retrieves the listeners or <code>null</code> if
 534:    * it does not exist.
 535:    */
 536:   public Method getGetListenerMethod()
 537:   {
 538:     return getListenerMethod;
 539:   }
 540: 
 541:   /** Sets whether or not multiple listeners may be added.
 542:    *
 543:    * @param unicast
 544:    *          whether or not multiple listeners may be added.
 545:    */
 546:   public void setUnicast(boolean unicast)
 547:   {
 548:     this.unicast = unicast;
 549:   }
 550: 
 551:   /** Returns whether or not multiple listeners may be added.
 552:    * (Defaults to false.)
 553:    */
 554:   public boolean isUnicast()
 555:   {
 556:     return unicast;
 557:   }
 558: 
 559:   /** Sets whether or not this is in the default event set.
 560:    *
 561:    * @param inDefaultEventSet
 562:    *          whether this is in the default event set.
 563:    */
 564:   public void setInDefaultEventSet(boolean inDefaultEventSet)
 565:   {
 566:     this.inDefaultEventSet = inDefaultEventSet;
 567:   }
 568: 
 569:   /** Returns whether or not this is in the default event set.
 570:    * (Defaults to true.)
 571:    */
 572:   public boolean isInDefaultEventSet()
 573:   {
 574:     return inDefaultEventSet;
 575:   }
 576: 
 577:   private void checkAddListenerUnicast() throws IntrospectionException
 578:   {
 579:     Class[] addListenerExceptions = this.addListenerMethod.getExceptionTypes();
 580:     if (addListenerExceptions.length > 1)
 581:       {
 582:         throw new IntrospectionException(
 583:                   "Listener add method throws too many exceptions.");
 584:       }
 585:     else if (addListenerExceptions.length == 1
 586:              && !java.util.TooManyListenersException.class
 587:                 .isAssignableFrom(addListenerExceptions[0]))
 588:       {
 589:         throw new IntrospectionException(
 590:                   "Listener add method throws too many exceptions.");
 591:       }
 592:   }
 593: 
 594:   private void checkMethods() throws IntrospectionException
 595:   {
 596:     if (!addListenerMethod.getDeclaringClass()
 597:         .isAssignableFrom(removeListenerMethod.getDeclaringClass())
 598:         && !removeListenerMethod.getDeclaringClass()
 599:         .isAssignableFrom(addListenerMethod.getDeclaringClass()))
 600:       {
 601:         throw new IntrospectionException(
 602:                   "add and remove listener methods do not come from the"
 603:                   + " same class.  This is bad.");
 604:       }
 605:     if (!addListenerMethod.getReturnType().equals(java.lang.Void.TYPE)
 606:         || addListenerMethod.getParameterTypes().length != 1
 607:         || !listenerType.equals(addListenerMethod.getParameterTypes()[0])
 608:         || !Modifier.isPublic(addListenerMethod.getModifiers()))
 609:       {
 610:         throw new IntrospectionException("Add Listener Method invalid.");
 611:       }
 612:     if (!removeListenerMethod.getReturnType().equals(java.lang.Void.TYPE)
 613:         || removeListenerMethod.getParameterTypes().length != 1
 614:         || !listenerType.equals(removeListenerMethod.getParameterTypes()[0])
 615:         || removeListenerMethod.getExceptionTypes().length > 0
 616:         || !Modifier.isPublic(removeListenerMethod.getModifiers()))
 617:       {
 618:         throw new IntrospectionException("Remove Listener Method invalid.");
 619:       }
 620: 
 621:     for (int i = 0; i < listenerMethods.length; i++)
 622:       {
 623:         if (!listenerMethods[i].getReturnType().equals(java.lang.Void.TYPE)
 624:             || Modifier.isPrivate(listenerMethods[i].getModifiers()))
 625:           {
 626:             throw new IntrospectionException("Event Method "
 627:                                              + listenerMethods[i].getName()
 628:                                              + " non-void or private.");
 629:           }
 630:         if (!listenerMethods[i].getDeclaringClass()
 631:             .isAssignableFrom(listenerType))
 632:           {
 633:             throw new IntrospectionException("Event Method "
 634:                                              + listenerMethods[i].getName()
 635:                                              + " not from class "
 636:                                              + listenerType.getName());
 637:           }
 638:       }
 639:   }
 640: 
 641:   private void findMethods(Class eventSourceClass, Class listenerType,
 642:                            String listenerMethodNames[],
 643:                            String addListenerMethodName,
 644:                            String removeListenerMethodName,
 645:                            String absurdEventClassCheckName)
 646:       throws IntrospectionException
 647:   {
 648: 
 649:     /* Find add listener method and remove listener method. */
 650:     Class[] listenerArgList = new Class[1];
 651:     listenerArgList[0] = listenerType;
 652:     try
 653:       {
 654:         this.addListenerMethod
 655:           = eventSourceClass.getMethod(addListenerMethodName,
 656:                                        listenerArgList);
 657:       }
 658:     catch (SecurityException E)
 659:       {
 660:         throw new IntrospectionException(
 661:                   "SecurityException trying to access method "
 662:                   + addListenerMethodName + ".");
 663:       }
 664:     catch (NoSuchMethodException E)
 665:       {
 666:         throw new IntrospectionException("Could not find method "
 667:                                          + addListenerMethodName + ".");
 668:       }
 669: 
 670:     if (this.addListenerMethod == null
 671:         || !this.addListenerMethod.getReturnType().equals(java.lang.Void.TYPE))
 672:       {
 673:         throw new IntrospectionException(
 674:                   "Add listener method does not exist, is not public,"
 675:                   + " or is not void.");
 676:       }
 677: 
 678:     try
 679:       {
 680:         this.removeListenerMethod
 681:           = eventSourceClass.getMethod(removeListenerMethodName,
 682:                                        listenerArgList);
 683:       }
 684:     catch (SecurityException E)
 685:       {
 686:         throw new IntrospectionException(
 687:                   "SecurityException trying to access method "
 688:                   + removeListenerMethodName + ".");
 689:       }
 690:     catch (NoSuchMethodException E)
 691:       {
 692:         throw new IntrospectionException("Could not find method "
 693:                                          + removeListenerMethodName + ".");
 694:       }
 695:     if (this.removeListenerMethod == null
 696:         || !this.removeListenerMethod.getReturnType()
 697:            .equals(java.lang.Void.TYPE))
 698:       {
 699:         throw new IntrospectionException(
 700:                   "Remove listener method does not exist, is not public,"
 701:                   + " or is not void.");
 702:       }
 703: 
 704:     /* Find the listener methods. */
 705:     Method[] methods;
 706:     try
 707:       {
 708:         methods = ClassHelper.getAllMethods(listenerType);
 709:       }
 710:     catch (SecurityException E)
 711:       {
 712:         throw new IntrospectionException(
 713:                   "Security: You cannot access fields in this class.");
 714:       }
 715: 
 716:     Vector chosenMethods = new Vector();
 717:     boolean[] listenerMethodFound = new boolean[listenerMethodNames.length];
 718:     for (int i = 0; i < methods.length; i++)
 719:       {
 720:         if (Modifier.isPrivate(methods[i].getModifiers()))
 721:           {
 722:             continue;
 723:           }
 724:         Method currentMethod = methods[i];
 725:         Class retval = currentMethod.getReturnType();
 726:         if (retval.equals(java.lang.Void.TYPE))
 727:           {
 728:             for (int j = 0; j < listenerMethodNames.length; j++)
 729:               {
 730:                 if (currentMethod.getName().equals(listenerMethodNames[j])
 731:                     && (absurdEventClassCheckName == null
 732:                     || (currentMethod.getParameterTypes().length == 1
 733:                     && ((currentMethod.getParameterTypes()[0])
 734:                         .getName().equals(absurdEventClassCheckName)
 735:                     || (currentMethod.getParameterTypes()[0])
 736:                        .getName().endsWith("." + absurdEventClassCheckName)))))
 737:                   {
 738:                     chosenMethods.addElement(currentMethod);
 739:                     listenerMethodFound[j] = true;
 740:                   }
 741:               }
 742:           }
 743:       }
 744: 
 745:     /* Make sure we found all the methods we were looking for. */
 746:     for (int i = 0; i < listenerMethodFound.length; i++)
 747:       {
 748:         if (!listenerMethodFound[i])
 749:           {
 750:             throw new IntrospectionException("Could not find event method "
 751:                                              + listenerMethodNames[i]);
 752:           }
 753:       }
 754: 
 755:     /* Now that we've chosen the listener methods we want, store them. */
 756:     this.listenerMethods = new Method[chosenMethods.size()];
 757:     for (int i = 0; i < chosenMethods.size(); i++)
 758:       {
 759:         this.listenerMethods[i] = (Method) chosenMethods.elementAt(i);
 760:       }
 761:   }
 762: 
 763: }