panel.java

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

			gbc = new GridBagConstraints();
			gbc.gridx = 0;       gbc.gridy = 3;
			gbc.gridwidth = 5;   gbc.gridheight = 1;
			gbc.weightx = 1;     gbc.weighty = 1;
			gbc.anchor = GridBagConstraints.CENTER;
			gbc.fill = GridBagConstraints.BOTH;
			leftHalf.add(signalButtonsPane, gbc);
		}

		// the right side with signal traces
		rightHalf = new JPanel();
		rightHalf.setLayout(new GridBagLayout());
		rightHalf.setPreferredSize(new Dimension(100, height));

		// a drop target for the signal panel
		new DropTarget(this, DnDConstants.ACTION_LINK, WaveformWindow.waveformDropTarget, true);

		// a separator at the top
		sep = new JSeparator(SwingConstants.HORIZONTAL);
		gbc = new GridBagConstraints();
		gbc.gridx = 0;       gbc.gridy = 0;
		gbc.weightx = 1;     gbc.weighty = 0;
		gbc.anchor = GridBagConstraints.NORTH;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbc.insets = new Insets(4, 0, 4, 0);
		rightHalf.add(sep, gbc);

		// the horizontal ruler (if separate rulers in each panel)
		if (!waveWindow.isXAxisLocked())
			addHorizRulerPanel();

		// the waveform display for this panel
		gbc = new GridBagConstraints();
		gbc.gridx = 0;       gbc.gridy = 2;
		gbc.weightx = 1;     gbc.weighty = 1;
		gbc.anchor = GridBagConstraints.CENTER;
		gbc.fill = GridBagConstraints.BOTH;
		gbc.insets = new Insets(0, 0, 0, 0);
		rightHalf.add(this, gbc);

		// add to list of wave panels
		waveWindow.addPanel(this);

		// put the left and right sides into the window
		if (WaveformWindow.USETABLES)
		{
			waveWindow.getWaveformTable().repaint();
			waveWindow.getWaveformTable().doLayout();
			waveWindow.getWaveformTable().updateUI();
		} else
		{
			waveWindow.getSignalNamesPanel().add(leftHalf);
			waveWindow.getSignalTracesPanel().add(rightHalf);
		}

		// rebuild list of panels
		waveWindow.rebuildPanelList();
		waveWindow.redrawAllPanels();
	}

	// ************************************* MISCELLANEOUS *************************************

	public WaveformWindow getWaveWindow() { return waveWindow; }

	/**
	 * Method to get rid of this Panel.
	 */
	public void finished()
	{
		// remove myself from listener list
		removeKeyListener(this);
		removeMouseListener(this);
		removeMouseMotionListener(this);
		removeMouseWheelListener(this);
	}

	public JPanel getLeftHalf() { return leftHalf; }

	public JPanel getRightHalf() { return rightHalf; }

	/**
	 * Make this panel show a linear Y axis.
	 */
	private void makeLinear() { setPanelLogarithmicVertically(false); }

	/**
	 * Make this panel show a logarithmic Y axis.
	 */
	private void makeLogarithmic() { setPanelLogarithmicVertically(true); }

	public void setPanelLogarithmicVertically(boolean logarithmic)
	{
		vertPanelLogarithmic = logarithmic;
		repaintContents();
	}

	public boolean isAnalog() { return analog; }

	public Analysis.AnalysisType getAnalysisType() { return analysisType; };

	public void setAnalysisType(Analysis.AnalysisType a)
	{
		analysisType = a;
		computeSmallestValues();
	}

	/**
	 * Method to ensure that a signal can be shown in this panel.
	 * Displays an error if not.
	 * @param sSig the signal being tested.
	 * @return true if the signal is wrong and cannot appear in this panel.
	 */
	public boolean wrongPanelType(Signal sSig)
	{
		if (sSig.getAnalysis().getAnalysisType() == getAnalysisType()) return false;
		JOptionPane.showMessageDialog(TopLevel.getCurrentJFrame(),
			"Cannot drop a " + sSig.getAnalysis().getAnalysisType() + " signal onto a " + getAnalysisType() + " panel.  " +
			"First convert the panel with the popup in the upper-left.",
			"Error Displaying Signals", JOptionPane.ERROR_MESSAGE);
		return true;
	}

	public JPanel getSignalButtons() { return signalButtons; };

	public JScrollPane getSignalButtonsPane() { return signalButtonsPane; };

	public JButton getDigitalSignalButton() { return digitalSignalButton; }

	public int getPanelNumber() { return panelNumber; }

	public void setPanelLogarithmicHorizontally(boolean logarithmic)
	{
		horizRulerPanelLogarithmic = logarithmic;
		horizRulerPanel.repaint();
	}

	public boolean isPanelLogarithmicHorizontally()
	{
		if (waveWindow.isXAxisLocked()) return waveWindow.isWaveWindowLogarithmic();
		return horizRulerPanelLogarithmic;
	}

	public boolean isPanelLogarithmicVertically() { return vertPanelLogarithmic; }

	public int getVertAxisPos() { return vertAxisPos; }

	public void setVertAxisPos(int x) { vertAxisPos = x; }

	public static Panel getCurrentPanel() { return curPanel; }

	public static int getCurrentXPos() { return curXPos; }

	// ************************************* SIGNALS IN THE PANEL *************************************

	public void addSignal(WaveSignal sig, JButton but)
	{
		waveSignals.put(but, sig);
	}

	public void removeSignal(JButton but)
	{
		if (signalButtons != null) signalButtons.remove(but);
		waveSignals.remove(but);
	}

	public void removeAllSignals()
	{
		waveSignals.clear();
	}

	/**
	 * Method to return a List of WaveSignals in this panel.
	 * @return a List of WaveSignals in this panel.
	 */
	public List<WaveSignal> getSignals()
	{
		List<WaveSignal> signals = new ArrayList<WaveSignal>();
		for(JButton but : waveSignals.keySet())
		{
			WaveSignal ws = waveSignals.get(but);
			signals.add(ws);
		}
		return signals;
	}

	public int getNumSignals() { return waveSignals.size(); }

	public WaveSignal findWaveSignal(Signal sig)
	{
		for(JButton but : waveSignals.keySet())
		{
			WaveSignal ws = waveSignals.get(but);
			if (ws.getSignal() == sig) return ws;
		}
		return null;
	}

	public WaveSignal findWaveSignal(JButton but)
	{
		WaveSignal sig = waveSignals.get(but);
		return sig;
	}

	public JButton findButton(WaveSignal ws)
	{
		for(JButton but : waveSignals.keySet())
		{
			WaveSignal oWs = waveSignals.get(but);
			if (oWs == ws) return but;
		}
		return null;
	}

	private void deleteSignalFromPanel()
	{
		waveWindow.deleteSignalFromPanel(this);
	}

	private void deleteAllSignalsFromPanel()
	{
		waveWindow.deleteAllSignalsFromPanel(this);
	}

	private void setPanelSignalType()
	{
		String typeName = (String)analysisCombo.getSelectedItem();
		Analysis.AnalysisType analysisType = Analysis.AnalysisType.findAnalysisType(typeName);
		if (getAnalysisType() != analysisType && getNumSignals() > 0)
		{
			String warning = "The signals in this panel are not " + analysisType +
				" data.  Remove them from the panel?";
			int response = JOptionPane.showConfirmDialog(TopLevel.getCurrentJFrame(), warning);
			if (response != JOptionPane.YES_OPTION)
			{
				// aborted: reset panel type
				analysisCombo.setSelectedItem(getAnalysisType().toString());
				return;
			}
			xAxisSignal = null;
			if (waveWindow.isXAxisLocked()) waveWindow.setXAxisSignalAll(null);
			waveWindow.deleteAllSignalsFromPanel(this);
		}
		setAnalysisType(analysisType);

		// redo X scale if time unlocked or this is the only panel
		Analysis an = waveWindow.getSimData().findAnalysis(analysisType);
		if (an != null)
		{
			Rectangle2D bounds = an.getBounds();
			double lowValue = bounds.getMinY();
			double highValue = bounds.getMaxY();
			setYAxisRange(lowValue, highValue);
			if (!waveWindow.isXAxisLocked() || waveWindow.getNumPanels() == 1)
			{
				// set the X range
				setXAxisRange(an.getLeftEdge(), an.getRightEdge());
			}
		}

		repaintWithRulers();
	}

	// ************************************* THE HORIZONTAL RULER *************************************

	public void addHorizRulerPanel()
	{
		horizRulerPanel = new HorizRuler(this, waveWindow);
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.gridx = 0;       gbc.gridy = 1;
		gbc.gridwidth = 1;   gbc.gridheight = 1;
		gbc.weightx = 1;     gbc.weighty = 0;
		gbc.anchor = GridBagConstraints.CENTER;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbc.insets = new Insets(0, 0, 0, 0);
		rightHalf.add(horizRulerPanel, gbc);
	}

	public void removeHorizRulerPanel()
	{
		rightHalf.remove(horizRulerPanel);
		horizRulerPanel = null;
	}

	public HorizRuler getHorizRuler() { return horizRulerPanel; }

	public Signal getXAxisSignal() { return xAxisSignal; }

	public void setXAxisSignal(Signal sig) { xAxisSignal = sig; }

	// ************************************* PANEL DISPLAY CONTROL *************************************

	public void hidePanel()
	{
		waveWindow.hidePanel(this);
	}

	public void closePanel()
	{
		waveWindow.closePanel(this);
		waveWindow.saveSignalOrder();
	}

	private void toggleBusContents()
	{
		// this panel must have one signal
		Collection<WaveSignal> theSignals = waveSignals.values();
		if (theSignals.size() != 1) return;

		// the only signal must be digital
		WaveSignal ws = theSignals.iterator().next();
		if (!(ws.getSignal() instanceof DigitalSignal)) return;

		// the digital signal must be a bus
		DigitalSignal sDSig = (DigitalSignal)ws.getSignal();
		List<DigitalSignal> bussedSignals = sDSig.getBussedSignals();
		if (bussedSignals == null) return;

		// see if any of the bussed signals are displayed
		boolean opened = false;
		for(Signal subSig : bussedSignals)
		{
			DigitalSignal subDS = (DigitalSignal)subSig;
			WaveSignal subWs = waveWindow.findDisplayedSignal(subDS);
			if (subWs != null)
			{
				opened = true;
				break;
			}
		}

		// now open or close the bus
		if (opened)
		{
			// opened: remove all entries on the bus
			List<Panel> allPanels = new ArrayList<Panel>();
			for(Iterator<Panel> it = waveWindow.getPanels(); it.hasNext(); )
				allPanels.add(it.next());

			for(Signal subSig : bussedSignals)
			{
				DigitalSignal subDS = (DigitalSignal)subSig;
				WaveSignal subWs = waveWindow.findDisplayedSignal(subDS);
				if (subWs != null)
				{
					Panel wp = subWs.getPanel();
					waveWindow.closePanel(wp);
					allPanels.remove(wp);
				}
			}
		} else
		{
			// closed: add all entries on the bus
			int increment = 1;
			if (WaveformWindow.USETABLES)
			{
				waveWindow.stopEditing();
			}
			for(Signal subSig : bussedSignals)
			{
				DigitalSignal subDS = (DigitalSignal)subSig;
				Panel wp = waveWindow.makeNewPanel(null);
				WaveSignal wsig = new WaveSignal(wp, subDS);

				if (WaveformWindow.USETABLES)
				{
					// remove the panels and put them in the right place
					waveWindow.removePanel(wsig.getPanel());

					int destIndex = waveWindow.getPanelIndex(this);
					waveWindow.addPanel(wsig.getPanel(), destIndex+increment);
				} else