getinfomulti.java

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

	{
        if (currentChangeTypes != null)
        {
            for(int c=0; c<currentChangeTypes.length; c++)
            {
                ChangeType change = currentChangeTypes[c];
                if (change == type) return ((JTextField)currentChangeValues[c]).getText().trim();
            }
        }
		return "";
	}

	private int findComponentIntValue(ChangeType type)
	{
        if (currentChangeTypes != null)
        {
            for(int c=0; c<currentChangeTypes.length; c++)
            {
                ChangeType change = currentChangeTypes[c];
                if (change == type) return ((JComboBox)currentChangeValues[c]).getSelectedIndex();
            }
        }
		return 0;
	}

	/**
	 * Class to hold the parameters for a multi-object change job.
	 */
	private static class MultiChangeParameters implements Serializable
	{
		private String xPos, yPos;
		private String xSize, ySize;
		private String rot;
		private int lr, ud;
		private int expanded;
		private int easySelect;
		private int invisOutside;
		private int locked;
		private String width;
		private int rigid, fixedangle, slidable;
		private int extension, directional, negated;
		private String characteristics;
		private int bodyOnly;
		private int alwaysDrawn;
		private String pointSize, unitSize;
		private String xOff, yOff;
		private int textRotation;
		private int anchor;
		private String font;
		private int color;
		private int bold, italic, underline;
		private CodeExpression.Code code;
		private int units;
		private int show;
	}

	/**
	 * This class implements database changes requested by the dialog.
	 */
	private static class MultiChange extends Job
	{
		private MultiChangeParameters mcp;
		private List<NodeInst> nodeList;
		private List<ArcInst> arcList;
		private List<Export> exportList;
		private List<DisplayedText> textList;
		private List<DisplayedText> annotationTextList;

		private MultiChange(
			MultiChangeParameters mcp, List<NodeInst> nodeList, List<ArcInst> arcList,
			List<Export> exportList, List<DisplayedText> textList, List<DisplayedText> annotationTextList)
		{
			super("Modify Objects", User.getUserTool(), Job.Type.CHANGE, null, null, Job.Priority.USER);
			this.mcp = mcp;
			this.nodeList = nodeList;
			this.arcList = arcList;
			this.exportList = exportList;
			this.textList = textList;
			this.annotationTextList = annotationTextList;
			startJob();
		}

		public boolean doIt() throws JobException
		{
			// change nodes
			int numNodes = nodeList.size();
			if (numNodes > 0)
			{
				// make other node changes
				boolean changes = false;
				for(NodeInst ni : nodeList)
				{
					if (ni.isCellInstance())
					{
						if (mcp.expanded == 1)
						{
							ni.setExpanded();
							changes = true;
						} else if (mcp.expanded == 2)
						{
							ni.clearExpanded();
							changes = true;
						}
					}
					if (mcp.easySelect == 1) ni.clearHardSelect(); else
						if (mcp.easySelect == 2) ni.setHardSelect();
					if (mcp.invisOutside == 1) ni.setVisInside(); else
						if (mcp.invisOutside == 2) ni.clearVisInside();
					if (mcp.locked == 1) ni.setLocked(); else
						if (mcp.locked == 2) ni.clearLocked();
				}

				// see if size, position, or orientation changed
				if (mcp.xPos.length() > 0 || mcp.yPos.length() > 0 || mcp.xSize.length() > 0 || mcp.ySize.length() > 0 ||
					mcp.rot.length() > 0 || mcp.lr != 0 || mcp.ud != 0 || changes)
				{
					// can do mass changes, but not orientation
					if (mcp.rot.length() == 0 && mcp.lr == 0 && mcp.ud == 0)
					{
						// change all nodes
						NodeInst [] nis = new NodeInst[numNodes];
						double [] dXP = new double[numNodes];
						double [] dYP = new double[numNodes];
						double [] dXS = new double[numNodes];
						double [] dYS = new double[numNodes];
						double newXPosition = TextUtils.atof(mcp.xPos);
						double newYPosition = TextUtils.atof(mcp.yPos);
						int i = 0;
						for(NodeInst ni : nodeList)
						{
							nis[i] = ni;
							if (mcp.xPos.length() == 0) dXP[i] = 0; else
								dXP[i] = newXPosition - ni.getAnchorCenterX();
							if (mcp.yPos.equals("")) dYP[i] = 0; else
								dYP[i] = newYPosition - ni.getAnchorCenterY();
							String newXSize = mcp.xSize;
							String newYSize = mcp.ySize;
					        if (ni.getAngle() == 900 || ni.getAngle() == 2700)
							{
								String swap = newXSize;   newXSize = newYSize;   newYSize = swap;
							}
							if (newXSize.equals("")) dXS[i] = 0; else
							{
								double baseXSize = TextUtils.atof(newXSize);
								dXS[i] = baseXSize - ni.getLambdaBaseXSize();
							}
							if (newYSize.equals("")) dYS[i] = 0; else
							{
								double baseYSize = TextUtils.atof(newYSize);
								dYS[i] = baseYSize - ni.getLambdaBaseYSize();
							}
							i++;
						}
						NodeInst.modifyInstances(nis, dXP, dYP, dXS, dYS);
					} else
					{
						for(NodeInst ni : nodeList)
						{
							double dX = 0, dY = 0, dXS = 0, dYS = 0;
							if (mcp.xPos.length() > 0) dX = TextUtils.atof(mcp.xPos) - ni.getAnchorCenterX();
							if (mcp.yPos.length() > 0) dY = TextUtils.atof(mcp.yPos) - ni.getAnchorCenterY();
							String newXSize = mcp.xSize;
							String newYSize = mcp.ySize;
					        if (ni.getAngle() == 900 || ni.getAngle() == 2700)
							{
								String swap = newXSize;   newXSize = newYSize;   newYSize = swap;
							}
							if (newXSize.length() > 0)
							{
								double baseXSize = TextUtils.atof(newXSize);
								dXS = baseXSize - ni.getLambdaBaseXSize();
							}
							if (newYSize.length() > 0)
							{
								double baseYSize = TextUtils.atof(newYSize);
								dYS = baseYSize - ni.getLambdaBaseYSize();
							}
							int dRot = 0;
							if (mcp.rot.length() > 0) dRot = ((int)(TextUtils.atof(mcp.rot)*10) - ni.getAngle() + 3600) % 3600;
							boolean dMirrorLR = false;
							if (mcp.lr == 1 && !ni.isXMirrored()) dMirrorLR = true; else
								if (mcp.lr == 2 && ni.isXMirrored()) dMirrorLR = true;
							boolean dMirrorUD = false;
							if (mcp.ud == 1 && !ni.isYMirrored()) dMirrorUD = true; else
								if (mcp.ud == 2 && ni.isYMirrored()) dMirrorUD = true;
			                Orientation orient = Orientation.fromJava(dRot, dMirrorLR, dMirrorUD);
							ni.modifyInstance(dX, dY, dXS, dYS, orient);
						}
					}
				}
			}

			if (arcList.size() > 0)
			{
				for(ArcInst ai : arcList)
				{
					if (mcp.width.length() > 0)
					{
						double newWidth = TextUtils.atof(mcp.width);
						ai.setLambdaBaseWidth(newWidth);
					}
					if (mcp.rigid == 1) ai.setRigid(true); else
						if (mcp.rigid == 2) ai.setRigid(false);
					if (mcp.fixedangle == 1) ai.setFixedAngle(true); else
						if (mcp.fixedangle == 2) ai.setFixedAngle(false);
					if (mcp.slidable == 1) ai.setSlidable(true); else
						if (mcp.slidable == 2) ai.setSlidable(false);
					switch (mcp.extension)
					{
						case 1: ai.setHeadExtended(true);    ai.setTailExtended(true);    break;
						case 2: ai.setHeadExtended(false);   ai.setTailExtended(false);   break;
						case 3: ai.setHeadExtended(true);    ai.setTailExtended(false);   break;
						case 4: ai.setHeadExtended(false);   ai.setTailExtended(true);    break;
					}
					switch (mcp.directional)
					{
						case 1: ai.setHeadArrowed(false);   ai.setTailArrowed(false);   ai.setBodyArrowed(false);   break;
						case 2: ai.setHeadArrowed(true);    ai.setTailArrowed(false);	ai.setBodyArrowed(true);    break;
						case 3: ai.setHeadArrowed(false);   ai.setTailArrowed(true);	ai.setBodyArrowed(true);    break;
						case 4: ai.setHeadArrowed(false);   ai.setTailArrowed(false);	ai.setBodyArrowed(true);    break;
						case 5: ai.setHeadArrowed(true);    ai.setTailArrowed(true);	ai.setBodyArrowed(true);    break;
					}
					switch (mcp.negated)
					{
						case 1: ai.setHeadNegated(false);   ai.setTailNegated(false);   break;
						case 2: ai.setHeadNegated(true);    ai.setTailNegated(false);   break;
						case 3: ai.setHeadNegated(false);   ai.setTailNegated(true);    break;
						case 4: ai.setHeadNegated(true);    ai.setTailNegated(true);    break;
					}
					if (mcp.easySelect == 1) ai.setHardSelect(false); else
						if (mcp.easySelect == 2) ai.setHardSelect(true);
				}
			}

			if (exportList.size() > 0)
			{
				for(Export e : exportList)
				{
					if (mcp.characteristics != null)
					{
						PortCharacteristic ch = PortCharacteristic.findCharacteristic(mcp.characteristics);
                        if (ch != null) // Set only when the characteristic is different frmo leave alone
                            e.setCharacteristic(ch);
					}
					if (mcp.bodyOnly == 1) e.setBodyOnly(true); else
						if (mcp.bodyOnly == 2) e.setBodyOnly(false);
					if (mcp.alwaysDrawn == 1) e.setAlwaysDrawn(true); else
						if (mcp.alwaysDrawn == 2) e.setAlwaysDrawn(false);

					MutableTextDescriptor td = e.getMutableTextDescriptor(Export.EXPORT_NAME);
					boolean tdChanged = false;
					if (mcp.pointSize.length() > 0)
					{
						td.setAbsSize(TextUtils.atoi(mcp.pointSize));
						tdChanged = true;
					}
					if (mcp.unitSize.length() > 0)
					{
						td.setRelSize(TextUtils.atof(mcp.unitSize));
						tdChanged = true;
					}
					if (mcp.xOff.length() > 0)
					{
						td.setOff(TextUtils.atof(mcp.xOff), td.getYOff());
						tdChanged = true;
					}
					if (mcp.yOff.length() > 0)
					{
						td.setOff(td.getXOff(), TextUtils.atof(mcp.yOff));
						tdChanged = true;
					}
					if (mcp.textRotation > 0)
					{
						switch (mcp.textRotation)
						{
							case 1: td.setRotation(TextDescriptor.Rotation.ROT0);     break;
							case 2: td.setRotation(TextDescriptor.Rotation.ROT90);    break;
							case 3: td.setRotation(TextDescriptor.Rotation.ROT180);   break;
							case 4: td.setRotation(TextDescriptor.Rotation.ROT270);   break;
						}
						tdChanged = true;
					}
					if (mcp.anchor >= 0)
					{
				        TextDescriptor.Position newPosition = TextDescriptor.Position.getPositionAt(mcp.anchor);
						td.setPos(newPosition);
						tdChanged = true;
					}
					if (mcp.font != null)
					{
                        td.setFaceWithActiveFont(mcp.font);
						tdChanged = true;
					}
					if (mcp.color > 0)
					{
                        td.setColorWithEGraphicsIndex(mcp.color-1); // -1 because of DEFAULT COLOR
						tdChanged = true;
					}
					if (mcp.bold == 1) { td.setBold(true);   tdChanged = true; } else
						if (mcp.bold == 2) { td.setBold(false);   tdChanged = true; }
					if (mcp.italic == 1) { td.setItalic(true);   tdChanged = true; } else
						if (mcp.italic == 2) { td.setItalic(false);   tdChanged = true; }
					if (mcp.underline == 1) { td.setUnderline(true);   tdChanged = true; } else
						if (mcp.underline == 2) { td.setUnderline(false);   tdChanged = true; }
					if (mcp.invisOutside == 1) { td.setInterior(true);   tdChanged = true; } else
						if (mcp.invisOutside == 2) { td.setInterior(false);   tdChanged = true; }

					// update text descriptor if it changed
					if (tdChanged)
						e.setTextDescriptor(Export.EXPORT_NAME, TextDescriptor.newTextDescriptor(td));
				}
			}

			if (textList.size() > 0)
			{
				processTextList(textList, false);
			}
			if (annotationTextList.size() > 0)
			{
				processTextList(annotationTextList, true);
			}
			return true;
		}

		private void processTextList(List<DisplayedText> textList, boolean annotation)
		{
			for(DisplayedText dt : textList)
			{
				ElectricObject eobj = dt.getElectricObject();
				Variable.Key descKey = dt.getVariableKey();
				if (mcp.code != null)
				{
	                if (eobj.isParam(descKey))
	                {
	                    if (eobj instanceof Cell)
	                    {
	                        Cell cell = (Cell)eobj;
	                        cell.getCellGroup().updateParam((Variable.AttrKey)descKey,
	                        	cell.getParameter(descKey).withCode(mcp.code).getObject());
	                    } else if (eobj instanceof NodeInst)
	                    {
	                        NodeInst ni = (NodeInst)eobj;
	                        ni.addParameter(ni.getParameter(descKey).withCode(mcp.code));
	                    }
	                } else
	                {
	                    eobj.updateVarCode(descKey, mcp.code);
	                }
	            }
				MutableTextDescriptor td = eobj.getMutableTextDescriptor(descKey);

				boolean tdChanged = false;
				if (mcp.pointSize.length() > 0)
				{
					td.setAbsSize(TextUtils.atoi(mcp.pointSize));
					tdChanged = true;
				}
				if (mcp.unitSize.length() > 0)
				{
					td.setRelSize(TextUtils.atof(mcp.unitSize));
					tdChanged = true;
				}
				if (annotation)
				{
					if (eobj instanceof NodeInst)
					{
						NodeInst ni = (NodeInst)eobj;
						double dX = 0, dY = 0;
						if (mcp.xPos.length() > 0) dX = TextUtils.atof(mcp.xPos) - ni.getAnchorCenterX();
						if (mcp.yPos.length() > 0) dY = TextUtils.atof(mcp.yPos) - ni.getAnchorCenterY();
						ni.modifyInstance(dX, dY, 0, 0, Orientation.IDENT);
					}
				} else
				{
					if (mcp.xOff.length() > 0)
					{
						td.setOff(TextUtils.atof(mcp.xOff), td.getYOff());
						tdChanged = true;
					}