import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
private StarButton( double innerRadius, double outerRadius, boolean initialEnabledState, PInputEventListener inputEventHandler ) {
    super( ENABLED_FILL_COLOR, STROKE, Color.BLACK );
    DoubleGeneralPath starPath = new DoubleGeneralPath();
    double angle = -Math.PI / 2;
    starPath.moveTo( Math.cos( angle ) * outerRadius, Math.sin( angle ) * outerRadius );
    for ( int i = 0; i < NUM_POINTS * 2; i++ ) {
        angle += Math.PI / NUM_POINTS;
        double length = i % 2 == 0 ? innerRadius : outerRadius;
        starPath.lineTo( Math.cos( angle ) * length, Math.sin( angle ) * length );
    }
    starPath.closePath();
    setPathTo( starPath.getGeneralPath() );
    setEnabled( initialEnabledState );
    addInputEventListener( inputEventHandler );
    addInputEventListener( new CursorHandler() );
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public MoleculeBucketNode( final MoleculeBucket bucket ) {
    super( bucket, MODEL_VIEW_TRANSFORM );

    addLabelToContainer( new ZeroOffsetNode( new PNode() {{
        final HTMLNode label = new HTMLNode( ChemUtils.toSubscript( bucket.getShape().name ),
                                             Color.BLACK, new PhetFont( 18, true ) ) {{
            setOffset( 0, -getFullBounds().getHeight() / 2 );
        }};
        final MoleculeNode exampleMoleculeNode = new MoleculeNode( new Molecule( bucket.getShape() ) );
        MoleculeNode icon = new MoleculeNode( new Molecule( bucket.getShape() ) {{
            setPosition( MODEL_VIEW_TRANSFORM.viewToModel( new Vector2D( 0, 0 ) ) );
        }} ) {{
            setLabelVisible( false );
            scale( 0.5 );

            // don't show the mouse hand over it
            for ( PInputEventListener listener : Arrays.asList( getInputEventListeners() ) ) {
                removeInputEventListener( listener );
            }
        }};
        addChild( label );
        addChild( new ZeroOffsetNode( icon ) {{
            setOffset( -getFullBounds().getWidth() - 10, -getFullBounds().getHeight() / 2 );
        }} );
    }} ) );
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Process Events - Give each node in the pick path, starting at the bottom
 * most one, a chance to handle the event.
 * 
 * @param event event to be processed
 * @param eventType the type of event being processed
 */
public void processEvent(final PInputEvent event, final int eventType) {
    event.setPath(this);

    for (int i = nodeStack.size() - 1; i >= 0; i--) {
        final PNode each = (PNode) nodeStack.get(i);

        final EventListenerList list = each.getListenerList();

        if (list != null) {
            final Object[] listeners = list.getListeners(PInputEventListener.class);

            for (int j = 0; j < listeners.length; j++) {
                final PInputEventListener listener = (PInputEventListener) listeners[j];
                listener.processEvent(event, eventType);
                if (event.isHandled()) {
                    return;
                }
            }
        }
    }
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public void testCursorHandlerIsInstalledByDefault() {
    PSWTBoundsHandle handle = new PSWTBoundsHandle(PBoundsLocator.createEastLocator(node));
    PInputEventListener dragHandler = handle.getHandleDraggerHandler();
    PInputEventListener cursorHandler = handle.getHandleCursorEventHandler();
    assertNotNull(cursorHandler);
    PInputEventListener[] listeners = handle.getInputEventListeners();
    assertEquals(2, listeners.length);
    assertTrue(cursorHandler == listeners[0] || cursorHandler == listeners[1]);
    assertTrue(dragHandler == listeners[0] || dragHandler == listeners[1]);
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
private int getHandlerIndex(PInputEventListener handler) {
    PInputEventListener[] listeners = canvas.getCamera().getInputEventListeners();
    int handlerIndex = -1;
    for (int i = 0; i < listeners.length; i++) {
        if (listeners[i] == handler) {
            handlerIndex = i;
        }
    }
    return handlerIndex;
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public void testHandleHasDragHandlerInstalled() {
    PInputEventListener dragHandler = handle.getHandleDraggerHandler();
    assertNotNull(dragHandler);

    PInputEventListener[] installedListeners = handle.getInputEventListeners();
    assertEquals(1, installedListeners.length);
    assertSame(dragHandler, installedListeners[0]);
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Set the node that should receive key events.
 * 
 * @param eventHandler sets the keyboard event focus, may be null
 */
public void setKeyboardFocus(final PInputEventListener eventHandler) {
    final PInputEvent focusEvent = new PInputEvent(this, null);

    if (keyboardFocus != null) {
        dispatchEventToListener(focusEvent, FocusEvent.FOCUS_LOST, keyboardFocus);
    }

    keyboardFocus = eventHandler;

    if (keyboardFocus != null) {
        dispatchEventToListener(focusEvent, FocusEvent.FOCUS_GAINED, keyboardFocus);
    }
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Dispatches the given event to the listener, or does nothing if listener
 * is null.
 * 
 * @param event event to be dispatched
 * @param type type of event to dispatch
 * @param listener target of dispatch
 */
private void dispatchEventToListener(final PInputEvent event, final int type, final PInputEventListener listener) {
    if (listener != null) {
        // clear the handled bit since the same event object is used to send
        // multiple events such as mouseEntered/mouseExited and mouseMove.
        event.setHandled(false);
        listener.processEvent(event, type);
    }
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Removes the specified input event listener so that it no longer receives
 * input events from this node.
 * 
 * @param listener the input listener to remove
 */
public void removeInputEventListener(final PInputEventListener listener) {
    if (listenerList == null) {
        return;
    }
    getListenerList().remove(PInputEventListener.class, listener);
    if (listenerList.getListenerCount() == 0) {
        listenerList = null;
    }
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Returns an array of input event listeners that are attached to this node.
 * 
 * @since 1.3
 * @return event listeners attached to this node
 */
public PInputEventListener[] getInputEventListeners() {
    if (listenerList == null || listenerList.getListenerCount() == 0) {
        return new PInputEventListener[] {};
    }

    final EventListener[] listeners = listenerList.getListeners(PInputEventListener.class);

    final PInputEventListener[] result = new PInputEventListener[listeners.length];
    for (int i = 0; i < listeners.length; i++) {
        result[i] = (PInputEventListener) listeners[i];
    }
    return result;
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public void testAddInputEventListenersIsHonoured() {
    canvas.addInputEventListener(mockListener);
    final PInputEventListener[] listeners = canvas.getInputEventListeners();
    assertNotNull(listeners);
    assertEquals(3, listeners.length); // zoom + pan + mockListener
    // by default
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public void testRemoveInputEventListenersIsHonoured() {
    canvas.addInputEventListener(mockListener);
    canvas.removeInputEventListener(mockListener);
    final PInputEventListener[] listeners = canvas.getInputEventListeners();
    assertNotNull(listeners);
    assertEquals(2, listeners.length); // zoom + pan + mockListener
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
private boolean containsListener( PInputEventListener listener ) {
    return asList( getInputEventListeners() ).contains( listener );
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public synchronized void addInputEventListener( PInputEventListener l ) {
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public void testDefaultNumberOfEventListenersIs2() {
    final PInputEventListener[] listeners = canvas.getInputEventListeners();
    assertNotNull(listeners);
    assertEquals(2, listeners.length);
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
public PInputEventListener getKeyboardListener() {
    if (swingRenderer != null) {
        return swingRenderer;
    }
	return inputHandler;
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Adds a listener to the thumb, so we tell when we're dragging it.
 *
 * @param listener
 */
public void addThumbListener( PInputEventListener listener ) {
    thumb.addInputEventListener( listener );
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Add an input listener to the camera associated with this canvas.
 * 
 * @param listener listener to add to to the camera
 */
public void addInputEventListener(final PInputEventListener listener) {
    getCamera().addInputEventListener(listener);
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Remove an input listener to the camera associated with this canvas. Does
 * nothign is the listener is not found.
 * 
 * @param listener listener to remove from the set of event listeners
 *            attached to this canvas.
 */
public void removeInputEventListener(final PInputEventListener listener) {
    getCamera().removeInputEventListener(listener);
}
 

import edu.umd.cs.piccolo.event.PInputEventListener; //导入依赖的package包/类
/**
 * Return the node that currently has the keyboard focus. This node receives
 * the key events.
 * 
 * @return the current keyboard focus
 */
public PInputEventListener getKeyboardFocus() {
    return keyboardFocus;
}