manipulateexports.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: ManipulateExports.java
 *
 * Copyright (c) 2008 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.dialogs;

import com.sun.electric.database.hierarchy.Cell;
import com.sun.electric.database.hierarchy.Export;
import com.sun.electric.database.text.TextUtils;
import com.sun.electric.database.variable.EditWindow_;
import com.sun.electric.database.variable.UserInterface;
import com.sun.electric.technology.ArcProto;
import com.sun.electric.technology.technologies.Generic;
import com.sun.electric.tool.Job;
import com.sun.electric.tool.user.ExportChanges;
import com.sun.electric.tool.user.ui.TopLevel;
import com.sun.electric.tool.user.ui.WindowFrame;

import java.awt.Frame;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;

/**
 * Class to handle the "Manipulate Exports" dialog.
 */
public class ManipulateExports extends EDialog
{
	private static final String [] columnNames = {" ", "Name", "Layer", "Characteristic", "Body Only"};

	private class ExportsTable extends JTable
	{
		private ExportTableModel model;

		/**
		 * Constructor for ExportsTable
		 */
		public ExportsTable(Cell cell)
		{
			model = new ExportTableModel(cell);
			for(Iterator<Export> it = cell.getExports(); it.hasNext(); )
			{
				Export e = it.next();
				model.newVar(e);
			}
			model.sortTable(1, true);
			setModel(model);
			TableColumn tc = getColumn(getColumnName(0));
			if (tc != null) tc.setPreferredWidth(10);
			tc = getColumn(getColumnName(1));
			if (tc != null) tc.setPreferredWidth(120);
			tc = getColumn(getColumnName(2));
			if (tc != null) tc.setPreferredWidth(100);
			tc = getColumn(getColumnName(3));
			if (tc != null) tc.setPreferredWidth(80);
			tc = getColumn(getColumnName(4));
			if (tc != null) tc.setPreferredWidth(20);
		}

		public void toggleSelection()
		{
			int [] rows = getSelectedRows();
			for(int i=0; i<rows.length; i++)
			{
				Boolean b = (Boolean)model.getValueAt(rows[i], 0);
				model.setValueAt(Boolean.valueOf(!b.booleanValue()), rows[i], 0);
			}
		}

		public ExportTableModel getModel() { return model; }

		public void selectAll() { model.selectAll(); }

		public void deselectAll() { model.deselectAll(); }

		public void renumberSelectedExports() { model.renumberSelectedExports(); }

		public void unExportSelected() { model.unExportSelected(); }

		public void showSelected() { model.showSelected(); }
	}

	/**
	 * Model for storing Table data
	 */
	private class ExportTableModel extends AbstractTableModel
	{
		private Cell cell;
		private List<ExportEntry> exports;

		private class ExportEntry
		{
			private boolean selected;
			private Export e;

			private ExportEntry(Export e) { this.e = e; }

			private Export getExport() { return e; }

			private boolean isSelected() { return selected; }

			private void setSelected(boolean s) { selected = s; }
		}

		/**
		 * Class to sort exports.
		 */
		public class ExportEntrySort implements Comparator<ExportEntry>
		{
			private int column;
			private boolean ascending;

			ExportEntrySort(int column, boolean ascending)
			{
				this.column = column;
				this.ascending = ascending;
			}

			public int compare(ExportEntry p1, ExportEntry p2)
			{
				if (!ascending)
				{
					ExportEntry swap = p1;
					p1 = p2;
					p2 = swap;
				}
				String s1 = null, s2 = null;
				switch (column)
				{
					case 0:		// selection
						boolean b1 = p1.isSelected();
						boolean b2 = p2.isSelected();
						if (b1 == b2) return 0;
						if (b1) return 1;
						return -1;
					case 1:		// name
						s1 = p1.getExport().getName();
						s2 = p2.getExport().getName();
						break;
					case 2:		// layer
						s1 = getLayer(p1.getExport());
						s2 = getLayer(p2.getExport());
						break;
					case 3:		// characteristics
						s1 = p1.getExport().getCharacteristic().getName();
						s2 = p2.getExport().getCharacteristic().getName();
						return s1.compareTo(s2);
					case 4:		// body-only
						b1 = p1.getExport().isBodyOnly();
						b2 = p2.getExport().isBodyOnly();
						if (b1 == b2) return 0;
						if (b1) return 1;
						return -1;
				}
				return TextUtils.STRING_NUMBER_ORDER.compare(s1, s2);
			}
		}

		// constructor
		private ExportTableModel(Cell cell)
		{
			this.cell = cell;
			exports = new ArrayList<ExportEntry>();
		}

		/**
		 * Create a new var with default properties
		 */
		public void newVar(Export e)
		{
			ExportEntry ve = new ExportEntry(e);
			exports.add(ve);
		}

		public void sortTable(int column, boolean ascending)
		{
			Collections.sort(exports, new ExportEntrySort(column, ascending));
			fireTableDataChanged();
		}

		public void selectAll()
		{
			int i = 0;
			for(ExportEntry pe : exports)
			{
				pe.setSelected(true);
				fireTableCellUpdated(i++, 0);
			}
		}

		public void deselectAll()
		{
			int i = 0;
			for(ExportEntry pe : exports)
			{
				pe.setSelected(false);
				fireTableCellUpdated(i++, 0);
			}
		}

		public void renumberSelectedExports()
		{
			List<Export> queuedExports = new ArrayList<Export>();
			for(ExportEntry pe : exports)
			{
				if (!pe.isSelected()) continue;
				queuedExports.add(pe.getExport());
			}
			new ExportChanges.RenumberNumericExports(queuedExports);
		}

		public void unExportSelected()
		{
			List<Export> queuedExports = new ArrayList<Export>();
			for(ExportEntry pe : exports)
			{
				if (!pe.isSelected()) continue;
				queuedExports.add(pe.getExport());
			}
			ExportChanges.deleteExports(cell, queuedExports);
		}

		public void showSelected()
		{
			UserInterface ui = Job.getUserInterface();
			EditWindow_ wnd = ui.getCurrentEditWindow_();
			if (wnd == null) return;
			wnd.clearHighlighting();
			for(ExportEntry pe : exports)
			{
				if (!pe.isSelected()) continue;
				wnd.addHighlightText(pe.getExport(), cell, Export.EXPORT_NAME);
			}
			wnd.finishedHighlighting();
		}

		/** Method to get the number of columns. */
		public int getColumnCount() { return 5; }

		/** Method to get the number of rows. */
		public int getRowCount() { return exports.size(); }

		/** Method to get a location in the table. */
		public Object getValueAt(int rowIndex, int columnIndex) {

			ExportEntry pe = exports.get(rowIndex);
			if (pe == null) return null;

			switch (columnIndex)
			{
				// selected
				case 0: return Boolean.valueOf(pe.isSelected());

				// name
				case 1: return pe.getExport().getName();

				// layer
				case 2:
					return getLayer(pe.getExport());

				// characteristic
				case 3: return pe.getExport().getCharacteristic().getName();

				// body-only
				case 4: return Boolean.valueOf(pe.getExport().isBodyOnly());
			}
			return null;
		}

		/**
		 * Convert an Export to the layers on it.
		 * @param e the Export.
		 * @return the name of the layer on the export.
		 */
		private String getLayer(Export e)
		{
			ArcProto [] arcs = e.getBasePort().getConnections();
			String layers = "";
			ArcProto firstGeneric = null;
			for(int i=0; i<arcs.length; i++)