artwork.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

		/** Opened-Dotted-Polygon */
		openedDottedPolygonNode = PrimitiveNode.newInstance0("Opened-Dotted-Polygon", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.OPENEDT1, Technology.NodeLayer.POINTS, box_2)
			});
		openedDottedPolygonNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, openedDottedPolygonNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		openedDottedPolygonNode.setFunction(PrimitiveNode.Function.ART);
		openedDottedPolygonNode.setHoldsOutline();
		openedDottedPolygonNode.setEdgeSelect();

		/** Opened-Dashed-Polygon */
		openedDashedPolygonNode = PrimitiveNode.newInstance0("Opened-Dashed-Polygon", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.OPENEDT2, Technology.NodeLayer.POINTS, box_2)
			});
		openedDashedPolygonNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, openedDashedPolygonNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		openedDashedPolygonNode.setFunction(PrimitiveNode.Function.ART);
		openedDashedPolygonNode.setHoldsOutline();
		openedDashedPolygonNode.setEdgeSelect();

		/** Opened-Thicker-Polygon */
		openedThickerPolygonNode = PrimitiveNode.newInstance0("Opened-Thicker-Polygon", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.OPENEDT3, Technology.NodeLayer.POINTS, box_2)
			});
		openedThickerPolygonNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, openedThickerPolygonNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		openedThickerPolygonNode.setFunction(PrimitiveNode.Function.ART);
		openedThickerPolygonNode.setHoldsOutline();
		openedThickerPolygonNode.setEdgeSelect();

		/** Closed-Polygon */
		closedPolygonNode = PrimitiveNode.newInstance0("Closed-Polygon", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.CLOSED, Technology.NodeLayer.POINTS, box_1)
			});
		closedPolygonNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, closedPolygonNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		closedPolygonNode.setFunction(PrimitiveNode.Function.ART);
		closedPolygonNode.setHoldsOutline();
		closedPolygonNode.setEdgeSelect();

		/** Filled-Polygon */
		filledPolygonNode = PrimitiveNode.newInstance0("Filled-Polygon", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.FILLED, Technology.NodeLayer.POINTS, box_1)
			});
		filledPolygonNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, filledPolygonNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		filledPolygonNode.setFunction(PrimitiveNode.Function.ART);
		filledPolygonNode.setHoldsOutline();
		filledPolygonNode.setEdgeSelect();

		/** Thick-Circle */
		thickCircleNode = PrimitiveNode.newInstance0("Thick-Circle", this, 6, 6,
			new Technology.NodeLayer []
			{
				new Technology.NodeLayer(defaultLayer, 0, Poly.Type.THICKCIRCLE, Technology.NodeLayer.POINTS, box_6)
			});
		thickCircleNode.addPrimitivePorts(new PrimitivePort[]
			{
				PrimitivePort.newInstance(this, thickCircleNode, new ArcProto [] {solidArc, dottedArc, dashedArc, thickerArc}, "site", 0,180, 0, PortCharacteristic.UNKNOWN,
					EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge(), EdgeH.makeRightEdge(), EdgeV.makeTopEdge())
			});
		thickCircleNode.setFunction(PrimitiveNode.Function.ART);
		thickCircleNode.setEdgeSelect();

		// Foundry
		newFoundry(Foundry.Type.NONE, null,
				// The GDS names
				"Graphics 1");
//		noFoundry.setFactoryGDSLayer(defaultLayer, "1");
//		defaultLayer.setFactoryGDSLayer("1", Foundry.Type.MOSIS.name());		// Graphics

		oldArcNames.put("Dash-1", dottedArc);
		oldArcNames.put("Dash-2", dashedArc);
		oldArcNames.put("Dash-3", thickerArc);

		oldNodeNames.put("Message", generic.invisiblePinNode);
		oldNodeNames.put("Centered-Message", generic.invisiblePinNode);
		oldNodeNames.put("Left-Message", generic.invisiblePinNode);
		oldNodeNames.put("Right-Message", generic.invisiblePinNode);
		oldNodeNames.put("Opened-FarDotted-Polygon", openedThickerPolygonNode);
	}

	private Object[][] techEditSet;

	/**
	 * Method to compute the component menu entries automatically.
	 * @return a two-dimensional array of menu entries.
	 */
	public Object[][] getNodesGrouped(Cell curCell)
	{
		if (curCell != null && curCell.isInTechnologyLibrary())
		{
			// special variation of Artwork for technology editing
			if (techEditSet != null) return techEditSet;
			techEditSet = new Object[16][1];
			techEditSet[0][0] = Technology.SPECIALMENUTEXT;
			NodeInst arc = NodeInst.makeDummyInstance(circleNode);
			arc.setArcDegrees(0, Math.PI/4);
			techEditSet[1][0] = arc;
			NodeInst half = NodeInst.makeDummyInstance(circleNode);
			half.setArcDegrees(0, Math.PI);
			techEditSet[2][0] = half;
			techEditSet[3][0] = filledCircleNode;
			techEditSet[4][0] = circleNode;
			techEditSet[5][0] = openedThickerPolygonNode;
			techEditSet[6][0] = openedDashedPolygonNode;
			techEditSet[7][0] = openedDottedPolygonNode;
			techEditSet[8][0] = openedPolygonNode;
			techEditSet[9][0] = Technology.makeNodeInst(closedPolygonNode, PrimitiveNode.Function.ART, 0, false, null, 4.5);
			techEditSet[10][0] = Technology.makeNodeInst(filledPolygonNode, PrimitiveNode.Function.ART, 0, false, null, 4.5);
			techEditSet[11][0] = boxNode;
			techEditSet[12][0] = crossedBoxNode;
			techEditSet[13][0] = filledBoxNode;
			techEditSet[14][0] = Technology.SPECIALMENUHIGH;
			techEditSet[15][0] = Technology.SPECIALMENUPORT;
			return techEditSet;
		}

		// just use the default
		return super.getNodesGrouped(curCell);
	}

	/**
	 * Method to construct a default group of elements for the palette.
	 * @return the default set of objects to display in the component menu.
	 */
	public Object[][] getDefaultNodesGrouped()
	{
		factoryNodeGroups = new Object[12][2];
		factoryNodeGroups[0][0] = solidArc;
		factoryNodeGroups[1][0] = thickerArc;
		factoryNodeGroups[2][0] = Technology.SPECIALMENUCELL;
		factoryNodeGroups[3][0] = openedPolygonNode;
		factoryNodeGroups[4][0] = openedThickerPolygonNode;
		factoryNodeGroups[5][0] = filledTriangleNode;
		factoryNodeGroups[6][0] = filledBoxNode;
		factoryNodeGroups[7][0] = Technology.makeNodeInst(filledPolygonNode, PrimitiveNode.Function.ART, 0, false, null, 4.5);
		factoryNodeGroups[8][0] = filledCircleNode;
		factoryNodeGroups[9][0] = pinNode;
		factoryNodeGroups[10][0] = crossedBoxNode;
		factoryNodeGroups[11][0] = thickCircleNode;

		factoryNodeGroups[0][1] = dottedArc;
		factoryNodeGroups[1][1] = dashedArc;
		factoryNodeGroups[2][1] = Technology.SPECIALMENUTEXT;
		factoryNodeGroups[3][1] = openedDottedPolygonNode;
		factoryNodeGroups[4][1] = openedDashedPolygonNode;
		factoryNodeGroups[5][1] = triangleNode;
		factoryNodeGroups[6][1] = boxNode;
		factoryNodeGroups[7][1] = Technology.makeNodeInst(closedPolygonNode, PrimitiveNode.Function.ART, 0, false, null, 4.5);
		factoryNodeGroups[8][1] = circleNode;
		factoryNodeGroups[9][1] = Technology.SPECIALMENUEXPORT;
		factoryNodeGroups[10][1] = arrowNode;
		factoryNodeGroups[11][1] = Technology.makeNodeInst(splineNode, PrimitiveNode.Function.ART, 0, false, null, 4.5);
		return factoryNodeGroups;
	}

	/**
	 * Method to return a list of Polys that describe a given NodeInst.
	 * This method overrides the general one in the Technology object
	 * because of the unusual primitives in this Technology.
	 * @param ni the NodeInst to describe.
	 * @param electrical true to get the "electrical" layers.
	 * This makes no sense for Artwork primitives.
	 * @param reasonable true to get only a minimal set of contact cuts in large contacts.
	 * This makes no sense for Artwork primitives.
	 * @param primLayers an array of NodeLayer objects to convert to Poly objects.
	 * @param layerOverride the layer to use for all generated polygons (if not null).
	 * @return an array of Poly objects.
	 */
	@Override
	protected Poly [] getShapeOfNode(NodeInst ni, boolean electrical, boolean reasonable, Technology.NodeLayer [] primLayers, Layer layerOverride)
	{
		PrimitiveNode np = (PrimitiveNode)ni.getProto();
		layerOverride = getProperLayer(ni.getD());

		if (np == circleNode || np == thickCircleNode)
		{
			double [] angles = ni.getArcDegrees();
			if (ni.getXSize() != ni.getYSize())
			{
				// handle ellipses
				Point2D [] pointList = fillEllipse(ni.getAnchorCenter(), ni.getXSize(), ni.getYSize(),
					angles[0], angles[1]);
				Poly [] polys = new Poly[1];
				polys[0] = new Poly(pointList);
				if (np == circleNode) polys[0].setStyle(Poly.Type.OPENED); else
					polys[0].setStyle(Poly.Type.OPENEDT3);
//				Technology.NodeLayer primLayer = primLayers[0];
				polys[0].setLayer(layerOverride);
				return polys;
			}

			// if there is arc information here, make it an arc of a circle
			if (angles[0] != 0.0 || angles[1] != 0.0)
			{
				// fill an arc of a circle here
				Poly [] polys = new Poly[1];
				Point2D [] pointList = new Point2D.Double[3];
				double cX = ni.getAnchorCenterX();
				double cY = ni.getAnchorCenterY();
				double dist = ni.getXSize() / 2;
				pointList[0] = new Point2D.Double(cX, cY);
				pointList[1] = new Point2D.Double(cX + Math.cos(angles[0]+angles[1])*dist, cY + Math.sin(angles[0]+angles[1])*dist);
				pointList[2] = new Point2D.Double(cX + Math.cos(angles[0])*dist, cY + Math.sin(angles[0])*dist);
				polys[0] = new Poly(pointList);
				if (np == circleNode) polys[0].setStyle(Poly.Type.CIRCLEARC); else
					polys[0].setStyle(Poly.Type.THICKCIRCLEARC);
//				Technology.NodeLayer primLayer = primLayers[0];
				polys[0].setLayer(layerOverride);
				return polys;
			}
		} else if (np == splineNode)
		{
			Point2D [] tracePoints = ni.getTrace();
			if (tracePoints != null)
			{
				double cX = ni.getAnchorCenterX();
				double cY = ni.getAnchorCenterY();
				Point2D [] pointList = fillSpline(cX, cY, tracePoints);
				Poly [] polys = new Poly[1];
				polys[0] = new Poly(pointList);
				polys[0].setStyle(Poly.Type.OPENED);
//				Technology.NodeLayer primLayer = primLayers[0];
				polys[0].setLayer(layerOverride);
				return polys;
			}
		} else if (np == arrowNode)
		{
			if (isFilledArrowHeads())
			{
				primLayers = new Technology.NodeLayer[2];
				primLayers[0] = new Technology.NodeLayer(defaultLayer, 0, Poly.Type.FILLED, Technology.NodeLayer.POINTS,
					new Technology.TechPoint[]
					{
						new Technology.TechPoint(EdgeH.makeLeftEdge(), EdgeV.makeTopEdge()),
						new Technology.TechPoint(EdgeH.makeRightEdge(), EdgeV.makeCenter()),
						new Technology.TechPoint(EdgeH.makeCenter(), EdgeV.makeCenter()),
					});
				primLayers[1] = new Technology.NodeLayer(defaultLayer, 0, Poly.Type.FILLED, Technology.NodeLayer.POINTS,
					new Technology.TechPoint[]
					{
						new Technology.TechPoint(EdgeH.makeLeftEdge(), EdgeV.makeBottomEdge()),
						new Technology.TechPoint(EdgeH.makeRightEdge(), EdgeV.makeCenter()),
						new Technology.TechPoint(EdgeH.makeCenter(), EdgeV.makeCenter()),
					});
			}
		}
		return super.getShapeOfNode(ni, electrical, reasonable, primLayers, layerOverride);
	}

	/**
	 * Returns a polygon that describes a particular port on a NodeInst.
	 * @param ni the NodeInst that has the port of interest.
	 * The prototype of this NodeInst must be a PrimitiveNode and not a Cell.
	 * @param pp the PrimitivePort on that NodeInst that is being described.
	 * @return a Poly object that describes this PrimitivePort graphically.
	 */
	public Poly getShapeOfPort(NodeInst ni, PrimitivePort pp, Point2D selectPt)
	{
		PrimitiveNode np = (PrimitiveNode)ni.getProto();
		if (np == pinNode || np == arrowNode || np == circleNode || np == thickCircleNode || np == filledCircleNode)
		{
			return super.getShapeOfPort(ni, pp, selectPt);
		}
		Poly [] polys = getShapeOfNode(ni);
		return polys[0];
	}

	/**
	 * Fill the polygons that describe arc "a".
	 * @param b AbstractShapeBuilder to fill polygons.
	 * @param a the ImmutableArcInst that is being described.
	 */
	@Override
	protected void getShapeOfArc(AbstractShapeBuilder b, ImmutableArcInst a) {
		getShapeOfArc(b, a, getProperLayer(a));
	}

	/**
	 * Tells if arc can be drawn by simplified algorithm
	 * Arcs with user-specified color or pattern are not easy
	 * @param a arc to test
	 * @param explain if true then print explanation why arc is not easy
	 * @return true if arc can be drawn by simplified algorithm
	 */
	@Override
	public boolean isEasyShape(ImmutableArcInst a, boolean explain) {
		if (a.getVar(Artwork.ART_COLOR) != null) {
			if (explain) System.out.println("ART_COLOR");
			return false;
		}
		if (a.getVar(Artwork.ART_PATTERN) != null) {
			if (explain) System.out.println("ART_PATTERN");
			return false;
		}
		return super.isEasyShape(a, explain);
	}

	/**
	 * Method to return an array of Point2D that describe an ellipse.
	 * @param center the center coordinate of the ellipse.
	 * @param sX the X size of the ellipse.
	 * @param sY the Y size of the ellipse.
	 * @param startoffset the starting angle of the ellipse, in radians.
	 * @param endangle the ending angle of the ellipse, in radians.
	 * If both startoffset and endangle are zero, draw the full ellipse.
	 * @return an array of points that describes the ellipse.
	 */
	public static Point2D [] fillEllipse(Point2D center, double sX, double sY, double startoffset, double endangle)
	{
		// ensure that the polygon can hold the vectors
		boolean closed = true;
		if (startoffset == 0 && endangle == 0)
		{
			// full ellipse
			endangle = Math.PI * 2.0;
		} else
		{
			// partial ellipse
			closed = false;
		}