1 /* 2 * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.java.accessibility.util; 27 28 import java.util.*; 29 import java.beans.*; 30 import java.awt.*; 31 import java.awt.event.*; 32 import javax.swing.*; 33 import javax.swing.event.*; 34 import javax.swing.table.*; 35 import javax.swing.tree.*; 36 import javax.swing.text.*; 37 import javax.swing.undo.*; 38 import javax.accessibility.*; 39 40 41 /** 42 * <P>{@code SwingEventMonitor} extends {@link AWTEventMonitor} by adding a suite of 43 * listeners conditionally installed on every Swing component instance 44 * in the Java Virtual Machine. The events captured by these listeners 45 * are made available through a unified set of listeners supported by 46 * {@code SwingEventMonitor}. With this, all the individual events on each of the 47 * AWT and Swing component instances are funneled into one set of listeners 48 * broken down by category (see {@link EventID} for the categories). 49 * <p>This class depends upon {@link EventQueueMonitor}, which provides the base 50 * level support for capturing the top-level containers as they are created. 51 * <p>Because this class extends {@code AWTEventMonitor}, it is not 52 * necessary to use this class and {@code AWTEventMonitor} at the same time. 53 * If you want to monitor both AWT and Swing components, you should 54 * use just this class. 55 * 56 * @see AWTEventMonitor 57 * 58 */ 59 public class SwingEventMonitor extends AWTEventMonitor { 60 61 /** 62 * The master list of all listeners registered by other classes. 63 * This can only be publicly modified by calling the add or 64 * remove listener methods in this class. 65 */ 66 static protected final EventListenerList listenerList = new EventListenerList(); 67 68 /** 69 * The actual listener that is installed on the component instances. 70 * This listener calls the other registered listeners when an event 71 * occurs. By doing things this way, the actual number of listeners 72 * installed on a component instance is drastically reduced. 73 */ 74 static private final SwingEventListener swingListener = new SwingEventListener(); 75 76 /** 77 * Adds the specified listener to receive all {@link EventID#ANCESTOR ANCESTOR} 78 * events on each component instance in the Java Virtual Machine as they occur. 79 * <P>Note: This listener is automatically added to all component 80 * instances created after this method is called. In addition, it 81 * is only added to component instances that support this listener type. 82 * 83 * @param l the listener to add 84 * @see #removeAncestorListener 85 */ addAncestorListener(AncestorListener l)86 static public void addAncestorListener(AncestorListener l) { 87 if (listenerList.getListenerCount(AncestorListener.class) == 0) { 88 swingListener.installListeners(EventID.ANCESTOR); 89 } 90 listenerList.add(AncestorListener.class, l); 91 } 92 93 /** 94 * Removes the specified listener so it no longer receives 95 * {@link EventID#ANCESTOR ANCESTOR} events when they occur. 96 * 97 * @param l the listener to remove 98 * @see #addAncestorListener 99 */ removeAncestorListener(AncestorListener l)100 static public void removeAncestorListener(AncestorListener l) { 101 listenerList.remove(AncestorListener.class, l); 102 if (listenerList.getListenerCount(AncestorListener.class) == 0) { 103 swingListener.removeListeners(EventID.ANCESTOR); 104 } 105 } 106 107 /** 108 * Adds the specified listener to receive all {@link EventID#CARET CARET} events 109 * on each component instance in the Java Virtual Machine as they occur. 110 * <P>Note: This listener is automatically added to all component 111 * instances created after this method is called. In addition, it 112 * is only added to component instances that support this listener type. 113 * 114 * @param l the listener to add 115 * @see #removeCaretListener 116 */ addCaretListener(CaretListener l)117 static public void addCaretListener(CaretListener l) { 118 if (listenerList.getListenerCount(CaretListener.class) == 0) { 119 swingListener.installListeners(EventID.CARET); 120 } 121 listenerList.add(CaretListener.class, l); 122 } 123 124 /** 125 * Removes the specified listener so it no longer receives 126 * {@link EventID#CARET CARET} events when they occur. 127 * 128 * @param l the listener to remove 129 * @see #addCaretListener 130 */ removeCaretListener(CaretListener l)131 static public void removeCaretListener(CaretListener l) { 132 listenerList.remove(CaretListener.class, l); 133 if (listenerList.getListenerCount(CaretListener.class) == 0) { 134 swingListener.removeListeners(EventID.CARET); 135 } 136 } 137 138 /** 139 * Adds the specified listener to receive all 140 * {@link EventID#CELLEDITOR CELLEDITOR} events on each 141 * component instance in the Java Virtual Machine as they occur. 142 * <P>Note: This listener is automatically added to all component 143 * instances created after this method is called. In addition, it 144 * is only added to component instances that support this listener type. 145 * 146 * @param l the listener to add 147 * @see #removeCellEditorListener 148 */ addCellEditorListener(CellEditorListener l)149 static public void addCellEditorListener(CellEditorListener l) { 150 if (listenerList.getListenerCount(CellEditorListener.class) == 0) { 151 swingListener.installListeners(EventID.CELLEDITOR); 152 } 153 listenerList.add(CellEditorListener.class, l); 154 } 155 156 /** 157 * Removes the specified listener so it no longer receives 158 * {@link EventID#CELLEDITOR CELLEDITOR} events when they occur. 159 * 160 * @param l the listener to remove 161 * @see #addCellEditorListener 162 */ removeCellEditorListener(CellEditorListener l)163 static public void removeCellEditorListener(CellEditorListener l) { 164 listenerList.remove(CellEditorListener.class, l); 165 if (listenerList.getListenerCount(CellEditorListener.class) == 0) { 166 swingListener.removeListeners(EventID.CELLEDITOR); 167 } 168 } 169 170 /** 171 * Adds the specified listener to receive all {@link EventID#CHANGE CHANGE} 172 * events on each component instance in the Java Virtual Machine as they occur. 173 * <P>Note: This listener is automatically added to all component 174 * instances created after this method is called. In addition, it 175 * is only added to component instances that support this listener type. 176 * 177 * @param l the listener to add 178 * @see #removeChangeListener 179 */ addChangeListener(ChangeListener l)180 static public void addChangeListener(ChangeListener l) { 181 if (listenerList.getListenerCount(ChangeListener.class) == 0) { 182 swingListener.installListeners(EventID.CHANGE); 183 } 184 listenerList.add(ChangeListener.class, l); 185 } 186 187 /** 188 * Removes the specified listener so it no longer receives 189 * {@link EventID#CHANGE CHANGE} events when they occur. 190 * 191 * @param l the listener to remove 192 * @see #addChangeListener 193 */ removeChangeListener(ChangeListener l)194 static public void removeChangeListener(ChangeListener l) { 195 listenerList.remove(ChangeListener.class, l); 196 if (listenerList.getListenerCount(ChangeListener.class) == 0) { 197 swingListener.removeListeners(EventID.CHANGE); 198 } 199 } 200 201 /** 202 * Adds the specified listener to receive all {@link EventID#COLUMNMODEL COLUMNMODEL} 203 * events on each component instance in the Java Virtual Machine as they occur. 204 * <P>Note: This listener is automatically added to all component 205 * instances created after this method is called. In addition, it 206 * is only added to component instances that support this listener type. 207 * 208 * @param l the listener to add 209 * @see #removeColumnModelListener 210 */ addColumnModelListener(TableColumnModelListener l)211 static public void addColumnModelListener(TableColumnModelListener l) { 212 if (listenerList.getListenerCount(TableColumnModelListener.class) == 0) { 213 swingListener.installListeners(EventID.COLUMNMODEL); 214 } 215 listenerList.add(TableColumnModelListener.class, l); 216 } 217 218 /** 219 * Removes the specified listener so it no longer receives 220 * {@link EventID#COLUMNMODEL COLUMNMODEL} events when they occur. 221 * 222 * @param l the listener to remove 223 * @see #addColumnModelListener 224 */ removeColumnModelListener(TableColumnModelListener l)225 static public void removeColumnModelListener(TableColumnModelListener l) { 226 listenerList.remove(TableColumnModelListener.class, l); 227 if (listenerList.getListenerCount(TableColumnModelListener.class) == 0) { 228 swingListener.removeListeners(EventID.COLUMNMODEL); 229 } 230 } 231 232 /** 233 * Adds the specified listener to receive all {@link EventID#DOCUMENT DOCUMENT} 234 * events on each component instance in the Java Virtual Machine as they occur. 235 * <P>Note: This listener is automatically added to all component 236 * instances created after this method is called. In addition, it 237 * is only added to component instances that support this listener type. 238 * 239 * @param l the listener to add 240 * @see #removeDocumentListener 241 */ addDocumentListener(DocumentListener l)242 static public void addDocumentListener(DocumentListener l) { 243 if (listenerList.getListenerCount(DocumentListener.class) == 0) { 244 swingListener.installListeners(EventID.DOCUMENT); 245 } 246 listenerList.add(DocumentListener.class, l); 247 } 248 249 /** 250 * Removes the specified listener so it no longer receives 251 * {@link EventID#DOCUMENT DOCUMENT} events when they occur. 252 * 253 * @param l the listener to remove 254 * @see #addDocumentListener 255 */ removeDocumentListener(DocumentListener l)256 static public void removeDocumentListener(DocumentListener l) { 257 listenerList.remove(DocumentListener.class, l); 258 if (listenerList.getListenerCount(DocumentListener.class) == 0) { 259 swingListener.removeListeners(EventID.DOCUMENT); 260 } 261 } 262 263 /** 264 * Adds the specified listener to receive all {@link EventID#LISTDATA LISTDATA} 265 * events on each component instance in the Java Virtual Machine as they occur. 266 * <P>Note: This listener is automatically added to all component 267 * instances created after this method is called. In addition, it 268 * is only added to component instances that support this listener type. 269 * 270 * @param l the listener to add 271 * @see #removeListDataListener 272 */ addListDataListener(ListDataListener l)273 static public void addListDataListener(ListDataListener l) { 274 if (listenerList.getListenerCount(ListDataListener.class) == 0) { 275 swingListener.installListeners(EventID.LISTDATA); 276 } 277 listenerList.add(ListDataListener.class, l); 278 } 279 280 /** 281 * Removes the specified listener so it no longer receives 282 * {@link EventID#LISTDATA LISTDATA} events when they occur. 283 * 284 * @param l the listener to remove 285 * @see #addListDataListener 286 */ removeListDataListener(ListDataListener l)287 static public void removeListDataListener(ListDataListener l) { 288 listenerList.remove(ListDataListener.class, l); 289 if (listenerList.getListenerCount(ListDataListener.class) == 0) { 290 swingListener.removeListeners(EventID.LISTDATA); 291 } 292 } 293 294 /** 295 * Adds the specified listener to receive all {@link EventID#LISTSELECTION LISTSELECTION} 296 * events on each component instance in the Java Virtual Machine as they occur. 297 * <P>Note: This listener is automatically added to all component 298 * instances created after this method is called. In addition, it 299 * is only added to component instances that support this listener type. 300 * 301 * @param l the listener to add 302 * @see #removeListSelectionListener 303 */ addListSelectionListener(ListSelectionListener l)304 static public void addListSelectionListener(ListSelectionListener l) { 305 if (listenerList.getListenerCount(ListSelectionListener.class) == 0) { 306 swingListener.installListeners(EventID.LISTSELECTION); 307 } 308 listenerList.add(ListSelectionListener.class, l); 309 } 310 311 /** 312 * Removes the specified listener so it no longer receives 313 * {@link EventID#LISTSELECTION LISTSELECTION} events when they occur. 314 * 315 * @param l the listener to remove 316 * @see #addListSelectionListener 317 */ removeListSelectionListener(ListSelectionListener l)318 static public void removeListSelectionListener(ListSelectionListener l) { 319 listenerList.remove(ListSelectionListener.class, l); 320 if (listenerList.getListenerCount(ListSelectionListener.class) == 0) { 321 swingListener.removeListeners(EventID.LISTSELECTION); 322 } 323 } 324 325 /** 326 * Adds the specified listener to receive all {@link EventID#MENU MENU} events 327 * on each component instance in the Java Virtual Machine as they occur. 328 * <P>Note: This listener is automatically added to all component 329 * instances created after this method is called. In addition, it 330 * is only added to component instances that support this listener type. 331 * 332 * @param l the listener to add 333 * @see #removeMenuListener 334 */ addMenuListener(MenuListener l)335 static public void addMenuListener(MenuListener l) { 336 if (listenerList.getListenerCount(MenuListener.class) == 0) { 337 swingListener.installListeners(EventID.MENU); 338 } 339 listenerList.add(MenuListener.class, l); 340 } 341 342 /** 343 * Removes the specified listener so it no longer receives 344 * {@link EventID#MENU MENU} events when they occur. 345 * 346 * @param l the listener to remove 347 * @see #addMenuListener 348 */ removeMenuListener(MenuListener l)349 static public void removeMenuListener(MenuListener l) { 350 listenerList.remove(MenuListener.class, l); 351 if (listenerList.getListenerCount(MenuListener.class) == 0) { 352 swingListener.removeListeners(EventID.MENU); 353 } 354 } 355 356 /** 357 * Adds the specified listener to receive all {@link EventID#POPUPMENU POPUPMENU} 358 * events on each component instance in the Java Virtual Machine as they occur. 359 * <P>Note: This listener is automatically added to all component 360 * instances created after this method is called. In addition, it 361 * is only added to component instances that support this listener type. 362 * 363 * @param l the listener to add 364 * @see #removePopupMenuListener 365 */ addPopupMenuListener(PopupMenuListener l)366 static public void addPopupMenuListener(PopupMenuListener l) { 367 if (listenerList.getListenerCount(PopupMenuListener.class) == 0) { 368 swingListener.installListeners(EventID.POPUPMENU); 369 } 370 listenerList.add(PopupMenuListener.class, l); 371 } 372 373 /** 374 * Removes the specified listener so it no longer receives 375 * {@link EventID#POPUPMENU POPUPMENU} events when they occur. 376 * 377 * @param l the listener to remove 378 * @see #addPopupMenuListener 379 */ removePopupMenuListener(PopupMenuListener l)380 static public void removePopupMenuListener(PopupMenuListener l) { 381 listenerList.remove(PopupMenuListener.class, l); 382 if (listenerList.getListenerCount(PopupMenuListener.class) == 0) { 383 swingListener.removeListeners(EventID.POPUPMENU); 384 } 385 } 386 387 /** 388 * Adds the specified listener to receive all {@link EventID#TABLEMODEL TABLEMODEL} 389 * events on each component instance in the Java Virtual Machine as they occur. 390 * <P>Note: This listener is automatically added to all component 391 * instances created after this method is called. In addition, it 392 * is only added to component instances that support this listener type. 393 * 394 * @param l the listener to add 395 * @see #removeTableModelListener 396 */ addTableModelListener(TableModelListener l)397 static public void addTableModelListener(TableModelListener l) { 398 if (listenerList.getListenerCount(TableModelListener.class) == 0) { 399 swingListener.installListeners(EventID.TABLEMODEL); 400 } 401 listenerList.add(TableModelListener.class, l); 402 } 403 404 /** 405 * Removes the specified listener so it no longer receives 406 * {@link EventID#TABLEMODEL TABLEMODEL} events when they occur. 407 * 408 * @param l the listener to remove 409 * @see #addTableModelListener 410 */ removeTableModelListener(TableModelListener l)411 static public void removeTableModelListener(TableModelListener l) { 412 listenerList.remove(TableModelListener.class, l); 413 if (listenerList.getListenerCount(TableModelListener.class) == 0) { 414 swingListener.removeListeners(EventID.TABLEMODEL); 415 } 416 } 417 418 /** 419 * Adds the specified listener to receive all {@link EventID#TREEEXPANSION TREEEXPANSION} 420 * events on each component instance in the Java Virtual Machine as they occur. 421 * <P>Note: This listener is automatically added to all component 422 * instances created after this method is called. In addition, it 423 * is only added to component instances that support this listener type. 424 * 425 * @param l the listener to add 426 * @see #removeTreeExpansionListener 427 */ addTreeExpansionListener(TreeExpansionListener l)428 static public void addTreeExpansionListener(TreeExpansionListener l) { 429 if (listenerList.getListenerCount(TreeExpansionListener.class) == 0) { 430 swingListener.installListeners(EventID.TREEEXPANSION); 431 } 432 listenerList.add(TreeExpansionListener.class, l); 433 } 434 435 /** 436 * Removes the specified listener so it no longer receives 437 * {@link EventID#TREEEXPANSION TREEEXPANSION} events when they occur. 438 * 439 * @param l the listener to remove 440 * @see #addTreeExpansionListener 441 */ removeTreeExpansionListener(TreeExpansionListener l)442 static public void removeTreeExpansionListener(TreeExpansionListener l) { 443 listenerList.remove(TreeExpansionListener.class, l); 444 if (listenerList.getListenerCount(TreeExpansionListener.class) == 0) { 445 swingListener.removeListeners(EventID.TREEEXPANSION); 446 } 447 } 448 449 /** 450 * Adds the specified listener to receive all {@link EventID#TREEMODEL TREEMODEL} 451 * events on each component instance in the Java Virtual Machine as they occur. 452 * <P>Note: This listener is automatically added to all component 453 * instances created after this method is called. In addition, it 454 * is only added to component instances that support this listener type. 455 * 456 * @param l the listener to add 457 * @see #removeTreeModelListener 458 */ addTreeModelListener(TreeModelListener l)459 static public void addTreeModelListener(TreeModelListener l) { 460 if (listenerList.getListenerCount(TreeModelListener.class) == 0) { 461 swingListener.installListeners(EventID.TREEMODEL); 462 } 463 listenerList.add(TreeModelListener.class, l); 464 } 465 466 /** 467 * Removes the specified listener so it no longer receives 468 * {@link EventID#TREEMODEL TREEMODEL} events when they occur. 469 * 470 * @param l the listener to remove 471 * @see #addTreeModelListener 472 */ removeTreeModelListener(TreeModelListener l)473 static public void removeTreeModelListener(TreeModelListener l) { 474 listenerList.remove(TreeModelListener.class, l); 475 if (listenerList.getListenerCount(TreeModelListener.class) == 0) { 476 swingListener.removeListeners(EventID.TREEMODEL); 477 } 478 } 479 480 /** 481 * Adds the specified listener to receive all {@link EventID#TREESELECTION TREESELECTION} 482 * events on each component instance in the Java Virtual Machine as they occur. 483 * <P>Note: This listener is automatically added to all component 484 * instances created after this method is called. In addition, it 485 * is only added to component instances that support this listener type. 486 * 487 * @param l the listener to add 488 * @see #removeTreeSelectionListener 489 */ addTreeSelectionListener(TreeSelectionListener l)490 static public void addTreeSelectionListener(TreeSelectionListener l) { 491 if (listenerList.getListenerCount(TreeSelectionListener.class) == 0) { 492 swingListener.installListeners(EventID.TREESELECTION); 493 } 494 listenerList.add(TreeSelectionListener.class, l); 495 } 496 497 /** 498 * Removes the specified listener so it no longer receives 499 * {@link EventID#TREESELECTION TREESELECTION} events when they occur. 500 * @see #addTreeSelectionListener 501 * @param l the listener to remove 502 */ removeTreeSelectionListener(TreeSelectionListener l)503 static public void removeTreeSelectionListener(TreeSelectionListener l) { 504 listenerList.remove(TreeSelectionListener.class, l); 505 if (listenerList.getListenerCount(TreeSelectionListener.class) == 0) { 506 swingListener.removeListeners(EventID.TREESELECTION); 507 } 508 } 509 510 /** 511 * Adds the specified listener to receive all {@link EventID#UNDOABLEEDIT UNDOABLEEDIT} 512 * events on each component instance in the Java Virtual Machine as they occur. 513 * <P>Note: This listener is automatically added to all component 514 * instances created after this method is called. In addition, it 515 * is only added to component instances that support this listener type. 516 * 517 * @param l the listener to add 518 * @see #removeUndoableEditListener 519 */ addUndoableEditListener(UndoableEditListener l)520 static public void addUndoableEditListener(UndoableEditListener l) { 521 if (listenerList.getListenerCount(UndoableEditListener.class) == 0) { 522 swingListener.installListeners(EventID.UNDOABLEEDIT); 523 } 524 listenerList.add(UndoableEditListener.class, l); 525 } 526 527 /** 528 * Removes the specified listener so it no longer receives 529 * {@link EventID#UNDOABLEEDIT UNDOABLEEDIT} events when they occur. 530 * 531 * @param l the listener to remove 532 * @see #addUndoableEditListener 533 */ removeUndoableEditListener(UndoableEditListener l)534 static public void removeUndoableEditListener(UndoableEditListener l) { 535 listenerList.remove(UndoableEditListener.class, l); 536 if (listenerList.getListenerCount(UndoableEditListener.class) == 0) { 537 swingListener.removeListeners(EventID.UNDOABLEEDIT); 538 } 539 } 540 541 /** 542 * Adds the specified listener to receive all {@link EventID#INTERNALFRAME INTERNALFRAME} 543 * events on each component instance in the Java Virtual Machine as they occur. 544 * <P>Note: This listener is automatically added to all component 545 * instances created after this method is called. In addition, it 546 * is only added to component instances that support this listener type. 547 * 548 * @param l the listener to add 549 * @see #removeInternalFrameListener 550 */ addInternalFrameListener(InternalFrameListener l)551 static public void addInternalFrameListener(InternalFrameListener l) { 552 if (listenerList.getListenerCount(InternalFrameListener.class) == 0) { 553 swingListener.installListeners(EventID.INTERNALFRAME); 554 } 555 listenerList.add(InternalFrameListener.class, l); 556 } 557 558 /** 559 * Removes the specified listener so it no longer receives 560 * {@link EventID#INTERNALFRAME INTERNALFRAME} events when they occur. 561 * 562 * @param l the listener to remove 563 * @see #addInternalFrameListener 564 */ removeInternalFrameListener(InternalFrameListener l)565 static public void removeInternalFrameListener(InternalFrameListener l) { 566 listenerList.remove(InternalFrameListener.class, l); 567 if (listenerList.getListenerCount(InternalFrameListener.class) == 0) { 568 swingListener.removeListeners(EventID.INTERNALFRAME); 569 } 570 } 571 572 /** 573 * Adds the specified listener to receive all {@link EventID#PROPERTYCHANGE PROPERTYCHANGE} 574 * events on each component instance in the Java Virtual Machine as they occur. 575 * <P>Note: This listener is automatically added to all component 576 * instances created after this method is called. In addition, it 577 * is only added to component instances that support this listener type. 578 * 579 * @param l the listener to add 580 * @see #removePropertyChangeListener 581 */ addPropertyChangeListener(PropertyChangeListener l)582 static public void addPropertyChangeListener(PropertyChangeListener l) { 583 if (listenerList.getListenerCount(PropertyChangeListener.class) == 0) { 584 swingListener.installListeners(EventID.PROPERTYCHANGE); 585 } 586 listenerList.add(PropertyChangeListener.class, l); 587 } 588 589 /** 590 * Removes the specified listener so it no longer receives 591 * {@link EventID#PROPERTYCHANGE PROPERTYCHANGE} events when they occur. 592 * @see #addPropertyChangeListener 593 * @param l the listener to remove 594 */ removePropertyChangeListener(PropertyChangeListener l)595 static public void removePropertyChangeListener(PropertyChangeListener l) { 596 listenerList.remove(PropertyChangeListener.class, l); 597 if (listenerList.getListenerCount(PropertyChangeListener.class) == 0) { 598 swingListener.removeListeners(EventID.PROPERTYCHANGE); 599 } 600 } 601 602 /** 603 * Adds the specified listener to receive all {@link EventID#VETOABLECHANGE VETOABLECHANGE} 604 * events on each component instance in the Java Virtual Machine as they occur. 605 * <P>Note: This listener is automatically added to all component 606 * instances created after this method is called. In addition, it 607 * is only added to component instances that support this listener type. 608 * 609 * @param l the listener to add 610 * @see #removeVetoableChangeListener 611 */ addVetoableChangeListener(VetoableChangeListener l)612 static public void addVetoableChangeListener(VetoableChangeListener l) { 613 if (listenerList.getListenerCount(VetoableChangeListener.class) == 0) { 614 swingListener.installListeners(EventID.VETOABLECHANGE); 615 } 616 listenerList.add(VetoableChangeListener.class, l); 617 } 618 619 /** 620 * Removes the specified listener so it no longer receives 621 * {@link EventID#VETOABLECHANGE VETOABLECHANGE} events when they occur. 622 * 623 * @param l the listener to remove 624 * @see #addVetoableChangeListener 625 */ removeVetoableChangeListener(VetoableChangeListener l)626 static public void removeVetoableChangeListener(VetoableChangeListener l) { 627 listenerList.remove(VetoableChangeListener.class, l); 628 if (listenerList.getListenerCount(VetoableChangeListener.class) == 0) { 629 swingListener.removeListeners(EventID.VETOABLECHANGE); 630 } 631 } 632 633 634 /** 635 * SwingEventListener is the class that does all the work for 636 * SwingEventMonitor. It is not intended for use by any other class 637 * except SwingEventMonitor. 638 * 639 */ 640 static class SwingEventListener extends AWTEventsListener 641 implements AncestorListener, CaretListener, CellEditorListener, 642 ChangeListener, DocumentListener, ListDataListener, 643 ListSelectionListener, MenuListener, PopupMenuListener, 644 TableColumnModelListener, TableModelListener, TreeExpansionListener, 645 TreeModelListener, TreeSelectionListener, UndoableEditListener, 646 InternalFrameListener, 647 PropertyChangeListener, VetoableChangeListener { 648 649 /** 650 * internal variables for Caret introspection 651 */ 652 private java.lang.Class<?>[] caretListeners; 653 private java.lang.reflect.Method removeCaretMethod; 654 private java.lang.reflect.Method addCaretMethod; 655 private java.lang.Object[] caretArgs; 656 657 /** 658 * internal variables for CellEditor introspection 659 */ 660 private java.lang.Class<?>[] cellEditorListeners; 661 private java.lang.reflect.Method removeCellEditorMethod; 662 private java.lang.reflect.Method addCellEditorMethod; 663 private java.lang.Object[] cellEditorArgs; 664 private java.lang.reflect.Method getCellEditorMethod; 665 666 /** 667 * internal variables for Change introspection 668 */ 669 private java.lang.Class<?>[] changeListeners; 670 private java.lang.reflect.Method removeChangeMethod; 671 private java.lang.reflect.Method addChangeMethod; 672 private java.lang.Object[] changeArgs; 673 674 /** 675 * internal variable for ColumnModel introspection 676 */ 677 private java.lang.reflect.Method getColumnModelMethod; 678 679 /** 680 * internal variables for Document introspection 681 */ 682 private java.lang.Class<?>[] documentListeners; 683 private java.lang.reflect.Method removeDocumentMethod; 684 private java.lang.reflect.Method addDocumentMethod; 685 private java.lang.Object[] documentArgs; 686 private java.lang.reflect.Method getDocumentMethod; 687 688 /** 689 * internal variable for ListData, Table, and Tree introspection 690 */ 691 private java.lang.reflect.Method getModelMethod; 692 693 /** 694 * internal variables for ListSelection introspection 695 */ 696 private java.lang.Class<?>[] listSelectionListeners; 697 private java.lang.reflect.Method removeListSelectionMethod; 698 private java.lang.reflect.Method addListSelectionMethod; 699 private java.lang.Object[] listSelectionArgs; 700 private java.lang.reflect.Method getSelectionModelMethod; 701 702 /** 703 * internal variables for Menu introspection 704 */ 705 private java.lang.Class<?>[] menuListeners; 706 private java.lang.reflect.Method removeMenuMethod; 707 private java.lang.reflect.Method addMenuMethod; 708 private java.lang.Object[] menuArgs; 709 710 /** 711 * internal variables for PopupMenu introspection 712 */ 713 private java.lang.Class<?>[] popupMenuListeners; 714 private java.lang.reflect.Method removePopupMenuMethod; 715 private java.lang.reflect.Method addPopupMenuMethod; 716 private java.lang.Object[] popupMenuArgs; 717 private java.lang.reflect.Method getPopupMenuMethod; 718 719 /** 720 * internal variables for TreeExpansion introspection 721 */ 722 private java.lang.Class<?>[] treeExpansionListeners; 723 private java.lang.reflect.Method removeTreeExpansionMethod; 724 private java.lang.reflect.Method addTreeExpansionMethod; 725 private java.lang.Object[] treeExpansionArgs; 726 727 /** 728 * internal variables for TreeSelection introspection 729 */ 730 private java.lang.Class<?>[] treeSelectionListeners; 731 private java.lang.reflect.Method removeTreeSelectionMethod; 732 private java.lang.reflect.Method addTreeSelectionMethod; 733 private java.lang.Object[] treeSelectionArgs; 734 735 /** 736 * internal variables for UndoableEdit introspection 737 */ 738 private java.lang.Class<?>[] undoableEditListeners; 739 private java.lang.reflect.Method removeUndoableEditMethod; 740 private java.lang.reflect.Method addUndoableEditMethod; 741 private java.lang.Object[] undoableEditArgs; 742 743 /** 744 * internal variables for InternalFrame introspection 745 */ 746 private java.lang.Class<?>[] internalFrameListeners; 747 private java.lang.reflect.Method removeInternalFrameMethod; 748 private java.lang.reflect.Method addInternalFrameMethod; 749 private java.lang.Object[] internalFrameArgs; 750 751 /** 752 * internal variables for PropertyChange introspection 753 */ 754 private java.lang.Class<?>[] propertyChangeListeners; 755 private java.lang.reflect.Method removePropertyChangeMethod; 756 private java.lang.reflect.Method addPropertyChangeMethod; 757 private java.lang.Object[] propertyChangeArgs; 758 759 /** 760 * internal variables for a variety of change introspections 761 */ 762 private java.lang.Class<?>[] nullClass; 763 private java.lang.Object[] nullArgs; 764 765 /** 766 * Create a new instance of this class and install it on each component 767 * instance in the virtual machine that supports any of the currently 768 * registered listeners in SwingEventMonitor. Also registers itself 769 * as a TopLevelWindowListener with EventQueueMonitor so it can 770 * automatically add new listeners to new components. 771 * @see EventQueueMonitor 772 * @see SwingEventMonitor 773 */ SwingEventListener()774 public SwingEventListener() { 775 initializeIntrospection(); 776 installListeners(); 777 EventQueueMonitor.addTopLevelWindowListener(this); 778 } 779 780 /** 781 * Set up all of the variables needed for introspection 782 */ initializeIntrospection()783 private boolean initializeIntrospection() { 784 caretListeners = new java.lang.Class<?>[1]; 785 caretArgs = new java.lang.Object[1]; 786 caretListeners[0] = javax.swing.event.CaretListener.class; 787 caretArgs[0] = this; 788 789 cellEditorListeners = new java.lang.Class<?>[1]; 790 cellEditorArgs = new java.lang.Object[1]; 791 cellEditorListeners[0] = javax.swing.event.CellEditorListener.class; 792 cellEditorArgs[0] = this; 793 794 changeListeners = new java.lang.Class<?>[1]; 795 changeArgs = new java.lang.Object[1]; 796 changeListeners[0] = javax.swing.event.ChangeListener.class; 797 changeArgs[0] = this; 798 799 documentListeners = new java.lang.Class<?>[1]; 800 documentArgs = new java.lang.Object[1]; 801 documentListeners[0] = javax.swing.event.DocumentListener.class; 802 documentArgs[0] = this; 803 804 listSelectionListeners = new java.lang.Class<?>[1]; 805 listSelectionArgs = new java.lang.Object[1]; 806 listSelectionListeners[0] = javax.swing.event.ListSelectionListener.class; 807 listSelectionArgs[0] = this; 808 809 menuListeners = new java.lang.Class<?>[1]; 810 menuArgs = new java.lang.Object[1]; 811 menuListeners[0] = javax.swing.event.MenuListener.class; 812 menuArgs[0] = this; 813 814 popupMenuListeners = new java.lang.Class<?>[1]; 815 popupMenuArgs = new java.lang.Object[1]; 816 popupMenuListeners[0] = javax.swing.event.PopupMenuListener.class; 817 popupMenuArgs[0] = this; 818 819 treeExpansionListeners = new java.lang.Class<?>[1]; 820 treeExpansionArgs = new java.lang.Object[1]; 821 treeExpansionListeners[0] = javax.swing.event.TreeExpansionListener.class; 822 treeExpansionArgs[0] = this; 823 824 treeSelectionListeners = new java.lang.Class<?>[1]; 825 treeSelectionArgs = new java.lang.Object[1]; 826 treeSelectionListeners[0] = javax.swing.event.TreeSelectionListener.class; 827 treeSelectionArgs[0] = this; 828 829 undoableEditListeners = new java.lang.Class<?>[1]; 830 undoableEditArgs = new java.lang.Object[1]; 831 undoableEditListeners[0] = javax.swing.event.UndoableEditListener.class; 832 undoableEditArgs[0] = this; 833 834 internalFrameListeners = new java.lang.Class<?>[1]; 835 internalFrameArgs = new java.lang.Object[1]; 836 internalFrameListeners[0] = javax.swing.event.InternalFrameListener.class; 837 internalFrameArgs[0] = this; 838 839 nullClass = new java.lang.Class<?>[0]; 840 nullArgs = new java.lang.Object[0]; 841 842 propertyChangeListeners = new java.lang.Class<?>[1]; 843 propertyChangeArgs = new java.lang.Object[1]; 844 propertyChangeListeners[0] = java.beans.PropertyChangeListener.class; 845 propertyChangeArgs[0] = this; 846 847 return true; 848 } 849 850 /** 851 * Installs all appropriate Swing listeners to just the component. 852 * Also calls super (AWTEventsListener.installListeners()) to install 853 * the requested AWT listeners. 854 * @param c the component to add listeners to 855 */ installListeners(Component c)856 protected void installListeners(Component c) { 857 858 // This SwingEventListener needs to be notified when a new 859 // Swing component has been added so it can add Swing listeners 860 // to these components. As a result, we always need a Container 861 // listener on every Container. 862 // 863 installListeners(c,EventID.CONTAINER); 864 865 // conditionally install Swing listeners 866 // 867 if (SwingEventMonitor.listenerList.getListenerCount(AncestorListener.class) > 0) { 868 installListeners(c,EventID.ANCESTOR); 869 } 870 if (SwingEventMonitor.listenerList.getListenerCount(CaretListener.class) > 0) { 871 installListeners(c,EventID.CARET); 872 } 873 if (SwingEventMonitor.listenerList.getListenerCount(CellEditorListener.class) > 0) { 874 installListeners(c,EventID.CELLEDITOR); 875 } 876 if (SwingEventMonitor.listenerList.getListenerCount(ChangeListener.class) > 0) { 877 installListeners(c,EventID.CHANGE); 878 } 879 if (SwingEventMonitor.listenerList.getListenerCount(TableColumnModelListener.class) > 0) { 880 installListeners(c,EventID.COLUMNMODEL); 881 } 882 if (SwingEventMonitor.listenerList.getListenerCount(DocumentListener.class) > 0) { 883 installListeners(c,EventID.DOCUMENT); 884 } 885 if (SwingEventMonitor.listenerList.getListenerCount(ListDataListener.class) > 0) { 886 installListeners(c,EventID.LISTDATA); 887 } 888 if (SwingEventMonitor.listenerList.getListenerCount(ListSelectionListener.class) > 0) { 889 installListeners(c,EventID.LISTSELECTION); 890 } 891 if (SwingEventMonitor.listenerList.getListenerCount(MenuListener.class) > 0) { 892 installListeners(c,EventID.MENU); 893 } 894 if (SwingEventMonitor.listenerList.getListenerCount(PopupMenuListener.class) > 0) { 895 installListeners(c,EventID.POPUPMENU); 896 } 897 if (SwingEventMonitor.listenerList.getListenerCount(TableModelListener.class) > 0) { 898 installListeners(c,EventID.TABLEMODEL); 899 } 900 if (SwingEventMonitor.listenerList.getListenerCount(TreeExpansionListener.class) > 0) { 901 installListeners(c,EventID.TREEEXPANSION); 902 } 903 if (SwingEventMonitor.listenerList.getListenerCount(TreeModelListener.class) > 0) { 904 installListeners(c,EventID.TREEMODEL); 905 } 906 if (SwingEventMonitor.listenerList.getListenerCount(TreeSelectionListener.class) > 0) { 907 installListeners(c,EventID.TREESELECTION); 908 } 909 if (SwingEventMonitor.listenerList.getListenerCount(UndoableEditListener.class) > 0) { 910 installListeners(c,EventID.UNDOABLEEDIT); 911 } 912 if (SwingEventMonitor.listenerList.getListenerCount(InternalFrameListener.class) > 0) { 913 installListeners(c,EventID.INTERNALFRAME); 914 } 915 916 // Conditionally install Beans listeners 917 // 918 if (SwingEventMonitor.listenerList.getListenerCount(PropertyChangeListener.class) > 0) { 919 installListeners(c,EventID.PROPERTYCHANGE); 920 } 921 if (SwingEventMonitor.listenerList.getListenerCount(VetoableChangeListener.class) > 0) { 922 installListeners(c,EventID.VETOABLECHANGE); 923 } 924 925 // Now install the AWT listeners if needed. 926 // 927 super.installListeners(c); 928 } 929 930 /** 931 * Installs all appropriate Swing listeners to the component and all its 932 * children. As a precaution, it always attempts to remove itself as 933 * a listener first so we're always guaranteed it will installed itself 934 * just once. 935 * @param c the component to add listeners to 936 * @param eventID the eventID to add listeners for 937 */ installListeners(Component c, int eventID)938 protected void installListeners(Component c, int eventID) { 939 940 // install the appropriate listener hook into this component 941 // 942 switch (eventID) { 943 944 case EventID.CONTAINER: 945 if (c instanceof Container) { 946 ((Container) c).removeContainerListener(this); 947 ((Container) c).addContainerListener(this); 948 } 949 break; 950 951 case EventID.ANCESTOR: 952 if (c instanceof JComponent) { 953 ((JComponent) c).removeAncestorListener(this); 954 ((JComponent) c).addAncestorListener(this); 955 } 956 break; 957 958 case EventID.CARET: 959 try { 960 removeCaretMethod = c.getClass().getMethod( 961 "removeCaretListener", caretListeners); 962 addCaretMethod = c.getClass().getMethod( 963 "addCaretListener", caretListeners); 964 try { 965 removeCaretMethod.invoke(c, caretArgs); 966 addCaretMethod.invoke(c, caretArgs); 967 } catch (java.lang.reflect.InvocationTargetException e) { 968 System.out.println("Exception: " + e.toString()); 969 } catch (IllegalAccessException e) { 970 System.out.println("Exception: " + e.toString()); 971 } 972 } catch (NoSuchMethodException e) { 973 // System.out.println("Exception: " + e.toString()); 974 } catch (SecurityException e) { 975 System.out.println("Exception: " + e.toString()); 976 } 977 break; 978 979 case EventID.CELLEDITOR: 980 // Look for components which support the getCellEditor method 981 // (e.g. JTable, JTree) 982 // 983 try { 984 getCellEditorMethod = c.getClass().getMethod( 985 "getCellEditorMethod", nullClass); 986 try { 987 Object o = getCellEditorMethod.invoke(c, nullArgs); 988 if (o != null && o instanceof CellEditor) { 989 ((CellEditor) o).removeCellEditorListener(this); 990 ((CellEditor) o).addCellEditorListener(this); 991 } 992 } catch (java.lang.reflect.InvocationTargetException e) { 993 System.out.println("Exception: " + e.toString()); 994 } catch (IllegalAccessException e) { 995 System.out.println("Exception: " + e.toString()); 996 } 997 } catch (NoSuchMethodException e) { 998 // System.out.println("Exception: " + e.toString()); 999 } catch (SecurityException e) { 1000 System.out.println("Exception: " + e.toString()); 1001 } 1002 1003 // Look for components which support CellEditor listeners 1004 // (no current example) 1005 // 1006 try { 1007 removeCellEditorMethod = c.getClass().getMethod( 1008 "removeCellEditorListener", cellEditorListeners); 1009 addCellEditorMethod = c.getClass().getMethod( 1010 "addCellEditorListener", cellEditorListeners); 1011 try { 1012 removeCellEditorMethod.invoke(c, cellEditorArgs); 1013 addCellEditorMethod.invoke(c, cellEditorArgs); 1014 } catch (java.lang.reflect.InvocationTargetException e) { 1015 System.out.println("Exception: " + e.toString()); 1016 } catch (IllegalAccessException e) { 1017 System.out.println("Exception: " + e.toString()); 1018 } 1019 } catch (NoSuchMethodException e) { 1020 // System.out.println("Exception: " + e.toString()); 1021 } catch (SecurityException e) { 1022 System.out.println("Exception: " + e.toString()); 1023 } 1024 break; 1025 1026 case EventID.CHANGE: 1027 // [[[FIXME: Need to add support for Style, StyleContext -pk]]] 1028 1029 // Look for components which support Change listeners 1030 // (e.g. AbstractButton, Caret, JProgressBar, JSlider, 1031 // JTabbedpane, JTextComponent, JViewport) 1032 // 1033 try { 1034 removeChangeMethod = c.getClass().getMethod( 1035 "removeChangeListener", changeListeners); 1036 addChangeMethod = c.getClass().getMethod( 1037 "addChangeListener", changeListeners); 1038 try { 1039 removeChangeMethod.invoke(c, changeArgs); 1040 addChangeMethod.invoke(c, changeArgs); 1041 } catch (java.lang.reflect.InvocationTargetException e) { 1042 System.out.println("Exception: " + e.toString()); 1043 } catch (IllegalAccessException e) { 1044 System.out.println("Exception: " + e.toString()); 1045 } 1046 } catch (NoSuchMethodException e) { 1047 // System.out.println("Exception: " + e.toString()); 1048 } catch (SecurityException e) { 1049 System.out.println("Exception: " + e.toString()); 1050 } 1051 1052 // Look for components which support the getModel method 1053 // whose model supports Change listeners 1054 // (e.g. BoundedRangeModel, ButtonModel, SingleSelectionModel) 1055 // 1056 try { 1057 getModelMethod = c.getClass().getMethod( 1058 "getModel", nullClass); 1059 try { 1060 Object o = getModelMethod.invoke(c, nullArgs); 1061 if (o != null) { 1062 removeChangeMethod = o.getClass().getMethod( 1063 "removeChangeListener", changeListeners); 1064 addChangeMethod = o.getClass().getMethod( 1065 "addChangeListener", changeListeners); 1066 removeChangeMethod.invoke(o, changeArgs); 1067 addChangeMethod.invoke(o, changeArgs); 1068 } 1069 } catch (java.lang.reflect.InvocationTargetException e) { 1070 System.out.println("Exception: " + e.toString()); 1071 } catch (IllegalAccessException e) { 1072 System.out.println("Exception: " + e.toString()); 1073 } 1074 } catch (NoSuchMethodException e) { 1075 // System.out.println("Exception: " + e.toString()); 1076 } catch (SecurityException e) { 1077 System.out.println("Exception: " + e.toString()); 1078 } 1079 1080 break; 1081 1082 case EventID.COLUMNMODEL: 1083 try { 1084 getColumnModelMethod = c.getClass().getMethod( 1085 "getTableColumnModel", nullClass); 1086 try { 1087 Object o = getColumnModelMethod.invoke(c, nullArgs); 1088 if (o != null && o instanceof TableColumnModel) { 1089 ((TableColumnModel) o).removeColumnModelListener(this); 1090 ((TableColumnModel) o).addColumnModelListener(this); 1091 } 1092 } catch (java.lang.reflect.InvocationTargetException e) { 1093 System.out.println("Exception: " + e.toString()); 1094 } catch (IllegalAccessException e) { 1095 System.out.println("Exception: " + e.toString()); 1096 } 1097 } catch (NoSuchMethodException e) { 1098 // System.out.println("Exception: " + e.toString()); 1099 } catch (SecurityException e) { 1100 System.out.println("Exception: " + e.toString()); 1101 } 1102 break; 1103 1104 case EventID.DOCUMENT: 1105 // Look for components which support the getDocument method 1106 // (e.g. JTextComponent) 1107 // 1108 try { 1109 getDocumentMethod = c.getClass().getMethod( 1110 "getDocument", nullClass); 1111 try { 1112 Object o = getDocumentMethod.invoke(c, nullArgs); 1113 if (o != null && o instanceof Document) { 1114 ((Document) o).removeDocumentListener(this); 1115 ((Document) o).addDocumentListener(this); 1116 } 1117 } catch (java.lang.reflect.InvocationTargetException e) { 1118 System.out.println("Exception: " + e.toString()); 1119 } catch (IllegalAccessException e) { 1120 System.out.println("Exception: " + e.toString()); 1121 } 1122 } catch (NoSuchMethodException e) { 1123 // System.out.println("Exception: " + e.toString()); 1124 } catch (SecurityException e) { 1125 System.out.println("Exception: " + e.toString()); 1126 } 1127 1128 // Look for components which support Document listeners 1129 // (no current example) 1130 // 1131 try { 1132 removeDocumentMethod = c.getClass().getMethod( 1133 "removeDocumentListener", documentListeners); 1134 addDocumentMethod = c.getClass().getMethod( 1135 "addDocumentListener", documentListeners); 1136 try { 1137 removeDocumentMethod.invoke(c, documentArgs); 1138 addDocumentMethod.invoke(c, documentArgs); 1139 } catch (java.lang.reflect.InvocationTargetException e) { 1140 System.out.println("Exception: " + e.toString()); 1141 } catch (IllegalAccessException e) { 1142 System.out.println("Exception: " + e.toString()); 1143 } 1144 } catch (NoSuchMethodException e) { 1145 // System.out.println("Exception: " + e.toString()); 1146 } catch (SecurityException e) { 1147 System.out.println("Exception: " + e.toString()); 1148 } 1149 // Add the monitor as a PropertyChangeListener for document 1150 // change events from text components. 1151 // 1152 if (c instanceof JTextComponent) { 1153 try { 1154 removePropertyChangeMethod = c.getClass().getMethod( 1155 "removePropertyChangeListener", 1156 propertyChangeListeners); 1157 addPropertyChangeMethod = c.getClass().getMethod( 1158 "addPropertyChangeListener", 1159 propertyChangeListeners); 1160 try { 1161 removePropertyChangeMethod.invoke(c, 1162 propertyChangeArgs); 1163 addPropertyChangeMethod.invoke(c, 1164 propertyChangeArgs); 1165 } catch (java.lang.reflect.InvocationTargetException e) { 1166 System.out.println("Exception: " + e.toString()); 1167 } catch (IllegalAccessException e) { 1168 System.out.println("Exception: " + e.toString()); 1169 } 1170 } catch (NoSuchMethodException e) { 1171 // System.out.println("Exception: " + e.toString()); 1172 } catch (SecurityException e) { 1173 System.out.println("Exception: " + e.toString()); 1174 } 1175 } 1176 break; 1177 1178 case EventID.LISTDATA: 1179 case EventID.TABLEMODEL: 1180 case EventID.TREEMODEL: 1181 try { 1182 getModelMethod = c.getClass().getMethod( 1183 "getModel", nullClass); 1184 try { 1185 Object o = getModelMethod.invoke(c, nullArgs); 1186 if (o != null) { 1187 if (eventID == EventID.LISTDATA && 1188 o instanceof ListModel) { 1189 ((ListModel) o).removeListDataListener(this); 1190 ((ListModel) o).addListDataListener(this); 1191 } else if (eventID == EventID.TABLEMODEL && 1192 o instanceof TableModel) { 1193 ((TableModel) o).removeTableModelListener(this); 1194 ((TableModel) o).addTableModelListener(this); 1195 } else if ( 1196 o instanceof TreeModel) { 1197 ((TreeModel) o).removeTreeModelListener(this); 1198 ((TreeModel) o).addTreeModelListener(this); 1199 } 1200 } 1201 } catch (java.lang.reflect.InvocationTargetException e) { 1202 System.out.println("Exception: " + e.toString()); 1203 } catch (IllegalAccessException e) { 1204 System.out.println("Exception: " + e.toString()); 1205 } 1206 } catch (NoSuchMethodException e) { 1207 // System.out.println("Exception: " + e.toString()); 1208 } catch (SecurityException e) { 1209 System.out.println("Exception: " + e.toString()); 1210 } 1211 break; 1212 1213 case EventID.LISTSELECTION: 1214 // Look for components which support ListSelectionListeners 1215 // (e.g. JList) 1216 // 1217 try { 1218 removeListSelectionMethod = c.getClass().getMethod( 1219 "removeListSelectionListener", listSelectionListeners); 1220 addListSelectionMethod = c.getClass().getMethod( 1221 "addListSelectionListener", listSelectionListeners); 1222 try { 1223 removeListSelectionMethod.invoke(c, listSelectionArgs); 1224 addListSelectionMethod.invoke(c, listSelectionArgs); 1225 } catch (java.lang.reflect.InvocationTargetException e) { 1226 System.out.println("Exception: " + e.toString()); 1227 } catch (IllegalAccessException e) { 1228 System.out.println("Exception: " + e.toString()); 1229 } 1230 } catch (NoSuchMethodException e) { 1231 // System.out.println("Exception: " + e.toString()); 1232 } catch (SecurityException e) { 1233 System.out.println("Exception: " + e.toString()); 1234 } 1235 1236 // Look for selection models which support ListSelectionListeners 1237 // (e.g. JTable's selection model) 1238 // 1239 try { 1240 getSelectionModelMethod = c.getClass().getMethod( 1241 "getSelectionModel", nullClass); 1242 try { 1243 Object o = getSelectionModelMethod.invoke(c, nullArgs); 1244 if (o != null && o instanceof ListSelectionModel) { 1245 ((ListSelectionModel) o).removeListSelectionListener(this); 1246 ((ListSelectionModel) o).addListSelectionListener(this); 1247 } 1248 } catch (java.lang.reflect.InvocationTargetException e) { 1249 System.out.println("Exception: " + e.toString()); 1250 } catch (IllegalAccessException e) { 1251 System.out.println("Exception: " + e.toString()); 1252 } 1253 } catch (NoSuchMethodException e) { 1254 // System.out.println("Exception: " + e.toString()); 1255 } catch (SecurityException e) { 1256 System.out.println("Exception: " + e.toString()); 1257 } 1258 break; 1259 1260 case EventID.MENU: 1261 try { 1262 removeMenuMethod = c.getClass().getMethod( 1263 "removeMenuListener", menuListeners); 1264 addMenuMethod = c.getClass().getMethod( 1265 "addMenuListener", menuListeners); 1266 try { 1267 removeMenuMethod.invoke(c, menuArgs); 1268 addMenuMethod.invoke(c, menuArgs); 1269 } catch (java.lang.reflect.InvocationTargetException e) { 1270 System.out.println("Exception: " + e.toString()); 1271 } catch (IllegalAccessException e) { 1272 System.out.println("Exception: " + e.toString()); 1273 } 1274 } catch (NoSuchMethodException e) { 1275 // System.out.println("Exception: " + e.toString()); 1276 } catch (SecurityException e) { 1277 System.out.println("Exception: " + e.toString()); 1278 } 1279 break; 1280 1281 case EventID.POPUPMENU: 1282 // Look for components which support PopupMenuListeners 1283 // (e.g. JPopupMenu) 1284 // 1285 try { 1286 removePopupMenuMethod = c.getClass().getMethod( 1287 "removePopupMenuListener", popupMenuListeners); 1288 addPopupMenuMethod = c.getClass().getMethod( 1289 "addPopupMenuListener", popupMenuListeners); 1290 try { 1291 removePopupMenuMethod.invoke(c, popupMenuArgs); 1292 addPopupMenuMethod.invoke(c, popupMenuArgs); 1293 } catch (java.lang.reflect.InvocationTargetException e) { 1294 System.out.println("Exception: " + e.toString()); 1295 } catch (IllegalAccessException e) { 1296 System.out.println("Exception: " + e.toString()); 1297 } 1298 } catch (NoSuchMethodException e) { 1299 // System.out.println("Exception: " + e.toString()); 1300 } catch (SecurityException e) { 1301 System.out.println("Exception: " + e.toString()); 1302 } 1303 1304 // Look for components which support getPopupMenu 1305 // (e.g. JMenu) 1306 // 1307 try { 1308 getPopupMenuMethod = c.getClass().getMethod( 1309 "getPopupMenu", nullClass); 1310 try { 1311 Object o = getPopupMenuMethod.invoke(c, nullArgs); 1312 if (o != null) { 1313 removePopupMenuMethod = o.getClass().getMethod( 1314 "removePopupMenuListener", popupMenuListeners); 1315 addPopupMenuMethod = o.getClass().getMethod( 1316 "addPopupMenuListener", popupMenuListeners); 1317 removePopupMenuMethod.invoke(o, popupMenuArgs); 1318 addPopupMenuMethod.invoke(o, popupMenuArgs); 1319 } 1320 } catch (java.lang.reflect.InvocationTargetException e) { 1321 System.out.println("Exception: " + e.toString()); 1322 } catch (IllegalAccessException e) { 1323 System.out.println("Exception: " + e.toString()); 1324 } 1325 } catch (NoSuchMethodException e) { 1326 // System.out.println("Exception: " + e.toString()); 1327 } catch (SecurityException e) { 1328 System.out.println("Exception: " + e.toString()); 1329 } 1330 break; 1331 1332 case EventID.TREEEXPANSION: 1333 try { 1334 removeTreeExpansionMethod = c.getClass().getMethod( 1335 "removeTreeExpansionListener", treeExpansionListeners); 1336 addTreeExpansionMethod = c.getClass().getMethod( 1337 "addTreeExpansionListener", treeExpansionListeners); 1338 try { 1339 removeTreeExpansionMethod.invoke(c, treeExpansionArgs); 1340 addTreeExpansionMethod.invoke(c, treeExpansionArgs); 1341 } catch (java.lang.reflect.InvocationTargetException e) { 1342 System.out.println("Exception: " + e.toString()); 1343 } catch (IllegalAccessException e) { 1344 System.out.println("Exception: " + e.toString()); 1345 } 1346 } catch (NoSuchMethodException e) { 1347 // System.out.println("Exception: " + e.toString()); 1348 } catch (SecurityException e) { 1349 System.out.println("Exception: " + e.toString()); 1350 } 1351 break; 1352 1353 case EventID.TREESELECTION: 1354 try { 1355 removeTreeSelectionMethod = c.getClass().getMethod( 1356 "removeTreeSelectionListener", treeSelectionListeners); 1357 addTreeSelectionMethod = c.getClass().getMethod( 1358 "addTreeSelectionListener", treeSelectionListeners); 1359 try { 1360 removeTreeSelectionMethod.invoke(c, treeSelectionArgs); 1361 addTreeSelectionMethod.invoke(c, treeSelectionArgs); 1362 } catch (java.lang.reflect.InvocationTargetException e) { 1363 System.out.println("Exception: " + e.toString()); 1364 } catch (IllegalAccessException e) { 1365 System.out.println("Exception: " + e.toString()); 1366 } 1367 } catch (NoSuchMethodException e) { 1368 // System.out.println("Exception: " + e.toString()); 1369 } catch (SecurityException e) { 1370 System.out.println("Exception: " + e.toString()); 1371 } 1372 break; 1373 1374 case EventID.UNDOABLEEDIT: 1375 // Look for components which support the getDocument method 1376 // (e.g. JTextComponent) 1377 // 1378 try { 1379 getDocumentMethod = c.getClass().getMethod( 1380 "getDocument", nullClass); 1381 try { 1382 Object o = getDocumentMethod.invoke(c, nullArgs); 1383 if (o != null && o instanceof Document) { 1384 ((Document) o).removeUndoableEditListener(this); 1385 ((Document) o).addUndoableEditListener(this); 1386 } 1387 } catch (java.lang.reflect.InvocationTargetException e) { 1388 System.out.println("Exception: " + e.toString()); 1389 } catch (IllegalAccessException e) { 1390 System.out.println("Exception: " + e.toString()); 1391 } 1392 } catch (NoSuchMethodException e) { 1393 // System.out.println("Exception: " + e.toString()); 1394 } catch (SecurityException e) { 1395 System.out.println("Exception: " + e.toString()); 1396 } 1397 1398 // Look for components which support UndoableEdit listeners 1399 // (no current example) 1400 // 1401 try { 1402 removeUndoableEditMethod = c.getClass().getMethod( 1403 "removeUndoableEditListener", undoableEditListeners); 1404 addUndoableEditMethod = c.getClass().getMethod( 1405 "addUndoableEditListener", undoableEditListeners); 1406 try { 1407 removeUndoableEditMethod.invoke(c, undoableEditArgs); 1408 addUndoableEditMethod.invoke(c, undoableEditArgs); 1409 } catch (java.lang.reflect.InvocationTargetException e) { 1410 System.out.println("Exception: " + e.toString()); 1411 } catch (IllegalAccessException e) { 1412 System.out.println("Exception: " + e.toString()); 1413 } 1414 } catch (NoSuchMethodException e) { 1415 // System.out.println("Exception: " + e.toString()); 1416 } catch (SecurityException e) { 1417 System.out.println("Exception: " + e.toString()); 1418 } 1419 break; 1420 1421 case EventID.INTERNALFRAME: 1422 // Look for components which support InternalFrame listeners 1423 // (e.g. JInternalFrame) 1424 // 1425 try { 1426 removeInternalFrameMethod = c.getClass().getMethod( 1427 "removeInternalFrameListener", internalFrameListeners); 1428 addInternalFrameMethod = c.getClass().getMethod( 1429 "addInternalFrameListener", internalFrameListeners); 1430 try { 1431 removeInternalFrameMethod.invoke(c, internalFrameArgs); 1432 addInternalFrameMethod.invoke(c, internalFrameArgs); 1433 } catch (java.lang.reflect.InvocationTargetException e) { 1434 System.out.println("Exception: " + e.toString()); 1435 } catch (IllegalAccessException e) { 1436 System.out.println("Exception: " + e.toString()); 1437 } 1438 } catch (NoSuchMethodException e) { 1439 // System.out.println("Exception: " + e.toString()); 1440 } catch (SecurityException e) { 1441 System.out.println("Exception: " + e.toString()); 1442 } 1443 break; 1444 1445 case EventID.PROPERTYCHANGE: 1446 // Look for components which support PropertyChange listeners 1447 // (e.g. JComponent) 1448 // 1449 try { 1450 removePropertyChangeMethod = c.getClass().getMethod( 1451 "removePropertyChangeListener", propertyChangeListeners); 1452 addPropertyChangeMethod = c.getClass().getMethod( 1453 "addPropertyChangeListener", propertyChangeListeners); 1454 try { 1455 removePropertyChangeMethod.invoke(c, propertyChangeArgs); 1456 addPropertyChangeMethod.invoke(c, propertyChangeArgs); 1457 } catch (java.lang.reflect.InvocationTargetException e) { 1458 System.out.println("Exception: " + e.toString()); 1459 } catch (IllegalAccessException e) { 1460 System.out.println("Exception: " + e.toString()); 1461 } 1462 } catch (NoSuchMethodException e) { 1463 // System.out.println("Exception: " + e.toString()); 1464 } catch (SecurityException e) { 1465 System.out.println("Exception: " + e.toString()); 1466 } 1467 1468 // Look for components which support the getSelectionModel method 1469 // (e.g. JTextComponent) 1470 // 1471 try { 1472 getSelectionModelMethod = c.getClass().getMethod( 1473 "getSelectionModel", nullClass); 1474 try { 1475 Object o = getSelectionModelMethod.invoke(c, nullArgs); 1476 if (o != null && o instanceof TreeSelectionModel) { 1477 ((TreeSelectionModel) o).removePropertyChangeListener(this); 1478 ((TreeSelectionModel) o).addPropertyChangeListener(this); 1479 } 1480 } catch (java.lang.reflect.InvocationTargetException e) { 1481 System.out.println("Exception: " + e.toString()); 1482 } catch (IllegalAccessException e) { 1483 System.out.println("Exception: " + e.toString()); 1484 } 1485 } catch (NoSuchMethodException e) { 1486 // System.out.println("Exception: " + e.toString()); 1487 } catch (SecurityException e) { 1488 System.out.println("Exception: " + e.toString()); 1489 } 1490 break; 1491 1492 case EventID.VETOABLECHANGE: 1493 if (c instanceof JComponent) { 1494 ((JComponent) c).removeVetoableChangeListener(this); 1495 ((JComponent) c).addVetoableChangeListener(this); 1496 } 1497 break; 1498 1499 // Don't bother recursing the children if this isn't going to 1500 // accomplish anything. 1501 // 1502 default: 1503 return; 1504 } 1505 1506 if (c instanceof Container) { 1507 int count = ((Container) c).getComponentCount(); 1508 for (int i = 0; i < count; i++) { 1509 installListeners(((Container) c).getComponent(i), eventID); 1510 } 1511 } 1512 } 1513 1514 /** 1515 * Removes all listeners for the given component and all its children. 1516 * @param c the component 1517 */ removeListeners(Component c)1518 protected void removeListeners(Component c) { 1519 1520 // conditionaly remove the Swing listeners 1521 // 1522 if (SwingEventMonitor.listenerList.getListenerCount(AncestorListener.class) > 0) { 1523 removeListeners(c,EventID.ANCESTOR); 1524 } 1525 if (SwingEventMonitor.listenerList.getListenerCount(CaretListener.class) > 0) { 1526 removeListeners(c,EventID.CARET); 1527 } 1528 if (SwingEventMonitor.listenerList.getListenerCount(CellEditorListener.class) > 0) { 1529 removeListeners(c,EventID.CELLEDITOR); 1530 } 1531 if (SwingEventMonitor.listenerList.getListenerCount(ChangeListener.class) > 0) { 1532 removeListeners(c,EventID.CHANGE); 1533 } 1534 if (SwingEventMonitor.listenerList.getListenerCount(TableColumnModelListener.class) > 0) { 1535 removeListeners(c,EventID.COLUMNMODEL); 1536 } 1537 if (SwingEventMonitor.listenerList.getListenerCount(DocumentListener.class) > 0) { 1538 removeListeners(c,EventID.DOCUMENT); 1539 } 1540 if (SwingEventMonitor.listenerList.getListenerCount(ListDataListener.class) > 0) { 1541 removeListeners(c,EventID.LISTDATA); 1542 } 1543 if (SwingEventMonitor.listenerList.getListenerCount(ListSelectionListener.class) > 0) { 1544 removeListeners(c,EventID.LISTSELECTION); 1545 } 1546 if (SwingEventMonitor.listenerList.getListenerCount(MenuListener.class) > 0) { 1547 removeListeners(c,EventID.MENU); 1548 } 1549 if (SwingEventMonitor.listenerList.getListenerCount(PopupMenuListener.class) > 0) { 1550 removeListeners(c,EventID.POPUPMENU); 1551 } 1552 if (SwingEventMonitor.listenerList.getListenerCount(TableModelListener.class) > 0) { 1553 removeListeners(c,EventID.TABLEMODEL); 1554 } 1555 if (SwingEventMonitor.listenerList.getListenerCount(TreeExpansionListener.class) > 0) { 1556 removeListeners(c,EventID.TREEEXPANSION); 1557 } 1558 if (SwingEventMonitor.listenerList.getListenerCount(TreeModelListener.class) > 0) { 1559 removeListeners(c,EventID.TREEMODEL); 1560 } 1561 if (SwingEventMonitor.listenerList.getListenerCount(TreeSelectionListener.class) > 0) { 1562 removeListeners(c,EventID.TREESELECTION); 1563 } 1564 if (SwingEventMonitor.listenerList.getListenerCount(UndoableEditListener.class) > 0) { 1565 removeListeners(c,EventID.UNDOABLEEDIT); 1566 } 1567 if (SwingEventMonitor.listenerList.getListenerCount(InternalFrameListener.class) > 0) { 1568 removeListeners(c,EventID.INTERNALFRAME); 1569 } 1570 1571 // conditionaly remove the beans listeners 1572 // 1573 if (SwingEventMonitor.listenerList.getListenerCount(PropertyChangeListener.class) > 0) { 1574 removeListeners(c,EventID.PROPERTYCHANGE); 1575 } 1576 if (SwingEventMonitor.listenerList.getListenerCount(VetoableChangeListener.class) > 0) { 1577 removeListeners(c,EventID.VETOABLECHANGE); 1578 } 1579 1580 // Now remove the AWT listeners if needed. 1581 // 1582 super.removeListeners(c); 1583 } 1584 1585 /** 1586 * Removes all Swing listeners for the event ID from the component and 1587 * all of its children. 1588 * @param c the component to remove listeners from 1589 */ removeListeners(Component c, int eventID)1590 protected void removeListeners(Component c, int eventID) { 1591 1592 // remove the appropriate listener hook into this component 1593 // 1594 switch (eventID) { 1595 1596 case EventID.CONTAINER: 1597 //Never remove these because we're always interested in them 1598 // for our own use. 1599 break; 1600 1601 case EventID.ANCESTOR: 1602 if (c instanceof JComponent) { 1603 ((JComponent) c).removeAncestorListener(this); 1604 } 1605 break; 1606 1607 case EventID.CARET: 1608 try { 1609 removeCaretMethod = c.getClass().getMethod( 1610 "removeCaretListener", caretListeners); 1611 try { 1612 removeCaretMethod.invoke(c, caretArgs); 1613 } catch (java.lang.reflect.InvocationTargetException e) { 1614 System.out.println("Exception: " + e.toString()); 1615 } catch (IllegalAccessException e) { 1616 System.out.println("Exception: " + e.toString()); 1617 } 1618 } catch (NoSuchMethodException e) { 1619 // System.out.println("Exception: " + e.toString()); 1620 } catch (SecurityException e) { 1621 System.out.println("Exception: " + e.toString()); 1622 } 1623 break; 1624 1625 case EventID.CELLEDITOR: 1626 // Look for components which support the getCellEditor method 1627 // (e.g. JTable, JTree) 1628 // 1629 try { 1630 getCellEditorMethod = c.getClass().getMethod( 1631 "getCellEditorMethod", nullClass); 1632 try { 1633 Object o = getCellEditorMethod.invoke(c, nullArgs); 1634 if (o != null && o instanceof CellEditor) { 1635 ((CellEditor) o).removeCellEditorListener(this); 1636 } 1637 } catch (java.lang.reflect.InvocationTargetException e) { 1638 System.out.println("Exception: " + e.toString()); 1639 } catch (IllegalAccessException e) { 1640 System.out.println("Exception: " + e.toString()); 1641 } 1642 } catch (NoSuchMethodException e) { 1643 // System.out.println("Exception: " + e.toString()); 1644 } catch (SecurityException e) { 1645 System.out.println("Exception: " + e.toString()); 1646 } 1647 1648 // Look for components which support CellEditor listeners 1649 // (no current example) 1650 // 1651 try { 1652 removeCellEditorMethod = c.getClass().getMethod( 1653 "removeCellEditorListener", cellEditorListeners); 1654 try { 1655 removeCellEditorMethod.invoke(c, cellEditorArgs); 1656 } catch (java.lang.reflect.InvocationTargetException e) { 1657 System.out.println("Exception: " + e.toString()); 1658 } catch (IllegalAccessException e) { 1659 System.out.println("Exception: " + e.toString()); 1660 } 1661 } catch (NoSuchMethodException e) { 1662 // System.out.println("Exception: " + e.toString()); 1663 } catch (SecurityException e) { 1664 System.out.println("Exception: " + e.toString()); 1665 } 1666 break; 1667 1668 case EventID.CHANGE: 1669 // [[[FIXME: Need to add support for Style, StyleContext -pk ]]] 1670 1671 // Look for components which support Change listeners 1672 // (e.g. AbstractButton, Caret, JProgressBar, JSlider, 1673 // JTabbedpane, JTextComponent, JViewport) 1674 // 1675 try { 1676 removeChangeMethod = c.getClass().getMethod( 1677 "removeChangeListener", changeListeners); 1678 try { 1679 removeChangeMethod.invoke(c, changeArgs); 1680 } catch (java.lang.reflect.InvocationTargetException e) { 1681 System.out.println("Exception: " + e.toString()); 1682 } catch (IllegalAccessException e) { 1683 System.out.println("Exception: " + e.toString()); 1684 } 1685 } catch (NoSuchMethodException e) { 1686 // System.out.println("Exception: " + e.toString()); 1687 } catch (SecurityException e) { 1688 System.out.println("Exception: " + e.toString()); 1689 } 1690 1691 // Look for components which support the getModel method 1692 // whose model supports Change listeners 1693 // (e.g. BoundedRangeModel, ButtonModel, SingleSelectionModel) 1694 // 1695 try { 1696 getModelMethod = c.getClass().getMethod( 1697 "getModel", nullClass); 1698 try { 1699 Object o = getModelMethod.invoke(c, nullArgs); 1700 if (o != null) { 1701 removeChangeMethod = o.getClass().getMethod( 1702 "removeChangeListener", changeListeners); 1703 removeChangeMethod.invoke(o, changeArgs); 1704 } 1705 } catch (java.lang.reflect.InvocationTargetException e) { 1706 System.out.println("Exception: " + e.toString()); 1707 } catch (IllegalAccessException e) { 1708 System.out.println("Exception: " + e.toString()); 1709 } 1710 } catch (NoSuchMethodException e) { 1711 // System.out.println("Exception: " + e.toString()); 1712 } catch (SecurityException e) { 1713 System.out.println("Exception: " + e.toString()); 1714 } 1715 break; 1716 1717 case EventID.COLUMNMODEL: 1718 try { 1719 getColumnModelMethod = c.getClass().getMethod( 1720 "getTableColumnModel", nullClass); 1721 try { 1722 Object o = getColumnModelMethod.invoke(c, nullArgs); 1723 if (o != null && o instanceof TableColumnModel) { 1724 ((TableColumnModel) o).removeColumnModelListener(this); 1725 } 1726 } catch (java.lang.reflect.InvocationTargetException e) { 1727 System.out.println("Exception: " + e.toString()); 1728 } catch (IllegalAccessException e) { 1729 System.out.println("Exception: " + e.toString()); 1730 } 1731 } catch (NoSuchMethodException e) { 1732 // System.out.println("Exception: " + e.toString()); 1733 } catch (SecurityException e) { 1734 System.out.println("Exception: " + e.toString()); 1735 } 1736 break; 1737 1738 case EventID.DOCUMENT: 1739 // Look for components which support the getDocument method 1740 // (e.g. JTextComponent) 1741 // 1742 try { 1743 getDocumentMethod = c.getClass().getMethod( 1744 "getDocument", nullClass); 1745 try { 1746 Object o = getDocumentMethod.invoke(c, nullArgs); 1747 if (o != null && o instanceof Document) { 1748 ((Document) o).removeDocumentListener(this); 1749 } 1750 } catch (java.lang.reflect.InvocationTargetException e) { 1751 System.out.println("Exception: " + e.toString()); 1752 } catch (IllegalAccessException e) { 1753 System.out.println("Exception: " + e.toString()); 1754 } 1755 } catch (NoSuchMethodException e) { 1756 // System.out.println("Exception: " + e.toString()); 1757 } catch (SecurityException e) { 1758 System.out.println("Exception: " + e.toString()); 1759 } 1760 1761 // Look for components which support Document listeners 1762 // (no current example) 1763 // 1764 try { 1765 removeDocumentMethod = c.getClass().getMethod( 1766 "removeDocumentListener", documentListeners); 1767 try { 1768 removeDocumentMethod.invoke(c, documentArgs); 1769 } catch (java.lang.reflect.InvocationTargetException e) { 1770 System.out.println("Exception: " + e.toString()); 1771 } catch (IllegalAccessException e) { 1772 System.out.println("Exception: " + e.toString()); 1773 } 1774 } catch (NoSuchMethodException e) { 1775 // System.out.println("Exception: " + e.toString()); 1776 } catch (SecurityException e) { 1777 System.out.println("Exception: " + e.toString()); 1778 } 1779 break; 1780 1781 case EventID.LISTDATA: 1782 case EventID.TABLEMODEL: 1783 case EventID.TREEMODEL: 1784 try { 1785 getModelMethod = c.getClass().getMethod( 1786 "getModel", nullClass); 1787 try { 1788 Object o = getModelMethod.invoke(c, nullArgs); 1789 if (o != null) { 1790 if (eventID == EventID.LISTDATA && 1791 o instanceof ListModel) { 1792 ((ListModel) o).removeListDataListener(this); 1793 } else if (eventID == EventID.TABLEMODEL && 1794 o instanceof TableModel) { 1795 ((TableModel) o).removeTableModelListener(this); 1796 } else if ( 1797 o instanceof TreeModel) { 1798 ((TreeModel) o).removeTreeModelListener(this); 1799 } 1800 } 1801 } catch (java.lang.reflect.InvocationTargetException e) { 1802 System.out.println("Exception: " + e.toString()); 1803 } catch (IllegalAccessException e) { 1804 System.out.println("Exception: " + e.toString()); 1805 } 1806 } catch (NoSuchMethodException e) { 1807 // System.out.println("Exception: " + e.toString()); 1808 } catch (SecurityException e) { 1809 System.out.println("Exception: " + e.toString()); 1810 } 1811 break; 1812 1813 case EventID.LISTSELECTION: 1814 // Look for components which support ListSelectionListeners 1815 // (e.g. JList) 1816 // 1817 try { 1818 removeListSelectionMethod = c.getClass().getMethod( 1819 "removeListSelectionListener", listSelectionListeners); 1820 try { 1821 removeListSelectionMethod.invoke(c, listSelectionArgs); 1822 } catch (java.lang.reflect.InvocationTargetException e) { 1823 System.out.println("Exception: " + e.toString()); 1824 } catch (IllegalAccessException e) { 1825 System.out.println("Exception: " + e.toString()); 1826 } 1827 } catch (NoSuchMethodException e) { 1828 // System.out.println("Exception: " + e.toString()); 1829 } catch (SecurityException e) { 1830 System.out.println("Exception: " + e.toString()); 1831 } 1832 1833 // Look for selection models which support 1834 // ListSelectionListeners (e.g. JTable's selection model) 1835 // 1836 try { 1837 getSelectionModelMethod = c.getClass().getMethod( 1838 "getSelectionModel", nullClass); 1839 try { 1840 Object o = getSelectionModelMethod.invoke(c, nullArgs); 1841 if (o != null && o instanceof ListSelectionModel) { 1842 ((ListSelectionModel) o).removeListSelectionListener(this); 1843 } 1844 } catch (java.lang.reflect.InvocationTargetException e) { 1845 System.out.println("Exception: " + e.toString()); 1846 } catch (IllegalAccessException e) { 1847 System.out.println("Exception: " + e.toString()); 1848 } 1849 } catch (NoSuchMethodException e) { 1850 // System.out.println("Exception: " + e.toString()); 1851 } catch (SecurityException e) { 1852 System.out.println("Exception: " + e.toString()); 1853 } 1854 break; 1855 1856 case EventID.MENU: 1857 try { 1858 removeMenuMethod = c.getClass().getMethod( 1859 "removeMenuListener", menuListeners); 1860 try { 1861 removeMenuMethod.invoke(c, menuArgs); 1862 } catch (java.lang.reflect.InvocationTargetException e) { 1863 System.out.println("Exception: " + e.toString()); 1864 } catch (IllegalAccessException e) { 1865 System.out.println("Exception: " + e.toString()); 1866 } 1867 } catch (NoSuchMethodException e) { 1868 // System.out.println("Exception: " + e.toString()); 1869 } catch (SecurityException e) { 1870 System.out.println("Exception: " + e.toString()); 1871 } 1872 break; 1873 1874 case EventID.POPUPMENU: 1875 // Look for components which support PopupMenuListeners 1876 // (e.g. JPopupMenu) 1877 // 1878 try { 1879 removePopupMenuMethod = c.getClass().getMethod( 1880 "removePopupMenuListener", popupMenuListeners); 1881 try { 1882 removePopupMenuMethod.invoke(c, popupMenuArgs); 1883 } catch (java.lang.reflect.InvocationTargetException e) { 1884 System.out.println("Exception: " + e.toString()); 1885 } catch (IllegalAccessException e) { 1886 System.out.println("Exception: " + e.toString()); 1887 } 1888 } catch (NoSuchMethodException e) { 1889 // System.out.println("Exception: " + e.toString()); 1890 } catch (SecurityException e) { 1891 System.out.println("Exception: " + e.toString()); 1892 } 1893 1894 // Look for components which support getPopupMenu 1895 // (e.g. JMenu) 1896 // 1897 try { 1898 getPopupMenuMethod = c.getClass().getMethod( 1899 "getPopupMenu", nullClass); 1900 try { 1901 Object o = getPopupMenuMethod.invoke(c, nullArgs); 1902 if (o != null) { 1903 removePopupMenuMethod = o.getClass().getMethod( 1904 "removePopupMenuListener", popupMenuListeners); 1905 removePopupMenuMethod.invoke(o, popupMenuArgs); 1906 } 1907 } catch (java.lang.reflect.InvocationTargetException e) { 1908 System.out.println("Exception: " + e.toString()); 1909 } catch (IllegalAccessException e) { 1910 System.out.println("Exception: " + e.toString()); 1911 } 1912 } catch (NoSuchMethodException e) { 1913 // System.out.println("Exception: " + e.toString()); 1914 } catch (SecurityException e) { 1915 System.out.println("Exception: " + e.toString()); 1916 } 1917 break; 1918 1919 case EventID.TREEEXPANSION: 1920 try { 1921 removeTreeExpansionMethod = c.getClass().getMethod( 1922 "removeTreeExpansionListener", treeExpansionListeners); 1923 try { 1924 removeTreeExpansionMethod.invoke(c, treeExpansionArgs); 1925 } catch (java.lang.reflect.InvocationTargetException e) { 1926 System.out.println("Exception: " + e.toString()); 1927 } catch (IllegalAccessException e) { 1928 System.out.println("Exception: " + e.toString()); 1929 } 1930 } catch (NoSuchMethodException e) { 1931 // System.out.println("Exception: " + e.toString()); 1932 } catch (SecurityException e) { 1933 System.out.println("Exception: " + e.toString()); 1934 } 1935 break; 1936 1937 case EventID.TREESELECTION: 1938 try { 1939 removeTreeSelectionMethod = c.getClass().getMethod( 1940 "removeTreeSelectionListener", treeSelectionListeners); 1941 try { 1942 removeTreeSelectionMethod.invoke(c, treeSelectionArgs); 1943 } catch (java.lang.reflect.InvocationTargetException e) { 1944 System.out.println("Exception: " + e.toString()); 1945 } catch (IllegalAccessException e) { 1946 System.out.println("Exception: " + e.toString()); 1947 } 1948 } catch (NoSuchMethodException e) { 1949 // System.out.println("Exception: " + e.toString()); 1950 } catch (SecurityException e) { 1951 System.out.println("Exception: " + e.toString()); 1952 } 1953 break; 1954 1955 case EventID.UNDOABLEEDIT: 1956 // Look for components which support the getDocument method 1957 // (e.g. JTextComponent) 1958 // 1959 try { 1960 getDocumentMethod = c.getClass().getMethod( 1961 "getDocument", nullClass); 1962 try { 1963 Object o = getDocumentMethod.invoke(c, nullArgs); 1964 if (o != null && o instanceof Document) { 1965 ((Document) o).removeUndoableEditListener(this); 1966 } 1967 } catch (java.lang.reflect.InvocationTargetException e) { 1968 System.out.println("Exception: " + e.toString()); 1969 } catch (IllegalAccessException e) { 1970 System.out.println("Exception: " + e.toString()); 1971 } 1972 } catch (NoSuchMethodException e) { 1973 // System.out.println("Exception: " + e.toString()); 1974 } catch (SecurityException e) { 1975 System.out.println("Exception: " + e.toString()); 1976 } 1977 1978 // Look for components which support UndoableEdit listeners 1979 // (no current example) 1980 // 1981 try { 1982 removeUndoableEditMethod = c.getClass().getMethod( 1983 "removeUndoableEditListener", undoableEditListeners); 1984 try { 1985 removeUndoableEditMethod.invoke(c, undoableEditArgs); 1986 } catch (java.lang.reflect.InvocationTargetException e) { 1987 System.out.println("Exception: " + e.toString()); 1988 } catch (IllegalAccessException e) { 1989 System.out.println("Exception: " + e.toString()); 1990 } 1991 } catch (NoSuchMethodException e) { 1992 // System.out.println("Exception: " + e.toString()); 1993 } catch (SecurityException e) { 1994 System.out.println("Exception: " + e.toString()); 1995 } 1996 break; 1997 1998 case EventID.INTERNALFRAME: 1999 try { 2000 removeInternalFrameMethod = c.getClass().getMethod( 2001 "removeInternalFrameListener", internalFrameListeners); 2002 try { 2003 removeInternalFrameMethod.invoke(c, internalFrameArgs); 2004 } catch (java.lang.reflect.InvocationTargetException e) { 2005 System.out.println("Exception: " + e.toString()); 2006 } catch (IllegalAccessException e) { 2007 System.out.println("Exception: " + e.toString()); 2008 } 2009 } catch (NoSuchMethodException e) { 2010 // System.out.println("Exception: " + e.toString()); 2011 } catch (SecurityException e) { 2012 System.out.println("Exception: " + e.toString()); 2013 } 2014 break; 2015 2016 case EventID.PROPERTYCHANGE: 2017 // Look for components which support PropertyChange listeners 2018 // (e.g. JComponent) 2019 // 2020 try { 2021 removePropertyChangeMethod = c.getClass().getMethod( 2022 "removePropertyChangeListener", propertyChangeListeners); 2023 try { 2024 removePropertyChangeMethod.invoke(c, propertyChangeArgs); 2025 } catch (java.lang.reflect.InvocationTargetException e) { 2026 System.out.println("Exception: " + e.toString()); 2027 } catch (IllegalAccessException e) { 2028 System.out.println("Exception: " + e.toString()); 2029 } 2030 } catch (NoSuchMethodException e) { 2031 // System.out.println("Exception: " + e.toString()); 2032 } catch (SecurityException e) { 2033 System.out.println("Exception: " + e.toString()); 2034 } 2035 2036 // Look for components which support the getSelectionModel 2037 // method (e.g. JTextComponent) 2038 // 2039 try { 2040 getSelectionModelMethod = c.getClass().getMethod( 2041 "getSelectionModel", nullClass); 2042 try { 2043 Object o = getSelectionModelMethod.invoke(c, nullArgs); 2044 if (o != null && o instanceof TreeSelectionModel) { 2045 ((TreeSelectionModel) o).removePropertyChangeListener(this); 2046 } 2047 } catch (java.lang.reflect.InvocationTargetException e) { 2048 System.out.println("Exception: " + e.toString()); 2049 } catch (IllegalAccessException e) { 2050 System.out.println("Exception: " + e.toString()); 2051 } 2052 } catch (NoSuchMethodException e) { 2053 // System.out.println("Exception: " + e.toString()); 2054 } catch (SecurityException e) { 2055 System.out.println("Exception: " + e.toString()); 2056 } 2057 break; 2058 2059 case EventID.VETOABLECHANGE: 2060 if (c instanceof JComponent) { 2061 ((JComponent) c).removeVetoableChangeListener(this); 2062 } 2063 break; 2064 2065 default: 2066 return; 2067 } 2068 2069 if (c instanceof Container) { 2070 int count = ((Container) c).getComponentCount(); 2071 for (int i = 0; i < count; i++) { 2072 removeListeners(((Container) c).getComponent(i), eventID); 2073 } 2074 } 2075 } 2076 2077 /********************************************************************/ 2078 /* */ 2079 /* Listener Interface Methods */ 2080 /* */ 2081 /********************************************************************/ 2082 2083 /* ContainerListener Methods ************************************/ 2084 componentAdded(ContainerEvent e)2085 public void componentAdded(ContainerEvent e) { 2086 installListeners(e.getChild()); 2087 } componentRemoved(ContainerEvent e)2088 public void componentRemoved(ContainerEvent e) { 2089 removeListeners(e.getChild()); 2090 } 2091 2092 /* AncestorListener Methods ******************************************/ 2093 ancestorAdded(AncestorEvent e)2094 public void ancestorAdded(AncestorEvent e) { 2095 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2096 for (int i = listeners.length-2; i>=0; i-=2) { 2097 if (listeners[i]==AncestorListener.class) { 2098 ((AncestorListener)listeners[i+1]).ancestorAdded(e); 2099 } 2100 } 2101 } 2102 ancestorRemoved(AncestorEvent e)2103 public void ancestorRemoved(AncestorEvent e) { 2104 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2105 for (int i = listeners.length-2; i>=0; i-=2) { 2106 if (listeners[i]==AncestorListener.class) { 2107 ((AncestorListener)listeners[i+1]).ancestorRemoved(e); 2108 } 2109 } 2110 } 2111 ancestorMoved(AncestorEvent e)2112 public void ancestorMoved(AncestorEvent e) { 2113 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2114 for (int i = listeners.length-2; i>=0; i-=2) { 2115 if (listeners[i]==AncestorListener.class) { 2116 ((AncestorListener)listeners[i+1]).ancestorMoved(e); 2117 } 2118 } 2119 } 2120 2121 /* CaretListener Methods ******************************************/ 2122 caretUpdate(CaretEvent e)2123 public void caretUpdate(CaretEvent e) { 2124 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2125 for (int i = listeners.length-2; i>=0; i-=2) { 2126 if (listeners[i]==CaretListener.class) { 2127 ((CaretListener)listeners[i+1]).caretUpdate(e); 2128 } 2129 } 2130 } 2131 2132 /* CellEditorListener Methods *****************************************/ 2133 editingStopped(ChangeEvent e)2134 public void editingStopped(ChangeEvent e) { 2135 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2136 for (int i = listeners.length-2; i>=0; i-=2) { 2137 if (listeners[i]==CellEditorListener.class) { 2138 ((CellEditorListener)listeners[i+1]).editingStopped(e); 2139 } 2140 } 2141 } 2142 editingCanceled(ChangeEvent e)2143 public void editingCanceled(ChangeEvent e) { 2144 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2145 for (int i = listeners.length-2; i>=0; i-=2) { 2146 if (listeners[i]==CellEditorListener.class) { 2147 ((CellEditorListener)listeners[i+1]).editingCanceled(e); 2148 } 2149 } 2150 } 2151 2152 /* ChangeListener Methods *****************************************/ 2153 stateChanged(ChangeEvent e)2154 public void stateChanged(ChangeEvent e) { 2155 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2156 for (int i = listeners.length-2; i>=0; i-=2) { 2157 if (listeners[i]==ChangeListener.class) { 2158 ((ChangeListener)listeners[i+1]).stateChanged(e); 2159 } 2160 } 2161 } 2162 2163 /* TableColumnModelListener Methods *******************************/ 2164 columnAdded(TableColumnModelEvent e)2165 public void columnAdded(TableColumnModelEvent e) { 2166 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2167 for (int i = listeners.length-2; i>=0; i-=2) { 2168 if (listeners[i]==TableColumnModelListener.class) { 2169 ((TableColumnModelListener)listeners[i+1]).columnAdded(e); 2170 } 2171 } 2172 } columnMarginChanged(ChangeEvent e)2173 public void columnMarginChanged(ChangeEvent e) { 2174 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2175 for (int i = listeners.length-2; i>=0; i-=2) { 2176 if (listeners[i]==TableColumnModelListener.class) { 2177 ((TableColumnModelListener)listeners[i+1]).columnMarginChanged(e); 2178 } 2179 } 2180 } columnMoved(TableColumnModelEvent e)2181 public void columnMoved(TableColumnModelEvent e) { 2182 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2183 for (int i = listeners.length-2; i>=0; i-=2) { 2184 if (listeners[i]==TableColumnModelListener.class) { 2185 ((TableColumnModelListener)listeners[i+1]).columnMoved(e); 2186 } 2187 } 2188 } columnRemoved(TableColumnModelEvent e)2189 public void columnRemoved(TableColumnModelEvent e) { 2190 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2191 for (int i = listeners.length-2; i>=0; i-=2) { 2192 if (listeners[i]==TableColumnModelListener.class) { 2193 ((TableColumnModelListener)listeners[i+1]).columnRemoved(e); 2194 } 2195 } 2196 } columnSelectionChanged(ListSelectionEvent e)2197 public void columnSelectionChanged(ListSelectionEvent e) { 2198 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2199 for (int i = listeners.length-2; i>=0; i-=2) { 2200 if (listeners[i]==TableColumnModelListener.class) { 2201 ((TableColumnModelListener)listeners[i+1]).columnSelectionChanged(e); 2202 } 2203 } 2204 } 2205 2206 /* DocumentListener Methods **************************************/ 2207 changedUpdate(DocumentEvent e)2208 public void changedUpdate(DocumentEvent e) { 2209 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2210 for (int i = listeners.length-2; i>=0; i-=2) { 2211 if (listeners[i]==DocumentListener.class) { 2212 ((DocumentListener)listeners[i+1]).changedUpdate(e); 2213 } 2214 } 2215 } insertUpdate(DocumentEvent e)2216 public void insertUpdate(DocumentEvent e) { 2217 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2218 for (int i = listeners.length-2; i>=0; i-=2) { 2219 if (listeners[i]==DocumentListener.class) { 2220 ((DocumentListener)listeners[i+1]).insertUpdate(e); 2221 } 2222 } 2223 } removeUpdate(DocumentEvent e)2224 public void removeUpdate(DocumentEvent e) { 2225 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2226 for (int i = listeners.length-2; i>=0; i-=2) { 2227 if (listeners[i]==DocumentListener.class) { 2228 ((DocumentListener)listeners[i+1]).removeUpdate(e); 2229 } 2230 } 2231 } 2232 2233 /* ListDataListener Methods *****************************************/ 2234 contentsChanged(ListDataEvent e)2235 public void contentsChanged(ListDataEvent e) { 2236 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2237 for (int i = listeners.length-2; i>=0; i-=2) { 2238 if (listeners[i]==ListDataListener.class) { 2239 ((ListDataListener)listeners[i+1]).contentsChanged(e); 2240 } 2241 } 2242 } intervalAdded(ListDataEvent e)2243 public void intervalAdded(ListDataEvent e) { 2244 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2245 for (int i = listeners.length-2; i>=0; i-=2) { 2246 if (listeners[i]==ListDataListener.class) { 2247 ((ListDataListener)listeners[i+1]).intervalAdded(e); 2248 } 2249 } 2250 } intervalRemoved(ListDataEvent e)2251 public void intervalRemoved(ListDataEvent e) { 2252 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2253 for (int i = listeners.length-2; i>=0; i-=2) { 2254 if (listeners[i]==ListDataListener.class) { 2255 ((ListDataListener)listeners[i+1]).intervalRemoved(e); 2256 } 2257 } 2258 } 2259 2260 /* ListSelectionListener Methods ***********************************/ 2261 valueChanged(ListSelectionEvent e)2262 public void valueChanged(ListSelectionEvent e) { 2263 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2264 for (int i = listeners.length-2; i>=0; i-=2) { 2265 if (listeners[i]==ListSelectionListener.class) { 2266 ((ListSelectionListener)listeners[i+1]).valueChanged(e); 2267 } 2268 } 2269 } 2270 2271 /* MenuListener Methods *****************************************/ 2272 menuCanceled(MenuEvent e)2273 public void menuCanceled(MenuEvent e) { 2274 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2275 for (int i = listeners.length-2; i>=0; i-=2) { 2276 if (listeners[i]==MenuListener.class) { 2277 ((MenuListener)listeners[i+1]).menuCanceled(e); 2278 } 2279 } 2280 } menuDeselected(MenuEvent e)2281 public void menuDeselected(MenuEvent e) { 2282 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2283 for (int i = listeners.length-2; i>=0; i-=2) { 2284 if (listeners[i]==MenuListener.class) { 2285 ((MenuListener)listeners[i+1]).menuDeselected(e); 2286 } 2287 } 2288 } menuSelected(MenuEvent e)2289 public void menuSelected(MenuEvent e) { 2290 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2291 for (int i = listeners.length-2; i>=0; i-=2) { 2292 if (listeners[i]==MenuListener.class) { 2293 ((MenuListener)listeners[i+1]).menuSelected(e); 2294 } 2295 } 2296 } 2297 2298 /* PopupMenuListener Methods **************************************/ 2299 popupMenuWillBecomeVisible(PopupMenuEvent e)2300 public void popupMenuWillBecomeVisible(PopupMenuEvent e) { 2301 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2302 for (int i = listeners.length-2; i>=0; i-=2) { 2303 if (listeners[i]==PopupMenuListener.class) { 2304 ((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeVisible(e); 2305 } 2306 } 2307 } 2308 popupMenuWillBecomeInvisible(PopupMenuEvent e)2309 public void popupMenuWillBecomeInvisible(PopupMenuEvent e) { 2310 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2311 for (int i = listeners.length-2; i>=0; i-=2) { 2312 if (listeners[i]==PopupMenuListener.class) { 2313 ((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeInvisible(e); 2314 } 2315 } 2316 } 2317 popupMenuCanceled(PopupMenuEvent e)2318 public void popupMenuCanceled(PopupMenuEvent e) { 2319 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2320 for (int i = listeners.length-2; i>=0; i-=2) { 2321 if (listeners[i]==PopupMenuListener.class) { 2322 ((PopupMenuListener)listeners[i+1]).popupMenuCanceled(e); 2323 } 2324 } 2325 } 2326 2327 /* TableModelListener Methods **************************************/ 2328 tableChanged(TableModelEvent e)2329 public void tableChanged(TableModelEvent e) { 2330 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2331 for (int i = listeners.length-2; i>=0; i-=2) { 2332 if (listeners[i]==TableModelListener.class) { 2333 ((TableModelListener)listeners[i+1]).tableChanged(e); 2334 } 2335 } 2336 } 2337 2338 /* TreeExpansionListener Methods **********************************/ 2339 treeCollapsed(TreeExpansionEvent e)2340 public void treeCollapsed(TreeExpansionEvent e) { 2341 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2342 for (int i = listeners.length-2; i>=0; i-=2) { 2343 if (listeners[i]==TreeExpansionListener.class) { 2344 ((TreeExpansionListener)listeners[i+1]).treeCollapsed(e); 2345 } 2346 } 2347 } treeExpanded(TreeExpansionEvent e)2348 public void treeExpanded(TreeExpansionEvent e) { 2349 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2350 for (int i = listeners.length-2; i>=0; i-=2) { 2351 if (listeners[i]==TreeExpansionListener.class) { 2352 ((TreeExpansionListener)listeners[i+1]).treeExpanded(e); 2353 } 2354 } 2355 } 2356 2357 /* TreeModelListener Methods **********************************/ 2358 treeNodesChanged(TreeModelEvent e)2359 public void treeNodesChanged(TreeModelEvent e) { 2360 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2361 for (int i = listeners.length-2; i>=0; i-=2) { 2362 if (listeners[i]==TreeModelListener.class) { 2363 ((TreeModelListener)listeners[i+1]).treeNodesChanged(e); 2364 } 2365 } 2366 } treeNodesInserted(TreeModelEvent e)2367 public void treeNodesInserted(TreeModelEvent e) { 2368 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2369 for (int i = listeners.length-2; i>=0; i-=2) { 2370 if (listeners[i]==TreeModelListener.class) { 2371 ((TreeModelListener)listeners[i+1]).treeNodesInserted(e); 2372 } 2373 } 2374 } treeNodesRemoved(TreeModelEvent e)2375 public void treeNodesRemoved(TreeModelEvent e) { 2376 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2377 for (int i = listeners.length-2; i>=0; i-=2) { 2378 if (listeners[i]==TreeModelListener.class) { 2379 ((TreeModelListener)listeners[i+1]).treeNodesRemoved(e); 2380 } 2381 } 2382 } treeStructureChanged(TreeModelEvent e)2383 public void treeStructureChanged(TreeModelEvent e) { 2384 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2385 for (int i = listeners.length-2; i>=0; i-=2) { 2386 if (listeners[i]==TreeModelListener.class) { 2387 ((TreeModelListener)listeners[i+1]).treeStructureChanged(e); 2388 } 2389 } 2390 } 2391 2392 /* TreeSelectionListener Methods ***********************************/ 2393 valueChanged(TreeSelectionEvent e)2394 public void valueChanged(TreeSelectionEvent e) { 2395 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2396 for (int i = listeners.length-2; i>=0; i-=2) { 2397 if (listeners[i]==TreeSelectionListener.class) { 2398 ((TreeSelectionListener)listeners[i+1]).valueChanged(e); 2399 } 2400 } 2401 } 2402 2403 /* UndoableEditListener Methods **************************************/ 2404 undoableEditHappened(UndoableEditEvent e)2405 public void undoableEditHappened(UndoableEditEvent e) { 2406 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2407 for (int i = listeners.length-2; i>=0; i-=2) { 2408 if (listeners[i]==UndoableEditListener.class) { 2409 ((UndoableEditListener)listeners[i+1]).undoableEditHappened(e); 2410 } 2411 } 2412 } 2413 2414 /* InternalFrame Methods **********************************/ 2415 internalFrameOpened(InternalFrameEvent e)2416 public void internalFrameOpened(InternalFrameEvent e) { 2417 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2418 for (int i = listeners.length-2; i>=0; i-=2) { 2419 if (listeners[i]==InternalFrameListener.class) { 2420 ((InternalFrameListener)listeners[i+1]).internalFrameOpened(e); 2421 } 2422 } 2423 } 2424 internalFrameActivated(InternalFrameEvent e)2425 public void internalFrameActivated(InternalFrameEvent e) { 2426 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2427 for (int i = listeners.length-2; i>=0; i-=2) { 2428 if (listeners[i]==InternalFrameListener.class) { 2429 ((InternalFrameListener)listeners[i+1]).internalFrameActivated(e); 2430 } 2431 } 2432 } 2433 internalFrameDeactivated(InternalFrameEvent e)2434 public void internalFrameDeactivated(InternalFrameEvent e) { 2435 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2436 for (int i = listeners.length-2; i>=0; i-=2) { 2437 if (listeners[i]==InternalFrameListener.class) { 2438 ((InternalFrameListener)listeners[i+1]).internalFrameDeactivated(e); 2439 } 2440 } 2441 } 2442 internalFrameIconified(InternalFrameEvent e)2443 public void internalFrameIconified(InternalFrameEvent e) { 2444 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2445 for (int i = listeners.length-2; i>=0; i-=2) { 2446 if (listeners[i]==InternalFrameListener.class) { 2447 ((InternalFrameListener)listeners[i+1]).internalFrameIconified(e); 2448 } 2449 } 2450 } 2451 internalFrameDeiconified(InternalFrameEvent e)2452 public void internalFrameDeiconified(InternalFrameEvent e) { 2453 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2454 for (int i = listeners.length-2; i>=0; i-=2) { 2455 if (listeners[i]==InternalFrameListener.class) { 2456 ((InternalFrameListener)listeners[i+1]).internalFrameDeiconified(e); 2457 } 2458 } 2459 } 2460 internalFrameClosing(InternalFrameEvent e)2461 public void internalFrameClosing(InternalFrameEvent e) { 2462 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2463 for (int i = listeners.length-2; i>=0; i-=2) { 2464 if (listeners[i]==InternalFrameListener.class) { 2465 ((InternalFrameListener)listeners[i+1]).internalFrameClosing(e); 2466 } 2467 } 2468 } 2469 internalFrameClosed(InternalFrameEvent e)2470 public void internalFrameClosed(InternalFrameEvent e) { 2471 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2472 for (int i = listeners.length-2; i>=0; i-=2) { 2473 if (listeners[i]==InternalFrameListener.class) { 2474 ((InternalFrameListener)listeners[i+1]).internalFrameClosed(e); 2475 } 2476 } 2477 } 2478 2479 /* PropertyChangeListener Methods **********************************/ 2480 propertyChange(PropertyChangeEvent e)2481 public void propertyChange(PropertyChangeEvent e) { 2482 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2483 for (int i = listeners.length-2; i>=0; i-=2) { 2484 if (listeners[i]==PropertyChangeListener.class) { 2485 ((PropertyChangeListener)listeners[i+1]).propertyChange(e); 2486 } 2487 } 2488 // Re-add the monitor as a DocumentChangeListener if 2489 // the document changed in the text component. 2490 if (e.getSource() instanceof JTextComponent) { 2491 Document c = ((JTextComponent)e.getSource()).getDocument(); 2492 if (c == null) { 2493 return; 2494 } 2495 try { 2496 removeDocumentMethod = c.getClass().getMethod( 2497 "removeDocumentListener", documentListeners); 2498 addDocumentMethod = c.getClass().getMethod( 2499 "addDocumentListener", documentListeners); 2500 try { 2501 removeDocumentMethod.invoke(c, documentArgs); 2502 addDocumentMethod.invoke(c, documentArgs); 2503 } catch (java.lang.reflect.InvocationTargetException e2) { 2504 System.out.println("Exception: " + e2.toString()); 2505 } catch (IllegalAccessException e2) { 2506 System.out.println("Exception: " + e2.toString()); 2507 } 2508 } catch (NoSuchMethodException e2) { 2509 // System.out.println("Exception: " + e2.toString()); 2510 } catch (SecurityException e2) { 2511 System.out.println("Exception: " + e2.toString()); 2512 } 2513 } 2514 2515 } 2516 2517 /* VetoableChangeListener Methods **********************************/ 2518 vetoableChange(PropertyChangeEvent e)2519 public void vetoableChange(PropertyChangeEvent e) 2520 throws PropertyVetoException { 2521 Object[] listeners = SwingEventMonitor.listenerList.getListenerList(); 2522 for (int i = listeners.length-2; i>=0; i-=2) { 2523 if (listeners[i]==VetoableChangeListener.class) { 2524 ((VetoableChangeListener)listeners[i+1]).vetoableChange(e); 2525 } 2526 } 2527 } 2528 } 2529 } 2530