예제 #1
0
 void drawItem(GC gc, boolean drawFocus) {
   int headerHeight = parent.getBandHeight();
   Display display = getDisplay();
   gc.setForeground(display.getSystemColor(SWT.COLOR_TITLE_BACKGROUND));
   gc.setBackground(display.getSystemColor(SWT.COLOR_TITLE_BACKGROUND_GRADIENT));
   gc.fillGradientRectangle(x, y, width, headerHeight, true);
   if (expanded) {
     gc.setForeground(display.getSystemColor(SWT.COLOR_TITLE_BACKGROUND_GRADIENT));
     gc.drawLine(x, y + headerHeight, x, y + headerHeight + height - 1);
     gc.drawLine(x, y + headerHeight + height - 1, x + width - 1, y + headerHeight + height - 1);
     gc.drawLine(x + width - 1, y + headerHeight + height - 1, x + width - 1, y + headerHeight);
   }
   int drawX = x;
   if (image != null) {
     drawX += ExpandItem.TEXT_INSET;
     if (imageHeight > headerHeight) {
       gc.drawImage(image, drawX, y + headerHeight - imageHeight);
     } else {
       gc.drawImage(image, drawX, y + (headerHeight - imageHeight) / 2);
     }
     drawX += imageWidth;
   }
   if (text.length() > 0) {
     drawX += ExpandItem.TEXT_INSET;
     Point size = gc.stringExtent(text);
     gc.setForeground(parent.getForeground());
     gc.drawString(text, drawX, y + (headerHeight - size.y) / 2, true);
   }
   int chevronSize = ExpandItem.CHEVRON_SIZE;
   drawChevron(gc, x + width - chevronSize, y + (headerHeight - chevronSize) / 2);
   if (drawFocus) {
     gc.drawFocus(x + 1, y + 1, width - 2, headerHeight - 2);
   }
 }
예제 #2
0
 public void backOperatoin(KeyEvent e) {
   if ((e.stateMask & SWT.CTRL) != 0) {
     if (e.keyCode == 'z') { // CTRL + z
       if (imagesList != null && imagesList.size() > 0) {
         int size = imagesList.size();
         // 取出最后一个元素
         image = imagesList.get(size - 1);
         // 显示到Canvas中
         if (image != null) {
           gc.drawImage(
               image,
               0,
               0,
               image.getImageData().width,
               image.getImageData().height,
               0,
               0,
               320,
               480);
           // gc.drawImage(image, 0, 0);
         }
         // 删除该元素
         imagesList.remove(size - 1);
         setParams(0, 0, 0, 0);
         // System.out.println(imagesList.size());
       } else {
         canvasDrawImage(gc);
       }
     }
   }
 }
예제 #3
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);
  }
예제 #4
0
  @SuppressWarnings("deprecation")
  private void doOverlayImage(GC gc) {
    Point2D lowerLeft = new Point2D.Double(overlayEnvelope.getMinX(), overlayEnvelope.getMinY());
    worldToScreen.transform(lowerLeft, lowerLeft);

    Point2D upperRight = new Point2D.Double(overlayEnvelope.getMaxX(), overlayEnvelope.getMaxY());
    worldToScreen.transform(upperRight, upperRight);

    Rectangle bounds = overlayImage.getBounds();
    if (overlayDoXor) {
      gc.setXORMode(true);
    }

    gc.drawImage(
        overlayImage, //
        0, //
        0, //
        bounds.width, //
        bounds.height, //
        (int) lowerLeft.getX(), //
        (int) upperRight.getY(), //
        (int) (upperRight.getX() - lowerLeft.getX()), //
        (int) Math.abs(upperRight.getY() - lowerLeft.getY()) //
        );
    if (overlayDoXor) {
      gc.setXORMode(false);
    }
  }
예제 #5
0
 private void drawClipImage(GC gc, Image image, int ix, int iy, Rectangle repaintRegion) {
   if (repaintRegion != null) {
     ix -= repaintRegion.x;
     iy -= repaintRegion.y;
   }
   gc.drawImage(image, ix, iy);
 }
예제 #6
0
  // @see
  // org.gudy.azureus2.ui.swt.views.table.TableCellSWTPaintListener#cellPaint(org.eclipse.swt.graphics.GC, org.gudy.azureus2.plugins.ui.tables.TableCell)
  public void cellPaint(GC gc, TableCellSWT cell) {
    VuzeActivitiesEntry entry = (VuzeActivitiesEntry) cell.getDataSource();

    if (entry instanceof VuzeActivitiesEntryBuddy) {

      VuzeActivitiesEntryBuddy entryBuddy = (VuzeActivitiesEntryBuddy) entry;
      VuzeBuddy buddy = entryBuddy.getBuddy();
      if (buddy instanceof VuzeBuddySWT) {
        VuzeBuddySWT buddySWT = (VuzeBuddySWT) buddy;
        Image imgAvatar = buddySWT.getAvatarImage();

        if (imgAvatar != null) {
          Rectangle cellBounds = cell.getBounds();
          Rectangle imgBounds = imgAvatar.getBounds();
          int dstWidth = cellBounds.width - 4;
          int dstHeight = dstWidth;

          gc.drawImage(
              imgAvatar,
              0,
              0,
              imgBounds.width,
              imgBounds.height,
              cellBounds.x + ((cellBounds.width - dstWidth) / 2),
              cellBounds.y + ((cellBounds.height - dstWidth) / 2),
              dstWidth,
              dstHeight);
        }
      }
    }
  }
예제 #7
0
  public void paint(
      GC gc,
      boolean hover,
      Hashtable resourceTable,
      boolean selected,
      SelectionData selData,
      Rectangle repaintRegion) {
    Image image = getImage(resourceTable);
    int iwidth = 0;
    int iheight = 0;
    if (image != null) {
      Rectangle rect = image.getBounds();
      iwidth = rect.width + (isSelectable() ? 2 : 0);
      iheight = rect.height + (isSelectable() ? 2 : 0);
    } else return;
    Rectangle bounds = getBounds();
    int ix = bounds.x + (isSelectable() ? 1 : 0);
    int iy = bounds.y + (isSelectable() ? 1 : 0);

    if (selData != null) {
      int leftOffset = selData.getLeftOffset(bounds.height);
      int rightOffset = selData.getRightOffset(bounds.height);
      boolean firstRow = selData.isFirstSelectionRow(bounds.y, bounds.height);
      boolean lastRow = selData.isLastSelectionRow(bounds.y, bounds.height);
      boolean selectedRow = selData.isSelectedRow(bounds.y, bounds.height);
      if (selectedRow) {
        if ((firstRow && leftOffset > ix) || (lastRow && rightOffset < ix + iwidth / 2)) {
          drawClipImage(gc, image, ix, iy, repaintRegion);
        } else {
          Color savedBg = gc.getBackground();
          gc.setBackground(selData.bg);
          int sx = ix;
          int sy = iy;
          if (repaintRegion != null) {
            sx -= repaintRegion.x;
            sy -= repaintRegion.y;
          }
          gc.fillRectangle(sx, sy, iwidth, iheight);
          Image selImage = getSelectedImage(resourceTable, selData);
          gc.drawImage(selImage, sx, sy);
          gc.setBackground(savedBg);
        }
      } else drawClipImage(gc, image, ix, iy, repaintRegion);
    } else drawClipImage(gc, image, ix, iy, repaintRegion);
    if (selected) {
      int fx = bounds.x;
      int fy = bounds.y;
      if (repaintRegion != null) {
        fx -= repaintRegion.x;
        fy -= repaintRegion.y;
      }
      Color fg = gc.getForeground();
      gc.setForeground(gc.getBackground());
      // Clean up to avoid canceling out XOR if it is already
      // selected.
      gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);
      gc.setForeground(fg);
      gc.drawFocus(fx, fy, bounds.width, bounds.height);
    }
  }
예제 #8
0
  private void onPaint(GC gc) {
    Rectangle clientArea = getClientArea();
    gc.setClipping(clientArea);

    gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_GRAY));
    int boxSize = 10;
    int maxCol = clientArea.width / boxSize + 1;
    int maxRow = clientArea.height / boxSize + 1;

    for (int r = 0; r < maxRow; r++) {
      for (int c = 0; c < maxCol; c++) {
        if (r % 2 == c % 2) {
          gc.fillRectangle(c * boxSize, r * boxSize, boxSize, boxSize);
        }
      }
    }

    if (image == null || image.isDisposed()) {
      return;
    }
    Rectangle imageBounds = image.getBounds();

    int x = -getHorizontalBar().getSelection();
    int y = -getVerticalBar().getSelection();

    if (clientArea.width > imageBounds.width) {
      x += (clientArea.width - imageBounds.width) / 2;
    }

    if (clientArea.height > imageBounds.height) {
      y += (clientArea.height - imageBounds.height) / 2;
    }

    gc.drawImage(image, x, y);
  }
예제 #9
0
 void paintCanvas(Event event) {
   canvas.setCursor(null);
   int index = list.getSelectionIndex();
   if (index == -1) return;
   GC gc = event.gc;
   Object object = objects[index];
   if (object instanceof Color) {
     if (((Color) object).isDisposed()) return;
     gc.setBackground((Color) object);
     gc.fillRectangle(canvas.getClientArea());
     return;
   }
   if (object instanceof Cursor) {
     if (((Cursor) object).isDisposed()) return;
     canvas.setCursor((Cursor) object);
     return;
   }
   if (object instanceof Font) {
     if (((Font) object).isDisposed()) return;
     gc.setFont((Font) object);
     FontData[] array = gc.getFont().getFontData();
     StringBuffer sb = new StringBuffer();
     String lf = text.getLineDelimiter();
     for (int i = 0; i < array.length; i++) {
       FontData data = array[i];
       String style = "NORMAL"; // $NON-NLS-1$
       int bits = data.getStyle();
       if (bits != 0) {
         if ((bits & SWT.BOLD) != 0) style = "BOLD "; // $NON-NLS-1$
         if ((bits & SWT.ITALIC) != 0) style += "ITALIC"; // $NON-NLS-1$
       }
       sb.append(data.getName())
           .append(" ")
           .append(data.getHeight()) // $NON-NLS-1$
           .append(" ")
           .append(style)
           .append(lf); // $NON-NLS-1$
     }
     gc.drawString(sb.toString(), 0, 0);
     return;
   }
   // NOTHING TO DRAW FOR GC
   // if (object instanceof GC) {
   // return;
   // }
   if (object instanceof Image) {
     if (((Image) object).isDisposed()) return;
     gc.drawImage((Image) object, 0, 0);
     return;
   }
   if (object instanceof Region) {
     if (((Region) object).isDisposed()) return;
     String string = ((Region) object).getBounds().toString();
     gc.drawString(string, 0, 0);
     return;
   }
 }
예제 #10
0
 @Override
 public void paintChild(MapValues map, GC gc, Location each) {
   // draw semi-transparent background
   gc.setAlpha(196);
   gc.fillOval(each.px - diameter / 2, each.py - diameter / 2, diameter, diameter);
   gc.setAlpha(255);
   // draw image
   gc.drawImage(image, each.px - bounds.width / 2, each.py - bounds.height / 2);
 }
예제 #11
0
 /**
  * This drawing function handles drawing the tile image at the specified zoom level. It will
  * attempt to use a cached copy, but will rescale if the requested zoom does not equal the current
  * cache zoom.
  *
  * @param gc Graphics instance to draw to
  * @param x x-coord to draw tile at
  * @param y y-coord to draw tile at
  * @param zoom Zoom level to draw the tile
  */
 public void drawRaw(GC gc, int x, int y, double zoom) {
   Image img = getScaledImage(zoom);
   if (img != null) {
     Rectangle bounds = img.getBounds();
     gc.drawImage(img, x, y - bounds.height);
   } else {
     // TODO: Allow drawing IDs when no image data exists as a
     // config option
   }
 }
예제 #12
0
  /**
   * Create an image. The image is added to a cache kept by this provider and is disposed of when
   * this provider is disposed of.
   *
   * @param name the image name.
   * @param rightImage
   * @param leftImage
   * @return the image.
   */
  @Nonnull
  private Image createImage(@Nonnull final String[] names) {
    final StringBuilder builder = new StringBuilder();
    for (final String string : names) {
      builder.append(string);
    }
    final String name = builder.toString();

    if (_imageCache.containsKey(name)) {
      return _imageCache.get(name);
    }

    Image leftImage;
    Image rightImage;
    int width;
    Image dualImage;

    if (names.length == 2) {
      leftImage = loadImage(AlarmTreePreference.RES_ICON_PATH.getValue() + "/" + names[0] + ".gif");
      rightImage =
          loadImage(AlarmTreePreference.RES_ICON_PATH.getValue() + "/" + names[1] + ".gif");
      width = leftImage.getBounds().width / 3 + 2 + rightImage.getBounds().width;
      dualImage = new Image(leftImage.getDevice(), width, leftImage.getBounds().height);
      final GC gc = new GC(dualImage);
      if (names[1].equals("checked")) {
        gc.drawImage(leftImage, leftImage.getBounds().width / 3 + 2, 0);
        gc.drawImage(rightImage, 2, 0);
      } else {
        gc.drawImage(leftImage, 0, 0);
        gc.drawImage(rightImage, leftImage.getBounds().width / 3 + 2, 0);
      }
      gc.dispose();
    } else {
      leftImage = loadImage(AlarmTreePreference.RES_ICON_PATH.getValue() + "/" + names[0] + ".gif");
      width = leftImage.getBounds().width / 3 + 2 + leftImage.getBounds().width;
      dualImage = new Image(leftImage.getDevice(), width, leftImage.getBounds().height);
      final GC gc = new GC(dualImage);
      gc.drawImage(leftImage, leftImage.getBounds().width / 3 + 2, 0);
      gc.dispose();
    }
    _imageCache.put(name, dualImage);
    return dualImage;
  }
예제 #13
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$
  }
예제 #14
0
  private Image createOverlayImg(Image mainImg, Image overlay) {
    Image resultImg = new Image(Display.getCurrent(), mainImg, SWT.IMAGE_COPY);

    GC gc = new GC(resultImg);
    try {
      gc.drawImage(overlay, -2, 1);
    } finally {
      gc.dispose();
    }

    return resultImg;
  }
예제 #15
0
 /**
  * Returns an {@link Image} composed of a base image decorated by another image.
  *
  * @param baseImage the base {@link Image} that should be decorated
  * @param decorator the {@link Image} to decorate the base image
  * @param corner the corner to place decorator image
  * @return the resulting decorated {@link Image}
  */
 public static Image decorateImage(
     final Image baseImage, final Image decorator, final int corner) {
   if (corner <= 0 || corner >= LAST_CORNER_KEY) {
     throw new IllegalArgumentException("Wrong decorate corner");
   }
   Map<Image, Map<Image, Image>> cornerDecoratedImageMap = m_decoratedImageMap[corner];
   if (cornerDecoratedImageMap == null) {
     cornerDecoratedImageMap = new HashMap<Image, Map<Image, Image>>();
     m_decoratedImageMap[corner] = cornerDecoratedImageMap;
   }
   Map<Image, Image> decoratedMap = cornerDecoratedImageMap.get(baseImage);
   if (decoratedMap == null) {
     decoratedMap = new HashMap<Image, Image>();
     cornerDecoratedImageMap.put(baseImage, decoratedMap);
   }
   //
   Image result = decoratedMap.get(decorator);
   if (result == null) {
     Rectangle bib = baseImage.getBounds();
     Rectangle dib = decorator.getBounds();
     //
     result = new Image(Display.getCurrent(), bib.width, bib.height);
     //
     GC gc = new GC(result);
     gc.drawImage(baseImage, 0, 0);
     if (corner == TOP_LEFT) {
       gc.drawImage(decorator, 0, 0);
     } else if (corner == TOP_RIGHT) {
       gc.drawImage(decorator, bib.width - dib.width, 0);
     } else if (corner == BOTTOM_LEFT) {
       gc.drawImage(decorator, 0, bib.height - dib.height);
     } else if (corner == BOTTOM_RIGHT) {
       gc.drawImage(decorator, bib.width - dib.width, bib.height - dib.height);
     }
     gc.dispose();
     //
     decoratedMap.put(decorator, result);
   }
   return result;
 }
예제 #16
0
 /**
  * @param image
  * @param width
  * @param height
  * @return
  */
 private Image resize(Image image, int width) {
   int height =
       (int) (width / ((float) image.getImageData().width / (float) image.getImageData().height));
   Image scaled = new Image(Display.getDefault(), width, height);
   GC gc = new GC(scaled);
   gc.setAntialias(SWT.ON);
   gc.setInterpolation(SWT.HIGH);
   gc.drawImage(
       image, 0, 0, image.getBounds().width, image.getBounds().height, 0, 0, width, height);
   gc.dispose();
   image.dispose();
   return scaled;
 }
예제 #17
0
  private void drawFinalImage(Image swtImage) {
    Display display = getDisplay();
    // this is only done if an overlay image exists

    // create a new image
    Image tmpImage = new Image(display, curPaintArea.width, curPaintArea.height);
    GC tmpGc = new GC(tmpImage);
    tmpGc.setBackground(white);
    tmpGc.fillRectangle(0, 0, curPaintArea.width, curPaintArea.height);
    if (swtImage != null) {
      // set the alpha to the new image
      tmpGc.setAlpha(alpha);
      /*
       * draw the background image into it
       * (this means everything but the overlay image)
       */
      tmpGc.drawImage(swtImage, imageOrigin.x, imageOrigin.y);
      /*
       * set the alpha back to opaque so it doesn't influence the
       * overlay image
       */
      tmpGc.setAlpha(255);
    }
    if (overlayImage != null) {
      // finally draw the overlay image on top
      doOverlayImage(tmpGc);
    }
    // draw the created new image on the pane
    if (gc != null && !gc.isDisposed()) gc.drawImage(tmpImage, imageOrigin.x, imageOrigin.y);

    if (tmpImage != null && !tmpImage.isDisposed()) {
      tmpImage.dispose();
      tmpImage = null;
    }
    if (tmpGc != null && !tmpGc.isDisposed()) {
      tmpGc.dispose();
      tmpGc = null;
    }
  }
예제 #18
0
  /* Paint function */
  private void paint(GC gc) {
    Rectangle clientRect = getClientArea(); // Canvas' painting area
    if (sourceImage != null) {
      Rectangle imageRect = SWTUtil.inverseTransformRect(transform, clientRect);
      int gap = 2; // find a better start point to render
      imageRect.x -= gap;
      imageRect.y -= gap;
      imageRect.width += 2 * gap;
      imageRect.height += 2 * gap;

      Rectangle imageBound = sourceImage.getBounds();
      imageRect = imageRect.intersection(imageBound);
      Rectangle destRect = SWTUtil.transformRect(transform, imageRect);

      if (screenImage != null) screenImage.dispose();
      screenImage = new Image(getDisplay(), clientRect.width, clientRect.height);
      GC newGC = new GC(screenImage);
      newGC.setClipping(clientRect);
      newGC.drawImage(
          sourceImage,
          imageRect.x,
          imageRect.y,
          imageRect.width,
          imageRect.height,
          destRect.x,
          destRect.y,
          destRect.width,
          destRect.height);
      newGC.dispose();

      gc.drawImage(screenImage, 0, 0);
    } else {
      gc.setClipping(clientRect);
      gc.fillRectangle(clientRect);
      initScrollBars();
    }
  }
예제 #19
0
  /**
   * Performs the skin draw operation.
   *
   * @param gcUsedToDraw The gc object associated with the skin composite that is used to draw the
   *     images
   */
  private void drawSkin(GC gcUsedToDraw, IAndroidKey changedKey) {
    if (currentSkinImage == null) {
      IAndroidEmulatorInstance instance = UIHelper.getInstanceAssociatedToControl(this);
      ImageData initialSkinImage = getImageData(false, false);
      setSkinImage(initialSkinImage, null, false);
      applyLayout(instance.getCurrentLayout());

      if (scrollBarsUsed) {
        synchronizeScrollBars();
      }
    }

    if (displayRectangle != null) {
      int srcXPos, srcYPos, srcWidth, srcHeight;
      int destXPos, destYPos, destWidth, destHeight;
      if (changedKey == null) {
        srcXPos = displayRectangle.x;
        srcYPos = displayRectangle.y;
        srcWidth = displayRectangle.width;
        srcHeight = displayRectangle.height;
        destXPos = 0;
        destYPos = 0;
        destWidth = Math.min(currentSkinImage.getImageData().width, displayRectangle.width);
        destHeight = Math.min(currentSkinImage.getImageData().height, displayRectangle.height);
      } else {
        srcXPos =
            ((int) (changedKey.getKeyArea().x > 0 ? changedKey.getKeyArea().x * zoomFactor : 0));
        srcYPos =
            ((int) (changedKey.getKeyArea().y > 0 ? changedKey.getKeyArea().y * zoomFactor : 0));
        srcWidth = ((int) (changedKey.getKeyArea().width * zoomFactor));
        srcHeight = ((int) (changedKey.getKeyArea().height * zoomFactor));
        destXPos = srcXPos - displayRectangle.x;
        destYPos = srcYPos - displayRectangle.y;
        destWidth = srcWidth;
        destHeight = srcHeight;
      }

      gcUsedToDraw.drawImage(
          currentSkinImage,
          srcXPos,
          srcYPos,
          srcWidth,
          srcHeight,
          destXPos,
          destYPos,
          destWidth,
          destHeight);
    }
  }
예제 #20
0
 private void drawEQImage(GC gc) {
   if (ibuffer != null) {
     synchronized (ibuffer) {
       if (AXIS_PADDING + (MINIMUM_UNIT_HEIGHT * size) > winYSize) {
         scroll.setMinSize(
             canvas.computeSize(SWT.DEFAULT, AXIS_PADDING + (MINIMUM_UNIT_HEIGHT * size)));
       } else {
         scroll.setMinSize(canvas.computeSize(SWT.DEFAULT, winYSize));
       }
       if (ibuffer.isDisposed() == false) {
         gc.drawImage(ibuffer, 0, 0);
       }
     }
   }
 }
예제 #21
0
  private void paint(PaintEvent event) {
    GC gc = event.gc;

    // fonts are disposed when calendar is disposed
    Font used = null;
    if (CalendarCombo.OS_CARBON) {
      used = mSettings.getCarbonDrawFont();
      if (used != null) gc.setFont(used);
    } else if (CalendarCombo.OS_WINDOWS) {
      used = mSettings.getWindowsMonthPopupDrawFont();
      if (used != null) gc.setFont(used);
    }

    // double buffering. this could be triple buffering if the platform does
    // it automatically, windows XP does not seem to however
    // basically, we draw all the updates onto an Image in memory, then we
    // transfer the contents thereof onto the canvas.
    // that way there is 0 flicker, which is the desired effect.
    if (mCreated && mEnableDoubleBuffering) {
      try {
        Image buffer = new Image(Display.getDefault(), super.getBounds());
        GC gc2 = new GC(buffer);
        drawOntoGC(gc2);

        // transfer the image buffer onto this canvas
        // just drawImage(buffer, w, h) didn't work, so we do the whole
        // source transfer call
        Rectangle b = getBounds();
        gc.drawImage(buffer, 0, 0, b.width, b.height, 0, 0, b.width, b.height);

        // dispose the buffer, very important or we'll run out of
        // address space for buffered images
        buffer.dispose();
        gc2.dispose();
      } catch (IllegalArgumentException iea) {
        // seems to come here for some reason when we switch phases
        // while the gantt chart is being viewed, I'm not sure why
        // but no time to figure it out for the demo.. so instead of
        // buffering, just draw it onto the GC
        drawOntoGC(gc);
      }
    } else {
      drawOntoGC(gc);
      mCreated = true;
    }

    // don't dispose font, they are disposed when the CalendarCombo are disposed
  }
예제 #22
0
  public void canvasDrawImage(GC gc) {
    try {

      FileInputStream input = new FileInputStream(new File("./workspace/" + file));
      ImageData imageData = new ImageData(input);
      image = new Image(Display.getDefault(), imageData);

      this.realHeight = imageData.height;
      this.realWidth = imageData.width;
      gc.drawImage(image, 0, 0, imageData.width, imageData.height, 0, 0, 320, 480);
      input.close();
      imagesList.add(image);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
예제 #23
0
  private static Image getFlagRect(Image oFlag) {
    // Color background = GUIPI.getColor(GUIPI.windowColor);

    int size = Math.max(oFlag.getBounds().height, oFlag.getBounds().width);
    //	Rectangle rect = new Rectangle(0,0,size,size);
    Image i = new Image(oFlag.getDevice(), size, size);
    GC gc = new GC(i);
    gc.setBackground(oFlag.getDevice().getSystemColor(SWT.COLOR_WHITE));
    gc.fillRectangle(0, 0, size, size);
    gc.drawImage(
        oFlag, (size - oFlag.getBounds().width) / 2, (size - oFlag.getBounds().height) / 2);
    gc.dispose();

    ImageData id = i.getImageData();
    id.transparentPixel = id.palette.getPixel(new RGB(255, 255, 255));
    i.dispose();
    return new Image(oFlag.getDevice(), id);
  }
  void paint(PaintEvent e) {
    GC gc = e.gc;
    Point size = comp.getSize();
    if (curveColor == null) curveColor = e.display.getSystemColor(SWT.COLOR_BLACK);
    int h = size.y;
    int[] simpleCurve = new int[] {0, h - 1, 1, h - 1, 2, h - 2, 2, 1, 3, 0};
    // draw border
    gc.setForeground(curveColor);
    gc.setAdvanced(true);
    if (gc.getAdvanced()) {
      gc.setAntialias(SWT.ON);
    }
    gc.drawPolyline(simpleCurve);

    Rectangle bounds = ((Control) e.widget).getBounds();
    bounds.x = bounds.y = 0;
    Region r = new Region();
    r.add(bounds);
    int[] simpleCurveClose = new int[simpleCurve.length + 4];
    System.arraycopy(simpleCurve, 0, simpleCurveClose, 0, simpleCurve.length);
    int index = simpleCurve.length;
    simpleCurveClose[index++] = bounds.width;
    simpleCurveClose[index++] = 0;
    simpleCurveClose[index++] = bounds.width;
    simpleCurveClose[index++] = bounds.height;
    r.subtract(simpleCurveClose);
    Region clipping = new Region();
    gc.getClipping(clipping);
    r.intersect(clipping);
    gc.setClipping(r);
    Image b = toolParent.getBackgroundImage();
    if (b != null && !b.isDisposed()) gc.drawImage(b, 0, 0);

    r.dispose();
    clipping.dispose();
    // // gc.fillRectangle(bounds);
    // Rectangle mappedBounds = e.display.map(comp, comp.getParent(),
    // bounds);
    // ((Composite) toolParent).drawBackground(gc, bounds.x, bounds.y,
    // bounds.width,
    // bounds.height, mappedBounds.x, mappedBounds.y);

  }
  private Image resize(Image source) {
    Rectangle sourceBounds = source.getBounds();

    boolean width = sourceBounds.width > sourceBounds.height;
    // calculate the new factor
    float factor = width ? 16 / (float) sourceBounds.width : 16 / (float) sourceBounds.height;

    // calculate the dimensions
    int newW = width ? 16 : Math.round(factor * sourceBounds.width);
    int newH = width ? Math.round(factor * sourceBounds.height) : 16;

    Image target = new Image(source.getDevice(), newW, newH);
    GC targetGC = new GC(target);

    targetGC.drawImage(source, 0, 0, sourceBounds.width, sourceBounds.height, 0, 0, newW, newH);
    targetGC.dispose();
    source.dispose();
    return target;
  }
예제 #26
0
  public Image captureImage(Control control) {
    Rectangle rectangle = control.getBounds();
    Display display = control.getDisplay();
    Image image = null;
    if (control instanceof Shell) {
      Shell shell = (Shell) control;
      shell.layout();
      Point parentLocation = control.toDisplay(0, 0);
      image = getImage(control, rectangle.width, rectangle.height, false);

      rectangle.x = parentLocation.x;
      rectangle.y = parentLocation.y;

      GC myImageGC = new GC(image);
      try {
        for (Control child : shell.getChildren()) {
          Rectangle childBounds = child.getBounds();
          // bug of SWT on Win32, child bounds is not correct in the Window is not in the ToolBar
          int x = (rectangle.width - childBounds.width) / 2;
          int y = (rectangle.height - childBounds.height) - x;
          childBounds.x = rectangle.x + x;
          childBounds.y = rectangle.y + y;
          if (!rectangle.intersects(childBounds)) continue; // Child is completely outside parent.

          Image childImage = new Image(display, child.getBounds());
          GC gc = new GC(childImage);
          child.print(gc);
          DisposeUtil.dispose(gc);
          try {
            myImageGC.drawImage(childImage, x, y);
          } finally {
            childImage.dispose();
          }
        }
      } finally {
        myImageGC.dispose();
      }
    } else {
      image = defaultCapture(control);
    }
    return image;
  }
예제 #27
0
 public void drawImage(FSImage image, int x, int y) {
   Image img = ((SWTFSImage) image).getImage();
   if (img == null) {
     int width = image.getWidth();
     int height = image.getHeight();
     Color oldBG = _gc.getBackground();
     Color oldFG = _gc.getForeground();
     _gc.setBackground(_gc.getDevice().getSystemColor(SWT.COLOR_WHITE));
     _gc.setForeground(_gc.getDevice().getSystemColor(SWT.COLOR_BLACK));
     _gc.fillRectangle(x, y, width, height);
     _gc.drawRectangle(x, y, width, height);
     _gc.drawLine(x, y, x + width - 1, y + height - 1);
     _gc.drawLine(x, y + height - 1, x + width - 1, y);
     _gc.setBackground(oldBG);
     _gc.setForeground(oldFG);
   } else {
     Rectangle bounds = img.getBounds();
     _gc.drawImage(
         img, 0, 0, bounds.width, bounds.height, x, y, image.getWidth(), image.getHeight());
   }
 }
예제 #28
0
 LRESULT wmDrawChild(long /*int*/ wParam, long /*int*/ lParam) {
   DRAWITEMSTRUCT struct = new DRAWITEMSTRUCT();
   OS.MoveMemory(struct, lParam, DRAWITEMSTRUCT.sizeof);
   if (image != null) {
     GCData data = new GCData();
     data.device = display;
     GC gc = GC.win32_new(struct.hDC, data);
     /*
      * Bug in Windows.  When a bitmap is included in the
      * menu bar, the HDC seems to already include the left
      * coordinate.  The fix is to ignore this value when
      * the item is in a menu bar.
      */
     int x = (parent.style & SWT.BAR) != 0 ? MARGIN_WIDTH * 2 : struct.left;
     Image image = getEnabled() ? this.image : new Image(display, this.image, SWT.IMAGE_DISABLE);
     gc.drawImage(image, x, struct.top + MARGIN_HEIGHT);
     if (this.image != image) image.dispose();
     gc.dispose();
   }
   if (parent.foreground != -1) OS.SetTextColor(struct.hDC, parent.foreground);
   return null;
 }
예제 #29
0
  protected void drawImage() {
    if (imageData != null) {
      int deltaX = (canvas.getSize().x - imageData.width) / 2;
      int deltaY = (canvas.getSize().y - imageData.height) / 2;
      image.dispose();
      image = new Image(Display.getCurrent(), imageData);
      bgImage.dispose();
      bgImage = new Image(Display.getCurrent(), canvas.getSize().x, canvas.getSize().y);
      GC gc = new GC(bgImage);
      gc.drawImage(image, deltaX, deltaY);
      gc.setLineWidth(3);
      gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_RED));

      Vector3f coords0 =
          implementor
              .getCamera()
              .getWorldCoordinates(
                  new Vector2f(
                      implementor.getCanvas().getSize().x / 2,
                      implementor.getCanvas().getSize().y / 2),
                  0);
      Vector3f coords1 =
          implementor
              .getCamera()
              .getWorldCoordinates(
                  new Vector2f(
                      implementor.getCanvas().getSize().x / 2,
                      implementor.getCanvas().getSize().y / 2),
                  1);
      Vector3f direction = coords0.subtract(coords1).normalizeLocal();
      coords0.subtractLocal(direction.mult(coords0.y / direction.y));
      Vector3f coords = mapCamera.getScreenCoordinates(coords0);
      gc.drawRectangle(deltaX + (int) coords.x - 25, 200 + deltaY - (int) coords.y - 25, 50, 50);

      canvas.setBackgroundImage(bgImage);
      gc.dispose();
    }
  }
예제 #30
0
  /**
   * Paints the region specified of the canvas onto the given Graphics Context.
   *
   * @param gc graphics onto within painting should occur
   * @param x left of the dirty region
   * @param y top of the dirty region
   * @param w width of the dirty region
   * @param h height of the dirty region
   */
  public void paintComponent(final GC gc, final int x, final int y, final int w, final int h) {
    PDebug.startProcessingOutput();

    GC imageGC = null;
    Graphics2D g2 = null;
    if (doubleBuffered) {
      imageGC = new GC(backBuffer);
      g2 = new SWTGraphics2D(imageGC, getDisplay());
    } else {
      g2 = new SWTGraphics2D(gc, getDisplay());
    }

    g2.setColor(Color.white);
    g2.setBackground(Color.white);

    final Rectangle rect = getBounds();
    g2.fillRect(0, 0, rect.width, rect.height);

    // This fixes a problem with standard debugging of region management in
    // SWT
    if (PDebug.debugRegionManagement) {
      final Rectangle r = gc.getClipping();
      final Rectangle2D r2 = new Rectangle2D.Double(r.x, r.y, r.width, r.height);
      g2.setBackground(PDebug.getDebugPaintColor());
      g2.fill(r2);
    }

    // create new paint context and set render quality
    final PPaintContext paintContext = new PPaintContext(g2);
    if (getInteracting() || getAnimating()) {
      if (interactingRenderQuality > animatingRenderQuality) {
        paintContext.setRenderQuality(interactingRenderQuality);
      } else {
        paintContext.setRenderQuality(animatingRenderQuality);
      }
    } else {
      paintContext.setRenderQuality(defaultRenderQuality);
    }

    // paint Piccolo2D
    camera.fullPaint(paintContext);

    // if switched state from animating to not animating invalidate
    // the entire screen so that it will be drawn with the default instead
    // of animating render quality.
    if (animatingOnLastPaint && !getAnimating()) {
      repaint();
    }
    animatingOnLastPaint = getAnimating();

    final boolean region = PDebug.debugRegionManagement;
    PDebug.debugRegionManagement = false;
    PDebug.endProcessingOutput(g2);
    PDebug.debugRegionManagement = region;

    if (doubleBuffered) {
      gc.drawImage(backBuffer, 0, 0);

      // Dispose of the allocated image gc
      imageGC.dispose();
    }
  }