/** Creates a hexagonal shape inscribed in the bounds given in the parameters. */ private Shape createHexagonShape(double x, double y, double width, double height) { GeneralPath result = new GeneralPath(Path2D.WIND_NON_ZERO, 5); double extend = height * NodeShape.HEX_EXTEND_RATIO; // stat at top left corner result.moveTo(x + extend, y); // to top right result.lineTo(x + width - extend, y); // to right result.lineTo(x + width, y + height / 2); // to bottom right result.lineTo(x + width - extend, y + height); // to bottom left result.lineTo(x + extend, y + height); // to left result.lineTo(x, y + height / 2); result.closePath(); return result; }
/** This method is called by Swing to draw highlights. */ public void paint(Graphics gr, int start, int end, Shape shape, JTextComponent text) { Color old = gr.getColor(); gr.setColor(color); try { Rectangle box = shape.getBounds(), a = text.getUI().modelToView(text, start), b = text.getUI().modelToView(text, end); if (a.y == b.y) { // same line (Note: furthermore, if start==end, then we draw all // the way to the right edge) Rectangle r = a.union(b); gr.fillRect(r.x, r.y, (r.width <= 1 ? (box.x + box.width - r.x) : r.width), r.height); } else { // Multiple lines; (Note: on first line we'll draw from "start" // and extend to rightmost) gr.fillRect(a.x, a.y, box.x + box.width - a.x, a.height); if (a.y + a.height < b.y) gr.fillRect(box.x, a.y + a.height, box.width, b.y - (a.y + a.height)); gr.fillRect(box.x, b.y, b.x - box.x, b.height); } } catch (BadLocationException e) {} // Failure to highlight is not fatal gr.setColor(old); }
/** * Creates the shape of the vertex given its description in a string * @param shapeString "square" or "circle" */ public void setShape(String shapeString) { Shape newShape; if (shapeString.startsWith("square")){ Rectangle2D rectangle = new Rectangle2D.Float(); rectangle.setFrameFromCenter(0,0,size,size); newShape = rectangle; } else { Ellipse2D ellipse = new Ellipse2D.Float(); ellipse.setFrameFromCenter(0,0,size,size); newShape = ellipse; } this.shape = newShape; }
private List<Shape> getMatchesList() { List<Shape> rMatches = new ArrayList<>(); try { Iterator<?> it = getMatches(); if (it != null) { Region sRegion = Region.create(shapes.get(0).getBounds()); while (it.hasNext()) { Object region = it.next(); Shape rx = ((Region) region).getRect(); if (sRegion != null && sRegion.getRect().contains(rx.getBounds())) { rMatches.add(rx); } } } } catch (FindFailed | IOException | NullPointerException ex) { Logger.getLogger(PropertyEditor.class.getName()).log(Level.SEVERE, null, ex); } return rMatches; }
/** * Returns a string containing the coordinates for a given shape. This * string is intended for use in an image map. * * @param shape the shape (<code>null</code> not permitted). * * @return The coordinates for a given shape as string. */ private String getPolyCoords(Shape shape) { if (shape == null) { throw new IllegalArgumentException("Null 'shape' argument."); } String result = ""; boolean first = true; float[] coords = new float[6]; PathIterator pi = shape.getPathIterator(null, 1.0); while (!pi.isDone()) { pi.currentSegment(coords); if (first) { first = false; result = result + (int) coords[0] + "," + (int) coords[1]; } else { result = result + "," + (int) coords[0] + "," + (int) coords[1]; } pi.next(); } return result; }
public Shape mapShape(Shape s) { if (LOGMAP) LOG.format("mapshape on path: %s\n", LayoutPathImpl.SegmentPath.this); PathIterator pi = s.getPathIterator(null, 1); // cheap way to handle curves. if (LOGMAP) LOG.format("start\n"); init(); final double[] coords = new double[2]; while (!pi.isDone()) { switch (pi.currentSegment(coords)) { case SEG_CLOSE: close(); break; case SEG_MOVETO: moveTo(coords[0], coords[1]); break; case SEG_LINETO: lineTo(coords[0], coords[1]); break; default: break; } pi.next(); } if (LOGMAP) LOG.format("finish\n\n"); GeneralPath gp = new GeneralPath(); for (Segment seg: segments) { gp.append(seg.gp, false); } return gp; }
public Shape getRegiaoComentario() { if (Regiao == null) { GeneralPath pa = new GeneralPath(); pa.setWindingRule(GeneralPath.WIND_NON_ZERO); Rectangle rec = getBounds(); int tam = Math.min(rec.width / 6, rec.height / 6); int curv = tam / 4; int lw = rec.x + rec.width; int[] px = new int[]{rec.x, lw - tam, lw, lw, rec.x}; int[] py = new int[]{rec.y, rec.y, rec.y + tam, rec.y + rec.height, rec.y + rec.height}; Polygon po = new Polygon(px, py, 5); pa.append(po, true); pa.moveTo(lw - tam, rec.y); pa.curveTo(lw - tam, rec.y, lw - tam + curv, rec.y + curv, lw - tam, rec.y + tam - (1)); pa.moveTo(lw - tam, rec.y + tam - (1)); pa.lineTo(lw, rec.y + tam); pa.closePath(); Regiao = pa; } return Regiao; }
public Shape getRegiaoDocumento() { if (Regiao == null) { final int v1 = getHeight() / 3; final int h1 = getWidth() / 2; final int repo = v1 / 3; final int L = getLeft(); final int T = getTop(); final int TH = T + getHeight() - repo; final int LW = L + getWidth(); CubicCurve2D c = new CubicCurve2D.Double(); c.setCurve(L, TH, L + h1, TH + v1, LW - h1, TH - v1, LW, TH); GeneralPath pa = new GeneralPath(); pa.moveTo(LW, TH); pa.lineTo(LW, T); pa.lineTo(L, T); pa.lineTo(L, TH); pa.append(c, true); Regiao = pa; final int ptToMove = 3; this.reposicionePonto[ptToMove] = new Point(0, -repo); ptsToMove[ptToMove] = 1; } return Regiao; }
/** * Returns a legend item for a series. * * @param datasetIndex the dataset index (zero-based). * @param series the series index (zero-based). * * @return the legend item. */ public LegendItem getLegendItem(int datasetIndex, int series) { CategoryPlot cp = getPlot(); if (cp == null) { return null; } CategoryDataset dataset; dataset = cp.getDataset(datasetIndex); String label = dataset.getRowKey(series).toString(); String description = label; Shape shape = getSeriesShape(series); Paint paint = getSeriesPaint(series); Paint outlinePaint = getSeriesOutlinePaint(series); Stroke stroke = getSeriesStroke(series); return new LegendItem( label, description, shape, true, paint, stroke, outlinePaint, stroke ); }
/** * Constructs a new double precision {@code Path2D} object * from an arbitrary {@link Shape} object, transformed by an * {@link AffineTransform} object. * All of the initial geometry and the winding rule for this path are * taken from the specified {@code Shape} object and transformed * by the specified {@code AffineTransform} object. * * @param s the specified {@code Shape} object * @param at the specified {@code AffineTransform} object * @since 1.6 */ public Double(Shape s, AffineTransform at) { if (s instanceof Path2D) { Path2D p2d = (Path2D) s; setWindingRule(p2d.windingRule); this.numTypes = p2d.numTypes; this.pointTypes = Arrays.copyOf(p2d.pointTypes, p2d.pointTypes.length); this.numCoords = p2d.numCoords; this.doubleCoords = p2d.cloneCoordsDouble(at); } else { PathIterator pi = s.getPathIterator(at); setWindingRule(pi.getWindingRule()); this.pointTypes = new byte[INIT_SIZE]; this.doubleCoords = new double[INIT_SIZE * 2]; append(pi, false); } }
public Shape createStrokedShape(Shape src, float width, int caps, int join, float miterlimit, float dashes[], float dashphase) { System.out.println(name+".createStrokedShape("+ src.getClass().getName()+", "+ "width = "+width+", "+ "caps = "+caps+", "+ "join = "+join+", "+ "miter = "+miterlimit+", "+ "dashes = "+dashes+", "+ "dashphase = "+dashphase+")"); return target.createStrokedShape(src, width, caps, join, miterlimit, dashes, dashphase); }
public Shape getBorder(double size) { AffineTransform at = new AffineTransform(); at.translate(getVisualX(size), getVisualY(size)); at.scale(size, size); return border.createTransformedShape(at); }
/** * Paints the border, with a given shape. */ private void paintBorder(Graphics2D g, Shape shape) { g.setColor(this.lineColor); g.setStroke(JAttr.createStroke(this.lineWidth, this.dash)); g.draw(shape); if (this.twoLines) { g.setColor(this.line2color); g.setStroke(JAttr.createStroke(this.line2width, this.line2dash)); g.draw(shape); } if (this.selected) { paintSelectionBorder(g, shape); } }
public Shape getOutline(AffineTransform tx) { GeneralPath dstShape = new GeneralPath(GeneralPath.WIND_NON_ZERO); for (int i=0, n = 0; i < fComponents.length; i++, n += 2) { TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)]; dstShape.append(tlc.getOutline(locs[n], locs[n+1]), false); } if (tx != null) { dstShape.transform(tx); } return dstShape; }
/** * save graphics state of a PathGraphics for later redrawing * of part of page represented by the region in that state */ public void saveState(AffineTransform at, Shape clip, Rectangle2D region, double sx, double sy) { GraphicsState gstate = new GraphicsState(); gstate.theTransform = at; gstate.theClip = clip; gstate.region = region; gstate.sx = sx; gstate.sy = sy; redrawList.add(gstate); }
protected static Shape transformShape(AffineTransform tx, Shape clip) { if (clip == null) { return null; } if (clip instanceof Rectangle2D && (tx.getType() & NON_RECTILINEAR_TRANSFORM_MASK) == 0) { Rectangle2D rect = (Rectangle2D) clip; double matrix[] = new double[4]; matrix[0] = rect.getX(); matrix[1] = rect.getY(); matrix[2] = matrix[0] + rect.getWidth(); matrix[3] = matrix[1] + rect.getHeight(); tx.transform(matrix, 0, matrix, 0, 2); fixRectangleOrientation(matrix, rect); return new Rectangle2D.Double(matrix[0], matrix[1], matrix[2] - matrix[0], matrix[3] - matrix[1]); } if (tx.isIdentity()) { return cloneShape(clip); } return tx.createTransformedShape(clip); }
Shape getChildAllocation(DocumentView docView, int index, Shape docViewAlloc) { Rectangle2D.Double mutableBounds = ViewUtils.shape2Bounds(docViewAlloc); double startYR = startVisualOffset(index); // relative i.e. not shifted by baseY double endYR = endVisualOffset(index); // relative i.e. not shifted by baseY mutableBounds.y += baseY + startYR; mutableBounds.height = endYR - startYR; // Leave mutableBounds.width return mutableBounds; }
public void runTest(Object ctx, int numReps) { GVContext gvctx = (GVContext)ctx; GlyphVector gv = gvctx.gv; Shape s; do { for (int i = 0, e = gv.getNumGlyphs(); i < e; ++i) { s = gv.getGlyphLogicalBounds(i); } } while (--numReps >= 0); }
@Override public Shape getShape() { if (ext.isWeak()) { return geom.shape; } else { return super.getShape(); } }
/** * Creates the default {@link Shape} for the given button. * * @param b * the button to create the shape for * @return the shape instance */ public static Shape createShapeForButton(AbstractButton b) { int w = b.getWidth(); int h = b.getHeight(); return new RoundRectangle2D.Double(1, 1, w - 2, h - 2, RapidLookAndFeel.CORNER_DEFAULT_RADIUS, RapidLookAndFeel.CORNER_DEFAULT_RADIUS); }
/** * */ public Shape createShape(mxGraphics2DCanvas canvas, mxCellState state) { Rectangle temp = state.getRectangle(); int x = temp.x; int y = temp.y; int w = temp.width; int h = temp.height; String direction = mxUtils.getString(state.getStyle(), mxConstants.STYLE_DIRECTION, mxConstants.DIRECTION_EAST); Polygon hexagon = new Polygon(); if (direction.equals(mxConstants.DIRECTION_NORTH) || direction.equals(mxConstants.DIRECTION_SOUTH)) { hexagon.addPoint(x + (int) (0.5 * w), y); hexagon.addPoint(x + w, y + (int) (0.25 * h)); hexagon.addPoint(x + w, y + (int) (0.75 * h)); hexagon.addPoint(x + (int) (0.5 * w), y + h); hexagon.addPoint(x, y + (int) (0.75 * h)); hexagon.addPoint(x, y + (int) (0.25 * h)); } else { hexagon.addPoint(x + (int) (0.25 * w), y); hexagon.addPoint(x + (int) (0.75 * w), y); hexagon.addPoint(x + w, y + (int) (0.5 * h)); hexagon.addPoint(x + (int) (0.75 * w), y + h); hexagon.addPoint(x + (int) (0.25 * w), y + h); hexagon.addPoint(x, y + (int) (0.5 * h)); } return hexagon; }
public void draw(SunGraphics2D sg2d, Shape s) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) { Path2D.Float p2df; int transX; int transY; if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) { if (s instanceof Path2D.Float) { p2df = (Path2D.Float)s; } else { p2df = new Path2D.Float(s); } transX = sg2d.transX; transY = sg2d.transY; } else { p2df = new Path2D.Float(s, sg2d.transform); transX = 0; transY = 0; } sg2d.loops.drawPathLoop.DrawPath(sg2d, sg2d.getSurfaceData(), transX, transY, p2df); return; } if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM) { fill(sg2d, sg2d.stroke.createStrokedShape(s)); return; } ShapeSpanIterator sr = getStrokeSpans(sg2d, s); try { fillSpans(sg2d, sr); } finally { sr.dispose(); } }
@Test public void testSuperList() throws Exception { ReifiedType tp = getReifiedTypeFor("superList"); assertEquals(1, tp.size()); assertEquals(LinkedList.class, tp.getRawClass()); assertEquals(Shape.class, tp.getActualTypeArgument(0).getRawClass()); }
/** * Converts an AWT <code>Shape</code> into a SWT <code>Path</code>. * * @param shape the shape. * * @return The path. */ private Path toSwtPath(Shape shape) { int type; float[] coords = new float[6]; Path path = new Path(this.gc.getDevice()); PathIterator pit = shape.getPathIterator(null); while (!pit.isDone()) { type = pit.currentSegment(coords); switch (type) { case (PathIterator.SEG_MOVETO): path.moveTo(coords[0], coords[1]); break; case (PathIterator.SEG_LINETO): path.lineTo(coords[0], coords[1]); break; case (PathIterator.SEG_QUADTO): path.quadTo(coords[0], coords[1], coords[2], coords[3]); break; case (PathIterator.SEG_CUBICTO): path.cubicTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); break; case (PathIterator.SEG_CLOSE): path.close(); break; default: break; } pit.next(); } return path; }
public static Shape createDiamond() { final float s = SHAPE_SIZE; double d = Math.round(Math.sqrt(2 * s * s) / 2.0); final GeneralPath p = new GeneralPath(); p.moveTo(0, d); p.lineTo(d, 0); p.lineTo(0, -d); p.lineTo(-d, 0); p.closePath(); return p; // final float s = shapeSize; // final float l = s / 4.0f; // final float t = s / 4.0f; // // final float SQRT2 = (float) Math.pow(2.0, 0.5); // final GeneralPath p0 = new GeneralPath(); // p0.moveTo(-l - t, -l + t); // p0.lineTo(-l + t, -l - t); // p0.lineTo(0.0f, -t * SQRT2); // p0.lineTo(l - t, -l - t); // p0.lineTo(l + t, -l + t); // p0.lineTo(t * SQRT2, 0.0f); // p0.lineTo(l + t, l - t); // p0.lineTo(l - t, l + t); // p0.lineTo(0.0f, t * SQRT2); // p0.lineTo(-l + t, l + t); // p0.lineTo(-l - t, l - t); // p0.lineTo(-t * SQRT2, 0.0f); // p0.closePath(); // return p0; }
Shape intersectRectShape(Rectangle2D r, Shape s, boolean keep1, boolean keep2) { if (s instanceof Rectangle2D) { Rectangle2D r2 = (Rectangle2D) s; Rectangle2D outrect; if (!keep1) { outrect = r; } else if (!keep2) { outrect = r2; } else { outrect = new Rectangle2D.Float(); } double x1 = Math.max(r.getX(), r2.getX()); double x2 = Math.min(r.getX() + r.getWidth(), r2.getX() + r2.getWidth()); double y1 = Math.max(r.getY(), r2.getY()); double y2 = Math.min(r.getY() + r.getHeight(), r2.getY() + r2.getHeight()); if (((x2 - x1) < 0) || ((y2 - y1) < 0)) // Width or height is negative. No intersection. outrect.setFrameFromDiagonal(0, 0, 0, 0); else outrect.setFrameFromDiagonal(x1, y1, x2, y2); return outrect; } if (r.contains(s.getBounds2D())) { if (keep2) { s = cloneShape(s); } return s; } return intersectByArea(r, s, keep1, keep2); }
public Shape modelToView(DocumentView docView, int offset, Position.Bias bias) { if (docView != null) { return docView.modelToViewNeedsLock(offset, docView.getAllocation(), bias); } else { TextUI ui = textComponent.getUI(); try { return (ui != null) ? ui.modelToView(textComponent, offset, bias) : null; } catch (BadLocationException ex) { return null; } } }
/** * Creates a new category item entity. * * @param area the area. * @param toolTipText the tool tip text. * @param urlText the URL text for HTML image maps. * @param dataset the dataset. * @param series the series (zero-based index). * @param category the category. * @param categoryIndex the category index. */ public CategoryItemEntity(Shape area, String toolTipText, String urlText, CategoryDataset dataset, int series, Object category, int categoryIndex) { super(area, toolTipText, urlText); this.dataset = dataset; this.series = series; this.category = category; this.categoryIndex = categoryIndex; }
/** * Draws the annotation. * * @param g2 the graphics device. * @param plot the plot. * @param dataArea the data area. * @param domainAxis the domain axis. * @param rangeAxis the range axis. * @param rendererIndex the renderer index. * @param info an optional info object that will be populated with * entity information. */ public void draw(Graphics2D g2, XYPlot plot, Rectangle2D dataArea, ValueAxis domainAxis, ValueAxis rangeAxis, int rendererIndex, PlotRenderingInfo info) { PlotOrientation orientation = plot.getOrientation(); RectangleEdge domainEdge = Plot.resolveDomainAxisLocation( plot.getDomainAxisLocation(), orientation); RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation( plot.getRangeAxisLocation(), orientation); float anchorX = (float) domainAxis.valueToJava2D( this.x, dataArea, domainEdge); float anchorY = (float) rangeAxis.valueToJava2D( this.y, dataArea, rangeEdge); if (orientation == PlotOrientation.HORIZONTAL) { float tempAnchor = anchorX; anchorX = anchorY; anchorY = tempAnchor; } g2.setFont(getFont()); g2.setPaint(getPaint()); TextUtilities.drawRotatedString(getText(), g2, anchorX, anchorY, getTextAnchor(), getRotationAngle(), getRotationAnchor()); Shape hotspot = TextUtilities.calculateRotatedStringBounds( getText(), g2, anchorX, anchorY, getTextAnchor(), getRotationAngle(), getRotationAnchor()); String toolTip = getToolTipText(); String url = getURL(); if (toolTip != null || url != null) { addEntity(info, hotspot, rendererIndex, toolTip, url); } }
@Override public void paint(Graphics2D g, Shape alloc, Rectangle clipBounds) { if (lock()) { try { checkDocumentLockedIfLogging(); op.checkViewsInited(); if (op.isActive()) { op.updateFontRenderContext(g, true); // Includes setting of rendering hints children.paint(this, g, alloc, clipBounds); } } finally { unlock(); } } }
/** * Used by getOutline, getGlyphsOutline */ private Shape getGlyphsOutline(int start, int count, float x, float y) { setFRCTX(); initPositions(); GeneralPath result = new GeneralPath(GeneralPath.WIND_NON_ZERO); for (int i = start, e = start + count, n = start * 2; i < e; ++i, n += 2) { float px = x + positions[n]; float py = y + positions[n+1]; getGlyphStrike(i).appendGlyphOutline(glyphs[i], result, px, py); } return result; }
/** * {@inheritDoc} */ @Override public final Shape modelToView(int offset, Shape alloc, Position.Bias bias) throws BadLocationException { checkBounds(offset); checkBias(bias); if (alloc != null) { return modelToViewChecked(offset, alloc, bias); } else { return null; } }
/** * Scales a shape according to the scaling factor for value (given by the sizeProvider if one * such exists). If no sizeProvider exists, the shape is returned unmodified. */ private Shape scaleShape(Shape shape, double scalingFactor) { // scale shape if necessary if (scalingFactor != 1) { AffineTransform t = new AffineTransform(); t.scale(scalingFactor, scalingFactor); shape = t.createTransformedShape(shape); } return shape; }
/** * Returns a <code>Shape</code> representing the outline of this * <code>TextLayout</code>. * @param tx an optional {@link AffineTransform} to apply to the * outline of this <code>TextLayout</code>. * @return a <code>Shape</code> that is the outline of this * <code>TextLayout</code>. This is in standard coordinates. */ public Shape getOutline(AffineTransform tx) { ensureCache(); Shape result = textLine.getOutline(tx); LayoutPathImpl lp = textLine.getLayoutPath(); if (lp != null) { result = lp.mapShape(result); } return result; }
public void runTest(Object ctx, int numReps) { GVContext gvctx = (GVContext)ctx; GlyphVector gv = gvctx.gv; Shape s; do { for (int i = 0, e = gv.getNumGlyphs(); i < e; ++i) { s = gv.getGlyphVisualBounds(i); } } while (--numReps >= 0); }
public Shape getRegiaoLosanglo() { if (Regiao == null) { Rectangle r = new Rectangle(getLeft(), getTop(), getWidth(), getHeight()); //getBounds(); Polygon los = new Polygon(); los.addPoint(r.x, r.y + r.height / 2); los.addPoint(r.x + r.width / 2, r.y); los.addPoint(r.x + r.width, r.y + r.height / 2); los.addPoint(r.x + r.width / 2, r.y + r.height); Regiao = los; } return Regiao; }
public void draw(SunGraphics2D sg, Shape s) { if (sg.stroke instanceof BasicStroke) { ShapeSpanIterator sr = LoopPipe.getStrokeSpans(sg, s); try { renderSpans(sg, sg.getCompClip(), s, sr); } finally { sr.dispose(); } } else { fill(sg, sg.stroke.createStrokedShape(s)); } }
@Override public Shape getRegiao() { if (Regiao == null) { Regiao = new RoundRectangle2D.Float(getLeft(), getTop(), getWidth(), getHeight(), getWidth()/3, getHeight()); } return Regiao; }
