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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of SteelSeries
The SteelSeries is a javabeans component library that contains gauges. You will find linear and radial gauges. In addition you will also find digital displays.
There is a newer version: 3.9.6
Show newest version
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package eu.hansolo.steelseries.gauges;

/**
 *
 * @author hansolo
 */
public final class RadialSquareSmall extends AbstractRadial
{
    private final java.awt.Rectangle INNER_BOUNDS;
    private final double FREE_AREA_ANGLE; // area where no tickmarks will be painted
    private double angleStep;
    private static final double TICKMARK_OFFSET = 0.75 * Math.PI;
    private final double ROTATION_OFFSET; // Offset for the pointer
    private int tickLabelPeriod; // Draw value at every nth tickmark
    private final java.awt.GraphicsConfiguration GFX_CONF;
    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 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;


    // ideal size  212 x 132
    
    public RadialSquareSmall()
    {
        super();
        INNER_BOUNDS = new java.awt.Rectangle(0, 0, WIDTH, HEIGHT);
        FREE_AREA_ANGLE = 0;
        ROTATION_OFFSET = (1.75 * Math.PI) + (FREE_AREA_ANGLE / 2.0);
        tickLabelPeriod = 20;
        GFX_CONF = java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();        
        angle = 0;        
        setLedPositionX(0.65);
        setLedPositionY(0.65);
        calcAngleStep();
        createInitialImages();
    }

    @Override
    public final AbstractGauge init(final int WIDTH, final int HEIGHT)
    {
        for(eu.hansolo.steelseries.tools.ImageType imageType : IMAGES_TO_UPDATE)
        {
            switch(imageType)
            {
                case FRAME:
                    if (frameImage != null)
                    {
                        frameImage.flush();
                    }
                    frameImage = FRAME_FACTORY.createLinearFrame(WIDTH, HEIGHT, getFrameDesign());
                    break;
                case BACKGROUND:
                    if (backgroundImage != null)
                    {
                        backgroundImage.flush();
                    }
                    backgroundImage = BACKGROUND_FACTORY.createLinearBackground(WIDTH, HEIGHT, getBackgroundColor(), isCustomBackgroundVisible(), getCustomBackground());
                    break;
                case POSTS:
                    if (postsImage != null)
                    {
                        postsImage.flush();
                    }
                    postsImage = create_POSTS_Image(WIDTH, eu.hansolo.steelseries.tools.PostPosition.SMALL_GAUGE_MIN_LEFT, eu.hansolo.steelseries.tools.PostPosition.SMALL_GAUGE_MAX_RIGHT);
                    break;
                case TRACK:
                    if (trackImage != null)
                    {
                        trackImage.flush();
                    }
                    trackImage = create_TRACK_Image(WIDTH, getMinValue(), getMaxValue(), angleStep, getTrackStart(), getTrackSection(), getTrackStop(), getTrackStartColor(), getTrackSectionColor(), getTrackStopColor(), ROTATION_OFFSET);
                    break;
                case TICKMARKS:
                    if (tickmarksImage != null)
                    {
                        tickmarksImage.flush();
                    }
                    tickmarksImage = create_TICKMARKS_Image(WIDTH, FREE_AREA_ANGLE, TICKMARK_OFFSET, getMinValue(), getMaxValue(), angleStep, tickLabelPeriod, getScaleDividerPower(), isDrawTicks(), isDrawTickLabels(), getTickmarkSections(), 0.44f, -0.04f, new java.awt.geom.Point2D.Double(WIDTH / 2.0, WIDTH * 0.73));
                    break;
                case TITLE:
                    if (backgroundImage != null)
                    {
                        backgroundImage.flush();
                    }
                    backgroundImage = BACKGROUND_FACTORY.createLinearBackground(WIDTH, HEIGHT, getBackgroundColor(), isCustomBackgroundVisible(), getCustomBackground());
                    break;
                case POINTER:
                    if (pointerImage != null)
                    {
                        pointerImage.flush();
                    }
                    pointerImage = create_POINTER_Image(WIDTH, (int) (0.6226415094339622 * WIDTH), getPointerType());
                    break;
                case POINTER_SHADOW:
                    if (pointerShadowImage != null)
                    {
                        pointerShadowImage.flush();
                    }
                    pointerShadowImage = create_POINTER_SHADOW_Image(WIDTH, (int) (0.6226415094339622 * WIDTH), getPointerType());
                    break;
                case FOREGROUND:
                    if (foregroundImage != null)
                    {
                        foregroundImage.flush();
                    }
                    foregroundImage = FOREGROUND_FACTORY.createLinearForeground(WIDTH, HEIGHT);
                    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 = DISABLED_FACTORY.createLinearDisabled(WIDTH, HEIGHT);                    
                    break;
            }
        }
        create_AREA();
        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();

        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        // Translate the coordinate system related to insets
        G2.translate(INNER_BOUNDS.x, INNER_BOUNDS.y);

        final java.awt.geom.Point2D CENTER = new java.awt.geom.Point2D.Double(getGaugeBounds().width / 2.0, getGaugeBounds().height * 1.1287878788);
        final int IMAGE_SHIFT_Y = (int) -(getGaugeBounds().width * 0.0606060606);

        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 sections
        if (isSectionsVisible())
        {
            
            G2.translate(0, getGaugeBounds().getCenterY());
            
            for (eu.hansolo.steelseries.tools.Section section : SECTIONS)
            {
                G2.setColor(section.getColor());
                G2.fill(section.getSectionArea());
            }
            G2.setTransform(OLD_TRANSFORM);
        }

        // Draw title
        final java.awt.font.FontRenderContext RENDER_CONTEXT = new java.awt.font.FontRenderContext(null, true, true);
        if (!getTitle().isEmpty())
        {
            if (isUsingLabelColorFromTheme())
            {
                G2.setColor(getBackgroundColor().LABEL_COLOR);
            }
            else
            {
                G2.setColor(getLabelColor());
            }
            G2.setFont(new java.awt.Font("Verdana", 0, (int) (0.04672897196261682 * getGaugeBounds().width)));
            final java.awt.font.TextLayout TITLE_LAYOUT = new java.awt.font.TextLayout(getTitle(), G2.getFont(), RENDER_CONTEXT);
            final java.awt.geom.Rectangle2D TITLE_BOUNDARY = TITLE_LAYOUT.getBounds();
            G2.drawString(getTitle(), (float)((getGaugeBounds().width - TITLE_BOUNDARY.getWidth()) / 2.0), 0.6f * getGaugeBounds().height + TITLE_LAYOUT.getAscent() - TITLE_LAYOUT.getDescent());
        }

        // Draw unit string
        if (!getUnitString().isEmpty())
        {
            if (isUsingLabelColorFromTheme())
            {
                G2.setColor(getBackgroundColor().LABEL_COLOR);
            }
            else
            {
                G2.setColor(getLabelColor());
            }
            G2.setFont(new java.awt.Font("Verdana", 0, (int) (0.04672897196261682 * getGaugeBounds().width)));
            final java.awt.font.TextLayout UNIT_LAYOUT = new java.awt.font.TextLayout(getUnitString(), G2.getFont(), RENDER_CONTEXT);
            final java.awt.geom.Rectangle2D UNIT_BOUNDARY = UNIT_LAYOUT.getBounds();
            G2.drawString(getUnitString(), (float)((getGaugeBounds().width - UNIT_BOUNDARY.getWidth()) / 2.0), 0.68f * getGaugeBounds().height + UNIT_LAYOUT.getAscent() - UNIT_LAYOUT.getDescent());
        }

        final java.awt.geom.AffineTransform FORMER_TRANSFORM = G2.getTransform();
        
        // Draw the tickmarks
        G2.drawImage(tickmarksImage, 0, IMAGE_SHIFT_Y, null);

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

        // Draw threshold indicator
        if (isThresholdVisible())
        {
            G2.rotate(ROTATION_OFFSET + (getThreshold() - getMinValue()) * angleStep, CENTER.getX(), CENTER.getY());
            G2.drawImage(thresholdImage, 0, IMAGE_SHIFT_Y, null);
            G2.setTransform(FORMER_TRANSFORM);
        }

        // Draw min measured value indicator
        if (isMinMeasuredValueVisible())
        {
            G2.rotate(ROTATION_OFFSET + (getMinMeasuredValue() - getMinValue()) * angleStep, CENTER.getX(), CENTER.getY());
            G2.drawImage(minMeasuredImage, 0, IMAGE_SHIFT_Y, null);
            G2.setTransform(FORMER_TRANSFORM);
        }

        // Draw max measured value indicator
        if (isMaxMeasuredValueVisible())
        {
            G2.rotate(ROTATION_OFFSET + (getMaxMeasuredValue() - getMinValue()) * angleStep, CENTER.getX(), CENTER.getY());
            G2.drawImage(maxMeasuredImage, 0, IMAGE_SHIFT_Y, null);
            G2.setTransform(FORMER_TRANSFORM);
        }

        // Draw led
        if (isLedVisible())
        {
            G2.drawImage(getCurrentLedImage(), (int) (getGaugeBounds().width * getLedPositionX()), (int) (getGaugeBounds().height * getLedPositionY()), null);
        }
                        
        // Draw the pointer
        angle = ROTATION_OFFSET + (getValue() - getMinValue()) * angleStep;
        //G2.rotate(ANGLE + (Math.cos(Math.toRadians(ANGLE - ROTATION_OFFSET - 91.5))), CENTER.getX(), backgroundImage.getHeight() * 0.7336448598);
        G2.rotate(angle, CENTER.getX(), CENTER.getY() + 2);
        G2.drawImage(pointerShadowImage, 0, 0, null);
        G2.setTransform(FORMER_TRANSFORM);
        G2.rotate(angle, CENTER.getX(), CENTER.getY());
        G2.drawImage(pointerImage, 0, 0, null);
        G2.setTransform(FORMER_TRANSFORM);

        // Draw posts
        G2.drawImage(postsImage, 0, IMAGE_SHIFT_Y, null);

        // Draw the foreground
        if (isForegroundVisible())
        {
            G2.drawImage(foregroundImage, 0, 0, null);
        }

        if (!isEnabled())
        {
            G2.drawImage(disabledImage, 0, 0, null);
        }
        
        // Translate coordinate system back to original
        G2.translate(-INNER_BOUNDS.x, -INNER_BOUNDS.y);

        G2.dispose();
    }
    
    @Override
    public eu.hansolo.steelseries.tools.FrameType getFrameType()
    {
        return eu.hansolo.steelseries.tools.FrameType.SQUARE;
    }
    
    @Override
    public eu.hansolo.steelseries.tools.GaugeType getGaugeType()
    {
        return eu.hansolo.steelseries.tools.GaugeType.TYPE1;
    }

    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
    protected final void calcAngleStep()
    {
        angleStep = (Math.PI / 2.0 - FREE_AREA_ANGLE) / (getMaxValue() - getMinValue());
    }

    @Override
    public java.awt.geom.Point2D getCenter()
    {
        return new java.awt.geom.Point2D.Double(getInnerBounds().getCenterX() + INNER_BOUNDS.x, getInnerBounds().getCenterX() / 2.0 + INNER_BOUNDS.y);
    }

    @Override
    public java.awt.geom.Rectangle2D getBounds2D()
    {
        return getInnerBounds();
    }

    private void create_AREA()
    {
        
    }

    private void createSections()
    {
        if (!getSections().isEmpty() && backgroundImage != null)
        {
            SECTIONS.clear();
            SECTIONS.addAll(getSections());

            final double ORIGIN_CORRECTION = 135;

            final double ANGLE_STEP = 90.0 / (getMaxValue() - getMinValue());
            final double OUTER_RADIUS = backgroundImage.getWidth() * 0.40f;
            final double INNER_RADIUS = backgroundImage.getWidth() * 0.37f;
            final double FREE_AREA_OUTER_RADIUS = backgroundImage.getWidth() / 2.0 - OUTER_RADIUS;
            final double FREE_AREA_INNER_RADIUS = backgroundImage.getWidth() / 2.0 - INNER_RADIUS;
            final java.awt.geom.Ellipse2D 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);

            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
    protected java.awt.image.BufferedImage create_THRESHOLD_Image(final int WIDTH)
    {
        if (WIDTH <= 0)
        {
            return null;
        }

        final java.awt.image.BufferedImage IMAGE = GFX_CONF.createCompatibleImage(WIDTH, WIDTH, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = IMAGE.createGraphics();
        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();

        final java.awt.geom.GeneralPath THRESHOLD = new java.awt.geom.GeneralPath();
        THRESHOLD.setWindingRule(java.awt.geom.GeneralPath.WIND_EVEN_ODD);
        THRESHOLD.moveTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.3333333333333333);
        THRESHOLD.lineTo(IMAGE_WIDTH * 0.4866666666666667, IMAGE_HEIGHT * 0.37333333333333335);
        THRESHOLD.lineTo(IMAGE_WIDTH * 0.52, IMAGE_HEIGHT * 0.37333333333333335);
        THRESHOLD.lineTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.3333333333333333);
        THRESHOLD.closePath();
        final java.awt.geom.Point2D THRESHOLD_START = new java.awt.geom.Point2D.Double(0, THRESHOLD.getBounds2D().getMinY() );
        final java.awt.geom.Point2D THRESHOLD_STOP = new java.awt.geom.Point2D.Double(0, THRESHOLD.getBounds2D().getMaxY() );
        final float[] THRESHOLD_FRACTIONS =
        {
            0.0f,
            0.3f,
            0.59f,
            1.0f
        };
        final java.awt.Color[] THRESHOLD_COLORS =
        {
            new java.awt.Color(82, 0, 0, 255),
            new java.awt.Color(252, 29, 0, 255),
            new java.awt.Color(252, 29, 0, 255),
            new java.awt.Color(82, 0, 0, 255)
        };
        final java.awt.LinearGradientPaint THRESHOLD_GRADIENT = new java.awt.LinearGradientPaint(THRESHOLD_START, THRESHOLD_STOP, THRESHOLD_FRACTIONS, THRESHOLD_COLORS);
        G2.setPaint(THRESHOLD_GRADIENT);
        G2.fill(THRESHOLD);

        G2.setColor(java.awt.Color.WHITE);
        G2.setStroke(new java.awt.BasicStroke(1.0f, java.awt.BasicStroke.CAP_BUTT, java.awt.BasicStroke.JOIN_MITER));
        G2.draw(THRESHOLD);

        G2.dispose();

        return IMAGE;
    }

    @Override
    protected java.awt.image.BufferedImage create_MEASURED_VALUE_Image(final int WIDTH, final java.awt.Color COLOR)
    {
        if (WIDTH <= 0 || HEIGHT <= 0)
        {
            return null;
        }

        final java.awt.image.BufferedImage IMAGE = GFX_CONF.createCompatibleImage(WIDTH, WIDTH, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = IMAGE.createGraphics();
        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();

        final java.awt.geom.GeneralPath MAXMEASURED = new java.awt.geom.GeneralPath();
        MAXMEASURED.setWindingRule(java.awt.geom.GeneralPath.WIND_EVEN_ODD);
        MAXMEASURED.moveTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.3037383177570093);
        MAXMEASURED.lineTo(IMAGE_WIDTH * 0.514018691588785, IMAGE_HEIGHT * 0.2803738317757009);
        MAXMEASURED.lineTo(IMAGE_WIDTH * 0.48598130841121495, IMAGE_HEIGHT * 0.2803738317757009);
        MAXMEASURED.lineTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.3037383177570093);
        MAXMEASURED.closePath();
        G2.setColor(COLOR);
        G2.fill(MAXMEASURED);

        G2.dispose();

        return IMAGE;
    }

    @Override
    protected java.awt.image.BufferedImage create_TRACK_Image(final int WIDTH, final double MIN_VALUE, final double MAX_VALUE, final double ANGLE_STEP, final double TRACK_START, final double TRACK_SECTION, final double TRACK_STOP, final java.awt.Color TRACK_START_COLOR, final java.awt.Color TRACK_SECTION_COLOR, final java.awt.Color TRACK_STOP_COLOR, final double ROTATION_OFFSET)
    {
        if (WIDTH <= 0 || HEIGHT <= 0)
        {
            return null;
        }

        final java.awt.image.BufferedImage IMAGE = GFX_CONF.createCompatibleImage(WIDTH, WIDTH, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = IMAGE.createGraphics();
        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();

        final java.awt.geom.Point2D CENTER = new java.awt.geom.Point2D.Double(IMAGE_WIDTH / 2.0f, IMAGE_HEIGHT * 0.73);

        final java.awt.geom.GeneralPath TRACK = new java.awt.geom.GeneralPath();
        TRACK.setWindingRule(java.awt.geom.GeneralPath.WIND_EVEN_ODD);
        TRACK.moveTo(IMAGE_WIDTH * 0.21333333333333335, IMAGE_HEIGHT * 0.44);
        TRACK.curveTo(IMAGE_WIDTH * 0.37333333333333335, IMAGE_HEIGHT * 0.2866666666666667, IMAGE_WIDTH * 0.6266666666666667, IMAGE_HEIGHT * 0.2866666666666667, IMAGE_WIDTH * 0.7866666666666666, IMAGE_HEIGHT * 0.44);
        TRACK.curveTo(IMAGE_WIDTH * 0.7866666666666666, IMAGE_HEIGHT * 0.44, IMAGE_WIDTH * 0.8066666666666666, IMAGE_HEIGHT * 0.4266666666666667, IMAGE_WIDTH * 0.8066666666666666, IMAGE_HEIGHT * 0.4266666666666667);
        TRACK.curveTo(IMAGE_WIDTH * 0.6333333333333333, IMAGE_HEIGHT * 0.26, IMAGE_WIDTH * 0.36666666666666664, IMAGE_HEIGHT * 0.26, IMAGE_WIDTH * 0.19333333333333333, IMAGE_HEIGHT * 0.4266666666666667);
        TRACK.curveTo(IMAGE_WIDTH * 0.19333333333333333, IMAGE_HEIGHT * 0.4266666666666667, IMAGE_WIDTH * 0.21333333333333335, IMAGE_HEIGHT * 0.44, IMAGE_WIDTH * 0.21333333333333335, IMAGE_HEIGHT * 0.44);
        TRACK.closePath();

        // Calculate the track start and stop position
        final float TRACK_START_POSITION = (float) Math.toDegrees((TRACK_START - MIN_VALUE) * ANGLE_STEP);
        final float TRACK_STOP_POSITION = ANGLE_CONST * (float) Math.toDegrees((TRACK_STOP - MIN_VALUE) * ANGLE_STEP) - (ANGLE_CONST * TRACK_START_POSITION);

        final java.awt.Color FULLY_TRANSPARENT = new java.awt.Color(0.0f, 0.0f, 0.0f, 0.0f);

        final float[] TRACK_FRACTIONS;
        final java.awt.Color[] TRACK_COLORS;

        // Three color gradient from trackStart over trackSection to trackStop
            final float TRACK_SECTION_POSITION = ANGLE_CONST * (float) Math.toDegrees((TRACK_SECTION - MIN_VALUE) * ANGLE_STEP) - (ANGLE_CONST * TRACK_START_POSITION);

        TRACK_FRACTIONS = new float[]
        {
            0.0f,
            0.000001f,
            TRACK_SECTION_POSITION,
            TRACK_STOP_POSITION,
            TRACK_STOP_POSITION + 0.001f,
            1.0f
        };

        TRACK_COLORS = new java.awt.Color[]
        {
            FULLY_TRANSPARENT,
            TRACK_START_COLOR,
            TRACK_SECTION_COLOR,
            TRACK_STOP_COLOR,
            FULLY_TRANSPARENT,
            FULLY_TRANSPARENT,
            };

        final float TRACK_OFFSET = -ANGLE_CONST * (360 - (float) Math.toDegrees(ROTATION_OFFSET)) + (ANGLE_CONST * TRACK_START_POSITION);

        final eu.hansolo.steelseries.tools.ConicalGradientPaint TRACK_GRADIENT = new eu.hansolo.steelseries.tools.ConicalGradientPaint(false, CENTER, TRACK_OFFSET, TRACK_FRACTIONS, TRACK_COLORS);
        G2.setPaint(TRACK_GRADIENT);
        G2.fill(TRACK);

        G2.dispose();

        return IMAGE;
    }

    private java.awt.image.BufferedImage create_POINTER_Image(final int WIDTH, final int HEIGHT, final eu.hansolo.steelseries.tools.PointerType POINTER_TYPE)
    {
        if (WIDTH <= 0 || HEIGHT <= 0)
        {
            return null;
        }

        final java.awt.image.BufferedImage IMAGE = GFX_CONF.createCompatibleImage(WIDTH, HEIGHT, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = IMAGE.createGraphics();
        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();
        
        final java.awt.geom.Point2D POINTER_START;
        final java.awt.geom.Point2D POINTER_STOP;
        final float[] POINTER_FRACTIONS;
        final java.awt.Color[] POINTER_COLORS;
        final java.awt.Paint POINTER_GRADIENT;

        switch(POINTER_TYPE)
        {
            case TYPE1:
                final java.awt.geom.GeneralPath POINTER1 = new java.awt.geom.GeneralPath();
                POINTER1.setWindingRule(java.awt.geom.GeneralPath.WIND_EVEN_ODD);
                POINTER1.moveTo(IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.curveTo(IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.49242424242424243, IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425, IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425);
                POINTER1.curveTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425, IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.49242424242424243, IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.curveTo(IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.6439393939393939, IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939, IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.closePath();
                POINTER_START = new java.awt.geom.Point2D.Double(0, POINTER1.getBounds2D().getMinY() );
                POINTER_STOP = new java.awt.geom.Point2D.Double(0, POINTER1.getBounds2D().getMaxY() );
                POINTER_FRACTIONS = new float[]
                {
                    0.0f,
                    0.3f,
                    0.59f,
                    1.0f
                };
                POINTER_COLORS = new java.awt.Color[]
                {
                    getPointerColor().DARK,
                    getPointerColor().LIGHT,
                    getPointerColor().LIGHT,
                    getPointerColor().DARK
                };

                POINTER_GRADIENT = new java.awt.LinearGradientPaint(POINTER_START, POINTER_STOP, POINTER_FRACTIONS, POINTER_COLORS);
                G2.setPaint(POINTER_GRADIENT);
                G2.fill(POINTER1);

                final java.awt.Color STROKE_COLOR_POINTER = getPointerColor().LIGHT;
                G2.setColor(STROKE_COLOR_POINTER);
                G2.setStroke(new java.awt.BasicStroke(1.0f, java.awt.BasicStroke.CAP_BUTT, java.awt.BasicStroke.JOIN_MITER));
                G2.draw(POINTER1);
                break;

            case TYPE2:
                final java.awt.geom.Rectangle2D POINTER2 = new java.awt.geom.Rectangle2D.Double(IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.4166666666666667, IMAGE_WIDTH * 0.009433962264150943, IMAGE_HEIGHT * 0.24242424242424243);
                POINTER_START = new java.awt.geom.Point2D.Double(0, POINTER2.getBounds2D().getMaxY() );
                POINTER_STOP = new java.awt.geom.Point2D.Double(0, POINTER2.getBounds2D().getMinY() );
                POINTER_FRACTIONS = new float[]
                {
                    0.0f,
                    0.25f,
                    0.251f,
                    1.0f
                };
                POINTER_COLORS = new java.awt.Color[]
                {
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(0, 0, 0, 255),                    
                    getPointerColor().LIGHT,
                    getPointerColor().LIGHT
                };
                POINTER_GRADIENT = new java.awt.LinearGradientPaint(POINTER_START, POINTER_STOP, POINTER_FRACTIONS, POINTER_COLORS);
                G2.setPaint(POINTER_GRADIENT);
                G2.fill(POINTER2);
                break;
        }

        G2.dispose();

        return IMAGE;
    }
   
    private java.awt.image.BufferedImage create_POINTER_SHADOW_Image(final int WIDTH, final int HEIGHT, final eu.hansolo.steelseries.tools.PointerType POINTER_TYPE)
    {
        if (WIDTH <= 0 || HEIGHT <= 0)
        {
            return null;
        }
        final java.awt.Color SHADOW_COLOR = new java.awt.Color(0.0f, 0.0f, 0.0f, 0.65f);

        final java.awt.image.BufferedImage IMAGE = GFX_CONF.createCompatibleImage(WIDTH, HEIGHT, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = IMAGE.createGraphics();
        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_TEXT_ANTIALIASING, java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();
        

        switch(POINTER_TYPE)
        {
            case TYPE1:
                final java.awt.geom.GeneralPath POINTER1 = new java.awt.geom.GeneralPath();
                POINTER1.setWindingRule(java.awt.geom.GeneralPath.WIND_EVEN_ODD);
                POINTER1.moveTo(IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.curveTo(IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.49242424242424243, IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425, IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425);
                POINTER1.curveTo(IMAGE_WIDTH * 0.5, IMAGE_HEIGHT * 0.42424242424242425, IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.49242424242424243, IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.curveTo(IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.6439393939393939, IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939, IMAGE_WIDTH * 0.5047169811320755, IMAGE_HEIGHT * 0.6439393939393939);
                POINTER1.closePath();
                G2.setColor(SHADOW_COLOR);
                G2.fill(POINTER1);
                break;

            case TYPE2:
                final java.awt.geom.Rectangle2D POINTER = new java.awt.geom.Rectangle2D.Double(IMAGE_WIDTH * 0.49528301886792453, IMAGE_HEIGHT * 0.4166666666666667, IMAGE_WIDTH * 0.009433962264150943, IMAGE_HEIGHT * 0.24242424242424243);
                G2.setColor(SHADOW_COLOR);
                G2.fill(POINTER);
                break;
        }

        G2.dispose();

        return IMAGE;
    }

    @Override
    public void calcInnerBounds()
    {
        final java.awt.Insets INSETS = getInsets();
        INNER_BOUNDS.setBounds(INSETS.left, INSETS.top, getWidth() - INSETS.left - INSETS.right, getHeight() - INSETS.top - INSETS.bottom);
    }

    @Override
    public final java.awt.Rectangle getInnerBounds()
    {
        return INNER_BOUNDS;
    }

    @Override
    public java.awt.Dimension getMinimumSize()
    {        
        return new java.awt.Dimension(212, 132);
    }

    @Override
    public java.awt.Dimension getSize(java.awt.Dimension dim)
    {
        if (getWidth() < getMinimumSize().width && getHeight() < getMinimumSize().height)
        {
            return (getMinimumSize());
        }
        else
        {            
            return new java.awt.Dimension(getWidth(), (int) (0.6226415094339622 * getWidth()));
        }
    }

    @Override
    public void componentResized(java.awt.event.ComponentEvent event)
    {        
        setPreferredSize(new java.awt.Dimension(getWidth(), (int) (0.6226415094339622 * getWidth())));        
        calcInnerBounds();
        recreateAllImages();
        init(INNER_BOUNDS.width, INNER_BOUNDS.height);
        revalidate();
        repaint();
    }

    @Override
    public String toString()
    {
        return "RadialSquareVerticalSmall";
    }
}