From a3e04c111532d6164aaf01f095a2b3c77013f05d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hakan=20I=C5=9F=C4=B1ktekin?= <hakan.isiktekin@gmail.com>
Date: Thu, 27 Jul 2017 14:41:52 +0300
Subject: [PATCH] Added dial chart. Refactored PlotContent_Pie. Removed
 warnings.

---
 .../xchart/demo/charts/dial/DialChart01.java  | 100 +++++
 .../java/org/knowm/xchart/BubbleChart.java    |  10 -
 .../main/java/org/knowm/xchart/DialChart.java | 178 +++++++++
 .../org/knowm/xchart/DialChartBuilder.java    |  35 ++
 .../java/org/knowm/xchart/DialSeries.java     | 175 +++++++++
 .../java/org/knowm/xchart/XChartPanel.java    |   3 +-
 .../internal/chartpart/PlotContent_Dial.java  | 284 ++++++++++++++
 .../internal/chartpart/PlotContent_Pie.java   |  20 +-
 .../internal/chartpart/PlotSurface_Pie.java   |  14 +-
 .../internal/chartpart/PlotSurface_Radar.java |  63 ----
 .../xchart/internal/chartpart/Plot_Dial.java  |  43 +++
 .../xchart/internal/chartpart/Plot_Pie.java   |  11 +-
 .../xchart/internal/chartpart/Plot_Radar.java |  38 +-
 .../org/knowm/xchart/style/DialStyler.java    | 345 ++++++++++++++++++
 14 files changed, 1195 insertions(+), 124 deletions(-)
 create mode 100644 xchart-demo/src/main/java/org/knowm/xchart/demo/charts/dial/DialChart01.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/DialChart.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/DialChartBuilder.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/DialSeries.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Dial.java
 delete mode 100644 xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Radar.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Dial.java
 create mode 100644 xchart/src/main/java/org/knowm/xchart/style/DialStyler.java

diff --git a/xchart-demo/src/main/java/org/knowm/xchart/demo/charts/dial/DialChart01.java b/xchart-demo/src/main/java/org/knowm/xchart/demo/charts/dial/DialChart01.java
new file mode 100644
index 000000000..fbd45ab51
--- /dev/null
+++ b/xchart-demo/src/main/java/org/knowm/xchart/demo/charts/dial/DialChart01.java
@@ -0,0 +1,100 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart.demo.charts.dial;
+
+import java.util.ArrayList;
+
+import org.knowm.xchart.DialChart;
+import org.knowm.xchart.DialChartBuilder;
+import org.knowm.xchart.SwingWrapper;
+import org.knowm.xchart.demo.charts.ExampleChart;
+
+/**
+ * Dial Chart
+ * <p>
+ * Demonstrates the following:
+ * <ul>
+ * <li>Dial Chart
+ * <li>DialChartBuilder
+ */
+public class DialChart01 implements ExampleChart<DialChart> {
+
+  public static void main(String[] args) {
+
+    ExampleChart<DialChart> exampleChart = new DialChart01();
+    ArrayList<DialChart> charts = new ArrayList<DialChart>();
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Dial chart");
+      charts.add(chart);
+    }
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Dial chart without green&red parts");
+      chart.getStyler().setRedFrom(-1);
+      chart.getStyler().setGreenFrom(-1);
+
+      charts.add(chart);
+    }
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Dial chart with custom ticks&labels");
+      chart.getStyler().setAxisTickValues(new double[] { .33, .45, .79});
+      chart.getStyler().setAxisTickLabels(new String[] { "min", "average", "max"});
+      charts.add(chart);
+    }
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Dial chart with custom arrow");
+      chart.getStyler().setArrowLengthPercentage(1.05);
+      chart.getStyler().setArrowArcAngle(90);
+      chart.getStyler().setArrowArcPercentage(.03);
+      charts.add(chart);
+    }
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Full circle dial chart");
+      chart.getStyler().setArcAngle(360);
+      //chart.getStyler().setDonutThickness(1);
+      chart.getStyler().setAxisTickLabelsVisible(false);
+      charts.add(chart);
+    }
+    {
+      DialChart chart = exampleChart.getChart();
+      chart.setTitle("Full circle dial chart without donut");
+      chart.getStyler().setArcAngle(360);
+      chart.getStyler().setDonutThickness(1);
+      chart.getStyler().setAxisTickLabelsVisible(false);
+      charts.add(chart);
+    }
+    new SwingWrapper<DialChart>(charts).displayChartMatrix();
+  }
+
+  @Override
+  public DialChart getChart() {
+
+    // Create Chart
+    DialChart chart = new DialChartBuilder().width(480).height(400).title("Dial Chart").build();
+
+    // Series
+    chart.addSeries("Rate", 0.9381, "93.81 %");
+    chart.getStyler().setToolTipsEnabled(true);
+    chart.getStyler().setLegendVisible(false);
+
+    return chart;
+  }
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/BubbleChart.java b/xchart/src/main/java/org/knowm/xchart/BubbleChart.java
index d532a106f..e11f8bfc8 100644
--- a/xchart/src/main/java/org/knowm/xchart/BubbleChart.java
+++ b/xchart/src/main/java/org/knowm/xchart/BubbleChart.java
@@ -16,8 +16,6 @@
  */
 package org.knowm.xchart;
 
-import java.awt.BasicStroke;
-import java.awt.Color;
 import java.awt.Graphics2D;
 import java.util.List;
 import java.util.Map;
@@ -244,14 +242,6 @@ private void setSeriesStyles() {
 
       SeriesColorMarkerLineStyle seriesColorMarkerLineStyle = seriesColorMarkerLineStyleCycler.getNextSeriesColorMarkerLineStyle();
 
-      /** Line Style */
-      BasicStroke stroke;
-
-      /** Line Color */
-      Color lineColor;
-
-      /** Line Width */
-      float lineWidth = -1.0f;
       if (series.getLineStyle() == null) { // wasn't set manually
         series.setLineStyle(seriesColorMarkerLineStyle.getStroke());
       }
diff --git a/xchart/src/main/java/org/knowm/xchart/DialChart.java b/xchart/src/main/java/org/knowm/xchart/DialChart.java
new file mode 100644
index 000000000..c33c1a69c
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/DialChart.java
@@ -0,0 +1,178 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart;
+
+import java.awt.Graphics2D;
+
+import org.knowm.xchart.internal.chartpart.Chart;
+import org.knowm.xchart.internal.chartpart.Legend_Pie;
+import org.knowm.xchart.internal.chartpart.Plot_Dial;
+import org.knowm.xchart.internal.style.SeriesColorMarkerLineStyle;
+import org.knowm.xchart.internal.style.SeriesColorMarkerLineStyleCycler;
+import org.knowm.xchart.style.DialStyler;
+import org.knowm.xchart.style.Styler.ChartTheme;
+import org.knowm.xchart.style.Theme;
+
+/**
+ * @author timmolter
+ */
+public class DialChart extends Chart<DialStyler, DialSeries> {
+
+  public enum DialRenderStyle {
+    Polygon, Circle;
+  }
+
+  private DialRenderStyle radarRenderStyle = DialRenderStyle.Polygon;
+
+  /**
+   * Constructor - the default Chart Theme will be used (XChartTheme)
+   *
+   * @param width
+   * @param height
+   */
+  public DialChart(int width, int height) {
+
+    super(width, height, new DialStyler());
+    plot = new Plot_Dial(this);
+    legend = new Legend_Pie(this);
+  }
+
+  /**
+   * Constructor
+   *
+   * @param width
+   * @param height
+   * @param theme - pass in a instance of Theme class, probably a custom Theme.
+   */
+  public DialChart(int width, int height, Theme theme) {
+
+    this(width, height);
+    styler.setTheme(theme);
+  }
+
+  /**
+   * Constructor
+   *
+   * @param width
+   * @param height
+   * @param chartTheme - pass in the desired ChartTheme enum
+   */
+  public DialChart(int width, int height, ChartTheme chartTheme) {
+
+    this(width, height, chartTheme.newInstance(chartTheme));
+  }
+
+  /**
+   * Constructor
+   *
+   * @param chartBuilder
+   */
+  public DialChart(DialChartBuilder chartBuilder) {
+
+    this(chartBuilder.width, chartBuilder.height, chartBuilder.chartTheme);
+    setTitle(chartBuilder.title);
+  }
+
+  /**
+   * Add a series for a Dial type chart
+   *
+   * @param seriesName
+   * @param value
+   * @return
+   */
+  public DialSeries addSeries(String seriesName, double value) {
+
+    return addSeries(seriesName, value, null);
+  }
+
+  public DialSeries addSeries(String seriesName, double value, String toolTip) {
+
+    // Sanity checks
+    sanityCheck(seriesName, value);
+
+    DialSeries series = new DialSeries(seriesName, value, toolTip);
+
+    seriesMap.put(seriesName, series);
+
+    return series;
+  }
+
+  private void sanityCheck(String seriesName, double value) {
+
+    if (seriesMap.keySet().contains(seriesName)) {
+      throw new IllegalArgumentException("Series name >" + seriesName + "< has already been used. Use unique names for each series!!!");
+    }
+    if (value < 0 || value > 1) {
+      throw new IllegalArgumentException("Value must be in [0, 1] range!!!");
+    }
+
+  }
+
+  @Override
+  public void paint(Graphics2D g, int width, int height) {
+
+    setWidth(width);
+    setHeight(height);
+
+    setSeriesStyles();
+
+    paintBackground(g);
+
+    plot.paint(g);
+    chartTitle.paint(g);
+    legend.paint(g);
+  }
+
+  /**
+   * set the series color based on theme
+   */
+  private void setSeriesStyles() {
+
+    SeriesColorMarkerLineStyleCycler seriesColorMarkerLineStyleCycler = new SeriesColorMarkerLineStyleCycler(getStyler().getSeriesColors(), getStyler().getSeriesMarkers(), getStyler()
+        .getSeriesLines());
+    for (DialSeries series : getSeriesMap().values()) {
+
+      SeriesColorMarkerLineStyle seriesColorMarkerLineStyle = seriesColorMarkerLineStyleCycler.getNextSeriesColorMarkerLineStyle();
+
+      if (series.getLineStyle() == null) { // wasn't set manually
+        series.setLineStyle(seriesColorMarkerLineStyle.getStroke());
+      }
+      if (series.getLineColor() == null) { // wasn't set manually
+        series.setLineColor(seriesColorMarkerLineStyle.getColor());
+      }
+      if (series.getFillColor() == null) { // wasn't set manually
+        series.setFillColor(seriesColorMarkerLineStyle.getColor());
+      }
+      if (series.getMarker() == null) { // wasn't set manually
+        series.setMarker(seriesColorMarkerLineStyle.getMarker());
+      }
+      if (series.getMarkerColor() == null) { // wasn't set manually
+        series.setMarkerColor(seriesColorMarkerLineStyle.getColor());
+      }
+    }
+  }
+
+  public DialRenderStyle getDialRenderStyle() {
+
+    return radarRenderStyle;
+  }
+
+  public void setDialRenderStyle(DialRenderStyle radarRenderStyle) {
+
+    this.radarRenderStyle = radarRenderStyle;
+  }
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/DialChartBuilder.java b/xchart/src/main/java/org/knowm/xchart/DialChartBuilder.java
new file mode 100644
index 000000000..a4edac7dc
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/DialChartBuilder.java
@@ -0,0 +1,35 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart;
+
+import org.knowm.xchart.internal.ChartBuilder;
+
+/**
+ * @author timmolter
+ */
+public class DialChartBuilder extends ChartBuilder<DialChartBuilder, DialChart> {
+
+  public DialChartBuilder() {
+
+  }
+
+  @Override
+  public DialChart build() {
+
+    return new DialChart(this);
+  }
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/DialSeries.java b/xchart/src/main/java/org/knowm/xchart/DialSeries.java
new file mode 100644
index 000000000..c7251bc04
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/DialSeries.java
@@ -0,0 +1,175 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+
+import org.knowm.xchart.internal.chartpart.RenderableSeries.LegendRenderType;
+import org.knowm.xchart.internal.series.Series;
+import org.knowm.xchart.style.markers.Marker;
+
+/**
+ * A Series containing Radar data to be plotted on a Chart
+ *
+ * @author timmolter
+ */
+public class DialSeries extends Series {
+
+  /**
+   * Line Style
+   */
+  private BasicStroke stroke;
+
+  /**
+   * Line Color
+   */
+  private Color lineColor;
+
+  /**
+   * Line Width
+   */
+  private float lineWidth;
+
+  /**
+   * Marker
+   */
+  private Marker marker;
+
+  /**
+   * Marker Color
+   */
+  private Color markerColor;
+
+  private double value;
+  private String toolTip;
+
+  /**
+   * @param toolTips Adds custom tool tips for series. If tool tip is null, it is automatically calculated.
+   */
+  public DialSeries(String name, double value, String toolTip) {
+
+    super(name);
+    this.value = value;
+    this.toolTip = toolTip;
+  }
+
+  public double getValue() {
+
+    return value;
+  }
+  
+  public void setValue(double value) {
+
+    this.value = value;
+  }
+  
+  public String getToolTip() {
+
+    return toolTip;
+  }
+  
+  /**
+   * Set the line style of the series
+   *
+   * @param basicStroke
+   */
+  public DialSeries setLineStyle(BasicStroke basicStroke) {
+
+    stroke = basicStroke;
+    if (this.lineWidth > 0.0f) {
+      stroke = new BasicStroke(lineWidth, this.stroke.getEndCap(), this.stroke.getLineJoin(), this.stroke.getMiterLimit(), this.stroke.getDashArray(), this.stroke.getDashPhase());
+    }
+    return this;
+  }
+
+  /**
+   * Set the line color of the series
+   *
+   * @param color
+   */
+  public DialSeries setLineColor(java.awt.Color color) {
+
+    this.lineColor = color;
+    return this;
+  }
+
+  /**
+   * Set the line width of the series
+   *
+   * @param lineWidth
+   */
+  public DialSeries setLineWidth(float lineWidth) {
+
+    this.lineWidth = lineWidth;
+    return this;
+  }
+
+  /**
+   * Sets the marker for the series
+   *
+   * @param marker
+   */
+  public DialSeries setMarker(Marker marker) {
+
+    this.marker = marker;
+    return this;
+  }
+
+  /**
+   * Sets the marker color for the series
+   *
+   * @param color
+   */
+  public DialSeries setMarkerColor(java.awt.Color color) {
+
+    this.markerColor = color;
+    return this;
+  }
+
+  public BasicStroke getLineStyle() {
+
+    return stroke;
+  }
+
+  public Color getLineColor() {
+
+    return lineColor;
+  }
+
+  public float getLineWidth() {
+
+    return lineWidth;
+  }
+
+  public Marker getMarker() {
+
+    return marker;
+  }
+
+  public Color getMarkerColor() {
+
+    return markerColor;
+  }
+
+  @Override
+  public LegendRenderType getLegendRenderType() {
+
+    // Pie charts are always rendered as a Box in the legend
+    return null;
+  }
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/XChartPanel.java b/xchart/src/main/java/org/knowm/xchart/XChartPanel.java
index 5404780a6..0447d1c6a 100644
--- a/xchart/src/main/java/org/knowm/xchart/XChartPanel.java
+++ b/xchart/src/main/java/org/knowm/xchart/XChartPanel.java
@@ -35,7 +35,6 @@
 import javax.swing.JPanel;
 import javax.swing.JPopupMenu;
 import javax.swing.KeyStroke;
-import javax.swing.UIDefaults;
 import javax.swing.UIManager;
 import javax.swing.filechooser.FileFilter;
 
@@ -220,7 +219,7 @@ private void showExportAsDialog() {
     UIManager.put("FileChooser.saveButtonText", "Export");
     UIManager.put("FileChooser.fileNameLabelText", "Export To:");
     UIManager.put("FileChooser.saveDialogFileNameLabel.textAndMnemonic", "Export To:");
-    UIDefaults defaults = UIManager.getDefaults();
+//    UIDefaults defaults = UIManager.getDefaults();
 //    System.out.println(defaults.size()+ " properties");
 //    for (Enumeration e = defaults.keys();
 //         e.hasMoreElements();) {
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Dial.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Dial.java
new file mode 100644
index 000000000..ebc79593f
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Dial.java
@@ -0,0 +1,284 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart.internal.chartpart;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.font.FontRenderContext;
+import java.awt.font.TextLayout;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.Map;
+
+import org.knowm.xchart.DialSeries;
+import org.knowm.xchart.internal.series.Series;
+import org.knowm.xchart.style.DialStyler;
+import org.knowm.xchart.style.Styler;
+
+public class PlotContent_Dial<ST extends Styler, S extends Series> extends PlotContent_ {
+
+  private final DialStyler styler;
+  private final NumberFormat df = DecimalFormat.getPercentInstance();
+
+  PlotContent_Dial(Chart<DialStyler, DialSeries> chart) {
+
+    super(chart);
+    styler = chart.getStyler();
+  }
+
+  @Override
+  public void doPaint(Graphics2D g) {
+
+    double pieFillPercentage = styler.getPlotContentSize();
+
+    double halfBorderPercentage = (1 - pieFillPercentage) / 2.0;
+    double boundsWidth = getBounds().getWidth();
+    double boundsHeight = getBounds().getHeight();
+    double min = Math.min(boundsWidth, boundsHeight);
+    double width = styler.isCircular() ? min : boundsWidth;
+    double height = styler.isCircular() ? min : boundsHeight;
+
+    // we need to adjust height when arcAngle is small. To much wasted space on buttom of the chart
+    // Not sure but something like r +=  r - cos((360-arcAngle)/2) where r is vertical radius
+ 
+
+    Rectangle2D pieBounds = new Rectangle2D.Double(
+
+        getBounds().getX() + boundsWidth / 2 - width / 2 + halfBorderPercentage * width,
+
+        getBounds().getY() + boundsHeight / 2 - height / 2 + halfBorderPercentage * height,
+
+        width * pieFillPercentage,
+
+        height * pieFillPercentage);
+
+    // get total
+    boolean axisTickLabelsVisible = styler.isAxisTickLabelsVisible();
+    double arcAngle = styler.getArcAngle();
+    double donutThickness = styler.getDonutThickness();
+    int axisTitlePadding = styler.getAxisTitlePadding();
+
+    double[] axisTickValues = styler.getAxisTickValues();
+    int markCount = axisTickValues.length;
+    String[] axisTickLabels = styler.getAxisTickLabels();
+
+    double[] fromArr = { styler.getNormalFrom(), styler.getGreenFrom(), styler.getRedFrom() };
+    double[] toArr = { styler.getNormalTo(), styler.getGreenTo(), styler.getRedTo() };
+    Color[] donutColorArr = { styler.getNormalColor(), styler.getGreenColor(), styler.getRedColor() };
+
+    double dountStartAngle = (arcAngle) / 2 + 90;
+    // draw shape
+    for (int i = 0; i < donutColorArr.length; i++) {
+      double from = fromArr[i];
+      double to = toArr[i];
+      if (to <= from || to < 0 || from < 0) {
+        continue;
+      }
+      double totalAngle = (to - from) * arcAngle;
+      double startAngle = dountStartAngle - from * arcAngle - totalAngle;
+      Shape donutSlice = PlotContent_Pie.getDonutSliceShape(pieBounds, donutThickness, startAngle, totalAngle);
+      g.setColor(donutColorArr[i]);
+      g.fill(donutSlice);
+      g.draw(donutSlice);
+    }
+
+    double xDiameter = pieBounds.getWidth() / 2;
+    double yDiameter = pieBounds.getHeight() / 2;
+
+    double xCenter = pieBounds.getX() + xDiameter;
+    double yCenter = pieBounds.getY() + yDiameter;
+
+    if (markCount > 0 && styler.isAxisTicksMarksVisible()) {
+      g.setColor(styler.getAxisTickMarksColor());
+      g.setStroke(styler.getAxisTickMarksStroke());
+
+      for (int i = 0; i < markCount; i++) {
+        double angle = -axisTickValues[i] * arcAngle + (arcAngle) / 2 + 90;
+        double radians = Math.toRadians(angle);
+        double cos = Math.cos(radians);
+        double sin = Math.sin(radians);
+
+        double xOffset = xCenter + cos * xDiameter;
+        double yOffset = yCenter - sin * yDiameter;
+        double xOffset2 = xCenter + cos * xDiameter * (1 - donutThickness);
+        double yOffset2 = yCenter - sin * yDiameter * (1 - donutThickness);
+
+        Line2D.Double line = new Line2D.Double(xOffset2, yOffset2, xOffset, yOffset);
+        g.setColor(styler.getAxisTickMarksColor());
+        g.setStroke(styler.getAxisTickMarksStroke());
+        g.draw(line);
+
+        if (!axisTickLabelsVisible) {
+          continue;
+        }
+        String annotation = axisTickLabels[i];
+
+        TextLayout textLayout = new TextLayout(annotation, styler.getAxisTitleFont(),
+            new FontRenderContext(null, true, false));
+        Shape shape = textLayout.getOutline(null);
+
+        Rectangle2D annotationBounds = shape.getBounds2D();
+        double annotationWidth = annotationBounds.getWidth();
+        double annotationHeight = annotationBounds.getHeight();
+
+        // calculate corrections
+        double xc;
+        double yc = 0;
+        if (axisTickValues[i] < 0.49) {
+          xc = 0;
+        } else if (axisTickValues[i] > 0.51) {
+          xc = -annotationWidth;
+        } else {
+          xc = -annotationWidth / 2;
+          yc = annotationHeight / 2;
+        }
+        xOffset2 = xCenter + cos * (xDiameter - axisTitlePadding) * (1 - donutThickness);
+        yOffset2 = yCenter - sin * (yDiameter - axisTitlePadding) * (1 - donutThickness);
+
+        double tx = xOffset2 + xc;
+        double ty = yOffset2 + yc + annotationHeight / 2;
+
+        g.setColor(styler.getChartFontColor());
+        g.setFont(styler.getAnnotationsFont());
+        AffineTransform orig = g.getTransform();
+        AffineTransform at = new AffineTransform();
+
+        at.translate(tx, ty);
+
+        g.transform(at);
+        g.fill(shape);
+        g.setTransform(orig);
+      }
+    }
+
+    Map<String, DialSeries> map = chart.getSeriesMap();
+    for (DialSeries series : map.values()) {
+      if (!series.isEnabled()) {
+        continue;
+      }
+
+      // draw title
+      if (styler.isAxisTitleVisible()) {
+        TextLayout textLayout = new TextLayout(series.getName(), styler.getAxisTitleFont(),
+            new FontRenderContext(null, true, false));
+        Shape shape = textLayout.getOutline(null);
+
+        Rectangle2D annotationBounds = shape.getBounds2D();
+        double annotationWidth = annotationBounds.getWidth();
+        double annotationHeight = annotationBounds.getHeight();
+
+        // calculate corrections
+        double tx = xCenter - annotationWidth / 2;
+        double ty = yCenter - yDiameter / 2 + annotationHeight / 2;
+
+        g.setColor(styler.getChartFontColor());
+        g.setFont(styler.getAxisTitleFont());
+        AffineTransform orig = g.getTransform();
+        AffineTransform at = new AffineTransform();
+
+        at.translate(tx, ty);
+
+        g.transform(at);
+        g.fill(shape);
+        g.setTransform(orig);
+      }
+
+      double value = series.getValue();
+      // draw title
+      if (styler.hasAnnotations()) {
+        String annotation = series.getToolTip();
+        if (annotation == null) {
+          if (styler.getDecimalPattern() != null) {
+            DecimalFormat df = new DecimalFormat(styler.getDecimalPattern());
+            annotation = df.format(value);
+          } else {
+            annotation = df.format(value);
+          }
+        }
+        if (!annotation.isEmpty()) {
+          TextLayout textLayout = new TextLayout(annotation, styler.getAnnotationsFont(),
+              new FontRenderContext(null, true, false));
+          Shape shape = textLayout.getOutline(null);
+
+          Rectangle2D annotationBounds = shape.getBounds2D();
+          double annotationWidth = annotationBounds.getWidth();
+          double annotationHeight = annotationBounds.getHeight();
+
+          double tx = xCenter - annotationWidth / 2;
+          double ty = yCenter + yDiameter / 2 - annotationHeight / 2;
+
+          g.setColor(styler.getChartFontColor());
+          g.setFont(styler.getAxisTitleFont());
+          AffineTransform orig = g.getTransform();
+          AffineTransform at = new AffineTransform();
+
+          at.translate(tx, ty);
+
+          g.transform(at);
+          g.fill(shape);
+          g.setTransform(orig);
+        }
+      }
+
+      // draw arrow
+      double angle = -value * arcAngle + (arcAngle) / 2 + 90;
+
+      double radians = Math.toRadians(angle);
+      double arrowLengthPercentage = styler.getArrowLengthPercentage();
+      double arrowArcAngle = styler.getArrowArcAngle();
+      double arrowArcPercentage = styler.getArrowArcPercentage();
+      double xOffset = xCenter + Math.cos(radians) * (xDiameter * arrowLengthPercentage);
+      double yOffset = yCenter - Math.sin(radians) * (yDiameter * arrowLengthPercentage);
+
+      Path2D.Double path = new Path2D.Double();
+      if (styler.isToolTipsEnabled()) {
+        String annotation = series.getToolTip();
+        if (annotation == null) {
+          if (styler.getDecimalPattern() != null) {
+            DecimalFormat df = new DecimalFormat(styler.getDecimalPattern());
+            annotation = df.format(value);
+          } else {
+            annotation = df.format(value);
+          }
+        }
+        chart.toolTips.addData(path, xOffset, yOffset + 10, 0, annotation);
+      }
+      path.moveTo(xCenter, yCenter);
+
+      double[][] angleValues = { { -arrowArcAngle, arrowArcPercentage }, { 0, 1 }, { arrowArcAngle, arrowArcPercentage } };
+      for (double[] ds : angleValues) {
+        radians = Math.toRadians(angle - ds[0]);
+
+        double diameterPerct = arrowLengthPercentage * ds[1];
+        xOffset = xCenter + Math.cos(radians) * (xDiameter * diameterPerct);
+        yOffset = yCenter - Math.sin(radians) * (yDiameter * diameterPerct);
+        path.lineTo(xOffset, yOffset);
+      }
+
+      path.closePath();
+      g.setColor(series.getFillColor());
+      g.fill(path);
+      g.setColor(series.getLineColor());
+      g.draw(path);
+    }
+  }
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Pie.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Pie.java
index 8d619611a..e21b82aa0 100644
--- a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Pie.java
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotContent_Pie.java
@@ -289,20 +289,25 @@ public void doPaint(Graphics2D g) {
     }
   }
 
-  private Shape getDonutSliceShape(Rectangle2D pieBounds, double thickness, double start, double extent) {
+  public static Shape getDonutSliceShape(Rectangle2D pieBounds, double thickness, double start, double extent) {
 
     thickness = thickness / 2;
 
     GeneralPath generalPath = new GeneralPath();
     GeneralPath dummy = new GeneralPath(); // used to find arc endpoints
 
-    Shape outer = new Arc2D.Double(pieBounds.getX(), pieBounds.getY(), pieBounds.getWidth(), pieBounds.getHeight(), start, extent, Arc2D.OPEN);
-    Shape inner = new Arc2D.Double(pieBounds.getX() + pieBounds.getWidth() * thickness, pieBounds.getY() + pieBounds.getHeight() * thickness, pieBounds.getWidth() - 2 * pieBounds.getWidth()
-        * thickness, pieBounds.getHeight() - 2 * pieBounds.getHeight() * thickness, start + extent, -extent, Arc2D.OPEN);
+    double x = pieBounds.getX();
+    double y = pieBounds.getY();
+    double width = pieBounds.getWidth();
+    double height = pieBounds.getHeight();
+    Shape outer = new Arc2D.Double(x, y, width, height, start, extent, Arc2D.OPEN);
+    double wt = width * thickness;
+    double ht = height * thickness;
+    Shape inner = new Arc2D.Double(x + wt, y + ht, width - 2 * wt, height - 2 * ht, start + extent, -extent,
+        Arc2D.OPEN);
     generalPath.append(outer, false);
 
-    dummy.append(new Arc2D.Double(pieBounds.getX() + pieBounds.getWidth() * thickness, pieBounds.getY() + pieBounds.getHeight() * thickness, pieBounds.getWidth() - 2 * pieBounds.getWidth()
-        * thickness, pieBounds.getHeight() - 2 * pieBounds.getHeight() * thickness, start, extent, Arc2D.OPEN), false);
+    dummy.append(new Arc2D.Double(x + wt, y + ht, width - 2 * wt, height - 2 * ht, start, extent, Arc2D.OPEN), false);
 
     Point2D point = dummy.getCurrentPoint();
 
@@ -311,10 +316,11 @@ private Shape getDonutSliceShape(Rectangle2D pieBounds, double thickness, double
     }
     generalPath.append(inner, false);
 
-    dummy.append(new Arc2D.Double(pieBounds.getX(), pieBounds.getY(), pieBounds.getWidth(), pieBounds.getHeight(), start + extent, -extent, Arc2D.OPEN), false);
+    dummy.append(new Arc2D.Double(x, y, width, height, start + extent, -extent, Arc2D.OPEN), false);
 
     point = dummy.getCurrentPoint();
     generalPath.lineTo(point.getX(), point.getY());
     return generalPath;
   }
+
 }
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Pie.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Pie.java
index dac8694e6..1a161837a 100644
--- a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Pie.java
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Pie.java
@@ -20,9 +20,7 @@
 import java.awt.Shape;
 import java.awt.geom.Rectangle2D;
 
-import org.knowm.xchart.PieSeries;
 import org.knowm.xchart.internal.series.Series;
-import org.knowm.xchart.style.PieStyler;
 import org.knowm.xchart.style.Styler;
 
 /**
@@ -32,17 +30,17 @@
  */
 public class PlotSurface_Pie<ST extends Styler, S extends Series> extends PlotSurface_ {
 
-  private final PieStyler stylerPie;
+  private final Styler styler;
 
   /**
    * Constructor
    *
    * @param chart
    */
-  PlotSurface_Pie(Chart<PieStyler, PieSeries> chart) {
+  PlotSurface_Pie(Chart<? extends Styler, ? extends Series> chart) {
 
     super(chart);
-    this.stylerPie = chart.getStyler();
+    this.styler = chart.getStyler();
   }
 
   @Override
@@ -52,12 +50,12 @@ public void paint(Graphics2D g) {
 
     // paint plot background
     Shape rect = new Rectangle2D.Double(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight());
-    g.setColor(stylerPie.getPlotBackgroundColor());
+    g.setColor(styler.getPlotBackgroundColor());
     g.fill(rect);
 
     // paint plot border
-    if (stylerPie.isPlotBorderVisible()) {
-      g.setColor(stylerPie.getPlotBorderColor());
+    if (styler.isPlotBorderVisible()) {
+      g.setColor(styler.getPlotBorderColor());
       // g.setStroke(getChartPainter().getstyler().getAxisTickMarksStroke());
       g.draw(rect);
     }
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Radar.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Radar.java
deleted file mode 100644
index 4dcd0f89d..000000000
--- a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/PlotSurface_Radar.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
- * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.knowm.xchart.internal.chartpart;
-
-import java.awt.Graphics2D;
-import java.awt.Shape;
-import java.awt.geom.Rectangle2D;
-
-import org.knowm.xchart.RadarSeries;
-import org.knowm.xchart.internal.series.Series;
-import org.knowm.xchart.style.RadarStyler;
-import org.knowm.xchart.style.Styler;
-
-/**
- * Draws the plot background and the plot border
- */
-public class PlotSurface_Radar<ST extends Styler, S extends Series> extends PlotSurface_ {
-
-  private final RadarStyler stylerRadar;
-
-  /**
-   * Constructor
-   *
-   * @param chart
-   */
-  PlotSurface_Radar(Chart<RadarStyler, RadarSeries> chart) {
-
-    super(chart);
-    this.stylerRadar = chart.getStyler();
-  }
-
-  @Override
-  public void paint(Graphics2D g) {
-
-    Rectangle2D bounds = getBounds();
-
-    // paint plot background
-    Shape rect = new Rectangle2D.Double(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight());
-    g.setColor(stylerRadar.getPlotBackgroundColor());
-    g.fill(rect);
-
-    // paint plot border
-    if (stylerRadar.isPlotBorderVisible()) {
-      g.setColor(stylerRadar.getPlotBorderColor());
-      // g.setStroke(getChartPainter().getstyler().getAxisTickMarksStroke());
-      g.draw(rect);
-    }
-  }
-}
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Dial.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Dial.java
new file mode 100644
index 000000000..419342e08
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Dial.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart.internal.chartpart;
+
+import org.knowm.xchart.DialSeries;
+import org.knowm.xchart.internal.series.Series;
+import org.knowm.xchart.style.DialStyler;
+import org.knowm.xchart.style.Styler;
+
+public class Plot_Dial<ST extends Styler, S extends Series> extends Plot_Pie<ST, S> {
+
+  /**
+   * Constructor
+   *
+   * @param chart
+   */
+  public Plot_Dial(Chart<DialStyler, DialSeries> chart) {
+
+    super((Chart<ST, S>) chart);
+  }
+  
+  @Override
+  protected void initContentAndSurface(Chart<ST, S> chart) {
+  
+    this.plotContent = new PlotContent_Dial(chart);
+    this.plotSurface = new PlotSurface_Pie(chart);
+  }
+  
+}
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Pie.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Pie.java
index 0e95e3907..0dc157974 100644
--- a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Pie.java
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Pie.java
@@ -35,11 +35,16 @@ public class Plot_Pie<ST extends Styler, S extends Series> extends Plot_ {
    *
    * @param chart
    */
-  public Plot_Pie(Chart<PieStyler, PieSeries> chart) {
+  public Plot_Pie(Chart<ST, S> chart) {
 
     super(chart);
-    this.plotContent = new PlotContent_Pie<PieStyler, PieSeries>(chart);
-    this.plotSurface = new PlotSurface_Pie<PieStyler, PieSeries>(chart);
+    initContentAndSurface(chart);
+  }
+
+  protected void initContentAndSurface(Chart<ST, S> chart) {
+
+    this.plotContent = new PlotContent_Pie<PieStyler, PieSeries>((Chart<PieStyler, PieSeries>) chart);
+    this.plotSurface = new PlotSurface_Pie<PieStyler, PieSeries>((Chart<PieStyler, PieSeries>) chart);
   }
 
   @Override
diff --git a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Radar.java b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Radar.java
index 49b6154be..5a115c205 100644
--- a/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Radar.java
+++ b/xchart/src/main/java/org/knowm/xchart/internal/chartpart/Plot_Radar.java
@@ -16,16 +16,12 @@
  */
 package org.knowm.xchart.internal.chartpart;
 
-import java.awt.Graphics2D;
-import java.awt.geom.Rectangle2D;
-
 import org.knowm.xchart.RadarSeries;
 import org.knowm.xchart.internal.series.Series;
 import org.knowm.xchart.style.RadarStyler;
 import org.knowm.xchart.style.Styler;
-import org.knowm.xchart.style.Styler.LegendPosition;
 
-public class Plot_Radar<ST extends Styler, S extends Series> extends Plot_ {
+public class Plot_Radar<ST extends Styler, S extends Series> extends Plot_Pie<ST, S> {
 
   /**
    * Constructor
@@ -34,34 +30,14 @@ public class Plot_Radar<ST extends Styler, S extends Series> extends Plot_ {
    */
   public Plot_Radar(Chart<RadarStyler, RadarSeries> chart) {
 
-    super(chart);
-    this.plotContent = new PlotContent_Radar<RadarStyler, RadarSeries>(chart);
-    this.plotSurface = new PlotSurface_Radar<RadarStyler, RadarSeries>(chart);
+    super((Chart<ST, S>) chart);
   }
 
   @Override
-  public void paint(Graphics2D g) {
-
-    // calculate bounds
-    double xOffset = chart.getStyler().getChartPadding();
-
-    // double yOffset = chart.getChartTitle().getBounds().getHeight() + 2 * chart.getStyler().getChartPadding();
-    double yOffset = chart.getChartTitle().getBounds().getHeight() + chart.getStyler().getChartPadding();
-
-    double width =
-
-        chart.getWidth()
-
-            - (chart.getStyler().getLegendPosition() == LegendPosition.OutsideE ? chart.getLegend().getBounds().getWidth() : 0)
-
-            - 2 * chart.getStyler().getChartPadding()
-
-            - (chart.getStyler().getLegendPosition() == LegendPosition.OutsideE && chart.getStyler().isLegendVisible() ? chart.getStyler().getChartPadding() : 0);
-
-    double height = chart.getHeight() - chart.getChartTitle().getBounds().getHeight() - 2 * chart.getStyler().getChartPadding();
-
-    this.bounds = new Rectangle2D.Double(xOffset, yOffset, width, height);
-
-    super.paint(g);
+  protected void initContentAndSurface(Chart<ST, S> chart) {
+  
+    this.plotContent = new PlotContent_Radar(chart);
+    this.plotSurface = new PlotSurface_Pie(chart);
   }
+
 }
diff --git a/xchart/src/main/java/org/knowm/xchart/style/DialStyler.java b/xchart/src/main/java/org/knowm/xchart/style/DialStyler.java
new file mode 100644
index 000000000..96e6d0eb0
--- /dev/null
+++ b/xchart/src/main/java/org/knowm/xchart/style/DialStyler.java
@@ -0,0 +1,345 @@
+/**
+ * Copyright 2015-2017 Knowm Inc. (http://knowm.org) and contributors.
+ * Copyright 2011-2015 Xeiam LLC (http://xeiam.com) and contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.knowm.xchart.style;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Stroke;
+
+/**
+ * @author timmolter
+ */
+public class DialStyler extends Styler {
+
+  private boolean isCircular;
+
+  // helper tick lines
+  private boolean axisTicksMarksVisible;
+  private Color axisTickMarksColor;
+  private Stroke axisTickMarksStroke;
+  private double[] axisTickValues = { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 };
+  private String[] axisTickLabels = { "0", "10", "20", "30", "40", "50", "60", "70", "80", "90", "100" };
+
+  // variable labels
+  private boolean axisTitleVisible;
+  private Font axisTitleFont;
+  private int axisTitlePadding;
+  private boolean axisTickLabelsVisible = true;
+
+  // donut area
+  private double arcAngle = 270;
+  private double donutThickness = .11;
+
+  private double normalFrom = 0;
+  private double normalTo = 1;
+  private Color normalColor = Color.LIGHT_GRAY;
+
+  private double greenFrom = 0;
+  private double greenTo = 0.2;
+  private Color greenColor = Color.GREEN;
+
+  private double redFrom = 0.8;
+  private double redTo = 1;
+  private Color redColor = Color.RED;
+
+  //
+  private double arrowLengthPercentage = 0.85;
+  private double arrowArcAngle = 20;
+  private double arrowArcPercentage = 0.15;
+
+  public DialStyler() {
+
+    this.setAllStyles();
+    super.setAllStyles();
+  }
+
+  @Override
+  void setAllStyles() {
+
+    this.isCircular = theme.isCircular();
+
+    // Annotations ////////////////////////////////
+    this.hasAnnotations = true;
+
+    this.axisTickMarksColor = theme.getAxisTickMarksColor();
+    this.axisTickMarksStroke = theme.getAxisTickMarksStroke();
+    this.axisTicksMarksVisible = theme.isAxisTicksMarksVisible();
+
+    this.axisTitleVisible = theme.isXAxisTitleVisible() || theme.isYAxisTitleVisible();
+    this.axisTitleFont = theme.getAxisTitleFont();
+    this.axisTitlePadding = theme.getAxisTitlePadding();
+  }
+
+  public boolean isCircular() {
+
+    return isCircular;
+  }
+
+  /**
+   * Sets whether or not the radar chart is forced to be circular. Otherwise
+   * it's shape is oval, matching the containing plot.
+   *
+   * @param isCircular
+   */
+  public DialStyler setCircular(boolean isCircular) {
+
+    this.isCircular = isCircular;
+    return this;
+  }
+
+  /**
+   * Set the theme the styler should use
+   *
+   * @param theme
+   */
+  public DialStyler setTheme(Theme theme) {
+
+    this.theme = theme;
+    super.setAllStyles();
+    return this;
+  }
+
+  public boolean isAxisTicksMarksVisible() {
+
+    return axisTicksMarksVisible;
+  }
+
+  public void setAxisTicksMarksVisible(boolean axisTicksMarksVisible) {
+
+    this.axisTicksMarksVisible = axisTicksMarksVisible;
+  }
+
+  public Color getAxisTickMarksColor() {
+
+    return axisTickMarksColor;
+  }
+
+  public void setAxisTickMarksColor(Color axisTickMarksColor) {
+
+    this.axisTickMarksColor = axisTickMarksColor;
+  }
+
+  public Stroke getAxisTickMarksStroke() {
+
+    return axisTickMarksStroke;
+  }
+
+  public void setAxisTickMarksStroke(Stroke axisTickMarksStroke) {
+
+    this.axisTickMarksStroke = axisTickMarksStroke;
+  }
+
+  public boolean isAxisTitleVisible() {
+
+    return axisTitleVisible;
+  }
+
+  public void setAxisTitleVisible(boolean axisTitleVisible) {
+
+    this.axisTitleVisible = axisTitleVisible;
+  }
+
+  public Font getAxisTitleFont() {
+
+    return axisTitleFont;
+  }
+
+  public void setAxisTitleFont(Font axisTitleFont) {
+
+    this.axisTitleFont = axisTitleFont;
+  }
+
+  public int getAxisTitlePadding() {
+
+    return axisTitlePadding;
+  }
+
+  public void setAxisTitlePadding(int axisTitlePadding) {
+
+    this.axisTitlePadding = axisTitlePadding;
+  }
+
+  public double[] getAxisTickValues() {
+
+    return axisTickValues;
+  }
+
+  public void setAxisTickValues(double[] axisTickValues) {
+
+    this.axisTickValues = axisTickValues;
+  }
+
+  public String[] getAxisTickLabels() {
+
+    return axisTickLabels;
+  }
+
+  public void setAxisTickLabels(String[] axisTickLabels) {
+
+    this.axisTickLabels = axisTickLabels;
+  }
+
+  public double getNormalFrom() {
+
+    return normalFrom;
+  }
+
+  public void setNormalFrom(double normalFrom) {
+
+    this.normalFrom = normalFrom;
+  }
+
+  public double getNormalTo() {
+
+    return normalTo;
+  }
+
+  public void setNormalTo(double normalTo) {
+
+    this.normalTo = normalTo;
+  }
+
+  public Color getNormalColor() {
+
+    return normalColor;
+  }
+
+  public void setNormalColor(Color normalColor) {
+
+    this.normalColor = normalColor;
+  }
+
+  public double getGreenFrom() {
+
+    return greenFrom;
+  }
+
+  public void setGreenFrom(double greenFrom) {
+
+    this.greenFrom = greenFrom;
+  }
+
+  public double getGreenTo() {
+
+    return greenTo;
+  }
+
+  public void setGreenTo(double greenTo) {
+
+    this.greenTo = greenTo;
+  }
+
+  public Color getGreenColor() {
+
+    return greenColor;
+  }
+
+  public void setGreenColor(Color greenColor) {
+
+    this.greenColor = greenColor;
+  }
+
+  public double getRedFrom() {
+
+    return redFrom;
+  }
+
+  public void setRedFrom(double redFrom) {
+
+    this.redFrom = redFrom;
+  }
+
+  public double getRedTo() {
+
+    return redTo;
+  }
+
+  public void setRedTo(double redTo) {
+
+    this.redTo = redTo;
+  }
+
+  public Color getRedColor() {
+
+    return redColor;
+  }
+
+  public void setRedColor(Color redColor) {
+
+    this.redColor = redColor;
+  }
+
+  public double getArcAngle() {
+
+    return arcAngle;
+  }
+
+  public void setArcAngle(double arcAngle) {
+
+    this.arcAngle = arcAngle;
+  }
+
+  public boolean isAxisTickLabelsVisible() {
+
+    return axisTickLabelsVisible;
+  }
+
+  public void setAxisTickLabelsVisible(boolean axisTickLabelsVisible) {
+
+    this.axisTickLabelsVisible = axisTickLabelsVisible;
+  }
+
+  public double getDonutThickness() {
+
+    return donutThickness;
+  }
+
+  public void setDonutThickness(double donutThickness) {
+
+    this.donutThickness = donutThickness;
+  }
+
+  public double getArrowLengthPercentage() {
+
+    return arrowLengthPercentage;
+  }
+
+  public void setArrowLengthPercentage(double arrowLengthPercentage) {
+
+    this.arrowLengthPercentage = arrowLengthPercentage;
+  }
+
+  public double getArrowArcAngle() {
+
+    return arrowArcAngle;
+  }
+
+  public void setArrowArcAngle(double arrowArcAngle) {
+
+    this.arrowArcAngle = arrowArcAngle;
+  }
+
+  public double getArrowArcPercentage() {
+
+    return arrowArcPercentage;
+  }
+
+  public void setArrowArcPercentage(double arrowArcPercentage) {
+
+    this.arrowArcPercentage = arrowArcPercentage;
+  }
+}