Class AbstractGraph<B>

Object
UIObject
Widget
Panel
SimplePanel
FocusPanel
AbstractGraph<B>
Type Parameters:
B - the type of buffer backing the graph (may be null if the graph does not use a RingBuffer): typically this is double[] but in some cases Color[], String[] or MeshLambertMaterial[] for Pop2D, PopGraph2D or PopGraph3D, respectively.
All Implemented Interfaces:
HasAllDragAndDropHandlers, HasAllFocusHandlers, HasAllGestureHandlers, HasAllKeyHandlers, HasAllMouseHandlers, HasAllTouchHandlers, HasBlurHandlers, HasClickHandlers, HasContextMenuHandlers, HasDoubleClickHandlers, HasDragEndHandlers, HasDragEnterHandlers, HasDragHandlers, HasDragLeaveHandlers, HasDragOverHandlers, HasDragStartHandlers, HasDropHandlers, HasFocusHandlers, HasGestureChangeHandlers, HasGestureEndHandlers, HasGestureStartHandlers, HasKeyDownHandlers, HasKeyPressHandlers, HasKeyUpHandlers, HasMouseDownHandlers, HasMouseMoveHandlers, HasMouseOutHandlers, HasMouseOverHandlers, HasMouseUpHandlers, HasMouseWheelHandlers, HasTouchCancelHandlers, HasTouchEndHandlers, HasTouchMoveHandlers, HasTouchStartHandlers, MouseDownHandler, MouseMoveHandler, MouseOutHandler, MouseUpHandler, MouseWheelHandler, TouchEndHandler, TouchMoveHandler, TouchStartHandler, HasAttachHandlers, EventHandler, HasHandlers, EventListener, AcceptsOneWidget, Focusable, HasFocus, HasOneWidget, HasVisibility, HasWidgets, HasWidgets.ForIsWidget, IsWidget, RequiresResize, SourcesClickEvents, SourcesFocusEvents, SourcesKeyboardEvents, SourcesMouseEvents, SourcesMouseWheelEvents, Iterable<Widget>, ContextMenu.Listener, ContextMenu.Provider, Tooltip.Provider
Direct Known Subclasses:
GenericPopGraph, HistoGraph, LineGraph, ParaGraph, S3Graph
public abstract class AbstractGraph<B> extends FocusPanel implements MouseOutHandler, MouseWheelHandler, MouseDownHandler, MouseUpHandler, MouseMoveHandler, TouchStartHandler, TouchEndHandler, TouchMoveHandler, RequiresResize, Tooltip.Provider, ContextMenu.Listener, ContextMenu.Provider
Abstract base class for 2D graphs rendered into a Canvas within the UI.

This class encapsulates common functionality required by a variety of concrete graph implementations: managing the canvas and its high-DPI scaling, calculating drawing bounds, handling user interactions (mouse and touch) for panning and zooming, integrating with shared UI utilities (tooltip and context menu), buffering historical data, and providing a comprehensive set of drawing helpers for frames, axes, ticks, levels, markers and primitive shapes.

Generic parameter

The type parameter <B> denotes the element type stored in an optional RingBuffer used for graphs that maintain historical data (for example time-series or trajectory graphs).

Primary responsibilities

  • Allocate and manage a Canvas element and a wrapped 2D rendering context (MyContext2d) tuned for device pixel ratio (retina/high-DPI) support.
  • Compute and maintain drawing bounds that leave room for frames, labels, ticks and tick labels while exposing helper methods to draw full graph frames (axes, tick marks, tick labels, grid levels and custom levels).
  • Provide a pluggable styling model (GraphStyle) and helpers to render axes labels, graph title, and common primitives (lines, circles, filled paths, rectangles and vertical text).
  • Offer a unified interaction model for shifting (panning) and zooming including mouse drag, mouse wheel, single- and multi-touch gestures, pinch-to-zoom, and inertial visual feedback via CSS classes and a scheduled timer.
  • Integrate with shared UI widgets: Tooltip (for hover/touch info) and ContextMenu (for buffer size, log-scale and zoom actions). Subclasses and the owning AbstractView can extend and populate the context menu.
  • Maintain an optional RingBuffer<B> for historical data and provide a small context menu for configuring buffer capacity. Subclasses may implement exporting of trajectory/history data when relevant.

Interfaces and Extension Points

AbstractGraph provides inner interfaces that concrete graphs and/or their containing view may implement to customize interaction behavior:

  • Shifting — marker indicating the graph supports shifting. Implementing classes can provide custom shift behavior by implementing Shifter, and can optionally override mouse/touch handlers if they need finer control.
  • Shifter — single method shift(int dx, int dy) used by the base class to move the view corner when panning. The default implementation in AbstractGraph updates the viewCorner constrained to valid extents.
  • Zooming — marker indicating the graph supports zooming. It extends Zoomer and MouseWheelHandler. It documents a default ZOOM_INCR and ZOOM_MAX. Implementations can override zoom behaviour; otherwise the base-class provides sensible defaults.
  • Zoomer — single method zoom(double zoom, int x, int y) used to apply zoom centered on a particular screen coordinate. Subclasses or the containing view can provide custom coordinate-space or content-level behavior by implementing Zoomer.
  • HasLogScaleY — marker for graphs that may support logarithmic Y scaling; the graph will enable/disable the log-y context menu item appropriately.
  • HasTrajectory — marker for graphs that can export trajectories; such graphs should implement an exportTrajectory(StringBuilder) routine.

Lifecycle

Typical lifecycle methods:

  • onLoad() — allocates the LayoutPanel wrapper and Canvas, obtains shared Tooltip and ContextMenu instances and configures them, and sets the rendering scale based on device pixel ratio.
  • onUnload() — removes and nulls references to DOM components and unregisters from shared widgets.
  • activate() — attaches mouse and touch handlers for zooming and shifting depending on which interfaces are implemented and on the environment (e.g. special handling for ePub readers).
  • deactivate() — removes all registered input handlers, closes tooltip and context menu, and cancels transient state.
  • onResize() — closes transient UI (tooltip/context menu), updates the canvas coordinate space and recalculates drawing bounds.

Interaction semantics

  • Mouse wheel: zooms with inertia. The wheel delta is converted to a multiplicative zoom factor (ZOOM_INCR ^ -deltaY) and the zoom center is the current mouse position. A CSS class is briefly applied while inertia is present.
  • Mouse drag with left button: initiates panning (shifting) of the viewport when the graph implements Shifting. A CSS class is applied to indicate view movement while dragging.
  • Touch: short taps and long touches are distinguished. Long single touches allow panning; two-finger long touches initiate pinch-to-zoom with the center of the pinch used as zoom focus. Touch handlers preventDefault() for panning and pinch gestures to avoid scrolling the page when interacting with the graph.
  • All interactions are no-ops when a textual message is shown on the graph (hasMessage flag) to avoid conflicting updates.

Canvas & scaling

The canvas coordinate space is scaled by the detected device pixel ratio to support crisp rendering on high-DPI displays. updateCanvas() sets both the CSS pixel size and the coordinate space (scaled) size; note that setting these properties clears the canvas, so callers should repaint after resizing.

Painting and Helpers

Subclasses must implement export(MyContext2d) and typically override paint() to perform actual rendering. AbstractGraph provides:

  • Utility primitives for drawing and filling complex paths efficiently (sketch/stroke/fill) with segmentation to avoid freezing the UI.
  • Convenience methods for drawing frames, axis labels, ticks, tick labels (including percent/log formatting), grid levels, and custom level lines.
  • Primitives for circles, lines, rectangles and vertical text.
  • Coordinate conversion helpers to map browser coordinates to scaled [0..1] coordinates relative to the drawing bounds (convertToScaledCoordinates).

Bounds and layout

calcBounds computes the inner drawing rectangle available for graph content, factoring in style-determined padding, frame width, label space, tick length and tick label widths. adjustBoundsForLabels() and adjustBoundsForTickLabels() are used to reserve space for axis and tick labels. The bounds are used by frame and drawing methods to position elements consistently.

History & buffering

When a RingBuffer<B> is present, hasHistory() returns true and a small buffer-size submenu is added to the context menu to select capacities (5k, 10k, 50k, 100k). Subclasses that maintain historical data should manage insertion into the buffer and may use prependTime2Data helper to attach a timestamp to stored data points.

Tooltips and context menu

A shared Tooltip instance is used to provide hover/touch information. Context menu population is extensible — AbstractGraph populates buffer-size, log-Y toggle and zoom items when applicable and then delegates to the owning AbstractView for additional items.

Messages

displayMessage(String) can be used to render a centered textual message on the graph (e.g. "No Data" or "Paused"). When a message is displayed most interaction handlers become inert and painting/updates are suppressed until the message is cleared via clearMessage().

Utilities & Helper classes

  • MyContext2d — a thin subclass of Context2d that exposes setLineDash for dashed lines.
  • ZoomCommand — small Command implementation used by context menu items to apply zoom factors.

Notes and implementation details

  • Drawing very large paths is split into segments (MAX_SEGEMENTS) and periodically closed/stroked to avoid performance bottlenecks and UI freezing.
  • Many protected helper methods are provided so subclasses can reuse the standardized rendering behavior and visuals defined by GraphStyle.
  • AbstractGraph intentionally separates coordinate-space transforms (via viewCorner and zoomFactor) from content rendering so subclasses can assume painting inside normalized bounds and apply their own content transforms as needed.
Author:
Christoph Hauert
See Also:

  • Field Details

    • doubleClickHandler

      HandlerRegistration doubleClickHandler
      The handler for DoubleClickEvents.

    • mouseOutHandler

      HandlerRegistration mouseOutHandler
      The handler for MouseOutEvents.

    • mouseDownHandler

      HandlerRegistration mouseDownHandler
      The handler for MouseDownEvents.

    • mouseUpHandler

      HandlerRegistration mouseUpHandler
      The handler for MouseUpEvents.

    • mouseMoveHandler

      HandlerRegistration mouseMoveHandler
      The handler for MouseMoveEvents.

    • mouseWheelHandler

      HandlerRegistration mouseWheelHandler
      The handler for MouseWheelEvents.

    • touchStartHandler

      HandlerRegistration touchStartHandler
      The handler for TouchStartEvents.

    • touchEndHandler

      HandlerRegistration touchEndHandler
      The handler for TouchEndEvents.

    • touchMoveHandler

      HandlerRegistration touchMoveHandler
      The handler for TouchMoveEvents.

    • zoomFactor

      protected double zoomFactor
      The current zoom level.

    • viewCorner

      protected Point2D viewCorner
      The coordinates of the lower left corner visible on the canvas.

    • view

      protected final AbstractView<?> view
      The view of this graph.

    • shifter

      AbstractGraph.Shifter shifter
      The controller for shifting this graph.

    • zoomer

      AbstractGraph.Zoomer zoomer
      The controller for zooming this graph.

    • contextMenu

      protected ContextMenu contextMenu
      The reference to the (shared) context menu.

    • tooltip

      protected Tooltip tooltip
      The reference to the (shared) tooltip.

    • tooltipProvider

      BasicTooltipProvider tooltipProvider
      The provider for tooltips.

    • scale

      protected double scale
      The scale of this graph. Used to translate width and height into canvas coordinates. For example, on retina displays the scale is typically 2, i.e. two pixels per unit width or height.
      See Also:

    • wrapper

      LayoutPanel wrapper
      The wrapper element which displays the canvas. Subclasses may use this to add further elements to the graph such as labels.

    • logger

      protected Logger logger
      Logger for keeping track of and reporting events and issues.

    • element

      protected Element element
      Handle to the object's underlying DOM element.

    • canvas

      protected Canvas canvas
      Handle to the canvas for drawing the graphics.

    • g

      protected AbstractGraph.MyContext2d g
      Handle to the graphical context for drawing on the canvas.

    • colors

      protected String[] colors
      The array of colors used for drawing the graph.

    • markers

      protected List<double[]> markers
      Markers for decorating the graph.

    • markerColors

      protected String[] markerColors
      The array of colors used for markers.

    • module

      protected Module<?> module
      The module backing the graph.

    • bounds

      protected Rectangle2D bounds
      The bounds of the displaying area. This excludes any frames and/or axes labels.

    • style

      protected GraphStyle style
      The style of the graph. Includes labels, fonts, etc.

    • buffer

      protected RingBuffer<B> buffer
      The buffer to store historical data, if applicable.

    • MIN_BUFFER_SIZE

      protected static final int MIN_BUFFER_SIZE
      The minimum buffer size.
      See Also:

    • DEFAULT_BUFFER_SIZE

      protected static final int DEFAULT_BUFFER_SIZE
      The default buffer size. Must be at least MIN_BUFFER_SIZE.
      See Also:

    • MIN_MSEC_BETWEEN_UPDATES

      public static final int MIN_MSEC_BETWEEN_UPDATES
      The minimum time between updates in milliseconds.
      See Also:

    • updatetime

      protected double updatetime
      The field to store the time of the last update.

    • CURSOR_GRAB_NODE_CLASS

      static final String CURSOR_GRAB_NODE_CLASS
      CSS class applied when the user is grabbing a node.
      See Also:

    • CURSOR_MOVE_NODE_CLASS

      static final String CURSOR_MOVE_NODE_CLASS
      CSS class applied when the user is dragging a node.
      See Also:

    • CURSOR_ZOOM_IN_CLASS

      static final String CURSOR_ZOOM_IN_CLASS
      CSS class applied when the user is zooming in.
      See Also:

    • CURSOR_ZOOM_OUT_CLASS

      static final String CURSOR_ZOOM_OUT_CLASS
      CSS class applied when the user is zooming out.
      See Also:

    • bufferSizeMenu

      private ContextMenu bufferSizeMenu
      The context menu to set the buffer size for graphs with historical data.

    • hasZoom

      protected boolean hasZoom
      The flag to indicate whether the graph supports zoom. The default is no support.

    • zoomResetMenu

      ContextMenuItem zoomResetMenu
      The context menu item to reset the zoom level.

    • zoomInMenu

      ContextMenuItem zoomInMenu
      The context menu item to zoom in (enlarge) by a factor of 2.

    • zoomOutMenu

      ContextMenuItem zoomOutMenu
      The context menu item to zoom out (reduce) by a factor of 1/2.

    • logYMenu

      ContextMenuCheckBoxItem logYMenu
      The menu item to toggle logarithmic scaling on the y-axis.

    • TWOPI

      private static final double TWOPI
      Constant representing the numerical value of \(2 \pi\)
      See Also:

    • PIHALF

      protected static final double PIHALF
      Constant representing the numerical value of \(\pi/2\)
      See Also:

    • MAX_SEGEMENTS

      private static final int MAX_SEGEMENTS
      The maximum number of line segments to draw before returning control to the event loop.
      See Also:

    • hasMessage

      protected boolean hasMessage
      Flag to indicate whether the graph displays a message.

    • leftMouseButton

      protected boolean leftMouseButton
      The flag to indicate whether the left mouse button is pressed.

    • mouseX

      protected int mouseX
      The x-coordinate of the previous mouse or tap event.

    • mouseY

      protected int mouseY
      The y-coordinate of the previous mouse or tap event.

    • CSS_CURSOR_MOVE_VIEW

      protected static final String CSS_CURSOR_MOVE_VIEW
      The CSS class name for the view movement cursor.
      See Also:

    • touchEndTime

      protected double touchEndTime
      The time when the previous touch ended.

    • pinchX

      protected int pinchX
      The x-coordinate of the center of the pinching gesture.

    • pinchY

      protected int pinchY
      The y-coordinate of the center of the pinching gesture.

    • pinchDist

      protected double pinchDist
      The distance between the pinching gesture.

    • zoomInertiaTimer

      protected Timer zoomInertiaTimer
      The timer to remove the CSS classes .evoludo-cursorZoomIn or .evoludo-cursorZoomIn, respectively, from the graph element after the inertia of zooming has worn off.

  • Constructor Details

    • AbstractGraph

      protected AbstractGraph(AbstractView<?> view, Module<?> module)
      Create the base class for graphs. Allocates the canvas, retrieves the shared tooltip and context menu. Use the CSS class evoludo-Canvas2D for custom formatting of the canvas element.
      Parameters:
      view - the view of this graph
      module - the module backing the graph

  • Method Details

    • setTooltipProvider

      public void setTooltipProvider(BasicTooltipProvider tooltipProvider)
      Set the provider for tooltips.
      Parameters:
      tooltipProvider - the provider for tooltips

    • getBuffer

      public RingBuffer<B> getBuffer()
      Return the RingBuffer<double[]> containing historical data, if applicable.
      Returns:
      the buffer with historical data or null

    • doUpdate

      public boolean doUpdate()
      Determine whether it is time to update the display.
      Returns:
      true if time to update graph

    • onLoad

      protected void onLoad()
      Overrides:
      onLoad in class Widget

    • onUnload

      protected void onUnload()
      Overrides:
      onUnload in class Widget

    • parse

      public boolean parse(String args)
      Parse the arguments for the graph. Default implementation does nothing.
      Parameters:
      args - the arguments for the graph
      Returns:
      true if parsing was successful

    • activate

      public void activate()
      Perform necessary preparations to show the graph in the GUI. Attaches mouse and touch handlers for graphs that implement AbstractGraph.Zooming or AbstractGraph.Shifting interfaces.
      See Also:

    • deactivate

      public void deactivate()
      The graph is removed from the GUI. Opportunity for some clean up. Removes all mouse and touch handlers from graph.
      See Also:

    • onResize

      public void onResize()
      Specified by:
      onResize in interface RequiresResize

    • updateCanvas

      private void updateCanvas()
      Update the canvas size and coordinate space dimensions. IMPORTANT: Setting the canvas size or the coordinate space dimensions clears the canvas (even with no actual changes)!

    • reset

      public void reset()
      Reset the graph. Clear canvas and messages.

    • init

      public void init()
      Initialize the graph. Do not clear graph.

    • paint

      public void paint()
      Draw the graph.

    • getModule

      public Module<?> getModule()
      Get the module that backs the graph.
      Returns:
      the module

    • paint

      public boolean paint(boolean force)
      Draw the graph. For re-drawing the graph, set force to true.
      Parameters:
      force - true to force re-drawing of graph
      Returns:
      true if painting skipped

    • setMarkers

      public void setMarkers(List<double[]> markers)
      Assign a list of markers to the graph.
      Parameters:
      markers - the list of markers

    • setMarkers

      public void setMarkers(List<double[]> markers, String[] colors)
      Assign a list of markers with custom colors to the graph.
      Parameters:
      markers - the list of markers
      colors - the list of custom colors

    • setColors

      public void setColors(String[] colors)
      Assign a list of colors to the graph.
      Parameters:
      colors - the list of colors

    • hasHistory

      public boolean hasHistory()
      Check whether the graph entertains a buffer with historical data.
      Returns:
      true if the graph stores the data history

    • clearHistory

      public void clearHistory()
      Clear the history of the graph (if there is one).

    • prependTime2Data

      protected double[] prependTime2Data(double t, double[] data)
      Utility method to prepend time to data point.
      Parameters:
      t - the time
      data - the data
      Returns:
      the new data array including time

    • populateContextMenuAt

      public void populateContextMenuAt(ContextMenu menu, int x, int y)
      Populate context menu menu in listening widget at (relative) position (x,y).

      Adds buffer size menu and queries the view to add further functionality.

      Specified by:
      populateContextMenuAt in interface ContextMenu.Provider
      Parameters:
      menu - context menu entries are added here
      x - horizontal coordinate (relative to listening widget)
      y - horizontal coordinate (relative to listening widget)
      See Also:

    • addBufferSizeMenu

      private void addBufferSizeMenu(ContextMenu menu)
      Add buffer size menu item to context menu if graph supports historical data.
      Parameters:
      menu - the context menu to populate

    • addLogScaleMenu

      private void addLogScaleMenu(ContextMenu menu)
      Add logarithmic scale menu item to context menu if graph supports log scale on y-axis.
      Parameters:
      menu - the context menu to populate

    • addZoomMenu

      private void addZoomMenu(ContextMenu menu)
      Add zoom menu items to context menu if graph supports zooming.
      Parameters:
      menu - the context menu to populate

    • setLogY

      void setLogY(boolean logY)
      Set the y-axis to logarithmic scale if logY is true and if yMin &ge; 0. If yMin == 0 it is increased to 0.01 * yMax. If yMin < 0 logarithmic scale requests are ignored.
      Parameters:
      logY - true to set logarithmic scale on y-axis

    • setBufferCapacity

      protected void setBufferCapacity(int capacity)
      Sets the buffer capacity to capacity, if applicable.
      Parameters:
      capacity - the new buffer capacity

    • contains

      public boolean contains(int x, int y)
      Checks if the (browser) coordinates (x, y) are inside this graph. This is useful for controllers that may manage several graphs.
      Parameters:
      x - the x-coordinate to check
      y - the y-coordinate to check
      Returns:
      true if (x, y) is inside graph

    • convertToScaledCoordinates

      public Point2D convertToScaledCoordinates(int x, int y)
      Convert the (browser) coordinates (x, y) to scaled coordinates in \([0,1]^2\).
      Parameters:
      x - the x-coordinate to convert
      y - the y-coordinate to convert
      Returns:
      the converted coordinates

    • convertToScaledCoordinates

      public Point2D convertToScaledCoordinates(int x, int y, Point2D dest)
      Convert the (browser) coordinates (x, y) to scaled coordinates in \([0,1]^2\) and store in dest.
      Parameters:
      x - the x-coordinate to convert
      y - the y-coordinate to convert
      dest - the point to save the converted coordinates
      Returns:
      the converted coordinates

    • export

      public abstract void export(AbstractGraph.MyContext2d ctx)
      Export the graphical context ctx.
      Parameters:
      ctx - the graphical context to export

    • calcBounds

      protected boolean calcBounds()
      Calculate bounds of drawing area. If element has never been visible its size is not yet known.
      Returns:
      true if bounds are successfully calculated.

    • calcBounds

      public void calcBounds(int width, int height)
      Calculate bounds of drawing area.
      Parameters:
      width - the width of the drawing area
      height - the height of the drawing area

    • adjustBoundsForLabels

      private void adjustBoundsForLabels()
      Adjust bounds to make room for axes labels.

    • adjustBoundsForTickLabels

      private void adjustBoundsForTickLabels()
      Adjust bounds to make room for tick labels.

    • drawFrame

      protected void drawFrame(int xLevels, int yLevels)
      Draw the frame of the graph including axes labels, ticks and tick marks, as applicable.

      Implementation Note:

      The top, left corner of the canvas is assumed to be at (0, 0). Flips the direction of the y-axis.
      Parameters:
      xLevels - the number of vertical levels
      yLevels - the number of horizontal levels
      See Also:

    • drawFrame

      protected void drawFrame(int xLevels, int yLevels, double gscale)
      Draw the frame of the graph including axes labels, ticks and tick marks, as applicable, after scaling the canvas by gscale.

      Implementation Note:

      After scaling the origin (0, 0) is assumed to be in the bottom, left corner of the canvas.
      Parameters:
      xLevels - the number of vertical levels
      yLevels - the number of horizontal levels
      gscale - the scaling applied to the coordinate transformation

    • drawFrameBorder

      private void drawFrameBorder(double w, double h)
      Draw the bounding box of the graph frame.
      Parameters:
      w - frame width
      h - frame height

    • drawXLevels

      private void drawXLevels(int xLevels, double w, double h)
      Draw regular vertical guide lines, ticks, and labels.
      Parameters:
      xLevels - number of levels
      w - frame width
      h - frame height

    • drawCustomXLevels

      private void drawCustomXLevels(double w, double h)
      Draw vertical guide lines at custom x positions.
      Parameters:
      w - frame width
      h - frame height

    • drawYLevels

      private void drawYLevels(int yLevels, double w, double h)
      Draw the y-levels including ticks and tick labels.
      Parameters:
      yLevels - the number of horizontal levels
      w - the width of the graph
      h - the height of the graph

    • computeYRange

      private double[] computeYRange()
      Compute the (possibly logarithmic) y-range for tick computations.
      Returns:
      array {ymin, yrange}

    • computeYVal

      private double computeYVal(int n, double frac, double yrange, double ymin)
      Compute the y-value for tick number n.
      Parameters:
      n - tick index
      frac - fractional spacing between ticks
      yrange - total y-range (possibly logarithmic)
      ymin - minimum y-value (possibly logarithmic)
      Returns:
      the y-value represented by the tick

    • drawYTickLabel

      private void drawYTickLabel(double w, double level, int n, double yval)
      Draw the y-axis tick label at the specified screen level.
      Parameters:
      w - frame width
      level - screen y-position for the tick
      n - tick index
      yval - y-value represented by the tick

    • drawCustomYLevels

      private void drawCustomYLevels(double w, double h)
      Draw horizontal guide lines at custom y positions.
      Parameters:
      w - frame width
      h - frame height

    • drawXAxisLabel

      private void drawXAxisLabel(double w, double h)
      Draw the x-axis label.
      Parameters:
      w - frame width
      h - frame height

    • drawYAxisLabel

      private void drawYAxisLabel(double w, double h)
      Draw the y-axis label, including positioning logic based on tick labels.
      Parameters:
      w - frame width
      h - frame height

    • drawGraphLabel

      private void drawGraphLabel(double gscale)
      Draw the label shown inside the graph canvas.
      Parameters:
      gscale - current canvas scale factor

    • setFont

      protected void setFont(String cssfont)
      Set the font to cssfont in CSS format for drawing on the canvas.
      Parameters:
      cssfont - the font for drawing

    • setStrokeStyleAt

      protected void setStrokeStyleAt(int node)
      Set the stroke colour for node with index node.
      Parameters:
      node - the index of the node

    • stroke

      protected void stroke(Path2D path)
      Draw the path path.
      Parameters:
      path - the path to draw

    • fill

      protected void fill(Path2D path)
      Fill the path path.
      Parameters:
      path - the path to fill

    • sketch

      private void sketch(Path2D path, boolean fill)
      Draw or fill (if fill == true) the path path.

      Implementation notes:

      • Drawing too many segments at once becomes very slow (why?).
      • Periodically closing and stroking the path is orders of magnitudes faster!
      • This simple change renders freezing of the GUI essentially a non issue.
      • SVG seems to be a stickler about opening and closing paths or empty paths (see Canvas2SVG.js)
      Parameters:
      path - the path to draw (or fill)
      fill - true to fill path

    • closePath

      private void closePath(boolean fill)
      Helper method to close the path and draw (or fill) it.
      Parameters:
      fill - true to fill path

    • strokeRect

      protected void strokeRect(double x, double y, double w, double h)
      Draw the rectangle with origin at (x,y), width w and height h.
      Parameters:
      x - the x-coordinate of the origin
      y - the y-coordinate of the origin
      w - the width of the rectangle
      h - the height of the rectangle

    • fillRect

      protected void fillRect(double x, double y, double w, double h)
      Fill the rectangle with origin at (x,y), width w and height h.
      Parameters:
      x - the x-coordinate of the origin
      y - the y-coordinate of the origin
      w - the width of the rectangle
      h - the height of the rectangle

    • strokeCircle

      protected void strokeCircle(Node2D node)
      Draw the outline of the 2D node.
      Parameters:
      node - the node to draw

    • strokeCircle

      protected void strokeCircle(Point2D point, double radius)
      Draw the outline of a circle at point with radius.
      Parameters:
      point - the node to draw
      radius - the radius of the circle

    • strokeCircle

      protected void strokeCircle(double x, double y, double radius)
      Draw the circle with the center at (x,y) and radius radius.
      Parameters:
      x - the x-coordinate of the center
      y - the y-coordinate of the center
      radius - the radius of the circle

    • fillCircle

      protected void fillCircle(Node2D node)
      Draw the filled 2D node.
      Parameters:
      node - the node to draw

    • fillCircle

      protected void fillCircle(Point2D point, double radius)
      Draw a filled circle at point with radius.
      Parameters:
      point - the node to draw
      radius - the radius of the circle

    • fillCircle

      protected void fillCircle(double x, double y, double radius)
      Fill the circle with the center at (x,y) and radius radius.
      Parameters:
      x - the x-coordinate of the center
      y - the y-coordinate of the center
      radius - the radius of the circle

    • sketchCircle

      private void sketchCircle(double x, double y, double radius)
      Helper method to create a path for a circle with the center at (x,y) and radius radius.
      Parameters:
      x - the x-coordinate of the center
      y - the y-coordinate of the center
      radius - the radius of the circle

    • strokeLine

      protected void strokeLine(Point2D a, Point2D b)
      Draw a line from point a to b).
      Parameters:
      a - the start point
      b - the end point

    • strokeLine

      protected void strokeLine(double sx, double sy, double ex, double ey)
      Draw a line from point (sx,sy) to (ex,ey).
      Parameters:
      sx - the x-coordinate of the start point
      sy - the y-coordinate of the start point
      ex - the x-coordinate of the end point
      ey - the y-coordinate of the end point

    • fillTextVertical

      protected void fillTextVertical(String msg, double x, double y)
      Draw filled text vertically starting at point (x,y)
      Parameters:
      msg - the text to write
      x - the x-coordinate of the start point
      y - the y-coordinate of the start point

    • clearGraph

      public void clearGraph()
      Clear the graph.

    • clearCanvas

      protected void clearCanvas()
      Clear the canvas.

      Implementation note:

      Assumes scaled canvas coordinates, i.e. lower, left corner at (0,0).

    • resetTransforms

      protected void resetTransforms()
      Reset the transformation of the graphics context to the identity transform.

    • displayMessage

      public boolean displayMessage(String msg)
      Display message msg on the graph (no HTML formatting).

      Implementation note:

      The message is centered and scaled such that it fills approximately two thirds of the width of the graph.
      Parameters:
      msg - the message to display
      Returns:
      true if message displayed

    • clearMessage

      public void clearMessage()
      Clear the message.

    • hasMessage

      public boolean hasMessage()
      Check if the graph displays a message.
      Returns:
      true if message displayed

    • zoom

      public void zoom()
      Reset zoom. Default implementation for graphs that implement Zooming.
      See Also:

    • zoom

      public void zoom(double zoom)
      Adjust zoom level by the factor zoom. Default implementation for graphs that implement Zooming.
      Parameters:
      zoom - the new zoom level
      See Also:

    • zoom

      public void zoom(double zoom, int x, int y)
      Adjust zoom level by the factor zoom with the center at coordinates (x,y) (in display coordinates as provided by event listeners). Default implementation for graphs that implement Zooming.
      Parameters:
      zoom - the new zoom level
      x - the x-coordinate of the zoom center
      y - the y-coordinate of the zoom center
      See Also:

    • zoom

      protected void zoom(double zoom, double fx, double fy)
      Helper method to adjust zoom level with the zoom center at the scaled coordinates (fx, fy), specified as a fraction of the view port in horizontal and vertical directions, respectively.
      Parameters:
      zoom - the new zoom level
      fx - the scaled x-coordinate of the zoom center
      fy - the scaled y-coordinate of the zoom center
      See Also:

    • shift

      public void shift(int dx, int dy)
      Shift the (zoomed) graph within the view port by (dx, dy). Default implementation for graphs that implement Shifting.
      Parameters:
      dx - the horizontal shift of the graph
      dy - the vertical shift of the graph
      See Also:

    • onMouseOut

      public void onMouseOut(MouseOutEvent event)

      If mouse leaves graph while shifting the view stop shifting. Mouse events are no longer received and hence it is impossible to track releasing or pressing mouse buttons.

      Specified by:
      onMouseOut in interface MouseOutHandler

    • onMouseDown

      public void onMouseDown(MouseDownEvent event)

      If a node has been hit by a left-click, remember the node's index and the current mouse coordinates. This information might be used by subsequent MouseMoveEvents.

      Specified by:
      onMouseDown in interface MouseDownHandler
      See Also:

    • onMouseUp

      public void onMouseUp(MouseUpEvent event)

      Cancel all interactions with the graph and reset node and mouse information.

      CSS Style Rules

      .evoludo-cursorMoveView
      removed from graph element.
      Specified by:
      onMouseUp in interface MouseUpHandler
      See Also:

    • onMouseMove

      public void onMouseMove(MouseMoveEvent event)

      If the left mouse-key is pressed the graph is shifted within its viewport. Note this requires that the zoom level of the graph exceeds 1.

      CSS Style Rules

      .evoludo-cursorMoveView
      added to graph element when shifting the view.
      Specified by:
      onMouseMove in interface MouseMoveHandler
      See Also:

    • onMouseWheel

      public void onMouseWheel(MouseWheelEvent event)

      Adjusts the zoom level of the graph, while preserving the location of the mouse on the graph. The zooming has inertia.

      CSS Style Rules

      .evoludo-cursorZoomIn
      added to graph element when zooming in and removed when inertia stops.
      .evoludo-cursorZoomOut
      added to graph element when zooming out and removed when inertia stops.
      Specified by:
      onMouseWheel in interface MouseWheelHandler
      See Also:

    • onTouchStart

      public void onTouchStart(TouchStartEvent event)

      The graph reacts to different kinds of touches: short touches or taps (&lt;250 msec) and long touches (&gt;250 msec). Long touches trigger different actions depending on the number of fingers:

      Single finger
      Initiate shifting the view
      Two fingers
      Initiate pinching zoom.
      Specified by:
      onTouchStart in interface TouchStartHandler
      See Also:

    • onTouchEnd

      public void onTouchEnd(TouchEndEvent event)

      The number of touches on the graph changed.

      Specified by:
      onTouchEnd in interface TouchEndHandler

    • onTouchMove

      public void onTouchMove(TouchMoveEvent event)

      The graph reacts to different kinds of touch moves:

      Move one finger
      Shift view
      Pinch two fingers
      Zoom view
      Specified by:
      onTouchMove in interface TouchMoveHandler

    • addContextMenuHandler

      public HandlerRegistration addContextMenuHandler(ContextMenuHandler handler)
      Specified by:
      addContextMenuHandler in interface HasContextMenuHandlers

    • getStyle

      public GraphStyle getStyle()
      Get the graph style.
      Returns:
      the graph style

    • autoscale

      public void autoscale(boolean x, boolean y)
      Set auto-scaling for horizontal and vertical axes.
      Parameters:
      x - true to automatically scale the x-axis
      y - true to automatically scale the y-axis