gt:             EdgeIndexFunction<V, E> parallelEdgeIndexFunction) {
context: /*
   * Copyright (c) 2003, The JUNG Authors
   * All rights reserved.
   * 
   * This software is open-source under the BSD license; see either "license.txt"
   * or https://github.com/jrtom/jung/blob/master/LICENSE for a description.
   */
  package edu.uci.ics.jung.visualization;
  
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Font;
  import java.awt.Paint;
  import java.awt.Shape;
  import java.awt.Stroke;
  import java.awt.geom.Ellipse2D;
  
  import javax.swing.CellRendererPane;
  import javax.swing.Icon;
  import javax.swing.JComponent;
  
  import com.google.common.base.Function;
  import com.google.common.base.Functions;
  import com.google.common.base.Predicate;
  import com.google.common.base.Predicates;
  
  import edu.uci.ics.jung.algorithms.layout.GraphElementAccessor;
  import edu.uci.ics.jung.graph.Graph;
  import edu.uci.ics.jung.graph.util.Context;
  import edu.uci.ics.jung.graph.util.DefaultParallelEdgeIndexFunction;
  import edu.uci.ics.jung.graph.util.EdgeIndexFunction;
  import edu.uci.ics.jung.graph.util.IncidentEdgeIndexFunction;
  import edu.uci.ics.jung.visualization.decorators.ConstantDirectionalEdgeValueTransformer;
  import edu.uci.ics.jung.visualization.decorators.DirectionalEdgeArrowTransformer;
  import edu.uci.ics.jung.visualization.decorators.EdgeShape;
  import edu.uci.ics.jung.visualization.decorators.ParallelEdgeShapeTransformer;
  import edu.uci.ics.jung.visualization.picking.PickedState;
  import edu.uci.ics.jung.visualization.renderers.DefaultEdgeLabelRenderer;
  import edu.uci.ics.jung.visualization.renderers.DefaultVertexLabelRenderer;
  import edu.uci.ics.jung.visualization.renderers.EdgeLabelRenderer;
  import edu.uci.ics.jung.visualization.renderers.VertexLabelRenderer;
  import edu.uci.ics.jung.visualization.transform.shape.GraphicsDecorator;
  
  
  public class PluggableRenderContext<V, E> implements RenderContext<V, E> {
      
  	protected float arrowPlacementTolerance = 1;
      protected Predicate<Context<Graph<V,E>,V>> vertexIncludePredicate = Predicates.alwaysTrue();
      protected Function<? super V,Stroke> vertexStrokeTransformer = 
      	Functions.<Stroke>constant(new BasicStroke(1.0f));
      
      protected Function<? super V,Shape> vertexShapeTransformer = 
          		Functions.<Shape>constant(
          		new Ellipse2D.Float(-10,-10,20,20));
  
      protected Function<? super V,String> vertexLabelTransformer = Functions.constant(null);
      protected Function<? super V,Icon> vertexIconTransformer;
      protected Function<? super V,Font> vertexFontTransformer = 
          Functions.constant(new Font("Helvetica", Font.PLAIN, 12));
      
      protected Function<? super V,Paint> vertexDrawPaintTransformer = 
      	Functions.<Paint>constant(Color.BLACK);
      protected Function<? super V,Paint> vertexFillPaintTransformer = 
      	Functions.<Paint>constant(Color.RED);
      
      protected Function<? super E,String> edgeLabelTransformer = 
      	Functions.constant(null);
      protected Function<? super E,Stroke> edgeStrokeTransformer = 
      	Functions.<Stroke>constant(new BasicStroke(1.0f));
      protected Function<? super E,Stroke> edgeArrowStrokeTransformer = 
      	Functions.<Stroke>constant(new BasicStroke(1.0f));
      
      protected Function<? super Context<Graph<V,E>,E>,Shape> edgeArrowTransformer = 
          new DirectionalEdgeArrowTransformer<V,E>(10, 8, 4);
      
      protected Predicate<Context<Graph<V,E>,E>> edgeArrowPredicate = new DirectedEdgeArrowPredicate<V,E>();
      protected Predicate<Context<Graph<V,E>,E>> edgeIncludePredicate = Predicates.alwaysTrue();
      protected Function<? super E,Font> edgeFontTransformer =
          Functions.constant(new Font("Helvetica", Font.PLAIN, 12));
      protected Function<? super Context<Graph<V,E>,E>,Number> edgeLabelClosenessTransformer = 
          new ConstantDirectionalEdgeValueTransformer<V,E>(0.5, 0.65);
      protected Function<? super E, Shape> edgeShapeTransformer;
      protected Function<? super E,Paint> edgeFillPaintTransformer =
          Functions.constant(null);
      protected Function<? super E,Paint> edgeDrawPaintTransformer =
          Functions.<Paint>constant(Color.black);
      protected Function<? super E,Paint> arrowFillPaintTransformer =
          Functions.<Paint>constant(Color.black);
      protected Function<? super E,Paint> arrowDrawPaintTransformer =
          Functions.<Paint>constant(Color.black);
      
      protected EdgeIndexFunction<V,E> parallelEdgeIndexFunction = 
          DefaultParallelEdgeIndexFunction.<V,E>getInstance();
      
      protected EdgeIndexFunction<V,E> incidentEdgeIndexFunction = 
          IncidentEdgeIndexFunction.<V,E>getInstance();
      
      protected MultiLayerTransformer multiLayerTransformer = new BasicTransformer();
      
  	/**
  	 * pluggable support for picking graph elements by
  	 * finding them based on their coordinates.
  	 */
  	protected GraphElementAccessor<V, E> pickSupport;
  
      
      protected int labelOffset = LABEL_OFFSET;
      
      /**
       * the JComponent that this Renderer will display the graph on
       */
      protected JComponent screenDevice;
      
      protected PickedState<V> pickedVertexState;
      protected PickedState<E> pickedEdgeState;
      
      /**
       * The CellRendererPane is used here just as it is in JTree
       * and JTable, to allow a pluggable JLabel-based renderer for
       * Vertex and Edge label strings and icons.
       */
      protected CellRendererPane rendererPane = new CellRendererPane();
      
      /**
       * A default GraphLabelRenderer - picked Vertex labels are
       * blue, picked edge labels are cyan
       */
      protected VertexLabelRenderer vertexLabelRenderer = 
          new DefaultVertexLabelRenderer(Color.blue);
      
      protected EdgeLabelRenderer edgeLabelRenderer = new DefaultEdgeLabelRenderer(Color.cyan);
      
      protected GraphicsDecorator graphicsContext;
      
      private EdgeShape<V, E> edgeShape;
      
      PluggableRenderContext(Graph<V, E> graph) {
          this.edgeShape = new EdgeShape<V, E>(graph);
      	this.edgeShapeTransformer = edgeShape.new QuadCurve();    	
      }
  
  	/**
  	 * @return the vertexShapeTransformer
  	 */
  	public Function<? super V, Shape> getVertexShapeTransformer() {
  		return vertexShapeTransformer;
  	}
  
  	/**
  	 * @param vertexShapeTransformer the vertexShapeTransformer to set
  	 */
  	public void setVertexShapeTransformer(
  			Function<? super V, Shape> vertexShapeTransformer) {
  		this.vertexShapeTransformer = vertexShapeTransformer;
  	}
  
  	/**
  	 * @return the vertexStrokeTransformer
  	 */
  	public Function<? super V, Stroke> getVertexStrokeTransformer() {
  		return vertexStrokeTransformer;
  	}
  
  	/**
  	 * @param vertexStrokeTransformer the vertexStrokeTransformer to set
  	 */
  	public void setVertexStrokeTransformer(
  			Function<? super V, Stroke> vertexStrokeTransformer) {
  		this.vertexStrokeTransformer = vertexStrokeTransformer;
  	}
  
  	public static float[] getDashing() {
          return dashing;
      }
  
      public static float[] getDotting() {
          return dotting;
      }
  
      public float getArrowPlacementTolerance() {
          return arrowPlacementTolerance;
      }
  
      public void setArrowPlacementTolerance(float arrow_placement_tolerance) {
          this.arrowPlacementTolerance = arrow_placement_tolerance;
      }
  
      public Function<? super Context<Graph<V,E>,E>,Shape> getEdgeArrowTransformer() {
          return edgeArrowTransformer;
      }
  
      public void setEdgeArrowTransformer(Function<? super Context<Graph<V,E>,E>,Shape> edgeArrowTransformer) {
          this.edgeArrowTransformer = edgeArrowTransformer;
      }
  
      public Predicate<Context<Graph<V,E>,E>> getEdgeArrowPredicate() {
          return edgeArrowPredicate;
      }
  
      public void setEdgeArrowPredicate(Predicate<Context<Graph<V,E>,E>> edgeArrowPredicate) {
          this.edgeArrowPredicate = edgeArrowPredicate;
      }
  
      public Function<? super E,Font> getEdgeFontTransformer() {
          return edgeFontTransformer;
      }
  
      public void setEdgeFontTransformer(Function<? super E,Font> edgeFontTransformer) {
          this.edgeFontTransformer = edgeFontTransformer;
      }
  
      public Predicate<Context<Graph<V,E>,E>> getEdgeIncludePredicate() {
          return edgeIncludePredicate;
      }
  
      public void setEdgeIncludePredicate(Predicate<Context<Graph<V,E>,E>> edgeIncludePredicate) {
          this.edgeIncludePredicate = edgeIncludePredicate;
      }
  
      public Function<? super Context<Graph<V,E>,E>,Number> getEdgeLabelClosenessTransformer() {
          return edgeLabelClosenessTransformer;
      }
  
      public void setEdgeLabelClosenessTransformer(
      		Function<? super Context<Graph<V,E>,E>,Number> edgeLabelClosenessTransformer) {
          this.edgeLabelClosenessTransformer = edgeLabelClosenessTransformer;
      }
  
      public EdgeLabelRenderer getEdgeLabelRenderer() {
          return edgeLabelRenderer;
      }
  
      public void setEdgeLabelRenderer(EdgeLabelRenderer edgeLabelRenderer) {
          this.edgeLabelRenderer = edgeLabelRenderer;
      }
  
      public Function<? super E,Paint> getEdgeFillPaintTransformer() {
          return edgeFillPaintTransformer;
      }
  
      public void setEdgeDrawPaintTransformer(Function<? super E,Paint> edgeDrawPaintTransformer) {
          this.edgeDrawPaintTransformer = edgeDrawPaintTransformer;
      }
  
      public Function<? super E,Paint> getEdgeDrawPaintTransformer() {
          return edgeDrawPaintTransformer;
      }
  
      public void setEdgeFillPaintTransformer(Function<? super E,Paint> edgeFillPaintTransformer) {
          this.edgeFillPaintTransformer = edgeFillPaintTransformer;
      }
  
      public Function<? super E, Shape> getEdgeShapeTransformer() {
          return edgeShapeTransformer;
      }
  
      public void setEdgeShapeTransformer(Function<? super E, Shape> edgeShapeTransformer) {
          this.edgeShapeTransformer = edgeShapeTransformer;
          if (edgeShapeTransformer instanceof ParallelEdgeShapeTransformer) {
          	@SuppressWarnings("unchecked")
  			ParallelEdgeShapeTransformer<V, E> transformer =
          			(ParallelEdgeShapeTransformer<V, E>)edgeShapeTransformer;
          	if (transformer instanceof EdgeShape.Orthogonal) {
          		transformer.setEdgeIndexFunction(this.incidentEdgeIndexFunction);
          	} else {
          		transformer.setEdgeIndexFunction(this.parallelEdgeIndexFunction);
          	}
          }
      }
  
      public Function<? super E,String> getEdgeLabelTransformer() {
          return edgeLabelTransformer;
      }
  
      public void setEdgeLabelTransformer(Function<? super E,String> edgeLabelTransformer) {
          this.edgeLabelTransformer = edgeLabelTransformer;
      }
  
      public Function<? super E,Stroke> getEdgeStrokeTransformer() {
          return edgeStrokeTransformer;
      }
  
      public void setEdgeStrokeTransformer(Function<? super E,Stroke> edgeStrokeTransformer) {
          this.edgeStrokeTransformer = edgeStrokeTransformer;
      }
  
      public Function<? super E,Stroke> getEdgeArrowStrokeTransformer() {
          return edgeArrowStrokeTransformer;
      }
  
      public void setEdgeArrowStrokeTransformer(Function<? super E,Stroke> edgeArrowStrokeTransformer) {
          this.edgeArrowStrokeTransformer = edgeArrowStrokeTransformer;
      }
  
      public GraphicsDecorator getGraphicsContext() {
          return graphicsContext;
      }
  
      public void setGraphicsContext(GraphicsDecorator graphicsContext) {
          this.graphicsContext = graphicsContext;
      }
  
      public int getLabelOffset() {
          return labelOffset;
      }
  
      public void setLabelOffset(int labelOffset) {
          this.labelOffset = labelOffset;
      }
  
      public EdgeIndexFunction<V, E> getParallelEdgeIndexFunction() {
          return parallelEdgeIndexFunction;
      }
  
      public void setParallelEdgeIndexFunction(
  