From b086f57f56bf0eb9dab9cf321a0f69aaaae84347 Mon Sep 17 00:00:00 2001 From: Andrew Branson Date: Wed, 30 May 2012 08:37:45 +0200 Subject: Initial Maven Conversion --- .../graph/controller/AutoScrollController.java | 41 ++ .../graph/controller/DeletionController.java | 92 ++++ .../controller/EdgeConstructionController.java | 253 +++++++++ .../controller/MultiSelectionDragController.java | 571 +++++++++++++++++++++ .../graph/controller/StartVertexController.java | 79 +++ .../controller/VertexConstructionController.java | 47 ++ 6 files changed, 1083 insertions(+) create mode 100644 src/main/java/com/c2kernel/graph/controller/AutoScrollController.java create mode 100644 src/main/java/com/c2kernel/graph/controller/DeletionController.java create mode 100644 src/main/java/com/c2kernel/graph/controller/EdgeConstructionController.java create mode 100644 src/main/java/com/c2kernel/graph/controller/MultiSelectionDragController.java create mode 100644 src/main/java/com/c2kernel/graph/controller/StartVertexController.java create mode 100644 src/main/java/com/c2kernel/graph/controller/VertexConstructionController.java (limited to 'src/main/java/com/c2kernel/graph/controller') diff --git a/src/main/java/com/c2kernel/graph/controller/AutoScrollController.java b/src/main/java/com/c2kernel/graph/controller/AutoScrollController.java new file mode 100644 index 0000000..aa04609 --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/AutoScrollController.java @@ -0,0 +1,41 @@ +package com.c2kernel.graph.controller; + +import java.awt.Point; +import java.awt.Rectangle; +import java.awt.event.MouseEvent; +import java.awt.event.MouseMotionListener; + +import com.c2kernel.graph.view.GraphPanel; + + +public class AutoScrollController implements MouseMotionListener +{ + private GraphPanel mGraphPanel = null; + + + public void setGraphPanel(GraphPanel graphPanel) + { + mGraphPanel = graphPanel; + mGraphPanel.addMouseMotionListener(this); + } + + + @Override + public void mouseDragged(MouseEvent me) + { + Point mousePoint = null; + + + if(mGraphPanel != null) + { + mousePoint = me.getPoint(); + mGraphPanel.scrollRectToVisible(new Rectangle(mousePoint.x, mousePoint.y, 1, 1)); + } + } + + + @Override + public void mouseMoved(MouseEvent me) + { + } +} diff --git a/src/main/java/com/c2kernel/graph/controller/DeletionController.java b/src/main/java/com/c2kernel/graph/controller/DeletionController.java new file mode 100644 index 0000000..44ea990 --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/DeletionController.java @@ -0,0 +1,92 @@ +package com.c2kernel.graph.controller; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyAdapter; +import java.awt.event.KeyEvent; +import java.util.Observable; +import java.util.Observer; + +import javax.swing.JButton; + +import com.c2kernel.graph.event.SelectionChangedEvent; +import com.c2kernel.graph.model.DirectedEdge; +import com.c2kernel.graph.model.GraphModelManager; +import com.c2kernel.graph.model.Vertex; + + +// The deletion controller is responsible for deleting the present +// selection within the graph. +// +// The controller listens to: +// * The graph model to determine if there is a selection +// * The delete button +// * The graph panel for the typing of the delete key +// +// The controller modifies: +// * The graph model to delete the current selection +// * The delete button to enable it only when there is a selection +public class DeletionController extends KeyAdapter implements Observer, ActionListener +{ + private GraphModelManager mGraphModelManager = null; + private JButton mDeleteButton = null; + + + public void setGraphModelManager(GraphModelManager graphModelManager) + { + mGraphModelManager = graphModelManager; + mGraphModelManager.addObserver(this); + } + + + public void setDeleteButton(JButton deleteButton) + { + mDeleteButton = deleteButton; + mDeleteButton.addActionListener(this); + } + + + // Invoked by the graph model + @Override + public void update(Observable o, Object arg) + { + SelectionChangedEvent event = null; + DirectedEdge selectedEdge = null; + Vertex[] selectedVertices = null; + + + // If the selected edge has changed + if(arg instanceof SelectionChangedEvent && mDeleteButton != null && mGraphModelManager.isEditable()) + { + // Enable the button if a single edge or single vertex is selected + event = (SelectionChangedEvent)arg; + + selectedEdge = event.mSelection.mEdge; + selectedVertices = event.mSelection.mVertices; + + mDeleteButton.setEnabled((selectedEdge != null) || (selectedVertices != null)); + } + } + + + // Invoked by the graph panel + @Override + public void keyPressed(KeyEvent e) + { + if(e.getKeyCode() == KeyEvent.VK_DELETE && mGraphModelManager.isEditable()) + { + mGraphModelManager.getModel().deleteSelection(); + } + } + + + // Invoked by the delete button + @Override + public void actionPerformed(ActionEvent ae) + { + if(mGraphModelManager != null && mGraphModelManager.isEditable()) + { + mGraphModelManager.getModel().deleteSelection(); + } + } +} diff --git a/src/main/java/com/c2kernel/graph/controller/EdgeConstructionController.java b/src/main/java/com/c2kernel/graph/controller/EdgeConstructionController.java new file mode 100644 index 0000000..00ea45b --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/EdgeConstructionController.java @@ -0,0 +1,253 @@ +package com.c2kernel.graph.controller; + +import java.awt.Point; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; + +import com.c2kernel.graph.model.GraphModelManager; +import com.c2kernel.graph.model.GraphPoint; +import com.c2kernel.graph.model.Vertex; +import com.c2kernel.graph.view.EditorModeListener; +import com.c2kernel.graph.view.EditorToolBar; + + +public class EdgeConstructionController extends MouseAdapter implements EditorModeListener +{ + private GraphModelManager mGraphModelManager = null; + private EditorToolBar mEditorToolBar = null; + + + /**********/ + /* States */ + /**********/ + private final Integer kOtherMode = new Integer(0); + private final Integer kWaitOrigin = new Integer(1); + private final Integer kWaitTerminus = new Integer(2); + + + /**********/ + /* Events */ + /**********/ + private final int kEdgeEntered = 0; + private final int kOtherEntered = 1; + private final int kPressOnVertex = 2; + private final int kDrag = 3; + private final int kReleaseOnTerminus = 4; + private final int kReleaseOnNothing = 5; + + + /***********/ + /* Actions */ + /***********/ + + private interface Action + { + public void doIt(Object data); + } + + + private Action mSetOriginVertex = new Action() + { + @Override + public void doIt(Object data) + { + if(mGraphModelManager != null) + { + mGraphModelManager.getModel().setNewEdgeOriginVertex((Vertex)data); + } + } + }; + + + private Action mSetEndPoint = new Action() + { + @Override + public void doIt(Object data) + { + if(mGraphModelManager != null) + { + mGraphModelManager.getModel().setNewEdgeEndPoint((Point)data); + } + } + }; + + + private Action mClearEdge = new Action() + { + @Override + public void doIt(Object data) + { + if(mGraphModelManager != null) + { + mGraphModelManager.getModel().setNewEdgeOriginVertex(null); + mGraphModelManager.getModel().setNewEdgeEndPoint(null); + } + } + }; + + + private Action mCreateEdge = new Action() + { + @Override + public void doIt(Object data) + { + if((mGraphModelManager != null) && (mEditorToolBar != null) && mGraphModelManager.isEditable()) + { + mGraphModelManager.getModel().createDirectedEdge + ( + mGraphModelManager.getModel().getNewEdgeOriginVertex(), + (Vertex)data, + mEditorToolBar.getSelectedEdgeType() + ); + mGraphModelManager.getModel().setNewEdgeOriginVertex(null); + mGraphModelManager.getModel().setNewEdgeEndPoint(null); + } + } + }; + + + /***********************************/ + /* Finite State Transition Network */ + /***********************************/ + + private Object[][][] mFSTN = + {// OtherMode WaitOrigin WaitTerminus + /* EdgeEntered */ {{null, kWaitOrigin}, null , null }, + /* OtherEntered */ { null , {null , kOtherMode} , null }, + /* PressOnVertex */ { null , {mSetOriginVertex, kWaitTerminus}, null }, + /* Drag */ { null , null , {mSetEndPoint, null} }, + /* ReleaseOnTerminus */ { null , null , {mCreateEdge , kWaitOrigin}}, + /* ReleaseOnNothing */ { null , null , {mClearEdge , kWaitOrigin}} + }; + + + /*****************/ + /* Current state */ + /*****************/ + + private Integer mState = kOtherMode; + + + /**************************/ + /* Event processing logic */ + /**************************/ + + private void processEvent(int event, Object data) + { + Object[] transition = mFSTN[event][mState.intValue()]; + Action action = null; + Integer nextState = null; + + if(transition != null) + { + action = (Action)transition[0]; + nextState = (Integer)transition[1]; + + if(action != null) + { + action.doIt(data); + } + + if(nextState != null) + { + mState = nextState; + } + } + } + + + /********************/ + /* Public interface */ + /********************/ + + public void setGraphModelManager(GraphModelManager graphModelManager) + { + mGraphModelManager = graphModelManager; + } + + + public void setEditorToolBar(EditorToolBar editorToolBar) + { + mEditorToolBar = editorToolBar; + mEditorToolBar.addEditorModeListener(this); + } + + + @Override + public void editorModeChanged(String idOfNewMode) + { + if(idOfNewMode.equals("Edge")) + { + processEvent(kEdgeEntered, null); + } + else + { + processEvent(kOtherEntered, null); + } + } + + + @Override + public void mousePressed(MouseEvent me) + { + Vertex vertex = null; + Point mousePoint = null; + + if(mGraphModelManager != null) + { + // Determine if there is a vertex under the mouse cursor + mousePoint = me.getPoint(); + vertex = mGraphModelManager.getModel().getVertex(new GraphPoint(mousePoint.x, mousePoint.y)); + + // If the mouse has been pressed on a vertex + if(vertex != null) + { + processEvent(kPressOnVertex, vertex); + } + } + } + + + @Override + public void mouseReleased(MouseEvent me) + { + Vertex vertex = null; + Point mousePoint = null; + + if(mGraphModelManager != null) + { + // Determine if there is a vertex under the mouse cursor + mousePoint = me.getPoint(); + vertex = mGraphModelManager.getModel().getVertex(new GraphPoint(mousePoint.x, mousePoint.y)); + + // If the mouse has been released on a vertex which is not the origin vertex + if((vertex != null) && (vertex != mGraphModelManager.getModel().getNewEdgeOriginVertex())) + { + processEvent(kReleaseOnTerminus, vertex); + } + else + { + processEvent(kReleaseOnNothing, null); + } + } + } + + + @Override + public void mouseExited(MouseEvent me) + { + } + + + @Override + public void mouseDragged(MouseEvent me) + { + processEvent(kDrag, me.getPoint()); + } + + + @Override + public void mouseMoved(MouseEvent me) + { + } +} diff --git a/src/main/java/com/c2kernel/graph/controller/MultiSelectionDragController.java b/src/main/java/com/c2kernel/graph/controller/MultiSelectionDragController.java new file mode 100644 index 0000000..eda5c1c --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/MultiSelectionDragController.java @@ -0,0 +1,571 @@ +package com.c2kernel.graph.controller; + +import java.awt.Point; +import java.awt.event.InputEvent; +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; + +import com.c2kernel.graph.model.DirectedEdge; +import com.c2kernel.graph.model.ElasticBand; +import com.c2kernel.graph.model.GraphModelManager; +import com.c2kernel.graph.model.GraphPoint; +import com.c2kernel.graph.model.GraphableVertex; +import com.c2kernel.graph.model.Selection; +import com.c2kernel.graph.model.Vertex; +import com.c2kernel.graph.view.EditorModeListener; + + +public class MultiSelectionDragController +extends MouseAdapter +implements EditorModeListener, KeyListener +{ + private class ResizeInf + { + public int mMousePressedX = 0; + public int mMousePressedY = 0; + public Vertex mSelectedVertex = null; + public GraphPoint[] mOldOutline = null; + public int mCentreX = 0; + public int mCentreY = 0; + public int mOldHeight = 0; + public int mOldWidth = 0; + } + private ResizeInf mResizeInf = new ResizeInf(); + + private class DispForSelection + { + public int mXDisp = 0; + public int mYDisp = 0; + } + private DispForSelection mDispForSelection = null; + + private class VertexAndDisp + { + public Vertex mVertex = null; + public int mXDisp = 0; + public int mYDisp = 0; + } + + protected GraphModelManager mGraphModelManager = null; + + + /**********/ + /* States */ + /**********/ + protected final Integer kOtherMode = new Integer(0); + protected final Integer kWaiting = new Integer(1); + protected final Integer kResizing = new Integer(2); + protected final Integer kDraggingSelection = new Integer(3); + protected final Integer kStretching = new Integer(4); + + + /**********/ + /* Events */ + /**********/ + protected final int kSelectEntered = 0; + protected final int kOtherEntered = 1; + protected final int kPressOnEdge = 2; + protected final int kPressOnVertex = 3; + protected final int kPressOnSelection = 4; + protected final int kPressOnResizePad = 5; + protected final int kCTRLPressOnVertex = 6; + protected final int kCTRL_A = 7; + protected final int kPressOnNothing = 8; + protected final int kDrag = 9; + protected final int kRelease = 10; + protected final int kZoomIn = 11; + + /***********/ + /* Actions */ + /***********/ + + protected interface Action + { + public void doIt(Object data); + } + + + protected Action mStoreResizeInf = new Action() + { + @Override + public void doIt(Object data) + { + Point mousePoint = (Point)data; + GraphPoint centre = null; + + mResizeInf.mMousePressedX = mousePoint.x; + mResizeInf.mMousePressedY = mousePoint.y; + mResizeInf.mSelectedVertex = mGraphModelManager.getModel().getSelection().mVertices[0]; + mResizeInf.mOldOutline = mResizeInf.mSelectedVertex.getOutlinePoints(); + centre = mResizeInf.mSelectedVertex.getCentrePoint(); + mResizeInf.mCentreX = centre.x; + mResizeInf.mCentreY = centre.y; + mResizeInf.mOldHeight = mResizeInf.mSelectedVertex.getHeight(); + mResizeInf.mOldWidth = mResizeInf.mSelectedVertex.getWidth(); + } + }; + + + protected Action mResizeVertex = new Action() + { + @Override + public void doIt(Object data) + { + Point mousePoint = (Point)data; + int resizeX = 0; + int resizeY = 0; + + + // Calculate how much the old outline should be resized + resizeX = mousePoint.x - mResizeInf.mMousePressedX; + resizeY = mousePoint.y - mResizeInf.mMousePressedY; + + // Clip the resize so that outline does not get any + // smaller than 10 x 10 pixels + if(resizeX < -mResizeInf.mOldWidth/2 + 10) + { + resizeX = -mResizeInf.mOldWidth/2 + 10; + } + + if(resizeY < -mResizeInf.mOldHeight/2 + 10) + { + resizeY = -mResizeInf.mOldHeight/2 + 10; + } + + if (mGraphModelManager.isEditable()) { + mResizeInf.mSelectedVertex.setOutlinePoints(newOutline(resizeX, resizeY)); + mGraphModelManager.forceNotify(); + } + } + + + private GraphPoint[] newOutline(int resizeX, int resizeY) + { + GraphPoint[] newOutline = new GraphPoint[mResizeInf.mOldOutline.length]; + int x = 0; + int y = 0; + int i = 0; + + + for(i=0; i mResizeInf.mCentreX) + { + x = mResizeInf.mOldOutline[i].x + resizeX; + } + else if(mResizeInf.mOldOutline[i].x < mResizeInf.mCentreX) + { + x = mResizeInf.mOldOutline[i].x - resizeX; + } + else + { + x = mResizeInf.mOldOutline[i].x; + } + + if(mResizeInf.mOldOutline[i].y > mResizeInf.mCentreY) + { + y = mResizeInf.mOldOutline[i].y + resizeY; + } + else if(mResizeInf.mOldOutline[i].y < mResizeInf.mCentreY) + { + y = mResizeInf.mOldOutline[i].y - resizeY; + } + else + { + y = mResizeInf.mOldOutline[i].y; + } + + newOutline[i] = new GraphPoint(x, y); + } + + return newOutline; + } + }; + + + protected Action mSelectEdge = new Action() + { + @Override + public void doIt(Object data) + { + Selection selection = new Selection((DirectedEdge)data, null, 0, 0, 0, 0); + + mGraphModelManager.getModel().setSelection(selection); + } + }; + + + protected Action mSelectVertexAndStoreDisp = new Action() + { + @Override + public void doIt(Object data) + { + VertexAndDisp vertexAndDisp = (VertexAndDisp)data; + GraphPoint centrePoint = vertexAndDisp.mVertex.getCentrePoint(); + Selection selection = new Selection(null, + new Vertex[] {vertexAndDisp.mVertex}, + centrePoint.x, + centrePoint.y, + centrePoint.x, + centrePoint.y); + + mGraphModelManager.getModel().setSelection(selection); + mDispForSelection = new DispForSelection(); + mDispForSelection.mXDisp = vertexAndDisp.mXDisp; + mDispForSelection.mYDisp = vertexAndDisp.mYDisp; + } + }; + + + protected Action mStoreDisp = new Action() + { + @Override + public void doIt(Object data) + { + mDispForSelection = (DispForSelection)data; + } + }; + + + protected Action mToggleVertex = new Action() + { + @Override + public void doIt(Object data) + { + Vertex vertex = (Vertex)data; + + if(mGraphModelManager.getModel().inSelection(vertex)) + { + mGraphModelManager.getModel().removeFromSelection(vertex); + } + else + { + mGraphModelManager.getModel().addToSelection(vertex); + } + } + }; + + + protected Action mSelectAll = new Action() + { + @Override + public void doIt(Object data) + { + mGraphModelManager.getModel().selectAll(); + } + }; + + + protected Action mCreateBand = new Action() + { + @Override + public void doIt(Object data) + { + Point fixedCorner = (Point)data; + + mGraphModelManager.getModel().setElasticBand(new ElasticBand(fixedCorner, fixedCorner)); + } + }; + + + protected Action mMoveSelection = new Action() + { + @Override + public void doIt(Object data) + { + Point mousePoint = (Point)data; + int topLeftX = mousePoint.x - mDispForSelection.mXDisp; + int topLeftY = mousePoint.y - mDispForSelection.mYDisp; + if (mGraphModelManager.isEditable()) { + mGraphModelManager.getModel().moveAbsoluteSelection(topLeftX, topLeftY); + } + } + }; + + + protected Action mResizeBand = new Action() + { + @Override + public void doIt(Object data) + { + mGraphModelManager.getModel().resizeElasticBand((Point)data); + } + }; + + + protected Action mSelectContents = new Action() + { + @Override + public void doIt(Object data) + { + mGraphModelManager.getModel().selectContentsOfElasticBand(); + } + }; + + protected Action mZoomIn = new Action() + { + @Override + public void doIt(Object data) // data is the clicked vertex + { + // Need to get child graph model out of the vertex before we can zoom in + if (data instanceof Vertex) { + Vertex zoomTo = (Vertex)data; + if (((GraphableVertex)zoomTo).getIsComposite()) mGraphModelManager.zoomIn(zoomTo); + } + } + }; + + /***********************************/ + /* Finite State Transition Network */ + /***********************************/ + + protected Object[][][] mFSTN = + {// OtherMode Waiting Resizing DraggingSelection Stretching + /* SelectEntered */ {{null, kWaiting}, null , null , null , null }, + /* OtherEntered */ { null , {null , kOtherMode }, null , null , null }, + /* PressOnEdge */ { null , {mSelectEdge , null }, null , null , null }, + /* PressOnVertex */ { null , {mSelectVertexAndStoreDisp, kDraggingSelection}, null , null , null }, + /* PressOnSelection */ { null , {mStoreDisp , kDraggingSelection}, null , null , null }, + /* PressOnResizePad */ { null , {mStoreResizeInf , kResizing }, null , null , null }, + /* CTRLPressOnVertex */ { null , {mToggleVertex , null }, null , null , null }, + /* CTRL_A */ { null , {mSelectAll , null }, null , null , null }, + /* PressOnNothing */ { null , {mCreateBand , kStretching }, null , null , null }, + /* Drag */ { null , null , {mResizeVertex, null }, {mMoveSelection, null }, {mResizeBand , null }}, + /* Release */ { null , null , {null , kWaiting}, {null , kWaiting}, {mSelectContents, kWaiting}}, + /* Double Click */ { null , {mZoomIn , null }, null , null , null }, + }; + + + /*****************/ + /* Current state */ + /*****************/ + + private Integer mState = kWaiting; + + + /**************************/ + /* Event processing logic */ + /**************************/ + + protected void processEvent(int event, Object data) + { + Object[] transition = mFSTN[event][mState.intValue()]; + Action action = null; + Integer nextState = null; + + if(transition != null) + { + action = (Action)transition[0]; + nextState = (Integer)transition[1]; + + if(action != null) + { + action.doIt(data); + } + + if(nextState != null) + { + mState = nextState; + } + } + } + + + /********************/ + /* Public interface */ + /********************/ + + public void setGraphModelManager(GraphModelManager graphModelManager) + { + mGraphModelManager = graphModelManager; + } + + + @Override + public void editorModeChanged(String idOfNewMode) + { + if(idOfNewMode.equals("Select")) + { + processEvent(kSelectEntered, null); + } + else + { + processEvent(kOtherEntered, null); + } + } + + + @Override + public void mousePressed(MouseEvent me) + { + int modifiers = me.getModifiers(); + + if(mGraphModelManager != null) + { + if((modifiers & InputEvent.CTRL_MASK) == 0) + { + mousePressedWithoutCTRL(me.getPoint()); + } + else + { + mousePressedWithCTRL(me.getPoint()); + } + } + } + + @Override + public void mouseClicked(MouseEvent me) + { + if (me.getClickCount() == 2) { // want double click + Point clickedSpot = me.getPoint(); + GraphPoint mouseGPoint = new GraphPoint(clickedSpot.x, clickedSpot.y); + Vertex clicked = mGraphModelManager.getModel().getVertex(mouseGPoint); + if (clicked != null) + processEvent(kZoomIn, clicked); + } + } + + private void mousePressedWithoutCTRL(Point mousePoint) + { + GraphPoint mouseGPoint = new GraphPoint(mousePoint.x, mousePoint.y); + DirectedEdge edge = mGraphModelManager.getModel().getEdge(mouseGPoint); + Vertex vertex = mGraphModelManager.getModel().getVertex(mouseGPoint); + GraphPoint vertexCentrePoint = null; + VertexAndDisp vertexAndDisp = null; + Selection selection = null; + DispForSelection dispForSelection = null; + + + // In order of priority: + // 1. Click on resize pad + // 2. Click on vertex + // 3. Click on edge + if(onResizePad(mouseGPoint)) + { + processEvent(kPressOnResizePad, mousePoint); + } + else if(vertex != null) + { + if(mGraphModelManager.getModel().inSelection(vertex)) + { + selection = mGraphModelManager.getModel().getSelection(); + dispForSelection = new DispForSelection(); + dispForSelection.mXDisp = mousePoint.x - selection.mTopLeftX; + dispForSelection.mYDisp = mousePoint.y - selection.mTopLeftY; + + processEvent(kPressOnSelection, dispForSelection); + } + else + { + vertexCentrePoint = vertex.getCentrePoint(); + + vertexAndDisp = new VertexAndDisp(); + vertexAndDisp.mVertex = vertex; + vertexAndDisp.mXDisp = mousePoint.x - vertexCentrePoint.x; + vertexAndDisp.mYDisp = mousePoint.y - vertexCentrePoint.y; + + processEvent(kPressOnVertex, vertexAndDisp); + } + } + // vertex == null + else + { + if(edge == null) + { + processEvent(kPressOnNothing, mousePoint); + } + else + { + processEvent(kPressOnEdge, edge); + } + } + } + + + private boolean onResizePad(GraphPoint mouseGPoint) + { + Selection selection = mGraphModelManager.getModel().getSelection(); + GraphPoint vertexCentre = null; + int bottomRightX = 0; + int bottomRightY = 0; + + + if(selection.mVertices == null) return false; + + if(selection.mVertices.length == 1) + { + vertexCentre = selection.mVertices[0].getCentrePoint(); + if (vertexCentre == null) return false; + bottomRightX = vertexCentre.x + selection.mVertices[0].getWidth()/2; + bottomRightY = vertexCentre.y + selection.mVertices[0].getHeight()/2; + + return + ( + (mouseGPoint.x > bottomRightX) && + (mouseGPoint.x < bottomRightX + 10) && + (mouseGPoint.y > bottomRightY) && + (mouseGPoint.y < bottomRightY + 10) + ); + } + else + { + return false; + } + } + + + private void mousePressedWithCTRL(Point mousePoint) + { + Vertex vertex = mGraphModelManager.getModel().getVertex(new GraphPoint(mousePoint.x, mousePoint.y)); + + if(vertex != null) + { + processEvent(kCTRLPressOnVertex, vertex); + } + } + + + @Override + public void mouseReleased(MouseEvent me) + { + processEvent(kRelease, null); + } + + + @Override + public void mouseMoved(MouseEvent me) + { + } + + + @Override + public void mouseDragged(MouseEvent e) + { + processEvent(kDrag, e.getPoint()); + } + + + @Override + public void keyPressed(KeyEvent e) + { + if((e.getKeyCode() == KeyEvent.VK_A) && e.isControlDown()) + { + processEvent(kCTRL_A, null); + } + } + + + @Override + public void keyReleased(KeyEvent e) + { + } + + + @Override + public void keyTyped(KeyEvent e) + { + } + +} diff --git a/src/main/java/com/c2kernel/graph/controller/StartVertexController.java b/src/main/java/com/c2kernel/graph/controller/StartVertexController.java new file mode 100644 index 0000000..3984cb7 --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/StartVertexController.java @@ -0,0 +1,79 @@ +package com.c2kernel.graph.controller; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.Observable; +import java.util.Observer; + +import javax.swing.JButton; + +import com.c2kernel.graph.event.SelectionChangedEvent; +import com.c2kernel.graph.model.GraphModelManager; +import com.c2kernel.graph.model.Vertex; + + +// The start vertex controller is responsible for selecting +// the vertex at the start of the graph. +// +// The controller listens to: +// * The graph model to determine if there is a single +// vertex selected +// * The start vertex button +// +// The controller modifies: +// * The graph model to select the start vertex +// * The start button to enable it only when there is a +// single vertex selected +public class StartVertexController implements Observer, ActionListener +{ + private GraphModelManager mGraphModelManager = null; + private JButton mStartButton = null; + + + public void setGraphModelManager(GraphModelManager graphModelManager) + { + mGraphModelManager = graphModelManager; + mGraphModelManager.addObserver(this); + } + + + public void setStartButton(JButton startButton) + { + mStartButton = startButton; + mStartButton.addActionListener(this); + } + + + @Override + public void update(Observable o, Object arg) + { + SelectionChangedEvent event = null; + Vertex[] selectedVertices = null; + + // If the selected vertex has changed + if(arg instanceof SelectionChangedEvent && mStartButton != null) + { + event = (SelectionChangedEvent)arg; + selectedVertices = event.mSelection.mVertices; + + if(selectedVertices == null) + { + mStartButton.setEnabled(false); + } + else if (mGraphModelManager.isEditable()) + { + mStartButton.setEnabled(selectedVertices.length == 1); + } + } + } + + + @Override + public void actionPerformed(ActionEvent ae) + { + if(mGraphModelManager != null) + { + mGraphModelManager.getModel().setSelectedVertexToBeStart(); + } + } +} diff --git a/src/main/java/com/c2kernel/graph/controller/VertexConstructionController.java b/src/main/java/com/c2kernel/graph/controller/VertexConstructionController.java new file mode 100644 index 0000000..1eb91f6 --- /dev/null +++ b/src/main/java/com/c2kernel/graph/controller/VertexConstructionController.java @@ -0,0 +1,47 @@ +package com.c2kernel.graph.controller; + +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; + +import com.c2kernel.graph.model.GraphModelManager; +import com.c2kernel.graph.view.EditorModeListener; +import com.c2kernel.graph.view.EditorToolBar; + + +public class VertexConstructionController extends MouseAdapter implements EditorModeListener +{ + private GraphModelManager mGraphModelManager = null; + private EditorToolBar mEditorToolBar = null; + private boolean mCreatingVertices = false; + + + public void setGraphModelManager(GraphModelManager graphModelManager) + { + mGraphModelManager = graphModelManager; + } + + + public void setEditorToolBar(EditorToolBar editorToolBar) + { + mEditorToolBar = editorToolBar; + mEditorToolBar.addEditorModeListener(this); + } + + + @Override + public void editorModeChanged(String idOfNewMode) + { + mCreatingVertices = idOfNewMode.equals("Vertex"); + } + + + @Override + public void mouseClicked(MouseEvent me) + { + if(mCreatingVertices && (mGraphModelManager != null) && (mEditorToolBar != null) && mGraphModelManager.isEditable()) + { + mGraphModelManager.getModel().createVertex(me.getPoint(), mEditorToolBar.getSelectedVertexType()); + mEditorToolBar.enterSelectMode(); + } + } +} -- cgit v1.2.3