Package edu.umd.cs.piccolo

Class PRoot

java.lang.Object
edu.umd.cs.piccolo.PNode
edu.umd.cs.piccolo.PRoot
All Implemented Interfaces:
Printable, Serializable, Cloneable
public class PRoot extends PNode
PRoot serves as the top node in Piccolo2D's runtime structure. The PRoot responsible for running the main UI loop that processes input from activities and external events.

Version:
1.1
Author:
Jesse Grosjean
See Also:

  • Field Details

    • PROPERTY_INPUT_SOURCES

      public static final String PROPERTY_INPUT_SOURCES
      The property name that identifies a change in the set of this root's input sources (see InputSource). In any property change event the new value will be a reference to the list of this root's input sources, but old value will always be null.
      See Also:

    • PROPERTY_CODE_INPUT_SOURCES

      public static final int PROPERTY_CODE_INPUT_SOURCES
      The property code that identifies a change in the set of this root's input sources (see InputSource). In any property change event the new value will be a reference to the list of this root's input sources, but old value will always be null.
      See Also:

    • PROPERTY_INTERACTING_CHANGED

      public static final String PROPERTY_INTERACTING_CHANGED
      The property name that identifies a change in this node's interacting state.
      Since:
      1.3
      See Also:

    • PROPERTY_CODE_INTERACTING_CHANGED

      public static final int PROPERTY_CODE_INTERACTING_CHANGED
      The property code that identifies a change in this node's interacting state.
      Since:
      1.3
      See Also:

    • processingInputs

      protected transient boolean processingInputs
      Whether this not is currently processing inputs.

    • processInputsScheduled

      protected transient boolean processInputsScheduled
      Whether this node needs to have its inputs processed.

  • Constructor Details

    • PRoot

      public PRoot()
      Construct a new PRoot(). Note the PCanvas already creates a basic scene graph for you so often you will not need to construct your own roots.

  • Method Details

    • addActivity

      public boolean addActivity(PActivity activity)
      Add an activity to the activity scheduler associated with this root. Activities are given a chance to run during each call to the roots processInputs method. When the activity has finished running it will automatically get removed.
      Overrides:
      addActivity in class PNode
      Parameters:
      activity - Activity that should be scheduled
      Returns:
      whether it has been scheduled (always true)

    • getActivityScheduler

      public PActivityScheduler getActivityScheduler()
      Get the activity scheduler associated with this root.
      Returns:
      associated scheduler

    • waitForActivities

      public void waitForActivities()
      Wait for all scheduled activities to finish before returning from this method. This will freeze out user input, and so it is generally recommended that you use PActivities.setTriggerTime() to offset activities instead of using this method.

    • getRoot

      public PRoot getRoot()
      Since getRoot is handled recursively, and root is the lowest point in the hierarchy, simply returns itself.
      Overrides:
      getRoot in class PNode
      Returns:
      itself

    • getDefaultInputManager

      public PInputManager getDefaultInputManager()
      Get the default input manager to be used when processing input events. PCanvas's use this method when they forward new swing input events to the PInputManager.
      Returns:
      a singleton instance of PInputManager

    • getInteracting

      public boolean getInteracting()
      Return true if this root has been marked as interacting. If so the root will normally render at a lower quality that is faster.
      Returns:
      true if this root has user interaction taking place
      Since:
      1.3

    • setInteracting

      public void setInteracting(boolean isInteracting)
      Set if this root is interacting. If so the root will normally render at a lower quality that is faster. Also repaints the root if the the interaction has ended.

      This has similar functionality to the setInteracting method on Canvas, but this is the appropriate place to mark interactions that may occur in multiple canvases if this Root is shared.

      Parameters:
      isInteracting - True if this root has user interaction taking place
      Since:
      1.3
      See Also:

    • addInputSource

      public void addInputSource(PRoot.InputSource inputSource)
      Advanced. If you want to add additional input sources to the roots UI process you can do that here. You will seldom do this unless you are making additions to the Piccolo2D framework.
      Parameters:
      inputSource - An input source that should be added

    • removeInputSource

      public void removeInputSource(PRoot.InputSource inputSource)
      Advanced. If you want to remove the default input source from the roots UI process you can do that here. You will seldom do this unless you are making additions to the Piccolo2D framework.
      Parameters:
      inputSource - input source that should no longer be asked about input events

    • createTimer

      public Timer createTimer(int delay, ActionListener listener)
      Returns a new timer. This method allows subclasses, such as PSWTRoot to create custom timers that will be used transparently by the Piccolo2D framework.
      Parameters:
      delay - # of milliseconds before action listener is invoked
      listener - listener to be invoked after delay
      Returns:
      A new Timer

    • getGlobalTime

      public long getGlobalTime()
      Get the global Piccolo2D time. This is set to System.currentTimeMillis() at the beginning of the roots processInputs method. Activities should usually use this global time instead of System. currentTimeMillis() so that multiple activities will be synchronized.
      Returns:
      time as recorded at the beginning of activity scheduling

    • processInputs

      public void processInputs()
      This is the heartbeat of the Piccolo2D framework. Pending input events are processed. Activities are given a chance to run, and the bounds caches and any paint damage is validated.

    • setFullBoundsInvalid

      public void setFullBoundsInvalid(boolean fullLayoutInvalid)
      Set the full bounds invalid flag. This flag is set when the full bounds of this node need to be recomputed as is the case when this node is transformed or when one of this node's children changes geometry.
      Overrides:
      setFullBoundsInvalid in class PNode
      Parameters:
      fullLayoutInvalid - true=invalid, false=valid

    • setChildBoundsInvalid

      public void setChildBoundsInvalid(boolean childLayoutInvalid)
      Set the flag indicating that one of this node's descendants has invalid bounds.
      Overrides:
      setChildBoundsInvalid in class PNode
      Parameters:
      childLayoutInvalid - true=invalid, false=valid

    • setPaintInvalid

      public void setPaintInvalid(boolean paintInvalid)
      Mark this node as having invalid paint. If this is set the node will later be repainted. Node this method is most often used internally.
      Overrides:
      setPaintInvalid in class PNode
      Parameters:
      paintInvalid - true if this node should be repainted

    • setChildPaintInvalid

      public void setChildPaintInvalid(boolean childPaintInvalid)
      Mark this node as having a child with invalid paint.
      Overrides:
      setChildPaintInvalid in class PNode
      Parameters:
      childPaintInvalid - true if this node has a child with invalid paint

    • scheduleProcessInputsIfNeeded

      public void scheduleProcessInputsIfNeeded()
      Schedule process inputs if needed.