Chart2D. ITrace2D contains the values to
* display, the color for displaying and a suitable label. It may be seen as a
* trace of the Chart2D that displays it. TracePoint2D- instances or Arrays for unordered Data
* (in the order of adding) for fast performance. Even an ITrace2D
* constructed by a "function- Object" may be thinkable.
*
* There are various constraints for Traces:
* - ordered by x-values
* - ordered by the order of addPoint- invocation (control form
* outside)
* - unique, single x- values
* - limitation of tracepoints
* - time- critical (fast- changing tracepoints)
*
* Therefore there are various ITrace2D- implementations. Read
* their description to find the one you need. Some may not have been written
* yet.
*
* {@link java.lang.Comparable} should be implemented by using the internal * property zIndex (see {@link #getZIndex()}, {@link #setZIndex(Integer)}). *
*
{@link java.beans.PropertyChangeEvent} may be
* fired to {@link PropertyChangeListener} instances that register
* themselves with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
* getPropertyName() |
* getSource() |
* getOldValue() |
* getNewValue() |
*
|---|---|---|---|
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_ZINDEX}
* |
* {@link ITrace2D} that changed |
* {@link java.lang.Number}, the old value |
* {@link java.lang.Number}, the new value |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_MAX_X} |
* {@link ITrace2D} that changed |
* {@link java.lang.Double}, the old value |
* {@link java.lang.Double}, the new value |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_MIN_X} |
* {@link ITrace2D} that changed |
* {@link java.lang.Double}, the old value |
* {@link java.lang.Double}, the new value |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_MAX_Y} |
* {@link ITrace2D} that changed |
* {@link java.lang.Double}, the old value |
* {@link java.lang.Double}, the new value |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_MIN_Y} |
* {@link ITrace2D} that changed |
* {@link java.lang.Double}, the old value |
* {@link java.lang.Double}, the new value |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_TRACEPOINT}
* |
* {@link ITrace2D} that changed |
* {@link info.monitorenter.gui.chart.TracePoint2D}, the
* instance that was removed |
* null, indication that an instance was removed |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_TRACEPOINT}
* |
* {@link ITrace2D} that changed |
* null, indication that a value was added |
* {@link info.monitorenter.gui.chart.TracePoint2D}, the new
* instance that was added, identifying that an instance was removed |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_VISIBLE} |
* {@link ITrace2D} that changed |
* {@link java.lang.Boolean}, the old state. |
* {@link java.lang.Boolean}, the new state. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_PAINTERS} |
* {@link ITrace2D} that changed |
* null, indicating that a painter was added. |
* {@link info.monitorenter.gui.chart.ITracePainter}, the new
* painter. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_PAINTERS} |
* {@link ITrace2D} that changed |
* {@link info.monitorenter.gui.chart.ITracePainter}, the old
* painter. |
* null, indicating that a painter was removed. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_POINT_HIGHLIGHTERS_CHANGED}
* |
* {@link ITrace2D} that changed |
* null, indicating that a point highlighter was added. |
* {@link info.monitorenter.gui.chart.IPointPainter}, the
* new highlighter. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_POINT_HIGHLIGHTERS_CHANGED}
* |
* {@link ITrace2D} that changed |
* {@link info.monitorenter.gui.chart.IPointPainter}, the
* old highlighter. |
* null, indicating that a point highlighter was removed. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_PAINTERS} |
* {@link ITrace2D} that changed |
* {@link info.monitorenter.gui.chart.IPointPainter}, the
* old highlighter. |
* null, indicating that a highlighter was removed. |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_STROKE}
* |
* {@link ITrace2D} that changed |
* {@link java.awt.Stroke}, the old stroke. |
* {@link java.awt.Stroke}, the new stroke. |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_COLOR} |
* {@link ITrace2D} that changed |
* {@link java.awt.Color}, the new color. |
* {@link java.awt.Color}, the new color. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_ERRORBARPOLICY}
* |
* {@link ITrace2D} that changed |
* null, indicating that an error bar policy was added. |
* {@link info.monitorenter.gui.chart.IErrorBarPolicy}, the new
* error bar policy. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_ERRORBARPOLICY}
* |
* {@link ITrace2D} that changed |
* {@link info.monitorenter.gui.chart.IErrorBarPolicy}, the old
* error bar policy. |
* null, indicating that an error bar policy was removed. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_ERRORBARPOLICY_CONFIGURATION}
* |
* {@link ITrace2D} that notifies the change of the configured
* error bar policy. |
* null | *{@link info.monitorenter.gui.chart.IErrorBarPolicy}, the
* instance with the configuration change. |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_POINT_CHANGED}
* |
* {@link ITrace2D} that notifies the change of the contained
* trace point. |
* null because it would be too much overhead to store the old
* point in a additional instance as the original is modified in
* {@link TracePoint2D#setLocation(java.awt.geom.Point2D)}. |
* {@link TracePoint2D} the point whose location was modified. |
*
{@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_NAME} |
* {@link ITrace2D} that notifies the change. |
* {@link String}, the old value of
* {@link #getName()} |
* {@link String}, the new value of
* {@link #getName()} |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_PHYSICALUNITS}
* |
* {@link ITrace2D} that notifies the change. |
* {@link String}, the old value of
* {@link #getPhysicalUnits()} |
* {@link String}, the new value of
* {@link #getPhysicalUnits()} |
*
* {@link info.monitorenter.gui.chart.ITrace2D#PROPERTY_LABEL}
* (triggered by {@link #setName(String)} and
* {@link #setPhysicalUnits(String, String)}) |
* {@link ITrace2D} that notifies the change. |
* {@link String}, the old value of
* {@link #getLabel()} |
* {@link String}, the new value of
* {@link #getLabel()} |
*
*
* @author Achim Westermann
* @version $Revision: 1.41 $
*/
public interface ITrace2D extends PropertyChangeListener, Comparable
* TODO: change this to an interface and implement in abstract base class to
* hide constructor.
*
*
* @author Achim Westermann
* @version $Revision: 1.41 $
*/
public final class DistancePoint {
/** Constant for unfound distance. */
public static final DistancePoint EMPTY = new DistancePoint();
/** The measured distance. */
private double m_distance;
/** The point with the distance. */
private ITracePoint2D m_point;
/**
* Defcon.
*/
public DistancePoint() {
// nop.
}
/**
* @return the distance.
*/
public final double getDistance() {
return this.m_distance;
}
/**
* @return the point.
*/
public final ITracePoint2D getPoint() {
return this.m_point;
}
/**
* @param manhattandistance
* the manhattandistance to set
*/
public final void setDistance(final double manhattandistance) {
this.m_distance = manhattandistance;
}
/**
* @param point
* the point to set
*/
public final void setPoint(final ITracePoint2D point) {
this.m_point = point;
}
}
/**
* The property key defining the
* This is fired from
* Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*
*/
public static final String PROPERTY_ERRORBARPOLICY = "ITrace2D.PROPERTY_ERRORBARPOLICY";
/**
* The property key defining a change of the configuration of a contained
*
* This is fired whenever an
* Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*
*/
public static final String PROPERTY_ERRORBARPOLICY_CONFIGURATION = "ITrace2D.PROPERTY_ERRORBARPOLICY_CONFIGURATION";
/**
* The property key defining the
*
* This is no real property as the
*/
public static final String PROPERTY_LABEL = "ITrace2D.PROPERTY_LABEL";
/**
* The property key defining the
* Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
* Property change event with this property will be fired if method
*
*/
public static final String PROPERTY_POINT_CHANGED = "ITrace2D.PROPERTY_POINT_CHANGED";
/**
* The property key defining a change in the set of
* Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*
*/
public static final String PROPERTY_ZINDEX = "ITrace2D.PROPERTY_ZINDEX";
/**
* The minimum value for property zIndex: 0.
*
* @see #getZIndex()
* @see #setZIndex(Integer)
*/
public static final int Z_INDEX_MIN = 0;
/**
* The maximum value for property zIndex: 100.
*
* the descriptive name for this trace.
*
*
* @see #getZIndex()
* @see #setZIndex(Integer)
*/
public static final int ZINDEX_MAX = 100;
/**
* Adds a trace that "should" compute values from the points added via
* The given trace will be informed in case an add operation on this trace
* succeeds via
* It will be the last error bar policy to render (most forward on screen).
*
*
* @param errorBarPolicy
* the error bar policy to add for rendering this trace's error bars.
* @return true if the painter was added (same instance was not contained
* before).
*/
public boolean addErrorBarPolicy(IErrorBarPolicy< ? > errorBarPolicy);
/**
* Adds a trace point to the internal data.
*
* Warning:
*
*
* @see #addPoint(ITracePoint2D p)
* @param x
* the x-value of the point to add.
* @param y
* the y-value of the point to add.
*
* @return true if the operation was successful, false else.
*
**/
public boolean addPoint(double x, double y);
/**
* Adds the given
* Try to pass instances of
* Implementations decide whether the point will be accepted or not. So they
* have to update the internal properties
*
* @param p
* the point to add.
* @return true if the operation was successful, false else.
*/
public boolean addPoint(ITracePoint2D p);
/**
* Adds the given point painter to the internal set of point highlighters.
*
* It will be the last point painter to paint highlighting if highlighting is
* active.
*
*
* @param highlighter
* the highlighter to add for highlighting this trace.
*
* @return true if the highlighter was added (class of instance not contained
* before).
*/
public boolean addPointHighlighter(IPointPainter< ? > highlighter);
/**
* Registers a property change listener that will be informed about changes of
* the property identified by the given
*
* @param propertyName
* the name of the property the listener is interested in
* @param listener
* a listener that will only be informed if the property identified
* by the argument
* It will be the last painter to paint (most forward).
*
*
* @param painter
* the painter to add for rendering this trace.
* @return true if the painter was added (class of instance not contained
* before).
*/
public boolean addTracePainter(ITracePainter< ? > painter);
/**
* Returns true if the given painter is contained in this compound painter.
*
*
* @param painter
* the painter to check whether it is contained.
* @return true if the given painter is contained in this compound painter.
*/
public boolean containsTracePainter(final ITracePainter< ? > painter);
/**
* Method to trigger by
* Bound checks are performed and property change events for the properties
*
*
* @param changed
* the point that has been changed which may be a newly added point
* (from
* On the other hand only the corresponding
* The
*
* @return The chosen java.awt.Color or null if the decision for the color
* should be made by the corresponding
*
* @return the
* If this returns false, no error bars will be painted for this trace.
*
*
* @return true if this trace has error bars configured.
*/
public boolean getHasErrorBars();
/**
* Callback method for the
* This method should be implemented and finalized ASAP in the inheritance
* tree and rely on the property
*
* @return a String describing the Axis being accessed.
*/
public String getLabel();
/**
*
* Returns the maximum amount of {@link TracePoint2D} instances that may be
* added. For implementations that limit the maximum amount this is a
* reasonable amount. Non-limiting implementations should return
* {@link Integer#MAX_VALUE}. This allows to detect the unlimitedness. Of
* course no implementation could store that amount of points.
*
* The
*
* @return the maximum value of the internal data for the x- dimension.
*/
public double getMaxX();
/**
* Returns the maximum value to be displayed on the y- axis of the Chart2D.
* Implementations should be synchronized for multithreaded use. No exception
* is thrown. In case of empty data (no tracepoints) 0 should be returned.
* (watch division with zero).
*
*
* @return the maximum value of the internal data for the y- dimension.
*/
public double getMaxY();
/**
* Returns the minimum value to be displayed on the x- axis of the Chart2D.
*
* Implementations should be synchronized for multithreaded use. No exception
* is thrown. In case of empty data (no tracepoints) 0 should be returned.
* (watch division with zero).
*
* The
*
* @return the minimum value of the internal data for the x- dimension.
*/
double getMinX();
/**
* Returns the minimum value to be displayed on the y- axis of the Chart2D.
*
* Implementations should be synchronized for multithreaded use. No exception
* is thrown. In case of empty data (no tracepoints) 0 should be returned.
* (watch division with zero).
*
* The
*
* @return the name of this trace.
* @see #setName(String s)
*/
public String getName();
/**
* Returns the nearest point to the given normalized value coordinates of this
* trace in Euclid distance.
*
* Please note that the arguments must be normalized value coordinates like
* provided by a
* Using the Manhattan distance is much faster than Euclid distance as it only
* includes basic addition an absolute value for computation per point (vs.
* square root, addition and quadrature for Euclid distance). However the
* euclid distance spans a circle for the nearest points which is visually
* more normal for end users than the Manhattan distance which forms a rhombus
* and reaches far distances in only one dimension.
*
*
* @param x
* the x value as a normalized value between 0 and 1.0.
* @param y
* the x value as a normalized value between 0 and 1.0.
*
* @return the nearest point to the given normalized value coordinates of this
* trace in Euclid distance.
*/
public DistancePoint getNearestPointEuclid(double x, double y);
/**
* Returns the nearest point to the given normalized value coordinates of this
* trace in Manhattan distance.
*
* Please note that the arguments must be normalized value coordinates like
* provided by a
* Using the Manhattan distance is much faster than Euclid distance as it only
* includes basic addition an absolute value for computation per point (vs.
* square root, addition and quadrature for Euclid distance).
*
*
* @param x
* the x value as a normalized value between 0 and 1.0.
* @param y
* the x value as a normalized value between 0 and 1.0.
*
* @return the nearest point to the given normalized value coordinates of this
* trace in Manhattan distance.
*/
public DistancePoint getNearestPointManhattan(double x, double y);
/**
* Returns the concatenation
*
* @return the concatenation
*
* @return the physical unit string value for the x dimension.
* @see #setPhysicalUnits(String x,String y)
*/
public String getPhysicalUnitsX();
/**
* Returns the physical unit string value for the y dimension.
*
*
* @return the physical unit string value for the y dimension.
* @see #setPhysicalUnits(String x,String y)
*/
public String getPhysicalUnitsY();
/**
* Returns the
* This is used by the point highlighting feature:
*
*
* @param property
* one of the constants with the
*
* @return The amount of
*
* @return the Stroke that is used to render this instance.
* @see #setStroke(Stroke)
*/
public Stroke getStroke();
/**
* Returns the
*
* The original set should be returned by contract to allow adding painters
* "silently" (vs. using
*
*
* @return the
* A higher value will bring it more "to the front".
*
*
* @return the z-index that will define the order in which this instance will
* be painted.
*/
public Integer getZIndex();
/**
* Returns false if internal
*
* @return false if internal
*
* @return true if this instance should be rendered.
*/
public boolean isVisible();
/**
* Returns an
* Implementations should be synchronized. This method is meant to allow
* modifications of the intenal
* There is no guarantee that changes made to the contained tracepoints will
* be reflected in the display immediately. The order the iterator returns the
*
*
* @return an
*
* Returns the
* This is used by the point highlighting feature:
*
*/
public void removeAllPoints();
/**
* Remove a trace that "should" compute values from the points added via
*
*
* @param trace
* the trace that will calculate it's points from the added points of
* this trace.
* @return true if the given trace was removed (recognized by the means of
*
*
* @param errorBarPolicy
* the error bar policy to remove.
* @return true if the painter was removed (same instance contained before).
*/
public boolean removeErrorBarPolicy(IErrorBarPolicy< ? > errorBarPolicy);
/**
* Removes the given point from this trace.
*
*
* @param point
* the point to remove.
* @return true if the remove opertation was successful, false else.
*/
public boolean removePoint(ITracePoint2D point);
/**
* Removes the given point highlighter, if it's class is contained.
*
*
* @param highlighter
* the highlighter to remove.
*
* @return true if a point highlighter of the class of the given argument was
* removed.
*/
public boolean removePointHighlighter(final IPointPainter< ? > highlighter);
/**
* Unregisters a property change listener that has been registered for
* listening on all properties.
*
*
* @param listener
* a listener that will only be informed if the property identified
* by the argument
*
* @param property
* one of the constants with the
*
* @param painter
* the trace painter to remove.
* @return true if a trace painter of the class of the given argument was
* removed.
*/
public boolean removeTracePainter(final ITracePainter< ? > painter);
/**
* Set a
*
* @param color
* the Color to set.
*/
public void setColor(Color color);
/**
* Replaces all internal error bar policies by the new one.
*
*
* @param errorBarPolicy
* the new sole painter to use.
* @return the
*
* @param name
* the name for this trace.
*/
public void setName(String name);
/**
* Assigns a specific String representing the physical unit to the
*
* @param xunit
* the physical unit for the x axis.
* @param yunit
* the physical unit for the y axis.
*/
public void setPhysicalUnits(final String xunit, final String yunit);
/**
* Replaces all internal point highlighters by the new one.
*
*
* @param highlighter
* the new sole highlighter to use.
*
* @return the
* Not the best design to put this to an interface, but Char2D should handle
* this interface only.
*
*
* @param renderer
* The renderer to set.
*/
public void setRenderer(Chart2D renderer);
/**
* Allows to specify the rendering of the ITrace2D. This Stroke will be
* assigned to the {@link java.awt.Graphics2D} by the rendering
* {@link Chart2D} when painting this instance.
*
*
* @param stroke
* the stroke to use for painting this trace.
*/
public void setStroke(Stroke stroke);
/**
* Replaces all internal trace painters by the new one.
*
*
* @param painter
* the new sole painter to use.
* @return the
*
* @param visible
* true if this trace should be painted, false else.
*/
public void setVisible(boolean visible);
/**
* Sets the internal z-index property. This decides the order in which
* different traces within the same
* The higher the given value is the more this trace will be brought to front.
*
* The value must not be lower than {@link #Z_INDEX_MIN}(0) and higher than
* {@link #ZINDEX_MAX}(100).
*
* This might not be tested for increased performance but ignoring these
* bounds may result in wrong ordering of display.
*
*
* @param zIndex
* the z index of this trace - the lower the value the more in front
* the trace will appear amongst other traces in the same chart.
* @see #getZIndex()
*/
public void setZIndex(Integer zIndex);
/**
* Tests whether error bars are painted by this trace.
*
* Returns true if
*
*
* @return true if this trace renders error bars.
*/
public boolean showsErrorBars();
/**
* Tests whether error bars in negative x direction are painted by this trace.
*
* Returns true if
*
*
* @return true if this trace renders error bars in negative x direction.
*/
public boolean showsNegativeXErrorBars();
/**
* Tests whether error bars in negative y direction are painted by this trace.
*
* Returns true if
*
*
* @return true if this trace renders error bars in negative y direction.
*/
public boolean showsNegativeYErrorBars();
/**
* Tests whether error bars in positive x direction are painted by this trace.
*
* Returns true if
*
*
* @return true if this trace renders error bars in positive x direction.
*/
public boolean showsPositiveXErrorBars();
/**
* Tests whether error bars in positive y direction are painted by this trace.
*
* Returns true if
*
*
* @return true if this trace renders error bars in positive y direction.
*/
public boolean showsPositiveYErrorBars();
}
color property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_COLOR = "ITrace2D.PROPERTY_COLOR";
/**
* The property key defining a change of {@link IErrorBarPolicy}
* instances contained.
* {@link #addErrorBarPolicy(IErrorBarPolicy)}, {@link #removeErrorBarPolicy(IErrorBarPolicy)} and
* {@link #setErrorBarPolicy(IErrorBarPolicy)}.
* {@link IErrorBarPolicy}.
* IErrorBarPolicy notifies this
* instance of a configuration change via an event for
* {@link IErrorBarPolicy#PROPERTY_CONFIGURATION}.
* label property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
* {@link #getLabel()} access two
* other fields.
* maxX property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_MAX_X = "ITrace2D.PROPERTY_MAX_X";
/**
* The property key defining the maxY property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_MAX_Y = "ITrace2D.PROPERTY_MAX_Y";
/**
* The property key defining the minX property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_MIN_X = "ITrace2D.PROPERTY_MIN_X";
/**
* The property key defining the minY property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_MIN_Y = "ITrace2D.PROPERTY_MIN_Y";
/**
* The property key defining the name property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_NAME = "ITrace2D.PROPERTY_NAME";
/**
* The property key defining a change in the set of
* {@link ITracePainter}
* instances. Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_PAINTERS = "ITrace2D.PROPERTY_PAINTERS";
/**
* The property key defining the physicalUnits property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_PHYSICALUNITS = "ITrace2D.PROPERTY_PHYSICALUNITS";
/**
* The property key defining any change of a location of a contained
* {@link TracePoint2D}
* .
* {@link TracePoint2D#setLocation(java.awt.geom.Point2D)} or
* {@link TracePoint2D#setLocation(double, double)} of any
* contained point is invoked.
*
* {@link IPointPainter}
* instances. Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_POINT_HIGHLIGHTERS_CHANGED = "ITrace2D.PROPERTY_POINT_HIGHLIGHTERS_CHANGED";
/**
* The property key defining the stroke property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_STROKE = "ITrace2D.PROPERTY_STROKE";
/**
* The property key defining a change in the collection of
* {@link TracePoint2D}
* instances within this trace. Use in combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_TRACEPOINT = "ITrace2D.PROPERTY_TRACEPOINT";
/**
* The property key defining the visible property. Use in
* combination with
* {@link #addPropertyChangeListener(String, PropertyChangeListener)}.
*/
public static final String PROPERTY_VISIBLE = "ITrace2D.PROPERTY_VISIBLE";
/**
* The property key defining the zIndex property.
*
* {@link #addPoint(ITracePoint2D)}
* .
* {@link #addPoint(ITracePoint2D)}.
*
* @param trace
* the trace that will calculate it's points from the added points of
* this trace.
*/
public void addComputingTrace(ITrace2D trace);
/**
* Adds the given error bar policy to the internal set of error bar policies.
*
* Do not call this method before this trace has been added to a chart or you
* will not succeed as the chart is needed to get the proper
* {@link Chart2D#getTracePointProvider()}.
* TracePoint2D to the internal data.
* TracePoint2D to this instance instead
* of invoking {@link #addPoint(double, double)} to increase
* performance. Else the given point has to be copied into such an instance
* from the other method and delegated to this method.
* minX, maxX,maxY and minY and also care about firing
* property change events for those properties by method
*
* {@link java.beans.PropertyChangeSupport#firePropertyChange(java.beans.PropertyChangeEvent)}.
* propertyName.
* propertyName changes
*/
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener);
/**
* Adds the given trace painter to the internal set of trace painters.
* {@link TracePoint2D#setLocation(double, double)}
* , {@link #addPoint(ITracePoint2D)}
* or
* {@link #removePoint(ITracePoint2D)}.
* {@link ITrace2D#PROPERTY_MAX_X},
* {@link ITrace2D#PROPERTY_MIN_X},
* {@link ITrace2D#PROPERTY_MAX_Y} and
* {@link ITrace2D#PROPERTY_MIN_Y} are fired if the add bounds
* have changed due to the modification of the point.
* {@link #addPoint(ITracePoint2D)}, a removed one
* or a modified one.
* @param state
* one of {{@link ITracePoint2D#STATE_ADDED},
* {@link ITracePoint2D#STATE_CHANGED},
* {@link ITracePoint2D#STATE_REMOVED} to inform about the
* type of change.
*/
public void firePointChanged(final ITracePoint2D changed, final int state);
/**
* Because the color is data common to a trace of a Chart2D it is
* stored here.
* Chart2D may detect
* the same color chosen for different IChart2D instances to be
* displayed. Therefore it is allowed to return null. This is a message to the
* Chart2D to leave it the choice of the color. Then the
* Chart2D will chose a color not owned by another
* ITrace2D instance managed and assign it to the null- returning
* instance.
* Chart2D will often call this method. So try to cache the
* value in implementation and only check on modifications of
* TracePoint instances or on add- invocations for
* changes.
* Chart2D.
*/
public Color getColor();
/**
* Returns the Set<{@link IErrorBarPolicy}> that will be used to render
* error bars for this trace.
* Set<{@link IErrorBarPolicy}> that will be
* used to render error bars for this trace.
*/
public SetChart2D that returns a
* String describing the label of the ITrace2D that
* will be displayed below the drawing area of the Chart2D.
* name and
* physicalUnits.
* Chart2D. Implementations should be synchronized for
* multithreaded use. No exception is thrown. In case of empty data (no
* tracepoints) 0 should be returned, to let the Chart2D know.
* Chart2D will often call this method. So try to cache the
* value in implementation and only check on modifications of
* TracePoint instances or on add- invocations for
* changes.
* Chart2D will often call this method. So try to cache the
* value in implementation and only check on modifications of
* TracePoint instances or on add- invocations for
* changes.
* Chart2D will often call this method. So try to cache the
* value in implementation and only check on modifications of
* TracePoint instances or on add- invocations for
* changes.
* {@link TracePoint2D#getScaledX()} or the
* division of a pixel coordinate by the total pixel range of the chart.
* {@link TracePoint2D#getScaledX()} or the
* division of a pixel coordinate by the total pixel range of the chart.
* [x: "{@link #getPhysicalUnitsX()}", y: "
* {@link #getPhysicalUnitsY()}"].
* [x: "{@link #getPhysicalUnitsX()}", y: "
* {@link #getPhysicalUnitsY()}"].
* @see #setPhysicalUnits(String x,String y)
*/
public String getPhysicalUnits();
/**
* Returns the physical unit string value for the x dimension.
* Set<{@link IPointPainter}> that may be used to highlight
* points of this trace.
* {@link Chart2D#enablePointHighlighting(boolean)}
*
* @return the Set<{@link IPointPainter}> that may be used
* to highlight points.
*/
public SetPROPERTY_ prefix
* defined in this class or subclasses.
* @return the property change listeners for the given property.
*/
public PropertyChangeListener[] getPropertyChangeListeners(String property);
/**
* @return Returns the renderer.
*/
public Chart2D getRenderer();
/**
* Returns the amount of {@link TracePoint2D} instances currently contained.
* {@link TracePoint2D} instances currently
* contained.
*/
public int getSize();
/**
* Returns the Stroke that is used to render this instance.
* Set<{@link ITracePainter}> that will be used to paint
* this trace.
* {@link ITrace2D#addTracePainter(ITracePainter)}).
* Set<{@link ITracePainter}> that will be used
* to paint this trace.
*/
public Set{@link TracePoint2D} instances are
* contained or true if not.
* {@link TracePoint2D}
* instances are contained or true if not.
*/
public boolean isEmpty();
/**
* Returns true if this instance should be rendered.
* Iterator over the internal
* {@link TracePoint2D}
* instances.
* TracePoint2D instances, so the
* original points should be returned.
* TracePoint2D instances decides how the Chart2D
* will paint the trace.
* Iterator over the internal
* {@link TracePoint2D} instances.
*/
public IteratorSet<{@link IPointPainter}> that was used to highlight
* points.
* {@link Chart2D#enablePointHighlighting(boolean)}
*
* @return the Set<{@link IPointPainter}> that was be used
* to highlight points.
*/
public SetTracePoint2D.{@link #isEmpty()} will
* return true afterwards.
* {@link #addPoint(ITracePoint2D)}.
* {@link Object#equals(Object)}).
*/
public boolean removeComputingTrace(ITrace2D trace);
/**
* Removes the given error bar policy from the internal set of error bar
* policies.
* propertyName changes
*/
public void removePropertyChangeListener(PropertyChangeListener listener);
/**
* Removes a property change listener for listening on the given property.
* PROPERTY_ prefix
* defined in this class or subclasses.
* @param listener
* the listener for this property change.
*/
public void removePropertyChangeListener(String property, PropertyChangeListener listener);
/**
* Removes the given trace painter, if it's class is contained and if more
* painters are remaining.
* java.awt.Color for this trace.
* Set<{@link IErrorBarPolicy}> that was used
* before.
*/
public SetITrace2D which will be
* displayed by the Chart2D.
*
* ITrace2D
* (e.g. Volt, Ohm, lux, ...) which will be displayed by the
* {@link Chart2D}
* Set<{@link IPointPainter}> that was used
* before or null if nothing changed.
*/
public SetSet<{@link ITracePainter}> that was used
* before.
*/
public Set{@link Chart2D} are painted.
*
*
*
*
*
*
*
*
*
*
*