Exemplo n.º 1
0
 private void markPoint(double x, double y, String label, Color fg, Color bg, GC gc) {
   gc.setForeground(black);
   gc.setBackground(bg);
   gc.fillOval((int) x - 3, (int) y - 3, 7, 7);
   gc.drawOval((int) x - 3, (int) y - 3, 6, 6);
   gc.setForeground(fg);
   gc.setBackground(white);
   if (y > 0) {
     gc.drawText(label, (int) x + 8, (int) y + 4, true);
   } else {
     gc.drawText(label, (int) x + 10, (int) y - 10, true);
   }
 }
Exemplo n.º 2
0
  /**
   * Draws the rotated text.
   *
   * @param gc the graphics context
   * @param text the text
   * @param x the x coordinate
   * @param y the y coordinate
   * @param angle the angle
   */
  private void drawRotatedText(GC gc, String text, float x, float y, int angle) {

    int textWidth = gc.textExtent(text).x;
    int textHeight = gc.textExtent(text).y;

    // create image to draw text
    Image image = new Image(Display.getCurrent(), textWidth, textHeight);
    GC tmpGc = new GC(image);
    tmpGc.setForeground(getForeground());
    tmpGc.setBackground(gc.getBackground());
    tmpGc.setFont(getFont());
    tmpGc.drawText(text, 0, 0);

    // set transform to rotate
    Transform transform = new Transform(gc.getDevice());
    transform.translate(x, y);
    transform.rotate(360 - angle);
    gc.setTransform(transform);

    // draw the image on the rotated graphics context
    gc.drawImage(image, 0, 0);

    // dispose resources
    tmpGc.dispose();
    transform.dispose();
    image.dispose();
    gc.setTransform(null);
  }
 public void writeValue(int ex) {
   double x = xyGraph.primaryXAxis.getPositionValue(ex, false);
   int index = (int) x;
   if (index < 0) {
     return;
   }
   Sample sample = (Sample) trace.getDataProvider().getSample(index);
   if (sample != null) {
     double y = sample.getYValue();
     int height = xyGraph.primaryYAxis.getValuePosition(y, false);
     int startX = xyGraph.primaryXAxis.getValuePosition((int) x, false);
     GC gc = new GC(canvas);
     Font font = new Font(null, "Verdana", 10, SWT.BOLD);
     gc.setFont(font);
     String value = FormatUtil.print(y, "#,###");
     Point textSize = gc.textExtent(value);
     gc.drawText(value, startX + (xAxisUnitWidth - textSize.x) / 2, height - 20, true);
     int ground = xyGraph.primaryYAxis.getValuePosition(0, false);
     gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK));
     gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_DARK_MAGENTA));
     gc.drawRectangle(
         startX + (xAxisUnitWidth - lineWidth) / 2, height, lineWidth, ground - height);
     gc.fillRectangle(
         startX + (xAxisUnitWidth - lineWidth) / 2, height, lineWidth, ground - height);
     gc.dispose();
     writedValueMode = true;
     lastWritedX = ex;
   }
 }
  protected void drawInformation(GC gc) {
    super.drawInformation(gc);

    String info2 = "SHFIT+×ó  -  Ç°ÒÆ   SHIFT+ÓÒ  -  ºóÒÆ";
    Point ts = gc.textExtent(info2);
    Point size = getSize();
    gc.drawText(info2, size.x / 2 - ts.x / 2, size.y - ts.y * 2 - 5);
  }
Exemplo n.º 5
0
  private static void paintImage(GC gc, Point size) {
    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
    gc.fillRectangle(0, 0, size.x, size.y);

    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION));
    gc.fillRoundRectangle(0, 0, size.x - 1, size.y - 1, 10, 10);

    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
    gc.drawRoundRectangle(0, 0, size.x - 1, size.y - 1, 10, 10);
    gc.drawText(gc.getFont().getFontData()[0].toString(), 10, 10, true);
  }
Exemplo n.º 6
0
  @Override
  public GC postCalculation(GC toDraw) {
    textScale = (float) canvas.imageDimension.width / (float) canvas.sourceImage.getWidth();

    String text = (int) (textScale * 100) + "%";
    Point textDim = toDraw.textExtent(text);
    toDraw.drawText(
        text,
        canvas.canvasDimension.width - textDim.x - 20,
        canvas.canvasDimension.height - textDim.y - 20);
    return toDraw;
  }
Exemplo n.º 7
0
  private void drawVersionWarning(GC gc, Display display) {
    gc.setBackground(versionWarningBackgroundColor);
    gc.setForeground(versionWarningForegroundColor);
    gc.fillRectangle(290, 231, 367, 49);
    gc.drawRectangle(290, 231, 367, 49);
    gc.setForeground(display.getSystemColor(SWT.COLOR_BLACK));
    gc.drawImage(exclamation_image, 304, 243);

    gc.setFont(devWarningFont);
    gc.drawText(
        BaseMessages.getString(PKG, "SplashDialog.DevelopmentWarning"), 335, 241); // $NON-NLS-1$
  }
 protected void drawButtons(GC gc) {
   Point size = getSize();
   gc.setBackground(getBackground());
   gc.setForeground(AbstractImageViewer.invert(getBackground()));
   int bx = 1;
   int i;
   for (i = 0; i < buttonTexts.length; i++) {
     Point ts = gc.textExtent(buttonTexts[i]);
     int by = size.y - ts.y - 8;
     int bw = ts.x + 7;
     int bh = ts.y + 6;
     buttonBounds[i] = new Rectangle(bx, by, bw, bh);
     gc.setForeground(AbstractImageViewer.invert(getBackground()));
     gc.drawRectangle(buttonBounds[i]);
     gc.drawText(buttonTexts[i], buttonBounds[i].x + 4, buttonBounds[i].y + 4);
     bx += bw + 2;
   }
 }
Exemplo n.º 9
0
  public void paintControl(PaintEvent e) {

    if (text == null || foreground == null) return;

    GC gc = e.gc;

    Color oldForeground = gc.getForeground(), oldBackground = gc.getBackground();
    Font oldFont = gc.getFont();
    int oldAntiAlias = gc.getTextAntialias();

    gc.setTextAntialias(SWT.ON);

    if (background != null) gc.setBackground(background);
    if (font != null) gc.setFont(font);

    int finalX = x, finalY = y;

    if (useRelativeXY) {
      Point size = shell.getSize();
      Point textExtent = gc.textExtent(text);

      if (x >= 0) finalX = x;
      else {
        finalX = size.x + x;
        finalX -= textExtent.x;
      }

      if (y >= 0) finalY = y;
      else {
        finalY = size.y + y;
        finalY -= textExtent.y;
      }
    }

    gc.setForeground(foreground);
    gc.drawText(text, finalX, finalY, background == null);

    gc.setForeground(oldForeground);
    gc.setBackground(oldBackground);
    gc.setFont(oldFont);
    gc.setTextAntialias(oldAntiAlias);
  }
Exemplo n.º 10
0
  /**
   * Draw the X tick.
   *
   * @param gc the graphics context
   */
  private void drawXTick(GC gc) {
    int offset = axis.getTick().getAxisTickMarks().getBounds().x;

    // draw tick labels
    gc.setFont(axis.getTick().getFont());
    int angle = axis.getTick().getTickLabelAngle();
    for (int i = 0; i < tickLabelPositions.size(); i++) {
      if (axis.isValidCategoryAxis() || tickVisibilities.get(i) == true) {
        String text = tickLabels.get(i);
        int textWidth = gc.textExtent(text).x;
        int textHeight = gc.textExtent(text).y;
        if (angle == 0) {
          int x = (int) (tickLabelPositions.get(i) - textWidth / 2d + offset);
          gc.drawText(text, bounds.x + x, bounds.y);
          continue;
        }

        float x, y;
        if (axis.getPosition() == Position.Primary) {
          x =
              (float)
                  (offset
                      + bounds.x
                      + tickLabelPositions.get(i)
                      - textWidth * Math.cos(Math.toRadians(angle))
                      - textHeight / 2d * Math.sin(Math.toRadians(angle)));
          y = (float) (bounds.y + textWidth * Math.sin(Math.toRadians(angle)));
        } else {
          x =
              (float)
                  (offset
                      + bounds.x
                      + tickLabelPositions.get(i)
                      - textHeight / 2d * Math.sin(Math.toRadians(angle)));
          y = (float) (bounds.y + tickLabelMaxLength * Math.sin(Math.toRadians(angle)));
        }
        drawRotatedText(gc, text, x, y, angle);
      }
    }
  }
Exemplo n.º 11
0
  /**
   * Draw the Y tick.
   *
   * @param gc the graphics context
   */
  private void drawYTick(GC gc) {
    int margin = Axis.MARGIN + AxisTickMarks.TICK_LENGTH;

    // draw tick labels
    gc.setFont(axis.getTick().getFont());
    int figureHeight = gc.textExtent("dummy").y;
    for (int i = 0; i < tickLabelPositions.size(); i++) {
      if (tickVisibilities.size() == 0 || tickLabels.size() == 0) {
        break;
      }

      if (tickVisibilities.get(i) == true) {
        String text = tickLabels.get(i);
        int x = 0;
        if (tickLabels.get(0).startsWith("-") && !text.startsWith("-")) {
          x += gc.textExtent("-").x;
        }
        int y = (int) (bounds.height - 1 - tickLabelPositions.get(i) - figureHeight / 2.0 - margin);
        gc.drawText(text, bounds.x + x, bounds.y + y);
      }
    }
  }
Exemplo n.º 12
0
  private static void paintImage2(GC gc, Point size, int f) {
    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
    gc.fillRectangle(0, 0, size.x, size.y);

    // Scale line width, corner roundness, and font size.
    // Caveat: line width expands in all directions, so the origin also has to move.

    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION));
    gc.fillRoundRectangle(f / 2, f / 2, size.x - f, size.y - f, 10 * f, 10 * f);

    gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
    gc.setLineWidth(f);
    gc.drawRoundRectangle(f / 2, f / 2, size.x - f, size.y - f, 10 * f, 10 * f);
    FontData fontData = gc.getFont().getFontData()[0];
    fontData.setHeight(fontData.getHeight() * f);
    Font font = new Font(gc.getDevice(), fontData);
    try {
      gc.setFont(font);
      gc.drawText(fontData.toString(), 10 * f, 10 * f, true);
    } finally {
      font.dispose();
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see
   * org.eclipse.nebula.widgets.gallery.AbstractGalleryItemRenderer#draw(org
   * .eclipse.swt.graphics.GC, org.eclipse.nebula.widgets.gallery.GalleryItem,
   * int, int, int, int, int)
   */
  public void draw(GC gc, GalleryItem item, int index, int x, int y, int width, int height) {

    Image itemImage = item.getImage();
    Color itemBackgroundColor = item.getBackground();
    Color itemForegroundColor = item.getForeground();

    int useableHeight = height;

    int imageWidth = 0;
    int imageHeight = 0;
    int xShift = 0;
    int yShift = 0;
    Point size = null;

    if (itemImage != null) {
      Rectangle itemImageBounds = itemImage.getBounds();
      imageWidth = itemImageBounds.width;
      imageHeight = itemImageBounds.height;

      size =
          RendererHelper.getBestSize(
              imageWidth,
              imageHeight,
              useableHeight - 4 - this.dropShadowsSize,
              useableHeight - 4 - this.dropShadowsSize);

      xShift = ((useableHeight - size.x) >> 1) + 2;
      yShift = (useableHeight - size.y) >> 1;

      if (dropShadows) {
        Color c = null;
        for (int i = this.dropShadowsSize - 1; i >= 0; i--) {
          c = dropShadowsColors.get(i);
          gc.setForeground(c);

          gc.drawLine(
              x + useableHeight + i - xShift - 1,
              y + dropShadowsSize + yShift,
              x + useableHeight + i - xShift - 1,
              y + useableHeight + i - yShift);
          gc.drawLine(
              x + xShift + dropShadowsSize,
              y + useableHeight + i - yShift - 1,
              x + useableHeight + i - xShift,
              y - 1 + useableHeight + i - yShift);
        }
      }
    }

    // Draw selection background (rounded rectangles)
    if (selected || RendererHelper.isColorsEquals(itemBackgroundColor, gallery.getBackground())) {
      if (selected) {
        gc.setBackground(selectionBackgroundColor);
        gc.setForeground(selectionBackgroundColor);
      } else if (itemBackgroundColor != null) {
        gc.setBackground(itemBackgroundColor);
      }

      if (showRoundedSelectionCorners)
        gc.fillRoundRectangle(x, y, width, useableHeight, selectionRadius, selectionRadius);
      else gc.fillRectangle(x, y, width, useableHeight);
    }

    if (itemImage != null && size != null) {
      if (size.x > 0 && size.y > 0) {
        gc.drawImage(
            itemImage, 0, 0, imageWidth, imageHeight, x + xShift, y + yShift, size.x, size.y);
        drawAllOverlays(gc, item, x, y, size, xShift, yShift);
      }
    }

    if (item.getText() != null && !EMPTY_STRING.equals(item.getText()) && showLabels) {

      // Calculate font height (text and description)
      gc.setFont(textFont);
      String text = RendererHelper.createLabel(item.getText(), gc, width - useableHeight - 10);
      int textFontHeight = gc.getFontMetrics().getHeight();

      String description = null;
      int descriptionFontHeight = 0;
      if (item.getText(1) != null && !EMPTY_STRING.equals(item.getText(1))) {
        gc.setFont(descriptionFont);
        description = RendererHelper.createLabel(item.getText(1), gc, width - useableHeight - 10);
        descriptionFontHeight = gc.getFontMetrics().getHeight();
      }

      boolean displayText = false;
      boolean displayDescription = false;
      int remainingHeight = height - 2 - textFontHeight;
      if (remainingHeight > 0) displayText = true;
      remainingHeight -= descriptionFontHeight;
      if (remainingHeight > 0) displayDescription = true;

      // Background color
      gc.setBackground(selected ? selectionBackgroundColor : backgroundColor);

      // Draw text
      if (displayText) {
        int transY = (height - textFontHeight - 2);
        if (displayDescription) transY -= descriptionFontHeight;
        transY = transY >> 1;

        if (selected) {
          gc.setForeground(this.selectionForegroundColor);
        } else if (itemForegroundColor != null) {
          gc.setForeground(itemForegroundColor);
        } else {
          gc.setForeground(this.foregroundColor);
        }

        gc.setFont(textFont);
        gc.drawText(text, x + useableHeight + 5, y + transY, true);
      }
      // Draw description
      if (description != null && displayDescription) {
        gc.setForeground(this.descriptionColor);
        gc.setFont(descriptionFont);
        gc.drawText(
            description,
            x + useableHeight + 5,
            y + ((height - descriptionFontHeight - textFontHeight - 2) >> 1) + textFontHeight + 1,
            true);
      }
    }
  }
Exemplo n.º 14
0
  /**
   * Paints the preview title at the given position (and returns the required height)
   *
   * @param gc the graphics context to paint into
   * @param x the left edge of the preview rectangle
   * @param y the top edge of the preview rectangle
   * @param displayName the title string to be used
   */
  int paintTitle(GC gc, int x, int y, boolean showFile, String displayName) {
    int titleHeight = 0;

    if (showFile && mIncludedWithin != null) {
      if (mManager.getMode() != INCLUDES) {
        displayName = "<include>";
      } else {
        // Skip: just paint footer instead
        displayName = null;
      }
    }

    int width = getWidth();
    int labelTop = y + 1;
    gc.setClipping(x, labelTop, width, 100);

    // Use font height rather than extent height since we want two adjacent
    // previews (which may have different display names and therefore end
    // up with slightly different extent heights) to have identical title
    // heights such that they are aligned identically
    int fontHeight = gc.getFontMetrics().getHeight();

    if (displayName != null && displayName.length() > 0) {
      gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_WHITE));
      Point extent = gc.textExtent(displayName);
      int labelLeft = Math.max(x, x + (width - extent.x) / 2);
      Image icon = null;
      Locale locale = mConfiguration.getLocale();
      if (locale != null
          && (locale.hasLanguage() || locale.hasRegion())
          && (!(mConfiguration instanceof NestedConfiguration)
              || ((NestedConfiguration) mConfiguration).isOverridingLocale())) {
        icon = locale.getFlagImage();
      }

      if (icon != null) {
        int flagWidth = icon.getImageData().width;
        int flagHeight = icon.getImageData().height;
        labelLeft = Math.max(x + flagWidth / 2, labelLeft);
        gc.drawImage(icon, labelLeft - flagWidth / 2 - 1, labelTop);
        labelLeft += flagWidth / 2 + 1;
        gc.drawText(displayName, labelLeft, labelTop - (extent.y - flagHeight) / 2, true);
      } else {
        gc.drawText(displayName, labelLeft, labelTop, true);
      }

      labelTop += extent.y;
      titleHeight += fontHeight;
    }

    if (showFile && (mAlternateInput != null || mIncludedWithin != null)) {
      // Draw file flag, and parent folder name
      IFile file = mAlternateInput != null ? mAlternateInput : mIncludedWithin.getFile();
      String fileName = file.getParent().getName() + File.separator + file.getName();
      Point extent = gc.textExtent(fileName);
      Image icon = IconFactory.getInstance().getIcon("android_file"); // $NON-NLS-1$
      int flagWidth = icon.getImageData().width;
      int flagHeight = icon.getImageData().height;

      int labelLeft = Math.max(x, x + (width - extent.x - flagWidth - 1) / 2);

      gc.drawImage(icon, labelLeft, labelTop);

      gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_GRAY));
      labelLeft += flagWidth + 1;
      labelTop -= (extent.y - flagHeight) / 2;
      gc.drawText(fileName, labelLeft, labelTop, true);

      titleHeight += Math.max(titleHeight, icon.getImageData().height);
    }

    gc.setClipping((Region) null);

    return titleHeight;
  }
Exemplo n.º 15
0
 public static void main(String[] args) {
   final Display display = new Display();
   final int[] count = new int[] {4};
   final Image image = new Image(display, 300, 300);
   GC gc = new GC(image);
   gc.setBackground(display.getSystemColor(SWT.COLOR_CYAN));
   gc.fillRectangle(image.getBounds());
   gc.drawText("Splash Screen", 10, 10);
   gc.dispose();
   final Shell splash = new Shell(SWT.ON_TOP);
   final ProgressBar bar = new ProgressBar(splash, SWT.NONE);
   bar.setMaximum(count[0]);
   Label label = new Label(splash, SWT.NONE);
   label.setImage(SWTResourceManager.getImage(SplashScreen.class, "/resources/splashep.png"));
   FormLayout layout = new FormLayout();
   splash.setLayout(layout);
   FormData labelData = new FormData();
   labelData.right = new FormAttachment(100, 0);
   labelData.bottom = new FormAttachment(100, 0);
   label.setLayoutData(labelData);
   FormData progressData = new FormData();
   progressData.left = new FormAttachment(0, 5);
   progressData.right = new FormAttachment(100, -5);
   progressData.bottom = new FormAttachment(100, -5);
   bar.setLayoutData(progressData);
   splash.pack();
   Rectangle splashRect = splash.getBounds();
   Rectangle displayRect = display.getBounds();
   int x = (displayRect.width - splashRect.width) / 2;
   int y = (displayRect.height - splashRect.height) / 2;
   splash.setLocation(x, y);
   splash.open();
   display.asyncExec(
       new Runnable() {
         @Override
         public void run() {
           Shell[] shells = new Shell[count[0]];
           for (int i = 0; i < count[0]; i++) {
             shells[i] = new Shell(display);
             shells[i].setSize(300, 300);
             shells[i].addListener(
                 SWT.Close,
                 new Listener() {
                   @Override
                   public void handleEvent(Event e) {
                     --count[0];
                   }
                 });
             bar.setSelection(i + 1);
             try {
               Thread.sleep(1000);
             } catch (Throwable e) {
             }
           }
           splash.close();
           image.dispose();
           // Start Main Window
           MainWindow.main(null);
         }
       });
   while (count[0] != 0) {
     if (!display.readAndDispatch()) display.sleep();
   }
   display.dispose();
 }
Exemplo n.º 16
0
  void onPaint(PaintEvent event) {
    Display disp = getDisplay();
    Rectangle rect = getClientArea();
    if (rect.width == 0 || rect.height == 0) return;

    boolean shortenText = false;
    String t = text;
    Image img = image;
    int availableWidth = Math.max(0, rect.width - 2 * hIndent);
    Point extent = getTotalSize(img, t);
    if (extent.x > availableWidth) {
      shortenText = true;
    }

    GC gc = event.gc;
    String[] lines = text == null ? null : splitString(text);

    // shorten the text
    if (shortenText) {
      extent.x = 0;

      if (image != null) {
        availableWidth -= image.getBounds().width + GAP;
      }

      for (int i = 0; i < lines.length; i++) {
        Point e = gc.textExtent(lines[i], DRAW_FLAGS);
        if (e.x > availableWidth) {
          lines[i] = shortenText(gc, lines[i], availableWidth);
          extent.x = Math.max(extent.x, getTotalSize(img, lines[i]).x);
        } else {
          extent.x = Math.max(extent.x, e.x);
        }
      }

      setToolTipText(text);
    }

    // determine horizontal position
    int x = rect.x + hIndent;

    // draw the background behind the text
    Color background = getBackground();

    if (selected) {
      background =
          Activator.getDefault().getFormColors(disp).getColor("labelex_selection_backgound");
    }

    gc.setBackground(background);
    gc.fillRectangle(rect);

    // draw the image
    if (img != null) {
      Rectangle imageRect = img.getBounds();
      gc.drawImage(
          img,
          0,
          0,
          imageRect.width,
          imageRect.height,
          x,
          (rect.height - imageRect.height) / 2,
          imageRect.width,
          imageRect.height);
      x += imageRect.width + GAP;
      extent.x -= imageRect.width + GAP;
    }

    // draw the text
    if (lines != null) {
      int lineHeight = gc.getFontMetrics().getHeight();
      int textHeight = lines.length * lineHeight;
      int lineY = Math.max(vIndent, rect.y + (rect.height - textHeight) / 2);
      gc.setForeground(getForeground());
      for (int i = 0; i < lines.length; i++) {
        int lineX = x;
        gc.drawText(lines[i], lineX, lineY, DRAW_FLAGS);
        lineY += lineHeight;
      }
    }
  }
Exemplo n.º 17
0
  int XmNexposureCallback(int w, int client_data, int call_data) {
    if ((style & SWT.SEPARATOR) != 0) return 0;
    int xDisplay = OS.XtDisplay(handle);
    if (xDisplay == 0) return 0;
    int xWindow = OS.XtWindow(handle);
    if (xWindow == 0) return 0;
    int[] argList = {
      OS.XmNcolormap, 0,
      OS.XmNwidth, 0,
      OS.XmNheight, 0,
    };
    OS.XtGetValues(handle, argList, argList.length / 2);
    int width = argList[3], height = argList[5];

    Image currentImage = image;
    boolean enabled = getEnabled();

    if ((parent.style & SWT.FLAT) != 0) {
      boolean hasCursor = hasCursor();

      /* Set the shadow thickness */
      int thickness = 0;
      if (set || (hasCursor && enabled)) {
        thickness = Math.min(2, display.buttonShadowThickness);
      }
      argList = new int[] {OS.XmNshadowThickness, thickness};
      OS.XtSetValues(handle, argList, argList.length / 2);

      /* Determine if hot image should be used */
      if (enabled && hasCursor && hotImage != null) {
        currentImage = hotImage;
      }
    }

    GCData data = new GCData();
    data.device = display;
    data.display = xDisplay;
    data.drawable = xWindow;
    data.font = parent.font;
    data.colormap = argList[1];
    int xGC = OS.XCreateGC(xDisplay, xWindow, 0, null);
    if (xGC == 0) SWT.error(SWT.ERROR_NO_HANDLES);
    GC gc = GC.motif_new(xGC, data);

    XmAnyCallbackStruct cb = new XmAnyCallbackStruct();
    OS.memmove(cb, call_data, XmAnyCallbackStruct.sizeof);
    if (cb.event != 0) {
      XExposeEvent xEvent = new XExposeEvent();
      OS.memmove(xEvent, cb.event, XExposeEvent.sizeof);
      Rectangle rect = new Rectangle(xEvent.x, xEvent.y, xEvent.width, xEvent.height);
      gc.setClipping(rect);
    }

    if (!enabled) {
      currentImage = disabledImage;
      if (currentImage == null && image != null) {
        currentImage = new Image(display, image, SWT.IMAGE_DISABLE);
      }
      Color disabledColor = display.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
      gc.setForeground(disabledColor);
    } else {
      gc.setForeground(parent.getForeground());
    }
    gc.setBackground(parent.getBackground());

    int textX = 0, textY = 0, textWidth = 0, textHeight = 0;
    if (text.length() != 0) {
      int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC;
      Point textExtent = gc.textExtent(text, flags);
      textWidth = textExtent.x;
      textHeight = textExtent.y;
    }
    int imageX = 0, imageY = 0, imageWidth = 0, imageHeight = 0;
    if (currentImage != null) {
      Rectangle imageBounds = currentImage.getBounds();
      imageWidth = imageBounds.width;
      imageHeight = imageBounds.height;
    }

    int spacing = 0;
    if (textWidth != 0 && imageWidth != 0) spacing = 2;
    if ((parent.style & SWT.RIGHT) != 0) {
      imageX = (width - imageWidth - textWidth - spacing) / 2;
      imageY = (height - imageHeight) / 2;
      textX = spacing + imageX + imageWidth;
      textY = (height - textHeight) / 2;
    } else {
      imageX = (width - imageWidth) / 2;
      imageY = (height - imageHeight - textHeight - spacing) / 2;
      textX = (width - textWidth) / 2;
      textY = spacing + imageY + imageHeight;
    }

    if ((style & SWT.DROP_DOWN) != 0) {
      textX -= 6;
      imageX -= 6;
    }
    if (textWidth > 0) {
      int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC | SWT.DRAW_TRANSPARENT;
      gc.drawText(text, textX, textY, flags);
    }
    if (imageWidth > 0) gc.drawImage(currentImage, imageX, imageY);
    if ((style & SWT.DROP_DOWN) != 0) {
      int startX = width - 12, startY = (height - 2) / 2;
      int[] arrow = {startX, startY, startX + 3, startY + 3, startX + 6, startY};
      gc.setBackground(parent.getForeground());
      gc.fillPolygon(arrow);
      gc.drawPolygon(arrow);
    }
    gc.dispose();
    OS.XFreeGC(xDisplay, xGC);

    if (!enabled && disabledImage == null) {
      if (currentImage != null) currentImage.dispose();
    }
    return 0;
  }
Exemplo n.º 18
0
  void onPaint(PaintEvent event) {
    Rectangle rect = getClientArea();
    if (rect.width == 0 || rect.height == 0) return;

    boolean shortenText = false;
    String t = text;
    Image img = image;
    int availableWidth = Math.max(0, rect.width - (leftMargin + rightMargin));
    Point extent = getTotalSize(img, t);
    if (extent.x > availableWidth) {
      img = null;
      extent = getTotalSize(img, t);
      if (extent.x > availableWidth) {
        shortenText = true;
      }
    }

    GC gc = event.gc;
    String[] lines = text == null ? null : splitString(text);

    // shorten the text
    if (shortenText) {
      extent.x = 0;
      for (int i = 0; i < lines.length; i++) {
        Point e = gc.textExtent(lines[i], DRAW_FLAGS);
        if (e.x > availableWidth) {
          lines[i] = shortenText(gc, lines[i], availableWidth);
          extent.x = Math.max(extent.x, getTotalSize(null, lines[i]).x);
        } else {
          extent.x = Math.max(extent.x, e.x);
        }
      }
      if (appToolTipText == null) {
        super.setToolTipText(text);
      }
    } else {
      super.setToolTipText(appToolTipText);
    }

    // determine horizontal position
    int x = rect.x + leftMargin;
    if (align == SWT.CENTER) {
      x = (rect.width - extent.x) / 2;
    }
    if (align == SWT.RIGHT) {
      x = rect.width - rightMargin - extent.x;
    }

    // draw a background image behind the text
    try {
      if (backgroundImage != null) {
        // draw a background image behind the text
        Rectangle imageRect = backgroundImage.getBounds();
        // tile image to fill space
        gc.setBackground(getBackground());
        gc.fillRectangle(rect);
        int xPos = 0;
        while (xPos < rect.width) {
          int yPos = 0;
          while (yPos < rect.height) {
            gc.drawImage(backgroundImage, xPos, yPos);
            yPos += imageRect.height;
          }
          xPos += imageRect.width;
        }
      } else if (gradientColors != null) {
        // draw a gradient behind the text
        final Color oldBackground = gc.getBackground();
        if (gradientColors.length == 1) {
          if (gradientColors[0] != null) gc.setBackground(gradientColors[0]);
          gc.fillRectangle(0, 0, rect.width, rect.height);
        } else {
          final Color oldForeground = gc.getForeground();
          Color lastColor = gradientColors[0];
          if (lastColor == null) lastColor = oldBackground;
          int pos = 0;
          for (int i = 0; i < gradientPercents.length; ++i) {
            gc.setForeground(lastColor);
            lastColor = gradientColors[i + 1];
            if (lastColor == null) lastColor = oldBackground;
            gc.setBackground(lastColor);
            if (gradientVertical) {
              final int gradientHeight = (gradientPercents[i] * rect.height / 100) - pos;
              gc.fillGradientRectangle(0, pos, rect.width, gradientHeight, true);
              pos += gradientHeight;
            } else {
              final int gradientWidth = (gradientPercents[i] * rect.width / 100) - pos;
              gc.fillGradientRectangle(pos, 0, gradientWidth, rect.height, false);
              pos += gradientWidth;
            }
          }
          if (gradientVertical && pos < rect.height) {
            gc.setBackground(getBackground());
            gc.fillRectangle(0, pos, rect.width, rect.height - pos);
          }
          if (!gradientVertical && pos < rect.width) {
            gc.setBackground(getBackground());
            gc.fillRectangle(pos, 0, rect.width - pos, rect.height);
          }
          gc.setForeground(oldForeground);
        }
        gc.setBackground(oldBackground);
      } else {
        if (background != null || (getStyle() & SWT.DOUBLE_BUFFERED) == 0) {
          gc.setBackground(getBackground());
          gc.fillRectangle(rect);
        }
      }
    } catch (SWTException e) {
      if ((getStyle() & SWT.DOUBLE_BUFFERED) == 0) {
        gc.setBackground(getBackground());
        gc.fillRectangle(rect);
      }
    }

    // draw border
    int style = getStyle();
    if ((style & SWT.SHADOW_IN) != 0 || (style & SWT.SHADOW_OUT) != 0) {
      paintBorder(gc, rect);
    }

    /*
     * Compute text height and image height. If image height is more than
     * the text height, draw image starting from top margin. Else draw text
     * starting from top margin.
     */
    Rectangle imageRect = null;
    int lineHeight = 0, textHeight = 0, imageHeight = 0;

    if (img != null) {
      imageRect = img.getBounds();
      imageHeight = imageRect.height;
    }
    if (lines != null) {
      lineHeight = gc.getFontMetrics().getHeight();
      textHeight = lines.length * lineHeight;
    }

    int imageY = 0, midPoint = 0, lineY = 0;
    if (imageHeight > textHeight) {
      if (topMargin == DEFAULT_MARGIN && bottomMargin == DEFAULT_MARGIN)
        imageY = rect.y + (rect.height - imageHeight) / 2;
      else imageY = topMargin;
      midPoint = imageY + imageHeight / 2;
      lineY = midPoint - textHeight / 2;
    } else {
      if (topMargin == DEFAULT_MARGIN && bottomMargin == DEFAULT_MARGIN)
        lineY = rect.y + (rect.height - textHeight) / 2;
      else lineY = topMargin;
      midPoint = lineY + textHeight / 2;
      imageY = midPoint - imageHeight / 2;
    }

    // draw the image
    if (img != null) {
      gc.drawImage(
          img, 0, 0, imageRect.width, imageHeight, x, imageY, imageRect.width, imageHeight);
      x += imageRect.width + GAP;
      extent.x -= imageRect.width + GAP;
    }

    // draw the text
    if (lines != null) {
      gc.setForeground(getForeground());
      for (int i = 0; i < lines.length; i++) {
        int lineX = x;
        if (lines.length > 1) {
          if (align == SWT.CENTER) {
            int lineWidth = gc.textExtent(lines[i], DRAW_FLAGS).x;
            lineX = x + Math.max(0, (extent.x - lineWidth) / 2);
          }
          if (align == SWT.RIGHT) {
            int lineWidth = gc.textExtent(lines[i], DRAW_FLAGS).x;
            lineX = Math.max(x, rect.x + rect.width - rightMargin - lineWidth);
          }
        }
        gc.drawText(lines[i], lineX, lineY, DRAW_FLAGS);
        lineY += lineHeight;
      }
    }
  }
Exemplo n.º 19
0
  private void drawAttitudeControls(GC gc, int width, int height) {
    int size = Math.min(width / 2, height);
    int verticalOffset = (height - size) / 2;

    gc.setLineWidth(2);

    gc.setBackground(background1);
    gc.fillArc(width / 2 - size, verticalOffset, size, size, 0, 360);
    gc.fillArc(width / 2, verticalOffset, size, size, 0, 360);

    gc.setBackground(background2);
    gc.fillArc(width / 2 - size, verticalOffset, size, size, (int) pitch, -180);
    gc.fillArc(width / 2, verticalOffset, size, size, (int) roll, -180);

    gc.setForeground(foregroundWhite);
    gc.drawArc(width / 2 - size, verticalOffset, size, size, 0, 360);
    gc.drawArc(width / 2, verticalOffset, size, size, 0, 360);

    String value = "";
    gc.setForeground(foregroundWhite);

    for (int i = 0; i < 2; i++) {
      int centerX = width / 2 - i * size;
      int tickSize = 20;
      int step = 20;

      for (int theta = 10; theta <= 360; theta += step) {
        int x = (int) (size / 2 + size / 2 * Math.cos(theta * Math.PI / 180.0)) + centerX;
        int y = (int) (size / 2 + size / 2 * Math.sin(theta * Math.PI / 180.0));

        int xx =
            (int) ((size) / 2 + (size - tickSize) / 2 * Math.cos(theta * Math.PI / 180.0))
                + centerX;
        int yy = (int) ((size) / 2 + (size - tickSize) / 2 * Math.sin(theta * Math.PI / 180.0));

        gc.drawLine(x, verticalOffset + y, xx, verticalOffset + yy);

        if (theta < 180) {
          if (theta > 90 && theta < 180) {
            yy = yy - 15;
            xx = xx + 2;
            value = String.valueOf(theta);
          } else if (theta > 45 && theta <= 90) {
            yy = yy - 15;
            xx = xx - 10;
            value = String.valueOf(theta);
          } else if (theta < 45) {
            yy = yy - 15;
            xx = xx - 15;
            value = String.valueOf(theta);
          }
          gc.drawText(value, xx, verticalOffset + yy, true);
        } else {
          if (theta > 270) {
            xx = xx - 9;
            value = String.valueOf(theta - 360);
          } else {
            xx = xx - 3;
            value = String.valueOf(theta - 360);
          }

          if (theta == 180) {
            yy = yy - 7;
            xx = xx + 10;
          } else if (theta == 360) {
            yy = yy - 7;
            xx = xx - 3;
          }
          gc.drawText(value, xx, verticalOffset + yy, true);
        }
      }
    }
  }
Exemplo n.º 20
0
  /**
   * Paints the preview at the given x/y position
   *
   * @param gc the graphics context to paint it into
   * @param x the x coordinate to paint the preview at
   * @param y the y coordinate to paint the preview at
   */
  void paint(GC gc, int x, int y) {
    mTitleHeight = paintTitle(gc, x, y, true /*showFile*/);
    y += mTitleHeight;
    y += 2;

    int width = getWidth();
    int height = getHeight();
    if (mThumbnail != null && mError == null) {
      gc.drawImage(mThumbnail, x, y);

      if (mActive) {
        int oldWidth = gc.getLineWidth();
        gc.setLineWidth(3);
        gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION));
        gc.drawRectangle(x - 1, y - 1, width + 2, height + 2);
        gc.setLineWidth(oldWidth);
      }
    } else if (mError != null) {
      if (mThumbnail != null) {
        gc.drawImage(mThumbnail, x, y);
      } else {
        gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
        gc.drawRectangle(x, y, width, height);
      }

      gc.setClipping(x, y, width, height);
      Image icon = IconFactory.getInstance().getIcon("renderError"); // $NON-NLS-1$
      ImageData data = icon.getImageData();
      int prevAlpha = gc.getAlpha();
      int alpha = 96;
      if (mThumbnail != null) {
        alpha -= 32;
      }
      gc.setAlpha(alpha);
      gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2);

      String msg = mError;
      Density density = mConfiguration.getDensity();
      if (density == Density.TV || density == Density.LOW) {
        msg =
            "Broken rendering library; unsupported DPI. Try using the SDK manager "
                + "to get updated layout libraries.";
      }
      int charWidth = gc.getFontMetrics().getAverageCharWidth();
      int charsPerLine = (width - 10) / charWidth;
      msg = SdkUtils.wrap(msg, charsPerLine, null);
      gc.setAlpha(255);
      gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK));
      gc.drawText(msg, x + 5, y + HEADER_HEIGHT, true);
      gc.setAlpha(prevAlpha);
      gc.setClipping((Region) null);
    } else {
      gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
      gc.drawRectangle(x, y, width, height);

      Image icon = IconFactory.getInstance().getIcon("refreshPreview"); // $NON-NLS-1$
      ImageData data = icon.getImageData();
      int prevAlpha = gc.getAlpha();
      gc.setAlpha(96);
      gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2);
      gc.setAlpha(prevAlpha);
    }

    if (mActive) {
      int left = x;
      int prevAlpha = gc.getAlpha();
      gc.setAlpha(208);
      Color bg = mCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE);
      gc.setBackground(bg);
      gc.fillRectangle(left, y, x + width - left, HEADER_HEIGHT);
      gc.setAlpha(prevAlpha);

      y += 2;

      // Paint icons
      gc.drawImage(CLOSE_ICON, left, y);
      left += CLOSE_ICON_WIDTH;

      gc.drawImage(ZOOM_IN_ICON, left, y);
      left += ZOOM_IN_ICON_WIDTH;

      gc.drawImage(ZOOM_OUT_ICON, left, y);
      left += ZOOM_OUT_ICON_WIDTH;

      gc.drawImage(EDIT_ICON, left, y);
      left += EDIT_ICON_WIDTH;
    }
  }
Exemplo n.º 21
0
  private void drawGraph(PaintEvent e) {
    GC gc = e.gc;
    Point size = canvasCurve.getSize();
    int gridSize = 50 - sliderZoom.getSelection();
    Color black = new Color(canvasCurve.getDisplay(), 0, 0, 0);
    Color grey = new Color(canvasCurve.getDisplay(), 235, 235, 235);

    // first, draw the grid
    gc.setForeground(grey);
    for (int i = 0; i < size.x / 2; i += gridSize) {
      gc.drawLine(size.x / 2 - i, 0, size.x / 2 - i, size.y);
      gc.drawLine(size.x / 2 + i, 0, size.x / 2 + i, size.y);
    }
    for (int i = 0; i < size.y / 2; i += gridSize) {
      gc.drawLine(0, size.y / 2 - i, size.x, size.y / 2 - i);
      gc.drawLine(0, size.y / 2 + i, size.x, size.y / 2 + i);
    }

    // Draw the axis
    gc.setForeground(black); // Black
    gc.drawLine(size.x / 2, 0, size.x / 2, size.y);
    gc.drawLine(0, size.y / 2, size.x, size.y / 2);
    int labeljumps = 5;
    int scale = (size.x / 2 / gridSize) - ((size.x / 2 / gridSize) % labeljumps);
    if (scale > 50) labeljumps = 10;
    for (int i = 0; i < size.x / 2; i += gridSize) {
      if ((i / gridSize) % labeljumps == 0) {
        gc.drawLine(size.x / 2 + i, size.y / 2 - 8, size.x / 2 + i, size.y / 2 + 8);
        gc.drawLine(size.x / 2 - i, size.y / 2 - 8, size.x / 2 - i, size.y / 2 + 8);
        gc.drawLine(size.x / 2 - 8, size.y / 2 + i, size.x / 2 + 8, size.y / 2 + i);
        gc.drawLine(size.x / 2 - 8, size.y / 2 - i, size.x / 2 + 8, size.y / 2 - i);

        int label = i / gridSize;
        if (label < 10) {
          if (label != 0) {
            gc.drawText(label + "", size.x / 2 + i - 2, size.y / 2 + 10, true); // $NON-NLS-1$
            gc.drawText(-label + "", size.x / 2 - i - 5, size.y / 2 + 10, true); // $NON-NLS-1$

            gc.drawText(label + "", size.x / 2 + 13, size.y / 2 - i - 7, true); // $NON-NLS-1$
            gc.drawText(-label + "", size.x / 2 + 13, size.y / 2 + i - 7, true); // $NON-NLS-1$
          } else {
            gc.drawText(label + "", size.x / 2 + i + 13, size.y / 2 + 10, true); // $NON-NLS-1$
          }
        } else {
          gc.drawText(label + "", size.x / 2 + i - 6, size.y / 2 + 10, true); // $NON-NLS-1$
          gc.drawText(-label + "", size.x / 2 - i - 10, size.y / 2 + 10, true); // $NON-NLS-1$

          gc.drawText(label + "", size.x / 2 + 13, size.y / 2 - i - 7, true); // $NON-NLS-1$
          gc.drawText(-label + "", size.x / 2 + 13, size.y / 2 + i - 7, true); // $NON-NLS-1$
        }

      } else {
        gc.drawLine(size.x / 2 + i, size.y / 2 - 2, size.x / 2 + i, size.y / 2 + 2);
        gc.drawLine(size.x / 2 - i, size.y / 2 - 2, size.x / 2 - i, size.y / 2 + 2);
        gc.drawLine(size.x / 2 - 2, size.y / 2 + i, size.x / 2 + 2, size.y / 2 + i);
        gc.drawLine(size.x / 2 - 2, size.y / 2 - i, size.x / 2 + 2, size.y / 2 - i);
      }
    }

    if (points != null) {
      gc.setForeground(blue);
      double step = Math.pow((double) gridSize, -1);
      double x1, y1, x2, y2;
      for (int i = 2; i < points.length; i++) {
        if (points[i - 2].y == 0) {
          if (points[i - 1] != null && points[i - 1].y != 0) {
            x1 = (double) points[i - 2].x / 100 / step + size.x / 2;
            y1 = -(double) points[i - 2].y / 100 / step + size.y / 2;
            x2 = (double) points[i - 1].x / 100 / step + size.x / 2;
            y2 = -(double) points[i - 1].y / 100 / step + size.y / 2;
            gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
            gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
            x1 = (double) points[i - 2].x / 100 / step + size.x / 2;
            y1 = -(double) points[i - 2].y / 100 / step + size.y / 2;
            x2 = (double) points[i].x / 100 / step + size.x / 2;
            y2 = -(double) points[i].y / 100 / step + size.y / 2;
            gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
            gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
          } else {
            x1 = (double) points[i - 2].x / 100 / step + size.x / 2;
            y1 = -(double) points[i - 2].y / 100 / step + size.y / 2;
            x2 = (double) points[i - 3].x / 100 / step + size.x / 2;
            y2 = -(double) points[i - 3].y / 100 / step + size.y / 2;
            gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
            gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
            x1 = (double) points[i - 2].x / 100 / step + size.x / 2;
            y1 = -(double) points[i - 2].y / 100 / step + size.y / 2;
            x2 = (double) points[i - 4].x / 100 / step + size.x / 2;
            y2 = -(double) points[i - 4].y / 100 / step + size.y / 2;
            gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
            gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
          }
        } else {
          x1 = (double) points[i - 2].x / 100 / step + size.x / 2;
          y1 = -(double) points[i - 2].y / 100 / step + size.y / 2;
          x2 = (double) points[i].x / 100 / step + size.x / 2;
          y2 = -(double) points[i].y / 100 / step + size.y / 2;
          if ((int) Math.signum(points[i - 2].y + 0.0) == (int) Math.signum(points[i].y + 0.0)) {
            gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
            gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
          }
        }
        if (points[points.length - 1].y == 0) {
          x1 = (double) points[points.length - 1].x / 100 / step + size.x / 2;
          y1 = -(double) points[points.length - 1].y / 100 / step + size.y / 2;
          x2 = (double) points[points.length - 2].x / 100 / step + size.x / 2;
          y2 = -(double) points[points.length - 2].y / 100 / step + size.y / 2;
          gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
          gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
          x1 = (double) points[points.length - 1].x / 100 / step + size.x / 2;
          y1 = -(double) points[points.length - 1].y / 100 / step + size.y / 2;
          x2 = (double) points[points.length - 3].x / 100 / step + size.x / 2;
          y2 = -(double) points[points.length - 3].y / 100 / step + size.y / 2;
          gc.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
          gc.drawLine((int) x1, (int) y1 + 1, (int) x2, (int) y2 + 1);
        }
      }

      if (pointR != null && !pointR.isInfinite()) {
        int rX;
        int rY;
        int lX;
        int lY;
        FpPoint p = pointP;
        FpPoint q = pointQ;
        FpPoint r = pointR;
        if (q != null) {
          if (p.x < q.x && p.x < r.x) { // if pointP is the most left point
            lX = (int) ((double) p.x / 100 / step + size.x / 2);
            lY = (int) ((double) -p.y / 100 / step + size.y / 2);
          } else if (q.x < r.x) { // if pointQ is the most left point
            lX = (int) ((double) q.x / 100 / step + size.x / 2);
            lY = (int) ((double) -q.y / 100 / step + size.y / 2);
          } else { // if pointR is the most left point
            lX = (int) ((double) r.x / 100 / step + size.x / 2);
            lY = (int) ((double) r.y / 100 / step + size.y / 2);
          }

          if (p.x > q.x && p.x > r.x) { // if pointP is the most right point
            rX = (int) ((double) p.x / 100 / step + size.x / 2);
            rY = (int) ((double) -p.y / 100 / step + size.y / 2);
          } else if (q.x > r.x) { // if pointQ is the most right point
            rX = (int) ((double) q.x / 100 / step + size.x / 2);
            rY = (int) ((double) -q.y / 100 / step + size.y / 2);
          } else { // if pointR is the most left point
            rX = (int) ((double) r.x / 100 / step + size.x / 2);
            rY = (int) ((double) r.y / 100 / step + size.y / 2);
          }
        } else {
          if (p.x < r.x) { // if pointP is the most left point
            lX = (int) ((double) p.x / 100 / step + size.x / 2);
            lY = (int) ((double) -p.y / 100 / step + size.y / 2);
            rX = (int) ((double) r.x / 100 / step + size.x / 2);
            rY = (int) ((double) r.y / 100 / step + size.y / 2);
          } else { // if pointR is the most left point
            lX = (int) ((double) r.x / 100 / step + size.x / 2);
            lY = (int) ((double) r.y / 100 / step + size.y / 2);
            rX = (int) ((double) p.x / 100 / step + size.x / 2);
            rY = (int) ((double) -p.y / 100 / step + size.y / 2);
          }
        }

        int startX;
        int endX;
        int startY;
        int endY;

        if ((rX > lX ? rX - lX : lX - rX) > (rY > lY ? rY - lY : lY - rY)) {
          double alfa = (double) (rY - lY) / (double) (rX - lX);
          startX = lX - 30;
          endX = rX + 30;
          startY = lY - (int) (alfa * 30);
          endY = rY + (int) (alfa * 30);
        } else {
          double alfa = (double) (rX - lX) / (double) (rY - lY);
          startX = lX + (lY > rY ? (int) (alfa * 30) : -(int) (alfa * 30));
          endX = rX + (lY > rY ? -(int) (alfa * 30) : (int) (alfa * 30));
          ;
          startY = lY + (lY > rY ? 30 : -30);
          endY = rY + (lY > rY ? -30 : 30);
        }

        if (startY < 0) {
          double alfa = (double) (rX - lX) / (double) (rY - lY);
          startX += (double) (-startY) * alfa;
          startY = 0;
        } else if (startY > size.y) {
          double alfa = (double) (rX - lX) / (double) (rY - lY);
          startX += -(double) (startY - size.y) * alfa;
          startY = size.y;
        }

        if (endY < 0) {
          double alfa = (double) (rX - lX) / (double) (rY - lY);
          endX += (double) (-endY - 1) * alfa;
          endY = -1;
        } else if (endY > size.y) {
          double alfa = (double) (rX - lX) / (double) (rY - lY);
          endX -= (double) (endY - size.y) * alfa + 0.5;
          endY = size.y;
        }

        gc.setForeground(darkPurple);
        gc.setLineWidth(2);
        gc.drawLine(startX, startY, endX, endY);

        startX = (int) ((double) pointR.x / 100 / step + size.x / 2);
        endX = startX;
        if (pointR.y > 0) {
          startY = (int) ((double) pointR.y / 100 / step + size.y / 2) + 30;
          endY = (int) ((double) -pointR.y / 100 / step + size.y / 2) - 30;
        } else {
          startY = (int) ((double) pointR.y / 100 / step + size.y / 2) - 30;
          endY = (int) ((double) -pointR.y / 100 / step + size.y / 2) + 30;
        }
        gc.setForeground(purple);
        gc.drawLine(startX, startY, endX, endY);
        gc.setLineWidth(1);

        double x = (double) pointR.x / 100 / step + size.x / 2;
        double y = (double) pointR.y / 100 / step + size.y / 2;
        gc.setForeground(black);
        gc.setBackground(darkPurple);
        gc.fillOval((int) x - 3, (int) y - 3, 7, 7);
        gc.drawOval((int) x - 3, (int) y - 3, 6, 6);
        gc.setForeground(darkPurple);
        gc.setBackground(white);
        if (y < size.x / 2) {
          gc.drawText("-R", (int) x + 8, (int) y + 4, true); // $NON-NLS-1$
        } else {
          gc.drawText("-R", (int) x + 8, (int) y - 10, true); // $NON-NLS-1$
        }
      } else if (pointP != null) {
        gc.setForeground(darkPurple);
        gc.setLineWidth(2);
        int x = (int) ((double) pointP.x / 100 / step + size.x / 2);
        gc.drawLine(x, 0, x, size.y);
        gc.setLineWidth(1);
      }

      if (pointSelect != null) {
        double x = (double) pointSelect.x / 100 / step + size.x / 2;
        double y = -(double) pointSelect.y / 100 / step + size.y / 2;
        String caption = "Q"; // $NON-NLS-1$
        if (pointP == null) caption = "P"; // $NON-NLS-1$
        markPoint(x, y, caption, black, lightBlue, gc);
      }

      if (pointP != null) {
        double x = (double) pointP.x / 100 / step + size.x / 2;
        double y = -(double) pointP.y / 100 / step + size.y / 2;
        String caption = "P"; // $NON-NLS-1$
        if (pointP.equals(pointQ)) caption = "P=Q"; // $NON-NLS-1$
        if (pointP.equals(pointR)) caption = "P=R"; // $NON-NLS-1$

        markPoint(x, y, caption, red, red, gc);
      }

      if (pointQ != null && !pointQ.equals(pointP)) {
        double x = (double) pointQ.x / 100 / step + size.x / 2;
        double y = -(double) pointQ.y / 100 / step + size.y / 2;
        if (!pointQ.equals(pointP)) markPoint(x, y, "Q", red, red, gc); // $NON-NLS-1$
      }

      if (pointR != null && !pointR.isInfinite()) {
        double x = (double) pointR.x / 100 / step + size.x / 2;
        double y = -(double) pointR.y / 100 / step + size.y / 2;
        markPoint(x, y, "R", purple, purple, gc); // $NON-NLS-1$
      }
    }
  }