visofgraph.java

petrinets小程序

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Polygon;

import javax.swing.JFrame;


public class visOfGraph extends Canvas{
	
//	 height and width of tokens/items (in pixel)
    private static final int TokenH = 10;
    private static final int TokenW = 3;
    
//  different modes which mouse events are handled by
    public static final int NodeMode = 1;
    public static final int TransitionMode = 2;
    public static final int EdgeMode = 3;
    public static final int MODE_ITEM = 4;
    public static final int MODE_DELETE = 5;
    public static final int MODE_DRAG = 6;
    public static final int MODE_EDIT = 7;
    public static final int SELECTMODE = 8;
    private int mode;
    
//  color modes (color or black&white)
    public static final int COLORMODE_STANDARD = 20;
    public static final int COLORMODE_BLACKANDWHITE = 21;
    private int colorMode;
//    
    private static final int MAX_NUM_DELETE_EDGE = 255;
    private int     iDeleteNode;
    private int     iDeleteTransition;
    private int     nDeleteEdge;
    private int     iDeleteEdge[];
//
    private place        dragingPlace;
    private transition  dragingTransition;
    private edge    newEdge;
    private boolean newEdgeFinished;
//    
    private Dimension   ViewDim;
//
    private static pn PNet;
//
    private Image   BackBuffer;

    PlaceFrame PlaceFra;
    TransitionFrame TransFra;
    EdgeFrame EdgeFra;

    public visOfGraph(pn PN, Dimension dim) {
        PNet = PN;
        ViewDim = new Dimension(dim);
        resize(dim);
        newEdgeFinished = true;

        colorMode = COLORMODE_STANDARD;
//      colorMode = COLORMODE_BLACKANDWHITE;

        iDeleteNode = -1;
        iDeleteTransition = -1;
        nDeleteEdge = 0;
        iDeleteEdge = new int[MAX_NUM_DELETE_EDGE];
    }
    
    public void setDimension(Dimension d) {
        ViewDim.height = d.height;
        ViewDim.width = d.width;
    }
    
    public boolean setMode(int mode, int autorisation) {
        if (this.mode == SELECTMODE) {
            if (autorisation == run.CODE) {
                this.mode = mode;
                iDeleteNode = -1;
                iDeleteTransition = -1;
                nDeleteEdge = 0;
                return true;
            }
        } else {
            this.mode = mode;
            iDeleteNode = -1;
            iDeleteTransition = -1;
            nDeleteEdge = 0;
            return true;
        }
        return false;
    }
    
    public int getMode() {
        return mode;
    }
    
    public void setColorMode(int colorMode) {
        this.colorMode = colorMode;
    }
    
    public int getColorMode() {
        return colorMode;
    }
	
    public void setPN(pn PN) {
        PNet = PN;
    }
    
    public boolean handleEvent(Event evt) {
        switch(evt.id) {
        case Event.MOUSE_DOWN:
            // right mouse button down
            if (mode == MODE_DRAG || evt.modifiers == Event.META_MASK) {////iSco  modifiers:修饰符键的状态
                mouseMetaDown(evt);                                     ////iSco  META_MASK:此标志指示当事件发生时按下 Meta 键
            }
            else {
                if (mode == SELECTMODE)
                	;
//                  mouseDownSelect(evt);
                if (mode == NodeMode)
                    mouseDownPlace(evt);
                else if (mode == TransitionMode)
                    mouseDownTransition(evt);
                else if (mode == EdgeMode)
                    mouseDownEdge(evt);
                else if (mode == MODE_ITEM)
                    mouseDownToken(evt);
                else if (mode == MODE_DELETE)
                    mouseDownDelete(evt);
                else if (mode == MODE_EDIT)
                    mouseDownEdit(evt);
            }
            repaint();
            break;
        case Event.MOUSE_UP:
            break;
        case Event.MOUSE_DRAG:
            if (mode == MODE_DRAG || evt.modifiers == Event.META_MASK) {
                mouseMetaDrag(evt);
            }
            else {
                if (mode == NodeMode)
                    ;
                else if (mode == TransitionMode)
                    ;
                else if (mode == EdgeMode)
                    mouseDragEdge(evt);
            }
            repaint();
            break;
        case Event.MOUSE_MOVE:
            if (mode == NodeMode)
                ;
            else if (mode == TransitionMode)
                ;
            else if (mode == EdgeMode)
                mouseMoveEdge(evt);
            else if (mode == MODE_DELETE)
                mouseMoveDelete(evt);
            repaint();
            break;
        case Event.MOUSE_EXIT:
            if (mode == EdgeMode && ! newEdgeFinished) {
                PNet.removeEdge(newEdge);
                newEdgeFinished = true;
            }
            repaint();
            return true;
        }
        return true;
    }
    
    public void mouseMetaDown(Event evt){
    	place n = getPlaceAtXY(evt.x, evt.y, null);
    	transition t = getTransitionAtXY(evt.x, evt.y, null);
    	if (n != null) {
            if (mode == MODE_ITEM) {
                n.decTokens();
                dragingPlace = null;
                dragingTransition = null;
            } else {
                dragingPlace = n;
                dragingTransition = null;
            }
        }
        else if (t != null) {
            dragingPlace = null;
            dragingTransition = t;
        }
        else {
            dragingPlace = null;
            dragingTransition = null;
        }
    }
    
/*    private void mouseDownSelect(Event evt) {
        transition t = getTransitionAtXY(evt.x, evt.y, null);
        if ((t != null) && (t.highlight)) {
            ((Editor)getParent()).getRunStep().select(t);
        }
    }*/
    
    private void mouseDownPlace(Event evt) {
        if (!tooCloseToPlace(evt.x, evt.y, null) &&
            !tooCloseToTransition(evt.x, evt.y , null))
            PNet.addPlace(evt.x, evt.y);
    }
    
    private void mouseDownTransition(Event evt) {
        if (!tooCloseToPlace(evt.x, evt.y, null) &&
            !tooCloseToTransition(evt.x, evt.y, null))
            PNet.addTransition(evt.x, evt.y);
        else {
            transition t = getTransitionAtXY(evt.x, evt.y, null);
            if (t != null)
                t.cycleOrientation();
        }
    }
    
    private void mouseDownEdge(Event evt) {
        place n = getPlaceAtXY(evt.x, evt.y, null);
        transition t = getTransitionAtXY(evt.x, evt.y, null);

        if (newEdgeFinished == true) {
            if (n != null) {
                newEdge = PNet.addEdge(edge.PLACE, PNet.getIndexOf(n), edge.NOTHING, 0, null);
                newEdgeFinished = false;
            }
            else if (t != null) {
                newEdge = PNet.addEdge(edge.TRANSITION, PNet.getIndexOf(t), edge.NOTHING, 0, null);
                newEdgeFinished = false;
            }
        }
        else {
            if (n != null) {
                // edge starts and ends at a node
                if (newEdge.getTFrom() == edge.PLACE) {
                    PNet.removeEdge(newEdge);
                    newEdgeFinished = true;
                }
                else {
                    newEdge.clearLastPoint();
                    newEdge.setTTo(edge.PLACE);
                    newEdge.setITo(PNet.getIndexOf(n));
                    newEdgeFinished = true;
                }
            }
            else if (t != null) {
                // edge starts and ends at a transition
                if (newEdge.getTFrom() == edge.TRANSITION) {
                    PNet.removeEdge(newEdge);
                    newEdgeFinished = true;
                }
                else {
                    newEdge.clearLastPoint();
                    newEdge.setTTo(edge.TRANSITION);
                    newEdge.setITo(PNet.getIndexOf(t));
                    newEdgeFinished = true;
                }
            }
            else {
                newEdge.setLastPoint(evt.x, evt.y);
                newEdge.addPoint(evt.x, evt.y);
            }
        }
    }

    private void mouseDownToken(Event evt) {
        place n = getPlaceAtXY(evt.x, evt.y, null);
        if (n != null)
            n.incTokens();
    }
    
    private void mouseDownDelete(Event evt) {
        place n = getPlaceAtXY(evt.x, evt.y, null);
        transition t = getTransitionAtXY(evt.x, evt.y, null);
        edge e = getEdgeAtXY(evt.x, evt.y, null);
        if (n != null) {
            iDeleteNode = PNet.getIndexOf(n);
            iDeleteTransition = -1;
            nDeleteEdge = 0;
            for (int i = 0; i < PNet.numberOfEdges(); i++) {
                edge ee = PNet.getEdge(i);
                if (ee.getTFrom() == edge.PLACE && ee.getIFrom() == iDeleteNode ||
                    ee.getTTo() == edge.PLACE && ee.getITo() == iDeleteNode) {
                    PNet.removeEdge(ee);
                }
            }
            PNet.removePlace(n);
            iDeleteNode = -1;
        }
        else if (t != null) {
            iDeleteNode = -1;
            iDeleteTransition = PNet.getIndexOf(t);
            nDeleteEdge = 0;
            for (int i = 0; i < PNet.numberOfEdges(); i++) {