Java ContainerListener类代码示例

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * Deserialize this Container:
 * <ol>
 * <li>Read from the stream the default serializable fields.</li>
 * <li>Read a list of serializable ContainerListeners as optional
 * data.  If the list is null, no listeners will be registered.</li>
 * <li>Read this Container's FocusTraversalPolicy as optional data.
 * If this is null, then this Container will use a
 * DefaultFocusTraversalPolicy.</li>
 * </ol>
 *
 * @param s the stream to read from
 * @throws ClassNotFoundException if deserialization fails
 * @throws IOException if the stream fails
 */
private void readObject (ObjectInputStream s)
  throws ClassNotFoundException, IOException
{
  s.defaultReadObject ();
  String key = (String) s.readObject ();
  while (key != null)
    {
      Object object = s.readObject ();
      if ("containerL".equals (key))
        addContainerListener((ContainerListener) object);
      // FIXME: under what key is the focus traversal policy stored?
      else if ("focusTraversalPolicy".equals (key))
        setFocusTraversalPolicy ((FocusTraversalPolicy) object);

      key = (String) s.readObject();
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
protected void processContainerEvent(ContainerEvent e) {
    // toolkit.lockAWT();
    // try {
    for (Iterator<?> i = containerListeners.getUserIterator(); i.hasNext();) {
        ContainerListener listener = (ContainerListener) i.next();

        switch (e.getID()) {
            case ContainerEvent.COMPONENT_ADDED:
                listener.componentAdded(e);
                break;
            case ContainerEvent.COMPONENT_REMOVED:
                listener.componentRemoved(e);
                break;
        }
    }
    // } finally {
    // toolkit.unlockAWT();
    // }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * Maps {@code Container.addContainerListener(ContainerListener)}
 * through queue
 */
public void addContainerListener(final ContainerListener containerListener) {
    runMapping(new MapVoidAction("addContainerListener") {
        @Override
        public void map() {
            ((Container) getSource()).addContainerListener(containerListener);
        }
    });
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * Maps {@code Container.removeContainerListener(ContainerListener)}
 * through queue
 */
public void removeContainerListener(final ContainerListener containerListener) {
    runMapping(new MapVoidAction("removeContainerListener") {
        @Override
        public void map() {
            ((Container) getSource()).removeContainerListener(containerListener);
        }
    });
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
public synchronized void addContainerListener(final ContainerListener l) {
    if (l == null) {
        return;
    }
    
    list.add(ContainerListener.class, l);
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
public synchronized void remove(final Component comp) {
	if(components == null){
		return;
	}
	
	final int index = components.indexOf(comp);
	if (index >= 0) {
		components.remove(index);
		comp.parent = null;
		
		final ViewGroup layoutView = (ViewGroup)getContainerViewAdAPI();
		final View subView = comp.getPeerAdAPI();
		if(layoutView != null && subView != null){
			ActivityManager.getActivity().runOnUiThread(new Runnable() {
				@Override
				public void run() {
					layoutView.removeView(subView);
				}
			});
		}
		
		{
			final ContainerEvent event = new ContainerEvent(this, ContainerEvent.COMPONENT_REMOVED, comp);
			final ContainerListener[] listener = list.getListeners(ContainerListener.class);
			for (int i = 0; i < listener.length; i++) {
				listener[i].componentRemoved(event);
			}
		}
	}
	
	if (layout != null) {
		layout.removeLayoutComponent(comp);
	}
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * Adds the specified container listener to this object's list of
 * container listeners.
 *
 * @param listener The listener to add.
 */
public synchronized void addContainerListener(ContainerListener listener)
{
  if (listener != null)
    {
      containerListener = AWTEventMulticaster.add(containerListener,
                                                  listener);
      newEventsOnly = true;
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * @since 1.4
 */
public synchronized ContainerListener[] getContainerListeners()
{
  return (ContainerListener[])
    AWTEventMulticaster.getListeners(containerListener,
                                     ContainerListener.class);
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * This method is called when a component is added to the container.
 *
 * @param event the <code>ContainerEvent</code> indicating component
 *          addition
 */
public void componentAdded(ContainerEvent event)
{
  if (applet != null)
    {
      ContainerListener[] l = applet.getContainerListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentAdded(event);
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * This method is called when a component is removed from the container.
 *
 * @param event the <code>ContainerEvent</code> indicating component removal
 */
public void componentRemoved(ContainerEvent event)
{
  if (applet != null)
    {
      ContainerListener[] l = applet.getContainerListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentRemoved(event);
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
private boolean isAddedTo(Container container) {
  for (ContainerListener listener : container.getContainerListeners()) {
    if (listener == this) {
      return true;
    }
  }
  return false;
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * This method is called when a component is added to the container.
 * 
 * @param event the <code>ContainerEvent</code> indicating component
 *          addition
 */
public void componentAdded(ContainerEvent event)
{
  if (applet != null)
    {
      ContainerListener[] l = applet.getContainerListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentAdded(event);
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
/**
 * This method is called when a component is removed from the container.
 * 
 * @param event the <code>ContainerEvent</code> indicating component removal
 */
public void componentRemoved(ContainerEvent event)
{
  if (applet != null)
    {
      ContainerListener[] l = applet.getContainerListeners();
      for (int i = 0; i < l.length; i++)
        l[i].componentRemoved(event);
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
public void componentAdded(ContainerEvent e) {
    if ((a != null) && (a instanceof ContainerListener)) {
        ((ContainerListener) a).componentAdded(e);
    }
    if ((b != null) && (b instanceof ContainerListener)) {
        ((ContainerListener) b).componentAdded(e);
    }
}
 

import java.awt.event.ContainerListener; //导入依赖的package包/类
public void componentRemoved(ContainerEvent e) {
    if ((a != null) && (a instanceof ContainerListener)) {
        ((ContainerListener) a).componentRemoved(e);
    }
    if ((b != null) && (b instanceof ContainerListener)) {
        ((ContainerListener) b).componentRemoved(e);
    }
}