//    public static Shape getInteriorShapeAsFirstPartTextField(Rectangle bounds) {
  //        int x = bounds.x;
  //        int y = bounds.y;
  //        int w = bounds.width;
  //        int h = bounds.height;
  //        int roundCorner = h;
  //
  //        int x1 = x + w, x2 = x + roundCorner, x3 = x, x4 = x, x5 = x, x6 = x, x7 = x +
  // roundCorner, x8 = x1;
  //        int y1 = y + h, y2 = y1, y3 = y1, y4 = y + h - roundCorner, y5 = y + roundCorner, y6 =
  // y, y7 = y6, y8 = y6;
  //        GeneralPath path = new GeneralPath();
  //        path.moveTo(x1, y1);
  //        path.lineTo(x2, y2);
  //        path.curveTo(x2, y2, x3, y3, x4, y4);
  //        path.lineTo(x5, y5);
  //        path.curveTo(x5, y5, x6, y6, x7, y7);
  //        path.lineTo(x8, y8);
  //        return path;
  //    }
  public static Shape getInteriorShapeAsLastPart(Rectangle bounds) {
    int x = bounds.x;
    int y = bounds.y;
    int w = bounds.width;
    int h = bounds.height;
    int roundCorner = h / 2;

    int x1 = x, x2 = x + w - roundCorner, x3 = x + w, x4 = x3, x5 = x3, x6 = x3, x7 = x2, x8 = x1;
    int y1 = y,
        y2 = y1,
        y3 = 1,
        y4 = y + roundCorner,
        y5 = y + h - roundCorner,
        y6 = y + h,
        y7 = y6,
        y8 = y6;
    GeneralPath path = new GeneralPath();
    path.moveTo(x1, y1);
    path.lineTo(x2, y2);
    path.curveTo(x2, y2, x3, y3, x4, y4);
    path.lineTo(x5, y5);
    path.curveTo(x5, y5, x6, y6, x7, y7);
    path.lineTo(x8, y8);
    return path;
  }
  @Override
  public void paint(Graphics2D graphics, Dimension dimensions) {

    final Color shadowColor = new Color(0.0f, 0.0f, 0.0f, 0.65f);

    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    graphics.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
    // graphics.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
    // RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
    // graphics.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
    // RenderingHints.VALUE_COLOR_RENDER_QUALITY);
    graphics.setRenderingHint(
        RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
    // graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
    // RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    final int imageWidth = (int) dimensions.getWidth();
    final int imageHeight = (int) dimensions.getHeight();

    final GeneralPath pointerShape;

    pointerShape = new GeneralPath();
    pointerShape.setWindingRule(Path2D.WIND_EVEN_ODD);
    pointerShape.moveTo(imageWidth * 0.5, imageHeight * 0.14953271028037382);
    pointerShape.curveTo(
        imageWidth * 0.5,
        imageHeight * 0.14953271028037382,
        imageWidth * 0.4439252336448598,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.4439252336448598,
        imageHeight * 0.5);
    pointerShape.curveTo(
        imageWidth * 0.4439252336448598,
        imageHeight * 0.5327102803738317,
        imageWidth * 0.4672897196261682,
        imageHeight * 0.5560747663551402,
        imageWidth * 0.5,
        imageHeight * 0.5560747663551402);
    pointerShape.curveTo(
        imageWidth * 0.5327102803738317,
        imageHeight * 0.5560747663551402,
        imageWidth * 0.5560747663551402,
        imageHeight * 0.5327102803738317,
        imageWidth * 0.5560747663551402,
        imageHeight * 0.5);
    pointerShape.curveTo(
        imageWidth * 0.5560747663551402,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.5,
        imageHeight * 0.14953271028037382,
        imageWidth * 0.5,
        imageHeight * 0.14953271028037382);
    pointerShape.closePath();
    graphics.setColor(shadowColor);
    graphics.fill(pointerShape);

    graphics.dispose();
  }
Example #3
0
 public GeneralPath getBezieredPoly(Polygon pts) {
   GeneralPath p = new GeneralPath();
   if (pts.npoints > 0) {
     p.moveTo(pts.xpoints[0], pts.ypoints[0]);
     if (pts.npoints >= 4) {
       int counter = 1;
       for (int i = 1; i + 2 < pts.npoints; i += 3) {
         p.curveTo(
             pts.xpoints[i],
             pts.ypoints[i],
             pts.xpoints[i + 1],
             pts.ypoints[i + 1],
             pts.xpoints[i + 2],
             pts.ypoints[i + 2]);
         counter += 3;
       }
       while (counter < pts.npoints) {
         p.lineTo(pts.xpoints[counter], pts.ypoints[counter]);
         counter++;
       }
     } else {
       for (int i = 1; i < pts.npoints; i++) {
         p.lineTo(pts.xpoints[i], pts.ypoints[i]);
       }
     }
   }
   return p;
 }
Example #4
0
  public java.awt.geom.GeneralPath appendPath(java.awt.geom.GeneralPath path) {
    // number of curves to approximate the arc
    int nSeg = (int) ceil(abs(angleExtent) / (PI / 2));
    nSeg = min(nSeg, 4);

    // angular extent of each curve
    double ext = angleExtent / nSeg;

    // compute coefficient
    double k = btan(abs(ext));

    for (int i = 0; i < nSeg; i++) {
      // position of the two extremities
      double ti0 = abs(i * ext);
      double ti1 = abs((i + 1) * ext);

      // extremity points
      Point2D p1 = this.point(ti0);
      Point2D p2 = this.point(ti1);

      // tangent vectors, multiplied by appropriate coefficient
      Vector2D v1 = this.tangent(ti0).times(k);
      Vector2D v2 = this.tangent(ti1).times(k);

      // append a cubic curve to the path
      path.curveTo(
          p1.x() + v1.x(), p1.y() + v1.y(), p2.x() - v2.x(), p2.y() - v2.y(), p2.x(), p2.y());
    }
    return path;
  }
  protected void curveVertexSegment(
      float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {
    curveCoordX[0] = x1;
    curveCoordY[0] = y1;

    curveCoordX[1] = x2;
    curveCoordY[1] = y2;

    curveCoordX[2] = x3;
    curveCoordY[2] = y3;

    curveCoordX[3] = x4;
    curveCoordY[3] = y4;

    curveToBezierMatrix.mult(curveCoordX, curveDrawX);
    curveToBezierMatrix.mult(curveCoordY, curveDrawY);

    // since the paths are continuous,
    // only the first point needs the actual moveto
    if (gpath == null) {
      gpath = new GeneralPath();
      gpath.moveTo(curveDrawX[0], curveDrawY[0]);
    }

    gpath.curveTo(
        curveDrawX[1], curveDrawY[1],
        curveDrawX[2], curveDrawY[2],
        curveDrawX[3], curveDrawY[3]);
  }
Example #6
0
 /**
  * Draws a curve segment relative to the current point of the GeneralPath.
  *
  * <p>Adds a curved segment, defined by three new points, to the path by drawing a Bezier curve
  * that intersects both the current coordinates and the coordinates (x3, y3), using the specified
  * points (x1, y1) and (x2, y2) as Bezier control points.
  */
 public static void curveTo(
     GeneralPath gp, float x1, float y1, float x2, float y2, float x3, float y3) {
   Point2D currentPoint = gp.getCurrentPoint();
   gp.curveTo(
       x1 + (float) currentPoint.getX(), y1 + (float) currentPoint.getY(),
       x2 + (float) currentPoint.getX(), y2 + (float) currentPoint.getY(),
       x3 + (float) currentPoint.getX(), y3 + (float) currentPoint.getY());
 }
Example #7
0
  static {
    GeneralPath gp = new GeneralPath();

    gp = new GeneralPath();
    ExplicitBoundsShape bnd = null;

    gp.moveTo(-0.145f, 0.000f);
    gp.lineTo(0.000f, 0.175f);
    gp.lineTo(0.105f, 0.000f);
    gp.closePath();
    bnd = new ExplicitBoundsShape(gp);
    bnd.setBounds(new Rectangle2D.Double(-0.5, -0.5, 0.5, 0.5));
    WELLKNOWN_SHAPES.put("triangle", bnd);

    gp = new GeneralPath();
    gp.moveTo(-0.125f, 0.000f);
    gp.curveTo(-0.125f, 0.000f, 0.000f, 0.250f, 0.125f, 0.000f);
    gp.closePath();
    bnd = new ExplicitBoundsShape(gp);
    bnd.setBounds(new Rectangle2D.Double(-0.5, -0.5, 0.5, 0.5));
    WELLKNOWN_SHAPES.put("emicircle", bnd);

    gp = new GeneralPath();
    gp.moveTo(-0.395f, 0.000f);
    gp.lineTo(-0.250f, -0.175f);
    gp.lineTo(-0.145f, 0.000f);
    gp.moveTo(0.125f, 0.000f);
    gp.curveTo(0.125f, 0.000f, 0.250f, 0.250f, 0.375f, 0.000f);
    gp.closePath();
    bnd = new ExplicitBoundsShape(gp);
    bnd.setBounds(new Rectangle2D.Double(-0.5, -0.5, 1.0, 1.0));
    WELLKNOWN_SHAPES.put("triangleemicircle", bnd);

    gp = new GeneralPath();
    gp.moveTo(0f, 0.5f);
    gp.lineTo(0.5, -0.5f);
    gp.lineTo(0.1f, -0.5f);
    gp.lineTo(0.1f, -2.0f);
    gp.lineTo(-0.1f, -2.0f);
    gp.lineTo(-0.1f, -0.5f);
    gp.lineTo(-0.5f, -0.5f);
    gp.closePath();
    ExplicitBoundsShape narrow = new ExplicitBoundsShape(gp);
    narrow.setBounds(new Rectangle2D.Double(-1.2, -0.3, 1, 0.6));
    WELLKNOWN_SHAPES.put("narrow", narrow);
  }
 public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) {
   gp.curveTo(x1, y1, x2, y2, x3, y3);
   this.x = x3;
   this.y = y3;
   points.add(new GlyphPoint(x1, y1, true));
   points.add(new GlyphPoint(x2, y2, true));
   points.add(new GlyphPoint(x3, y3, false));
 }
 public void curveTo(double x1, double y1, double x2, double y2, double x3, double y3) {
   if (currentPath != null) {
     currentPath.curveTo(
         (float) ((state.dx + x1) * state.scale),
         (float) ((state.dy + y1) * state.scale),
         (float) ((state.dx + x2) * state.scale),
         (float) ((state.dy + y2) * state.scale),
         (float) ((state.dx + x3) * state.scale),
         (float) ((state.dy + y3) * state.scale));
   }
 }
Example #10
0
  /**
   * Paints the transcoded SVG image on the specified graphics context.
   *
   * @param g Graphics context.
   */
  private void paint(Graphics2D g) {
    Shape shape = null;

    float origAlpha = 1.0f;

    java.util.LinkedList<AffineTransform> transformations =
        new java.util.LinkedList<AffineTransform>();

    //
    transformations.offer(g.getTransform());
    g.transform(new AffineTransform(1.0666667f, 0, 0, 1.0666667f, 0, 0));

    // _0

    // _0_0

    // _0_0_0
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(44.85476, 13.658783);
    ((GeneralPath) shape).lineTo(39.8797, 18.833183);
    ((GeneralPath) shape).lineTo(62.034473, 24.087093);
    ((GeneralPath) shape).lineTo(56.182423, 2.2196937);
    ((GeneralPath) shape).lineTo(51.25553, 7.156234);
    ((GeneralPath) shape).curveTo(23.11004, -15.968987, -18.852411, 21.698124, 9.346271, 53.566833);
    ((GeneralPath) shape).curveTo(34.37855, 75.45358, 62.938217, 55.468464, 62.84925, 31.573273);
    ((GeneralPath) shape).lineTo(53.94392, 31.646673);
    ((GeneralPath) shape).curveTo(53.04116, 50.485714, 32.096634, 60.792103, 16.790325, 48.184963);
    ((GeneralPath) shape)
        .curveTo(-3.4530144, 28.782303, 21.423546, -2.7391064, 44.85476, 13.658743);
    ((GeneralPath) shape).closePath();

    g.setPaint(color);
    g.fill(shape);

    g.setTransform(transformations.poll()); // _0
  }
Example #11
0
  /**
   * Get the shape that defines this geometry object. If any of the sites have been translated since
   * this shape was set, a new shape will be produced and returned.
   */
  public Shape getShape() {
    if (_path == null) {
      GeneralPath p = new GeneralPath(GeneralPath.WIND_NON_ZERO, _vertexCount + 2);
      int c = 0;

      for (int i = 0; i < _vertexCount; i++) {
        switch (_type[i]) {
          case PathIterator.SEG_CLOSE:
            p.closePath();
            break;

          case PathIterator.SEG_MOVETO:
            p.moveTo(_coordinate[c], _coordinate[c + 1]);
            c += 2;
            break;

          case PathIterator.SEG_LINETO:
            p.lineTo(_coordinate[c], _coordinate[c + 1]);
            c += 2;
            break;

          case PathIterator.SEG_QUADTO:
            p.quadTo(_coordinate[c], _coordinate[c + 1], _coordinate[c + 2], _coordinate[c + 3]);
            c += 4;
            break;

          case PathIterator.SEG_CUBICTO:
            p.curveTo(
                _coordinate[c],
                _coordinate[c + 1],
                _coordinate[c + 2],
                _coordinate[c + 3],
                _coordinate[c + 4],
                _coordinate[c + 5]);
            c += 6;
            break;
        }
      }

      _path = p;
    }

    return _path;
  }
Example #12
0
 private GeneralPath getGeneralPath(Shape shape) {
   GeneralPath gp = new GeneralPath();
   for (PointFormat pf : shape.getDrawCmds()) {
     if (PointType.MOVE.equals(pf.getPointType())) {
       gp.moveTo(pf.getPosX1(), pf.getPosY1());
     } else if (PointType.LINE.equals(pf.getPointType())) {
       gp.lineTo(pf.getPosX1(), pf.getPosY1());
     } else if (PointType.QUAD.equals(pf.getPointType())) {
       gp.quadTo(pf.getPosX1(), pf.getPosY1(), pf.getPosX2(), pf.getPosY2());
     } else if (PointType.CURVE.equals(pf.getPointType())) {
       gp.curveTo(
           pf.getPosX1(),
           pf.getPosY1(),
           pf.getPosX2(),
           pf.getPosY2(),
           pf.getPosX3(),
           pf.getPosY3());
     }
   }
   return gp;
 }
Example #13
0
  @Override
  public void readConstructorParams(DataInput in) throws IOException {
    super.readConstructorParams(in);

    String fontName = in.readUTF();
    int style = in.readInt();
    int size = in.readInt();
    font = new Font(fontName, style, size);

    tesselationTolerance = in.readDouble();

    GeneralPath shape = null;
    int segType = in.readInt();
    while (segType != Integer.MIN_VALUE) {
      if (shape == null) shape = new GeneralPath();

      if (segType == PathIterator.SEG_MOVETO) {
        shape.moveTo(in.readFloat(), in.readFloat());
      } else if (segType == PathIterator.SEG_LINETO) {
        shape.lineTo(in.readFloat(), in.readFloat());
      } else if (segType == PathIterator.SEG_QUADTO) {
        shape.quadTo(in.readFloat(), in.readFloat(), in.readFloat(), in.readFloat());
      } else if (segType == PathIterator.SEG_CUBICTO) {
        shape.curveTo(
            in.readFloat(),
            in.readFloat(),
            in.readFloat(),
            in.readFloat(),
            in.readFloat(),
            in.readFloat());
      } else if (segType == PathIterator.SEG_CLOSE) {
        shape.closePath();
      }

      segType = in.readInt();
    }
    if (shape != null) extrudePath = new FontExtrusion(shape, in.readDouble());
    else extrudePath = null;
  }
Example #14
0
  private void loadWorld() throws IOException, XMLStreamException {
    Source source;
    warning("openingg " + svgMapUri);
    if (IOUtils.isRemoteURI(svgMapUri)) {
      source = new StreamSource(svgMapUri);
    } else {
      source = new StreamSource(new File(svgMapUri));
    }

    XMLInputFactory xif = XMLInputFactory.newFactory();
    XMLEventReader xef = xif.createXMLEventReader(source);
    while (xef.hasNext()) {
      XMLEvent evt = xef.nextEvent();
      if (!evt.isStartElement()) {
        continue;
      }
      StartElement E = evt.asStartElement();
      String localName = E.getName().getLocalPart();
      if (!localName.equals("path")) continue;
      Attribute att = E.getAttributeByName(new QName("id"));
      if (att == null) continue;
      String country = att.getValue().toLowerCase().replaceAll("[ ]+", "");
      att = E.getAttributeByName(new QName("d"));
      if (att == null) continue;
      GeneralPath path = null;
      char op = '\0';
      Scanner scanner = new Scanner(att.getValue().replaceAll("[ \t\n\r,]+", " "));
      path = new GeneralPath();

      while (scanner.hasNext()) {
        if (op == '\0') {
          op = scanner.next().charAt(0);
        }
        switch (op) {
          case 'M':
            path.moveTo(scanner.nextDouble(), scanner.nextDouble());
            break;
          case 'C':
            path.curveTo(
                scanner.nextDouble(),
                scanner.nextDouble(),
                scanner.nextDouble(),
                scanner.nextDouble(),
                scanner.nextDouble(),
                scanner.nextDouble());
            break;
          case 'Z':
            {
              path.closePath();

              break;
            }
          default:
            throw new IOException("bad operator " + op);
        }
        if (scanner.hasNext("[MCZ]")) {
          op = scanner.next().charAt(0);
        }
      }
      scanner.close();
      this.country2shape.put(country, scaleWorld(path));
    }
    xef.close();
  }
Example #15
0
  /**
   * if the edge is reflexive its painted as a cyclic edge if there are 2 controlpoints the
   * connection is painted as a straight line from the source to the targetanchor if there are more
   * as 2 controlpoints the connection path between 2 control points is painted as bezier curve
   */
  @Override
  protected void paintWidget() {

    List<Point> contrPoints = this.getControlPoints();
    int listSize = contrPoints.size();

    Graphics2D gr = getGraphics();

    if (listSize <= 2) {
      if (isReflexive()) { // special case for reflexive connection widgets
        Widget related = this.getTargetAnchor().getRelatedWidget();
        int position = this.edgeBalance(related);
        Rectangle bounds = related.convertLocalToScene(related.getBounds());
        gr.setColor(getLineColor());
        Point first = new Point();
        Point last = new Point();
        double centerX = bounds.getCenterX();
        first.x = (int) (centerX + bounds.width / 4);
        first.y = bounds.y + bounds.height;
        last.x = first.x;
        last.y = bounds.y;

        gr.setStroke(this.getStroke());

        double cutDistance = this.getTargetAnchorShape().getCutDistance();
        double anchorAngle = Math.PI / -3.0;
        double cutX = Math.abs(Math.cos(anchorAngle) * cutDistance);
        double cutY = Math.abs(Math.sin(anchorAngle) * cutDistance);
        int ydiff = first.y - last.y;
        int endy = -ydiff;
        double height = bounds.getHeight();
        double cy = height / 4.0;
        double cx = bounds.getWidth() / 5.0;
        double dcx = cx * 2;
        GeneralPath gp = new GeneralPath();
        gp.moveTo(0, 0);
        gp.quadTo(0, cy, cx, cy);
        gp.quadTo(dcx, cy, dcx, -height / 2.0);
        gp.quadTo(dcx, endy - cy, cy, -(cy + ydiff));
        gp.quadTo(cutX * 1.5, endy - cy, cutX, endy - cutY);

        AffineTransform af = new AffineTransform();
        AnchorShape anchorShape = this.getTargetAnchorShape();

        if (position < 0) {
          first.x = (int) (centerX - bounds.width / 4);
          af.translate(first.x, first.y);
          af.scale(-1.0, 1.0);
          last.x = first.x;
        } else {
          af.translate(first.x, first.y);
        }
        Shape s = gp.createTransformedShape(af);
        gr.draw(s);

        if (last != null) {
          AffineTransform previousTransform = gr.getTransform();
          gr.translate(last.x, last.y);

          if (position < 0) gr.rotate(Math.PI - anchorAngle);
          else gr.rotate(anchorAngle);

          anchorShape.paint(gr, false);
          gr.setTransform(previousTransform);
        }

      } else {
        super.paintWidget();
      }
      return;
    }

    // bezier curve...
    GeneralPath curvePath = new GeneralPath();
    Point lastControlPoint = null;
    double lastControlPointRotation = 0.0;

    Point prev = null;
    for (int i = 0; i < listSize - 1; i++) {
      Point cur = contrPoints.get(i);
      Point next = contrPoints.get(i + 1);
      Point nextnext = null;
      if (i < listSize - 2) {
        nextnext = contrPoints.get(i + 2);
      }

      double len = cur.distance(next);
      double scale = len * BEZIER_SCALE;
      Point bezierFrom = null; // first ControlPoint
      Point bezierTo = null; // second ControlPoint

      if (prev == null) {
        // first point
        curvePath.moveTo(cur.x, cur.y); // startpoint
        bezierFrom = cur;
      } else {
        bezierFrom = new Point(next.x - prev.x, next.y - prev.y);
        bezierFrom = scaleVector(bezierFrom, scale);
        bezierFrom.translate(cur.x, cur.y);
      }

      if (nextnext == null) { // next== last point (curve to)
        lastControlPoint = next;
        bezierTo = next; // set 2nd intermediate point to endpoint
        GeneralPath lastseg = this.subdivide(cur, bezierFrom, bezierTo, next);
        if (lastseg != null) curvePath.append(lastseg, true);
        break;
      } else {
        bezierTo = new Point(cur.x - nextnext.x, cur.y - nextnext.y);
        bezierTo = scaleVector(bezierTo, scale);
        bezierTo.translate(next.x, next.y);
      }

      curvePath.curveTo(
          bezierFrom.x, bezierFrom.y, // controlPoint1
          bezierTo.x, bezierTo.y, // controlPoint2
          next.x, next.y);
      prev = cur;
    }
    Point2D cur = curvePath.getCurrentPoint();
    Point next = lastControlPoint;

    lastControlPointRotation = // anchor anchorAngle
        Math.atan2(cur.getY() - next.y, cur.getX() - next.x);

    Color previousColor = gr.getColor();
    gr.setColor(getLineColor());
    Stroke s = this.getStroke();
    gr.setStroke(s);
    gr.setColor(this.getLineColor());
    gr.draw(curvePath);

    AffineTransform previousTransform = gr.getTransform();
    gr.translate(lastControlPoint.x, lastControlPoint.y);
    gr.rotate(lastControlPointRotation);
    AnchorShape targetAnchorShape = this.getTargetAnchorShape();
    targetAnchorShape.paint(gr, false);
    gr.setTransform(previousTransform);

    // paint ControlPoints if enabled
    if (isPaintControlPoints()) {
      int last = listSize - 1;
      for (int index = 0; index <= last; index++) {
        Point point = contrPoints.get(index);
        previousTransform = gr.getTransform();
        gr.translate(point.x, point.y);
        if (index == 0 || index == last) getEndPointShape().paint(gr);
        else getControlPointShape().paint(gr);
        gr.setTransform(previousTransform);
      }
    }
    gr.setColor(previousColor);
  }
  private BufferedImage create_SMALL_POINTER_SHADOW_Image(final int WIDTH) {
    if (WIDTH <= 0) {
      return null;
    }

    final BufferedImage IMAGE = UTIL.createImage(WIDTH, WIDTH, Transparency.TRANSLUCENT);
    final Graphics2D G2 = IMAGE.createGraphics();
    G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

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

    final GeneralPath STOPWATCHPOINTERSMALL = new GeneralPath();
    STOPWATCHPOINTERSMALL.setWindingRule(Path2D.WIND_EVEN_ODD);
    STOPWATCHPOINTERSMALL.moveTo(
        IMAGE_WIDTH * 0.4766355140186916, IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.32242990654205606,
        IMAGE_WIDTH * 0.48598130841121495,
        IMAGE_HEIGHT * 0.3317757009345794,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.3364485981308411);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.3364485981308411,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.35046728971962615,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.35046728971962615);
    STOPWATCHPOINTERSMALL.lineTo(
        IMAGE_WIDTH * 0.5046728971962616, IMAGE_HEIGHT * 0.35046728971962615);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.35046728971962615,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.3364485981308411,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.3364485981308411);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.514018691588785,
        IMAGE_HEIGHT * 0.3317757009345794,
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.32242990654205606,
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.3037383177570093,
        IMAGE_WIDTH * 0.514018691588785,
        IMAGE_HEIGHT * 0.29439252336448596,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.2897196261682243);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.2897196261682243,
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233,
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.2897196261682243,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.2897196261682243);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.48598130841121495,
        IMAGE_HEIGHT * 0.29439252336448596,
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.3037383177570093,
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.closePath();

    G2.setPaint(SHADOW_COLOR);
    G2.fill(STOPWATCHPOINTERSMALL);

    G2.dispose();

    return IMAGE;
  }
Example #17
0
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;

    float origAlpha = 1.0f;
    Composite origComposite = ((Graphics2D) g).getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    AffineTransform defaultTransform_ = g.getTransform();
    //
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0
    g.setComposite(AlphaComposite.getInstance(3, 0.14117648f * origAlpha));
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            1.4897359609603882f,
            0.0f,
            0.0f,
            -1.0012520551681519f,
            -12.647159576416016f,
            75.3125991821289f));
    // _0_0_0
    paint =
        new RadialGradientPaint(
            new Point2D.Double(24.837125778198242, 36.42112731933594),
            15.644737f,
            new Point2D.Double(24.837125778198242, 36.42112731933594),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0f,
                0.0f,
                0.0f,
                0.5367230176925659f,
                -5.825328826085385E-14f,
                16.87306022644043f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(40.48186, 36.421127);
    ((GeneralPath) shape).curveTo(40.483814, 39.421745, 37.50237, 42.19488, 32.66107, 43.69549);
    ((GeneralPath) shape).curveTo(27.81977, 45.196106, 21.854479, 45.196106, 17.01318, 43.69549);
    ((GeneralPath) shape).curveTo(12.17188, 42.19488, 9.190436, 39.421745, 9.192389, 36.421127);
    ((GeneralPath) shape).curveTo(9.190436, 33.42051, 12.17188, 30.647373, 17.01318, 29.14676);
    ((GeneralPath) shape).curveTo(21.854479, 27.646149, 27.81977, 27.646149, 32.66107, 29.14676);
    ((GeneralPath) shape).curveTo(37.50237, 30.647373, 40.483814, 33.42051, 40.48186, 36.421127);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(33.0, 35.75),
            new Point2D.Double(31.5, 42.5),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(128, 11, 176, 255), new Color(138, 11, 176, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(38.37476, 45.03437);
    ((GeneralPath) shape).curveTo(-1.6510485, 46.35551, 4.6747956, 12.29355, 25.49479, 12.49765);
    ((GeneralPath) shape).lineTo(25.49479, 3.1222396);
    ((GeneralPath) shape).lineTo(42.143272, 17.708818);
    ((GeneralPath) shape).lineTo(25.49479, 33.006348);
    ((GeneralPath) shape).curveTo(25.49479, 33.006348, 25.49479, 23.337969, 25.49479, 23.337969);
    ((GeneralPath) shape).curveTo(11.43168, 22.751999, 7.3172617, 44.77055, 38.37476, 45.03437);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(33.0, 35.75),
            new Point2D.Double(31.5, 42.5),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(109, 0, 134, 255), new Color(116, 0, 134, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0000001f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(38.37476, 45.03437);
    ((GeneralPath) shape).curveTo(-1.6510485, 46.35551, 4.6747956, 12.29355, 25.49479, 12.49765);
    ((GeneralPath) shape).lineTo(25.49479, 3.1222396);
    ((GeneralPath) shape).lineTo(42.143272, 17.708818);
    ((GeneralPath) shape).lineTo(25.49479, 33.006348);
    ((GeneralPath) shape).curveTo(25.49479, 33.006348, 25.49479, 23.337969, 25.49479, 23.337969);
    ((GeneralPath) shape).curveTo(11.43168, 22.751999, 7.3172617, 44.77055, 38.37476, 45.03437);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 0.6988636f * origAlpha));
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2
    paint =
        new LinearGradientPaint(
            new Point2D.Double(17.060806274414062, 11.39501953125),
            new Point2D.Double(12.624337196350098, 12.583768844604492),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.8134709379429573E-16f,
                -1.1719260215759277f,
                1.1719260215759277f,
                1.8134709379429573E-16f,
                1.7828010320663452f,
                54.10110855102539f));
    stroke = new BasicStroke(0.9999997f, 0, 0, 10.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(16.92492, 39.315517);
    ((GeneralPath) shape).curveTo(5.2018204, 33.235893, 8.737127, 13.087489, 26.5085, 13.549959);
    ((GeneralPath) shape).lineTo(26.5085, 5.4508677);
    ((GeneralPath) shape).curveTo(26.5085, 5.4508677, 40.556236, 17.714588, 40.556236, 17.714588);
    ((GeneralPath) shape).lineTo(26.5085, 30.658617);
    ((GeneralPath) shape).curveTo(26.5085, 30.658617, 26.5085, 22.38098, 26.5085, 22.38098);
    ((GeneralPath) shape).curveTo(11.66865, 22.03271, 12.34859, 35.13858, 16.92492, 39.315517);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_2);
    g.setComposite(AlphaComposite.getInstance(3, 0.49431816f * origAlpha));
    AffineTransform defaultTransform__0_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_3
    paint =
        new RadialGradientPaint(
            new Point2D.Double(16.5638370513916, 11.132235527038574),
            19.0625f,
            new Point2D.Double(16.5638370513916, 11.132235527038574),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                -0.01290126983076334f,
                1.6851969957351685f,
                1.713081955909729f,
                0.013114750385284424f,
                -1.0414990186691284f,
                -10.115710258483887f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(26.03699, 4.5686097);
    ((GeneralPath) shape).lineTo(36.72373, 14.798241);
    ((GeneralPath) shape).curveTo(29.786226, 14.79824, 32.036987, 23.735424, 25.91199, 26.610424);
    ((GeneralPath) shape).lineTo(25.97449, 22.94361);
    ((GeneralPath) shape).curveTo(10.786989, 22.88111, 11.661989, 38.443607, 22.72449, 42.693607);
    ((GeneralPath) shape).curveTo(3.6363413, 37.81168, 6.28699, 13.381109, 25.91199, 12.88111);
    ((GeneralPath) shape).lineTo(26.03699, 4.5686097);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_3);
    g.setTransform(defaultTransform__0_0);
    g.setTransform(defaultTransform__0);
    g.setTransform(defaultTransform_);
  }
Example #18
0
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public static void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;
    Area clip = null;

    float origAlpha = 1.0f;
    Composite origComposite = g.getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    Shape clip_ = g.getClip();
    AffineTransform defaultTransform_ = g.getTransform();
    //  is CompositeGraphicsNode
    float alpha__0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0 = g.getClip();
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    clip = new Area(g.getClip());
    clip.intersect(new Area(new Rectangle2D.Double(0.0, 0.0, 48.0, 48.0)));
    g.setClip(clip);
    // _0 is CompositeGraphicsNode
    float alpha__0_0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0 = g.getClip();
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0 is CompositeGraphicsNode
    float alpha__0_0_0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0 = g.getClip();
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0 is ShapeNode
    paint = new Color(117, 161, 208, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(27.514357, 37.542683);
    ((GeneralPath) shape).lineTo(27.514357, 28.515722);
    ((GeneralPath) shape).lineTo(37.49282, 28.475542);
    ((GeneralPath) shape).lineTo(37.49282, 21.480219);
    ((GeneralPath) shape).lineTo(27.523285, 21.480219);
    ((GeneralPath) shape).lineTo(27.514357, 11.520049);
    ((GeneralPath) shape).lineTo(20.498081, 11.53121);
    ((GeneralPath) shape).lineTo(20.502546, 21.462362);
    ((GeneralPath) shape).lineTo(10.51292, 21.536022);
    ((GeneralPath) shape).lineTo(10.477206, 28.50456);
    ((GeneralPath) shape).lineTo(20.511475, 28.475542);
    ((GeneralPath) shape).lineTo(20.518171, 37.515896);
    ((GeneralPath) shape).lineTo(27.514357, 37.542683);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(52, 101, 164, 255);
    stroke = new BasicStroke(1.0000004f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(27.514357, 37.542683);
    ((GeneralPath) shape).lineTo(27.514357, 28.515722);
    ((GeneralPath) shape).lineTo(37.49282, 28.475542);
    ((GeneralPath) shape).lineTo(37.49282, 21.480219);
    ((GeneralPath) shape).lineTo(27.523285, 21.480219);
    ((GeneralPath) shape).lineTo(27.514357, 11.520049);
    ((GeneralPath) shape).lineTo(20.498081, 11.53121);
    ((GeneralPath) shape).lineTo(20.502546, 21.462362);
    ((GeneralPath) shape).lineTo(10.51292, 21.536022);
    ((GeneralPath) shape).lineTo(10.477206, 28.50456);
    ((GeneralPath) shape).lineTo(20.511475, 28.475542);
    ((GeneralPath) shape).lineTo(20.518171, 37.515896);
    ((GeneralPath) shape).lineTo(27.514357, 37.542683);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0;
    g.setTransform(defaultTransform__0_0_0);
    g.setClip(clip__0_0_0);
    float alpha__0_0_1 = origAlpha;
    origAlpha = origAlpha * 0.40860215f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_1 = g.getClip();
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(34.89284896850586, 36.42298889160156),
            new Point2D.Double(45.918697357177734, 48.54798889160156),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(114, 159, 207, 255), new Color(81, 135, 214, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0f, 0.0f, 0.0f, 1.0f, -18.017850875854492f, -13.571189880371094f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(26.498701, 36.53392);
    ((GeneralPath) shape).lineTo(26.498701, 27.499739);
    ((GeneralPath) shape).lineTo(36.501305, 27.499739);
    ((GeneralPath) shape).lineTo(36.494606, 22.47531);
    ((GeneralPath) shape).lineTo(26.50763, 22.47531);
    ((GeneralPath) shape).lineTo(26.50763, 12.480335);
    ((GeneralPath) shape).lineTo(21.512796, 12.498193);
    ((GeneralPath) shape).lineTo(21.521725, 22.47531);
    ((GeneralPath) shape).lineTo(11.495536, 22.493166);
    ((GeneralPath) shape).lineTo(11.46875, 27.466255);
    ((GeneralPath) shape).lineTo(21.533142, 27.475185);
    ((GeneralPath) shape).lineTo(21.51975, 36.50267);
    ((GeneralPath) shape).lineTo(26.498701, 36.53392);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(16.874998092651367, 22.85179901123047),
            new Point2D.Double(27.900846481323242, 34.97679901123047),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 87)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0000006f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(26.498701, 36.53392);
    ((GeneralPath) shape).lineTo(26.498701, 27.499739);
    ((GeneralPath) shape).lineTo(36.501305, 27.499739);
    ((GeneralPath) shape).lineTo(36.494606, 22.47531);
    ((GeneralPath) shape).lineTo(26.50763, 22.47531);
    ((GeneralPath) shape).lineTo(26.50763, 12.480335);
    ((GeneralPath) shape).lineTo(21.512796, 12.498193);
    ((GeneralPath) shape).lineTo(21.521725, 22.47531);
    ((GeneralPath) shape).lineTo(11.495536, 22.493166);
    ((GeneralPath) shape).lineTo(11.46875, 27.466255);
    ((GeneralPath) shape).lineTo(21.533142, 27.475185);
    ((GeneralPath) shape).lineTo(21.51975, 36.50267);
    ((GeneralPath) shape).lineTo(26.498701, 36.53392);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_1;
    g.setTransform(defaultTransform__0_0_1);
    g.setClip(clip__0_0_1);
    float alpha__0_0_2 = origAlpha;
    origAlpha = origAlpha * 0.31182796f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_2 = g.getClip();
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2 is ShapeNode
    paint = new Color(255, 255, 255, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(11.0, 25.0);
    ((GeneralPath) shape).curveTo(11.0, 26.9375, 36.984375, 24.03125, 36.984375, 24.96875);
    ((GeneralPath) shape).lineTo(36.984375, 21.96875);
    ((GeneralPath) shape).lineTo(27.0, 22.0);
    ((GeneralPath) shape).lineTo(27.0, 12.034772);
    ((GeneralPath) shape).lineTo(21.0, 12.034772);
    ((GeneralPath) shape).lineTo(21.0, 22.0);
    ((GeneralPath) shape).lineTo(11.0, 22.0);
    ((GeneralPath) shape).lineTo(11.0, 25.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_2;
    g.setTransform(defaultTransform__0_0_2);
    g.setClip(clip__0_0_2);
    origAlpha = alpha__0_0;
    g.setTransform(defaultTransform__0_0);
    g.setClip(clip__0_0);
    origAlpha = alpha__0;
    g.setTransform(defaultTransform__0);
    g.setClip(clip__0);
    g.setTransform(defaultTransform_);
    g.setClip(clip_);
  }
  /** create the actual shape */
  @Override
  public void createPaths(
      final int[] pX,
      final int[] pY,
      final boolean[] onCurve,
      final boolean[] endOfContour,
      final int endIndex) {

    // allow for bum data
    if (endOfContour == null) {
      return;
    }

    /*
     * scan data and adjust glyfs after first if do not end in contour
     */

    final int ptCount = endOfContour.length;

    int start = 0, firstPt = -1;
    for (int ii = 0; ii < ptCount; ii++) {

      if (endOfContour[ii]) {

        if (firstPt != -1
            && (!onCurve[start]
                || !onCurve[ii])) { // last point not on curve and we have a first point

          final int diff = firstPt - start;
          int newPos;

          // make a deep copy of values
          final int pXlength = pX.length;
          final int[] old_pX = new int[pXlength];
          System.arraycopy(pX, 0, old_pX, 0, pXlength);

          final int[] old_pY = new int[pXlength];
          System.arraycopy(pY, 0, old_pY, 0, pXlength);

          final boolean[] old_onCurve = new boolean[pXlength];
          System.arraycopy(onCurve, 0, old_onCurve, 0, pXlength);

          // rotate values to ensure point at start
          for (int oldPos = start; oldPos < ii + 1; oldPos++) {

            newPos = oldPos + diff;
            if (newPos > ii) {
              newPos -= (ii - start + 1);
            }
            pX[oldPos] = old_pX[newPos];
            pY[oldPos] = old_pY[newPos];
            onCurve[oldPos] = old_onCurve[newPos];
          }
        }

        // reset values
        start = ii + 1;
        firstPt = -1;

      } else if (onCurve[ii] && firstPt == -1) { // track first point
        firstPt = ii;
      }
    }

    boolean isFirstDraw = true;

    final GeneralPath current_path = new GeneralPath(GeneralPath.WIND_NON_ZERO);

    final int c = pX.length;
    int fc = -1;

    // find first end contour
    for (int jj = 0; jj < c; jj++) {
      if (endOfContour[jj]) {
        fc = jj + 1;
        jj = c;
      }
    }

    int x1, y1, x2 = 0, y2 = 0, x3 = 0, y3 = 0;

    x1 = pX[0];
    y1 = pY[0];

    if (debug) {
      System.out.println(pX[0] + " " + pY[0] + " move to x1,y1=" + x1 + ' ' + y1);
    }

    current_path.moveTo(x1, y1);

    if (debug) {
      System.out.println(
          "first contour=" + fc + "====================================" + pX[0] + ' ' + pY[0]);
      // System.out.println("start="+x1+ ' ' +y1+" unitsPerEm="+unitsPerEm);
      // for (int i = 0; i <c-2; i++)
      // System.out.println(i+" "+convertX(pX[i],pY[i])+ ' ' +convertY(pX[i],pY[i])+ ' '
      // +onCurve[i]+ ' ' +endOfContour[i]+" raw="+pX[i]+ ' ' +pY[i]);

      // System.out.println("Move to "+x1+ ' ' +y1);

    }

    int xs = 0, ys = 0, lc = 0;
    boolean isEnd = false;

    for (int j = 0; j < endIndex; j++) {

      final int p = j % fc;
      int p1 = (j + 1) % fc;
      int p2 = (j + 2) % fc;
      int pm1 = (j - 1) % fc;

      /* special cases
       *
       *round up to last point at end
       *First point
       */
      if (j == 0) {
        pm1 = fc - 1;
      }
      if (p1 < lc) {
        p1 += lc;
      }
      if (p2 < lc) {
        p2 += lc;
      }

      if (debug) {
        System.out.println(
            "points="
                + lc
                + '/'
                + fc
                + ' '
                + pm1
                + ' '
                + p
                + ' '
                + p1
                + ' '
                + p2
                + " j="
                + j
                + " endOfContour[j]="
                + endOfContour[j]);
      }

      // allow for wrap around on contour
      if (endOfContour[j]) {
        isEnd = true;

        if (onCurve[fc]) {
          xs = pX[fc];
          ys = pY[fc];
        } else {
          xs = pX[j + 1];
          ys = pY[j + 1];
        }

        // remember start point
        lc = fc;
        // find next contour
        for (int jj = j + 1; jj < c; jj++) {
          if (endOfContour[jj]) {
            fc = jj + 1;
            jj = c;
          }
        }

        if (debug) {
          System.out.println("End of contour. next=" + j + ' ' + fc + ' ' + lc);
        }
      }

      if (debug) {
        if (j > 0) {
          System.out.println(
              "curves="
                  + onCurve[p]
                  + ' '
                  + onCurve[p1]
                  + ' '
                  + onCurve[p2]
                  + " EndOfContour j-1="
                  + endOfContour[j - 1]
                  + " j="
                  + endOfContour[j]
                  + " j+1="
                  + endOfContour[j + 1]);
        } else {
          System.out.println(
              "curves="
                  + onCurve[p]
                  + ' '
                  + onCurve[p1]
                  + ' '
                  + onCurve[p2]
                  + " EndOfContour j="
                  + endOfContour[j]
                  + " j+1="
                  + endOfContour[j + 1]);
        }
      }

      if (lc == fc && onCurve[p]) {
        j = c;
        if (debug) {
          System.out.println("last 2 match");
        }
      } else {

        if (debug) {
          System.out.println(fc + " " + pm1 + ' ' + p + ' ' + p1 + ' ' + p2);
        }

        if (onCurve[p] && onCurve[p1]) { // straight line
          x3 = pX[p1];
          y3 = pY[p1];
          current_path.lineTo(x3, y3);
          if (debug) {
            System.out.println(p + " pt,pt " + x3 + ' ' + y3 + " (lineTo)");
          }

          isFirstDraw = false;
          // curves
        } else if (j < (c - 3) && ((fc - lc) > 1 || fc == lc)) {
          boolean checkEnd = false;
          if (onCurve[p] && !onCurve[p1] && onCurve[p2]) { // 2 points + control

            x1 = pX[p];
            y1 = pY[p];
            x2 = pX[p1];
            y2 = pY[p1];
            x3 = pX[p2];
            y3 = pY[p2];
            j++;
            checkEnd = true;
            if (debug) {
              System.out.println(
                  p + " pt,cv,pt " + x1 + ' ' + y1 + ' ' + x2 + ' ' + y2 + ' ' + x3 + ' ' + y3);
            }

          } else if (onCurve[p] && !onCurve[p1] && !onCurve[p2]) { // 1 point + 2 control

            x1 = pX[p];
            y1 = pY[p];
            x2 = pX[p1];
            y2 = pY[p1];
            x3 = midPt(pX[p1], pX[p2]);
            y3 = midPt(pY[p1], pY[p2]);
            j++;

            checkEnd = true;

            if (debug) {
              System.out.println(
                  p + " pt,cv,cv " + x1 + ' ' + y1 + ' ' + x2 + ' ' + y2 + ' ' + x3 + ' ' + y3);
            }

          } else if (!onCurve[p]
              && !onCurve[p1]
              && (!endOfContour[p2]
                  || fc - p2
                      == 1)) { // 2 control + 1 point (final check allows for last point to complete
            // loop

            x1 = midPt(pX[pm1], pX[p]);
            y1 = midPt(pY[pm1], pY[p]);
            x2 = pX[p];
            y2 = pY[p];

            x3 = midPt(pX[p], pX[p1]);
            y3 = midPt(pY[p], pY[p1]);
            if (debug) {
              System.out.println(
                  p + " cv,cv1 " + x1 + ' ' + y1 + ' ' + x2 + ' ' + y2 + ' ' + x3 + ' ' + y3);
            }

          } else if (!onCurve[p] && onCurve[p1]) { // 1 control + 2 point

            x1 = midPt(pX[pm1], pX[p]);
            y1 = midPt(pY[pm1], pY[p]);
            x2 = pX[p];
            y2 = pY[p];
            x3 = pX[p1];
            y3 = pY[p1];
            if (debug) {
              System.out.println(
                  p + " cv,pt " + x1 + ' ' + y1 + ' ' + x2 + ' ' + y2 + ' ' + x3 + ' ' + y3);
            }
          }

          if (isFirstDraw) {
            current_path.moveTo(x1, y1);
            isFirstDraw = false;

            if (debug) {
              System.out.println("first draw move to " + x1 + ' ' + y1);
            }
          }

          if (!(endOfContour[p] && p > 0 && endOfContour[p - 1])) {
            hasEndCurve = true;
            current_path.curveTo(x1, y1, x2, y2, x3, y3);
          }

          if (debug) {
            System.out.println(
                "curveto " + x1 + ' ' + y1 + ' ' + x2 + ' ' + y2 + ' ' + x3 + ' ' + y3);
          }

          /* if end after curve, roll back so we pick up the end*/
          if (checkEnd && endOfContour[j]) {

            isEnd = true;

            xs = pX[fc];
            ys = pY[fc];
            // remmeber start point
            lc = fc;
            // find next contour
            for (int jj = j + 1; jj < c; jj++) {
              if (endOfContour[jj]) {
                fc = jj + 1;
                jj = c;
              }
            }

            if (debug) {
              System.out.println("Curve");
            }
          }
        }

        if (endOfContour[p]) {
          current_path.closePath();
        }

        if (debug) {
          System.out.println("x2 " + xs + ' ' + ys + ' ' + isEnd);
        }

        if (isEnd) {
          current_path.moveTo(xs, ys);
          isEnd = false;
          if (debug) {
            System.out.println("Move to " + xs + ' ' + ys);
          }
        }

        if (debug) {
          try {
            if (img == null) {
              img =
                  new java.awt.image.BufferedImage(
                      800, 800, java.awt.image.BufferedImage.TYPE_INT_ARGB);
            }

            final Graphics2D g2 = img.createGraphics();
            g2.setColor(java.awt.Color.green);
            g2.draw(current_path);

            final String key = String.valueOf(p);

            org.jpedal.gui.ShowGUIMessage.showGUIMessage(key, img, key);

          } catch (final Exception e) {
            LogWriter.writeLog("Exception: " + e.getMessage());
          }
        }
      }
    }

    /*
     * store so we can draw glyf as set of paths
     */
    paths.addElement(current_path);

    if (debug) {
      System.out.println(
          "Ends at "
              + x1
              + ' '
              + y1
              + " x="
              + minX
              + ','
              + maxX
              + " y="
              + minY
              + ','
              + maxY
              + " glyph x="
              + compMinX
              + ','
              + compMaxX
              + " y="
              + compMinY
              + ','
              + compMaxY);
    }
  }
  private BufferedImage create_SMALL_POINTER_Image(final int WIDTH) {
    if (WIDTH <= 0) {
      return null;
    }

    final BufferedImage IMAGE = UTIL.createImage(WIDTH, WIDTH, Transparency.TRANSLUCENT);
    final Graphics2D G2 = IMAGE.createGraphics();
    G2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    G2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    // G2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
    // RenderingHints.VALUE_STROKE_NORMALIZE);

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

    final GeneralPath STOPWATCHPOINTERSMALL = new GeneralPath();
    STOPWATCHPOINTERSMALL.setWindingRule(Path2D.WIND_EVEN_ODD);
    STOPWATCHPOINTERSMALL.moveTo(
        IMAGE_WIDTH * 0.4766355140186916, IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.32242990654205606,
        IMAGE_WIDTH * 0.48598130841121495,
        IMAGE_HEIGHT * 0.3317757009345794,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.3364485981308411);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.3364485981308411,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.35046728971962615,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.35046728971962615);
    STOPWATCHPOINTERSMALL.lineTo(
        IMAGE_WIDTH * 0.5046728971962616, IMAGE_HEIGHT * 0.35046728971962615);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.35046728971962615,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.3364485981308411,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.3364485981308411);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.514018691588785,
        IMAGE_HEIGHT * 0.3317757009345794,
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.32242990654205606,
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5233644859813084,
        IMAGE_HEIGHT * 0.3037383177570093,
        IMAGE_WIDTH * 0.514018691588785,
        IMAGE_HEIGHT * 0.29439252336448596,
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.2897196261682243);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5046728971962616,
        IMAGE_HEIGHT * 0.2897196261682243,
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233,
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.5,
        IMAGE_HEIGHT * 0.20093457943925233,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.2897196261682243,
        IMAGE_WIDTH * 0.4953271028037383,
        IMAGE_HEIGHT * 0.2897196261682243);
    STOPWATCHPOINTERSMALL.curveTo(
        IMAGE_WIDTH * 0.48598130841121495,
        IMAGE_HEIGHT * 0.29439252336448596,
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.3037383177570093,
        IMAGE_WIDTH * 0.4766355140186916,
        IMAGE_HEIGHT * 0.3130841121495327);
    STOPWATCHPOINTERSMALL.closePath();
    if (flatNeedle) {
      G2.setColor(getPointerColor().MEDIUM);
      G2.fill(STOPWATCHPOINTERSMALL);
    } else {
      final Point2D POINTER_START =
          new Point2D.Double(STOPWATCHPOINTERSMALL.getBounds2D().getMinX(), 0);
      final Point2D POINTER_STOP =
          new Point2D.Double(STOPWATCHPOINTERSMALL.getBounds2D().getMaxX(), 0);
      final float[] POINTER_FRACTIONS = {0.0f, 0.3888888889f, 0.5f, 0.6111111111f, 1.0f};
      final Color[] POINTER_COLORS = {
        getPointerColor().MEDIUM,
        getPointerColor().MEDIUM,
        getPointerColor().LIGHT,
        getPointerColor().MEDIUM,
        getPointerColor().MEDIUM
      };
      final LinearGradientPaint GRADIENT =
          new LinearGradientPaint(POINTER_START, POINTER_STOP, POINTER_FRACTIONS, POINTER_COLORS);
      G2.setPaint(GRADIENT);
      G2.fill(STOPWATCHPOINTERSMALL);
      G2.setPaint(getPointerColor().DARK);
      G2.draw(STOPWATCHPOINTERSMALL);
    }

    final Ellipse2D SWBRASSRINGSMALL =
        new Ellipse2D.Double(
            IMAGE_WIDTH * 0.4813084006309509,
            IMAGE_HEIGHT * 0.29439252614974976,
            IMAGE_WIDTH * 0.037383198738098145,
            IMAGE_HEIGHT * 0.03738316893577576);
    G2.setColor(new Color(0xC48200));
    G2.fill(SWBRASSRINGSMALL);

    final Ellipse2D SWRING1SMALL =
        new Ellipse2D.Double(
            IMAGE_WIDTH * 0.4859813153743744,
            IMAGE_HEIGHT * 0.29906541109085083,
            IMAGE_WIDTH * 0.02803739905357361,
            IMAGE_HEIGHT * 0.02803739905357361);
    G2.setColor(new Color(0x999999));
    G2.fill(SWRING1SMALL);

    final Ellipse2D SWRING1SMALL0 =
        new Ellipse2D.Double(
            IMAGE_WIDTH * 0.49065420031547546,
            IMAGE_HEIGHT * 0.3037383258342743,
            IMAGE_WIDTH * 0.018691569566726685,
            IMAGE_HEIGHT * 0.018691569566726685);
    G2.setColor(Color.BLACK);
    G2.fill(SWRING1SMALL0);

    G2.dispose();

    return IMAGE;
  }
Example #21
0
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public static void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;

    float origAlpha = 1.0f;
    Composite origComposite = ((Graphics2D) g).getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    AffineTransform defaultTransform_ = g.getTransform();
    //
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.021751120686531067f,
            0.0f,
            0.0f,
            0.024932630360126495f,
            42.41048812866211f,
            33.8111686706543f));
    // _0_0
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0
    paint =
        new LinearGradientPaint(
            new Point2D.Double(302.8571472167969, 366.64788818359375),
            new Point2D.Double(302.8571472167969, 609.5050659179688),
            new float[] {0.0f, 0.5f, 1.0f},
            new Color[] {new Color(0, 0, 0, 0), new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1892.178955078125f,
                -872.8853759765625f));
    shape =
        new Rectangle2D.Double(
            -1559.2523193359375, -150.6968536376953, 1339.633544921875, 478.357177734375);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1891.633056640625f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-219.61876, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-219.61876, -150.68037, -219.61876, 327.65042, -219.61876, 327.65042);
    ((GeneralPath) shape).curveTo(-76.74459, 328.55087, 125.78146, 220.48074, 125.78138, 88.45424);
    ((GeneralPath) shape)
        .curveTo(125.78138, -43.572304, -33.655437, -150.68036, -219.61876, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                -2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                112.76229858398438f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-1559.2523, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-1559.2523, -150.68037, -1559.2523, 327.65042, -1559.2523, 327.65042);
    ((GeneralPath) shape)
        .curveTo(-1702.1265, 328.55087, -1904.6525, 220.48074, -1904.6525, 88.45424);
    ((GeneralPath) shape)
        .curveTo(-1904.6525, -43.572304, -1745.2157, -150.68036, -1559.2523, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_2);
    g.setTransform(defaultTransform__0_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(12.487299919128418, 3.7318999767303467),
            new Point2D.Double(31.081300735473633, 36.032798767089844),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(210, 210, 210, 255), new Color(237, 237, 237, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.4340029954910278f,
                0.0f,
                0.0f,
                0.9900869727134705f,
                52.32167053222656f,
                2.8389179706573486f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(2.7177715, 6.454775);
    ((GeneralPath) shape).lineTo(43.379543, 6.454775);
    ((GeneralPath) shape).curveTo(44.002792, 6.454775, 44.504543, 6.956525, 44.504543, 7.5797744);
    ((GeneralPath) shape).lineTo(44.504543, 31.480581);
    ((GeneralPath) shape).curveTo(44.504543, 32.103832, 36.04784, 39.49987, 35.424595, 39.49987);
    ((GeneralPath) shape).lineTo(2.7177715, 39.49987);
    ((GeneralPath) shape).curveTo(2.094522, 39.49987, 1.5927727, 38.998123, 1.5927727, 38.37487);
    ((GeneralPath) shape).lineTo(1.5927727, 7.5797744);
    ((GeneralPath) shape).curveTo(1.5927727, 6.956525, 2.094522, 6.454775, 2.7177715, 6.454775);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(187, 191, 187, 255);
    stroke = new BasicStroke(0.99999994f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(2.7177715, 6.454775);
    ((GeneralPath) shape).lineTo(43.379543, 6.454775);
    ((GeneralPath) shape).curveTo(44.002792, 6.454775, 44.504543, 6.956525, 44.504543, 7.5797744);
    ((GeneralPath) shape).lineTo(44.504543, 31.480581);
    ((GeneralPath) shape).curveTo(44.504543, 32.103832, 36.04784, 39.49987, 35.424595, 39.49987);
    ((GeneralPath) shape).lineTo(2.7177715, 39.49987);
    ((GeneralPath) shape).curveTo(2.094522, 39.49987, 1.5927727, 38.998123, 1.5927727, 38.37487);
    ((GeneralPath) shape).lineTo(1.5927727, 7.5797744);
    ((GeneralPath) shape).curveTo(1.5927727, 6.956525, 2.094522, 6.454775, 2.7177715, 6.454775);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2 = g.getTransform();
    g.transform(
        new AffineTransform(
            1.0547740459442139f,
            0.0f,
            0.0f,
            1.0499889850616455f,
            -0.8146470189094543f,
            4.485012054443359f));
    // _0_2
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_0
    paint =
        new LinearGradientPaint(
            new Point2D.Double(21.932600021362305, 24.627399444580078),
            new Point2D.Double(21.932600021362305, 7.109099864959717),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(133, 149, 188, 255), new Color(4, 26, 59, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0989890098571777f,
                0.0f,
                0.0f,
                -0.7977570295333862f,
                -1.9538650512695312f,
                37.32400131225586f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(5.512695, 30.0);
    ((GeneralPath) shape).lineTo(39.643234, 30.0);
    ((GeneralPath) shape).lineTo(39.643234, 19.627375);
    ((GeneralPath) shape).lineTo(5.512695, 19.627375);
    ((GeneralPath) shape).lineTo(5.512695, 30.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(21.932600021362305, 24.627399444580078),
            new Point2D.Double(21.932600021362305, 7.109099864959717),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(208, 214, 229, 255), new Color(9, 58, 128, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0989890098571777f,
                0.0f,
                0.0f,
                1.1066969633102417f,
                -1.9538650512695312f,
                -4.922452926635742f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(5.512695, 5.237844);
    ((GeneralPath) shape).lineTo(39.643234, 5.237844);
    ((GeneralPath) shape).lineTo(39.643234, 19.627375);
    ((GeneralPath) shape).lineTo(5.512695, 19.627375);
    ((GeneralPath) shape).lineTo(5.512695, 5.237844);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_2 = g.getTransform();
    g.transform(
        new AffineTransform(
            1.1892169713974f,
            0.0f,
            0.0f,
            1.1892169713974f,
            -3.525355100631714f,
            -6.535408020019531f));
    // _0_2_2
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0
    g.setComposite(AlphaComposite.getInstance(3, 0.04999994f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_0
    paint = new Color(232, 245, 47, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(18.4, 15.4);
    ((GeneralPath) shape).curveTo(18.4, 17.6, 16.6, 19.5, 14.3, 19.5);
    ((GeneralPath) shape).curveTo(12.1, 19.5, 10.2, 17.7, 10.2, 15.4);
    ((GeneralPath) shape).curveTo(10.2, 13.2, 12.0, 11.3, 14.3, 11.3);
    ((GeneralPath) shape).curveTo(16.5, 11.3, 18.4, 13.1, 18.4, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 0.20829993f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_1
    paint = new Color(236, 247, 81, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(18.0, 15.4);
    ((GeneralPath) shape).curveTo(18.0, 17.4, 16.4, 19.1, 14.3, 19.1);
    ((GeneralPath) shape).curveTo(12.3, 19.1, 10.6, 17.5, 10.6, 15.4);
    ((GeneralPath) shape).curveTo(10.6, 13.4, 12.2, 11.7, 14.3, 11.7);
    ((GeneralPath) shape).curveTo(16.3, 11.7, 18.0, 13.3, 18.0, 15.4);
    ((GeneralPath) shape).lineTo(18.0, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 0.36669993f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_2
    paint = new Color(240, 249, 114, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(17.6, 15.4);
    ((GeneralPath) shape).curveTo(17.6, 17.2, 16.1, 18.7, 14.3, 18.7);
    ((GeneralPath) shape).curveTo(12.5, 18.7, 11.0, 17.2, 11.0, 15.4);
    ((GeneralPath) shape).curveTo(11.0, 13.6, 12.5, 12.1, 14.3, 12.1);
    ((GeneralPath) shape).curveTo(16.1, 12.1, 17.6, 13.6, 17.6, 15.4);
    ((GeneralPath) shape).lineTo(17.6, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_2);
    g.setComposite(AlphaComposite.getInstance(3, 0.525f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_3
    paint = new Color(244, 250, 149, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(17.2, 15.4);
    ((GeneralPath) shape).curveTo(17.2, 17.0, 15.9, 18.3, 14.3, 18.3);
    ((GeneralPath) shape).curveTo(12.7, 18.3, 11.4, 17.0, 11.4, 15.4);
    ((GeneralPath) shape).curveTo(11.4, 13.8, 12.7, 12.5, 14.3, 12.5);
    ((GeneralPath) shape).curveTo(15.9, 12.5, 17.2, 13.8, 17.2, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_3);
    g.setComposite(AlphaComposite.getInstance(3, 0.6833f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_4
    paint = new Color(247, 252, 183, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(16.8, 15.4);
    ((GeneralPath) shape).curveTo(16.8, 16.8, 15.7, 17.9, 14.3, 17.9);
    ((GeneralPath) shape).curveTo(12.9, 17.9, 11.8, 16.8, 11.8, 15.4);
    ((GeneralPath) shape).curveTo(11.8, 14.0, 12.9, 12.9, 14.3, 12.9);
    ((GeneralPath) shape).curveTo(15.7, 12.9, 16.8, 14.0, 16.8, 15.4);
    ((GeneralPath) shape).lineTo(16.8, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_4);
    g.setComposite(AlphaComposite.getInstance(3, 0.8417f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_5
    paint = new Color(251, 253, 219, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(16.4, 15.4);
    ((GeneralPath) shape).curveTo(16.4, 16.6, 15.4, 17.5, 14.3, 17.5);
    ((GeneralPath) shape).curveTo(13.2, 17.5, 12.2, 16.5, 12.2, 15.4);
    ((GeneralPath) shape).curveTo(12.2, 14.3, 13.2, 13.3, 14.3, 13.3);
    ((GeneralPath) shape).curveTo(15.4, 13.3, 16.4, 14.3, 16.4, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_5);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_2_0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_2_0_6
    paint = new Color(255, 255, 255, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(16.0, 15.4);
    ((GeneralPath) shape).curveTo(16.0, 16.4, 15.2, 17.2, 14.2, 17.2);
    ((GeneralPath) shape).curveTo(13.2, 17.2, 12.4, 16.4, 12.4, 15.4);
    ((GeneralPath) shape).curveTo(12.4, 14.4, 13.2, 13.6, 14.2, 13.6);
    ((GeneralPath) shape).curveTo(15.2, 13.6, 16.0, 14.4, 16.0, 15.4);
    ((GeneralPath) shape).lineTo(16.0, 15.4);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_2_0_6);
    g.setTransform(defaultTransform__0_2_2_0);
    g.setTransform(defaultTransform__0_2_2);
    g.setComposite(AlphaComposite.getInstance(3, 0.3f * origAlpha));
    AffineTransform defaultTransform__0_2_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_3
    paint = new Color(0, 0, 0, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(25.01586, 21.649044);
    ((GeneralPath) shape).lineTo(33.697147, 21.649044);
    ((GeneralPath) shape).lineTo(35.362053, 22.124731);
    ((GeneralPath) shape).lineTo(32.50793, 22.124731);
    ((GeneralPath) shape).curveTo(32.50793, 22.124731, 35.362053, 22.362574, 36.789116, 24.1464);
    ((GeneralPath) shape).curveTo(38.216175, 25.811304, 35.12421, 27.832975, 35.12421, 27.832975);
    ((GeneralPath) shape).curveTo(35.12421, 27.832975, 35.12421, 27.832975, 35.12421, 27.832975);
    ((GeneralPath) shape).curveTo(35.005287, 27.47621, 34.291756, 24.622087, 32.864697, 23.43287);
    ((GeneralPath) shape).curveTo(31.7944, 22.481497, 30.605183, 22.243652, 30.605183, 22.243652);
    ((GeneralPath) shape).lineTo(25.01586, 22.243652);
    ((GeneralPath) shape).lineTo(25.01586, 21.767965);
    ((GeneralPath) shape).lineTo(25.01586, 21.649044);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_3);
    g.setComposite(AlphaComposite.getInstance(3, 0.3f * origAlpha));
    AffineTransform defaultTransform__0_2_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_4
    paint = new Color(0, 0, 0, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(30.724106, 22.362574);
    ((GeneralPath) shape).lineTo(25.729391, 22.362574);
    ((GeneralPath) shape).lineTo(35.005287, 27.59513);
    ((GeneralPath) shape).lineTo(30.724106, 22.362574);
    ((GeneralPath) shape).lineTo(30.724106, 22.362574);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_5
    paint = new Color(81, 81, 81, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(25.01586, 21.767965);
    ((GeneralPath) shape).lineTo(33.697147, 21.767965);
    ((GeneralPath) shape).lineTo(35.005287, 20.935513);
    ((GeneralPath) shape).lineTo(32.15117, 20.935513);
    ((GeneralPath) shape).curveTo(32.15117, 20.935513, 34.767445, 20.459827, 35.12421, 17.486782);
    ((GeneralPath) shape).curveTo(35.480972, 14.513739, 31.08087, 11.183931, 31.08087, 11.183931);
    ((GeneralPath) shape).curveTo(31.08087, 11.183931, 31.08087, 11.183931, 31.08087, 11.302853);
    ((GeneralPath) shape).curveTo(31.19979, 12.016383, 32.389008, 17.011095, 31.556557, 18.913845);
    ((GeneralPath) shape).curveTo(31.19979, 20.578747, 30.129496, 20.935513, 30.129496, 20.935513);
    ((GeneralPath) shape).lineTo(24.659094, 20.935513);
    ((GeneralPath) shape).lineTo(24.896938, 21.767965);
    ((GeneralPath) shape).lineTo(25.01586, 21.767965);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_5);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_2_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_2_6
    paint = new Color(81, 81, 81, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(30.248419, 20.459827);
    ((GeneralPath) shape).lineTo(25.253704, 20.459827);
    ((GeneralPath) shape).lineTo(31.19979, 11.421773);
    ((GeneralPath) shape).lineTo(30.248419, 20.459827);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_2_6);
    g.setTransform(defaultTransform__0_2);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_3
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(0.99999976f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(2.8042316, 7.4528584);
    ((GeneralPath) shape).lineTo(43.233986, 7.4528584);
    ((GeneralPath) shape).curveTo(43.384365, 7.4528584, 43.505432, 7.5739236, 43.505432, 7.7243047);
    ((GeneralPath) shape).lineTo(43.505432, 31.422651);
    ((GeneralPath) shape).curveTo(43.505432, 32.368526, 36.401688, 38.5, 36.251305, 38.5);
    ((GeneralPath) shape).lineTo(2.8042316, 38.5);
    ((GeneralPath) shape).curveTo(2.6538508, 38.5, 2.532786, 38.378937, 2.532786, 38.228554);
    ((GeneralPath) shape).lineTo(2.532786, 7.7243047);
    ((GeneralPath) shape).curveTo(2.532786, 7.5739236, 2.6538508, 7.4528584, 2.8042316, 7.4528584);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_3);
    g.setComposite(AlphaComposite.getInstance(3, 0.84659094f * origAlpha));
    AffineTransform defaultTransform__0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_4
    paint = new Color(79, 79, 79, 255);
    stroke = new BasicStroke(1.0f, 0, 0, 4.0f, null, 0.0f);
    shape = new Rectangle2D.Double(5.5, 10.5, 35.0625, 25.0625);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_5
    paint =
        new LinearGradientPaint(
            new Point2D.Double(35.99658203125, 40.458221435546875),
            new Point2D.Double(33.664920806884766, 37.770721435546875),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(124, 124, 124, 255), new Color(184, 184, 184, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 5.1475701332092285f, -3.034791946411133f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(35.206654, 39.46876);
    ((GeneralPath) shape).curveTo(37.23707, 39.79866, 44.795444, 34.938835, 44.491062, 30.970919);
    ((GeneralPath) shape).curveTo(42.9278, 33.394016, 39.73254, 32.257656, 35.623783, 32.416668);
    ((GeneralPath) shape).curveTo(35.623783, 32.416668, 36.019154, 38.96876, 35.206654, 39.46876);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(42.1875, 31.0),
            new Point2D.Double(45.0, 39.98469161987305),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(187, 189, 186, 255), new Color(112, 116, 110, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0000002f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(35.206654, 39.46876);
    ((GeneralPath) shape).curveTo(37.23707, 39.79866, 44.795444, 34.938835, 44.491062, 30.970919);
    ((GeneralPath) shape).curveTo(42.9278, 33.394016, 39.73254, 32.257656, 35.623783, 32.416668);
    ((GeneralPath) shape).curveTo(35.623783, 32.416668, 36.019154, 38.96876, 35.206654, 39.46876);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_5);
    g.setComposite(AlphaComposite.getInstance(3, 0.36931816f * origAlpha));
    AffineTransform defaultTransform__0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_6
    paint =
        new LinearGradientPaint(
            new Point2D.Double(33.39600372314453, 36.92133331298828),
            new Point2D.Double(34.170047760009766, 38.07038116455078),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 5.1475701332092285f, -3.409791946411133f));
    stroke = new BasicStroke(0.9999998f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(36.65709, 37.27726);
    ((GeneralPath) shape).curveTo(38.026867, 36.593433, 41.08534, 35.130795, 42.38472, 33.24979);
    ((GeneralPath) shape).curveTo(40.788624, 33.929848, 39.43691, 33.45929, 36.682384, 33.440197);
    ((GeneralPath) shape).curveTo(36.682384, 33.440197, 36.844707, 36.502293, 36.65709, 37.27726);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_6);
    g.setComposite(AlphaComposite.getInstance(3, 0.30113637f * origAlpha));
    AffineTransform defaultTransform__0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_7
    paint =
        new RadialGradientPaint(
            new Point2D.Double(12.700490951538086, 10.404875755310059),
            19.96875f,
            new Point2D.Double(12.700490951538086, 10.404875755310059),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.7105309963226318f,
                -5.396358033332207E-24f,
                2.4703449431856023E-24f,
                1.1248489618301392f,
                -11.568329811096191f,
                1.802582025527954f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(3.0625, 8.0);
    ((GeneralPath) shape).lineTo(3.0625, 30.0625);
    ((GeneralPath) shape).curveTo(25.388578, 30.950861, 27.884634, 17.0, 43.0, 17.0);
    ((GeneralPath) shape).lineTo(43.0, 8.0);
    ((GeneralPath) shape).lineTo(3.0625, 8.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_7);
    g.setTransform(defaultTransform__0);
    g.setTransform(defaultTransform_);
  }
Example #22
0
  /**
   * Appends path gp2 to gp1. Taken from pre-redesign code.
   *
   * @param reversed is true if the segments are added in reverse order
   */
  public static void appendPath(GeneralPath gp1, GeneralPath gp2, boolean reversed) {
    ArrayList<Number[]> points =
        new ArrayList<
            Number[]>(); // Each element is an array consisting of one Integer and six Floats

    PathIterator i = gp2.getPathIterator(new AffineTransform());

    float[] segment = new float[] {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};

    float leftmost = Float.POSITIVE_INFINITY;

    while (!i.isDone()) {
      int type = i.currentSegment(segment);
      i.next();

      points.add(
          new Number[] {
            new Integer(type),
            new Float(segment[0]),
            new Float(segment[1]),
            new Float(segment[2]),
            new Float(segment[3]),
            new Float(segment[4]),
            new Float(segment[5])
          });
    }

    if (reversed) {
      float deltaX = (float) gp1.getCurrentPoint().getX();
      float deltaY = (float) gp1.getCurrentPoint().getY();

      Object[] typeAndPoints = points.get(points.size() - 1);

      int type = ((Integer) typeAndPoints[0]).intValue();

      if (type == PathIterator.SEG_LINETO) {
        deltaX -= ((Float) typeAndPoints[1]).floatValue();
        deltaY -= ((Float) typeAndPoints[2]).floatValue();
      } else if (type == PathIterator.SEG_QUADTO) {
        deltaX -= ((Float) typeAndPoints[3]).floatValue();
        deltaY -= ((Float) typeAndPoints[4]).floatValue();
      } else if (type == PathIterator.SEG_CUBICTO) {
        deltaX -= ((Float) typeAndPoints[5]).floatValue();
        deltaY -= ((Float) typeAndPoints[6]).floatValue();
      } else {
        assert false : type;
      }

      for (int j = points.size() - 1; j >= 1; j--) {
        typeAndPoints = points.get(j);

        type = ((Integer) typeAndPoints[0]).intValue();
        float x1 = ((Float) typeAndPoints[1]).floatValue();
        float y1 = ((Float) typeAndPoints[2]).floatValue();
        float x2 = ((Float) typeAndPoints[3]).floatValue();
        float y2 = ((Float) typeAndPoints[4]).floatValue();

        float prevX = 0.0f, prevY = 0.0f;

        int prevType = ((Integer) points.get(j - 1)[0]).intValue();

        if ((prevType == PathIterator.SEG_MOVETO) || (prevType == PathIterator.SEG_LINETO)) {
          prevX = ((Float) points.get(j - 1)[1]).floatValue();
          prevY = ((Float) points.get(j - 1)[2]).floatValue();
        } else if (prevType == PathIterator.SEG_QUADTO) {
          prevX = ((Float) points.get(j - 1)[3]).floatValue();
          prevY = ((Float) points.get(j - 1)[4]).floatValue();
        } else if (prevType == PathIterator.SEG_CUBICTO) {
          prevX = ((Float) points.get(j - 1)[5]).floatValue();
          prevY = ((Float) points.get(j - 1)[6]).floatValue();
        } else {
          assert false : prevType;
        }

        leftmost = Math.min(leftmost, prevX + deltaX);

        if ((type == PathIterator.SEG_MOVETO) || (type == PathIterator.SEG_LINETO)) {
          gp1.lineTo(prevX + deltaX, prevY + deltaY);
        } else if (type == PathIterator.SEG_QUADTO) {
          gp1.quadTo(x1 + deltaX, y1 + deltaY, prevX + deltaX, prevY + deltaY);
        } else if (type == PathIterator.SEG_CUBICTO) {
          gp1.curveTo(
              x2 + deltaX, y2 + deltaY, x1 + deltaX, y1 + deltaY, prevX + deltaX, prevY + deltaY);
        } else {
          assert false : type;
        }
      }
    } else // Not reversed
    {
      float deltaX = (float) gp1.getCurrentPoint().getX() - ((Float) points.get(0)[1]).floatValue();
      float deltaY = (float) gp1.getCurrentPoint().getY() - ((Float) points.get(0)[2]).floatValue();

      for (int j = 1; j < points.size(); j++) {
        Object[] typeAndPoints = points.get(j);

        int type = ((Integer) typeAndPoints[0]).intValue();
        float x1 = ((Float) typeAndPoints[1]).floatValue();
        float y1 = ((Float) typeAndPoints[2]).floatValue();
        float x2 = ((Float) typeAndPoints[3]).floatValue();
        float y2 = ((Float) typeAndPoints[4]).floatValue();
        float x3 = ((Float) typeAndPoints[5]).floatValue();
        float y3 = ((Float) typeAndPoints[6]).floatValue();

        if (type == PathIterator.SEG_MOVETO) {
        } else if (type == PathIterator.SEG_LINETO) {
          gp1.lineTo(x1 + deltaX, y1 + deltaY);

          leftmost = Math.min(leftmost, x1 + deltaX);
        } else if (type == PathIterator.SEG_QUADTO) {
          gp1.quadTo(x1 + deltaX, y1 + deltaY, x2 + deltaX, y2 + deltaY);

          leftmost = Math.min(leftmost, x2 + deltaX);
        } else if (type == PathIterator.SEG_CUBICTO) {
          gp1.curveTo(x1 + deltaX, y1 + deltaY, x2 + deltaX, y2 + deltaY, x3 + deltaX, y3 + deltaY);

          leftmost = Math.min(leftmost, x3 + deltaX);
        } else {
          assert false : type;
        }
      }
    }
  }
Example #23
0
 /** Assumes we are at (x1,y1), the corner point is (x2,y2), and we end at (x3, y3) */
 public static void cornerShape(
     GeneralPath gp, float x1, float y1, float x2, float y2, float x3, float y3) {
   gp.curveTo((x1 + x2) / 2, (y1 + y2) / 2, (x2 + x3) / 2, (y2 + y3) / 2, x3, y3);
 }
Example #24
0
  /**
   * Iscrtava vezu.
   *
   * @param g
   */
  @Override
  public void paint(Graphics2D g) {
    calulatePoints();

    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    g.setStroke(new BasicStroke((float) graphView.sizeToUserSpace(1)));

    if (graphView.getGraphModel().isLinkSelected(link)) {
      g.setColor(SELECTED_LINK_COLOR);
    } else {
      if (link.getColor() == null) {
        g.setColor(LINK_COLOR);
      } else {
        g.setColor(link.getColor());
      }
    }

    GeneralPath path = new GeneralPath();

    /* Pomeramo se u pocetnu tacku */
    path.moveTo(begin.getX(), begin.getY());

    /* Prva Bezierova kriva. */
    path.curveTo(
        bezierCurveCoords.getX(),
        bezierCurveCoords.getY(),
        bezierCurveCoords.getX(),
        bezierCurveCoords.getY(),
        end.getX(),
        end.getY());

    /* Crtanje cele krive. */
    g.draw(path);

    /*
     * Ako je veza neusmerena, na sredini se isctava krug, u protivnom na
     * sredini se izcrtava strelica u pravcu odredisnog cvora.
     */
    if ((!link.isDirected() || (link.getNode1() == link.getNode2()))) {
      g.draw(shape);

      if (graphView.getGraphModel().isLinkSelected(link)) {
        g.setColor(SELECTED_LINK_COLOR);
      } else {
        g.setColor(Color.WHITE);
      }

      g.fill(shape);
    } else {
      g.translate((int) middleCircleCoords.getX(), (int) middleCircleCoords.getY());

      double angle = 0;

      /* Ako veza spaja dva razlicita cvora. */
      double x = link.getNode2().getPosition().getX() - link.getNode1().getPosition().getX();
      double y = link.getNode2().getPosition().getY() - link.getNode1().getPosition().getY();
      angle = Math.atan(x / y);

      if (link.getNode1().getPosition().getY() > link.getNode2().getPosition().getY()) {
        angle = -angle;
      } else {
        angle = Math.PI - angle;
      }

      if (!(Double.isNaN(angle)) && !(Double.isInfinite(angle))) {
        g.rotate(angle);
        g.draw(triangle);
        g.fill(triangle);
        g.rotate(-angle);
        g.translate(-(int) middleCircleCoords.getX(), -(int) middleCircleCoords.getY());
      }
    }

    /*
     * Ako veza ima boju drugacija od default, ispisuje se specijalni
     * atribut veze, ako postoji.
     */
    if (link.getColor() != null) {
      Double specialAttribute = link.getAttribute("special");

      /* Ako specijalni atribut postoji. */
      if (specialAttribute != null) {
        String str = Math.round(specialAttribute) + "";
        g.translate(middleCircleCoords.getX() - 15, middleCircleCoords.getY() - 15);

        g.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, 13));
        FontMetrics fm = g.getFontMetrics();
        int hintWidth = fm.stringWidth(str);

        /* Iscrtavanje pravougaonika. */
        g.setColor(new Color(200, 200, 200));
        Rectangle2D rect = new Rectangle2D.Double(-hintWidth / 2 - 5, -9, hintWidth + 10, 18);
        g.draw(rect);
        g.setColor(new Color(255, 220, 255));
        g.fill(rect);

        /* Ispis teksta. */
        g.setColor(Color.BLUE);
        g.drawString(str, -hintWidth / 2, 5);

        g.translate(-middleCircleCoords.getX() + 15, -middleCircleCoords.getY() + 15);
      }
    }
  }
Example #25
0
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public static void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;

    float origAlpha = 1.0f;
    Composite origComposite = ((Graphics2D) g).getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    AffineTransform defaultTransform_ = g.getTransform();
    //
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.0231101606041193f,
            0.0f,
            0.0f,
            0.022715330123901367f,
            44.685020446777344f,
            39.36098861694336f));
    // _0_0_0
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_0
    paint =
        new LinearGradientPaint(
            new Point2D.Double(302.8571472167969, 366.64788818359375),
            new Point2D.Double(302.8571472167969, 609.5050659179688),
            new float[] {0.0f, 0.5f, 1.0f},
            new Color[] {new Color(0, 0, 0, 0), new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1892.178955078125f,
                -872.8853759765625f));
    shape =
        new Rectangle2D.Double(
            -1559.2523193359375, -150.6968536376953, 1339.633544921875, 478.357177734375);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_1
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1891.633056640625f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-219.61876, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-219.61876, -150.68037, -219.61876, 327.65042, -219.61876, 327.65042);
    ((GeneralPath) shape).curveTo(-76.74459, 328.55087, 125.78146, 220.48074, 125.78138, 88.45424);
    ((GeneralPath) shape)
        .curveTo(125.78138, -43.572304, -33.655437, -150.68036, -219.61876, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_2
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                -2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                112.76229858398438f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-1559.2523, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-1559.2523, -150.68037, -1559.2523, 327.65042, -1559.2523, 327.65042);
    ((GeneralPath) shape)
        .curveTo(-1702.1265, 328.55087, -1904.6525, 220.48074, -1904.6525, 88.45424);
    ((GeneralPath) shape)
        .curveTo(-1904.6525, -43.572304, -1745.2157, -150.68036, -1559.2523, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_2);
    g.setTransform(defaultTransform__0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(1.8456430435180664, 88.29493713378906),
            new Point2D.Double(18.972126007080078, 88.29493713378906),
            new float[] {0.0f, 0.27586207f, 1.0f},
            new Color[] {
              new Color(142, 141, 135, 255),
              new Color(203, 201, 193, 255),
              new Color(142, 141, 135, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.302720069885254f, 0.0f, 0.0f, 0.4379180073738098f, 0.0f, 0.5840340256690979f));
    shape =
        new RoundRectangle2D.Double(
            4.75,
            36.004188537597656,
            38.4375,
            6.491594314575195,
            3.4230966567993164,
            3.423095464706421);
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(89, 89, 89, 255);
    stroke = new BasicStroke(0.9999998f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new RoundRectangle2D.Double(
            4.75,
            36.004188537597656,
            38.4375,
            6.491594314575195,
            3.4230966567993164,
            3.423095464706421);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2
    paint =
        new LinearGradientPaint(
            new Point2D.Double(1.8456430435180664, 88.29492950439453),
            new Point2D.Double(18.972126007080078, 88.29492950439453),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(220, 220, 218, 255), new Color(186, 185, 183, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.2918241024017334f, 0.0f, 0.0f, 0.4342690110206604f, 0.08855178952217102f, 2.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.130896, 21.5);
    ((GeneralPath) shape).lineTo(40.870613, 21.5);
    ((GeneralPath) shape).curveTo(41.25566, 21.5, 41.747646, 21.788155, 42.05105, 22.223919);
    ((GeneralPath) shape).curveTo(42.35445, 22.659683, 43.787518, 24.83394, 44.109447, 25.297964);
    ((GeneralPath) shape).curveTo(44.431377, 25.761988, 44.502396, 26.201853, 44.502396, 26.77405);
    ((GeneralPath) shape).lineTo(44.502396, 38.850952);
    ((GeneralPath) shape).curveTo(44.502396, 39.764523, 43.7704, 40.5, 42.861153, 40.5);
    ((GeneralPath) shape).lineTo(5.1403594, 40.5);
    ((GeneralPath) shape).curveTo(4.2311096, 40.5, 3.4991138, 39.764523, 3.4991138, 38.850952);
    ((GeneralPath) shape).lineTo(3.4991138, 26.77405);
    ((GeneralPath) shape).curveTo(3.4991138, 26.280031, 3.6002798, 25.571642, 3.9455202, 25.120718);
    ((GeneralPath) shape).curveTo(4.3811665, 24.551714, 5.549866, 22.57277, 5.8581276, 22.153118);
    ((GeneralPath) shape).curveTo(6.1663885, 21.733467, 6.732446, 21.5, 7.130896, 21.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(103, 103, 103, 255);
    stroke = new BasicStroke(1.0000004f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.130896, 21.5);
    ((GeneralPath) shape).lineTo(40.870613, 21.5);
    ((GeneralPath) shape).curveTo(41.25566, 21.5, 41.747646, 21.788155, 42.05105, 22.223919);
    ((GeneralPath) shape).curveTo(42.35445, 22.659683, 43.787518, 24.83394, 44.109447, 25.297964);
    ((GeneralPath) shape).curveTo(44.431377, 25.761988, 44.502396, 26.201853, 44.502396, 26.77405);
    ((GeneralPath) shape).lineTo(44.502396, 38.850952);
    ((GeneralPath) shape).curveTo(44.502396, 39.764523, 43.7704, 40.5, 42.861153, 40.5);
    ((GeneralPath) shape).lineTo(5.1403594, 40.5);
    ((GeneralPath) shape).curveTo(4.2311096, 40.5, 3.4991138, 39.764523, 3.4991138, 38.850952);
    ((GeneralPath) shape).lineTo(3.4991138, 26.77405);
    ((GeneralPath) shape).curveTo(3.4991138, 26.280031, 3.6002798, 25.571642, 3.9455202, 25.120718);
    ((GeneralPath) shape).curveTo(4.3811665, 24.551714, 5.549866, 22.57277, 5.8581276, 22.153118);
    ((GeneralPath) shape).curveTo(6.1663885, 21.733467, 6.732446, 21.5, 7.130896, 21.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_2);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_3
    paint = new Color(251, 251, 251, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.424621, 21.975533);
    ((GeneralPath) shape).curveTo(6.921893, 21.975533, 6.3048778, 22.053783, 6.0546017, 22.46703);
    ((GeneralPath) shape).lineTo(4.1542525, 25.604816);
    ((GeneralPath) shape).curveTo(3.8721285, 26.070648, 4.1881986, 26.868141, 5.087311, 26.868141);
    ((GeneralPath) shape).lineTo(42.730785, 26.868141);
    ((GeneralPath) shape).curveTo(44.040733, 26.868141, 43.950535, 25.858072, 43.663845, 25.42804);
    ((GeneralPath) shape).lineTo(41.896076, 22.776388);
    ((GeneralPath) shape).curveTo(41.575542, 22.29559, 41.459198, 21.975533, 40.65864, 21.975533);
    ((GeneralPath) shape).lineTo(7.424621, 21.975533);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_3);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_4
    paint =
        new LinearGradientPaint(
            new Point2D.Double(15.387969017028809, 32.53923797607422),
            new Point2D.Double(15.487822532653809, 58.83126449584961),
            new float[] {0.0f, 0.10344828f, 1.0f},
            new Color[] {
              new Color(255, 255, 255, 32),
              new Color(255, 255, 255, 255),
              new Color(255, 255, 255, 0)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.4925689697265625f, 0.0f, 0.0f, 0.66874098777771f, 0.08188071846961975f, 2.0f));
    stroke = new BasicStroke(0.9469671f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.60536, 22.445757);
    ((GeneralPath) shape).lineTo(40.432674, 22.445757);
    ((GeneralPath) shape).curveTo(40.79835, 22.445757, 41.26559, 22.71863, 41.553734, 23.131283);
    ((GeneralPath) shape).curveTo(41.841873, 23.543938, 42.849964, 25.160946, 43.1557, 25.60036);
    ((GeneralPath) shape).curveTo(43.461437, 26.039776, 43.59127, 26.456312, 43.59127, 26.998163);
    ((GeneralPath) shape).lineTo(43.59127, 38.279263);
    ((GeneralPath) shape).curveTo(43.59127, 39.144386, 43.457546, 39.528355, 42.594032, 39.528355);
    ((GeneralPath) shape).lineTo(5.5322266, 39.528355);
    ((GeneralPath) shape).curveTo(4.6687107, 39.528355, 4.4726048, 39.144386, 4.4726048, 38.279263);
    ((GeneralPath) shape).lineTo(4.4726048, 26.998163);
    ((GeneralPath) shape).curveTo(4.4726048, 26.530346, 4.69345, 25.859524, 5.021325, 25.432514);
    ((GeneralPath) shape).curveTo(5.435059, 24.893684, 6.103854, 23.461634, 6.3966103, 23.064238);
    ((GeneralPath) shape).curveTo(6.6893663, 22.666842, 7.2269516, 22.445757, 7.60536, 22.445757);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_5
    paint =
        new LinearGradientPaint(
            new Point2D.Double(25.056711196899414, 3.6785457134246826),
            new Point2D.Double(24.78970718383789, 25.247310638427734),
            new float[] {0.0f, 0.4054697f, 0.5344828f, 1.0f},
            new Color[] {
              new Color(224, 224, 224, 255),
              new Color(255, 255, 255, 255),
              new Color(205, 205, 205, 255),
              new Color(73, 73, 73, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                0.9457100033760071f,
                0.0f,
                0.0f,
                1.076032042503357f,
                0.05016683042049408f,
                4.095404148101807f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(11.672962, 4.4999475);
    ((GeneralPath) shape).lineTo(36.325115, 4.4999475);
    ((GeneralPath) shape).curveTo(36.97588, 4.4999475, 37.49978, 5.0100775, 37.49978, 5.6437373);
    ((GeneralPath) shape).lineTo(37.49978, 24.348175);
    ((GeneralPath) shape).lineTo(10.498298, 24.348175);
    ((GeneralPath) shape).lineTo(10.498298, 5.6437373);
    ((GeneralPath) shape).curveTo(10.498298, 5.0100775, 11.022197, 4.4999475, 11.672962, 4.4999475);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(137, 137, 137, 255);
    stroke = new BasicStroke(1.0000004f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(11.672962, 4.4999475);
    ((GeneralPath) shape).lineTo(36.325115, 4.4999475);
    ((GeneralPath) shape).curveTo(36.97588, 4.4999475, 37.49978, 5.0100775, 37.49978, 5.6437373);
    ((GeneralPath) shape).lineTo(37.49978, 24.348175);
    ((GeneralPath) shape).lineTo(10.498298, 24.348175);
    ((GeneralPath) shape).lineTo(10.498298, 5.6437373);
    ((GeneralPath) shape).curveTo(10.498298, 5.0100775, 11.022197, 4.4999475, 11.672962, 4.4999475);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_5);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_6
    paint =
        new LinearGradientPaint(
            new Point2D.Double(20.771228790283203, 25.1402530670166),
            new Point2D.Double(20.71780014038086, 19.33746337890625),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 0), new Color(248, 248, 248, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.198768973350525f,
                0.0f,
                0.0f,
                0.853564977645874f,
                -0.1430860012769699f,
                2.034512996673584f));
    stroke = new BasicStroke(1.0000002f, 1, 1, 4.0f, null, 0.0f);
    shape =
        new RoundRectangle2D.Double(
            11.498513221740723,
            5.499246597290039,
            25.00057601928711,
            18.836374282836914,
            0.35355344414711,
            0.35355350375175476);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_6);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_7
    paint =
        new LinearGradientPaint(
            new Point2D.Double(10.33823299407959, 64.65225982666016),
            new Point2D.Double(10.33823299407959, 54.136138916015625),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(247, 246, 245, 255), new Color(247, 246, 245, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(2.3698439598083496f, 0.0f, 0.0f, 0.4219689965248108f, 0.0f, 2.0f));
    shape =
        new RoundRectangle2D.Double(
            6.875, 27.375, 33.75, 5.1875, 3.4230966567993164, 3.4230966567993164);
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(9.731653213500977, 70.7249755859375),
            new Point2D.Double(9.705278396606445, 62.282466888427734),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(102, 102, 102, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(2.3698439598083496f, 0.0f, 0.0f, 0.4219689965248108f, 0.0f, 2.0f));
    stroke = new BasicStroke(1.0f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new RoundRectangle2D.Double(
            6.875, 27.375, 33.75, 5.1875, 3.4230966567993164, 3.4230966567993164);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_7);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_8 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 2.0f));
    // _0_0_8
    paint =
        new RadialGradientPaint(
            new Point2D.Double(9.129549026489258, 26.925594329833984),
            2.1227016f,
            new Point2D.Double(9.129549026489258, 26.925594329833984),
            new float[] {0.0f, 0.5f, 1.0f},
            new Color[] {
              new Color(255, 255, 253, 255), new Color(187, 187, 185, 255), new Color(0, 0, 0, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(10.871767, 27.626486);
    ((GeneralPath) shape).curveTo(10.871767, 28.33431, 10.297961, 28.908117, 9.590136, 28.908117);
    ((GeneralPath) shape).curveTo(8.882311, 28.908117, 8.308505, 28.33431, 8.308505, 27.626486);
    ((GeneralPath) shape).curveTo(8.308505, 26.918661, 8.882311, 26.344854, 9.590136, 26.344854);
    ((GeneralPath) shape).curveTo(10.297961, 26.344854, 10.871767, 26.918661, 10.871767, 27.626486);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_8);
    g.setComposite(AlphaComposite.getInstance(3, 0.36571428f * origAlpha));
    AffineTransform defaultTransform__0_0_9 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_9
    paint =
        new LinearGradientPaint(
            new Point2D.Double(9.869808197021484, 57.2276496887207),
            new Point2D.Double(9.912813186645508, 72.06431579589844),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 60), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7720859050750732f,
                0.0f,
                0.0f,
                0.36073899269104004f,
                0.6187180280685425f,
                2.883882999420166f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(11.743718, 25.416054);
    ((GeneralPath) shape).lineTo(37.306217, 25.478554);
    ((GeneralPath) shape).curveTo(37.993717, 25.480234, 38.294037, 25.107557, 38.243717, 24.478554);
    ((GeneralPath) shape).lineTo(38.118717, 22.916054);
    ((GeneralPath) shape).lineTo(39.984837, 22.916054);
    ((GeneralPath) shape).curveTo(40.797337, 22.916054, 40.975037, 23.108616, 41.172337, 23.478554);
    ((GeneralPath) shape).lineTo(41.672337, 24.416054);
    ((GeneralPath) shape).curveTo(42.19913, 25.403793, 43.48351, 26.390165, 42.170494, 26.390165);
    ((GeneralPath) shape).curveTo(37.667786, 26.390165, 13.993718, 26.041054, 11.743718, 25.416054);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_9);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_10 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_10
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(0.99999994f, 1, 1, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(43.488808, 26.5);
    ((GeneralPath) shape).lineTo(4.5111804, 26.5);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_10);
    g.setComposite(AlphaComposite.getInstance(3, 0.43575415f * origAlpha));
    AffineTransform defaultTransform__0_0_11 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 2.0f));
    // _0_0_11
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_0
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 7.0, 19.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_1
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 9.0, 19.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_2
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 11.0, 19.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_2);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_3
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 13.0, 11.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_3);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_4
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 17.0, 19.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_11_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11_5
    paint = new Color(0, 0, 0, 75);
    shape = new Rectangle2D.Double(14.0, 19.0, 19.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11_5);
    g.setTransform(defaultTransform__0_0_11);
    g.setTransform(defaultTransform__0_0);
    g.setTransform(defaultTransform__0);
    g.setTransform(defaultTransform_);
  }
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;

    float origAlpha = 1.0f;
    Composite origComposite = ((Graphics2D) g).getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    AffineTransform defaultTransform_ = g.getTransform();
    //
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.023305730894207954f,
            0.0f,
            0.0f,
            0.012270580045878887f,
            44.47890853881836f,
            44.416908264160156f));
    // _0_0_0
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_0
    paint =
        new LinearGradientPaint(
            new Point2D.Double(302.8571472167969, 366.64788818359375),
            new Point2D.Double(302.8571472167969, 609.5050659179688),
            new float[] {0.0f, 0.5f, 1.0f},
            new Color[] {new Color(0, 0, 0, 0), new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1892.178955078125f,
                -872.8853759765625f));
    shape =
        new Rectangle2D.Double(
            -1559.2523193359375, -150.6968536376953, 1339.633544921875, 478.357177734375);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_1
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                -1891.633056640625f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-219.61876, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-219.61876, -150.68037, -219.61876, 327.65042, -219.61876, 327.65042);
    ((GeneralPath) shape).curveTo(-76.74459, 328.55087, 125.78146, 220.48074, 125.78138, 88.45424);
    ((GeneralPath) shape)
        .curveTo(125.78138, -43.572304, -33.655437, -150.68036, -219.61876, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 0.40206185f * origAlpha));
    AffineTransform defaultTransform__0_0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_2
    paint =
        new RadialGradientPaint(
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            117.14286f,
            new Point2D.Double(605.7142944335938, 486.64788818359375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                -2.7743890285491943f,
                0.0f,
                0.0f,
                1.9697060585021973f,
                112.76229858398438f,
                -872.8853759765625f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(-1559.2523, -150.68037);
    ((GeneralPath) shape)
        .curveTo(-1559.2523, -150.68037, -1559.2523, 327.65042, -1559.2523, 327.65042);
    ((GeneralPath) shape)
        .curveTo(-1702.1265, 328.55087, -1904.6525, 220.48074, -1904.6525, 88.45424);
    ((GeneralPath) shape)
        .curveTo(-1904.6525, -43.572304, -1745.2157, -150.68036, -1559.2523, -150.68037);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0_2);
    g.setTransform(defaultTransform__0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(20.794008255004883, 18.378812789916992),
            new Point2D.Double(35.59600067138672, 39.600460052490234),
            new float[] {0.0f, 0.59928656f, 1.0f},
            new Color[] {
              new Color(248, 248, 247, 255),
              new Color(232, 232, 232, 255),
              new Color(226, 226, 222, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.3427040576934814f,
                0.0f,
                0.0f,
                1.2353780269622803f,
                -8.219611167907715f,
                -6.577188968658447f));
    shape =
        new RoundRectangle2D.Double(
            4.501601696014404,
            1.4968987703323364,
            38.99679183959961,
            45.00310134887695,
            1.133015751838684,
            1.1330164670944214);
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(0, 0, 0, 255);
    stroke = new BasicStroke(0.99999976f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new RoundRectangle2D.Double(
            4.501601696014404,
            1.4968987703323364,
            38.99679183959961,
            45.00310134887695,
            1.133015751838684,
            1.1330164670944214);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 10.0, 27.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_2);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_3
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 16.0, 25.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_3);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_4
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 22.0, 22.97153091430664, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_5
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 28.0, 27.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_5);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_6
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 34.0, 17.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_6);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_7
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(0.9999998f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new Rectangle2D.Double(
            5.4997124671936035, 2.4997177124023438, 37.02556610107422, 43.022315979003906);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_7);
    g.setTransform(defaultTransform__0_0);
    g.setTransform(defaultTransform__0);
    g.setTransform(defaultTransform_);
  }
Example #27
0
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public static void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;
    Area clip = null;

    float origAlpha = 1.0f;
    Composite origComposite = g.getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    Shape clip_ = g.getClip();
    AffineTransform defaultTransform_ = g.getTransform();
    //  is CompositeGraphicsNode
    float alpha__0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0 = g.getClip();
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    clip = new Area(g.getClip());
    clip.intersect(new Area(new Rectangle2D.Double(0.0, 0.0, 48.0, 48.0)));
    g.setClip(clip);
    // _0 is CompositeGraphicsNode
    float alpha__0_0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0 = g.getClip();
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            1.6164523363113403f,
            0.0f,
            0.0f,
            1.6164523363113403f,
            -2.138885736465454f,
            -21.565214157104492f));
    // _0_0 is CompositeGraphicsNode
    float alpha__0_0_0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0 = g.getClip();
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 3.469669818878174f, -10.369165420532227f));
    // _0_0_0 is CompositeGraphicsNode
    float alpha__0_0_0_0 = origAlpha;
    origAlpha = origAlpha * 0.3f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_0 = g.getClip();
    AffineTransform defaultTransform__0_0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.41036099195480347f,
            0.0f,
            0.0f,
            0.6798580288887024f,
            -0.07301999628543854f,
            15.97854995727539f));
    // _0_0_0_0 is ShapeNode
    paint =
        new RadialGradientPaint(
            new Point2D.Double(23.9375, 42.6875),
            23.75956f,
            new Point2D.Double(23.9375, 42.6875),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 0.24763000011444092f, 0.0f, 32.116798400878906f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(47.69706, 42.6875);
    ((GeneralPath) shape).curveTo(47.69706, 45.936913, 37.05954, 48.57108, 23.9375, 48.57108);
    ((GeneralPath) shape).curveTo(10.815458, 48.57108, 0.17794037, 45.936913, 0.17794037, 42.6875);
    ((GeneralPath) shape).curveTo(0.17794037, 39.438087, 10.815458, 36.80392, 23.9375, 36.80392);
    ((GeneralPath) shape).curveTo(37.05954, 36.80392, 47.69706, 39.438087, 47.69706, 42.6875);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_0_0;
    g.setTransform(defaultTransform__0_0_0_0);
    g.setClip(clip__0_0_0_0);
    float alpha__0_0_0_1 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_1 = g.getClip();
    AffineTransform defaultTransform__0_0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_1 is ShapeNode
    paint = new Color(0, 0, 0, 255);
    stroke = new BasicStroke(0.9999998f, 1, 1, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(17.5, 34.5);
    ((GeneralPath) shape).lineTo(14.5, 31.5);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_1;
    g.setTransform(defaultTransform__0_0_0_1);
    g.setClip(clip__0_0_0_1);
    float alpha__0_0_0_2 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_2 = g.getClip();
    AffineTransform defaultTransform__0_0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_2 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(47.998985290527344, 47.27030944824219),
            new Point2D.Double(63.938480377197266, 47.27030944824219),
            new float[] {0.0f, 0.3493976f, 1.0f},
            new Color[] {
              new Color(186, 189, 182, 255),
              new Color(238, 238, 236, 255),
              new Color(136, 138, 133, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0041179656982422f,
                0.0f,
                0.0f,
                1.0234580039978027f,
                -47.19974136352539f,
                -10.879670143127441f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(8.999472, 27.50001);
    ((GeneralPath) shape).curveTo(4.8597455, 27.50001, 1.4999676, 28.744392, 1.4999676, 30.277649);
    ((GeneralPath) shape).lineTo(1.4999676, 43.721375);
    ((GeneralPath) shape).curveTo(1.4999676, 45.25463, 4.8597455, 46.499016, 8.999472, 46.499016);
    ((GeneralPath) shape).curveTo(13.139198, 46.499016, 16.49898, 45.25463, 16.49898, 43.721375);
    ((GeneralPath) shape).lineTo(16.49898, 30.277649);
    ((GeneralPath) shape).curveTo(16.49898, 28.744392, 13.139198, 27.50001, 8.999472, 27.50001);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(5.3125, 26.99901008605957),
            new Point2D.Double(5.625, 39.0),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(46, 52, 54, 255), new Color(136, 138, 133, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0019997f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(8.999472, 27.50001);
    ((GeneralPath) shape).curveTo(4.8597455, 27.50001, 1.4999676, 28.744392, 1.4999676, 30.277649);
    ((GeneralPath) shape).lineTo(1.4999676, 43.721375);
    ((GeneralPath) shape).curveTo(1.4999676, 45.25463, 4.8597455, 46.499016, 8.999472, 46.499016);
    ((GeneralPath) shape).curveTo(13.139198, 46.499016, 16.49898, 45.25463, 16.49898, 43.721375);
    ((GeneralPath) shape).lineTo(16.49898, 30.277649);
    ((GeneralPath) shape).curveTo(16.49898, 28.744392, 13.139198, 27.50001, 8.999472, 27.50001);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_2;
    g.setTransform(defaultTransform__0_0_0_2);
    g.setClip(clip__0_0_0_2);
    float alpha__0_0_0_3 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_3 = g.getClip();
    AffineTransform defaultTransform__0_0_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_3 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(47.52022171020508, 53.98938751220703),
            new Point2D.Double(51.531280517578125, 40.39101791381836),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, -47.0f, -10.0f));
    stroke = new BasicStroke(1.0019997f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(9.0, 28.5);
    ((GeneralPath) shape).curveTo(7.031106, 28.5, 5.264027, 28.804224, 4.0625, 29.25);
    ((GeneralPath) shape).curveTo(3.461736, 29.472889, 2.993416, 29.755526, 2.75, 29.96875);
    ((GeneralPath) shape).curveTo(2.506584, 30.181974, 2.5, 30.264948, 2.5, 30.28125);
    ((GeneralPath) shape).lineTo(2.5, 43.71875);
    ((GeneralPath) shape).curveTo(2.5, 43.73505, 2.50658, 43.81802, 2.75, 44.03125);
    ((GeneralPath) shape).curveTo(2.993416, 44.244476, 3.461736, 44.52711, 4.0625, 44.75);
    ((GeneralPath) shape).curveTo(5.264028, 45.195778, 7.031107, 45.5, 9.0, 45.5);
    ((GeneralPath) shape).curveTo(10.968893, 45.5, 12.735971, 45.195774, 13.9375, 44.75);
    ((GeneralPath) shape).curveTo(14.538264, 44.52711, 15.006584, 44.244476, 15.25, 44.03125);
    ((GeneralPath) shape).curveTo(15.493416, 43.818024, 15.5, 43.73505, 15.5, 43.71875);
    ((GeneralPath) shape).lineTo(15.5, 30.28125);
    ((GeneralPath) shape).curveTo(15.5, 30.26495, 15.4934, 30.18198, 15.25, 29.96875);
    ((GeneralPath) shape).curveTo(15.006584, 29.755526, 14.538264, 29.472889, 13.9375, 29.25);
    ((GeneralPath) shape).curveTo(12.735973, 28.804224, 10.968894, 28.5, 9.0, 28.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_3;
    g.setTransform(defaultTransform__0_0_0_3);
    g.setClip(clip__0_0_0_3);
    float alpha__0_0_0_4 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_4 = g.getClip();
    AffineTransform defaultTransform__0_0_0_4 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.9285699725151062f,
            0.0f,
            0.0f,
            0.7996000051498413f,
            -56.46419143676758f,
            5.712399959564209f));
    // _0_0_0_4 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(62.9604606628418, 31.0),
            new Point2D.Double(76.70162200927734, 31.0),
            new float[] {0.0f, 0.6626506f, 1.0f},
            new Color[] {
              new Color(0, 0, 0, 255), new Color(86, 88, 85, 255), new Color(46, 52, 54, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(77.5, 31.0);
    ((GeneralPath) shape).curveTo(77.5, 32.38071, 74.36599, 33.5, 70.5, 33.5);
    ((GeneralPath) shape).curveTo(66.63401, 33.5, 63.5, 32.38071, 63.5, 31.0);
    ((GeneralPath) shape).curveTo(63.5, 29.619287, 66.63401, 28.5, 70.5, 28.5);
    ((GeneralPath) shape).curveTo(74.36599, 28.5, 77.5, 29.619287, 77.5, 31.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(1.1628509f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(77.5, 31.0);
    ((GeneralPath) shape).curveTo(77.5, 32.38071, 74.36599, 33.5, 70.5, 33.5);
    ((GeneralPath) shape).curveTo(66.63401, 33.5, 63.5, 32.38071, 63.5, 31.0);
    ((GeneralPath) shape).curveTo(63.5, 29.619287, 66.63401, 28.5, 70.5, 28.5);
    ((GeneralPath) shape).curveTo(74.36599, 28.5, 77.5, 29.619287, 77.5, 31.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_4;
    g.setTransform(defaultTransform__0_0_0_4);
    g.setClip(clip__0_0_0_4);
    float alpha__0_0_0_5 = origAlpha;
    origAlpha = origAlpha * 0.1f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_5 = g.getClip();
    AffineTransform defaultTransform__0_0_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_5 is ShapeNode
    paint = new Color(0, 0, 0, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(9.345005, 42.713127);
    ((GeneralPath) shape).curveTo(9.204923, 33.22204, 5.5778227, 33.856804, 7.334597, 32.244312);
    ((GeneralPath) shape).curveTo(12.218053, 32.56472, 14.649587, 31.727633, 15.3125, 30.84375);
    ((GeneralPath) shape).curveTo(17.886276, 34.05394, 10.425369, 32.933487, 11.3263645, 42.68907);
    ((GeneralPath) shape).curveTo(11.311034, 44.32013, 9.306448, 44.76434, 9.345005, 42.71313);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_0_5;
    g.setTransform(defaultTransform__0_0_0_5);
    g.setClip(clip__0_0_0_5);
    float alpha__0_0_0_6 = origAlpha;
    origAlpha = origAlpha * 0.6f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_6 = g.getClip();
    AffineTransform defaultTransform__0_0_0_6 = g.getTransform();
    g.transform(
        new AffineTransform(0.75f, 0.125f, 0.0f, 0.8585929870605469f, 1.75f, 4.182837963104248f));
    // _0_0_0_6 is ShapeNode
    paint = new Color(136, 138, 133, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.0, 35.747044);
    ((GeneralPath) shape).curveTo(7.0, 36.71191, 6.1045694, 37.494087, 5.0, 37.494087);
    ((GeneralPath) shape).curveTo(3.8954306, 37.494087, 3.0, 36.71191, 3.0, 35.747044);
    ((GeneralPath) shape).curveTo(3.0, 34.782177, 3.8954306, 34.0, 5.0, 34.0);
    ((GeneralPath) shape).curveTo(6.1045694, 34.0, 7.0, 34.782177, 7.0, 35.747044);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_0_6;
    g.setTransform(defaultTransform__0_0_0_6);
    g.setClip(clip__0_0_0_6);
    float alpha__0_0_0_7 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_7 = g.getClip();
    AffineTransform defaultTransform__0_0_0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_7 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(11.269515037536621, 37.85743713378906),
            new Point2D.Double(10.562406539916992, 32.48784255981445),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(164, 0, 0, 255), new Color(239, 41, 41, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, -2.0f, 0.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(9.032505, 42.369377);
    ((GeneralPath) shape).curveTo(9.283048, 30.94079, 3.624698, 33.71618, 5.709597, 31.728687);
    ((GeneralPath) shape).curveTo(11.354185, 32.403618, 14.372165, 31.395576, 15.0, 30.5);
    ((GeneralPath) shape).curveTo(17.573776, 33.71019, 10.112869, 32.589737, 11.0138645, 42.34532);
    ((GeneralPath) shape).curveTo(10.998534, 43.97638, 8.993948, 44.42059, 9.032505, 42.36938);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_0_7;
    g.setTransform(defaultTransform__0_0_0_7);
    g.setClip(clip__0_0_0_7);
    float alpha__0_0_0_8 = origAlpha;
    origAlpha = origAlpha * 0.3f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_8 = g.getClip();
    AffineTransform defaultTransform__0_0_0_8 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_8 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(11.296875, 37.5),
            new Point2D.Double(10.296875, 32.890625),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, -2.0f, 0.0f));
    stroke = new BasicStroke(0.4f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(7.718751, 33.531254);
    ((GeneralPath) shape).curveTo(8.311668, 34.52206, 9.518863, 36.40045, 9.593751, 41.734383);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_8;
    g.setTransform(defaultTransform__0_0_0_8);
    g.setClip(clip__0_0_0_8);
    float alpha__0_0_0_9 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_9 = g.getClip();
    AffineTransform defaultTransform__0_0_0_9 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_9 is ShapeNode
    paint = new Color(0, 0, 0, 255);
    stroke = new BasicStroke(1.0000001f, 1, 1, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(5.5, 35.5);
    ((GeneralPath) shape).curveTo(5.5, 35.5, 10.361633, 41.44325, 13.611814, 41.498775);
    ((GeneralPath) shape).curveTo(16.861994, 41.554306, 18.47873, 39.728474, 18.5, 37.422268);
    ((GeneralPath) shape).curveTo(18.52129, 35.116177, 17.5, 34.500008, 17.5, 34.500008);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_9;
    g.setTransform(defaultTransform__0_0_0_9);
    g.setClip(clip__0_0_0_9);
    float alpha__0_0_0_10 = origAlpha;
    origAlpha = origAlpha * 0.6f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_10 = g.getClip();
    AffineTransform defaultTransform__0_0_0_10 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_0_10 is ShapeNode
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(0.3f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(6.03865, 32.310688);
    ((GeneralPath) shape).curveTo(10.705692, 32.89853, 14.322287, 32.21565, 14.955822, 31.212723);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_0_0_10;
    g.setTransform(defaultTransform__0_0_0_10);
    g.setClip(clip__0_0_0_10);
    float alpha__0_0_0_11 = origAlpha;
    origAlpha = origAlpha * 0.3f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_0_0_11 = g.getClip();
    AffineTransform defaultTransform__0_0_0_11 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.7735850214958191f,
            0.0f,
            0.0f,
            1.1914889812469482f,
            0.5613210201263428f,
            -8.249003410339355f));
    // _0_0_0_11 is ShapeNode
    paint = new Color(255, 255, 255, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(12.140624, 42.710938);
    ((GeneralPath) shape).curveTo(12.140624, 42.91373, 11.955242, 43.078125, 11.7265625, 43.078125);
    ((GeneralPath) shape).curveTo(11.497882, 43.078125, 11.312499, 42.91373, 11.312499, 42.710938);
    ((GeneralPath) shape).curveTo(11.312499, 42.508144, 11.497881, 42.34375, 11.7265625, 42.34375);
    ((GeneralPath) shape).curveTo(11.955242, 42.34375, 12.140624, 42.508144, 12.140624, 42.710938);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_0_0_11;
    g.setTransform(defaultTransform__0_0_0_11);
    g.setClip(clip__0_0_0_11);
    origAlpha = alpha__0_0_0;
    g.setTransform(defaultTransform__0_0_0);
    g.setClip(clip__0_0_0);
    origAlpha = alpha__0_0;
    g.setTransform(defaultTransform__0_0);
    g.setClip(clip__0_0);
    float alpha__0_1 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1 = g.getClip();
    AffineTransform defaultTransform__0_1 = g.getTransform();
    g.transform(
        new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 3.358757257461548f, 20.329320907592773f));
    // _0_1 is CompositeGraphicsNode
    float alpha__0_1_0 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0 = g.getClip();
    AffineTransform defaultTransform__0_1_0 = g.getTransform();
    g.transform(
        new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 3.707106828689575f, -22.445436477661133f));
    // _0_1_0 is CompositeGraphicsNode
    float alpha__0_1_0_0 = origAlpha;
    origAlpha = origAlpha * 0.3f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_0 = g.getClip();
    AffineTransform defaultTransform__0_1_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            0.2309119999408722f,
            0.0f,
            0.0f,
            0.4249109923839569f,
            23.95890998840332f,
            27.361600875854492f));
    // _0_1_0_0 is ShapeNode
    paint =
        new RadialGradientPaint(
            new Point2D.Double(23.9375, 42.6875),
            23.75956f,
            new Point2D.Double(23.9375, 42.6875),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 0.24763000011444092f, 0.0f, 32.116798400878906f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(47.69706, 42.6875);
    ((GeneralPath) shape).curveTo(47.69706, 45.936913, 37.05954, 48.57108, 23.9375, 48.57108);
    ((GeneralPath) shape).curveTo(10.815458, 48.57108, 0.17794037, 45.936913, 0.17794037, 42.6875);
    ((GeneralPath) shape).curveTo(0.17794037, 39.438087, 10.815458, 36.80392, 23.9375, 36.80392);
    ((GeneralPath) shape).curveTo(37.05954, 36.80392, 47.69706, 39.438087, 47.69706, 42.6875);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_1_0_0;
    g.setTransform(defaultTransform__0_1_0_0);
    g.setClip(clip__0_1_0_0);
    float alpha__0_1_0_1 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_1 = g.getClip();
    AffineTransform defaultTransform__0_1_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_0_1 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(27.65625, 40.4375),
            new Point2D.Double(32.46925354003906, 40.4375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(233, 185, 110, 255), new Color(193, 125, 17, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(31.011063, 32.499992);
    ((GeneralPath) shape).curveTo(31.011063, 32.499992, 32.528572, 40.253124, 32.5, 42.424072);
    ((GeneralPath) shape).curveTo(32.4719, 44.559433, 31.819656, 46.43749, 29.469381, 46.43749);
    ((GeneralPath) shape).curveTo(27.15003, 46.43749, 26.531536, 44.704422, 26.50061, 42.424072);
    ((GeneralPath) shape).curveTo(26.46969, 40.144012, 27.95765, 32.562492, 27.95765, 32.562492);
    ((GeneralPath) shape).lineTo(31.01106, 32.499992);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(32.0, 37.25),
            new Point2D.Double(32.0, 34.2707405090332),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(143, 89, 2, 255), new Color(99, 61, 0, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f));
    stroke = new BasicStroke(0.9999998f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(31.011063, 32.499992);
    ((GeneralPath) shape).curveTo(31.011063, 32.499992, 32.528572, 40.253124, 32.5, 42.424072);
    ((GeneralPath) shape).curveTo(32.4719, 44.559433, 31.819656, 46.43749, 29.469381, 46.43749);
    ((GeneralPath) shape).curveTo(27.15003, 46.43749, 26.531536, 44.704422, 26.50061, 42.424072);
    ((GeneralPath) shape).curveTo(26.46969, 40.144012, 27.95765, 32.562492, 27.95765, 32.562492);
    ((GeneralPath) shape).lineTo(31.01106, 32.499992);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_0_1;
    g.setTransform(defaultTransform__0_1_0_1);
    g.setClip(clip__0_1_0_1);
    float alpha__0_1_0_2 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_2 = g.getClip();
    AffineTransform defaultTransform__0_1_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_0_2 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(29.410438537597656, 20.64676856994629),
            new Point2D.Double(30.096174240112305, 25.90407371520996),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(73, 83, 86, 255), new Color(30, 34, 36, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(22.5, 27.5);
    ((GeneralPath) shape).curveTo(22.45849, 23.0625, 20.41699, 19.4375, 20.5, 19.5);
    ((GeneralPath) shape).curveTo(21.994165, 20.8125, 23.986385, 21.0, 24.982494, 23.4375);
    ((GeneralPath) shape).curveTo(24.982494, 23.5, 26.974714, 22.0, 26.538916, 20.4375);
    ((GeneralPath) shape).curveTo(27.970825, 21.0, 28.157595, 22.145832, 28.966934, 23.0);
    ((GeneralPath) shape).lineTo(29.963045, 20.0);
    ((GeneralPath) shape).lineTo(32.45052, 23.0);
    ((GeneralPath) shape).lineTo(35.509438, 20.0);
    ((GeneralPath) shape).curveTo(35.509438, 20.0, 36.437744, 24.9375, 36.5, 27.5);
    ((GeneralPath) shape).lineTo(22.5, 27.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(27.510536193847656, 25.36113739013672),
            new Point2D.Double(28.02859878540039, 20.057836532592773),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(212, 40, 40, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0000001f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(22.5, 27.5);
    ((GeneralPath) shape).curveTo(22.45849, 23.0625, 20.41699, 19.4375, 20.5, 19.5);
    ((GeneralPath) shape).curveTo(21.994165, 20.8125, 23.986385, 21.0, 24.982494, 23.4375);
    ((GeneralPath) shape).curveTo(24.982494, 23.5, 26.974714, 22.0, 26.538916, 20.4375);
    ((GeneralPath) shape).curveTo(27.970825, 21.0, 28.157595, 22.145832, 28.966934, 23.0);
    ((GeneralPath) shape).lineTo(29.963045, 20.0);
    ((GeneralPath) shape).lineTo(32.45052, 23.0);
    ((GeneralPath) shape).lineTo(35.509438, 20.0);
    ((GeneralPath) shape).curveTo(35.509438, 20.0, 36.437744, 24.9375, 36.5, 27.5);
    ((GeneralPath) shape).lineTo(22.5, 27.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_0_2;
    g.setTransform(defaultTransform__0_1_0_2);
    g.setClip(clip__0_1_0_2);
    float alpha__0_1_0_3 = origAlpha;
    origAlpha = origAlpha * 0.6f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_3 = g.getClip();
    AffineTransform defaultTransform__0_1_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f));
    // _0_1_0_3 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(28.5, 44.0),
            new Point2D.Double(28.0, 30.375),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(0.9999998f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(28.78125, 32.53125);
    ((GeneralPath) shape).curveTo(28.676458, 33.07113, 28.516066, 34.062725, 28.21875, 35.8125);
    ((GeneralPath) shape).curveTo(27.8503, 37.980934, 27.487719, 40.531914, 27.5, 41.4375);
    ((GeneralPath) shape).curveTo(27.51428, 42.490627, 27.68577, 43.2988, 27.96875, 43.75);
    ((GeneralPath) shape).curveTo(28.25173, 44.2012, 28.556435, 44.4375, 29.46875, 44.4375);
    ((GeneralPath) shape).curveTo(30.379202, 44.4375, 30.69847, 44.198746, 31.0, 43.71875);
    ((GeneralPath) shape).curveTo(31.30153, 43.238754, 31.487242, 42.407036, 31.5, 41.4375);
    ((GeneralPath) shape).curveTo(31.51099, 40.602573, 31.157352, 38.01107, 30.78125, 35.8125);
    ((GeneralPath) shape).curveTo(30.482124, 34.063904, 30.298449, 33.104626, 30.1875, 32.53125);
    ((GeneralPath) shape).lineTo(28.78125, 32.53125);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_0_3;
    g.setTransform(defaultTransform__0_1_0_3);
    g.setClip(clip__0_1_0_3);
    float alpha__0_1_0_4 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_4 = g.getClip();
    AffineTransform defaultTransform__0_1_0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_0_4 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(28.747844696044922, 28.779314041137695),
            new Point2D.Double(28.747844696044922, 32.069236755371094),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(193, 125, 17, 255), new Color(233, 185, 110, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(22.504711, 32.99529);
    ((GeneralPath) shape).lineTo(22.5, 28.5);
    ((GeneralPath) shape).lineTo(36.5, 28.5);
    ((GeneralPath) shape).lineTo(36.5047, 32.99529);
    ((GeneralPath) shape).curveTo(36.50471, 33.99529, 36.0, 34.520832, 35.0, 34.5);
    ((GeneralPath) shape).lineTo(24.0, 34.5);
    ((GeneralPath) shape).curveTo(23.0, 34.5, 22.5, 34.0, 22.504711, 32.99529);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(143, 89, 2, 255);
    stroke = new BasicStroke(1.0f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(22.504711, 32.99529);
    ((GeneralPath) shape).lineTo(22.5, 28.5);
    ((GeneralPath) shape).lineTo(36.5, 28.5);
    ((GeneralPath) shape).lineTo(36.5047, 32.99529);
    ((GeneralPath) shape).curveTo(36.50471, 33.99529, 36.0, 34.520832, 35.0, 34.5);
    ((GeneralPath) shape).lineTo(24.0, 34.5);
    ((GeneralPath) shape).curveTo(23.0, 34.5, 22.5, 34.0, 22.504711, 32.99529);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_0_4;
    g.setTransform(defaultTransform__0_1_0_4);
    g.setClip(clip__0_1_0_4);
    float alpha__0_1_0_5 = origAlpha;
    origAlpha = origAlpha * 0.3608247f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_5 = g.getClip();
    AffineTransform defaultTransform__0_1_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_0_5 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(29.258052825927734, 33.98051834106445),
            new Point2D.Double(29.15077781677246, 35.60707092285156),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(-1.0f, 0.0f, 0.0f, 1.0f, 58.984371185302734f, 1.0f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(27.984375, 35.0);
    ((GeneralPath) shape).lineTo(30.96875, 34.9922);
    ((GeneralPath) shape).curveTo(31.21286, 36.31806, 31.160522, 35.96878, 31.363445, 37.31524);
    ((GeneralPath) shape).curveTo(30.723043, 35.335163, 28.484375, 35.0, 27.984375, 35.0);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_1_0_5;
    g.setTransform(defaultTransform__0_1_0_5);
    g.setClip(clip__0_1_0_5);
    float alpha__0_1_0_6 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_6 = g.getClip();
    AffineTransform defaultTransform__0_1_0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_0_6 is ShapeNode
    paint = new Color(239, 41, 41, 255);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(21.743534, 20.953165);
    ((GeneralPath) shape).lineTo(22.804193, 25.107418);
    ((GeneralPath) shape).lineTo(22.936775, 22.698835);
    ((GeneralPath) shape).curveTo(23.934671, 22.956944, 24.241106, 24.509592, 24.925512, 25.39468);
    ((GeneralPath) shape).curveTo(25.679361, 24.879639, 26.703506, 24.284899, 27.400387, 23.42804);
    ((GeneralPath) shape).lineTo(29.389124, 24.886448);
    ((GeneralPath) shape).lineTo(30.847532, 22.9861);
    ((GeneralPath) shape).lineTo(32.968853, 25.019032);
    ((GeneralPath) shape).lineTo(35.708893, 23.162876);
    ((GeneralPath) shape).lineTo(35.266953, 21.041555);
    ((GeneralPath) shape).lineTo(32.438526, 23.781595);
    ((GeneralPath) shape).lineTo(30.140429, 20.997362);
    ((GeneralPath) shape).curveTo(29.80531, 22.035887, 29.448578, 23.117634, 29.168156, 24.04676);
    ((GeneralPath) shape).curveTo(28.40532, 23.250467, 27.937128, 22.15954, 27.046835, 21.32882);
    ((GeneralPath) shape).curveTo(26.696201, 22.181229, 26.418604, 23.131428, 24.704542, 24.04676);
    ((GeneralPath) shape).curveTo(24.091263, 22.70779, 23.345703, 21.477758, 21.743534, 20.953169);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    origAlpha = alpha__0_1_0_6;
    g.setTransform(defaultTransform__0_1_0_6);
    g.setClip(clip__0_1_0_6);
    float alpha__0_1_0_7 = origAlpha;
    origAlpha = origAlpha * 0.6f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_0_7 = g.getClip();
    AffineTransform defaultTransform__0_1_0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f));
    // _0_1_0_7 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(26.282012939453125, 28.0),
            new Point2D.Double(26.229612350463867, 34.544891357421875),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(255, 255, 255, 255), new Color(255, 255, 255, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    stroke = new BasicStroke(1.0f, 0, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(23.5, 28.5);
    ((GeneralPath) shape).lineTo(23.5, 32.0);
    ((GeneralPath) shape).curveTo(23.4984, 32.335457, 23.54743, 32.422497, 23.5625, 32.4375);
    ((GeneralPath) shape).curveTo(23.57757, 32.4525, 23.663807, 32.5, 24.0, 32.5);
    ((GeneralPath) shape).lineTo(35.0, 32.5);
    ((GeneralPath) shape).curveTo(35.010414, 32.499836, 35.020836, 32.499836, 35.03125, 32.5);
    ((GeneralPath) shape).curveTo(35.355663, 32.5068, 35.390083, 32.45384, 35.40625, 32.4375);
    ((GeneralPath) shape).curveTo(35.422417, 32.421165, 35.5, 32.334637, 35.5, 32.0);
    ((GeneralPath) shape).lineTo(35.5, 28.5);
    ((GeneralPath) shape).lineTo(23.5, 28.5);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_0_7;
    g.setTransform(defaultTransform__0_1_0_7);
    g.setClip(clip__0_1_0_7);
    origAlpha = alpha__0_1_0;
    g.setTransform(defaultTransform__0_1_0);
    g.setClip(clip__0_1_0);
    float alpha__0_1_1 = origAlpha;
    origAlpha = origAlpha * 1.0f;
    g.setComposite(AlphaComposite.getInstance(3, origAlpha));
    Shape clip__0_1_1 = g.getClip();
    AffineTransform defaultTransform__0_1_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_1_1 is ShapeNode
    paint =
        new LinearGradientPaint(
            new Point2D.Double(38.5, 26.718740463256836),
            new Point2D.Double(26.499988555908203, 23.9999942779541),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(186, 189, 182, 255), new Color(211, 215, 207, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.7071067690849304f, -19.445436477661133f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(40.207108, 6.0804515);
    ((GeneralPath) shape).lineTo(40.207108, 7.0286756);
    ((GeneralPath) shape).curveTo(40.207108, 7.5970173, 39.74956, 8.0545635, 39.18122, 8.0545635);
    ((GeneralPath) shape).lineTo(27.232998, 8.0545635);
    ((GeneralPath) shape).curveTo(26.664656, 8.0545635, 26.20711, 7.5970173, 26.20711, 7.0286756);
    ((GeneralPath) shape).lineTo(26.20711, 6.0804515);
    ((GeneralPath) shape).lineTo(40.207108, 6.0804515);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    paint =
        new LinearGradientPaint(
            new Point2D.Double(26.084016799926758, 25.42251205444336),
            new Point2D.Double(26.084016799926758, 28.000019073486328),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(85, 87, 83, 255), new Color(136, 138, 133, 255)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.7071067690849304f, -19.445436477661133f));
    stroke = new BasicStroke(0.9999997f, 1, 0, 4.0f, null, 0.0f);
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(40.207108, 6.0804515);
    ((GeneralPath) shape).lineTo(40.207108, 7.0286756);
    ((GeneralPath) shape).curveTo(40.207108, 7.5970173, 39.74956, 8.0545635, 39.18122, 8.0545635);
    ((GeneralPath) shape).lineTo(27.232998, 8.0545635);
    ((GeneralPath) shape).curveTo(26.664656, 8.0545635, 26.20711, 7.5970173, 26.20711, 7.0286756);
    ((GeneralPath) shape).lineTo(26.20711, 6.0804515);
    ((GeneralPath) shape).lineTo(40.207108, 6.0804515);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    origAlpha = alpha__0_1_1;
    g.setTransform(defaultTransform__0_1_1);
    g.setClip(clip__0_1_1);
    origAlpha = alpha__0_1;
    g.setTransform(defaultTransform__0_1);
    g.setClip(clip__0_1);
    origAlpha = alpha__0;
    g.setTransform(defaultTransform__0);
    g.setClip(clip__0);
    g.setTransform(defaultTransform_);
    g.setClip(clip_);
  }
  /**
   * Paints the transcoded SVG image on the specified graphics context. You can install a custom
   * transformation on the graphics context to scale the image.
   *
   * @param g Graphics context.
   */
  public static void paint(Graphics2D g) {
    Shape shape = null;
    Paint paint = null;
    Stroke stroke = null;

    float origAlpha = 1.0f;
    Composite origComposite = ((Graphics2D) g).getComposite();
    if (origComposite instanceof AlphaComposite) {
      AlphaComposite origAlphaComposite = (AlphaComposite) origComposite;
      if (origAlphaComposite.getRule() == AlphaComposite.SRC_OVER) {
        origAlpha = origAlphaComposite.getAlpha();
      }
    }

    AffineTransform defaultTransform_ = g.getTransform();
    //
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0
    g.setComposite(AlphaComposite.getInstance(3, 0.47368422f * origAlpha));
    AffineTransform defaultTransform__0_0_0 = g.getTransform();
    g.transform(
        new AffineTransform(
            1.4723349809646606f,
            0.0f,
            0.0f,
            0.2663849890232086f,
            -9.159070014953613f,
            37.48202896118164f));
    // _0_0_0
    paint =
        new RadialGradientPaint(
            new Point2D.Double(22.571428298950195, 30.85714340209961),
            15.571428f,
            new Point2D.Double(22.571428298950195, 30.85714340209961),
            new float[] {0.0f, 1.0f},
            new Color[] {new Color(0, 0, 0, 255), new Color(0, 0, 0, 0)},
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.0f,
                0.0f,
                0.0f,
                0.6513760089874268f,
                4.6386480336631404E-15f,
                10.757539749145508f));
    shape = new GeneralPath();
    ((GeneralPath) shape).moveTo(38.142857, 30.857143);
    ((GeneralPath) shape).curveTo(38.142857, 36.45889, 31.171291, 41.0, 22.571428, 41.0);
    ((GeneralPath) shape).curveTo(13.971566, 41.0, 7.0, 36.45889, 7.0, 30.857143);
    ((GeneralPath) shape).curveTo(7.0, 25.255398, 13.971566, 20.714287, 22.571428, 20.714287);
    ((GeneralPath) shape).curveTo(31.171291, 20.714287, 38.142857, 25.255398, 38.142857, 30.857143);
    ((GeneralPath) shape).closePath();
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_0);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_1 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_1
    paint =
        new LinearGradientPaint(
            new Point2D.Double(20.794008255004883, 18.378812789916992),
            new Point2D.Double(35.59600067138672, 39.600460052490234),
            new float[] {0.0f, 0.59928656f, 1.0f},
            new Color[] {
              new Color(248, 248, 247, 255),
              new Color(232, 232, 232, 255),
              new Color(226, 226, 222, 255)
            },
            MultipleGradientPaint.CycleMethod.NO_CYCLE,
            MultipleGradientPaint.ColorSpaceType.SRGB,
            new AffineTransform(
                1.3427040576934814f,
                0.0f,
                0.0f,
                1.2353780269622803f,
                -8.219611167907715f,
                -6.577188968658447f));
    shape =
        new RoundRectangle2D.Double(
            4.501601696014404,
            1.4968987703323364,
            38.99679183959961,
            45.00310134887695,
            1.133015751838684,
            1.1330164670944214);
    g.setPaint(paint);
    g.fill(shape);
    paint = new Color(136, 138, 133, 255);
    stroke = new BasicStroke(0.99999976f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new RoundRectangle2D.Double(
            4.501601696014404,
            1.4968987703323364,
            38.99679183959961,
            45.00310134887695,
            1.133015751838684,
            1.1330164670944214);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_1);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_2 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_2
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(22.0, 10.0, 14.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_2);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_3 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_3
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(22.0, 16.0, 12.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_3);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_4 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_4
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 22.0, 22.97153091430664, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_4);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_5 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_5
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 28.0, 27.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_5);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_6 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_6
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 34.0, 17.0, 2.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_6);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_7 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_7
    paint = new Color(255, 255, 255, 255);
    stroke = new BasicStroke(1.0f, 0, 0, 4.0f, null, 0.0f);
    shape =
        new Rectangle2D.Double(
            5.499715328216553, 2.4997177124023438, 37.00001907348633, 43.022315979003906);
    g.setPaint(paint);
    g.setStroke(stroke);
    g.draw(shape);
    g.setTransform(defaultTransform__0_0_7);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_8 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_8
    paint = new Color(153, 153, 153, 255);
    shape = new Rectangle2D.Double(9.0, 10.0, 11.0, 10.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_8);
    g.setComposite(AlphaComposite.getInstance(3, 0.49999997f * origAlpha));
    AffineTransform defaultTransform__0_0_9 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_9
    paint = new Color(114, 159, 207, 255);
    shape = new Rectangle2D.Double(8.0, 14.0, 29.0, 6.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_9);
    g.setComposite(AlphaComposite.getInstance(3, 0.49999997f * origAlpha));
    AffineTransform defaultTransform__0_0_10 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_10
    paint = new Color(114, 159, 207, 255);
    shape = new Rectangle2D.Double(8.0, 8.0, 31.0, 6.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_10);
    g.setComposite(AlphaComposite.getInstance(3, 0.5f * origAlpha));
    AffineTransform defaultTransform__0_0_11 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_11
    paint = new Color(114, 159, 207, 255);
    shape = new Rectangle2D.Double(8.0, 20.0, 25.0, 6.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_11);
    g.setComposite(AlphaComposite.getInstance(3, 0.5f * origAlpha));
    AffineTransform defaultTransform__0_0_12 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_12
    paint = new Color(114, 159, 207, 255);
    shape = new Rectangle2D.Double(8.0, 26.0, 29.0, 6.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_12);
    g.setComposite(AlphaComposite.getInstance(3, 0.5f * origAlpha));
    AffineTransform defaultTransform__0_0_13 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_13
    paint = new Color(114, 159, 207, 255);
    shape = new Rectangle2D.Double(8.0, 32.0, 19.0, 6.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_13);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_14 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_14
    paint = new Color(0, 0, 0, 255);
    shape = new Rectangle2D.Double(28.0, 32.0, 1.0, 7.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_14);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_15 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_15
    paint = new Color(0, 0, 0, 255);
    shape = new Rectangle2D.Double(27.0, 31.0, 1.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_15);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_16 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_16
    paint = new Color(0, 0, 0, 255);
    shape = new Rectangle2D.Double(29.0, 31.0, 1.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_16);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_17 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_17
    paint = new Color(0, 0, 0, 255);
    shape = new Rectangle2D.Double(29.0, 39.0, 1.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_17);
    g.setComposite(AlphaComposite.getInstance(3, 1.0f * origAlpha));
    AffineTransform defaultTransform__0_0_18 = g.getTransform();
    g.transform(new AffineTransform(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f));
    // _0_0_18
    paint = new Color(0, 0, 0, 255);
    shape = new Rectangle2D.Double(27.0, 39.0, 1.0, 1.0);
    g.setPaint(paint);
    g.fill(shape);
    g.setTransform(defaultTransform__0_0_18);
    g.setTransform(defaultTransform__0_0);
    g.setTransform(defaultTransform__0);
    g.setTransform(defaultTransform_);
  }
  @Override
  protected void paintSymbol(GeneralPath symbol, Dimension dimensions) {

    int imageWidth = (int) dimensions.getWidth();
    int imageHeight = (int) dimensions.getHeight();

    symbol.setWindingRule(Path2D.WIND_EVEN_ODD);
    symbol.moveTo(imageWidth * 0.4953271028037383, imageHeight * 0.4766355140186916);
    symbol.curveTo(
        imageWidth * 0.5186915887850467,
        imageHeight * 0.4766355140186916,
        imageWidth * 0.5327102803738317,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.5327102803738317,
        imageHeight * 0.514018691588785);
    symbol.curveTo(
        imageWidth * 0.5327102803738317,
        imageHeight * 0.5327102803738317,
        imageWidth * 0.5186915887850467,
        imageHeight * 0.5514018691588785,
        imageWidth * 0.4953271028037383,
        imageHeight * 0.5514018691588785);
    symbol.curveTo(
        imageWidth * 0.4766355140186916,
        imageHeight * 0.5514018691588785,
        imageWidth * 0.45794392523364486,
        imageHeight * 0.5327102803738317,
        imageWidth * 0.45794392523364486,
        imageHeight * 0.514018691588785);
    symbol.curveTo(
        imageWidth * 0.45794392523364486,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.4766355140186916,
        imageWidth * 0.4953271028037383,
        imageHeight * 0.4766355140186916);
    symbol.closePath();
    symbol.moveTo(imageWidth * 0.42990654205607476, imageHeight * 0.5233644859813084);
    symbol.curveTo(
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5233644859813084,
        imageWidth * 0.411214953271028,
        imageHeight * 0.5280373831775701,
        imageWidth * 0.411214953271028,
        imageHeight * 0.5280373831775701);
    symbol.curveTo(
        imageWidth * 0.38317757009345793,
        imageHeight * 0.5280373831775701,
        imageWidth * 0.37850467289719625,
        imageHeight * 0.5,
        imageWidth * 0.3317757009345794,
        imageHeight * 0.5);
    symbol.curveTo(
        imageWidth * 0.3130841121495327,
        imageHeight * 0.5046728971962616,
        imageWidth * 0.29439252336448596,
        imageHeight * 0.514018691588785,
        imageWidth * 0.27102803738317754,
        imageHeight * 0.5420560747663551);
    symbol.curveTo(
        imageWidth * 0.2570093457943925,
        imageHeight * 0.5700934579439252,
        imageWidth * 0.27102803738317754,
        imageHeight * 0.6869158878504673,
        imageWidth * 0.38317757009345793,
        imageHeight * 0.6869158878504673);
    symbol.curveTo(
        imageWidth * 0.38317757009345793,
        imageHeight * 0.6869158878504673,
        imageWidth * 0.4532710280373832,
        imageHeight * 0.6915887850467289,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.6214953271028038);
    symbol.curveTo(
        imageWidth * 0.4766355140186916,
        imageHeight * 0.6214953271028038,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.602803738317757,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.5794392523364486);
    symbol.curveTo(
        imageWidth * 0.48598130841121495,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.49065420560747663,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.4953271028037383,
        imageHeight * 0.5794392523364486);
    symbol.curveTo(
        imageWidth * 0.5093457943925234,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.5186915887850467,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.5233644859813084,
        imageHeight * 0.5747663551401869);
    symbol.curveTo(
        imageWidth * 0.5233644859813084,
        imageHeight * 0.5747663551401869,
        imageWidth * 0.5280373831775701,
        imageHeight * 0.5887850467289719,
        imageWidth * 0.5280373831775701,
        imageHeight * 0.5887850467289719);
    symbol.curveTo(
        imageWidth * 0.5280373831775701,
        imageHeight * 0.616822429906542,
        imageWidth * 0.5,
        imageHeight * 0.6214953271028038,
        imageWidth * 0.5,
        imageHeight * 0.6728971962616822);
    symbol.curveTo(
        imageWidth * 0.5046728971962616,
        imageHeight * 0.6915887850467289,
        imageWidth * 0.514018691588785,
        imageHeight * 0.705607476635514,
        imageWidth * 0.5420560747663551,
        imageHeight * 0.7289719626168224);
    symbol.curveTo(
        imageWidth * 0.5747663551401869,
        imageHeight * 0.7429906542056075,
        imageWidth * 0.6915887850467289,
        imageHeight * 0.7289719626168224,
        imageWidth * 0.6915887850467289,
        imageHeight * 0.616822429906542);
    symbol.curveTo(
        imageWidth * 0.6915887850467289,
        imageHeight * 0.616822429906542,
        imageWidth * 0.6915887850467289,
        imageHeight * 0.5467289719626168,
        imageWidth * 0.6214953271028038,
        imageHeight * 0.5233644859813084);
    symbol.curveTo(
        imageWidth * 0.6214953271028038,
        imageHeight * 0.5233644859813084,
        imageWidth * 0.5981308411214953,
        imageHeight * 0.5046728971962616,
        imageWidth * 0.5654205607476636,
        imageHeight * 0.5093457943925234);
    symbol.curveTo(
        imageWidth * 0.5654205607476636,
        imageHeight * 0.5,
        imageWidth * 0.5607476635514018,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.5560747663551402,
        imageHeight * 0.48598130841121495);
    symbol.curveTo(
        imageWidth * 0.5654205607476636,
        imageHeight * 0.48130841121495327,
        imageWidth * 0.5794392523364486,
        imageHeight * 0.4766355140186916,
        imageWidth * 0.5934579439252337,
        imageHeight * 0.4719626168224299);
    symbol.curveTo(
        imageWidth * 0.616822429906542,
        imageHeight * 0.4719626168224299,
        imageWidth * 0.6214953271028038,
        imageHeight * 0.5,
        imageWidth * 0.6728971962616822,
        imageHeight * 0.5);
    symbol.curveTo(
        imageWidth * 0.6915887850467289,
        imageHeight * 0.4953271028037383,
        imageWidth * 0.7102803738317757,
        imageHeight * 0.48598130841121495,
        imageWidth * 0.7289719626168224,
        imageHeight * 0.45794392523364486);
    symbol.curveTo(
        imageWidth * 0.7429906542056075,
        imageHeight * 0.42990654205607476,
        imageWidth * 0.7289719626168224,
        imageHeight * 0.3130841121495327,
        imageWidth * 0.616822429906542,
        imageHeight * 0.3130841121495327);
    symbol.curveTo(
        imageWidth * 0.616822429906542,
        imageHeight * 0.3130841121495327,
        imageWidth * 0.5514018691588785,
        imageHeight * 0.308411214953271,
        imageWidth * 0.5233644859813084,
        imageHeight * 0.37850467289719625);
    symbol.curveTo(
        imageWidth * 0.5233644859813084,
        imageHeight * 0.37850467289719625,
        imageWidth * 0.5046728971962616,
        imageHeight * 0.411214953271028,
        imageWidth * 0.5093457943925234,
        imageHeight * 0.4485981308411215);
    symbol.curveTo(
        imageWidth * 0.5046728971962616,
        imageHeight * 0.4485981308411215,
        imageWidth * 0.5,
        imageHeight * 0.4485981308411215,
        imageWidth * 0.4953271028037383,
        imageHeight * 0.4485981308411215);
    symbol.curveTo(
        imageWidth * 0.4953271028037383,
        imageHeight * 0.4485981308411215,
        imageWidth * 0.49065420560747663,
        imageHeight * 0.4485981308411215,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.4485981308411215);
    symbol.curveTo(
        imageWidth * 0.48598130841121495,
        imageHeight * 0.4392523364485981,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.4252336448598131,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.411214953271028);
    symbol.curveTo(
        imageWidth * 0.4766355140186916,
        imageHeight * 0.38317757009345793,
        imageWidth * 0.5,
        imageHeight * 0.37850467289719625,
        imageWidth * 0.5,
        imageHeight * 0.32710280373831774);
    symbol.curveTo(
        imageWidth * 0.5,
        imageHeight * 0.308411214953271,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.29439252336448596,
        imageWidth * 0.45794392523364486,
        imageHeight * 0.27102803738317754);
    symbol.curveTo(
        imageWidth * 0.42990654205607476,
        imageHeight * 0.2570093457943925,
        imageWidth * 0.3130841121495327,
        imageHeight * 0.27102803738317754,
        imageWidth * 0.3130841121495327,
        imageHeight * 0.38317757009345793);
    symbol.curveTo(
        imageWidth * 0.3130841121495327,
        imageHeight * 0.38317757009345793,
        imageWidth * 0.3130841121495327,
        imageHeight * 0.4532710280373832,
        imageWidth * 0.37850467289719625,
        imageHeight * 0.4766355140186916);
    symbol.curveTo(
        imageWidth * 0.37850467289719625,
        imageHeight * 0.4766355140186916,
        imageWidth * 0.40186915887850466,
        imageHeight * 0.49065420560747663,
        imageWidth * 0.43457943925233644,
        imageHeight * 0.49065420560747663);
    symbol.curveTo(
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5,
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5046728971962616,
        imageWidth * 0.42990654205607476,
        imageHeight * 0.514018691588785);
    symbol.curveTo(
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5186915887850467,
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5186915887850467,
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5233644859813084);
    symbol.closePath();
  }
Example #30
0
  @Override
  protected void paintSymbol(GeneralPath symbol, Dimension dimensions) {

    int imageWidth = (int) dimensions.getWidth();
    int imageHeight = (int) dimensions.getHeight();

    symbol.setWindingRule(Path2D.WIND_EVEN_ODD);
    symbol.moveTo(imageWidth * 0.42990654205607476, imageHeight * 0.5794392523364486);
    symbol.curveTo(
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.29906542056074764,
        imageHeight * 0.43457943925233644,
        imageWidth * 0.29906542056074764,
        imageHeight * 0.43457943925233644);
    symbol.curveTo(
        imageWidth * 0.40654205607476634,
        imageHeight * 0.3364485981308411,
        imageWidth * 0.5934579439252337,
        imageHeight * 0.3364485981308411,
        imageWidth * 0.705607476635514,
        imageHeight * 0.43457943925233644);
    symbol.curveTo(
        imageWidth * 0.705607476635514,
        imageHeight * 0.43457943925233644,
        imageWidth * 0.5747663551401869,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.5747663551401869,
        imageHeight * 0.5794392523364486);
    symbol.curveTo(
        imageWidth * 0.5514018691588785,
        imageHeight * 0.5560747663551402,
        imageWidth * 0.514018691588785,
        imageHeight * 0.5514018691588785,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.5560747663551402);
    symbol.curveTo(
        imageWidth * 0.4766355140186916,
        imageHeight * 0.5560747663551402,
        imageWidth * 0.40186915887850466,
        imageHeight * 0.4158878504672897,
        imageWidth * 0.40186915887850466,
        imageHeight * 0.4158878504672897);
    symbol.curveTo(
        imageWidth * 0.40186915887850466,
        imageHeight * 0.411214953271028,
        imageWidth * 0.3925233644859813,
        imageHeight * 0.40654205607476634,
        imageWidth * 0.3878504672897196,
        imageHeight * 0.411214953271028);
    symbol.curveTo(
        imageWidth * 0.37850467289719625,
        imageHeight * 0.4158878504672897,
        imageWidth * 0.37850467289719625,
        imageHeight * 0.4252336448598131,
        imageWidth * 0.38317757009345793,
        imageHeight * 0.42990654205607476);
    symbol.curveTo(
        imageWidth * 0.38317757009345793,
        imageHeight * 0.42990654205607476,
        imageWidth * 0.4532710280373832,
        imageHeight * 0.5654205607476636,
        imageWidth * 0.4532710280373832,
        imageHeight * 0.5654205607476636);
    symbol.curveTo(
        imageWidth * 0.4439252336448598,
        imageHeight * 0.5700934579439252,
        imageWidth * 0.43457943925233644,
        imageHeight * 0.5747663551401869,
        imageWidth * 0.42990654205607476,
        imageHeight * 0.5794392523364486);
    symbol.closePath();
    symbol.moveTo(imageWidth * 0.4205607476635514, imageHeight * 0.602803738317757);
    symbol.curveTo(
        imageWidth * 0.43457943925233644,
        imageHeight * 0.5934579439252337,
        imageWidth * 0.4485981308411215,
        imageHeight * 0.5841121495327103,
        imageWidth * 0.46261682242990654,
        imageHeight * 0.5794392523364486);
    symbol.curveTo(
        imageWidth * 0.46261682242990654,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.48130841121495327,
        imageHeight * 0.616822429906542,
        imageWidth * 0.48130841121495327,
        imageHeight * 0.616822429906542);
    symbol.curveTo(
        imageWidth * 0.4719626168224299,
        imageHeight * 0.6261682242990654,
        imageWidth * 0.4719626168224299,
        imageHeight * 0.6355140186915887,
        imageWidth * 0.4766355140186916,
        imageHeight * 0.6495327102803738);
    symbol.curveTo(
        imageWidth * 0.48598130841121495,
        imageHeight * 0.6635514018691588,
        imageWidth * 0.5046728971962616,
        imageHeight * 0.6682242990654206,
        imageWidth * 0.5186915887850467,
        imageHeight * 0.6588785046728972);
    symbol.curveTo(
        imageWidth * 0.5327102803738317,
        imageHeight * 0.6542056074766355,
        imageWidth * 0.5373831775700935,
        imageHeight * 0.6355140186915887,
        imageWidth * 0.5327102803738317,
        imageHeight * 0.6214953271028038);
    symbol.curveTo(
        imageWidth * 0.5233644859813084,
        imageHeight * 0.6121495327102804,
        imageWidth * 0.514018691588785,
        imageHeight * 0.602803738317757,
        imageWidth * 0.5046728971962616,
        imageHeight * 0.602803738317757);
    symbol.curveTo(
        imageWidth * 0.5046728971962616,
        imageHeight * 0.602803738317757,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.5747663551401869,
        imageWidth * 0.48598130841121495,
        imageHeight * 0.5747663551401869);
    symbol.curveTo(
        imageWidth * 0.5186915887850467,
        imageHeight * 0.5700934579439252,
        imageWidth * 0.5514018691588785,
        imageHeight * 0.5794392523364486,
        imageWidth * 0.5794392523364486,
        imageHeight * 0.602803738317757);
    symbol.curveTo(
        imageWidth * 0.5794392523364486,
        imageHeight * 0.602803738317757,
        imageWidth * 0.7336448598130841,
        imageHeight * 0.42990654205607476,
        imageWidth * 0.7336448598130841,
        imageHeight * 0.42990654205607476);
    symbol.curveTo(
        imageWidth * 0.5981308411214953,
        imageHeight * 0.308411214953271,
        imageWidth * 0.40186915887850466,
        imageHeight * 0.3130841121495327,
        imageWidth * 0.26635514018691586,
        imageHeight * 0.42990654205607476);
    symbol.curveTo(
        imageWidth * 0.26635514018691586,
        imageHeight * 0.42990654205607476,
        imageWidth * 0.4205607476635514,
        imageHeight * 0.602803738317757,
        imageWidth * 0.4205607476635514,
        imageHeight * 0.602803738317757);
    symbol.closePath();
  }