• Home
• eu.hansolo
• SteelSeries
• 3.5.3
• source code
• Radial.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

eu.hansolo.steelseries.gauges.Radial Maven / Gradle / Ivy

package eu.hansolo.steelseries.gauges;


/**
 *
 * @author Gerrit Grunwald 
 */
public class Radial extends AbstractRadial
{            
    private double tickmarkOffset;
    private double rotationOffset; // Offset for the pointer
    private int tickLabelPeriod; // Draw value at every nth tickmark      
    private java.awt.image.BufferedImage frameImage;
    private java.awt.image.BufferedImage backgroundImage;
    private java.awt.image.BufferedImage postsImage;
    private java.awt.image.BufferedImage trackImage;
    private java.awt.image.BufferedImage tickmarksImage;
    private java.awt.image.BufferedImage titleImage;
    private java.awt.image.BufferedImage lcdImage;
    private java.awt.image.BufferedImage pointerImage;
    private java.awt.image.BufferedImage pointerShadowImage;
    private java.awt.image.BufferedImage foregroundImage;
    private java.awt.image.BufferedImage thresholdImage;
    private java.awt.image.BufferedImage minMeasuredImage;
    private java.awt.image.BufferedImage maxMeasuredImage;
    private java.awt.image.BufferedImage disabledImage;          
    private double angle;
    private final java.awt.geom.Point2D LCD_POSITION;

        
    public Radial()
    {
        super(); 
        LCD_POSITION = new java.awt.geom.Point2D.Double();
        setLcdVisible(true);
        switch(getGaugeType())
        {
            case TYPE1:
                setFreeAreaAngle(0);        
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI;
                tickLabelPeriod = 20;
                break;
                
            case TYPE2:
                setFreeAreaAngle(0);
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI;
                tickLabelPeriod = 10; 
                break;
                
            case TYPE3:
                setFreeAreaAngle(0);
                rotationOffset = Math.PI;
                tickmarkOffset = 0;        
                tickLabelPeriod = 10; 
                break;
                
            case TYPE4:
                setFreeAreaAngle(Math.toRadians(60));
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                tickLabelPeriod = 10;
                break;
                
            default:
                setFreeAreaAngle(Math.toRadians(60));
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                tickLabelPeriod = 10;
                break;
        }         
                        
        angle = 0;
        calcAngleStep();  
        createInitialImages();
    }

    @Override
    public final AbstractGauge init(final int WIDTH, final int HEIGHT)
    {
        switch(getGaugeType())
        {
            case TYPE1:
                setFreeAreaAngle(0);        
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI;
                tickLabelPeriod = 20;
                break;
                
            case TYPE2:
                setFreeAreaAngle(0);
                rotationOffset = (1.5 * Math.PI);
                tickmarkOffset = 0.5 * Math.PI;
                tickLabelPeriod = 10; 
                break;
                
            case TYPE3:
                setFreeAreaAngle(0);
                rotationOffset = Math.PI;
                tickmarkOffset = 0;        
                tickLabelPeriod = 10; 
                break;
                
            case TYPE4:
                setFreeAreaAngle(Math.toRadians(60));
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                tickLabelPeriod = 10;
                break;
                
            default:
                setFreeAreaAngle(Math.toRadians(60));
                rotationOffset = Math.PI + (getFreeAreaAngle() / 2.0);
                tickmarkOffset = 0;
                tickLabelPeriod = 10;
                break;
        } 
        calcAngleStep();
        
        if (isDigitalFont())
        {
            setLcdValueFont(LCD_DIGITAL_FONT.deriveFont(0.7f * WIDTH * 0.15f));            
        }
        else
        {
            setLcdValueFont(LCD_STANDARD_FONT.deriveFont(0.625f * WIDTH * 0.15f));       
        }

        if (getUseCustomLcdUnitFont())
        {
            setLcdUnitFont(getCustomLcdUnitFont().deriveFont(0.25f * WIDTH * 0.15f));
        }
        else
        {
            setLcdUnitFont(LCD_STANDARD_FONT.deriveFont(0.25f * WIDTH * 0.15f));
        }
        
        for(eu.hansolo.steelseries.tools.ImageType imageType : IMAGES_TO_UPDATE)
        {
            switch(imageType)
            {
                case FRAME:
                    if (frameImage != null)
                    {
                        frameImage.flush();
                    }
                    frameImage = create_FRAME_Image(WIDTH);                                        
                    break;
                case BACKGROUND:
                    if (backgroundImage != null)
                    {
                        backgroundImage.flush();                        
                    }
                    backgroundImage = create_BACKGROUND_Image(WIDTH);
                    break;
                case POSTS:
                    if (postsImage != null)
                    {
                        postsImage.flush();
                    }
                    switch(getGaugeType())
                    {
                        case TYPE1:
                            postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.CENTER, eu.hansolo.steelseries.tools.PostPosition.MAX_CENTER_TOP, eu.hansolo.steelseries.tools.PostPosition.MIN_LEFT);                    
                            break;
                            
                        case TYPE2:
                            postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.CENTER, eu.hansolo.steelseries.tools.PostPosition.MIN_LEFT, eu.hansolo.steelseries.tools.PostPosition.MAX_RIGHT);
                            break;
                            
                        case TYPE3:
                            postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.CENTER, eu.hansolo.steelseries.tools.PostPosition.MAX_CENTER_BOTTOM, eu.hansolo.steelseries.tools.PostPosition.MAX_RIGHT);
                            break;
                            
                        case TYPE4:
                            postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.CENTER, eu.hansolo.steelseries.tools.PostPosition.MIN_BOTTOM, eu.hansolo.steelseries.tools.PostPosition.MAX_BOTTOM);
                            break;
                            
                        default:
                            postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.CENTER, eu.hansolo.steelseries.tools.PostPosition.MIN_BOTTOM, eu.hansolo.steelseries.tools.PostPosition.MAX_BOTTOM);
                            break;
                    }                            
                    break;
                case TRACK:
                    if (trackImage != null)
                    {
                        trackImage.flush();
                    }
                    trackImage = create_TRACK_Image(WIDTH, getMinValue(), getMaxValue(), getAngleStep(), getTrackStart(), getTrackSection(), getTrackStop(), getTrackStartColor(), getTrackSectionColor(), getTrackStopColor(), rotationOffset);
                    break;
                case TICKMARKS:
                    if (tickmarksImage != null)
                    {
                        tickmarksImage.flush();
                    }
                    tickmarksImage = create_TICKMARKS_Image(WIDTH, getFreeAreaAngle(), tickmarkOffset, getMinValue(), getMaxValue(), getAngleStep(), tickLabelPeriod, getScaleDividerPower(), isDrawTicks(), isDrawTickLabels(), getTickmarkSections());                   
                    break;
                case TITLE:
                    if (titleImage != null)
                    {
                        titleImage.flush();
                    }
                    titleImage = create_TITLE_Image(WIDTH, getTitle(), getUnitString());
                    break;
                case LCD:
                    if (lcdImage != null)
                    {
                        lcdImage.flush();
                    }
                    switch(getGaugeType())
                    {
                        case TYPE1:
                            lcdImage = create_LCD_Image((int) (WIDTH * 0.55), (int) (WIDTH * 0.15), getLcdColor());
                            break;
                            
                        case TYPE2:
                            lcdImage = create_LCD_Image((int) (WIDTH * 0.55), (int) (WIDTH * 0.15), getLcdColor());
                            break;
                            
                        case TYPE3:
                            lcdImage = create_LCD_Image((int) (WIDTH * 0.4), (int) (WIDTH * 0.15), getLcdColor());
                            break;
                            
                        case TYPE4:
                            lcdImage = create_LCD_Image((int) (WIDTH * 0.4), (int) (WIDTH * 0.15), getLcdColor());
                            break;
                            
                        default:
                            lcdImage = create_LCD_Image((int) (WIDTH * 0.4), (int) (WIDTH * 0.15), getLcdColor());
                            break;
                    }            
                    LCD_POSITION.setLocation(((getGaugeBounds().width - lcdImage.getWidth()) / 2.0), (getGaugeBounds().height * 0.55));
                    break;    
                case POINTER:
                    if (pointerImage != null)
                    {
                        pointerImage.flush();
                    }
                    pointerImage = create_POINTER_Image(WIDTH, getPointerType());
                    break;
                case POINTER_SHADOW:
                    if (pointerShadowImage != null)
                    {
                        pointerShadowImage.flush();
                    }
                    pointerShadowImage = create_POINTER_SHADOW_Image(WIDTH, getPointerType());
                    break;
                case FOREGROUND:
                    if (foregroundImage != null)
                    {
                        foregroundImage.flush();
                    }
                    foregroundImage = create_FOREGROUND_Image(WIDTH, false);
                    break;
                case THRESHOLD:
                    if (thresholdImage != null)
                    {
                        thresholdImage.flush();
                    }
                    thresholdImage = create_THRESHOLD_Image(WIDTH);
                    break;
                case MIN_MEASURED:
                    if (minMeasuredImage != null)
                    {
                        minMeasuredImage.flush();
                    }
                    minMeasuredImage = create_MEASURED_VALUE_Image(WIDTH, new java.awt.Color(0, 23, 252, 255));
                    break;
                case MAX_MEASURED:
                    if (maxMeasuredImage != null)
                    {
                        maxMeasuredImage.flush();
                    }
                    maxMeasuredImage = create_MEASURED_VALUE_Image(WIDTH, new java.awt.Color(252, 29, 0, 255));
                    break;
                case DISABLED:
                    if (disabledImage != null)
                    {
                        disabledImage.flush();
                    }
                    disabledImage = create_DISABLED_Image(WIDTH);
                    break;
            }
        }
        // Create areas if not empty
        if (!AREAS.isEmpty())
        {
            createAreas();
        }
        // Create sections if not empty
        if (!SECTIONS.isEmpty())
        {
            createSections();
        }
        setCurrentLedImage(getLedImageOff());

        IMAGES_TO_UPDATE.clear();

        return this;
    }

    @Override
    protected void paintComponent(java.awt.Graphics g)
    {
        if (!isInitialized())
        {
            return;
        }
        
        final java.awt.Graphics2D G2 = (java.awt.Graphics2D) g.create();        
        final java.awt.geom.Point2D CENTER = new java.awt.geom.Point2D.Double(getGaugeBounds().getCenterX(), getGaugeBounds().getCenterX());

        G2.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
        G2.setRenderingHint(java.awt.RenderingHints.KEY_RENDERING, java.awt.RenderingHints.VALUE_RENDER_QUALITY);
        //G2.setRenderingHint(java.awt.RenderingHints.KEY_DITHERING, java.awt.RenderingHints.VALUE_DITHER_ENABLE);
        //G2.setRenderingHint(java.awt.RenderingHints.KEY_ALPHA_INTERPOLATION, java.awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
        //G2.setRenderingHint(java.awt.RenderingHints.KEY_COLOR_RENDERING, java.awt.RenderingHints.VALUE_COLOR_RENDER_QUALITY);
        G2.setRenderingHint(java.awt.RenderingHints.KEY_STROKE_CONTROL, java.awt.RenderingHints.VALUE_STROKE_PURE);
        //G2.setRenderingHint(java.awt.RenderingHints.KEY_FRACTIONALMETRICS, java.awt.RenderingHints.VALUE_FRACTIONALMETRICS_ON);
        G2.setRenderingHint(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        G2.translate(getInnerBounds().x, getInnerBounds().y);        
        final java.awt.geom.AffineTransform OLD_TRANSFORM = G2.getTransform();

        // Draw the frame
        if (isFrameVisible())
        {
            G2.drawImage(frameImage, 0, 0, null);
        }

        // Draw the background        
        if (isBackgroundVisible())
        {
            G2.drawImage(backgroundImage, 0, 0, null);
        }
                
        // Draw the areas
        if (isAreasVisible())
        {
            for (eu.hansolo.steelseries.tools.Section area : AREAS)
            {
                G2.setColor(area.getColor());
                G2.fill(area.getFilledArea());
            }
        }
        
        // Draw the sections
        if (isSectionsVisible())
        {
            for (eu.hansolo.steelseries.tools.Section section : SECTIONS)
            {
                G2.setColor(section.getColor());
                G2.fill(section.getSectionArea());
            }
        }

        // Draw the track
        if (isTrackVisible())
        {
            G2.drawImage(trackImage, 0, 0, null);
        }
        
        // Draw the tickmarks
        G2.drawImage(tickmarksImage, 0, 0, null);

        // Draw threshold indicator
        if (isThresholdVisible())
        {
            G2.rotate(rotationOffset + (getThreshold() - getMinValue()) * getAngleStep(), CENTER.getX(), CENTER.getY());            
            G2.drawImage(thresholdImage, (int) (getGaugeBounds().width * 0.480369999), (int) (getGaugeBounds().height * 0.13), null);
            G2.setTransform(OLD_TRANSFORM);
        }

        // Draw min measured value indicator
        if (isMinMeasuredValueVisible())
        {
            G2.rotate(rotationOffset + (getMinMeasuredValue() - getMinValue()) * getAngleStep(), CENTER.getX(), CENTER.getY());
            G2.drawImage(minMeasuredImage, (int) (getGaugeBounds().width * 0.4865), (int) (getGaugeBounds().height * 0.105), null);
            G2.setTransform(OLD_TRANSFORM);
        }

        // Draw max measured value indicator
        if (isMaxMeasuredValueVisible())
        {
            G2.rotate(rotationOffset + (getMaxMeasuredValue() - getMinValue()) * getAngleStep(), CENTER.getX(), CENTER.getY());
            G2.drawImage(maxMeasuredImage, (int) (getGaugeBounds().width * 0.4865), (int) (getGaugeBounds().height * 0.105), null);
            G2.setTransform(OLD_TRANSFORM);
        }

        // Draw title and unit
        G2.drawImage(titleImage, 0, 0, null);

        // Draw LED if enabled
        if (isLedVisible())
        {
            G2.drawImage(getCurrentLedImage(), (int) (getGaugeBounds().width * getLedPositionX()), (int) (getGaugeBounds().height * getLedPositionY()), null);
        }

        // Draw LCD display
        if (isLcdVisible())
        {
            //G2.drawImage(lcdImage, (int) ((getGaugeBounds().width - lcdImage.getWidth()) / 2.0), (int) (getGaugeBounds().height * 0.55), null);
            G2.drawImage(lcdImage, (int) (LCD_POSITION.getX()), (int) (LCD_POSITION.getY()), null);
            
            G2.setColor(getLcdColor().TEXT_COLOR);
            G2.setFont(getLcdUnitFont());
            final java.awt.font.FontRenderContext RENDER_CONTEXT = new java.awt.font.FontRenderContext(null, true, true);
            final double UNIT_STRING_WIDTH;
            if (isLcdUnitStringVisible())
            {
                final java.awt.font.TextLayout UNIT_LAYOUT = new java.awt.font.TextLayout(getLcdUnitString(), G2.getFont(), RENDER_CONTEXT);
                final java.awt.geom.Rectangle2D UNIT_BOUNDARY = UNIT_LAYOUT.getBounds();
                G2.drawString(getLcdUnitString(), (int) (LCD_POSITION.getX() + (lcdImage.getWidth() - UNIT_BOUNDARY.getWidth()) - lcdImage.getWidth() * 0.03), (int) (LCD_POSITION.getY() + lcdImage.getHeight() * 0.76f));
                UNIT_STRING_WIDTH = UNIT_BOUNDARY.getWidth();
            }
            else
            {
                UNIT_STRING_WIDTH = 0;
            }
            G2.setFont(getLcdValueFont());
            final java.awt.font.TextLayout VALUE_LAYOUT = new java.awt.font.TextLayout(formatLcdValue(getValue()), G2.getFont(), RENDER_CONTEXT);
            final java.awt.geom.Rectangle2D VALUE_BOUNDARY = VALUE_LAYOUT.getBounds();        
            G2.drawString(formatLcdValue(getLcdValue()), (int) (LCD_POSITION.getX() + (lcdImage.getWidth() - UNIT_STRING_WIDTH - VALUE_BOUNDARY.getWidth()) - lcdImage.getWidth() * 0.09), (int) (LCD_POSITION.getY() + lcdImage.getHeight() * 0.76f));
        }
        
        // Draw the pointer
        angle = rotationOffset + (getValue() - getMinValue()) * getAngleStep();
        G2.rotate(angle + (Math.cos(Math.toRadians(angle - rotationOffset - 91.5))), CENTER.getX(), CENTER.getY());
        G2.drawImage(pointerShadowImage, 0, 0, null);
        G2.setTransform(OLD_TRANSFORM);
        G2.rotate(angle, CENTER.getX(), CENTER.getY());
        G2.drawImage(pointerImage, 0, 0, null);
        G2.setTransform(OLD_TRANSFORM);

        // Draw posts
        G2.drawImage(postsImage, 0, 0, null);
        
        // Draw the foreground        
        if (isForegroundVisible())
        {
            G2.drawImage(foregroundImage, 0, 0, null);
        }
        
        // Draw disabled image if component isEnabled() == false
        if (!isEnabled())
        {
            G2.drawImage(disabledImage, 0, 0, null);
        }

        G2.translate(-getInnerBounds().x, -getInnerBounds().y);

        G2.dispose();
    }

    @Override
    public void setValue(double value)
    {
        super.setValue(value);
                
        if (isValueCoupled())
        {
            setLcdValue(value);            
        }
        repaint(getInnerBounds());                        
    }
    
    public int getTickLabelPeriod()
    {
        return this.tickLabelPeriod;
    }

    public void setTickLabelPeriod(final int TICK_LABEL_PERIOD)
    {
        this.tickLabelPeriod = TICK_LABEL_PERIOD;        
        IMAGES_TO_UPDATE.add(eu.hansolo.steelseries.tools.ImageType.TICKMARKS);
        repaint(getInnerBounds());
    }
               
    @Override
    public java.awt.geom.Point2D getCenter()
    {
        return new java.awt.geom.Point2D.Double(backgroundImage.getWidth() / 2.0 + getInnerBounds().x, backgroundImage.getHeight() / 2.0 + getInnerBounds().y);
    }

    @Override
    public java.awt.geom.Rectangle2D getBounds2D()
    {
        return new java.awt.geom.Rectangle2D.Double(backgroundImage.getMinX(), backgroundImage.getMinY(), backgroundImage.getWidth(), backgroundImage.getHeight());
    }
        
    //     
    private void createAreas()
    {
        final double ORIGIN_CORRECTION;
        final double ANGLE_STEP;

        switch(getGaugeType())
        {
            case TYPE1:
                ORIGIN_CORRECTION = 180;
                ANGLE_STEP = 90 / (getMaxValue() - getMinValue());
                break;
                
            case TYPE2:
                ORIGIN_CORRECTION = 180;
                ANGLE_STEP = 180 / (getMaxValue() - getMinValue());
                break;
                
            case TYPE3:
                ORIGIN_CORRECTION = 270;
                ANGLE_STEP = 270 / (getMaxValue() - getMinValue());
                break;
                
            case TYPE4:
                ORIGIN_CORRECTION = 240;
                ANGLE_STEP = 300 / (getMaxValue() - getMinValue());
                break;
                
            default:
                ORIGIN_CORRECTION = 240;
                ANGLE_STEP = 300 / (getMaxValue() - getMinValue());
                break;
        }
        
        if (backgroundImage != null && !AREAS.isEmpty())
        {            
            final double RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
            final double FREE_AREA = backgroundImage.getWidth() / 2.0 - RADIUS;
            final java.awt.geom.Rectangle2D AREA_FRAME = new java.awt.geom.Rectangle2D.Double(backgroundImage.getMinX() + FREE_AREA, backgroundImage.getMinY() + FREE_AREA, 2 * RADIUS, 2 * RADIUS);           
            for (eu.hansolo.steelseries.tools.Section tmpArea : AREAS)
            {                
                tmpArea.setFilledArea(new java.awt.geom.Arc2D.Double(AREA_FRAME, ORIGIN_CORRECTION - (tmpArea.getStart() * ANGLE_STEP), -(tmpArea.getStop() - tmpArea.getStart()) * ANGLE_STEP, java.awt.geom.Arc2D.PIE));                
            }           
        }        
    }
    //
    
    private void createSections()
    {                                            
        final double ORIGIN_CORRECTION;
        final double ANGLE_STEP;
        final double OUTER_RADIUS;
        final double INNER_RADIUS;
        final double FREE_AREA_OUTER_RADIUS;
        final double FREE_AREA_INNER_RADIUS;
        final java.awt.geom.Ellipse2D INNER;

        switch (getGaugeType())
        {
            case TYPE1:
                ORIGIN_CORRECTION = 180.0;
                ANGLE_STEP = 90.0 / (getMaxValue() - getMinValue());
                OUTER_RADIUS = backgroundImage.getWidth() * 0.38f;
                INNER_RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
                FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
                FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
                INNER = new java.awt.geom.Ellipse2D.Double(backgroundImage.getMinX() + FREE_AREA_INNER_RADIUS, backgroundImage.getMinY() + FREE_AREA_INNER_RADIUS, 2 * INNER_RADIUS, 2 * INNER_RADIUS);
                break;

            case TYPE2:
                ORIGIN_CORRECTION = 180.0;
                ANGLE_STEP = 180.0 / (getMaxValue() - getMinValue());
                OUTER_RADIUS = backgroundImage.getWidth() * 0.38f;
                INNER_RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
                FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
                FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
                INNER = new java.awt.geom.Ellipse2D.Double(backgroundImage.getMinX() + FREE_AREA_INNER_RADIUS, backgroundImage.getMinY() + FREE_AREA_INNER_RADIUS, 2 * INNER_RADIUS, 2 * INNER_RADIUS);
                break;

            case TYPE3:                
                ORIGIN_CORRECTION = 270.0;
                ANGLE_STEP = 270.0 / (getMaxValue() - getMinValue());          
                OUTER_RADIUS = backgroundImage.getWidth() * 0.38f;
                INNER_RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
                FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
                FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
                INNER = new java.awt.geom.Ellipse2D.Double(backgroundImage.getMinX() + FREE_AREA_INNER_RADIUS, backgroundImage.getMinY() + FREE_AREA_INNER_RADIUS, 2 * INNER_RADIUS, 2 * INNER_RADIUS);
                break;

            case TYPE4:
                ORIGIN_CORRECTION = 240.0;
                ANGLE_STEP = 300.0 / (getMaxValue() - getMinValue());
                OUTER_RADIUS = backgroundImage.getWidth() * 0.38f;
                INNER_RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
                FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
                FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
                INNER = new java.awt.geom.Ellipse2D.Double(backgroundImage.getMinX() + FREE_AREA_INNER_RADIUS, backgroundImage.getMinY() + FREE_AREA_INNER_RADIUS, 2 * INNER_RADIUS, 2 * INNER_RADIUS);
                break;

            default:
                ORIGIN_CORRECTION = 240.0;
                ANGLE_STEP = 300.0 / (getMaxValue() - getMinValue());
                OUTER_RADIUS = backgroundImage.getWidth() * 0.38f;
                INNER_RADIUS = backgroundImage.getWidth() * 0.38f - backgroundImage.getWidth() * 0.04f;
                FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
                FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
                INNER = new java.awt.geom.Ellipse2D.Double(backgroundImage.getMinX() + FREE_AREA_INNER_RADIUS, backgroundImage.getMinY() + FREE_AREA_INNER_RADIUS, 2 * INNER_RADIUS, 2 * INNER_RADIUS);
                break;
        }

        for (eu.hansolo.steelseries.tools.Section section : SECTIONS)
        {                            
            final double ANGLE_START = ORIGIN_CORRECTION - (section.getStart() * ANGLE_STEP);
            final double ANGLE_EXTEND = -(section.getStop() - section.getStart()) * ANGLE_STEP;                

            final java.awt.geom.Arc2D OUTER_ARC = new java.awt.geom.Arc2D.Double(java.awt.geom.Arc2D.PIE);
            OUTER_ARC.setFrame(backgroundImage.getMinX() + FREE_AREA_OUTER_RADIUS, backgroundImage.getMinY() + FREE_AREA_OUTER_RADIUS, 2 * OUTER_RADIUS, 2 * OUTER_RADIUS);
            OUTER_ARC.setAngleStart(ANGLE_START);
            OUTER_ARC.setAngleExtent(ANGLE_EXTEND);
            final java.awt.geom.Area SECTION = new java.awt.geom.Area(OUTER_ARC);
            
            SECTION.subtract(new java.awt.geom.Area(INNER));

            section.setSectionArea(SECTION);
        }       
    }
        
    @Override
    public String toString()
    {
        return "Radial " + getGaugeType();
    }  
}