Java 类javafx.scene.shape.Polyline 实例源码

public static String convertPolyline(final Polyline POLYLINE) {
    final StringBuilder fxPath = new StringBuilder();
    final int size = POLYLINE.getPoints().size();
    if (size % 2 == 0) {
        List<Double> coordinates = POLYLINE.getPoints();
        for (int i = 0; i < size; i += 2) {
            fxPath
                    .append(i == 0 ? "M " : "L ")
                    .append(coordinates.get(i))
                    .append(" ")
                    .append(coordinates.get(i + 1))
                    .append(" ");
        }
    }
    return fxPath.toString();
}

public static Node createIconContent() {
    Polyline polyline = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline.setStroke(Color.web("#b9c0c5"));
    polyline.setStrokeWidth(5);
    polyline.getStrokeDashArray().addAll(15d,15d);
    polyline.setFill(null);
    javafx.scene.effect.InnerShadow effect = new javafx.scene.effect.InnerShadow();
    effect.setOffsetX(1);
    effect.setOffsetY(1);
    effect.setRadius(3);
    effect.setColor(Color.rgb(0,0,0,0.6));
    polyline.setEffect(effect);
    return polyline;
}

public static Node createIconContent() {
    Polyline polyline = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline.setStroke(Color.web("#b9c0c5"));
    polyline.setStrokeWidth(5);
    polyline.getStrokeDashArray().addAll(15d,15d);
    polyline.setFill(null);
    javafx.scene.effect.InnerShadow effect = new javafx.scene.effect.InnerShadow();
    effect.setOffsetX(1);
    effect.setOffsetY(1);
    effect.setRadius(3);
    effect.setColor(Color.rgb(0,0,0,0.6));
    polyline.setEffect(effect);
    return polyline;
}

private static void makeNFPPolylineScene(Group group,NoFitPolygon nfp, double biggestValue) {

    //sceneSize divided by 2 because x and y axis are in the middle
    double resizeFactor = sceneSizeY/biggestValue/2;        

    Color sligthlyLighterBlack = Color.web("0x201F18");

    Polyline[] nfpPolygonList = nfp.toPolylineList(sceneSizeX, sceneSizeY, resizeFactor);

    for(Polyline polygon : nfpPolygonList){
        polygon.setStrokeWidth(4);
        polygon.setStroke(sligthlyLighterBlack);
        polygon.setFill(Color.TRANSPARENT);
        group.getChildren().add(polygon);
    }

}

/**
 * Draws the shape, uses a polyline along with the width and height to calculate a suitable shape
 * @param polyline The polyline to draw with
 */
public void drawShape(Polyline polyline){
    double baseX = getX();
    double baseY = getY();

    double rightHeight = super.getShapeHeight() * 0.6;
    double rightSmallHeight = (super.getShapeHeight() - rightHeight) / 2;

    double gapWidth = super.getShapeHeight() * 0.3;
    double leftHeight = (super.getShapeHeight() - gapWidth) / 2;

    polyline.getPoints().clear();
    polyline.getPoints().addAll(
            baseX, baseY,
            baseX + getShapeWidth(), baseY + rightSmallHeight,
            baseX + getShapeWidth(), baseY + rightHeight + rightSmallHeight,
            baseX, baseY + super.getShapeHeight(),
            baseX, baseY + gapWidth + leftHeight,
            baseX + (getShapeWidth() * 0.2), baseY + leftHeight + (gapWidth / 2),
            baseX, baseY + leftHeight,
            baseX, baseY);

    setComponentShape(polyline);
}

/**
 * Sets attributes on the shape, useful when resizing
 * @param x The new x coordinate
 * @param y The new y coordinate
 * @param width The new width
 * @param height The new height
 */
public void setAttrs(double x, double y, double width, double height){
    Shape shape = getComponentShape();
    Text text = getComponentLabel();
    setLayoutX(x);
    shape.setLayoutX(x);
    setLayoutY(y);
    shape.setLayoutY(y);
    setX(x);
    setY(y);
    setShapeWidth(width);
    setPrefWidth(width);
    setShapeHeight(height);
    setPrefHeight(height);
    text.setWrappingWidth(width);
    drawShape(((Polyline) shape));
}

/**
 * Sets up the connector wire
 * @param from The shape going from
 * @param to The shape going to
 * @param type The type of wire
 * @param rightOrBottom If starting from the right or bottom
 * @param arrowStart If the arrow should be on from or to
 * @param offset The offset of the wire to multiply (0-1)
 */
public ConnectorWire(ComponentStackPane from, ComponentStackPane to, Type type, boolean rightOrBottom, boolean arrowStart, double offset){
    super(new Polyline(), new Polyline(), type);
    this.from = from;
    this.to = to;
    this.arrowStart = arrowStart;
    this.type = type;
    this.rightOrBottom = rightOrBottom;
    setReverse(rightOrBottom && arrowStart);

    this.offset = offset;
    if(type == Type.HORIZONTAL){
        drawHorizontalWire();
    } else {
        drawVerticalLine();
    }

    getArrowhead().getStyleClass().add("cpu-arrowhead");
    getLine().getStyleClass().add("cpu-line");

    this.getChildren().addAll(getLine(), getArrowhead());

}

/**
 * Get the JavaFX representation of the way.
 *
 * @return The JavaFX representation of the way.
 */
public Polyline render() {
  Polyline polyline = new Polyline();

  // Don't use antialiasing for performance reasons.
  polyline.setSmooth(false);

  polyline.getStyleClass().add("way");

  for (Map.Entry<String, String> tag: this.tags().entrySet()) {
    polyline.getStyleClass().add(tag.getKey());
    polyline.getStyleClass().add(tag.getKey() + "-" + tag.getValue());
  }

  if (this.nodes != null) {
    for (Node node: this.nodes) {
      polyline.getPoints().add((double) node.x());
      polyline.getPoints().add((double) node.y());
    }
  }

  return polyline;
}

public static Node createIconContent() {
    Polyline polyline = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline.setStroke(Color.web("#b9c0c5"));
    polyline.setStrokeWidth(5);
    polyline.getStrokeDashArray().addAll(15d,15d);
    polyline.setFill(null);
    javafx.scene.effect.InnerShadow effect = new javafx.scene.effect.InnerShadow();
    effect.setOffsetX(1);
    effect.setOffsetY(1);
    effect.setRadius(3);
    effect.setColor(Color.rgb(0,0,0,0.6));
    polyline.setEffect(effect);
    return polyline;
}

public PolylineSample() {
    super(180,90);
    // Red stroked not closed triangle
    Polyline polyline1 = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline1.setFill(Color.TRANSPARENT);
    polyline1.setStroke(Color.RED);

    // Blue stroked closed triangle
    Polyline polyline2 = new Polyline(new double[]{
        135, 10,
        100, 80,
        170, 80,
        135, 10,
    });
    polyline2.setStroke(Color.DODGERBLUE);
    polyline2.setStrokeWidth(2);
    polyline2.setFill(null);


    // Create a group to show all the polylines);
    getChildren().add(new Group(polyline1, polyline2));
    // REMOVE ME
    setControls(
            new SimplePropertySheet.PropDesc("Polyline 1 Fill", polyline1.fillProperty()),
            new SimplePropertySheet.PropDesc("Polyline 1 Stroke", polyline1.strokeProperty()),
            new SimplePropertySheet.PropDesc("Polyline 2 Stroke", polyline2.strokeProperty())
    );
    // END REMOVE ME
}

public PolylineSample() {
    super(180,90);
    // Red stroked not closed triangle
    Polyline polyline1 = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline1.setFill(Color.TRANSPARENT);
    polyline1.setStroke(Color.RED);

    // Blue stroked closed triangle
    Polyline polyline2 = new Polyline(new double[]{
        135, 10,
        100, 80,
        170, 80,
        135, 10,
    });
    polyline2.setStroke(Color.DODGERBLUE);
    polyline2.setStrokeWidth(2);
    polyline2.setFill(null);


    // Create a group to show all the polylines);
    getChildren().add(new Group(polyline1, polyline2));
    // REMOVE ME
    setControls(
            new SimplePropertySheet.PropDesc("Polyline 1 Fill", polyline1.fillProperty()),
            new SimplePropertySheet.PropDesc("Polyline 1 Stroke", polyline1.strokeProperty()),
            new SimplePropertySheet.PropDesc("Polyline 2 Stroke", polyline2.strokeProperty())
    );
    // END REMOVE ME
}

public Polyline[] toPolylineList(double xSize, double ySize, double sizeFactor) {

    Polyline[] polygonList = new Polyline[nfpPolygonsList.size()];
    for (int i = 0; i < nfpPolygonsList.size(); i++) {
        polygonList[i] = new Polyline();
        for (Coordinate coord : nfpPolygonsList.get(i)) {
            polygonList[i].getPoints().add(sizeFactor * coord.getxCoord() + xSize / 2);
            // yCoord*-1 to invert to normal axis
            polygonList[i].getPoints().add(-1 * sizeFactor * coord.getyCoord() + ySize / 2);
        }
    }

    return polygonList;
}

/**
 * Draws the shape, sets attributes and sets the text alignment
 * @param vis The CPU visualisation
 * @param label The label to use
 */
public ALU(CPUVisualisation vis, String label){
    super(vis, label);
    drawShape(new Polyline());
    setAttributes();
    getComponentLabel().setTextAlignment(TextAlignment.RIGHT);
}

/**
 * Sets up a new wire
 * @param line The poly line to use for the wire
 * @param arrowHead the poly line to use for the arrowhead
 * @param type The type of wire
    */
Wire(Polyline line, Polyline arrowHead, Type type) {
    this.line = line;
    this.arrowHead = arrowHead;
    this.type = type;
    this.animating = false;
    this.reverse = false;
    this.transitions = new LinkedList<>();
    this.path = new Path();
    setCache(true);
    setCacheHint(CacheHint.SPEED);
}

/**
 * Sets up a new custom wire
 * @param xStart The starting x position
 * @param yStart The starting y position
 * @param customLines The custom lines for the wire
 */
public CustomWire(double xStart, double yStart, CustomLine... customLines){
    super(new Polyline(), new Polyline(), Type.CUSTOM);

    drawLine(xStart, yStart, customLines);

    getArrowhead().getStyleClass().add("cpu-arrowhead");
    getLine().getStyleClass().add("cpu-line");

    getChildren().addAll(getLine(), getArrowhead());
}

private void createOverlayBottomLineUp() {
    overlayBottomLineUp = new Polyline();
    overlayBottomLineUp.getPoints().addAll(
            new Double[]{
                    -10.0d, 4.0d,
                    0.0d, 0.0d,
                    10.0d, 4.0d}
    );
}

public static String shapeToSvgString(final Shape SHAPE) {
    final StringBuilder fxPath = new StringBuilder();
    if (Line.class.equals(SHAPE.getClass())) {
        fxPath.append(convertLine((Line) SHAPE));
    } else if (Arc.class.equals(SHAPE.getClass())) {
        fxPath.append(convertArc((Arc) SHAPE));
    } else if (QuadCurve.class.equals(SHAPE.getClass())) {
        fxPath.append(convertQuadCurve((QuadCurve) SHAPE));
    } else if (CubicCurve.class.equals(SHAPE.getClass())) {
        fxPath.append(convertCubicCurve((CubicCurve) SHAPE));
    } else if (Rectangle.class.equals(SHAPE.getClass())) {
        fxPath.append(convertRectangle((Rectangle) SHAPE));
    } else if (Circle.class.equals(SHAPE.getClass())) {
        fxPath.append(convertCircle((Circle) SHAPE));
    } else if (Ellipse.class.equals(SHAPE.getClass())) {
        fxPath.append(convertEllipse((Ellipse) SHAPE));
    } else if (Text.class.equals(SHAPE.getClass())) {
        Path path = (Path)(Shape.subtract(SHAPE, new Rectangle(0, 0)));
        fxPath.append(convertPath(path));
    } else if (Path.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPath((Path) SHAPE));
    } else if (Polygon.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPolygon((Polygon) SHAPE));
    } else if (Polyline.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPolyline((Polyline) SHAPE));
    } else if (SVGPath.class.equals(SHAPE.getClass())) {
        fxPath.append(((SVGPath) SHAPE).getContent());
    }
    return fxPath.toString();
}

public static String convertPolyline(final Polyline POLYLINE) {
    final StringBuilder fxPath = new StringBuilder();
    final int           size   = POLYLINE.getPoints().size();
    if (size % 2 == 0) {
        List<Double> coordinates     = POLYLINE.getPoints();
        for (int i = 0 ; i < size ; i += 2) {
            fxPath.append(i == 0 ? "M " : "L ")
                  .append(coordinates.get(i)).append(" ").append(coordinates.get(i + 1)).append(" ");
        }
    }
    return fxPath.toString();
}

@Override
public Group createJFXNode() throws Exception
{
    final Polyline polyline = new Polyline();
    polyline.setStrokeLineJoin(StrokeLineJoin.MITER);
    polyline.setStrokeLineCap(StrokeLineCap.BUTT);
    return new Group(polyline, new Arrow(), new Arrow());
}

@Test
public void testGetPolylineAdjuster() {
    Adjuster adjuster = Adjuster.getAdjuster(Polyline.class);

    assertThat(adjuster, is(instanceOf(PolylineAdjuster.class)));
    assertThat(adjuster.getNodeClass(), is(sameInstance(Polyline.class)));
}

@Override // Override the start method in the Application class
public void start(Stage primaryStage) {
    // Create a pane 
    Pane pane = new Pane();

    // Create a polyline
    Polyline polyline = new Polyline(new Double(100.0), new Double(100.0));
    polyline.setFill(Color.WHITE);
    polyline.setStroke(Color.BLACK);
    pane.getChildren().add(polyline);
    ObservableList<Double> list = polyline.getPoints();

    // Create and register handler
    pane.setOnKeyPressed(e -> {
        double x = 0, y = 0;
        double length = 10;
        switch (e.getCode()) {
            case DOWN: x = list.get(list.size() - 2);
                          y = list.get(list.size() - 1) + length; break;
            case UP: x = list.get(list.size() - 2);
                        y = list.get(list.size() - 1) - length; break;
            case RIGHT: x = list.get(list.size() - 2) + length;
                          y = list.get(list.size() - 1); break;
            case LEFT: x = list.get(list.size() - 2) - length;
                          y = list.get(list.size() - 1); break;

        }
        list.add(x);
        list.add(y); 
    });

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 200, 200);
    primaryStage.setTitle("Exercise_15_09"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage

    pane.requestFocus(); // Pane is focused to receive key input 
}

public PolylineSample() {
    super(180,90);
    // Red stroked not closed triangle
    Polyline polyline1 = new Polyline(new double[]{
        45, 10,
        10, 80,
        80, 80,
    });
    polyline1.setFill(Color.TRANSPARENT);
    polyline1.setStroke(Color.RED);

    // Blue stroked closed triangle
    Polyline polyline2 = new Polyline(new double[]{
        135, 10,
        100, 80,
        170, 80,
        135, 10,
    });
    polyline2.setStroke(Color.DODGERBLUE);
    polyline2.setStrokeWidth(2);
    polyline2.setFill(null);


    // Create a group to show all the polylines);
    getChildren().add(new Group(polyline1, polyline2));
    // REMOVE ME
    setControls(
            new SimplePropertySheet.PropDesc("Polyline 1 Fill", polyline1.fillProperty()),
            new SimplePropertySheet.PropDesc("Polyline 1 Stroke", polyline1.strokeProperty()),
            new SimplePropertySheet.PropDesc("Polyline 2 Stroke", polyline2.strokeProperty())
    );
    // END REMOVE ME
}

public static String shapeToSvgString(final Shape SHAPE) {
    final StringBuilder fxPath = new StringBuilder();
    if (Line.class.equals(SHAPE.getClass())) {
        fxPath.append(convertLine((Line) SHAPE));
    } else if (Arc.class.equals(SHAPE.getClass())) {
        fxPath.append(convertArc((Arc) SHAPE));
    } else if (QuadCurve.class.equals(SHAPE.getClass())) {
        fxPath.append(convertQuadCurve((QuadCurve) SHAPE));
    } else if (CubicCurve.class.equals(SHAPE.getClass())) {
        fxPath.append(convertCubicCurve((CubicCurve) SHAPE));
    } else if (Rectangle.class.equals(SHAPE.getClass())) {
        fxPath.append(convertRectangle((Rectangle) SHAPE));
    } else if (Circle.class.equals(SHAPE.getClass())) {
        fxPath.append(convertCircle((Circle) SHAPE));
    } else if (Ellipse.class.equals(SHAPE.getClass())) {
        fxPath.append(convertEllipse((Ellipse) SHAPE));
    } else if (Text.class.equals(SHAPE.getClass())) {
        Path path = (Path)(Shape.subtract(SHAPE, new Rectangle(0, 0)));
        fxPath.append(convertPath(path));
    } else if (Path.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPath((Path) SHAPE));
    } else if (Polygon.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPolygon((Polygon) SHAPE));
    } else if (Polyline.class.equals(SHAPE.getClass())) {
        fxPath.append(convertPolyline((Polyline) SHAPE));
    } else if (SVGPath.class.equals(SHAPE.getClass())) {
        fxPath.append(((SVGPath) SHAPE).getContent());
    }
    return fxPath.toString();
}

public static String convertPolyline(final Polyline POLYLINE) {
    final StringBuilder fxPath = new StringBuilder();
    final int           size   = POLYLINE.getPoints().size();
    if (size % 2 == 0) {
        List<Double> coordinates     = POLYLINE.getPoints();
        for (int i = 0 ; i < size ; i += 2) {
            fxPath.append(i == 0 ? "M " : "L ")
                  .append(coordinates.get(i)).append(" ").append(coordinates.get(i + 1)).append(" ");
        }
    }
    return fxPath.toString();
}

public PolylineNode(List<Double> points) {
    this(new Polyline(), points);
}

private PolylineNode(Polyline polyline, List<Double> points) {
    super(polyline);
    this.polyline = polyline;
    polyline.getPoints().addAll(points);
}

private void createTimeLine(final Pane field, final Interpolator interpolator) {
    Circle start = new Circle(10, 10, 3);
    start.setFill(Color.GREEN);
    Line finish = new Line(0, 110, 120, 110);
    finish.setStroke(Color.RED);
    field.getChildren().add(start);
    field.getChildren().add(finish);

    final Polyline pl = new Polyline();
    pl.getPoints().addAll(10., 10.);
    field.getChildren().add(pl);

    WritableDoubleValue dv = new WritableDoubleValue() {
        double value = 0;
        private double x = 10;
        private static final double Y = 9;

        public Number getValue() {
            return value;
        }

        public double get() {
            return value;
        }

        public void set(double d) {
            value = d;
            pl.getPoints().addAll(++x, Y + d);
        }

        public void setValue(Number t) {
            setValue(t.doubleValue());
        }
    };

    KeyFrame kf = new KeyFrame(Duration.millis(1000), new KeyValue(dv, Double.valueOf(100), interpolator));
    final Timeline timeline = new Timeline();
    timeline.getKeyFrames().add(kf);

    Platform.runLater(new Runnable() {
        public void run() {
            timeline.play();
        }
    });

}

@Override
public Class<? extends Node> getNodeClass() {
    return Polyline.class;
}

@Override // Override the start method in the Application class
public void start(Stage primaryStage) {
    // Create two panes
    Pane pane1 = new Pane();
    pane1.setRotate(180);
    pane1.setPadding(new Insets(72, 0, 0, 75));
    Pane pane2 = new Pane();

    // Create a polyline
    Polyline polyline1 = new Polyline();
    pane1.getChildren().add(polyline1);             
    ObservableList<Double> list = polyline1.getPoints();
    double scaleFactor = 0.0125;                       
    for (int x = -100; x <= 100; x++) {                
        list.add(x + 200.0);                            
        list.add(scaleFactor * x * x);                  
    }  

    // Create two lines
    Line lineX = new Line(10, 200, 350, 200);                                                
    //pane.getChildren().addAll(stackPane, lineX);

    Line lineY = new Line(lineX.getEndX() / 2, 250, lineX.getEndX() / 2, 30);                                                
    pane2.getChildren().addAll(pane1, lineX, lineY);

    // Create two polylines
    Polyline polyline2 = new Polyline();
    pane2.getChildren().add(polyline2);
    ObservableList<Double> list2 = polyline2.getPoints();
    list2.addAll(lineY.getEndX() - 10, lineY.getEndY() + 20, 
        lineY.getEndX(), lineY.getEndY(), lineY.getEndX() + 10, 
        lineY. getEndY() + 20);

    Polyline polyline3 = new Polyline();
    pane2.getChildren().add(polyline3);
    ObservableList<Double> list3 = polyline3.getPoints();
    list3.addAll(lineX.getEndX() - 20, lineX.getEndY() - 10, 
        lineX.getEndX(), lineX.getEndY(), lineX.getEndX() - 20, 
        lineX. getEndY() + 10);

    // Create two text objects
    Text textX = new Text(lineX.getEndX() - 10, lineX.getEndY() - 20, "X");
    Text textY = new Text(lineY.getEndX() + 20, lineY.getEndY() + 10, "Y");
    pane2.getChildren().addAll(textX, textY);

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane2);
    primaryStage.setTitle("Exercise_14_18"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
}

@Override // Override the start method in the Application class
public void start(Stage primaryStage) {
    // Create a pane
    Pane pane = new Pane();

    // Create three polylines and set their properties
    Polyline polyline1 = new Polyline();
    pane.getChildren().add(polyline1);
    polyline1.setStroke(Color.BLACK);
    ObservableList<Double> list = polyline1.getPoints();
    double x1 = 40.0;
    double y1 = 190.0;
    double y2 = 20.0;
    double x3 = 125.0;
    list.addAll(x1, y1, x1, y2, x3, y2, x3, y1 * .60);

    Polyline polyline2 = new Polyline();
    pane.getChildren().add(polyline2);
    polyline2.setStroke(Color.BLACK);
    ObservableList<Double> list2 = polyline2.getPoints();
    list2.addAll((x1 + x3) * .5, y1 * .5, x3, y1 * .25,
        x3 + (x3 - x1) * .5, y1 * .5);

    Polyline polyline3 = new Polyline();
    pane.getChildren().add(polyline3);
    polyline3.setStroke(Color.BLACK);
    ObservableList<Double> list3 = polyline3.getPoints();
    list3.addAll((x1 + x3) * .6, y1 * .80, x3, y1 * .60,
        x3 + (x3 - x1) * .3, y1 * .80);

    // Create a circle and set its properties
    Circle circle = new Circle(x3, y1 * .25, 15);
    circle.setFill(Color.WHITE);
    circle.setStroke(Color.BLACK);
    pane.getChildren().add(circle);

    // Create an arc and set its properties
    Arc arc = new Arc(x1, y1 + 1, 25, 15, 0, 180);
    arc.setFill(Color.WHITE);
    arc.setStroke(Color.BLACK);
    pane.getChildren().add(arc);

    // Create a scene and place it in the stage
    Scene scene = new Scene(pane, 200, 200);
    primaryStage.setTitle("Exercise_14_17"); // Set the stage title
    primaryStage.setScene(scene); // Place the scene in the stage
    primaryStage.show(); // Display the stage
}

/**
 * Gets the line
 * @return The main line
    */
public Polyline getLine(){
    return line;
}

/**
 * Gets the arrowhead
 * @return The arrowhead
    */
Polyline getArrowhead(){
    return arrowHead;
}

/**
 * Constructor.
 * 
 * @param sketchPointsVal The Sketch points list
 * @param sketchDrawingVal the Sketch displayed polyline
 */
SketchEvent(final List<Point2D> sketchPointsVal, final Polyline sketchDrawingVal) {
    super(EVENT_TYPE);
    sketchPoints = sketchPointsVal;
    sketchDrawing = sketchDrawingVal;
}

/**
 * Get the Sketch displayed polyline.
 * 
 * @return the Sketch displayed polyline
 */
final Polyline getSketchDrawing() {
    return sketchDrawing;
}