arcinfo.java

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

/* -*- tab-width: 4 -*-
 *
 * Electric(tm) VLSI Design System
 *
 * File: ArcInfo.java
 * Technology Editor, arc information
 * Written by Steven M. Rubin, Sun Microsystems.
 *
 * Copyright (c) 2005 Sun Microsystems and Static Free Software
 *
 * Electric(tm) is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Electric(tm) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Electric(tm); see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, Mass 02111-1307, USA.
 */
package com.sun.electric.tool.user.tecEdit;

import com.sun.electric.database.geometry.Poly;
import com.sun.electric.database.hierarchy.Cell;
import com.sun.electric.database.hierarchy.Library;
import com.sun.electric.technology.ArcProto;
import com.sun.electric.database.text.TextUtils;
import com.sun.electric.database.topology.NodeInst;
import com.sun.electric.database.variable.Variable;
import com.sun.electric.technology.technologies.Generic;

import java.awt.geom.Rectangle2D;
import java.util.Iterator;
import java.util.List;

/**
 * This class defines information about arcs in the Technology Editor.
 */
public class ArcInfo extends Info
{
	static class LayerDetails
	{
		LayerInfo layer;
		double    width;
		Poly.Type style;
	}

	/** the name of the arc */					String name;
	/** the name of the arc in Java code */		String javaName;
	/** the arc Function */						ArcProto.Function func;
	/** true for fixed-angle arcs */			boolean fixAng;
	/** true if arcs wipe pins */				boolean wipes;
	/** true if arcs don't extend endpoints */	boolean noExtend;
    /** true if arc is curvable */              boolean curvable;
    /** true if arc is special */               boolean special;
    /** true if arc not used */                 boolean notUsed;
    /** true if arc size doesn't grow palette */boolean skipSizeInPalette; 
    /** true if arc is slidable */              boolean slidable;
	/** the arc angle increment */				int angInc;
	/** the maximum antenna ratio */			double antennaRatio;
	/** the width offset to the highlight */	double widthOffset;
	/** the ArcProto in the Technology */		ArcProto generated;
	/** layers in the arc */					LayerDetails [] arcDetails;

	private static SpecialTextDescr [] arcTextTable =
	{
		new SpecialTextDescr(0, 21, ARCFUNCTION),
		new SpecialTextDescr(0, 18, ARCFIXANG),
		new SpecialTextDescr(0, 15, ARCWIPESPINS),
		new SpecialTextDescr(0, 12, ARCNOEXTEND),
		new SpecialTextDescr(0,  9, ARCINC),
		new SpecialTextDescr(0,  6, ARCANTENNARATIO),
        new SpecialTextDescr(0,  3, ARCWIDTHOFFSET),
	};

	ArcInfo()
	{
		func = ArcProto.Function.UNKNOWN;
	}

	/**
	 * Method to return an array of cells that comprise the arcs in a technology library.
	 * @param lib the technology library.
	 * @return an array of cells for each arc (in the proper order).
	 */
	public static Cell [] getArcCells(Library lib)
	{
		Library [] oneLib = new Library[1];
		oneLib[0] = lib;
		return findCellSequence(oneLib, "arc-", ARCSEQUENCE_KEY);
	}

	/**
	 * Method to build the appropriate descriptive information for an arc into
	 * cell "np".  The function is in "func"; the arc is fixed-angle if "fixang"
	 * is nonzero; the arc wipes pins if "wipes" is nonzero; and the arc does
	 * not extend its ends if "noextend" is nonzero.  The angle increment is
	 * in "anginc".
	 */
	void generate(Cell np)
	{
		// load up the structure with the current values
		loadTableEntry(arcTextTable, ARCFUNCTION, func);
		loadTableEntry(arcTextTable, ARCFIXANG, Boolean.valueOf(fixAng));
		loadTableEntry(arcTextTable, ARCWIPESPINS, Boolean.valueOf(wipes));
		loadTableEntry(arcTextTable, ARCNOEXTEND, Boolean.valueOf(noExtend));
		loadTableEntry(arcTextTable, ARCINC, new Integer(angInc));
		loadTableEntry(arcTextTable, ARCANTENNARATIO, new Double(antennaRatio));
		loadTableEntry(arcTextTable, ARCWIDTHOFFSET, new Double(widthOffset));

		// now create those text objects
		createSpecialText(np, arcTextTable);
	}

	/**
	 * Method to parse the arc cell in "np" and return an ArcInfo object that describes it.
	 */
	static ArcInfo parseCell(Cell np)
	{
		// create and initialize the GRAPHICS structure
		ArcInfo aIn = new ArcInfo();
		aIn.name = np.getName().substring(4);

		// look at all nodes in the arc description cell
		for(Iterator<NodeInst> it = np.getNodes(); it.hasNext(); )
		{
			NodeInst ni = it.next();
			Variable var = ni.getVar(OPTION_KEY);
			if (var == null) continue;
			String str = getValueOnNode(ni);

			switch (((Integer)var.getObject()).intValue())
			{
				case ARCFUNCTION:
					aIn.func = ArcProto.Function.UNKNOWN;
					List<ArcProto.Function> allFuncs = ArcProto.Function.getFunctions();
					for(ArcProto.Function fun : allFuncs)
					{
						if (fun.toString().equalsIgnoreCase(str))
						{
							aIn.func = fun;
							break;
						}
					}
					break;
				case ARCINC:
					aIn.angInc = TextUtils.atoi(str);
					break;
				case ARCFIXANG:
					aIn.fixAng = str.equalsIgnoreCase("yes");
					break;
				case ARCWIPESPINS:
					aIn.wipes = str.equalsIgnoreCase("yes");
					break;
				case ARCNOEXTEND:
					aIn.noExtend = str.equalsIgnoreCase("no");
					break;
				case ARCANTENNARATIO:
					aIn.antennaRatio = TextUtils.atof(str);
					break;
				case ARCWIDTHOFFSET:
					aIn.widthOffset = TextUtils.atof(str);
					break;
			}
		}
		return aIn;
	}

	/**
	 * Method to compact an Arc technology-edit cell
	 */
	static void compactCell(Cell cell)
	{
		// compute bounds of arc contents
		Rectangle2D nonSpecBounds = null;
		for(Iterator<NodeInst> it = cell.getNodes(); it.hasNext(); )
		{
			NodeInst ni = it.next();
			if (ni.getProto() == Generic.tech().cellCenterNode) continue;

			// ignore the special text nodes
			boolean special = false;
			for(int i=0; i<arcTextTable.length; i++)
				if (arcTextTable[i].ni == ni) special = true;
			if (special) continue;

			// compute overall bounds
			Rectangle2D bounds = ni.getBounds();
			if (nonSpecBounds == null) nonSpecBounds = bounds; else
				Rectangle2D.union(nonSpecBounds, bounds, nonSpecBounds);
		}

		// now rearrange the geometry
		if (nonSpecBounds != null)
		{
			double xOff = -nonSpecBounds.getCenterX();
			double yOff = -nonSpecBounds.getMaxY();
			if (xOff != 0 || yOff != 0)
			{
				for(Iterator<NodeInst> it = cell.getNodes(); it.hasNext(); )
				{
					NodeInst ni = it.next();
					if (ni.getProto() == Generic.tech().cellCenterNode) continue;

					// ignore the special text nodes
					boolean special = false;
					for(int i=0; i<arcTextTable.length; i++)
						if (arcTextTable[i].ni == ni) special = true;
					if (special) continue;

					// center the geometry
					ni.move(xOff, yOff);
				}
			}
		}
	}
}