jdk/src/share/classes/javax/swing/JLayer.java
changeset 3743 906063616ec2
parent 3737 83fb4621a129
child 3748 b88af44d77a8
equal deleted inserted replaced
3742:5e1b8bc3cb1a 3743:906063616ec2
   406         this.eventMask = layerEventMask;
   406         this.eventMask = layerEventMask;
   407         firePropertyChange("layerEventMask", oldEventMask, layerEventMask);
   407         firePropertyChange("layerEventMask", oldEventMask, layerEventMask);
   408         if (layerEventMask != oldEventMask) {
   408         if (layerEventMask != oldEventMask) {
   409             disableEvents(oldEventMask);
   409             disableEvents(oldEventMask);
   410             enableEvents(eventMask);
   410             enableEvents(eventMask);
   411             eventController.updateAWTEventListener(this);
   411             if (isDisplayable()) {
       
   412                 eventController.updateAWTEventListener(
       
   413                         oldEventMask, layerEventMask);
       
   414             }
   412         }
   415         }
   413     }
   416     }
   414 
   417 
   415     /**
   418     /**
   416      * Returns the bitmap of event mask to receive by this {@code JLayer}
   419      * Returns the bitmap of event mask to receive by this {@code JLayer}
   547     }
   550     }
   548 
   551 
   549     private void readObject(ObjectInputStream s)
   552     private void readObject(ObjectInputStream s)
   550             throws IOException, ClassNotFoundException {
   553             throws IOException, ClassNotFoundException {
   551         s.defaultReadObject();
   554         s.defaultReadObject();
   552         if (getUI() != null) {
   555         if (layerUI != null) {
   553             setUI(getUI());
   556             setUI(layerUI);
   554         }
   557         }
   555         if (getLayerEventMask() != 0) {
   558         if (eventMask != 0) {
   556             eventController.updateAWTEventListener(this);
   559             eventController.updateAWTEventListener(0, eventMask);
   557         }
   560         }
       
   561     }
       
   562 
       
   563     public void addNotify() {
       
   564         eventController.updateAWTEventListener(0, eventMask);
       
   565         super.addNotify();
       
   566     }
       
   567 
       
   568     public void removeNotify() {
       
   569         eventController.updateAWTEventListener(eventMask, 0);
       
   570         super.removeNotify();
   558     }
   571     }
   559 
   572 
   560     /**
   573     /**
   561      * static AWTEventListener to be shared with all AbstractLayerUIs
   574      * static AWTEventListener to be shared with all AbstractLayerUIs
   562      */
   575      */
   563     private static class LayerEventController implements AWTEventListener {
   576     private static class LayerEventController implements AWTEventListener {
   564         private ArrayList<WeakReference<JLayer>> layerList =
   577         private ArrayList<Long> layerMaskList =
   565                 new ArrayList<WeakReference<JLayer>>();
   578                 new ArrayList<Long>();
   566 
   579 
   567         private long currentEventMask;
   580         private long currentEventMask;
   568 
   581 
   569         @SuppressWarnings("unchecked")
   582         @SuppressWarnings("unchecked")
   570         public void eventDispatched(AWTEvent event) {
   583         public void eventDispatched(AWTEvent event) {
   584                     component = component.getParent();
   597                     component = component.getParent();
   585                 }
   598                 }
   586             }
   599             }
   587         }
   600         }
   588 
   601 
   589         private boolean layerListContains(JLayer l) {
   602         private void updateAWTEventListener(long oldEventMask, long newEventMask) {
   590             for (WeakReference<JLayer> layerWeakReference : layerList) {
   603             if (oldEventMask != 0) {
   591                 if (layerWeakReference.get() == l) {
   604                 layerMaskList.remove(oldEventMask);
   592                     return true;
   605             }
   593                 }
   606             if (newEventMask != 0) {
   594             }
   607                 layerMaskList.add(newEventMask);
   595             return false;
       
   596         }
       
   597 
       
   598         private void updateAWTEventListener(JLayer layer) {
       
   599             if (!layerListContains(layer) && layer.getLayerEventMask() != 0) {
       
   600                 layerList.add(new WeakReference<JLayer>(layer));
       
   601             }
   608             }
   602             long combinedMask = 0;
   609             long combinedMask = 0;
   603             Iterator<WeakReference<JLayer>> it = layerList.iterator();
   610             for (Long mask : layerMaskList) {
   604             while (it.hasNext()) {
   611                 combinedMask |= mask;
   605                 WeakReference<JLayer> weakRef = it.next();
       
   606                 JLayer currLayer = weakRef.get();
       
   607                 if (currLayer == null) {
       
   608                     it.remove();
       
   609                 } else {
       
   610                     combinedMask |= currLayer.getLayerEventMask();
       
   611                 }
       
   612             }
   612             }
   613             if (combinedMask == 0) {
   613             if (combinedMask == 0) {
   614                 removeAWTEventListener();
   614                 removeAWTEventListener();
   615                 layerList.clear();
       
   616             } else if (getCurrentEventMask() != combinedMask) {
   615             } else if (getCurrentEventMask() != combinedMask) {
   617                 removeAWTEventListener();
   616                 removeAWTEventListener();
   618                 addAWTEventListener(combinedMask);
   617                 addAWTEventListener(combinedMask);
   619             }
   618             }
       
   619             currentEventMask = combinedMask;
   620         }
   620         }
   621 
   621 
   622         private long getCurrentEventMask() {
   622         private long getCurrentEventMask() {
   623             return currentEventMask;
   623             return currentEventMask;
   624         }
   624         }
   629                     Toolkit.getDefaultToolkit().
   629                     Toolkit.getDefaultToolkit().
   630                             addAWTEventListener(LayerEventController.this, eventMask);
   630                             addAWTEventListener(LayerEventController.this, eventMask);
   631                     return null;
   631                     return null;
   632                 }
   632                 }
   633             });
   633             });
   634             currentEventMask = eventMask;
   634 
   635         }
   635         }
   636 
   636 
   637         private void removeAWTEventListener() {
   637         private void removeAWTEventListener() {
   638             AccessController.doPrivileged(new PrivilegedAction<Void>() {
   638             AccessController.doPrivileged(new PrivilegedAction<Void>() {
   639                 public Void run() {
   639                 public Void run() {
   640                     Toolkit.getDefaultToolkit().
   640                     Toolkit.getDefaultToolkit().
   641                             removeAWTEventListener(LayerEventController.this);
   641                             removeAWTEventListener(LayerEventController.this);
   642                     return null;
   642                     return null;
   643                 }
   643                 }
   644             });
   644             });
   645             currentEventMask = 0;
       
   646         }
   645         }
   647 
   646 
   648         private boolean isEventEnabled(long eventMask, int id) {
   647         private boolean isEventEnabled(long eventMask, int id) {
   649             return (((eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 &&
   648             return (((eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 &&
   650                     id >= ComponentEvent.COMPONENT_FIRST &&
   649                     id >= ComponentEvent.COMPONENT_FIRST &&