--- a/artifacts/src/main/java/org/dive4elements/river/jfree/StyledAreaSeriesCollection.java	Tue Jun 26 20:18:18 2018 +0200
+++ b/artifacts/src/main/java/org/dive4elements/river/jfree/StyledAreaSeriesCollection.java	Tue Jun 26 20:19:16 2018 +0200
@@ -17,10 +17,9 @@
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 
+import org.dive4elements.river.themes.ThemeDocument;
 import org.jfree.data.xy.XYSeriesCollection;
 
-import org.dive4elements.river.themes.ThemeDocument;
-
 /**
  * One or more dataseries to draw a polygon (either "open up/downwards", or
  * the area between two curves), a theme-document and further display options.
@@ -39,15 +38,15 @@
     private FILL_MODE mode;
 
     /** Theme-document with attributes about actual visual representation. */
-    private ThemeDocument theme;
+    private final ThemeDocument theme;
 
     /**
      * @param theme the theme-document.
      */
-    public StyledAreaSeriesCollection(ThemeDocument theme) {
+    public StyledAreaSeriesCollection(final ThemeDocument theme) {
         this.theme = theme;
         this.mode = FILL_MODE.BETWEEN;
-   }
+    }
 
 
     /** Gets the Fill mode. */
@@ -57,7 +56,7 @@
 
 
     /** Sets the Fill mode. */
-    public void setMode(FILL_MODE fMode) {
+    public void setMode(final FILL_MODE fMode) {
         this.mode = fMode;
     }
 
@@ -69,44 +68,38 @@
      * @return \param renderer
      */
     public StableXYDifferenceRenderer applyTheme(
-        StableXYDifferenceRenderer renderer
-    ) {
+            final StableXYDifferenceRenderer renderer
+            ) {
         applyFillColor(renderer);
-        applyShowShape(renderer);
+        applyShowBorder(renderer);
+        applyShowArea(renderer);
         applyOutlineColor(renderer);
         applyOutlineStyle(renderer);
         applyShowLine(renderer);
         applyShowAreaLabel(renderer);
         applyPointStyle(renderer);
-        if (mode == FILL_MODE.UNDER) {
+        if (this.mode == FILL_MODE.UNDER) {
             renderer.setAreaCalculationMode(
-                StableXYDifferenceRenderer.CALCULATE_NEGATIVE_AREA);
+                    StableXYDifferenceRenderer.CALCULATE_NEGATIVE_AREA);
         }
-        else if (mode == FILL_MODE.ABOVE) {
+        else if (this.mode == FILL_MODE.ABOVE) {
             renderer.setAreaCalculationMode(
-                StableXYDifferenceRenderer.CALCULATE_POSITIVE_AREA);
+                    StableXYDifferenceRenderer.CALCULATE_POSITIVE_AREA);
         }
         else {
             renderer.setAreaCalculationMode(
-                StableXYDifferenceRenderer.CALCULATE_ALL_AREA);
+                    StableXYDifferenceRenderer.CALCULATE_ALL_AREA);
         }
 
         // Apply text style.
-        theme.parseComplexTextStyle().apply(renderer);
+        this.theme.parseComplexTextStyle().apply(renderer);
         return renderer;
     }
 
     private void applyFillColor(final StableXYDifferenceRenderer renderer) {
-        
-        final boolean showArea = theme.parseShowArea();
-        if( !showArea ) {
-            renderer.setPositivePaint(null);
-            renderer.setNegativePaint(null);
-            return;
-        }
 
         Paint paint = parseFillPaint();
-        
+
         if (paint != null && this.getMode() == FILL_MODE.ABOVE) {
             renderer.setPositivePaint(paint);
             renderer.setNegativePaint(new Color(0,0,0,0));
@@ -118,7 +111,7 @@
         else {
             if (paint == null)
                 paint = new Color(177, 117, 102);
-                
+
             renderer.setPositivePaint(paint);
             renderer.setNegativePaint(paint);
         }
@@ -126,17 +119,17 @@
 
     private Paint parseFillPaint() {
         final Color paint = this.theme.parseAreaBackgroundColor();
-        final int transparency = theme.parseAreaTransparency();
-        
+        final int transparency = this.theme.parseAreaTransparency();
+
         final Color alphaPaint = withAlpha(paint, transparency);
-        
+
         final AreaFillPattern pattern = this.theme.parseAreaBackgroundPattern();
 
         if( pattern == null || pattern == AreaFillPattern.patternFill )
             return alphaPaint;
-        
+
         final BufferedImage image = pattern.getImage(alphaPaint);
-        
+
         final Rectangle2D anchor = new Rectangle2D.Double(0,0, image.getWidth(), image.getHeight());
         return new TexturePaint(image, anchor);
     }
@@ -145,7 +138,7 @@
 
         if (transparency <= 0 || color == null)
             return color;
-        
+
         return new Color(
                 color.getRed(),
                 color.getGreen(),
@@ -153,32 +146,37 @@
                 (int)((100 - transparency) * 2.55f));
     }
 
-    private void applyShowShape(StableXYDifferenceRenderer renderer) {
-        boolean show = theme.parseAreaShowBorder();
+    private void applyShowBorder(final StableXYDifferenceRenderer renderer) {
+        final boolean show = this.theme.parseAreaShowBorder();
         renderer.setDrawOutline(show);
     }
 
+    private void applyShowArea(final StableXYDifferenceRenderer renderer) {
 
-    private void applyShowLine(StableXYDifferenceRenderer renderer) {
+        final boolean showArea = this.theme.parseShowArea();
+        renderer.setDrawArea(showArea);
+    }
+
+    private void applyShowLine(final StableXYDifferenceRenderer renderer) {
         /* FIXME: strange: this will enable/disable showing the 'point' shapes at each vertex. */
         /* FIXME: this will also now be overridden by the option 'showpoints' */
-        final boolean show = theme.parseShowLine();
+        final boolean show = this.theme.parseShowLine();
         renderer.setShapesVisible(show);
     }
 
-    private void applyOutlineColor(StableXYDifferenceRenderer renderer) {
-        Color c = theme.parseLineColorField();
+    private void applyOutlineColor(final StableXYDifferenceRenderer renderer) {
+        final Color c = this.theme.parseLineColorField();
         renderer.setOutlinePaint(c);
     }
 
     /** Inform renderer whether it should draw a label. */
-    private void applyShowAreaLabel(StableXYDifferenceRenderer renderer) {
-        renderer.setLabelArea(theme.parseShowAreaLabel());
+    private void applyShowAreaLabel(final StableXYDifferenceRenderer renderer) {
+        renderer.setLabelArea(this.theme.parseShowAreaLabel());
     }
 
-    private void applyOutlineStyle(StableXYDifferenceRenderer renderer) {
-        float[] dashes = theme.parseLineStyle();
-        int size       = theme.parseLineWidth();
+    private void applyOutlineStyle(final StableXYDifferenceRenderer renderer) {
+        final float[] dashes = this.theme.parseLineStyle();
+        final int size       = this.theme.parseLineWidth();
 
         Stroke stroke = null;
 
@@ -187,11 +185,11 @@
         }
         else {
             stroke = new BasicStroke(Integer.valueOf(size),
-                BasicStroke.CAP_BUTT,
-                BasicStroke.JOIN_ROUND,
-                1.0f,
-                dashes,
-                0.0f);
+                    BasicStroke.CAP_BUTT,
+                    BasicStroke.JOIN_ROUND,
+                    1.0f,
+                    dashes,
+                    0.0f);
         }
 
         renderer.setOutlineStroke(stroke);
@@ -203,12 +201,12 @@
         renderer.setShapesVisible(showPoints);
 
         if( showPoints )
-        {        
-            final int size = theme.parsePointWidth();
+        {
+            final int size = this.theme.parsePointWidth();
             final int dim  = 2 * size;
 
             final Ellipse2D pointShape = new Ellipse2D.Double(-size, -size, dim, dim);
-            final Color pointColor = theme.parsePointColor();
+            final Color pointColor = this.theme.parsePointColor();
 
             renderer.setSeriesPaint(0, pointColor);
             renderer.setSeriesPaint(1, pointColor);
@@ -219,7 +217,7 @@
     }
 
     public boolean shouldCalculateRange() {
-        return theme.parseCalculateRange();
+        return this.theme.parseCalculateRange();
     }
 }
 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :