@Override public void paintPreview(JEnvironment env, JRequest req, Graphics2D g) { g.setColor(getPreviewColor()); AffineTransform af = new AffineTransform(totalTransform); if (addingTransform != null) af.preConcatenate(addingTransform); Shape s = getShape(); if (addingTransform != null) s = addingTransform.createTransformedShape(s); s = env.getToScreenTransform().createTransformedShape(s); g.draw(s); PathIterator path = s.getPathIterator(null); double radius = JEnvironment.PATH_SELECTOR_SIZE / 2; Rectangle2D.Double sr = new Rectangle2D.Double(0, 0, radius * 2, radius * 2); double[] coords = new double[6]; while (!path.isDone()) { int type = path.currentSegment(coords); if (type == path.SEG_MOVETO || type == path.SEG_LINETO) { sr.x = coords[0] - radius; sr.y = coords[1] - radius; g.fill(sr); } else if (type == path.SEG_CUBICTO) { sr.x = coords[4] - radius; sr.y = coords[5] - radius; g.fill(sr); } else if (type == path.SEG_QUADTO) { sr.x = coords[2] - radius; sr.y = coords[3] - radius; g.fill(sr); } path.next(); } }
@Override public int hitByPoint(JEnvironment env, JRequest req, Point2D point) { if (isLocked() || !isVisible()) return JRequest.HIT_NON; Shape s = getShape(); if (s.contains(point)) { req.hitObjects.add(this); return (req.hitResult = JRequest.HIT_OBJECT); } double radius = JEnvironment.PATH_SELECTOR_SIZE / 2 / env.getToScreenRatio(); Rectangle2D.Double sr = new Rectangle2D.Double(0, 0, radius * 2, radius * 2); PathIterator path = s.getPathIterator(null); double[] coords = new double[6]; while (!path.isDone()) { int type = path.currentSegment(coords); if (type == path.SEG_LINETO || type == path.SEG_MOVETO) { sr.x = coords[0] - radius; sr.y = coords[1] - radius; if (sr.contains(point)) { req.hitObjects.add(this); return (req.hitResult = JRequest.HIT_OBJECT); } } path.next(); } return JRequest.HIT_NON; }
public boolean checkWorldCollision(Shape s) { if (s == null) return false; Point area = Globals.findTile(s.getBounds().x, s.getBounds().y); int areaX = area.x; int areaY = area.y; areaX--; areaY--; if (areaX < 0) areaX = 0; if (areaY < 0) areaY = 0; int areaXEnd = areaX + 21; int areaYEnd = areaY + 21; if (areaXEnd > xLength) areaXEnd = xLength; if (areaYEnd > yHeight) areaYEnd = yHeight; for (int x = areaX; x < areaXEnd; x++) { for (int y = areaY; y < areaYEnd; y++) { if (walls[x][y] == null) continue; if (s.intersects(walls[x][y].getPhysicsShape())) { // walls[x][y].printName(); return true; } } } return false; }
/** * Get the bounding box of the shape when stroked. This method takes account of the thickness of * the stroke. */ public Rectangle2D getBounds() { // FIXME: these bounds REALLY need to be cached. But it's // painful because of the public members. if (stroke == null) { return shape.getBounds2D(); } else if (stroke instanceof BasicStroke) { // For some reason (antialiasing?) the bounds returned by // BasicStroke is off by one. This code works around it. // if all we want is the bounds, then we don't need to actually // stroke the shape. We've had reports that this is no longer // necessary with JDK1.3. Rectangle2D rect = shape.getBounds2D(); int width = (int) ((BasicStroke) stroke).getLineWidth() + 2; return new Rectangle2D.Double( rect.getX() - width, rect.getY() - width, rect.getWidth() + width + width, rect.getHeight() + width + width); } else { // For some reason (antialiasing?) the bounds returned by // BasicStroke is off by one. This code works around it. // We've had reports that this is no longer // necessary with JDK1.3. Rectangle2D rect = stroke.createStrokedShape(shape).getBounds2D(); return new Rectangle2D.Double( rect.getX() - 1, rect.getY() - 1, rect.getWidth() + 2, rect.getHeight() + 2); } }
@Override public boolean contains(Point2D position) { double flatness = 0.01; boolean intersect = false; PathIterator pit = path.getPathIterator(null, flatness); double[] coords = new double[6]; double lastX = 0, lastY = 0; while (!intersect && !pit.isDone()) { int type = pit.currentSegment(coords); switch (type) { case PathIterator.SEG_MOVETO: lastX = coords[0]; lastY = coords[1]; break; case PathIterator.SEG_LINETO: BasicStroke stroke = new BasicStroke(10.0f); Line2D.Double line = new Line2D.Double(lastX, lastY, coords[0], coords[1]); Shape shape = stroke.createStrokedShape(line); if (shape.contains(position)) { intersect = true; } lastX = coords[0]; lastY = coords[1]; } pit.next(); } return intersect; }
@Override public Shape getPointShape(PointData data) { Row row = data.row; int colLabel = getColumn(); if (colLabel >= row.size()) { return null; } Comparable<?> labelValue = row.get(colLabel); if (labelValue == null) { return null; } Format format = getFormat(); Font font = getFont(); String text = format.format(labelValue); double alignment = getAlignmentX(); Shape shape = GraphicsUtils.getOutline(text, font, 0f, alignment); double alignX = getAlignmentX(); double alignY = getAlignmentY(); Rectangle2D bounds = shape.getBounds2D(); AffineTransform tx = AffineTransform.getTranslateInstance( -alignX * bounds.getWidth(), alignY * bounds.getHeight()); shape = tx.createTransformedShape(shape); return shape; }
private double calculateWidth(V v) { double childrenWidthSum = 0; int childrenNum = graph.getSuccessors(v).size(); if (childrenNum != 0) { boolean first = true; for (V element : graph.getSuccessors(v)) { if (!first) { childrenWidthSum += MARGIN; } childrenWidthSum += calculateWidth(element); first = false; } } double width = DEFAULT_WIDTH; if (this.shapeTransformer != null) { Shape shape = this.shapeTransformer.transform(v); if (shape != null) { width = shape.getBounds().getWidth(); } } double size = Math.max(width, childrenWidthSum); size = Math.max(0, size); return size; }
/** * Build a shape for the entire subtree by joining together the shapes for each of its edges. * Vertices included since needed for FullTextPanel. */ public Shape constructInternalShape(DiagramBase diagram, boolean includeVertices) { GeneralPath shape = new GeneralPath(); Enumeration edges = m_edgeList.elements(); while (edges.hasMoreElements()) { TreeEdge edge = (TreeEdge) edges.nextElement(); Shape edgeShape = edge.getSchemeShape(diagram); PathIterator path = edgeShape.getPathIterator(null); shape.append(path, false); if (includeVertices) { Shape vertexShape; if (!edge.getSourceVertex().isVirtual()) { vertexShape = edge.getSourceVertex().getShape(diagram); path = vertexShape.getPathIterator(null); shape.append(path, false); } if (!edge.getDestVertex().isVirtual()) { vertexShape = edge.getDestVertex().getShape(diagram); path = vertexShape.getPathIterator(null); shape.append(path, false); } } } BasicStroke stroke = new BasicStroke( diagram.getSubtreeLineWidth() - DiagramBase.EDGE_OUTLINE_WIDTH + 1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER); internalShapeTable.put(diagram, stroke.createStrokedShape(shape)); return (Shape) internalShapeTable.get(diagram); }
/** @return the shapes contained in this group container */ public Shape[] getShapes() { // Out escher container record should contain serveral // SpContainers, the first of which is the group shape itself List lst = _escherContainer.getChildRecords(); ArrayList shapeList = new ArrayList(); // Don't include the first SpContainer, it is always NotPrimitive for (int i = 1; i < lst.size(); i++) { EscherRecord r = (EscherRecord) lst.get(i); if (r instanceof EscherContainerRecord) { // Create the Shape for it EscherContainerRecord container = (EscherContainerRecord) r; Shape shape = ShapeFactory.createShape(container, this); shape.setSheet(getSheet()); shapeList.add(shape); } else { // Should we do anything special with these non // Container records? logger.log( POILogger.ERROR, "Shape contained non container escher record, was " + r.getClass().getName()); } } // Put the shapes into an array, and return Shape[] shapes = (Shape[]) shapeList.toArray(new Shape[shapeList.size()]); return shapes; }
/** RedŽfinition de la mŽthode paintComponent() de JComponent */ public void paintComponent(Graphics g) { super.paintComponent(g); for (Shape s : shapes) { s.paint(g); } notifyObservers(); }
@Override public boolean contains(int x, int y) { if (shape == null || !shape.getBounds().equals(getBounds())) { shape = new Area(makeStarDesign(5, new Point(50, 50), 50, 30)); } return shape.contains(x, y); }
/** * This implementation calls <code>super.hitTest</code> and returns the result if non-null (this * should be a HitInfo.Point), then returns a HitInfo.Interior if the mouse-click occured inside * the text bound (as defined by text layout) * * @return a HitInfo corresponding to the given mouse-event */ public HitInfo hitTest(PEMouseEvent e) { // from Bitmap: if (image != null) { if (getBounds().contains(e.getPicPoint())) { return new HitInfo.Interior((PicText) element, e); } return null; } // from TextLayout: if (!getBounds().contains(e.getPicPoint())) return null; PicText te = (PicText) element; // recompute textlayout b-box, but store it in a temporary field ! Rectangle2D tb = textLayout.getBounds(); Shape text_bounds = text2ModelTr.createTransformedShape(tb); if (text_bounds.contains(e.getPicPoint())) { // [SR:pending] for the hitInfo to be reliable, getPicPoint() should first be transformed by // inverse text2ModelTr ! (especially when rotationAngle != 0) TextHitInfo thi = textLayout.hitTestChar( (float) (e.getPicPoint().x - strx), (float) (e.getPicPoint().y - stry)); // guaranteed to return a non-null thi return new HitInfo.Text((PicText) element, thi, e); } // test hit on textlayout's bounding rectangle : // else if (bounds.contains(e.getPicPoint())) return new HitInfo.Interior(element,e); return null; }
/** * Draw some graphics into an Graphics2D object. * * @param image the image to draw into * @throws NoninvertibleTransformException in transform errors. */ private void draw(Graphics2D gr) throws NoninvertibleTransformException { gr.setPaint(Color.WHITE); gr.fill(new Rectangle(0, 0, tileWidth, tileHeight)); // AffineTransform[[0.318755336305853, 0.0, 420.03106689453125], // [0.0, 0.318755336305853, 245.5029296875]] AffineTransform transform = new AffineTransform( 0.318755336305853, 0.0, 0.0, 0.318755336305853, 420.03106689453125, 245.5029296875); gr.setTransform(transform); Shape s = new Rectangle(0, 0, 96, 83); // create an enbedded graphics Graphics2D grr = (Graphics2D) gr.create(); // AffineTransform[[1.0, 0.0, -343.9285583496093], // [0.0, 1.0, -502.5158386230469]] grr.clip(s.getBounds()); transform = new AffineTransform(1.0, 0.0, 0.0, 1.0, -343.9285583496093, -502.5158386230469); grr.transform(transform); AffineTransform t = transform.createInverse(); s = t.createTransformedShape(s); assertTrue(s.getBounds().intersects(grr.getClip().getBounds2D())); grr.setPaint(Color.BLUE); grr.draw(s); grr.dispose(); gr.dispose(); }
private static LegendTitle createLegend(String legend1Text, String legend2Text) { final LegendItemCollection legendItems = new LegendItemCollection(); FontRenderContext frc = new FontRenderContext(null, true, true); Font legenfont = new Font(Font.SANS_SERIF, Font.BOLD, 12); GlyphVector gv = legenfont.createGlyphVector(frc, new char[] {'X', 'X'}); Shape shape = gv.getVisualBounds(); Rectangle2D bounds = shape.getBounds2D(); HatchedRectangle hatchShape = new HatchedRectangle( bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight(), 5, 5); { LegendItem li = new LegendItem(legend1Text, null, null, null, hatchShape, Color.black); li.setLabelFont(legenfont); legendItems.add(li); } { LegendItem li = new LegendItem(legend2Text, null, null, null, shape, Color.black); li.setLabelFont(legenfont); legendItems.add(li); } LegendTitle legend = new LegendTitle( new LegendItemSource() { @Override public LegendItemCollection getLegendItems() { return legendItems; } }); legend.setPosition(RectangleEdge.BOTTOM); legend.setMargin(new RectangleInsets(0, 30, 0, 0)); legend.setPadding(RectangleInsets.ZERO_INSETS); legend.setLegendItemGraphicPadding(new RectangleInsets(0, 20, 0, 0)); return legend; }
public void paint(Graphics g) { Graphics2D g2d = (Graphics2D) g; g2d.setColor(Color.white); g2d.fillRect(0, 0, 500, 500); g2d.setColor(Color.red); g2d.drawString(Double.toString(fpsCounter.fps()), 50, 50); // g2d.fillRect(0, 0, 50, 50); Rectangle2D.Double testRect = new Rectangle2D.Double(200, 170, 100, 100); Ellipse2D.Double testEllipse = new Ellipse2D.Double(200, 0, 50, 50); Shape testShape = testRect; // g2d.fill(testShape); switch (testShape.getClass().getCanonicalName()) { case "java.awt.geom.Rectangle2D.Double": Rectangle2D.Double newRect = (Rectangle2D.Double) testShape; g2d.fill(newRect); // System.out.println(testShape.getBounds().x + testShape.getBounds().y); break; case "java.awt.geom.Ellipse2D.Double": Ellipse2D.Double newEllipse = (Ellipse2D.Double) testShape; g2d.fill(newEllipse); break; } // System.out.println(testShape.getClass().getCanonicalName()); }
/** * Add a shape to this group. * * @param shape - the Shape to add */ public void addShape(Shape shape) { _escherContainer.addChildRecord(shape.getSpContainer()); Sheet sheet = getSheet(); shape.setSheet(sheet); shape.setShapeId(sheet.allocateShapeId()); shape.afterInsert(sheet); }
public boolean contains(int x, int y) { // If the button has changed size, // make a new shape object. if (shape == null || !shape.getBounds().equals(getBounds())) { shape = new Ellipse2D.Float(0, 0, getWidth(), getHeight()); } return shape.contains(x, y); }
@Override public void hitByRect(JEnvironment env, JRequest req, Rectangle2D rect) { if (isLocked() || !isVisible()) return; Shape s = getShape(); if (s.intersects(rect)) { req.hitObjects.add(this); } }
/** * Check if teleporting from a location is allowed. * * @param x x coordinate * @param y y coordinate * @return <code>true</code> if teleporting to the point is allowed, <code>false</code> otherwise */ public boolean isOutAllowed(int x, int y) { for (Shape r : leavingBarriers) { if (r.contains(x, y)) { return false; } } return true; }
/** * Returns an edge whose shape intersects the 'pickArea' footprint of the passed x,y, coordinates. * * @param layout the context in which the location is defined * @param x the x coordinate of the location * @param y the y coordinate of the location * @return an edge whose shape intersects the pick area centered on the location {@code (x,y)} */ public E getEdge(Layout<V, E> layout, double x, double y) { Point2D ip = vv.getRenderContext() .getMultiLayerTransformer() .inverseTransform(Layer.VIEW, new Point2D.Double(x, y)); x = ip.getX(); y = ip.getY(); // as a Line has no area, we can't always use edgeshape.contains(point) so we // make a small rectangular pickArea around the point and check if the // edgeshape.intersects(pickArea) Rectangle2D pickArea = new Rectangle2D.Float( (float) x - pickSize / 2, (float) y - pickSize / 2, pickSize, pickSize); E closest = null; double minDistance = Double.MAX_VALUE; while (true) { try { for (E e : getFilteredEdges(layout)) { Shape edgeShape = getTransformedEdgeShape(layout, e); if (edgeShape == null) continue; // because of the transform, the edgeShape is now a GeneralPath // see if this edge is the closest of any that intersect if (edgeShape.intersects(pickArea)) { float cx = 0; float cy = 0; float[] f = new float[6]; PathIterator pi = new GeneralPath(edgeShape).getPathIterator(null); if (pi.isDone() == false) { pi.next(); pi.currentSegment(f); cx = f[0]; cy = f[1]; if (pi.isDone() == false) { pi.currentSegment(f); cx = f[0]; cy = f[1]; } } float dx = (float) (cx - x); float dy = (float) (cy - y); float dist = dx * dx + dy * dy; if (dist < minDistance) { minDistance = dist; closest = e; } } } break; } catch (ConcurrentModificationException cme) { } } return closest; }
void addShape(Shape shape) { // Add the shape to the canvas, and set its size/position and color. // The shape is added at the top-left corner, with size 80-by-50. // Then redraw the canvas to show the newly added shape. shape.setColor(currentColor); shape.reshape(3, 3, 80, 50); shapes.add(shape); repaint(); }
/** Redefinition de la methode paintComponent() de JComponent */ public void paintComponent(Graphics g) { super.paintComponent(g); for (Shape s : shapes) { s.paint(g); } for (Shape s : shapesCloneList) { s.paint(g); } }
@Override public void writeConstructorParams(DataOutput out) throws IOException { super.writeConstructorParams(out); // issue 483: init the node Font3D font3D = (Font3D) node; font = font3D.getFont(); out.writeUTF(font.getFontName()); out.writeInt(font.getStyle()); out.writeInt(font.getSize()); out.writeDouble(font3D.getTessellationTolerance()); // issue 483 extrudePath = new FontExtrusion(); font3D.getFontExtrusion(extrudePath); if (extrudePath.getExtrusionShape() == null) { extrudePath = null; } if (extrudePath != null) { Shape shape = extrudePath.getExtrusionShape(); if (shape != null) { PathIterator shapePath = shape.getPathIterator(null); float[] coords = new float[6]; int segType; int points; while (!(shapePath.isDone())) { // Get type of current path segment and associated // coordinates segType = shapePath.currentSegment(coords); out.writeInt(segType); // Write out relevant coordinates points = 0; if (segType == PathIterator.SEG_MOVETO) points = 1; else if (segType == PathIterator.SEG_LINETO) points = 1; else if (segType == PathIterator.SEG_QUADTO) points = 2; else if (segType == PathIterator.SEG_CUBICTO) points = 3; for (int i = 0; i < points; i++) { out.writeFloat(coords[i * 2 + 0]); out.writeFloat(coords[i * 2 + 1]); } // Next segment if (!(shapePath.isDone())) shapePath.next(); } } // Flag for end of path definition out.writeInt(Integer.MIN_VALUE); out.writeDouble(extrudePath.getTessellationTolerance()); } else { out.writeInt(Integer.MIN_VALUE); } }
/** * @param shape * @param rotation * @return */ public static Shape getRotatedShape(Shape shape, double rotation) { AffineTransform localAT = null; Shape localShape = null; localAT = AffineTransform.getRotateInstance( Math.toRadians(rotation), shape.getBounds().getX(), shape.getBounds().getY()); localShape = localAT.createTransformedShape(shape); return localShape; }
/** * Constructs a ShapeIcon. * * @param shape the shape to draw * @param decoration a decorating shape to draw * @param width width of the icon * @param height height of the icon */ public ShapeIcon(Shape shape, Shape decoration, int width, int height) { w = width; h = height; this.shape = shape; this.decoration = decoration; Rectangle rect = shape == null ? new Rectangle() : shape.getBounds(); if (decoration != null) rect = rect.union(decoration.getBounds()); offsetX = w / 2 - rect.width / 2 - rect.x; offsetY = h / 2 - rect.height / 2 - rect.y; }
/** * A utility method for determining the height of a text block. * * @param block the text block. * @param position the label position. * @param g2 the graphics device. * @return The height. */ protected double calculateTextBlockHeight( TextBlock block, CategoryLabelPosition position, Graphics2D g2) { RectangleInsets insets = getTickLabelInsets(); Size2D size = block.calculateDimensions(g2); Rectangle2D box = new Rectangle2D.Double(0.0, 0.0, size.getWidth(), size.getHeight()); Shape rotatedBox = ShapeUtilities.rotateShape(box, position.getAngle(), 0.0f, 0.0f); double h = rotatedBox.getBounds2D().getHeight() + insets.getTop() + insets.getBottom(); return h; }
public void selectAllWithin(BaseObject boundary) { BaseObject[] list = list(); for (int i = 0; i < list.length; i++) { java.awt.Shape s1 = boundary.getShape(); java.awt.Shape s2 = list[i].getShape(); if (s1.contains(s2.getBounds2D())) { grab(list[i]); } } }
public static Path getFXShape(LinkedList swingShapeList) { Path sfx = new Path(); for (Object s : swingShapeList) { java.awt.Shape ss = (java.awt.Shape) s; if (ss instanceof java.awt.Shape) { double[] coords = new double[6]; ArrayList<double[]> areaPoints = new ArrayList<double[]>(); for (PathIterator pi = ss.getPathIterator(null); !pi.isDone(); pi.next()) { int type = pi.currentSegment(coords); double[] pathIteratorCoords = { type, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5] }; areaPoints.add(pathIteratorCoords); } for (double[] d : areaPoints) { if (d[0] == PathIterator.SEG_MOVETO) { MoveTo moveTo = new MoveTo(); moveTo.setX(d[1]); moveTo.setY(d[2]); sfx.getElements().add(moveTo); } else if (d[0] == PathIterator.SEG_LINETO) { LineTo lineTo = new LineTo(); lineTo.setX(d[1]); lineTo.setY(d[2]); sfx.getElements().add(lineTo); } else if (d[0] == PathIterator.SEG_CUBICTO) { CubicCurveTo ccTo = new CubicCurveTo(d[1], d[2], d[3], d[4], d[5], d[6]); sfx.getElements().add(ccTo); } else if (d[0] == PathIterator.SEG_QUADTO) { QuadCurveTo qcTo = new QuadCurveTo(d[1], d[2], d[3], d[4]); sfx.getElements().add(qcTo); } else if (d[0] == PathIterator.SEG_CLOSE) { ClosePath cp = new ClosePath(); sfx.getElements().add(cp); } } } } return sfx; }
/** * Selects all the entities in provided rectangle. Allows a user to drag around the desired * entities. * * @param area The area to select the entities in. */ public void select(Shape area) { deselectAll(); boolean multi = myMultiSelect; setMultiSelect(true); for (InteractiveEntity ie : myEntities) { if (area.intersects(ie.getBounds()) || area.contains(ie.getBounds())) { select(ie); } } setMultiSelect(multi); }
/** @see prefuse.render.Renderer#locatePoint(java.awt.geom.Point2D, prefuse.visual.VisualItem) */ @Override public boolean locatePoint(Point2D p, VisualItem item) { Shape s = getShape(item); if (s == null) { return false; } else { double width = Math.max(2, getLineWidth(item)); double halfWidth = width / 2.0; return s.intersects(p.getX() - halfWidth, p.getY() - halfWidth, width, width); } }