datapane.java

ALGAE是一个快速创建算法演示的框架。目前支持的算法实现语言包括java和c

package edu.odu.cs.zeil.AlgAE.Client.DataViewer;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Event;
import java.awt.Font;
import java.awt.Label;
import java.awt.Panel;

import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.KeyEvent;

import java.util.Vector;

import edu.odu.cs.zeil.AlgAE.Debug;
import edu.odu.cs.zeil.AlgAE.Direction;

import edu.odu.cs.zeil.AlgAE.Client.DataViewer.EdgeSet;
import edu.odu.cs.zeil.AlgAE.Client.DataViewer.NodeDirSet;


import edu.odu.cs.zeil.AlgAE.Application;
import edu.odu.cs.zeil.AlgAE.Message;
import edu.odu.cs.zeil.AlgAE.Messages;
import edu.odu.cs.zeil.AlgAE.MessageListener;

import edu.odu.cs.zeil.AlgAE.Client.GraphicsInfo;
import edu.odu.cs.zeil.AlgAE.Client.DataViewer.DataCanvas;
import edu.odu.cs.zeil.AlgAE.Client.DataViewer.DataGraph.Edge;
import edu.odu.cs.zeil.AlgAE.Client.DataViewer.DataGraph.Graph;
import edu.odu.cs.zeil.AlgAE.Client.DataViewer.DataGraph.Node;

import edu.odu.cs.zeil.AlgAE.Client.MessageDispatcher;


public class DataPane extends Panel implements FocusListener
{
  private Label status;
  private DataCanvas canvas;
  private MessageDispatcher dispatcher;
   
  public DataPane(Application appl, MessageDispatcher mdispatcher)
  {
    dispatcher = mdispatcher;

    setLayout(new BorderLayout());

    canvas = new DataCanvas(this, dispatcher);
    add ("Center", canvas);

    status = new Label("AlgAE");
    status.setBackground (Color.lightGray);
    add ("South", status);

    canvas.setIncrementSteps (5);

    appl.msgs.node.addMessageListener (new MessageListener()
      {
	public void messageReceived (String kind, Vector params)
	  {
	    try {
	      String nodeId = params.elementAt(0).toString();
	      Node n = findNode (nodeId);
	      String text = params.elementAt(1).toString();
	      if (params.size() > 2)
		{
		  int vertical = ((Integer)params.elementAt(2)).intValue();
		  int red = ((Integer)params.elementAt(3)).intValue();
		  int green = ((Integer)params.elementAt(4)).intValue();
		  int blue = ((Integer)params.elementAt(5)).intValue();
		  Color color = new Color (red, green, blue);
		  n.setVertical (vertical == 1);
		  n.setColor (color);
		}
	      n.setText (text);
	    }
	    catch (ClassCastException e) {
	      Debug.error ("Internal Error\nIllegal parameter in NODE msg:\n"
				  + e.getMessage());
	    }
	  }
      });
				  
    appl.msgs.edge.addMessageListener (new MessageListener()
      {
	public void messageReceived (String kind, Vector params)
	  {
	    try {
	      String sourceID = params.elementAt(0).toString();
	      String destID = params.elementAt(1).toString();
	      int direction = ((Integer)params.elementAt(2)).intValue();

	      int red = ((Integer)params.elementAt(3)).intValue();
	      int green = ((Integer)params.elementAt(4)).intValue();
	      int blue = ((Integer)params.elementAt(5)).intValue();
	      Color color = new Color (red, green, blue);

	      String text        = (String) params.elementAt(6);

	      Node source = findNode (sourceID);
	      Node dest = findNode (destID);
	      
	      if (direction < Direction.N || direction > Direction.NNW) {
		direction = Direction.ANYDIR;
	      }
	      
	      Edge e = source.addEdge (dest, direction, color, text);
	    }
	    catch (ClassCastException e) {
	      Debug.error ("Internal Error\nIllegal parameter in EDGE msg:\n"
			   + params);
	    }
	  }
      });
				  
    appl.msgs.component.addMessageListener (new MessageListener()
      {
	public void messageReceived (String kind, Vector params)
	  {
	    try {

	      String containerID = params.elementAt(0).toString();
	      Node container = findNode (containerID);

	      for (int i = 1; i < params.size(); ++i)
		{
		  String componentID = params.elementAt(i).toString();

		  Node component = findNode (componentID);
		  if (component != null)
		      container.addComponent (component);
		}
	    }
	    catch (ClassCastException e) {
	      Debug.error ("Internal Error\nIllegal parameter in COMP msg:\n"
			   + params);
	    }
	  }
      });

    
    addFocusListener (this);
			  
  }


  public Graph graph()
  {
    return canvas.graph;
  }
  
  public GraphicsInfo graphicsInfo()
  {
    return dispatcher.getGraphics();
  }
  
  public void setAutoArranging (boolean yesOrNo)
  {
    dispatcher.getGraphics().autoArranging = yesOrNo;
  }
  
  public boolean getAutoArranging ()
  {
    return dispatcher.getGraphics().autoArranging;
  }
  
  public boolean isFocusTraversable()
  {
    return true;
  }
    
  public void setStatusText (String str)
  {
    status.setText (str);
    // status.repaint();
  }
  
  public int fontSize ()
  {
    return dispatcher.getGraphics().getFontSize();
  }
  
  public Canvas getCanvas()
  {
    return canvas;
  }
  
  public Graph getGraph()
  {
    return canvas.graph;
  }
  
  public void setFontSize (int size)
  {
    canvas.setFontSize (size);

    Font oldStatusFont = status.getFont();
    if (oldStatusFont == null)
      {
	oldStatusFont = new Font ("Dialog", Font.PLAIN, size);
      }
    
    status.setFont
      (new Font(oldStatusFont.getName(),
		oldStatusFont.getStyle(),
		size));
  }


  public void showGraph()
  {
    if (isShowing())
      canvas.showGraph();
  }
  
  public void forceArrangeData()
  {
    if (isShowing())
      {
	  //	canvas.graph.recenter(true, dispatcher.getGraphics());
	canvas.graph.reposition(dispatcher.getGraphics());
	canvas.showGraph();
      }
  }

  public void arrangeData()
  {
    if (isShowing())
      {
	  //	canvas.graph.recenter(dispatcher.getGraphics().autoArranging,
	  //	      dispatcher.getGraphics());
	Debug.show (Debug.messageSynch, "DP.arrangeData dispatcher.getGraphicsInfo().autoArranging: ",
		    dispatcher.getGraphics().autoArranging);
	if (dispatcher.getGraphics().autoArranging)
	  canvas.graph.reposition(dispatcher.getGraphics());
	else
	  canvas.graph.recenter(false, dispatcher.getGraphics());
	canvas.showGraph();
      }
  }


    /**
     * Searches for a Node, given it's ID. If not found, the node is created.
     * Three Node ID's are reserved: "0", "", and "null" all can be used
     * interchangably to denote a nonexistent node.  No node will be created
     * with these IDs.
     */
  private Node findNode(String nodeID)
  {
    Graph g = graph();
    Node node = null;
    node = g.findNode (nodeID);
    if (node == null)
      {
	if (!(nodeID.equals("0") || nodeID.equals("")
	      || nodeID.equals("null")))
	  {
	    node = new Node (nodeID, Color.black, false);
	    g.addNode (node);
	    node.setText ("??");
	    node.setMarked(true);
	  }
      }
    else if (!node.getMarked())
      {
	node.clearInEdges();
	node.clearOutEdges();
	node.clearComponents();
	node.setMarked (true);
      }
    return node;
  }


    public void focusGained(FocusEvent e)
    {
	status.setForeground (Color.blue);
	repaint();
    }

    public void focusLost(FocusEvent e)
    {
	status.setForeground (Color.black);
	repaint();
    }	      

}