Exemplo n.º 1
0
 public void overlay(Graphics g) {
   if (!firstOverlayInvocation) {
     if (cachedBounds != null) {
       g.setColor(Color.black);
       Rectangle2D tmp = graph.toScreen((Rectangle2D) cachedBounds.clone());
       g.drawRect(
           (int) tmp.getX(),
           (int) tmp.getY(),
           (int) tmp.getWidth() - 2,
           (int) tmp.getHeight() - 2);
     } else if (!initialBounds.equals(vertex.getBounds())) {
       Graphics2D g2 = (Graphics2D) g;
       AffineTransform oldTransform = g2.getTransform();
       g2.scale(graph.getScale(), graph.getScale());
       graph.getUI().paintCell(g, vertex, vertex.getBounds(), true);
       if (contextViews != null) {
         for (int i = 0; i < contextViews.length; i++) {
           graph.getUI().paintCell(g, contextViews[i], contextViews[i].getBounds(), true);
         }
       }
       if (!graph.isPortsScaled()) g2.setTransform(oldTransform);
       if (portViews != null && graph.isPortsVisible()) graph.getUI().paintPorts(g, portViews);
       g2.setTransform(oldTransform);
     }
   }
   firstOverlayInvocation = false;
 }
Exemplo n.º 2
0
 public SizeHandle(VertexView vertexview, GraphContext ctx) {
   graph = ctx.getGraph();
   vertex = vertexview;
   editing = graph.getEditingCell() == vertex.getCell();
   int sizeableAxis = GraphConstants.getSizeableAxis(vertex.getAllAttributes());
   if (sizeableAxis == GraphConstants.X_AXIS) cursors = xCursors;
   else if (sizeableAxis == GraphConstants.Y_AXIS) cursors = yCursors;
   else cursors = defaultCursors;
   // PortView Preview
   portViews = ctx.createTemporaryPortViews();
   initialBounds = (Rectangle2D) vertex.getBounds().clone();
   context = ctx;
   for (int i = 0; i < r.length; i++) r[i] = new Rectangle2D.Double();
   invalidate();
 }
Exemplo n.º 3
0
 protected void invalidate() {
   // Retrieve current bounds and set local vars
   Rectangle2D tmp = graph.getCellBounds(vertex.getCell());
   if (tmp != null) {
     tmp = (Rectangle2D) tmp.clone();
     graph.toScreen(tmp);
     int handlesize = graph.getHandleSize();
     int s2 = 2 * handlesize;
     double left = tmp.getX() - handlesize;
     double top = tmp.getY() - handlesize;
     double w2 = tmp.getX() + (tmp.getWidth() / 2) - handlesize;
     double h2 = tmp.getY() + (tmp.getHeight() / 2) - handlesize;
     double right = tmp.getX() + tmp.getWidth() - handlesize;
     double bottom = tmp.getY() + tmp.getHeight() - handlesize;
     // Update control point positions
     r[0].setFrame(left, top, s2, s2);
     r[1].setFrame(w2, top, s2, s2);
     r[2].setFrame(right, top, s2, s2);
     r[3].setFrame(left, h2, s2, s2);
     r[4].setFrame(right, h2, s2, s2);
     r[5].setFrame(left, bottom, s2, s2);
     r[6].setFrame(w2, bottom, s2, s2);
     r[7].setFrame(right, bottom, s2, s2);
   }
 }
  /**
   * Creates a <code>VertexView</code> for the given cell, which is expected to be for a vertex in
   * the graph. If the cell is a type we are expecting and it holds a user object that we know how
   * to handle, we determine if a custom renderer has been registered with us for that cell type. If
   * no custom view is found, we fall back on the superclass version of this method.
   *
   * @return An instance of <code>VertexView</code> (or a subclass thereof) for the given cell.
   * @see org.jgraph.graph.VertexView
   * @see org.jgraph.graph.DefaultCellViewFactory#createVertexView(Object)
   */
  protected VertexView createVertexView(Object cell) {
    VertexView view = null;

    // Right now, we expect that vertex cells are instances of
    // DefaultGraphCell (or some subclass thereof) and that they contain a
    // user object of type ConfigElementHolder (or some subclass thereof).
    // This is not inifinitely flexible, but considering the purpose of the
    // devicegraph package, it is a reasonable assumption.
    if (cell instanceof DefaultGraphCell
        && ((DefaultGraphCell) cell).getUserObject() instanceof ConfigElementHolder) {
      // Extract the user object which we know to be an instance of
      // ConfigElementHolder.
      ConfigElementHolder holder = (ConfigElementHolder) ((DefaultGraphCell) cell).getUserObject();

      // Look up the config definition for the held ConfigElement and check
      // to see if a VertexView was registered with us for that definition.
      ConfigElement elt = holder.getElement();
      ConfigDefinition def = elt.getDefinition();
      Class view_class = (Class) mCreatorMap.get(def);

      // If a VertexView for the cell's config definition was registered
      // with us, try to instantiate and use that view for the given
      // cell.
      if (null != view_class) {
        try {
          view = (VertexView) view_class.newInstance();
          view.setCell(cell);
        }
        // If we catch an exception trying to instantiate the custom
        // VertexView type, ignore it and leave view set to null.
        catch (Exception e) {
          e.printStackTrace();
        }
      }
    }

    // If we have no custom view at this point, use the JGraph version of
    // createVertexView() to get a default view for the given cell.
    if (null == view) {
      view = super.createVertexView(cell);
    }

    return view;
  }
Exemplo n.º 5
0
 // Dispatch the edit event
 public void mouseReleased(MouseEvent e) {
   if (index != -1) {
     cachedBounds = computeBounds(e);
     vertex.setBounds(cachedBounds);
     CellView[] views = AbstractCellView.getDescendantViews(new CellView[] {vertex});
     Map attributes = GraphConstants.createAttributes(views, null);
     graph.getGraphLayoutCache().edit(attributes, null, null, null);
   }
   e.consume();
   cachedBounds = null;
   initialBounds = null;
   firstDrag = true;
 }
Exemplo n.º 6
0
 /** Process mouse pressed event. */
 public void mousePressed(MouseEvent event) {
   if (!graph.isSizeable()) return;
   for (int i = 0; i < r.length; i++) {
     if (r[i].contains(event.getPoint()) && cursors[i] != 0) {
       Set set = new HashSet();
       set.add(vertex.getCell());
       contextViews = context.createTemporaryContextViews(set);
       Object[] all = AbstractCellView.getDescendantViews(new CellView[] {vertex});
       if (all.length >= org.jgraph.plaf.basic.BasicGraphUI.MAXHANDLES)
         cachedBounds = (Rectangle2D) initialBounds.clone();
       event.consume();
       index = i;
       return;
     }
   }
 }
Exemplo n.º 7
0
 protected Rectangle2D computeBounds(MouseEvent event) {
   double left = initialBounds.getX();
   double right = initialBounds.getX() + initialBounds.getWidth() - 1;
   double top = initialBounds.getY();
   double bottom = initialBounds.getY() + initialBounds.getHeight() - 1;
   Point2D p = graph.fromScreen(graph.snap((Point2D) event.getPoint().clone()));
   // Not into negative coordinates
   p.setLocation(Math.max(0, p.getX()), Math.max(0, p.getY()));
   // Bottom row
   if (index > 4) bottom = p.getY();
   // Top row
   else if (index < 3) top = p.getY();
   // Left col
   if (index == 0 || index == 3 || index == 5) left = p.getX();
   // Right col
   else if (index == 2 || index == 4 || index == 7) right = p.getX();
   double width = right - left;
   double height = bottom - top;
   if (isConstrainedSizeEvent(event)
       || GraphConstants.isConstrained(vertex.getAllAttributes())) {
     if (index == 3 || index == 4 || index == 5) height = width;
     else if (index == 1 || index == 6 || index == 2 || index == 7) width = height;
     else {
       height = width;
       top = bottom - height;
     }
   }
   if (width < 0) { // Flip over left side
     left += width;
     width = Math.abs(width);
   }
   if (height < 0) { // Flip over top side
     top += height;
     height = Math.abs(height);
   }
   return new Rectangle2D.Double(left, top, width + 1, height + 1);
 }
Exemplo n.º 8
0
 /** Process mouse dragged event. */
 public void mouseDragged(MouseEvent event) {
   if (firstDrag && graph.isDoubleBuffered() && cachedBounds == null) {
     initOffscreen();
     firstDrag = false;
   }
   Rectangle2D dirty = null;
   Graphics g = (offgraphics != null) ? offgraphics : graph.getGraphics();
   if (index == -1) return;
   if (offgraphics != null || !graph.isXorEnabled()) {
     dirty = graph.toScreen((Rectangle2D) vertex.getBounds().clone());
     Rectangle2D t = graph.toScreen(AbstractCellView.getBounds(contextViews));
     if (t != null) dirty.add(t);
   }
   Rectangle2D newBounds = computeBounds(event);
   if (graph.isXorEnabled()) {
     g.setColor(graph.getForeground());
     g.setXORMode(graph.getBackground().darker());
     overlay(g);
   } else {
     firstOverlayInvocation = false;
   }
   if (cachedBounds != null) cachedBounds = newBounds;
   else {
     // Reset old Bounds
     CellView[] all = AbstractCellView.getDescendantViews(new CellView[] {vertex});
     for (int i = 0; i < all.length; i++) {
       CellView orig = graph.getGraphLayoutCache().getMapping(all[i].getCell(), false);
       if (orig != null) {
         AttributeMap origAttr = (AttributeMap) orig.getAllAttributes().clone();
         all[i].changeAttributes(graph.getGraphLayoutCache(), origAttr);
         all[i].refresh(graph.getGraphLayoutCache(), context, false);
       }
     }
     vertex.setBounds(newBounds);
     if (vertex != null) graph.getGraphLayoutCache().update(vertex);
     if (contextViews != null) graph.getGraphLayoutCache().update(contextViews);
   }
   if (graph.isXorEnabled()) {
     overlay(g);
   }
   if (offgraphics != null || !graph.isXorEnabled()) {
     dirty.add(graph.toScreen((Rectangle2D) vertex.getBounds().clone()));
     Rectangle2D t = graph.toScreen(AbstractCellView.getBounds(contextViews));
     if (t != null) dirty.add(t);
     int border = PortView.SIZE + 10;
     if (graph.isPortsScaled()) border = (int) (graph.getScale() * border);
     int border2 = border / 2;
     dirty.setFrame(
         dirty.getX() - border2,
         dirty.getY() - border2,
         dirty.getWidth() + border,
         dirty.getHeight() + border);
     double sx1 = Math.max(0, dirty.getX());
     double sy1 = Math.max(0, dirty.getY());
     double sx2 = sx1 + dirty.getWidth();
     double sy2 = sy1 + dirty.getHeight();
     if (offgraphics != null) {
       graph.drawImage(
           (int) sx1, (int) sy1, (int) sx2, (int) sy2, (int) sx1, (int) sy1, (int) sx2,
           (int) sy2);
     } else {
       graph.repaint(
           (int) dirty.getX(),
           (int) dirty.getY(),
           (int) dirty.getWidth(),
           (int) dirty.getHeight());
     }
   }
 }