All Downloads are FREE. Search and download functionalities are using the official Maven repository.

eu.hansolo.steelseries.tools.FrameImageFactory Maven / Gradle / Ivy

Go to download

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, indicators from cars and some instruments from airplanes and sailboats.

There is a newer version: 3.9.30
Show newest version
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package eu.hansolo.steelseries.tools;

/**
 *
 * @author hansolo
 */
public enum FrameImageFactory
{
    INSTANCE;

    // Variables for caching
    private int radWidth = 0;
    private final java.awt.GraphicsConfiguration GFX_CONF = java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
    private eu.hansolo.steelseries.tools.FrameDesign radFrameDesign = eu.hansolo.steelseries.tools.FrameDesign.METAL;
    private java.awt.image.BufferedImage radFrameImage = GFX_CONF.createCompatibleImage(200, 200, java.awt.Transparency.TRANSLUCENT);
    private boolean rad3dEffect = false;
    private java.awt.Paint radCustomFrame = java.awt.Color.BLACK;
    private int linWidth = 0;
    private int linHeight = 0;
    private eu.hansolo.steelseries.tools.FrameDesign linFrameDesign = eu.hansolo.steelseries.tools.FrameDesign.METAL;
    private java.awt.image.BufferedImage linFrameImage = GFX_CONF.createCompatibleImage(200, 200, java.awt.Transparency.TRANSLUCENT);
    private boolean lin3dEffect = false;
    private java.awt.Paint linCustomFrame = java.awt.Color.BLACK;

    /**
     * Creates the frame image for a radial gauge.
     * The image parameters and the image will be cached. If the
     * current request has the same parameters as the last request
     * it will return the already created image instead of creating
     * a new image.
     * @param WIDTH
     * @param FRAME_DESIGN
     * @param ADD_EFFECT 
     * @param CUSTOM_FRAME_DESIGN 
     * @return a buffered image that contains the frame image for a radial gauge
     */
    public java.awt.image.BufferedImage createRadialFrame(final int WIDTH, final eu.hansolo.steelseries.tools.FrameDesign FRAME_DESIGN, final java.awt.Paint CUSTOM_FRAME_DESIGN, final boolean ADD_EFFECT)
    {

        if (WIDTH <= 0)
        {
            return GFX_CONF.createCompatibleImage(200, 200, java.awt.Transparency.TRANSLUCENT);
        }

        // Take image from cache instead of creating a new one if parameters are the same as last time
        if (radWidth == WIDTH && radFrameDesign == FRAME_DESIGN && rad3dEffect == ADD_EFFECT && radCustomFrame.equals(CUSTOM_FRAME_DESIGN))
        {
            return radFrameImage;
        }

        radFrameImage.flush();
        radFrameImage = GFX_CONF.createCompatibleImage(WIDTH, WIDTH, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = radFrameImage.createGraphics();
        G2.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);

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

        // Skip frame if frameDesign == NO_FRAME
        if (FRAME_DESIGN != eu.hansolo.steelseries.tools.FrameDesign.NO_FRAME)
        {
            // Shape that will be subtracted from the ellipse and will be filled by the background image later
            final java.awt.geom.Area SUBTRACT = new java.awt.geom.Area(new java.awt.geom.Ellipse2D.Double(IMAGE_WIDTH * 0.08411215245723724, IMAGE_HEIGHT * 0.08411215245723724, IMAGE_WIDTH * 0.8317756652832031, IMAGE_HEIGHT * 0.8317756652832031));

            final java.awt.geom.Area FRAME_OUTERFRAME = new java.awt.geom.Area(new java.awt.geom.Ellipse2D.Double(0.0, 0.0, IMAGE_WIDTH, IMAGE_HEIGHT));
            FRAME_OUTERFRAME.subtract(SUBTRACT);
            final java.awt.Color FILL_COLOR_FRAME_OUTERFRAME = new java.awt.Color(0x848484);
            G2.setColor(FILL_COLOR_FRAME_OUTERFRAME);
            G2.fill(FRAME_OUTERFRAME);
            
            final java.awt.geom.Area FRAME_MAIN = new java.awt.geom.Area(new java.awt.geom.Ellipse2D.Double(IMAGE_WIDTH * 0.004672897048294544, IMAGE_HEIGHT * 0.004672897048294544, IMAGE_WIDTH * 0.9906542301177979, IMAGE_HEIGHT * 0.9906542301177979));
            FRAME_MAIN.subtract(SUBTRACT);
            final java.awt.geom.Point2D FRAME_MAIN_START = new java.awt.geom.Point2D.Double(0, FRAME_MAIN.getBounds2D().getMinY());
            final java.awt.geom.Point2D FRAME_MAIN_STOP = new java.awt.geom.Point2D.Double(0, FRAME_MAIN.getBounds2D().getMaxY());
            final java.awt.geom.Point2D FRAME_MAIN_CENTER = new java.awt.geom.Point2D.Double(FRAME_MAIN.getBounds2D().getCenterX(), FRAME_MAIN.getBounds2D().getCenterY());

            final float[] FRAME_MAIN_FRACTIONS;
            final java.awt.Color[] FRAME_MAIN_COLORS;
            final java.awt.Paint FRAME_MAIN_GRADIENT;

            switch (FRAME_DESIGN)
            {
                case BLACK_METAL:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        45.0f,
                        125.0f,
                        180.0f,
                        245.0f,
                        315.0f,
                        360.0f
                    };

                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(254, 254, 254, 255),
                        new java.awt.Color(0, 0, 0, 255),
                        new java.awt.Color(153, 153, 153, 255),
                        new java.awt.Color(0, 0, 0, 255),
                        new java.awt.Color(153, 153, 153, 255),
                        new java.awt.Color(0, 0, 0, 255),
                        new java.awt.Color(254, 254, 254, 255)
                    };

                    FRAME_MAIN_GRADIENT = new eu.hansolo.steelseries.tools.ConicalGradientPaint(true, FRAME_MAIN_CENTER, 0, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;

                case METAL:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.07f,
                        0.12f,
                        1.0f
                    };

                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(254, 254, 254, 255),
                        new java.awt.Color(210, 210, 210, 255),
                        new java.awt.Color(179, 179, 179, 255),
                        new java.awt.Color(213, 213, 213, 255)
                    };

                    FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;

                case SHINY_METAL:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        45.0f,
                        90.0f,
                        125.0f,
                        180.0f,
                        235.0f,
                        270.0f,
                        315.0f,
                        360.0f
                    };

                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(254, 254, 254, 255),
                        new java.awt.Color(210, 210, 210, 255),
                        new java.awt.Color(179, 179, 179, 255),
                        new java.awt.Color(238, 238, 238, 255),
                        new java.awt.Color(160, 160, 160, 255),
                        new java.awt.Color(238, 238, 238, 255),
                        new java.awt.Color(179, 179, 179, 255),
                        new java.awt.Color(210, 210, 210, 255),
                        new java.awt.Color(254, 254, 254, 255)
                    };

                    FRAME_MAIN_GRADIENT = new eu.hansolo.steelseries.tools.ConicalGradientPaint(true, FRAME_MAIN_CENTER, 0, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;

                case BRASS:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.05f,
                        0.10f,
                        0.50f,
                        0.90f,
                        0.95f,
                        1.0f
                    };
                    
                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(249, 243, 155, 255),
                        new java.awt.Color(246, 226, 101, 255),
                        new java.awt.Color(240, 225, 132, 255),
                        new java.awt.Color(90, 57, 22, 255),
                        new java.awt.Color(249, 237, 139, 255),
                        new java.awt.Color(243, 226, 108, 255),
                        new java.awt.Color(202, 182, 113, 255)
                    };
                    FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;
                
                case STEEL:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.05f,
                        0.10f,
                        0.50f,
                        0.90f,
                        0.95f,
                        1.0f
                    };
                    
                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(231, 237, 237, 255),
                        new java.awt.Color(189, 199, 198, 255),
                        new java.awt.Color(192, 201, 200, 255),
                        new java.awt.Color(23, 31, 33, 255),
                        new java.awt.Color(196, 205, 204, 255),
                        new java.awt.Color(194, 204, 203, 255),
                        new java.awt.Color(189, 201, 199, 255)
                    };
                    FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;    
                
                case GOLD:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.15f,
                        0.22f,
                        0.3f,
                        0.38f,
                        0.44f,
                        0.51f,
                        0.6f,
                        0.68f,
                        0.75f,
                        1.0f
                    };
                    
                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(255, 255, 207, 255),
                        new java.awt.Color(255, 237, 96, 255),
                        new java.awt.Color(254, 199, 57, 255),
                        new java.awt.Color(255, 249, 203, 255),
                        new java.awt.Color(255, 199, 64, 255),
                        new java.awt.Color(252, 194, 60, 255),
                        new java.awt.Color(255, 204, 59, 255),
                        new java.awt.Color(213, 134, 29, 255),
                        new java.awt.Color(255, 201, 56, 255),
                        new java.awt.Color(212, 135, 29, 255),
                        new java.awt.Color(247, 238, 101, 255)
                    };
                    FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;
                    
                default:
                    FRAME_MAIN_FRACTIONS = new float[]
                        {
                            0.0f,
                            0.07f,
                            0.12f,
                            1.0f
                        };

                    FRAME_MAIN_COLORS = new java.awt.Color[]
                        {
                            new java.awt.Color(254, 254, 254, 255),
                            new java.awt.Color(210, 210, 210, 255),
                            new java.awt.Color(179, 179, 179, 255),
                            new java.awt.Color(213, 213, 213, 255)
                        };

                    FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                    break;
            }

            if (CUSTOM_FRAME_DESIGN != null && FRAME_DESIGN == eu.hansolo.steelseries.tools.FrameDesign.CUSTOM)
            {
                G2.setPaint(CUSTOM_FRAME_DESIGN);
            }
            else
            {
                G2.setPaint(FRAME_MAIN_GRADIENT);
            }
            G2.fill(FRAME_MAIN);

            //final java.awt.geom.Ellipse2D FRAME_INNERFRAME = new java.awt.geom.Ellipse2D.Double(IMAGE_WIDTH * 0.07943925261497498, IMAGE_HEIGHT * 0.07943925261497498, IMAGE_WIDTH * 0.8411215543746948, IMAGE_HEIGHT * 0.8411215543746948);
            final java.awt.geom.Area FRAME_INNERFRAME = new java.awt.geom.Area(new java.awt.geom.Ellipse2D.Double(IMAGE_WIDTH * 0.07943925261497498, IMAGE_HEIGHT * 0.07943925261497498, IMAGE_WIDTH * 0.8411215543746948, IMAGE_HEIGHT * 0.8411215543746948));
            FRAME_INNERFRAME.subtract(SUBTRACT);
            G2.setColor(java.awt.Color.WHITE);
            G2.fill(FRAME_INNERFRAME);
                                
            // 3D effect overlay
            if (ADD_EFFECT)
            {            
                final java.awt.geom.Point2D EFFECT_CENTER = new java.awt.geom.Point2D.Double( (0.5 * IMAGE_WIDTH), (0.5 * IMAGE_HEIGHT) );
                final float[] EFFECT_FRACTIONS = 
                {
                    0.0f,
                    0.82f,
                    0.83f,
                    0.86f,
                    0.87f,
                    1.0f
                };
                final java.awt.Color[] EFFECT_COLORS = 
                {
                    new java.awt.Color(0, 0, 0, 0),
                    new java.awt.Color(0, 0, 0, 76),
                    new java.awt.Color(0, 0, 0, 95),
                    new java.awt.Color(219, 219, 219, 153),
                    new java.awt.Color(255, 255, 255, 151),
                    new java.awt.Color(0, 0, 0, 102)
                };
                final java.awt.RadialGradientPaint EFFECT_GRADIENT = new java.awt.RadialGradientPaint(EFFECT_CENTER, (0.5f * IMAGE_WIDTH), EFFECT_FRACTIONS, EFFECT_COLORS);
                G2.setPaint(EFFECT_GRADIENT);
                G2.fill(FRAME_OUTERFRAME);
            }
        }
        
        G2.dispose();

        // Cache current parameters
        radWidth = WIDTH;
        radFrameDesign = FRAME_DESIGN;
        rad3dEffect = ADD_EFFECT;
        radCustomFrame = CUSTOM_FRAME_DESIGN;

        return radFrameImage;
    }

    /**
     * Creates the frame image for a linear gauge.
     * The image parameters and the image will be cached. If the
     * current request has the same parameters as the last request
     * it will return the already created image instead of creating
     * a new image.
     * @param WIDTH
     * @param FRAME_DESIGN
     * @param ADD_EFFECT 
     * @param CUSTOM_FRAME_DESIGN 
     * @return a buffered image that contains the frame image for a linear gauge
     */
    public java.awt.image.BufferedImage createLinearFrame(final int WIDTH, final eu.hansolo.steelseries.tools.FrameDesign FRAME_DESIGN, final java.awt.Paint CUSTOM_FRAME_DESIGN, final boolean ADD_EFFECT)
    {
        return createLinearFrame(WIDTH, WIDTH, FRAME_DESIGN, CUSTOM_FRAME_DESIGN, ADD_EFFECT);
    }
    
    /**
     * Creates the frame image for a linear gauge.
     * The image parameters and the image will be cached. If the
     * current request has the same parameters as the last request
     * it will return the already created image instead of creating
     * a new image.
     * @param WIDTH
     * @param HEIGHT
     * @param FRAME_DESIGN
     * @param ADD_EFFECT 
     * @param CUSTOM_FRAME_DESIGN 
     * @return a buffered image that contains the frame image for a linear gauge
     */
    public java.awt.image.BufferedImage createLinearFrame(final int WIDTH, final int HEIGHT, final eu.hansolo.steelseries.tools.FrameDesign FRAME_DESIGN, final java.awt.Paint CUSTOM_FRAME_DESIGN, final boolean ADD_EFFECT)
    {
        if (WIDTH <= 2 || HEIGHT <= 2)
        {
            return GFX_CONF.createCompatibleImage(140, 140, java.awt.Transparency.TRANSLUCENT);
        }
                
        // Take image from cache instead of creating a new one if parameters are the same as last time
        if (linWidth == WIDTH && linHeight == HEIGHT && linFrameDesign == FRAME_DESIGN && lin3dEffect == ADD_EFFECT && linCustomFrame.equals(CUSTOM_FRAME_DESIGN))
        {
            return linFrameImage;
        }

        linFrameImage.flush();
        linFrameImage = GFX_CONF.createCompatibleImage(WIDTH, HEIGHT, java.awt.Transparency.TRANSLUCENT);
        final java.awt.Graphics2D G2 = linFrameImage.createGraphics();
        G2.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
        G2.setRenderingHint(java.awt.RenderingHints.KEY_STROKE_CONTROL, java.awt.RenderingHints.VALUE_STROKE_PURE);

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

        final double OUTER_FRAME_CORNER_RADIUS;
        if (IMAGE_WIDTH >= IMAGE_HEIGHT)
        {
            OUTER_FRAME_CORNER_RADIUS = IMAGE_HEIGHT * 0.05;
        }
        else
        {
            OUTER_FRAME_CORNER_RADIUS = IMAGE_WIDTH * 0.05;
        }

        final java.awt.geom.Area OUTER_FRAME = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Double(0.0, 0.0, IMAGE_WIDTH, IMAGE_HEIGHT, OUTER_FRAME_CORNER_RADIUS, OUTER_FRAME_CORNER_RADIUS));
        final java.awt.Color COLOR_OUTER_FRAME = new java.awt.Color(0x848484);
        G2.setColor(COLOR_OUTER_FRAME);
        // The outer frame will be painted later because first we have to subtract the inner background

        final double FRAME_MAIN_CORNER_RADIUS;
        if (IMAGE_WIDTH >= IMAGE_HEIGHT)
        {
            FRAME_MAIN_CORNER_RADIUS = OUTER_FRAME_CORNER_RADIUS - ((OUTER_FRAME.getBounds2D().getHeight() - IMAGE_HEIGHT - 2) / 2.0);
        }
        else
        {
            FRAME_MAIN_CORNER_RADIUS = OUTER_FRAME_CORNER_RADIUS - ((OUTER_FRAME.getBounds2D().getWidth() - IMAGE_WIDTH - 2) / 2.0);
        }
        final java.awt.geom.Area FRAME_MAIN = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Double(1.0, 1.0, IMAGE_WIDTH - 2, IMAGE_HEIGHT - 2, FRAME_MAIN_CORNER_RADIUS, FRAME_MAIN_CORNER_RADIUS));
        final java.awt.geom.Point2D FRAME_MAIN_START = new java.awt.geom.Point2D.Double(0, FRAME_MAIN.getBounds2D().getMinY() );
        final java.awt.geom.Point2D FRAME_MAIN_STOP = new java.awt.geom.Point2D.Double(0, FRAME_MAIN.getBounds2D().getMaxY() );
        final java.awt.geom.Point2D FRAME_MAIN_CENTER = new java.awt.geom.Point2D.Double(FRAME_MAIN.getBounds2D().getCenterX(), FRAME_MAIN.getBounds2D().getCenterY());

        // Create shape that needs to be subtracted from rectangles
        final double SUBTRACT_CORNER_RADIUS;
        if (IMAGE_WIDTH >= IMAGE_HEIGHT)
        {
            SUBTRACT_CORNER_RADIUS = IMAGE_HEIGHT * 0.02857143;
        }
        else
        {
            SUBTRACT_CORNER_RADIUS = IMAGE_WIDTH * 0.02857143;
        }
        final java.awt.geom.Area SUBTRACT = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Double(FRAME_MAIN.getBounds2D().getX() + 16, FRAME_MAIN.getBounds2D().getY() + 16, FRAME_MAIN.getBounds2D().getWidth() - 32, FRAME_MAIN.getBounds2D().getHeight() - 32, SUBTRACT_CORNER_RADIUS, SUBTRACT_CORNER_RADIUS));

        // Paint outer frame after we subtracted the inner background shape
        if (FRAME_DESIGN != eu.hansolo.steelseries.tools.FrameDesign.NO_FRAME)
        {
            OUTER_FRAME.subtract(SUBTRACT);
            G2.fill(OUTER_FRAME);
        }

        final float ANGLE_OFFSET = (float) Math.toDegrees(Math.atan((IMAGE_HEIGHT / 8.0f) / (IMAGE_WIDTH / 2.0f)));
        final float[] FRAME_MAIN_FRACTIONS;
        final java.awt.Color[] FRAME_MAIN_COLORS;
        final java.awt.Paint FRAME_MAIN_GRADIENT;

        switch(FRAME_DESIGN)
        {
            case BLACK_METAL:
                FRAME_MAIN_FRACTIONS = new float[]
                {
                    0.0f,
                    90.0f - 2 * ANGLE_OFFSET,
                    90.0f,
                    90.0f + 3 * ANGLE_OFFSET,
                    180.0f,
                    270.0f - 3 * ANGLE_OFFSET,
                    270.0f,
                    270.0f + 2 * ANGLE_OFFSET,
                    1.0f
                };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                {
                    new java.awt.Color(254, 254, 254, 255),
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(153, 153, 153, 255),
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(153, 153, 153, 255),
                    new java.awt.Color(0, 0, 0, 255),
                    new java.awt.Color(254, 254, 254, 255)
                };

                FRAME_MAIN_GRADIENT = new eu.hansolo.steelseries.tools.ConicalGradientPaint(true, FRAME_MAIN_CENTER, 0, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;

            case METAL:
                FRAME_MAIN_FRACTIONS = new float[]
                {
                    0.0f,
                    0.07f,
                    0.12f,
                    1.0f
                };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                {
                    new java.awt.Color(254, 254, 254, 255),
                    new java.awt.Color(210, 210, 210, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(213, 213, 213, 255)
                };

                FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;

            case SHINY_METAL:
                FRAME_MAIN_FRACTIONS = new float[]
                {
                    0.0f,
                    90.0f - 2 * ANGLE_OFFSET,
                    90.0f,
                    90.0f + 3 * ANGLE_OFFSET,
                    180.0f,
                    270.0f - 3 * ANGLE_OFFSET,
                    270.0f,
                    270.0f + 2 * ANGLE_OFFSET,
                    1.0f
                };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                {
                    new java.awt.Color(254, 254, 254, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(238, 238, 238, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(238, 238, 238, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(254, 254, 254, 255)
                };

                FRAME_MAIN_GRADIENT = new eu.hansolo.steelseries.tools.ConicalGradientPaint(true, FRAME_MAIN_CENTER, 0, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;

            case BRASS:
                FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.05f,
                        0.10f,
                        0.50f,
                        0.90f,
                        0.95f,
                        1.0f
                    };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(249, 243, 155, 255),
                        new java.awt.Color(246, 226, 101, 255),
                        new java.awt.Color(240, 225, 132, 255),
                        new java.awt.Color(90, 57, 22, 255),
                        new java.awt.Color(249, 237, 139, 255),
                        new java.awt.Color(243, 226, 108, 255),
                        new java.awt.Color(202, 182, 113, 255)
                    };
                FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;

            case STEEL:
                FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.05f,
                        0.10f,
                        0.50f,
                        0.90f,
                        0.95f,
                        1.0f
                    };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(231, 237, 237, 255),
                        new java.awt.Color(189, 199, 198, 255),
                        new java.awt.Color(192, 201, 200, 255),
                        new java.awt.Color(23, 31, 33, 255),
                        new java.awt.Color(196, 205, 204, 255),
                        new java.awt.Color(194, 204, 203, 255),
                        new java.awt.Color(189, 201, 199, 255)
                    };
                FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;     
                
            case GOLD:
                    FRAME_MAIN_FRACTIONS = new float[]
                    {
                        0.0f,
                        0.15f,
                        0.22f,
                        0.3f,
                        0.38f,
                        0.44f,
                        0.51f,
                        0.6f,
                        0.68f,
                        0.75f,
                        1.0f
                    };
                    
                    FRAME_MAIN_COLORS = new java.awt.Color[]
                    {
                        new java.awt.Color(255, 255, 207, 255),
                        new java.awt.Color(255, 237, 96, 255),
                        new java.awt.Color(254, 199, 57, 255),
                        new java.awt.Color(255, 249, 203, 255),
                        new java.awt.Color(255, 199, 64, 255),
                        new java.awt.Color(252, 194, 60, 255),
                        new java.awt.Color(255, 204, 59, 255),
                        new java.awt.Color(213, 134, 29, 255),
                        new java.awt.Color(255, 201, 56, 255),
                        new java.awt.Color(212, 135, 29, 255),
                        new java.awt.Color(247, 238, 101, 255)
                    };
                FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;
                
            default:
                FRAME_MAIN_FRACTIONS = new float[]
                {
                    0.0f,
                    0.07f,
                    0.12f,
                    1.0f
                };

                FRAME_MAIN_COLORS = new java.awt.Color[]
                {
                    new java.awt.Color(254, 254, 254, 255),
                    new java.awt.Color(210, 210, 210, 255),
                    new java.awt.Color(179, 179, 179, 255),
                    new java.awt.Color(213, 213, 213, 255)
                };

                FRAME_MAIN_GRADIENT = new java.awt.LinearGradientPaint(FRAME_MAIN_START, FRAME_MAIN_STOP, FRAME_MAIN_FRACTIONS, FRAME_MAIN_COLORS);
                break;
        }
        if (CUSTOM_FRAME_DESIGN != null && FRAME_DESIGN == eu.hansolo.steelseries.tools.FrameDesign.CUSTOM)
        {
            G2.setPaint(CUSTOM_FRAME_DESIGN);
        }
        else
        {
            G2.setPaint(FRAME_MAIN_GRADIENT);
        }
                
        if (FRAME_DESIGN != eu.hansolo.steelseries.tools.FrameDesign.NO_FRAME)
        {
            FRAME_MAIN.subtract(SUBTRACT);
            G2.fill(FRAME_MAIN);
            
            if (ADD_EFFECT)
            {                
                final float[] EFFECT_FRACTIONS;       
                final float relFrameSize;
                // The smaller side is important for the contour gradient
                if (WIDTH >= HEIGHT)
                {
                    relFrameSize = (32f / HEIGHT);                    
                }
                else
                {
                    relFrameSize = (32f / WIDTH);                    
                }
                EFFECT_FRACTIONS = new float[]
                {
                    0.0f,
                    relFrameSize * 0.87f,
                    relFrameSize * 0.86f,
                    relFrameSize * 0.83f,                    
                    relFrameSize,
                    relFrameSize * 1.01f,
                    1.0f
                };
                final java.awt.Color[] EFFECT_COLORS = 
                {                    
                    new java.awt.Color(0, 0, 0, 102),
                    new java.awt.Color(255, 255, 255, 151),
                    new java.awt.Color(219, 219, 219, 153),
                    new java.awt.Color(219, 219, 219, 153),
                    new java.awt.Color(36, 36, 36, 76),
                    new java.awt.Color(0, 0, 0, 95),                    
                    new java.awt.Color(0, 0, 0, 0)
                };                
                final eu.hansolo.steelseries.tools.ContourGradientPaint EFFECT_GRADIENT = new eu.hansolo.steelseries.tools.ContourGradientPaint(OUTER_FRAME.getBounds2D(), EFFECT_FRACTIONS, EFFECT_COLORS);
                G2.setPaint(EFFECT_GRADIENT);
                G2.fill(OUTER_FRAME);
            }
        }

        final double INNER_FRAME_CORNER_RADIUS;
        if (IMAGE_WIDTH >= IMAGE_HEIGHT)
        {
            INNER_FRAME_CORNER_RADIUS = IMAGE_HEIGHT * 0.02857143;
        }
        else
        {
            INNER_FRAME_CORNER_RADIUS = IMAGE_WIDTH * 0.02857143;
        }

        final java.awt.geom.Area INNER_FRAME = new java.awt.geom.Area(new java.awt.geom.RoundRectangle2D.Double(FRAME_MAIN.getBounds2D().getX() + 16, FRAME_MAIN.getBounds2D().getY() + 16, FRAME_MAIN.getBounds2D().getWidth() - 32, FRAME_MAIN.getBounds2D().getHeight() - 32, INNER_FRAME_CORNER_RADIUS, INNER_FRAME_CORNER_RADIUS));
        G2.setColor(java.awt.Color.WHITE);
        if (FRAME_DESIGN != eu.hansolo.steelseries.tools.FrameDesign.NO_FRAME)
        {
            INNER_FRAME.subtract(SUBTRACT);
            G2.fill(INNER_FRAME);
        }

        G2.dispose();

        // Cache current parameters
        linWidth = WIDTH;
        linHeight = HEIGHT;
        linFrameDesign = FRAME_DESIGN;
        lin3dEffect = ADD_EFFECT;
        linCustomFrame = CUSTOM_FRAME_DESIGN;

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




© 2015 - 2024 Weber Informatics LLC | Privacy Policy