/**
   * Given a label figure object, this will calculate the correct Font needed to display into screen
   * coordinates, taking into account the current mapmode. This will typically be used by direct
   * edit cell editors that need to display independent of the zoom or any coordinate mapping that
   * is taking place on the drawing surface.
   *
   * @param label the label to use for the font calculation
   * @return the <code>Font</code> that is scaled to the screen coordinates. Note: the returned
   *     <code>Font</code> should not be disposed since it is cached by a common resource manager.
   */
  protected Font getScaledFont(IFigure label) {
    Font scaledFont = label.getFont();
    FontData data = scaledFont.getFontData()[0];
    Dimension fontSize = new Dimension(0, MapModeUtil.getMapMode(label).DPtoLP(data.getHeight()));
    label.translateToAbsolute(fontSize);

    if (Math.abs(data.getHeight() - fontSize.height) < 2) fontSize.height = data.getHeight();

    try {
      FontDescriptor fontDescriptor = FontDescriptor.createFrom(data);
      cachedFontDescriptors.add(fontDescriptor);
      return getResourceManager().createFont(fontDescriptor);
    } catch (DeviceResourceException e) {
      Trace.catching(
          DiagramUIPlugin.getInstance(),
          DiagramUIDebugOptions.EXCEPTIONS_CATCHING,
          getClass(),
          "getScaledFont",
          e); //$NON-NLS-1$
      Log.error(
          DiagramUIPlugin.getInstance(),
          DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING,
          "getScaledFont",
          e); //$NON-NLS-1$
    }
    return JFaceResources.getDefaultFont();
  }
  /**
   * Given an absolute point (pStart) and a list of EditParts, this method finds the closest
   * EditPart (except for the one to be excluded) in the given direction.
   *
   * @param siblings List of sibling EditParts
   * @param pStart The starting point (must be in absolute coordinates) from which the next sibling
   *     is to be found.
   * @param direction PositionConstants
   * @param exclude The EditPart to be excluded from the search
   */
  public IGraphicalEntityPart findSibling(
      List<?> siblings, Point pStart, int direction, EditPart exclude) {
    IGraphicalEntityPart epCurrent;
    IGraphicalEntityPart epFinal = null;
    IFigure figure;
    Point pCurrent;
    int distance = Integer.MAX_VALUE;

    Iterator<?> iter = siblings.iterator();
    while (iter.hasNext()) {
      epCurrent = (IGraphicalEntityPart) iter.next();
      if (epCurrent == exclude || !epCurrent.isSelectable()) continue;
      figure = epCurrent.getFigure();
      pCurrent = getNavigationPoint(figure);
      figure.translateToAbsolute(pCurrent);
      if (pStart.getPosition(pCurrent) != direction) continue;

      Dimension difference = pCurrent.getDifference(pStart);
      int d = Math.abs(difference.width()) + Math.abs(difference.height());
      if (d < distance) {
        distance = d;
        epFinal = epCurrent;
      }
    }
    return epFinal;
  }
 @Override
 protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
   Dimension d = getLayoutData().getSize();
   Insets insets = container.getInsets();
   d = new Dimension(d.width + insets.getWidth(), d.height + insets.getHeight());
   return d.union(getBorderPreferredSize(container));
 }
Example #4
0
 @Override
 protected Dimension calculatePreferredSize(IFigure container, int w, int h) {
   Insets insets = container.getInsets();
   Dimension d = new Dimension(64, 4 * 64);
   d.expand(insets.getWidth(), insets.getHeight());
   return d;
 }
  @Override
  protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
    Insets insets = container.getInsets();
    if (isHorizontal()) {
      wHint = -1;
      if (hHint >= 0) {
        hHint = Math.max(0, hHint - insets.getHeight());
      }
    } else {
      hHint = -1;
      if (wHint >= 0) {
        wHint = Math.max(0, wHint - insets.getWidth());
      }
    }

    List children = container.getChildren();
    Dimension prefSize = calculateChildrenSize(children, wHint, hHint, true);
    // Do a second pass, if necessary
    if (wHint >= 0 && prefSize.width > wHint) {
      prefSize = calculateChildrenSize(children, prefSize.width, hHint, true);
    } else if (hHint >= 0 && prefSize.width > hHint) {
      prefSize = calculateChildrenSize(children, wHint, prefSize.width, true);
    }

    prefSize.height += Math.max(0, children.size() - 1) * spacing;
    return transposer
        .t(prefSize)
        .expand(insets.getWidth(), insets.getHeight())
        .union(getBorderPreferredSize(container));
  }
  /**
   * Used inside the getSizeDeltaToFitAnchors operation. It's goal is to modify a SizeDelta in order
   * to keep fitting an anchor within the figureBounds
   *
   * @param anchor The anchor whose position will be kept
   * @param sizeDelta
   * @param preserveAxis
   * @param figureBounds
   */
  protected static void modifySizeDeltaToFitAnchor(
      IdentityAnchor anchor, Dimension sizeDelta, int preserveAxis, Rectangle figureBounds) {

    if (anchor == null) {
      return;
    }

    PrecisionPoint pp = BaseSlidableAnchor.parseTerminalString(anchor.getId());

    int margin = 6;

    if (preserveAxis == PRESERVE_Y || preserveAxis == PRESERVE_XY) {
      int anchorYPos = (int) Math.round(figureBounds.height * pp.preciseY);

      int newHeight = figureBounds.height + sizeDelta.height;

      if (anchorYPos + margin > newHeight) {
        sizeDelta.height = (anchorYPos - figureBounds.height) + margin;
      }
    }

    if (preserveAxis == PRESERVE_X || preserveAxis == PRESERVE_XY) {
      int anchorXPos = (int) Math.round(figureBounds.width * pp.preciseX);

      int newWidth = figureBounds.width + sizeDelta.width;

      if (anchorXPos + margin > newWidth) {
        sizeDelta.width = (anchorXPos - figureBounds.width) + margin;
      }
    }
  }
  /**
   * Computes actual grid specification (origin + single cell width and height) in the coordinates
   * relative to the diagram content pane.
   *
   * <p>This specification depends only on the grid-relative properties stored in the {@link
   * EditPartViewer}, so client may cache it and rely on {@link
   * EditPartViewer#addPropertyChangeListener(PropertyChangeListener)}
   *
   * @param viewer
   * @return grid specification in the coordinate system relative to diagram content pane, or <code>
   *     null</code> if grid is not enabled
   */
  private static PrecisionRectangle getRelativeGridSpec(EditPartViewer viewer) {
    Boolean enabled = (Boolean) viewer.getProperty(SnapToGrid.PROPERTY_GRID_ENABLED);
    if (enabled == null || !enabled) {
      return null;
    }
    double gridX = 0;
    double gridY = 0;
    Dimension spacing = (Dimension) viewer.getProperty(SnapToGrid.PROPERTY_GRID_SPACING);
    if (spacing != null) {
      gridX = spacing.preciseWidth();
      gridY = spacing.preciseHeight();
    }
    if (gridX <= 0) {
      gridX = SnapToGrid.DEFAULT_GRID_SIZE;
    }
    if (gridY <= 0) {
      gridY = SnapToGrid.DEFAULT_GRID_SIZE;
    }
    Point origin = (Point) viewer.getProperty(SnapToGrid.PROPERTY_GRID_ORIGIN);
    PrecisionRectangle result =
        new PrecisionRectangle( //
            origin == null ? 0 : origin.preciseX(),
            origin == null ? 0 : origin.preciseY(),
            gridX,
            gridY);

    return result;
  }
 @Override
 public Dimension getPreferredSize(int wHint, int hHint) {
   Dimension prefSize = super.getPreferredSize(wHint, hHint);
   int bodyHeight = getParent().getBounds().height - 10;
   Dimension defaultSize = new Dimension(SWT.DEFAULT, bodyHeight);
   prefSize.union(defaultSize);
   return prefSize;
 }
 @Override
 public Dimension getPreferredSize(int wHint, int hHint) {
   Dimension size = super.getPreferredSize(wHint, hHint);
   // FIXME
   if (size.width < DrawUtils.SPACING + getBorder().getPreferredSize(this).width)
     size.width =
         Math.max(size.width, DrawUtils.SPACING + getBorder().getPreferredSize(this).width);
   return size;
 }
    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.draw2d.ToolbarLayout#calculatePreferredSize(org.eclipse.draw2d.IFigure, int, int)
     */
    @Override
    protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
      Insets insets = container.getInsets();
      Dimension prefSize = calculateChildrenSize(container.getChildren(), wHint, hHint);

      return prefSize
          .expand(insets.getWidth(), insets.getHeight())
          .union(getBorderPreferredSize(container));
    }
Example #11
0
  // We override reveal to show the Handles of the selected EditPart when
  // scrolling
  public void reveal(EditPart part) {
    // In some case, the editor control is not created, but get the sync selection event.
    // Fix this problem temporary.
    if (getFigureCanvas() == null || getFigureCanvas().isDisposed()) {
      return;
    }

    Viewport port = getFigureCanvas().getViewport();
    IFigure target = ((GraphicalEditPart) part).getFigure();

    Rectangle exposeRegion = target.getBounds().getCopy();

    // Get the primary editpolicy
    EditPolicy policy = part.getEditPolicy(EditPolicy.PRIMARY_DRAG_ROLE);

    // If the policy let us access the handles, proceed, otherwise
    // default to original behaviour
    if (!(policy instanceof ISelectionHandlesEditPolicy)) {
      super.reveal(part);
      return;
    }

    // First translate exposeRegion to the root level
    target = target.getParent();
    while (target != null && target != port) {
      target.translateToParent(exposeRegion);
      target = target.getParent();
    }

    // Merge selection handles if any to the exposeRegion
    List handles = ((ISelectionHandlesEditPolicy) policy).getHandles();
    for (Iterator iter = handles.iterator(); iter.hasNext(); ) {
      AbstractHandle handle = (AbstractHandle) iter.next();

      Locator locator = handle.getLocator();
      locator.relocate(handle);
      exposeRegion.union(handle.getBounds().getCopy());
    }

    exposeRegion.getExpanded(5, 5);

    Dimension viewportSize = port.getClientArea().getSize();

    Point topLeft = exposeRegion.getTopLeft();
    Point bottomRight = exposeRegion.getBottomRight().translate(viewportSize.getNegated());
    Point finalLocation = new Point();
    if (viewportSize.width < exposeRegion.width)
      finalLocation.x = Math.min(bottomRight.x, Math.max(topLeft.x, port.getViewLocation().x));
    else finalLocation.x = Math.min(topLeft.x, Math.max(bottomRight.x, port.getViewLocation().x));

    if (viewportSize.height < exposeRegion.height)
      finalLocation.y = Math.min(bottomRight.y, Math.max(topLeft.y, port.getViewLocation().y));
    else finalLocation.y = Math.min(topLeft.y, Math.max(bottomRight.y, port.getViewLocation().y));

    getFigureCanvas().scrollSmoothTo(finalLocation.x, finalLocation.y);
  }
  /*
   * (non-Javadoc)
   *
   * @see henshineditor.figure.condition.FormulaFigure#getPreferredDimension()
   */
  @Override
  protected Dimension getPreferredDimension() {
    Dimension dimension = super.getPreferredDimension();

    FormulaFigure<?> childFigure = getChildFigure();
    if (childFigure != null) {
      Dimension childDimension = childFigure.getPreferredDimension();
      dimension.height += childDimension.height;
      dimension.width = childDimension.width;
    }

    return dimension;
  }
 /**
  * Calculate the best size for this label using the class's width to height ratio. This is done by
  * calculating the area that the text would occupy if it was in only one line, then calculate a
  * new width that would give the same area using the width to height ratio, and finally it sends
  * this width to the {@link FlowPage}'s {@link FlowPage#getPreferredSize(int, int)} method which
  * calculates the real height using line breaks.
  *
  * @return A close match to the size that this figure should have to match the required width to
  *     height ratio.
  */
 public Dimension calculateSize() {
   try {
     Dimension lineDimensions =
         TextUtilities.INSTANCE.getStringExtents(textFlow.getText(), getFont());
     double area = lineDimensions.width() * lineDimensions.height();
     double width = Math.sqrt(area / ratio) * ratio;
     invalidate();
     Dimension pSize = textFlow.getPreferredSize((int) width, -1).getCopy();
     if (pSize.width < OPPFigureConstants.MINIMUM_NODE_SIZE) pSize.width = pSize.height;
     return pSize;
   } catch (Exception e) {
     return new Dimension(0, 0);
   }
 }
 private void refreshLabelBounds(IFigure figure, GraphLabel label) {
   Rectangle figureBounds = figure.getBounds();
   if (figureBounds.width * figureBounds.height > 0) {
     label.setText(label.getText()); // hack: resets label's size
     Dimension labelSize = label.getSize();
     labelSize.expand(-6, -4);
     Point anchorPoint = figure.getBounds().getBottomRight();
     anchorPoint.x -= labelSize.width / 2;
     anchorPoint.y -= labelSize.height / 2;
     Rectangle bounds = new Rectangle(anchorPoint, labelSize);
     label.setBounds(bounds);
     label.getParent().setConstraint(label, bounds);
   } else {
     label.getParent().setConstraint(label, new Rectangle(figureBounds.x, figureBounds.y, 0, 0));
     label.setBounds(new Rectangle(figureBounds.x, figureBounds.y, 0, 0));
   }
 }
  /** {@inheritDoc} */
  @Override
  protected void updateTargetRequest() {

    super.updateTargetRequest();
    Dimension delta = getDragMoveDelta();

    if (getSourceEditPart() instanceof GraphicalEditPart) {
      Rectangle childRect = ((GraphicalEditPart) getSourceEditPart()).getFigure().getBounds();
      if (getSourceEditPart().getParent() instanceof GraphicalEditPart) {
        Rectangle parentRect =
            ((GraphicalEditPart) getSourceEditPart().getParent()).getFigure().getBounds();
        IFigure fig = ((GraphicalEditPart) getSourceEditPart().getParent()).getFigure();

        IFigure contentPane =
            ((GraphicalEditPart) getSourceEditPart().getParent()).getContentPane();

        // calculate the virtual position
        Rectangle virtualPosition = childRect.getCopy();
        virtualPosition.x = virtualPosition.x + delta.width;
        virtualPosition.y = virtualPosition.y + delta.height;

        if (virtualPosition.x < 0) {
          delta.width = 0 - childRect.x;
        }
        if (virtualPosition.y < 0) {
          delta.height = 0 - childRect.y;
        }

        if (virtualPosition.x + virtualPosition.width + getBorder() > parentRect.width) {
          delta.width = parentRect.width - childRect.width - childRect.x - getBorder();
        }

        if (virtualPosition.y + virtualPosition.height + 2 * getBorder() > parentRect.height) {
          delta.height = parentRect.height - childRect.height - childRect.y - 2 * getBorder();
        }
        ChangeBoundsRequest request = (ChangeBoundsRequest) getTargetRequest();
        Point moveDelta = new Point(delta.width, delta.height);
        request.setMoveDelta(moveDelta);

        // Very important the child element to block inside the container
        // if not test first the target editPart.
        // let the default algorithm if the target is not its parent.
        setTargetEditPart(getSourceEditPart().getParent());
      }
    }
  }
 /** @see org.eclipse.draw2d.LayoutManager#layout(org.eclipse.draw2d.IFigure) */
 public void layout(IFigure container) {
   List children = container.getChildren();
   Rectangle rulerSize = container.getClientArea();
   for (int i = 0; i < children.size(); i++) {
     IFigure child = (IFigure) children.get(i);
     Dimension childSize = child.getPreferredSize();
     int position = ((Integer) getConstraint(child)).intValue();
     if (((RulerFigure) container).isHorizontal()) {
       childSize.height = rulerSize.height - 1;
       Rectangle.getSINGLETON().setLocation(position - (childSize.width / 2), rulerSize.y);
     } else {
       childSize.width = rulerSize.width - 1;
       Rectangle.getSINGLETON().setLocation(rulerSize.x, position - (childSize.height / 2));
     }
     Rectangle.getSINGLETON().setSize(childSize);
     child.setBounds(Rectangle.getSINGLETON());
   }
 }
Example #17
0
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.draw2d.Figure#getMinimumSize(int, int)
   */
  private Dimension getMinimumSize(
      int wHint, int hHint, boolean isFix, boolean forceWidth, boolean forceHeight) {
    if (DesignChoiceConstants.DISPLAY_NONE.equals(display)) {
      return ZERO_DIMENSION;
    }

    int rx = recommendSize != null ? recommendSize.width : 0;
    int ry = recommendSize != null ? recommendSize.height : 0;

    rx = getRealRecommendSizeX(rx, wHint);

    if (wHint == -1 && hHint == -1) {
      int maxWidth = calcMaxSegment();

      // use recommend size if specified, otherwise use max segment size
      Dimension dim = super.getMinimumSize(rx == 0 ? maxWidth : rx, -1);

      dim.height = Math.max(dim.height, Math.max(getInsets().getHeight(), ry));

      return dim;
    }
    Dimension dim;
    // return the true minimum size with minimum width;
    if (isFix) {
      int tempHint = wHint;
      int maxWidth = calcMaxSegment();
      if (wHint < maxWidth && !forceWidth) {
        tempHint = maxWidth;
      }
      dim = super.getMinimumSize(tempHint <= 0 ? -1 : tempHint, hHint);

      return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
    } else {
      dim = super.getMinimumSize(rx == 0 ? -1 : rx, hHint);
    }

    if (dim.width < wHint) {
      return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
    }

    dim = super.getMinimumSize(wHint, hHint);

    return new Dimension(Math.max(dim.width, rx), Math.max(dim.height, ry));
  }
 /**
  * Returns the size set specified by setPreferredImageSize() or the size specified by the image.
  * In the case of meta-images a preferred size of 32x32 is returned.
  */
 public Dimension getPreferredSize(int wHint, int hHint) {
   if (preferredSize.height == -1 && preferredSize.width == -1) {
     int extent = MapModeUtil.getMapMode(this).DPtoLP(32);
     preferredSize = new Dimension(extent, extent);
     if (getFlag(FLAG_USE_DEFAULT_IMAGESIZE)) {
       if (getRenderedImage() != null) {
         setRenderedImage(getRenderedImage(new Dimension(0, 0)));
         Image swtImage = null;
         if (getRenderedImage() != null) swtImage = getRenderedImage().getSWTImage();
         if (swtImage != null) {
           org.eclipse.swt.graphics.Rectangle imgRect = swtImage.getBounds();
           preferredSize.width = MapModeUtil.getMapMode(this).DPtoLP(imgRect.width);
           preferredSize.height = MapModeUtil.getMapMode(this).DPtoLP(imgRect.height);
         }
       }
     }
   }
   return preferredSize;
 }
  protected void showChangeBoundsFeedback(ChangeBoundsRequest request) {
    IFigure feedback = getDragSourceFeedbackFigure();

    PrecisionRectangle rect = new PrecisionRectangle(getInitialFeedbackBounds().getCopy());
    getHostFigure().translateToAbsolute(rect);
    rect.translate(request.getMoveDelta());
    rect.resize(request.getSizeDelta());

    IFigure f = getHostFigure();
    Dimension min = f.getMinimumSize().getCopy();
    Dimension max = f.getMaximumSize().getCopy();
    IMapMode mmode = MapModeUtil.getMapMode(f);
    min.height = mmode.LPtoDP(min.height);
    min.width = mmode.LPtoDP(min.width);
    max.height = mmode.LPtoDP(max.height);
    max.width = mmode.LPtoDP(max.width);

    if (min.width > rect.width) rect.width = min.width;
    else if (max.width < rect.width) rect.width = max.width;

    if (min.height > rect.height) rect.height = min.height;
    else if (max.height < rect.height) rect.height = max.height;

    feedback.translateToRelative(rect);
    feedback.setBounds(rect);
  }
Example #20
0
  private double getFitXZoomLevel(int which) {
    IFigure fig = getScalableFigure();

    Dimension available = getViewport().getClientArea().getSize();
    Dimension desired;
    if (fig instanceof FreeformFigure) {
      desired = ((FreeformFigure) fig).getFreeformExtent().getCopy().union(0, 0).getSize();
    } else {
      desired = fig.getPreferredSize().getCopy();
    }

    desired.width -= fig.getInsets().getWidth();
    desired.height -= fig.getInsets().getHeight();

    while (fig != getViewport()) {
      available.width -= fig.getInsets().getWidth();
      available.height -= fig.getInsets().getHeight();
      fig = fig.getParent();
    }

    double scaleX = Math.min(available.width * zoom / desired.width, getMaxZoom());
    double scaleY = Math.min(available.height * zoom / desired.height, getMaxZoom());
    if (which == 0) {
      return scaleX;
    }
    if (which == 1) {
      return scaleY;
    }
    return Math.min(scaleX, scaleY);
  }
  /**
   * Return the default draw2D dimension according to the specified DNode.
   *
   * @return the default draw2D dimension according to the specified DNode.
   */
  public Dimension getDefaultDimension() {
    final Dimension result = DEFAULT_NODE_DIMENSION.getCopy();

    if (node.getStyle() instanceof WorkspaceImage) {
      final WorkspaceImage workspaceImage = (WorkspaceImage) node.getStyle();
      final String path = workspaceImage.getWorkspacePath();
      final Image image;
      image = WorkspaceImageFigure.getImageInstanceFromPath(path);
      if (image != null) {
        // Use default image size
        if (node.getWidth() == null || Integer.valueOf(node.getWidth()) == -1) {
          result.width = image.getBounds().width;
          result.height = image.getBounds().height;
        } else {
          // width is already defined, adapt height thanks to
          // image ratio
          final double ratio = (double) image.getBounds().width / image.getBounds().height;
          double newHeight = node.getWidth().intValue() / ratio;

          // Adapt to draw2D
          result.width = node.getWidth().intValue() * LayoutUtils.SCALE;
          result.height = (int) (newHeight * LayoutUtils.SCALE);
        }
      }
    } else {
      if (node.getWidth() != null) {
        result.width = node.getWidth().intValue();
      }
      if (node.getHeight() != null) {
        result.height = node.getHeight().intValue();
      }

      // Adapt to draw2D
      result.width = result.width * LayoutUtils.SCALE;
      result.height = result.height * LayoutUtils.SCALE;
    }

    return result;
  }
Example #22
0
  /**
   * Fix for #422827
   *
   * <p>We would better override the Dimension.max() logic from the super class but it itself calls
   * super.super so we can't easily do that.
   *
   * <p>So we have to explicitly call {@link #getMinimumSizeForHint(GraphicalEditPart, Dimension)}
   * and ensure that Dimension.max() logic in super-class does not affect results by returning
   * something small from {@link #getMinimumSizeFor(GraphicalEditPart)}
   */
  @Override
  protected Object getConstraintFor(Request request, GraphicalEditPart child, Rectangle rect) {
    if (isReflowable(child) && request instanceof ChangeBoundsRequest) {
      ChangeBoundsRequest reqImpl = (ChangeBoundsRequest) request;

      Dimension sizeDelta = reqImpl.getSizeDelta();
      if (sizeDelta.width != 0 || sizeDelta.height != 0) {
        Dimension correctedMinSize = getMinimumSizeForHint(child, rect.getSize());
        rect.setSize(Dimension.max(correctedMinSize, rect.getSize()));
      }
    }
    return super.getConstraintFor(request, child, rect);
  }
Example #23
0
    public void layout(IFigure container) {
      Rectangle area = container.getClientArea();
      area.height -= 1;
      Dimension scaleSize = new Dimension(0, 0);
      Dimension markerSize = new Dimension(0, 0);

      if (scale != null) {
        if (scale.isVisible()) {
          scaleSize = scale.getPreferredSize(-1, area.height);
          scale.setBounds(new Rectangle(area.x, area.y, scaleSize.width, scaleSize.height));
        } else {
          scaleSize = scale.getPreferredSize(-1, area.height + 2 * scale.getMargin());
          scale.setBounds(
              new Rectangle(area.x, area.y - scale.getMargin(), scaleSize.width, scaleSize.height));
          scaleSize.height = 0;
          scaleSize.width = 0;
        }
      }

      if (marker != null && marker.isVisible()) {
        markerSize = marker.getPreferredSize();
        marker.setBounds(
            new Rectangle(
                area.x + area.width - markerSize.width,
                marker.getScale().getBounds().y,
                markerSize.width,
                markerSize.height));
      }

      if (tank != null) {
        tank.setBounds(
            new Rectangle(
                area.x + scaleSize.width,
                scale.getValuePosition(scale.getRange().getUpper(), false),
                area.width - scaleSize.width - markerSize.width,
                scale.getTickLength() + tank.getLineWidth()));
      }
    }
 /**
  * Shows or updates feedback for a change bounds request. The request is updated by the way so
  * that the shape stays a square.
  *
  * @param request the request
  */
 @Override
 protected void showChangeBoundsFeedback(ChangeBoundsRequest request) {
   // adapt the request for a square resize
   Point move = request.getMoveDelta();
   Dimension delta = request.getSizeDelta();
   int dH = delta.height;
   int dW = delta.width;
   int signum = 0;
   if (dH <= 0 && dW <= 0) {
     signum = -1;
   } else {
     signum = 1;
   }
   int positiveResize = Math.max(dH, dW);
   if (positiveResize <= 0) {
     if (dH == 0) {
       positiveResize = -dW;
     } else if (dW == 0) {
       positiveResize = -dH;
     } else {
       positiveResize = Math.min(-dH, -dW);
     }
   }
   int newDH = signum * positiveResize;
   int newDW = newDH;
   int dir = request.getResizeDirection();
   // adjust new position if impacted by resizing
   if ((dir & PositionConstants.NORTH) > 0) {
     move.y += dH - newDH;
   }
   if ((dir & PositionConstants.WEST) > 0) {
     move.x += dW - newDW;
   }
   request.setMoveDelta(move);
   delta.height = newDH;
   delta.width = newDW;
   super.showChangeBoundsFeedback(request);
 }
  /** creates the command to move the shapes left or right. */
  protected Command getCommand() {
    if (_container == null) {
      return null;
    }
    CompoundCommand command = new CompoundCommand("Multiple Shape Move");
    TransactionalEditingDomain editingDomain = _container.getEditingDomain();

    Point moveDelta = ((ChangeBoundsRequest) getSourceRequest()).getMoveDelta().getCopy();
    Dimension spSizeDelta = new Dimension(moveDelta.x, moveDelta.y);
    ZoomManager zoomManager =
        ((DiagramRootEditPart) getCurrentViewer().getRootEditPart()).getZoomManager();
    spSizeDelta.scale(1 / zoomManager.getZoom());
    command.add(_container.getCommand(getSourceRequest()));

    for (IGraphicalEditPart sp : _subProcesses) {
      Dimension spDim = sp.getFigure().getBounds().getSize().getCopy();
      spDim.expand(spSizeDelta);
      SetBoundsCommand setBounds =
          new SetBoundsCommand(editingDomain, "MultipleShape Move", sp, spDim);
      command.add(new ICommandProxy(setBounds));
    }
    return command;
  }
  @Override
  protected void updateSourceRequest() {
    ChangeBoundsRequest request = (ChangeBoundsRequest) getSourceRequest();
    Dimension d = getDragMoveDelta();

    Point location = new Point(getLocation());
    Point moveDelta = new Point(0, 0);
    Dimension resizeDelta = new Dimension(0, 0);

    request.setConstrainedResize(false);

    request.setCenteredResize(getCurrentInput().isModKeyDown(SWT.MOD1));

    if ((getResizeDirection() & PositionConstants.NORTH) != 0) {
      moveDelta.y += d.height;
      resizeDelta.height -= d.height;
    }
    if ((getResizeDirection() & PositionConstants.SOUTH) != 0) {
      resizeDelta.height += d.height;
    }
    if ((getResizeDirection() & PositionConstants.WEST) != 0) {
      moveDelta.x += d.width;
      resizeDelta.width -= d.width;
    }
    if ((getResizeDirection() & PositionConstants.EAST) != 0) {
      resizeDelta.width += d.width;
    }

    request.setMoveDelta(moveDelta);
    request.setSizeDelta(resizeDelta);
    request.setLocation(location);
    request.setEditParts(getOperationSet());

    request.getExtendedData().clear();

    // TODO: snapping
  }
    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.draw2d.ToolbarLayout#layout(org.eclipse.draw2d.IFigure)
     */
    @Override
    public void layout(IFigure parent) {
      final Rectangle clientArea = parent.getClientArea();
      int x = clientArea.x;
      int y = clientArea.y;
      final List children = parent.getChildren();
      int numChildren = children.size();

      int maxHeight = 0;
      for (int i = 0; i < numChildren; i++) {
        IFigure child = (IFigure) children.get(i);
        Dimension prefSize = getChildPreferredSize(child, clientArea.width, -1);
        maxHeight = Math.max(maxHeight, prefSize.height);
      }
      maxHeight = Math.max(maxHeight, clientArea.height);

      if (numChildren == 1) {
        IFigure child = (IFigure) children.get(0);
        Dimension prefSize = child.getPreferredSize(clientArea.width, -1);
        prefSize.width = Math.max(prefSize.width, clientArea.width);
        Rectangle newBounds = new Rectangle(x, y, prefSize.width, maxHeight);
        child.setBounds(newBounds);
      } else if (numChildren == 2) {
        int initExpressionWidth =
            (xmlTreePart.getViewer().getControl().getSize().x / 3 - 80 - 10) / 2;
        IFigure child = (IFigure) children.get(0);
        Rectangle newBounds = new Rectangle(x, y, initExpressionWidth, maxHeight);
        child.setBounds(newBounds);

        child = (IFigure) children.get(1);
        Dimension prefSize = child.getPreferredSize(clientArea.width, -1);
        prefSize.width = Math.max(prefSize.width, clientArea.width - initExpressionWidth);
        newBounds = new Rectangle(x + initExpressionWidth, y, prefSize.width, maxHeight);
        child.setBounds(newBounds);
      }
    }
Example #28
0
  /* (non-Javadoc)
   * @see streamit.eclipse.debugger.graph.IStream#setHorizontalLocation(org.eclipse.draw2d.geometry.Point, int, int)
   */
  public int setHorizontalLocation(
      int currentHeight,
      boolean stretchTopChannel,
      boolean stretchBottomChannel,
      int stretchHeight,
      int currentWidth) {
    Dimension topSize = fTopChannel.getSize();
    Dimension pipelineSize = getSize();
    Dimension bottomSize = fBottomChannel.getSize();

    // expand channels
    if (stretchTopChannel) {
      topSize.height = stretchHeight - pipelineSize.height - bottomSize.height;
      fTopChannel.setSize(topSize);
    }
    if (stretchBottomChannel) {
      bottomSize.height = stretchHeight - pipelineSize.height - topSize.height;
      fBottomChannel.setSize(bottomSize);
    }

    setVerticalLocation(new Point(currentWidth + pipelineSize.width / 2, currentHeight), 0);
    currentWidth = currentWidth + pipelineSize.width + IStreamItGraphConstants.MARGIN / 2;
    return currentWidth;
  }
    protected LayoutData getLayoutData() {
      Dimension initSize = initFigure.getPreferredSize();
      initSize.width = Math.min(initSize.width, MAX_BOX_WIDTH);
      Dimension methodoSize = methodoFigure.getPreferredSize();
      methodoSize.width = Math.min(methodoSize.width, MAX_BOX_WIDTH);
      Dimension processSize = processFigure.getPreferredSize();
      processSize.width = Math.min(processSize.width, MAX_BOX_WIDTH);
      Dimension endSize = endFigure.getPreferredSize();
      endSize.width = Math.min(endSize.width, MAX_BOX_WIDTH);

      LayoutData data = new LayoutData();

      // boxes
      int initY = BOX_SPACING;
      int methodoY = initY + initSize.height + BOX_SPACING;
      int processY = methodoY + methodoSize.height + BOX_SPACING;
      int endY = processY + processSize.height + BOX_SPACING;
      int gap = processSize.width - methodoSize.width;
      data.initBox = new Rectangle(processSize.width / 2, initY, initSize.width, initSize.height);
      data.methodoBox = new Rectangle(gap / 2, methodoY, methodoSize.width, methodoSize.height);
      data.processBox = new Rectangle(0, processY, processSize.width, processSize.height);
      data.endBox = new Rectangle(processSize.width / 2, endY, endSize.width, endSize.height);
      // points
      int pointH = data.initBox.x + data.initBox.width / 2;
      data.init2methodoPoints = new PointList(2);
      data.init2methodoPoints.addPoint(pointH, data.initBox.y + data.initBox.height);
      data.init2methodoPoints.addPoint(pointH, data.methodoBox.y);
      data.methodo2processPoints = new PointList(2);
      data.methodo2processPoints.addPoint(pointH, data.methodoBox.y + data.methodoBox.height);
      data.methodo2processPoints.addPoint(pointH, data.processBox.y);
      data.process2endPoints = new PointList(2);
      data.process2endPoints.addPoint(pointH, data.processBox.y + data.processBox.height);
      data.process2endPoints.addPoint(pointH, data.endBox.y);
      // logo and status
      Dimension logoSize = logoFigure.getPreferredSize();
      data.logoBox = new Rectangle(0, 0, logoSize.width, logoSize.height);
      Dimension statusSize = statusFigure.getPreferredSize();
      int statusX =
          Math.max(
              data.methodoBox.x + data.methodoBox.width - statusSize.width,
              data.processBox.x + data.processBox.width + BOX_SPACING);
      data.statusBox = new Rectangle(statusX, 0, statusSize.width, statusSize.height);
      return data;
    }
  protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
    Dimension extent = null;

    for (Iterator i = container.getChildren().iterator(); i.hasNext(); ) {
      IFigure child = (IFigure) i.next();

      Dimension childSize = null;
      if (!(child instanceof FreeformFigure)) {
        childSize = child.getPreferredSize();
      }
      if (null != childSize) {
        if (null == extent) {
          extent = childSize.getCopy();
        } else {
          extent.width += childSize.width + getMinorSpacing();
          extent.height = Math.max(extent.height, childSize.height);
        }
      }
    }

    if (null != extent) {
      extent.union(container.getMinimumSize());
    } else {
      extent = container.getMinimumSize();
    }

    Insets insets = container.getInsets();
    if (null == extent) {
      extent = new Dimension(insets.getWidth(), insets.getHeight());
    } else {
      // compartment.translateToParent(extent);
      extent.expand(insets.getWidth(), insets.getHeight());
    }

    return extent;
  }