/** {@inheritDoc} */
 @Override
 protected synchronized void fillShape(final Graphics graphics) {
   Rectangle figureBounds = getClientArea();
   if (!transparent) {
     if (isEnabled()) graphics.setBackgroundColor(getBackgroundColor());
     if (gradient && useAdvancedGraphics) {
       graphics.setForegroundColor(backGradientStartColor);
       graphics.fillGradient(figureBounds, horizontalFill);
     } else graphics.fillRectangle(figureBounds);
   }
   if (getFill() > 0) {
     if (isEnabled()) graphics.setBackgroundColor(getForegroundColor());
     Rectangle fillRectangle;
     if (horizontalFill) {
       int newW = (int) Math.round(figureBounds.width * (getFill() / 100));
       fillRectangle = new Rectangle(figureBounds.x, figureBounds.y, newW, figureBounds.height);
     } else {
       int newH = (int) Math.round(figureBounds.height * (getFill() / 100));
       fillRectangle =
           new Rectangle(
               figureBounds.x,
               figureBounds.y + figureBounds.height - newH,
               figureBounds.width,
               newH);
     }
     if (gradient && useAdvancedGraphics) {
       graphics.setForegroundColor(foreGradientStartColor);
       graphics.fillGradient(fillRectangle, horizontalFill);
     } else graphics.fillRectangle(fillRectangle);
   }
 }
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.draw2d.IFigure#paint(org.eclipse.draw2d.Graphics)
  */
 public void paint(Graphics graphics) {
   if (!isVisible()) return;
   if (uncheckedImage != null) {
     if (hilite) {
       if (state == false) graphics.drawImage(uncheckedHiliteImage, getLocation());
       else graphics.drawImage(checkedHiliteImage, getLocation());
     } else {
       if (state == false) graphics.drawImage(uncheckedImage, getLocation());
       else graphics.drawImage(checkedImage, getLocation());
     }
   } else {
     Iterator<Rectangle> iter = null;
     if (state == false) iter = uncheckedRects.iterator();
     else iter = checkedRects.iterator();
     while (iter.hasNext()) {
       Point p = getLocation();
       Rectangle r = iter.next().getCopy();
       r = r.translate(p.x, p.y);
       graphics.setForegroundColor(getForegroundColor());
       if (hilite) graphics.setBackgroundColor(ColorConstants.lightBlue);
       else graphics.setBackgroundColor(ColorConstants.white);
       graphics.fillRectangle(r);
       graphics.drawRectangle(r);
     }
   }
 }
 /**
  * The main drawing routine.
  *
  * @param gfx The {@link Graphics} to use
  */
 @Override
 public synchronized void paintFigure(final Graphics gfx) {
   if (isLoadingImage()) return;
   Rectangle bounds = getBounds().getCopy();
   ImageUtils.crop(bounds, this.getInsets());
   IPath imagePath = booleanValue ? onImagePath : offImagePath;
   if (loadingError) {
     if (!imagePath.isEmpty()) {
       gfx.setBackgroundColor(getBackgroundColor());
       gfx.setForegroundColor(getForegroundColor());
       gfx.fillRectangle(bounds);
       gfx.translate(bounds.getLocation());
       TextPainter.drawText(
           gfx,
           "ERROR in loading image\n" + imagePath,
           bounds.width / 2,
           bounds.height / 2,
           TextPainter.CENTER);
     }
     return;
   }
   Color currentcolor = null;
   if (useForegroundColor) currentcolor = getForegroundColor();
   else currentcolor = booleanValue ? onColor : offColor;
   getCurrentImage().setCurrentColor(currentcolor);
   getCurrentImage().setBounds(bounds);
   getCurrentImage().setBorder(getBorder());
   getCurrentImage().setAbsoluteScale(gfx.getAbsoluteScale());
   getCurrentImage().paintFigure(gfx);
   if (!isEnabled()) {
     gfx.setAlpha(DISABLED_ALPHA);
     gfx.setBackgroundColor(DISABLE_COLOR);
     gfx.fillRectangle(bounds);
   }
 }
  @Override
  public void paint(Graphics graphics) {
    graphics.setBackgroundColor(NodeUtil.BG_COLOR);

    if (node.getGraph().getRule() != null) {
      Rule rule = node.getGraph().getRule();
      if (!NodeUtil.nodeIsMapped(node, rule.getMappings())) {
        if (node.getGraph().isLhs()) graphics.setBackgroundColor(NodeUtil.BG_COLOR_DELETED);
        if (node.getGraph().isRhs()) graphics.setBackgroundColor(NodeUtil.BG_COLOR_CREATED);
      }
    }
    super.paint(graphics);
  }
  /** @see org.eclipse.draw2d.Figure#paintFigure(Graphics) */
  protected void paintFigure(Graphics g) {
    IMapMode mm = MapModeUtil.getMapMode(this);
    Rectangle displayRectangle =
        new Rectangle(mm.DPtoLP(15), mm.DPtoLP(11), mm.DPtoLP(31), mm.DPtoLP(25));
    Rectangle displayShadow =
        new Rectangle(mm.DPtoLP(14), mm.DPtoLP(10), mm.DPtoLP(32), mm.DPtoLP(26));
    Rectangle displayHighlight =
        new Rectangle(mm.DPtoLP(15), mm.DPtoLP(11), mm.DPtoLP(32), mm.DPtoLP(26));
    Point valuePoint = new Point(mm.DPtoLP(16), mm.DPtoLP(10));

    int Y1 = mm.DPtoLP(0);
    int Y2 = mm.DPtoLP(44);

    Rectangle r = getBounds().getCopy();

    g.translate(r.getLocation());
    g.fillRectangle(mm.DPtoLP(0), mm.DPtoLP(0), r.width, r.height /*- MapMode.DPtoLP(4)*/);
    int right = r.width - 1;
    g.drawLine(mm.DPtoLP(0), Y1, right, Y1);
    g.drawLine(mm.DPtoLP(0), Y1, mm.DPtoLP(0), Y2);

    g.drawLine(mm.DPtoLP(0), Y2, right, Y2);
    g.drawLine(right, Y1, right, Y2);

    // Draw the display
    RGB whiteColor = ColorConstants.white.getRGB();
    RGB backgroundColor = getBackgroundColor().getRGB();
    RGB newHightlightRGB =
        new RGB(
            (whiteColor.red + backgroundColor.red) / 2,
            (whiteColor.green + backgroundColor.green) / 2,
            (whiteColor.blue + backgroundColor.blue) / 2);
    g.setBackgroundColor(DiagramColorRegistry.getInstance().getColor(newHightlightRGB));
    g.fillRectangle(displayHighlight);
    RGB blackColor = ColorConstants.black.getRGB();
    RGB newShadowRGB =
        new RGB(
            (blackColor.red + backgroundColor.red) / 2,
            (blackColor.green + backgroundColor.green) / 2,
            (blackColor.blue + backgroundColor.blue) / 2);
    g.setBackgroundColor(DiagramColorRegistry.getInstance().getColor(newShadowRGB));
    g.fillRectangle(displayShadow);

    g.setBackgroundColor(ColorConstants.black);
    g.fillRectangle(displayRectangle);

    // Draw the value
    g.setForegroundColor(getFontColor());
    g.drawText(value, valuePoint);
  }
Beispiel #6
0
  @Override
  protected void paintFigure(Graphics graphics) {
    graphics.setAntialias(SWT.ON);

    Rectangle bounds = getBounds().getCopy();

    graphics.setForegroundColor(getFillColor());
    graphics.setBackgroundColor(ColorFactory.getLighterColor(getFillColor(), 0.9f));
    graphics.fillGradient(bounds, false);

    // Border
    if (getBorderColor() != null) {
      graphics.setForegroundColor(ColorFactory.getLighterColor(getBorderColor(), 0.82f));
      graphics.drawLine(bounds.x, bounds.y, bounds.x + bounds.width - 1, bounds.y);
      graphics.drawLine(
          bounds.x + bounds.width - 1,
          bounds.y,
          bounds.x + bounds.width - 1,
          bounds.y + bounds.height - 1);

      graphics.setForegroundColor(getBorderColor());
      graphics.drawLine(bounds.x, bounds.y, bounds.x, bounds.y + bounds.height - 1);
      graphics.drawLine(
          bounds.x,
          bounds.y + bounds.height - 1,
          bounds.x + bounds.width - 1,
          bounds.y + bounds.height - 1);
    }

    fIconicDelegate.drawIcon(graphics, bounds);
  }
 /**
  * Fills the circle.
  *
  * @param graphics the graphics
  * @see org.eclipse.draw2d.Shape#fillShape(org.eclipse.draw2d.Graphics)
  */
 protected void fillShape(Graphics graphics) {
   graphics.pushState();
   graphics.setBackgroundColor(ColorConstants.white);
   graphics.fillOval(getBounds());
   graphics.popState();
   Dimension dim = new Dimension(20, 20);
   this.setMaximumSize(dim);
 }
 @Override
 protected void fillShape(Graphics graphics) {
   if (shouldUseGradient()) {
     graphics.pushState();
     graphics.setBackgroundColor(DiagramColorConstants.white);
     graphics.setForegroundColor(getBackgroundColor());
     graphics.fillGradient(getBounds(), true);
     graphics.popState();
   } else {
     super.fillShape(graphics);
   }
 }
  /**
   * If the rendering is occuring on a separate thread, this method is a hook to draw a temporary
   * image onto the drawing surface.
   *
   * @param g the <code>Graphics</code> object to paint the temporary image to
   */
  protected void paintFigureWhileRendering(Graphics g) {
    Rectangle area = getClientArea().getCopy();

    g.pushState();
    g.setBackgroundColor(ColorConstants.white);
    g.fillRectangle(area.x, area.y, area.width - 1, area.height - 1);
    g.setForegroundColor(ColorConstants.red);
    g.drawRectangle(area.x, area.y, area.width - 1, area.height - 1);
    g.setLineStyle(SWT.LINE_DOT);
    g.drawLine(area.x, area.y, area.x + area.width, area.y + area.height);
    g.drawLine(area.x + area.width, area.y, area.x, area.y + area.height);
    g.popState();
  }
  @Override
  protected void paintFigure(final org.eclipse.draw2d.Graphics graphics) {
    if (!getBackgroundColor().isDisposed()) {
      graphics.setBackgroundColor(getBackgroundColor());
    }
    final int boxWidth = getBounds().height / HALF;
    final int laneYStart = getBounds().y;
    final int y = laneYStart + boxWidth / HALF;
    graphics.fillRectangle(3, y, boxWidth, boxWidth);
    graphics.drawRectangle(3, y, boxWidth, boxWidth);

    final int textXOffset = getBounds().height;
    graphics.drawString(user.getName(), textXOffset, laneYStart);
  }
 @Override
 public void paintFigure(Graphics g) {
   Rectangle r = getBounds();
   r.shrink(1, 1);
   try {
     g.setBackgroundColor(getFillColor());
     g.fillOval(r);
     g.setForegroundColor(getLineColor());
     g.drawOval(r);
   } finally {
     // We don't really own rect 'r', so fix it.
     r.expand(1, 1);
   }
 }
Beispiel #12
0
  @Override
  public void paintFigure(Graphics graphics) {
    graphics.pushState();

    graphics.setAntialias(SWT.ON);

    if (!isEnabled()) {
      setDisabledState(graphics);
    }

    graphics.setBackgroundColor(getFillColor());
    graphics.fillOval(bounds.getCopy());

    graphics.popState();
  }
Beispiel #13
0
  protected void paintFigure(Graphics g) {
    super.paintFigure(g);

    Rectangle bounds = getBounds();
    Rectangle nameBounds = getContentPane(1).getBounds();
    Rectangle r = Rectangle.SINGLETON;

    r.setLocation(nameBounds.x - 3, nameBounds.y);
    r.setSize(bounds.width - 4, nameBounds.height);
    g.setBackgroundColor(FigurePrefs.lightBlueColor);
    g.fillRectangle(r);

    int baseline = getLayoutManager().getBaseline(0) + 1;
    Rectangle ruleBounds = getContentPane(0).getClientArea();

    g.setForegroundColor(FigurePrefs.relationsColor);
    g.drawLine(bounds.x, baseline, ruleBounds.x, baseline);
    g.drawLine(ruleBounds.right() - 1, baseline, bounds.right(), baseline);
  }
  public void drawIcon(Graphics graphics, Point origin) {
    graphics.pushState();

    graphics.setLineWidth(1);

    // fills
    graphics.setForegroundColor(blue3);
    graphics.setBackgroundColor(blue4);
    graphics.fillGradient(origin.x, origin.y, 5, 5, true);
    graphics.fillGradient(origin.x, origin.y + 9, 5, 5, true);

    graphics.setForegroundColor(blue1);

    // squares
    graphics.drawRectangle(origin.x, origin.y, 5, 5);
    graphics.drawRectangle(origin.x, origin.y + 9, 5, 5);

    graphics.drawRectangle(origin.x + 8, origin.y + 6, 2, 2); // little square

    // lines
    graphics.translate(7, 2);
    graphics.setForegroundColor(blue2);
    graphics.drawLine(origin.x, origin.y, origin.x + 6, origin.y);
    graphics.translate(0, 1);
    graphics.setForegroundColor(blue1);
    graphics.drawLine(origin.x, origin.y, origin.x + 6, origin.y);

    graphics.translate(0, 8);
    graphics.setForegroundColor(blue2);
    graphics.drawLine(origin.x, origin.y, origin.x + 6, origin.y);
    graphics.translate(0, 1);
    graphics.setForegroundColor(blue1);
    graphics.drawLine(origin.x, origin.y, origin.x + 6, origin.y);

    // small line
    graphics.translate(4, -5);
    graphics.setForegroundColor(blue1);
    graphics.drawLine(origin.x, origin.y, origin.x + 2, origin.y);

    graphics.popState();
  }
Beispiel #15
0
    @Override
    protected void fillShape(Graphics graphics) {
      graphics.setAntialias(SWT.ON);
      Pattern pattern = null;
      graphics.setBackgroundColor(GRAY_COLOR);
      boolean support3D = GraphicsUtil.testPatternSupported(graphics);
      if (effect3D && support3D) {
        // add this to eliminate the repaint bug on Mac
        graphics.fillOval(new Rectangle());

        pattern =
            new Pattern(
                Display.getCurrent(),
                bounds.x,
                bounds.y,
                bounds.x + bounds.width,
                bounds.y + bounds.height,
                WHITE_COLOR,
                BORDER_COLOR);
        graphics.setBackgroundPattern(pattern);
      }
      super.fillShape(graphics);
      if (effect3D && support3D) pattern.dispose();
    }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.draw2d.Shape#paintFigure(org.eclipse.draw2d.Graphics)
   */
  public void paintFigure(Graphics graphics) {
    graphics.setAntialias(SWT.LOW);
    super.paintFigure(graphics);
    graphics.pushState();
    graphics.setBackgroundColor(ColorConstants.black);

    /* Creates the cross in the circle */
    Rectangle rect1 = getBounds().getCopy();
    int scaleFactor_horizontale = rect1.height / 2;
    int scaleFactor_verticale = rect1.width / 2;
    Rectangle rect = getBounds().getCopy();
    graphics.drawLine(
        rect1.x,
        rect1.y + scaleFactor_horizontale,
        rect1.x + (int) Math.floor(rect1.width * (scaleFactor_horizontale)),
        rect1.y - (1 - scaleFactor_horizontale));
    graphics.drawLine(
        rect1.x + scaleFactor_verticale,
        rect1.y,
        rect1.x - (1 - scaleFactor_verticale),
        rect1.y + (int) Math.floor(rect1.height * (scaleFactor_verticale)));

    graphics.popState();
  }
Beispiel #17
0
  /** Draw the icon */
  protected void drawIcon(Graphics graphics) {
    graphics.setLineWidth(1);
    graphics.setForegroundColor(ColorConstants.black);
    graphics.setBackgroundColor(ColorConstants.black);

    Point pt = getIconOrigin();

    Path path = new Path(null);

    graphics.setLineWidthFloat(1.2f);
    path.addArc(pt.x, pt.y, 13, 13, 0, 360);

    graphics.drawPath(path);
    path.dispose();

    graphics.fillOval(pt.x + 5, pt.y + 5, 4, 4);

    graphics.setLineWidth(1);

    path = new Path(null);

    path.moveTo(pt.x - 2, pt.y + 6.5f);
    path.lineTo(pt.x + 15, pt.y + 6.5f);

    path.moveTo(pt.x + 6.5f, pt.y - 2);
    path.lineTo(pt.x + 6.5f, pt.y + 15);

    path.moveTo(pt.x + 0.5f, pt.y + 0.5f);
    path.lineTo(pt.x + 12.5f, pt.y + 12.5f);

    path.moveTo(pt.x + 0.5f, pt.y + 12.5f);
    path.lineTo(pt.x + 12.5f, pt.y + 0.5f);

    graphics.drawPath(path);
    path.dispose();
  }
  /** @see org.eclipse.draw2d.Figure#paintFigure(Graphics) */
  protected void paintFigure(Graphics g) {
    g.setXORMode(true);
    g.setForegroundColor(ColorConstants.white);

    g.setBackgroundColor(LogicColorConstants.ghostFillColor);

    Rectangle r = getBounds().getCopy();

    g.fillOval(r);
    r.height--;
    r.width--;
    g.drawOval(r);
    g.translate(r.getLocation());

    // Draw the "V"
    g.drawLine(3, 4, 5, 9);
    g.drawLine(5, 9, 7, 4);
    g.drawLine(5, 8, 5, 9);

    // Draw the "+"
    g.drawLine(9, 7, 9, 11);
    g.drawLine(7, 9, 11, 9);
    g.drawPoint(9, 9);
  }
Beispiel #19
0
    @Override
    protected void fillShape(Graphics graphics) {

      int fill_corner = DEFAULT_CORNER;
      // If this is more close to 1/2, more light the tank will be.
      double intersectFactor = 11d / 20d;
      if (bounds.width < 2 * DEFAULT_CORNER) intersectFactor = 12d / 20d;
      int rectWidth = (int) (bounds.width * intersectFactor);
      if (fill_corner > (2 * rectWidth - (bounds.width - 2 * getLineWidth())))
        fill_corner = 2 * rectWidth - bounds.width;

      corner.height = fill_corner;
      corner.width = fill_corner;
      graphics.setAntialias(SWT.ON);
      int valuePosition = ((LinearScale) scale).getValuePosition(getCoercedValue(), false);
      if (support3d == null) support3d = GraphicsUtil.testPatternSupported(graphics);

      if (effect3D && support3d) {
        graphics.setBackgroundColor(WHITE_COLOR);
        super.fillShape(graphics);
        // fill background
        Rectangle leftRectangle = new Rectangle(bounds.x, bounds.y, rectWidth, bounds.height);
        Pattern leftGradientPattern =
            GraphicsUtil.createScaledPattern(
                graphics,
                Display.getCurrent(),
                leftRectangle.x,
                leftRectangle.y,
                leftRectangle.x + leftRectangle.width + 2,
                leftRectangle.y,
                fillBackgroundColor,
                255,
                WHITE_COLOR,
                0);
        graphics.setBackgroundPattern(leftGradientPattern);
        graphics.fillRoundRectangle(leftRectangle, corner.width, corner.height);
        Rectangle rightRectangle =
            new Rectangle(bounds.x + bounds.width - rectWidth, bounds.y, rectWidth, bounds.height);
        Pattern rightGradientPattern =
            GraphicsUtil.createScaledPattern(
                graphics,
                Display.getCurrent(),
                rightRectangle.x - 2,
                rightRectangle.y,
                rightRectangle.x + rightRectangle.width,
                rightRectangle.y,
                WHITE_COLOR,
                0,
                fillBackgroundColor,
                255);
        graphics.setBackgroundPattern(rightGradientPattern);
        graphics.fillRoundRectangle(rightRectangle, corner.width, corner.height);
        leftGradientPattern.dispose();
        rightGradientPattern.dispose();

        // fill value
        graphics.setBackgroundColor(WHITE_COLOR);
        int fillHeight = bounds.height - (valuePosition - bounds.y) - getLineWidth();
        if (fillHeight > 0) {
          graphics.fillRoundRectangle(
              new Rectangle(bounds.x, valuePosition, bounds.width, fillHeight),
              fill_corner,
              fill_corner);
          leftRectangle = new Rectangle(bounds.x, valuePosition, rectWidth, fillHeight);
          leftGradientPattern =
              GraphicsUtil.createScaledPattern(
                  graphics,
                  Display.getCurrent(),
                  leftRectangle.x,
                  leftRectangle.y,
                  leftRectangle.x + leftRectangle.width + 2,
                  leftRectangle.y,
                  fillColor,
                  255,
                  WHITE_COLOR,
                  0);
          graphics.setBackgroundPattern(leftGradientPattern);
          graphics.fillRoundRectangle(leftRectangle, fill_corner, fill_corner);

          rightRectangle =
              new Rectangle(
                  bounds.x + bounds.width - rectWidth, valuePosition, rectWidth, fillHeight);
          rightGradientPattern =
              GraphicsUtil.createScaledPattern(
                  graphics,
                  Display.getCurrent(),
                  rightRectangle.x - 2,
                  rightRectangle.y,
                  rightRectangle.x + rightRectangle.width,
                  rightRectangle.y,
                  WHITE_COLOR,
                  0,
                  fillColor,
                  255);
          graphics.setBackgroundPattern(rightGradientPattern);
          graphics.fillRoundRectangle(rightRectangle, fill_corner, fill_corner);

          leftGradientPattern.dispose();
          rightGradientPattern.dispose();
        }
        graphics.setForegroundColor(EFFECT3D_OUTLINE_COLOR);

      } else {
        graphics.setBackgroundColor(fillBackgroundColor);
        super.fillShape(graphics);
        graphics.setBackgroundColor(fillColor);
        graphics.fillRoundRectangle(
            new Rectangle(
                bounds.x + lineWidth,
                valuePosition,
                bounds.width - 2 * lineWidth,
                bounds.height - (valuePosition - bounds.y)),
            fill_corner,
            fill_corner);
        //        graphics.setForegroundColor(outlineColor);
      }
    }
Beispiel #20
0
  @Override
  protected void paintClientArea(Graphics graphics) {
    graphics.setAntialias(SWT.ON);
    Rectangle area = getClientArea();
    area.width = Math.min(area.width, area.height);
    area.height = area.width;
    Pattern pattern = null;
    graphics.pushState();
    graphics.setBackgroundColor(GRAY_COLOR);
    boolean support3D = GraphicsUtil.testPatternSupported(graphics);
    if (effect3D && support3D) {
      // add this to eliminate the repaint bug on Mac
      graphics.fillOval(new Rectangle());
      pattern =
          new Pattern(
              Display.getCurrent(),
              area.x,
              area.y,
              area.x + area.width,
              area.y + area.height,
              BORDER_COLOR,
              WHITE_COLOR);
      graphics.setBackgroundPattern(pattern);
    }
    graphics.fillOval(area);
    graphics.popState();

    if (effect3D && support3D) {
      pattern.dispose();
      area.shrink(BORDER_WIDTH, BORDER_WIDTH);
    } else area.shrink(1, 1);

    graphics.fillOval(area);

    super.paintClientArea(graphics);

    // glossy effect
    if (effect3D && support3D) {
      graphics.pushState();
      graphics.setAntialias(SWT.ON);
      final double R = area.width / 2.0d;
      final double UD_FILL_PART = 9.5d / 10d;
      final double UP_DOWN_RATIO = 1d / 2d;
      final double LR_FILL_PART = 8.5d / 10d;
      final double UP_ANGLE = 0d * Math.PI / 180d;
      final double DOWN_ANGLE = 35d * Math.PI / 180d;
      // add this to eliminate the repaint bug on Mac

      graphics.fillOval(new Rectangle());

      Pattern glossyPattern =
          new Pattern(
              Display.getCurrent(),
              area.x + area.width / 2,
              (float) (area.y + area.height / 2 - R * UD_FILL_PART),
              area.x + area.width / 2,
              (float) (area.y + area.height / 2 + R * UP_DOWN_RATIO),
              WHITE_COLOR,
              90,
              WHITE_COLOR,
              0);
      graphics.setBackgroundPattern(glossyPattern);
      Rectangle rectangle =
          new Rectangle(
              (int) (area.x + area.width / 2 - R * LR_FILL_PART * Math.cos(UP_ANGLE)),
              (int) (area.y + area.height / 2 - R * UD_FILL_PART),
              (int) (2 * R * LR_FILL_PART * Math.cos(UP_ANGLE)),
              (int) (R * UD_FILL_PART + R * UP_DOWN_RATIO));
      graphics.fillOval(rectangle);
      glossyPattern.dispose();

      glossyPattern =
          new Pattern(
              Display.getCurrent(),
              area.x + area.width / 2,
              (float) (area.y + area.height / 2 + R * UP_DOWN_RATIO - 1),
              area.x + area.width / 2,
              (float) (area.y + area.height / 2 + R * UD_FILL_PART + 1),
              WHITE_COLOR,
              0,
              WHITE_COLOR,
              40);
      graphics.setBackgroundPattern(glossyPattern);
      rectangle =
          new Rectangle(
              (int) (area.x + area.width / 2 - R * LR_FILL_PART * Math.sin(DOWN_ANGLE)),
              (int) Math.ceil(area.y + area.height / 2 + R * UP_DOWN_RATIO),
              (int) (2 * R * LR_FILL_PART * Math.sin(DOWN_ANGLE)),
              (int) Math.ceil(R * UD_FILL_PART - R * UP_DOWN_RATIO));
      graphics.fillOval(rectangle);
      glossyPattern.dispose();
      graphics.popState();
    }
  }
Beispiel #21
0
  @Override
  protected void paintClientArea(Graphics graphics) {
    updateThresholdPosition();
    graphics.setAntialias(SWT.ON);
    graphics.setLineWidth(rampWidth);
    graphics.pushState();
    int overlap = 0;
    Pattern pattern = null;
    boolean support3D = GraphicsUtil.testPatternSupported(graphics);
    // draw lolo part
    if (lolo.visible) {
      graphics.setBackgroundColor(lolo.color);
      graphics.fillArc(bounds, lolo.absolutePosition, min.relativePosition - lolo.relativePosition);
    }
    // draw lo part
    if (lo.visible) {
      if (support3D && gradient && lolo.visible) {
        try {
          pattern =
              new Pattern(
                  Display.getCurrent(),
                  lolo.leftPoint.x,
                  lolo.leftPoint.y,
                  lo.rightPoint.x,
                  lo.rightPoint.y,
                  lolo.color,
                  lo.color);
          graphics.setBackgroundPattern(pattern);
          overlap = OVERLAP_DEGREE / 2;
        } catch (Exception e) {
          support3D = false;
          pattern.dispose();
          graphics.setBackgroundColor(lo.color);
          overlap = 0;
        }
      } else {
        graphics.setBackgroundColor(lo.color);
        overlap = 0;
      }

      if (lolo.visible)
        graphics.fillArc(
            bounds, lo.absolutePosition, lolo.relativePosition - lo.relativePosition + overlap);
      else
        graphics.fillArc(bounds, lo.absolutePosition, min.relativePosition - lo.relativePosition);
      if (gradient && lolo.visible && support3D) pattern.dispose();
    }

    // draw left normal part
    // get the left marker
    boolean leftMarkerVisible = false;
    ThresholdMarker leftMarker = null;
    if (lo.visible) {
      leftMarkerVisible = true;
      leftMarker = lo;
    } else if (lolo.visible) {
      leftMarkerVisible = true;
      leftMarker = lolo;
    } else leftMarkerVisible = false;

    if (gradient && leftMarkerVisible && support3D) {
      pattern =
          new Pattern(
              Display.getCurrent(),
              leftMarker.leftPoint.x,
              leftMarker.leftPoint.y,
              normal.rightPoint.x,
              normal.rightPoint.y,
              leftMarker.color,
              normal.color);
      graphics.setBackgroundPattern(pattern);
      overlap = OVERLAP_DEGREE / 2;
    } else {
      graphics.setBackgroundColor(normal.color);
      overlap = 0;
    }

    if (leftMarkerVisible)
      graphics.fillArc(
          bounds,
          normal.absolutePosition,
          leftMarker.relativePosition - normal.relativePosition + overlap);
    else
      graphics.fillArc(
          bounds, normal.absolutePosition, min.relativePosition - normal.relativePosition);

    if (gradient && leftMarkerVisible && support3D) pattern.dispose();

    // draw right normal part
    // get the right marker
    boolean rightMarkerVisible = false;
    ThresholdMarker rightMarker = null;
    if (hi.visible) {
      rightMarkerVisible = true;
      rightMarker = hi;
    } else if (hihi.visible) {
      rightMarkerVisible = true;
      rightMarker = hihi;
    } else rightMarkerVisible = false;

    if (gradient && rightMarkerVisible && support3D) {
      pattern =
          new Pattern(
              Display.getCurrent(),
              rightMarker.rightPoint.x,
              rightMarker.rightPoint.y,
              normal.leftPoint.x,
              normal.leftPoint.y,
              rightMarker.color,
              normal.color);
      graphics.setBackgroundPattern(pattern);
      overlap = OVERLAP_DEGREE / 2;
    } else {
      graphics.setBackgroundColor(normal.color);
      overlap = 0;
    }

    if (rightMarkerVisible)
      graphics.fillArc(
          bounds,
          rightMarker.absolutePosition,
          normal.relativePosition - rightMarker.relativePosition + overlap + 1);
    else
      graphics.fillArc(
          bounds, max.absolutePosition, normal.relativePosition - max.relativePosition + 1);

    if (gradient && rightMarkerVisible && support3D) pattern.dispose();

    // draw hi part
    if (hi.visible) {
      if (hihi.visible) {
        rightMarkerVisible = true;
        rightMarker = hihi;
      } else rightMarkerVisible = false;

      if (gradient && rightMarkerVisible && support3D) {
        pattern =
            new Pattern(
                Display.getCurrent(),
                rightMarker.rightPoint.x,
                rightMarker.rightPoint.y,
                hi.leftPoint.x,
                hi.leftPoint.y,
                rightMarker.color,
                hi.color);
        graphics.setBackgroundPattern(pattern);
        overlap = OVERLAP_DEGREE / 2;
      } else {
        graphics.setBackgroundColor(hi.color);
        overlap = 0;
      }

      if (rightMarkerVisible)
        graphics.fillArc(
            bounds,
            rightMarker.absolutePosition,
            hi.relativePosition - rightMarker.relativePosition + overlap);
      else
        graphics.fillArc(bounds, max.absolutePosition, hi.relativePosition - max.relativePosition);

      if (gradient && rightMarkerVisible && support3D) pattern.dispose();
    }

    // draw hihi part
    if (hihi.visible) {
      if (gradient && support3D) overlap = OVERLAP_DEGREE / 2;
      else overlap = 0;
      graphics.setBackgroundColor(hihi.color);
      graphics.fillArc(
          bounds, max.absolutePosition, hihi.relativePosition - max.relativePosition + overlap);
    }

    graphics.popState();
    graphics.fillOval(
        bounds.x + rampWidth,
        bounds.y + rampWidth,
        bounds.width - 2 * rampWidth,
        bounds.height - 2 * rampWidth);

    super.paintClientArea(graphics);
  }
  @Override
  protected void drawSymbol(Graphics g) {
    PointList points = null;

    super.drawSymbol(g);

    int centerPointX = (int) Math.ceil((H_EXTENT / 2.0f)); // Center point of odd #.

    switch (this.featureCategory) {
      case BUS_ACCESS:
      case DATA_ACCESS:
        // Configure GC.
        g.setForegroundColor(this.getForegroundColor());
        g.setBackgroundColor(ColorConstants.white);
        g.setLineWidth(2);

        // Create point list that defines the symbol.
        points = new PointList();

        /* Populate point list. */
        points.addPoint(centerPointX, 0);
        points.addPoint(0, V_EXTENT - 8);
        points.addPoint(0, V_EXTENT);
        points.addPoint(centerPointX, V_EXTENT - 2);
        points.addPoint(H_EXTENT, V_EXTENT);
        points.addPoint(H_EXTENT, V_EXTENT - 8);

        // Fill symbol.
        g.fillPolygon(points);
        // Draw symbol.
        g.drawPolygon(points);

        break;
      case SUBPROGRAM_ACCESS:
      case SUBPROGRAM_GROUP_ACCESS:
        // Configure GC
        if (this.featureCategory == FeatureAdapterCategory.SUBPROGRAM_ACCESS) {
          g.setBackgroundColor(ColorConstants.white);
          g.setForegroundColor(ColorConstants.black);
        } else {
          g.setBackgroundColor(ColorConstants.black);
          g.setForegroundColor(ColorConstants.white);
        }

        g.setLineCap(SWT.CAP_ROUND);
        g.setLineWidth(2);

        int ovalWidth = H_EXTENT;
        int ovalHeight = V_EXTENT;
        // Draw oval.
        Rectangle ovalRect =
            new Rectangle(
                (int) (0.5f * (H_EXTENT - ovalWidth)),
                (int) (0.5f * (V_EXTENT - ovalHeight)),
                ovalWidth,
                ovalHeight);
        g.fillOval(ovalRect);

        if (this.featureCategory == FeatureAdapterCategory.SUBPROGRAM_ACCESS) g.drawOval(ovalRect);

        int triangleWidth = 7;
        int triangleHeight = 5;
        int triangleStartX = (int) Math.ceil((0.5f * (H_EXTENT - triangleWidth)));
        int triangleStartY = (int) Math.ceil((0.5f * (V_EXTENT - triangleHeight)));

        // Draw triangle.
        g.drawLine(triangleStartX, triangleStartY, centerPointX, triangleStartY + triangleHeight);
        g.drawLine(
            triangleStartX + triangleWidth,
            triangleStartY,
            centerPointX,
            triangleStartY + triangleHeight);

        break;
    }
  }