Разработка редактора изучения теории графов

* between them from that location.

*

* @return Line2D, the line connecting those points

*/

public Line2D getConnectionPoints() {

Rectangle2D startBounds = start.getBounds();

Rectangle2D endBounds = end.getBounds();

Point2D startCenter = new Point2D.Double(

startBounds.getCenterX(), startBounds.getCenterY());

Point2D endCenter = new Point2D.Double(

endBounds.getCenterX(), endBounds.getCenterY());

return new Line2D.Double(

start.getConnectionPoint(endCenter),

end.getConnectionPoint(startCenter));

}

/**

* Tells if this edge is equal to edge e by their connecting nodes.

*

* @param Edge e, the edge this edge is being compared to.

* @return boolean, true if equal; false if not.

*/

public boolean equals(Object e) {

boolean isEqual = false;

if (start.equals(((Edge) e).getStart()) && end.equals(((Edge) e).getEnd())) {

isEqual = true;

}

if (start.equals(((Edge) e).getEnd()) && end.equals(((Edge) e).getStart())) {

isEqual = true;

}

return isEqual;

}

private Node start;

private Node end;

}

import java.awt.*;

import java.awt.geom.*;

/**

* A class that supplies convenience implementations for a number of methods in

* the Node interface type.

*/

public abstract class AbstractNode implements Node {

private int x;

private int y;

private double size;

private int index;

private String label;

private Color color;

private Font font;

private static final double DEFAULT_SIZE = 20;

private static final String DEFAULT_LABEL = "";

private static final String[] ALPHABET = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",

"q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};

/**

* Creates a clone of the Node

*/

public Object clone() {

try {

return super.clone();

} catch (CloneNotSupportedException exception) {

return null;

}

}

/*

Accessors and mutators

*/

public double getDefaultSize() {

return DEFAULT_SIZE;

}

public String getDefaultLabel() {

String defLabel = "";

return defLabel;

}

public double getSize() {

return size;

}

public void setSize(double newSize) {

size = newSize;

}

public int getX() {

return x;

}

public int getY() {

return y;

}

public void setTheX(int newX) {

x = newX;

}

public void setTheY(int newY) {

y = newY;

}

public int getIndex() {

return index;

}

public void sendIndex(int ndx) {

index = ndx;

if (ndx < 26) {

label = ALPHABET[ index];

}

}

public String getLabel() {

return label;

}

public void setLabel(String label) {

this.label = label;

}

public Font getFont() {

return font;

}

public void setFont(Font font) {

this.font = font;

}

public Color getColor() {

return color;

}

public void setColor(Color c) {

color = c;

}

/**

* Gets the boundaries of the node

*

* @return The rectangle area that is the boundary

*/

public Rectangle2D getBounds() {

return new Rectangle2D.Double(

getX(), getY(), getSize(), getSize());

}

/**

* Moves the node across the graph panel

*

* @param double dx, the change in the x direction

* @param double dy, the change in the y direction

*/

public void translate(double dx, double dy) {

x += dx;

y += dy;

}

/**

* Tells if this node is equal to node right using various properties of the

* node

*

* @param Node right, the node this node is being compared to

* @return boolean, true if equal, false if not.

*/

public boolean equals(Object right) {

boolean isEqual = true;

if (x != ((Node) right).getX() || y != ((Node) right).getY()) {

isEqual = false;

}

return isEqual;

}

}

import java.awt.*;

import java.awt.geom.*;

import java.util.*;

import java.io.*;

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

/**

*

* @author JDI

*/

public class AdjacencyListGraph extends SimpleGraph {

private int n = 0; // number of nodes

private int d = 0; // diameter

/**

* Constructs new AdjacencyListGraph.

*

* @param f a file to parse

*/

public AdjacencyListGraph(File f) {

clearAll();

parse(f);

}

/**

* Parses the text file into a new graph

*

* @param f a file

* @return Graph a graph reflecting the format of the text file

*/

private void parse(File f) {

try {

Scanner s = new Scanner(f); // use for counting purposes

Scanner s2 = new Scanner(f); // data purposes

String line;

boolean first = false; //check if first line of text

boolean wt = false; // weighted or unweighted

boolean dir = true; // directed or undirected

boolean made = false; // check if node already made

double theta;

double x;

double y;

int r;

//StringTokenizer st;

int k = 0;

line = s.next();

while (s.hasNext()) // if the field isn't blank

{

k++;

line = s.next();

}

String[] list = new String[k];

k = 0;

while (k < list.length) {

list[k] = s2.next();

k++;

}

n = Integer.parseInt(list[0]); // convert string to integer for number of nodes

d = Integer.parseInt(list[1]); // convert string to integer for diameter

if (list[2].matches("weighted")) {

wt = true;

}

if (list[3].contains("undirected")) {

dir = false;

}

theta = 2 * Math.PI / n;

r = d / 2;

CircleNode c = new CircleNode(Color.WHITE);

CircleNode c2 = new CircleNode(Color.WHITE);

c.setLabel(String.valueOf(list[4].charAt(0))); // very first node, doesnt return int for now..

System.out.println(c.getLabel());

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c, new Point2D.Double(x + r, y + r));

//c.sendIndex( getNodes().size() - 1 );

int i = 5; // second node

while (i < list.length) {

if (!wt) // if unweighted

{

if (list[i].length() > 1) // if the substring is more than one character

{

//i++; // advance position to next node

c = new CircleNode(Color.WHITE); //

c.setLabel(String.valueOf(list[i].charAt(0))); // reset head node *******

System.out.println(c.getLabel());

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c, new Point2D.Double(x + r, y + r));

c2 = new CircleNode(Color.WHITE); //

c2.setLabel(String.valueOf(list[i].charAt(1)));

//i++; // advance again

} else {

c2 = new CircleNode(Color.WHITE);

c2.setLabel(list[i]);

}

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c2, new Point2D.Double(x + r, y + r));

System.out.println(c2.getLabel());

if (!dir) // if undirected

{

LineEdge l = new LineEdge(false);

l.connect(c, c2);

addEdge(l);

} else {

LineEdge l = new LineEdge(true);

l.connect(c, c2);

addEdge(l);

}

i++;

} else // if weighted

{

if (list[i].length() > 1) // if the substring is more than one character

{

//i++; // advance position to next node

c = new CircleNode(Color.WHITE); //

c.setLabel(String.valueOf(list[i].charAt(0))); // reset head node *******

System.out.println(c.getLabel());

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c, new Point2D.Double(x + r, y + r));

c2 = new CircleNode(Color.WHITE); //

c2.setLabel(String.valueOf(list[i].charAt(1)));

//i++; // advance again

} else {

c2 = new CircleNode(Color.WHITE);

c2.setLabel(list[i]);

}

System.out.println(c2.getLabel());

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c2, new Point2D.Double(x + r, y + r));

if (!dir) // if undirected

{

LineEdge l = new LineEdge(false);

l.connect(c, c2);

l.setLabel(list[i + 1]);

addEdge(l);

} else {

LineEdge l = new LineEdge(true);

l.connect(c, c2);

l.setLabel(list[i + 1]);

addEdge(l);

}

i += 2;

}

}

} catch (FileNotFoundException exception) {

n = 0;

d = 0;

}

//return g;

}

public Node[] getNodePrototypes() {

Node[] nodeTypes = {

new CircleNode(Color.BLACK),

new CircleNode(Color.WHITE),

new SquareNode(Color.LIGHT_GRAY)

};

return nodeTypes;

}

public Edge[] getEdgePrototypes() {

Edge[] edgeTypes = {

new LineEdge(),

new LineEdge(true)

};

return edgeTypes;

}

}

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.geom.GeneralPath;

import java.awt.geom.Point2D;

/**

* This class defines arrowheads of various shapes.

*/

public enum ArrowHead {

NONE, TRIANGLE, BLACK_TRIANGLE, V, DIAMOND, BLACK_DIAMOND;

/**

* Draws the arrowhead.

*

* @param g2 the graphics context

* @param p a point on the axis of the arrow head

* @param q the end point of the arrow head

*/

public void draw(Graphics2D g2, Point2D p, Point2D q) {

GeneralPath path = getPath(p, q);

Color oldColor = g2.getColor();

if (this == BLACK_DIAMOND || this == BLACK_TRIANGLE) {

g2.setColor(Color.BLACK);

} else {

g2.setColor(Color.WHITE);

}

g2.fill(path);

g2.setColor(oldColor);

g2.draw(path);

}

/**

* Gets the path of the arrowhead

*

* @param p a point on the axis of the arrow head

* @param q the end point of the arrow head

* @return the path

*/

public GeneralPath getPath(Point2D p, Point2D q) {

GeneralPath path = new GeneralPath();

if (this == NONE) {

return path;

}

final double ARROW_ANGLE = Math.PI / 6;

final double ARROW_LENGTH = 8;

double dx = q.getX() - p.getX();

double dy = q.getY() - p.getY();

double angle = Math.atan2(dy, dx);

double x1 = q.getX()

- ARROW_LENGTH * Math.cos(angle + ARROW_ANGLE);

double y1 = q.getY()

- ARROW_LENGTH * Math.sin(angle + ARROW_ANGLE);

double x2 = q.getX()

- ARROW_LENGTH * Math.cos(angle - ARROW_ANGLE);

double y2 = q.getY()

- ARROW_LENGTH * Math.sin(angle - ARROW_ANGLE);

path.moveTo((float) q.getX(), (float) q.getY());

path.lineTo((float) x1, (float) y1);

if (this == V) {

path.moveTo((float) x2, (float) y2);

path.lineTo((float) q.getX(), (float) q.getY());

} else if (this == TRIANGLE || this == BLACK_TRIANGLE) {

path.lineTo((float) x2, (float) y2);

path.closePath();

} else if (this == DIAMOND || this == BLACK_DIAMOND) {

double x3 = x2 - ARROW_LENGTH * Math.cos(angle + ARROW_ANGLE);

double y3 = y2 - ARROW_LENGTH * Math.sin(angle + ARROW_ANGLE);

path.lineTo((float) x3, (float) y3);

path.lineTo((float) x2, (float) y2);

path.closePath();

}

return path;

}

}

import java.awt.*;

import java.awt.geom.*;

/**

* A circular node that is filled with a color.

*/

public class CircleNode extends AbstractNode //implements Node

{

/**

* Construct a circle node with a given size and color.

*

* @param aColor the fill color

*/

public CircleNode(Color aColor) {

setSize(getDefaultSize());

setTheX(0);

setTheY(0);

setColor(aColor);

setLabel(getDefaultLabel());

}

/**

* Draws the node to the graph.

*

* @param g2 the graphics object to which the circle node is drawn.

*/

public void draw(Graphics2D g2) {

Ellipse2D circle = new Ellipse2D.Double(

getX(), getY(), getSize(), getSize());

Color oldColor = g2.getColor();

g2.setColor(getColor());

g2.fill(circle);

g2.setColor(oldColor);

g2.draw(circle);

Font oldFont = g2.getFont();

g2.setFont(getFont());

g2.drawString(getLabel(), (float) (getX() + getSize() / 3), (float) (getY() + getSize() / 1.5));

g2.setFont(oldFont);

}

/**

* Tests if this CircleNode contains a point.

*

* @param p the other point

* @return whether p is inside this CircleNode

*/

public boolean contains(Point2D p) {

Ellipse2D circle = new Ellipse2D.Double(

getX(), getY(), getSize(), getSize());

return circle.contains(p);

}

/**

* Get the best connection point to connect this node with another node.

* This should be a point on the boundary of the shape of this node.

*

* @param other an exterior point that is to be joined with this node

* @return the recommended connection point

*/

public Point2D getConnectionPoint(Point2D other) {

double centerX = getX() + getSize() / 2;

double centerY = getY() + getSize() / 2;

double dx = other.getX() - centerX;

double dy = other.getY() - centerY;

double distance = Math.sqrt(dx * dx + dy * dy);

if (distance == 0) {

return other;

} else {

return new Point2D.Double(

centerX + dx * (getSize() / 2) / distance,

centerY + dy * (getSize() / 2) / distance);

}

}

}

import java.awt.*;

import java.awt.geom.*;

/**

* A circular node that is filled with a color.

*/

public class CircularNode extends AbstractNode //implements Node

{

/**

* Construct a circle node with a given size and color.

*

* @param aColor the fill color

*/

public CircularNode(Color aColor) {

setSize(getDefaultSize());

setTheX(0);

setTheY(0);

setColor(aColor);

setLabel(getDefaultLabel());

}

public void draw(Graphics2D g2) {

Ellipse2D circle = new Ellipse2D.Double(

getX(), getY(), getSize(), getSize());

Color oldColor = g2.getColor();

g2.setColor(getColor());

g2.fill(circle);

g2.setColor(oldColor);

g2.draw(circle);

// if ( getLabel() != getDefaultLabel( getIndex() ) ) setLabel(getDefaultLabel( getIndex() ));

g2.drawString(getLabel(), (float) (getX() + getSize() / 4), (float) (getY() + getSize() / 2));

}

public boolean contains(Point2D p) {

Ellipse2D circle = new Ellipse2D.Double(

getX(), getY(), getSize(), getSize());

return circle.contains(p);

}

public Rectangle2D getBounds() {

return new Rectangle2D.Double(

getX(), getY(), getSize(), getSize());

}

public Point2D getConnectionPoint(Point2D other) {

double centerX = getX() + getSize() / 2;

double centerY = getY() + getSize() / 2;

double dx = other.getX() - centerX;

double dy = other.getY() - centerY;

double distance = Math.sqrt(dx * dx + dy * dy);

if (distance == 0) {

return other;

} else {

return new Point2D.Double(

centerX + dx * (getSize() / 2) / distance,

centerY + dy * (getSize() / 2) / distance);

}

}

}

/**

* The class ColorEditor manages colors with a JColorChooser. It customizes some

* of the methods of the PropertyEditor interface that the class

* PropertyEditorSupport implements, in particular, supportsCustomEditor(),

* getCustomEditor(), isPaintable(), paintValue().

*

* See text pp. 313-4.

*

* yanushka

*/

import java.beans.*;

import java.awt.*;

import javax.swing.*;

import javax.swing.event.*;

public class ColorEditor extends PropertyEditorSupport {

private static final long serialVersionUID = 1;

public boolean supportsCustomEditor() {

return true;

}

public boolean isPaintable() {

return true;

}

/**

* Customize paintValue() to fill box with the current color.

*

* @param g, a Graphics object

* @param box, a Rectangle object for painting

*/

public void paintValue(Graphics g, Rectangle box) {

Graphics2D g2 = (Graphics2D) g;

g2.setColor((Color) getValue());

g2.fill(box);

}

/**

* Define a CustomEditor using a JColorChooser object.

*

* @return a JColorChooser object with an anonymous controller

*/

public Component getCustomEditor() {

final JColorChooser jcc = new JColorChooser();

jcc.getSelectionModel().addChangeListener(new ChangeListener() {

public void stateChanged(ChangeEvent ce) {

setValue(jcc.getColor());

}

});

return jcc;

}

}

import java.awt.*;

import java.awt.geom.*;

import java.io.*;

import java.util.*;

import java.util.List;

/**

* A graph in which all nodes make every connection to all other nodes with

* undirected edges

*/

//completely new graph

public class CompleteGraph extends SimpleGraph {

private int diameter; // The diameter of the invisible circle on which the nodes lie

/**

* Constructor, adds the number of nodes to the graph on the circle and

* calls connectAll()

*

* @param d diameter of circle to place nodes

* @param n numbers of nodes to place

*/

public CompleteGraph(int d, int n) {

diameter = d;

int r = diameter / 2;

double x = r;

double y = r;

double theta = 2 * Math.PI / n;

clearAll();

while (getNodes().size() < n) {

CircleNode c = new CircleNode(Color.WHITE);

x = r * Math.sin(-1 * (getNodes().size()) * theta + Math.PI);

y = r * Math.cos(-1 * (getNodes().size()) * theta + Math.PI);

add(c, new Point2D.Double(x + r, y + r));

c.sendIndex(getNodes().size() - 1);

}

connectAll();

}

public Node[] getNodePrototypes() {

Node[] nodeTypes = {

new CircleNode(Color.BLACK),

new CircleNode(Color.WHITE),

new SquareNode(Color.LIGHT_GRAY)

};

return nodeTypes;

}

public Edge[] getEdgePrototypes() {

Edge[] edgeTypes = {

new LineEdge(),

new LineEdge(true)

};

return edgeTypes;

}

/**

* Connects all the points together in a graph with undirected edges

*/

private void connectAll() {

int i = 0;

int j = 1;

while (i < getNodes().size()) {

while (j < getNodes().size()) {

LineEdge l = new LineEdge(false);

l.setStart(getNodes().get(i));

l.setEnd(getNodes().get(j));

addEdge(l);

j++;

}

i++;

j = i + 1;

}

}

}

import java.awt.*;

import java.awt.geom.*;

import java.io.*;

/**

* An edge in a graph.

*/

public interface Edge extends Serializable, Cloneable {

/**

* Draw the edge.

*

* @param g2 the graphics context

*/

void draw(Graphics2D g2);

/**

* Tests whether the edge contains a point.

*

* @param aPoint the point to test

* @return true if this edge contains aPoint

*/

boolean contains(Point2D aPoint);

/**

* Connects this edge to two nodes.

*

* @param aStart the starting node

* @param anEnd the ending node

*/

void connect(Node aStart, Node anEnd);

/**

* Gets the starting node.

*

* @return the starting node

*/

Node getStart();

/**

* Gets the ending node.

*

* @return the ending node

*/

Node getEnd();

/**

* Sets the starting node.

*

* @param the new starting node.

*/

void setStart(Node n);

/**

* Sets the ending node.

*

* @param the new ending node.

*/

void setEnd(Node n);

/**

* Gets the points at which this edge is connected to its nodes.

*

* @return a line joining the two connection points

*/

Line2D getConnectionPoints();

/**

* Gets the smallest rectangle that bounds this edge. The bounding rectangle

* contains all labels.

*

* @return the bounding rectangle

*/

Rectangle2D getBounds(Graphics2D g2);

/**

* Clones this edge.

*

* @return a copy of the edge

*/

Object clone();

/**

* Returns whether this edge equals e.

*

* @param e the edge to which this edge is compared.

* @return whether e equals this edge.

*/

boolean equals(Object e);

/**

* Р'озвращает метку ребра

* @return строка с меткой узла

*/

String getLabel();

/**

* Р'озвращает true если узел направленный, иначе false

* @return true если узел направленный, иначе false

*/

boolean getDirected();

}

import java.beans.*;

/**

* A property editor for enumerated types.

*/

public class EnumEditor extends PropertyEditorSupport {

/**

* Constructs a property editor for an enumerated type

*

* @param cl the class object for the enumerated type

*/

public EnumEditor(Class cl) {

this.cl = cl;

}

public String[] getTags() {

try {

Object[] values = (Object[]) cl.getMethod("values").invoke(null);

String[] result = new String[values.length];

for (int i = 0; i < values.length; i++) {

result[i] = values[i].toString();

}

return result;

} catch (Exception ex) {

return null;

}

}

public String getAsText() {

return getValue().toString();

}

public void setAsText(String s) {

setValue(Enum.valueOf(cl, s));

}

private Class cl;

}

/**

* The class FontEditor manages an editor for available and viewable fonts. It

* customizes some of the methods of the PropertyEditor interface that the class

* PropertyEditorSupport implements, in particular, a constructor,

* supportsCustomEditor(), getCustomEditor(), isPaintable(), paintValue().

* updateFont() assists the construction of the editor in getCustomEditor().

*

* The editor is a JPanel object with a JLabel object, a JComboBox object

* containing names for fonts, a JTextField object for the size and a JComboBox

* object for the style of the current Font object.

*

* The class has as its attribute an array of String objects for the the names

* of the available and viewable fonts.

*

* See first edition of text p. 313-4.

*

* yanushka

*/

import java.beans.*;

import java.awt.*;

import java.awt.geom.*;

import java.awt.event.*;

import java.awt.font.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

public class FontEditor extends PropertyEditorSupport {

/**

* Create a FontEditor object with a finite set of String objects. Get the

* available fonts in fontArray. Retain the ones that display in the

* ArrayList fontList. Then transfer fontList into the arrays names and

* fonts.

*/

public FontEditor() {

GraphicsEnvironment ge =

GraphicsEnvironment.getLocalGraphicsEnvironment();

String[] fontArray = ge.getAvailableFontFamilyNames();

ArrayList< String> fontList =

new ArrayList< String>(fontArray.length);

for (int i = 0; i < fontArray.length; i++) {

if (new Font(fontArray[ i], Font.PLAIN, 12).canDisplayUpTo(

fontArray[ i]) == -1) {

fontList.add(fontArray[ i]);

}

}

names = new String[fontList.size()];

for (int i = 0; i < fontList.size(); i++) {

names[ i] = fontList.get(i);

}

}

public boolean supportsCustomEditor() {

return true;

}

public boolean isPaintable() {

return true;

}

/**

* Define a custom editor for the Font class.

*

* @return a JPanel object

*

* The panel consists of a JLabel, a JComboBox object containing names for

* fonts, a JTextField object for the size and a JComboBox object for the

* style of the current Font object. Define an anonymous controller for each

* combo box and for the text field.

*/

public Component getCustomEditor() {

final JComboBox fonts = new JComboBox(names),

styles = new JComboBox(STYLES);

final JTextField sizeTF = new JTextField("12");

final JLabel label = new JLabel("Abcd0123.");

fonts.setSelectedItem("Arial");

styles.setSelectedItem("Plain");

JPanel panel = new JPanel(new GridLayout(1, 4));

panel.add(label);

panel.add(fonts);

panel.add(sizeTF);

panel.add(styles);

JComboBox[] widgets = {fonts, styles};

for (int i = 0; i < 2; i++) {

widgets[ i].addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

updateFont(fonts, styles, sizeTF, label);

}

});

}

sizeTF.getDocument().addDocumentListener(new DocumentListener() {

public void insertUpdate(DocumentEvent e) {

try {

updateFont(fonts, styles, sizeTF, label);

setAsText(sizeTF.getText());

} catch (IllegalArgumentException exception) {

}

}

public void removeUpdate(DocumentEvent e) {

try {

updateFont(fonts, styles, sizeTF, label);

setAsText(sizeTF.getText());

} catch (IllegalArgumentException exception) {

}

}

public void changedUpdate(DocumentEvent e) {

}

});

return panel;

}

/**

* Update selected Font object.

*

* @param fonts, a JComboBox object of available fonts

* @param style, a JComboBox object of plain, bold and italic

* @param sizeTF, a JTextField object for the size of the font

* @param label, a JLabel object to display the selected font

*/

private void updateFont(JComboBox fonts, JComboBox styles,

JTextField sizeTF, JLabel label) {

String strF = (String) fonts.getSelectedItem();

int style = Font.PLAIN,

size = Integer.parseInt((String) sizeTF.getText());

if (((String) styles.getSelectedItem()).equals("Bold")) {

style = Font.BOLD;

} else if (((String) styles.getSelectedItem()).equals("Italic")) {

style = Font.ITALIC;

}

Font font = new Font(strF, style, size);

label.setFont(font);

setValue(font);

}

/**

* Customize paintValue() to fill box with the current color.

*

* @param g, a Graphics object

* @param box, a Rectangle object for painting

*

* Draw the name of the font centered in box.

*/

public void paintValue(Graphics g, Rectangle box) {

Graphics2D g2 = (Graphics2D) g;

Font font = (Font) getValue();

String name = font.getName();

FontRenderContext frc = g2.getFontRenderContext();

Rectangle2D b = font.getStringBounds(name, frc);

double xSlack = Math.max(box.getWidth() - b.getWidth(), 0),

xStart = box.getX() + xSlack / 2,

yTop = box.getY() + (box.getHeight() - b.getHeight()) / 2,

yStart = yTop - b.getY();

g2.setColor(Color.BLACK);

g2.drawString(name, (float) xStart, (float) yStart);

}

private String[] names;

private static final String[] STYLES = {"Plain", "Bold", "Italic"};

}

import java.awt.*;

/**

* A layout manager that lays out components along a central axis

*/

class FormLayout implements LayoutManager {

public Dimension preferredLayoutSize(Container parent) {

Component[] components = parent.getComponents();

left = 0;

right = 0;

height = 0;

for (int i = 0; i < components.length; i += 2) {

Component cleft = components[i];

Component cright = components[i + 1];

Dimension dleft = cleft.getPreferredSize();

Dimension dright = cright.getPreferredSize();

left = Math.max(left, dleft.width);

right = Math.max(right, dright.width);

height = height + Math.max(dleft.height,

dright.height);

}

return new Dimension(left + GAP + right, height + EXTRA_HEIGHT);

}

public Dimension minimumLayoutSize(Container parent) {

return preferredLayoutSize(parent);

}

public void layoutContainer(Container parent) {

preferredLayoutSize(parent); // sets left, right

Component[] components = parent.getComponents();

Insets insets = parent.getInsets();

int xcenter = insets.left + left;

int y = insets.top;

for (int i = 0; i < components.length; i += 2) {

Component cleft = components[i];

Component cright = components[i + 1];

Dimension dleft = cleft.getPreferredSize();

Dimension dright = cright.getPreferredSize();

int height = Math.max(dleft.height,

dright.height);

cleft.setBounds(xcenter - dleft.width, y + (height

- dleft.height) / 2, dleft.width, dleft.height);

cright.setBounds(xcenter + GAP, y + (height

- dright.height) / 2, dright.width, dright.height);

y += height;

}

}

public void addLayoutComponent(String name,

Component comp) {

}

public void removeLayoutComponent(Component comp) {

}

private int left;

private int right;

private int height;

private static final int GAP = 6;

private static final int EXTRA_HEIGHT = 60;

}

/**

* The class FontEditor manages an editor for available and viewable fonts. It

* customizes some of the methods of the PropertyEditor interface that the class

* PropertyEditorSupport implements, in particular, a constructor,

* supportsCustomEditor(), getCustomEditor(), isPaintable(), paintValue().

* updateFont() assists the construction of the editor in getCustomEditor().

*

* The editor is a JPanel object with a JLabel object, a JComboBox object

* containing names for fonts, a JTextField object for the size and a JComboBox

* object for the style of the current Font object.

*

* The class has as its attribute an array of String objects for the the names

* of the available and viewable fonts.

*

* See first edition of text p. 313-4.

*

* yanushka

*/

import java.beans.*;

import java.awt.*;

import java.awt.geom.*;

import java.awt.event.*;

import java.awt.font.*;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

public class FontEditor extends PropertyEditorSupport {

/**

* Create a FontEditor object with a finite set of String objects. Get the

* available fonts in fontArray. Retain the ones that display in the

* ArrayList fontList. Then transfer fontList into the arrays names and

* fonts.

*/

public FontEditor() {

GraphicsEnvironment ge =

GraphicsEnvironment.getLocalGraphicsEnvironment();

String[] fontArray = ge.getAvailableFontFamilyNames();

ArrayList< String> fontList =

new ArrayList< String>(fontArray.length);

for (int i = 0; i < fontArray.length; i++) {

if (new Font(fontArray[ i], Font.PLAIN, 12).canDisplayUpTo(

fontArray[ i]) == -1) {

fontList.add(fontArray[ i]);

}

}

names = new String[fontList.size()];

for (int i = 0; i < fontList.size(); i++) {

names[ i] = fontList.get(i);

}

}

public boolean supportsCustomEditor() {

return true;

}

public boolean isPaintable() {

return true;

}

/**

* Define a custom editor for the Font class.

*

* @return a JPanel object

*

* The panel consists of a JLabel, a JComboBox object containing names for

* fonts, a JTextField object for the size and a JComboBox object for the

* style of the current Font object. Define an anonymous controller for each

* combo box and for the text field.

*/

public Component getCustomEditor() {

final JComboBox fonts = new JComboBox(names),

styles = new JComboBox(STYLES);

final JTextField sizeTF = new JTextField("12");

final JLabel label = new JLabel("Abcd0123.");

fonts.setSelectedItem("Arial");

styles.setSelectedItem("Plain");

JPanel panel = new JPanel(new GridLayout(1, 4));

panel.add(label);

panel.add(fonts);

panel.add(sizeTF);

panel.add(styles);

JComboBox[] widgets = {fonts, styles};

for (int i = 0; i < 2; i++) {

widgets[ i].addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

updateFont(fonts, styles, sizeTF, label);

}

});

}

sizeTF.getDocument().addDocumentListener(new DocumentListener() {

public void insertUpdate(DocumentEvent e) {

try {

updateFont(fonts, styles, sizeTF, label);

setAsText(sizeTF.getText());

} catch (IllegalArgumentException exception) {

}

}

public void removeUpdate(DocumentEvent e) {

try {

updateFont(fonts, styles, sizeTF, label);

setAsText(sizeTF.getText());

} catch (IllegalArgumentException exception) {

}

}

public void changedUpdate(DocumentEvent e) {

}

});

return panel;

}

/**

* Update selected Font object.

*

* @param fonts, a JComboBox object of available fonts

* @param style, a JComboBox object of plain, bold and italic

* @param sizeTF, a JTextField object for the size of the font

* @param label, a JLabel object to display the selected font

*/

private void updateFont(JComboBox fonts, JComboBox styles,

JTextField sizeTF, JLabel label) {

String strF = (String) fonts.getSelectedItem();

int style = Font.PLAIN,

size = Integer.parseInt((String) sizeTF.getText());

if (((String) styles.getSelectedItem()).equals("Bold")) {

style = Font.BOLD;

} else if (((String) styles.getSelectedItem()).equals("Italic")) {

style = Font.ITALIC;

}

Font font = new Font(strF, style, size);

label.setFont(font);

setValue(font);

}

/**

* Customize paintValue() to fill box with the current color.

*

* @param g, a Graphics object

* @param box, a Rectangle object for painting

*

* Draw the name of the font centered in box.

*/

public void paintValue(Graphics g, Rectangle box) {

Graphics2D g2 = (Graphics2D) g;

Font font = (Font) getValue();

String name = font.getName();

FontRenderContext frc = g2.getFontRenderContext();

Rectangle2D b = font.getStringBounds(name, frc);

double xSlack = Math.max(box.getWidth() - b.getWidth(), 0),

xStart = box.getX() + xSlack / 2,

yTop = box.getY() + (box.getHeight() - b.getHeight()) / 2,

yStart = yTop - b.getY();

g2.setColor(Color.BLACK);

g2.drawString(name, (float) xStart, (float) yStart);

}

private String[] names;

private static final String[] STYLES = {"Plain", "Bold", "Italic"};

}

import java.awt.*;

import java.awt.geom.*;

import java.io.*;

import java.util.*;

import java.util.List;

/**

* A graph consisting of selectable nodes and edges.

*/

public abstract class Graph implements Serializable {

/**

* Constructs a graph with no nodes or edges.

*/

public Graph() {

nodes = new ArrayList<Node>();

edges = new ArrayList<Edge>();

}

/**

* Adds an edge to the graph that joins the nodes containing the given

* points. If the points aren't both inside nodes, then no edge is added.

*

* @param e the edge to add

* @param p1 a point in the starting node

* @param p2 a point in the ending node

*/

public boolean connect(Edge e, Point2D p1, Point2D p2) {

Node n1 = findNode(p1);

Node n2 = findNode(p2);

if (n1 != null && n2 != null && (!n1.getClass().equals(new NoteNode("").getClass()))

&& (!n2.getClass().equals(new NoteNode("").getClass()))) {

e.connect(n1, n2);

edges.add(e);

return true;

}

return false;

}

/**

* Reverses all directed edges in the graph.

*/

public void reverse() {

for (int i = 0; i < edges.size(); i++) {

Node temp = edges.get(i).getStart();

edges.get(i).setStart(edges.get(i).getEnd());

edges.get(i).setEnd(temp);

}

}

/**

* Takes this graph and switches all of the edges and non edges.

*/

public void complement() {

ArrayList<Edge> allEdges = new ArrayList<Edge>();

int i = 0;

int j = 1;

while (i < nodes.size()) {

while (nodes.get(i).getClass().equals(new NoteNode("").getClass()) && i < (nodes.size() - 1)) {

i++;

}

while (j < nodes.size()) {

while (nodes.get(j).getClass().equals(new NoteNode("").getClass()) && j < (nodes.size() - 1)) {

j++;

}

if (!nodes.get(i).getClass().equals(new NoteNode("").getClass())

&& !nodes.get(j).getClass().equals(new NoteNode("").getClass())) {

LineEdge l = new LineEdge(false);

l.setStart(nodes.get(i));

l.setEnd(nodes.get(j));

allEdges.add(l);

} // Only fails if a note is at last index.

j++;

}

i++;

j = i + 1;

}

allEdges.removeAll(edges);

edges = allEdges;

}

/**

* Adds a node to the graph so that the top left corner of the bounding

* rectangle is at the given point.

*

* @param n the node to add

* @param p the desired location

* @return that the node was added.

*/

public boolean add(Node n, Point2D p) {

Rectangle2D bounds = n.getBounds();

n.translate(p.getX() - bounds.getX(),

p.getY() - bounds.getY());

nodes.add(n);

return true;

}

/**

* Adds a specified edge to the graph.

*

* @param e the edge to be added.

*/

public void addEdge(Edge e) {

if (e.getStart() != null && e.getEnd() != null) {

edges.add(e);

}

}

/**

* Finds a node containing the given point.

*

* @param p a point

* @return a node containing p or null if no nodes contain p

*/

public Node findNode(Point2D p) {

for (int i = nodes.size() - 1; i >= 0; i--) {

Node n = nodes.get(i);

if (n.contains(p)) {

return n;

}

}

return null;

}

/**

* Finds an edge containing the given point.

*

* @param p a point

* @return an edge containing p or null if no edges contain p

*/

public Edge findEdge(Point2D p) {

for (int i = edges.size() - 1; i >= 0; i--) {

Edge e = edges.get(i);

if (e.contains(p)) {

return e;

}

}

return null;

}

/**

* Draws the graph

*

* @param g2 the graphics context

*/

public void draw(Graphics2D g2) {

for (Node n : nodes) {

n.draw(g2);

}

for (Edge e : edges) {

e.draw(g2);

}

}

/**

* Removes a node and all edges that start or end with that node

*

* @param n the node to remove

*/

public void removeNode(Node n) {

for (int i = edges.size() - 1; i >= 0; i--) {

Edge e = edges.get(i);

if (e.getStart() == n || e.getEnd() == n) {

edges.remove(e);

}

}

nodes.remove(n);

}

/**

* Removes an edge from the graph.

*

* @param e the edge to remove

*/

public void removeEdge(Edge e) {

edges.remove(e);

}

/**

* Gets the smallest rectangle enclosing the graph

*

* @param g2 the graphics context

* @return the bounding rectangle

*/

public Rectangle2D getBounds(Graphics2D g2) {

Rectangle2D r = null;

for (Node n : nodes) {

Rectangle2D b = n.getBounds();

if (r == null) {

r = b;

} else {

r.add(b);

}

}

for (Edge e : edges) {

r.add(e.getBounds(g2));

}

return r == null ? new Rectangle2D.Double() : r;

}

/**

* Gets the node types of a particular graph type.

*

* @return an array of node prototypes

*/

public abstract Node[] getNodePrototypes();

/**

* Gets the edge types of a particular graph type.

*

* @return an array of edge prototypes

*/

public abstract Edge[] getEdgePrototypes();

/**

* Gets the nodes of this graph.

*

* @return an unmodifiable list of the nodes

*/

public List<Node> getNodes() {

return Collections.unmodifiableList(nodes);

}

/**

* Gets the edges of this graph.

*

* @return an unmodifiable list of the edges

*/

public List<Edge> getEdges() {

return Collections.unmodifiableList(edges);

}

/**

* Removes all nodes and edges from this graph.

*/

public void clearAll() {

nodes.clear();

edges.clear();

}

private ArrayList<Node> nodes;

private ArrayList<Edge> edges;

}

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.event.*;

import java.awt.image.*;

import javax.imageio.*;

import javax.swing.filechooser.*;

/**

* This frame shows the toolbar and the graph.

*/

public class GraphFrame extends JFrame {

/**

* Constructs a graph frame that displays a given graph.

*

* @param graph the graph to display

*/

public GraphFrame(final Graph graph, boolean isMR) {

setTitle("Редактор Графов 0.1");

setSize(FRAME_WIDTH, FRAME_HEIGHT);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//setLocation(5,5);

this.graph = graph;

isMoreRandom = isMR;

constructFrameComponents();

// set up menus

JMenuBar menuBar = new JMenuBar();

setJMenuBar(menuBar);

JMenu fileMenu = new JMenu("Файл");

menuBar.add(fileMenu);

JMenuItem openItem = new JMenuItem("Открыть");

openItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

openFile();

}

});

fileMenu.add(openItem);

JMenuItem saveItem = new JMenuItem("Сохранить");

saveItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

saveFile();

}

});

fileMenu.add(saveItem);

JMenuItem exitItem = new JMenuItem("Р'ыход");

exitItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

System.exit(0);

}

});

fileMenu.add(exitItem);

JMenuItem deleteItem = new JMenuItem("Удалить");

deleteItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

panel.removeSelected();

}

});

JMenuItem propertiesItem = new JMenuItem("Свойства");

propertiesItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

panel.editSelected();

}

});

JMenuItem reverseItem = new JMenuItem("Реверсировать");

reverseItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

panel.reverseEdges();

}

});

JMenuItem incidence = new JMenuItem("Матрица инциденции");

incidence.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel.incidence();

}

});

JMenuItem adjacency = new JMenuItem("Матрица смежности");

adjacency.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel.adjacency();

}

});

JMenuItem clearItem = new JMenuItem("Очистка");

clearItem.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent event) {

panel.clearAll();

}

});

JMenuItem graphMatrix = new JMenu("Матрица инциндеции");

graphMatrix.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

}

});

JMenu editMenu = new JMenu("Редактировать");

JMenu graphMenu = new JMenu("Граф");

editMenu.add(clearItem);

editMenu.add(deleteItem);

editMenu.add(propertiesItem);

graphMenu.add(reverseItem);

graphMenu.add(incidence);

graphMenu.add(adjacency);

menuBar.add(editMenu);

menuBar.add(graphMenu);

}

/**

* Constructs the tool bar and graph panel.

*/

private void constructFrameComponents() {

toolBar = new ToolBar(graph);

panel = new GraphPanel(toolBar, graph);

scrollPane = new JScrollPane(panel);

this.add(toolBar, BorderLayout.SOUTH);

this.add(scrollPane, BorderLayout.CENTER);

}

/**

* Export the current finite graph as a graphics file in png format.

*/

private void export() {

JFileChooser fileChooser = new JFileChooser(CURR_DIR);

// Not supported in pre Java 6. Comment out if running Java 5 or earlier.

javax.swing.filechooser.FileFilter pingFilter = new FileNameExtensionFilter("ping graphics files", "png");

fileChooser.addChoosableFileFilter(pingFilter);

int choice = fileChooser.showDialog(null, "Export");

if (choice == JFileChooser.APPROVE_OPTION) {

try {

File file = fileChooser.getSelectedFile();

RenderedImage image = createGraphImage();

ImageIO.write(image, "png", file);

} catch (IOException exception) {

JOptionPane.showMessageDialog(null, exception);

}

}

}

/**

* Create a RenderedImage object for the current Graph object.

*

* http://www.exampledepot.com/egs/javax.imageio/Graphic2File.html

*/

private RenderedImage createGraphImage() {

BufferedImage bufferedImage = new BufferedImage(

panel.getWidth(), panel.getHeight(),

BufferedImage.TYPE_INT_RGB);

// Create a graphics contents on the buffered image.

Graphics2D g2d = bufferedImage.createGraphics();

// Draw graphics.

g2d.setColor(Color.white);

g2d.fillRect(0, 0, panel.getWidth(), panel.getHeight());

g2d.setColor(Color.black);

panel.paintComponent(g2d);

g2d.dispose();

return bufferedImage;

}

/**

* Asks the user to open a graph file.

*/

private void openFile() {

// let user select file

JFileChooser fileChooser = new JFileChooser();

int r = fileChooser.showOpenDialog(this);

if (r == JFileChooser.APPROVE_OPTION) {

// open the file that the user selected

try {

File file = fileChooser.getSelectedFile();

ObjectInputStream in = new ObjectInputStream(

new FileInputStream(file));

graph = (Graph) in.readObject();

in.close();

this.remove(scrollPane);

this.remove(toolBar);

constructFrameComponents();

validate();

repaint();

} catch (IOException exception) {

JOptionPane.showMessageDialog(null,

exception);

} catch (ClassNotFoundException exception) {

JOptionPane.showMessageDialog(null,

exception);

}

}

}

/**

* Saves the current graph in a file.

*/

private void saveFile() {

JFileChooser fileChooser = new JFileChooser();

if (fileChooser.showSaveDialog(this)

== JFileChooser.APPROVE_OPTION) {

try {

File file = fileChooser.getSelectedFile();

ObjectOutputStream out = new ObjectOutputStream(

new FileOutputStream(file));

out.writeObject(graph);

out.close();

} catch (IOException exception) {

JOptionPane.showMessageDialog(null,

exception);

}

}

}

/**

* Reads a text file for input

*/

public void importList() {

JFileChooser fileChooser = new JFileChooser();

int r = fileChooser.showOpenDialog(this);

if (r == JFileChooser.APPROVE_OPTION) {

// open the file that the user selected

try {

File file = fileChooser.getSelectedFile();

graph = new AdjacencyListGraph(file);

this.remove(scrollPane);

this.remove(toolBar);

constructFrameComponents();

validate();

repaint();

} finally {

}

}

}

/**

* Returns whether or not RandomGraphs have randomized colors and sizes.

*

* @return if the graph is set to display more random RandomGraphs.

*/

public boolean getIsMoreRandom() {

return isMoreRandom;

}

/**

* Sets whether or not RandomGraphs have randomized colors and sizes.

*

* @param isMR the new value of isMoreRandom

*/

public void setIsMoreRandom(boolean isMR) {

isMoreRandom = isMR;

}

private Graph graph;

private GraphPanel panel;

private JScrollPane scrollPane;

private ToolBar toolBar;

private boolean isMoreRandom;

private static final String CURR_DIR = ".";

public static final int FRAME_WIDTH = 600;

public static final int FRAME_HEIGHT = 400;

}

import java.awt.*;

import java.awt.geom.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

import java.lang.reflect.*;

/**

* A panel to draw a graph

*/

public class GraphPanel extends JComponent {

/**

* Constructs a graph.

*

* @param aToolBar the tool bar with the node and edge tools

* @param aGraph the graph to be displayed and edited

*/

public GraphPanel(ToolBar aToolBar, Graph aGraph) {

toolBar = aToolBar;

graph = aGraph;

setBackground(Color.WHITE);

addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent event) {

Point2D mousePoint = event.getPoint();

Node n = graph.findNode(mousePoint);

Edge e = graph.findEdge(mousePoint);

Object tool = toolBar.getSelectedTool();

if (tool == null) // select

{

if (e != null) {

selected = e;

} else if (n != null) {

selected = n;

dragStartPoint = mousePoint;

dragStartBounds = n.getBounds();

} else {

selected = null;

}

} else if (tool instanceof Node) {

Node prototype = (Node) tool;

Node newNode = (Node) prototype.clone();

boolean added = graph.add(newNode, mousePoint);

try {

if (newNode.getClass().getMethod("setLabel", new Class[]{String.class}) != null) {

Method m = newNode.getClass().getMethod("setLabel", new Class[]{String.class});

Method me = newNode.getClass().getMethod("getDefaultLabel");

try {

String s = (String) me.invoke(newNode, new Object[]{});

m.invoke(newNode, new Object[]{s});

} catch (IllegalAccessException exception) {

exception.printStackTrace();

} catch (InvocationTargetException exception) {

exception.printStackTrace();

}

}

} catch (NoSuchMethodException exception) {

exception.printStackTrace();

}

if (added) {

if (!newNode.getClass().equals(new NoteNode("").getClass())) {

newNode.sendIndex(graph.getNodes().size() - 1);

}

selected = newNode;

dragStartPoint = mousePoint;

dragStartBounds = newNode.getBounds();

} else if (n != null) {

selected = n;

dragStartPoint = mousePoint;

dragStartBounds = n.getBounds();

}

} else if (tool instanceof Edge) {

if (n != null) {

rubberBandStart = mousePoint;

}

}

lastMousePoint = mousePoint;

repaint();

}

public void mouseReleased(MouseEvent event) {

Object tool = toolBar.getSelectedTool();

if (rubberBandStart != null) {

Point2D mousePoint = event.getPoint();

Edge prototype = (Edge) tool;

Edge newEdge = (Edge) prototype.clone();

if (graph.connect(newEdge,

rubberBandStart, mousePoint)) {

selected = newEdge;

}

}

revalidate();

repaint();

lastMousePoint = null;

dragStartBounds = null;

rubberBandStart = null;

}

});

addMouseMotionListener(new MouseMotionAdapter() {

public void mouseDragged(MouseEvent event) {

Point2D mousePoint = event.getPoint();

if (dragStartBounds != null) {

if (selected instanceof Node) {

Node n = (Node) selected;

Rectangle2D bounds = n.getBounds();

n.translate(

dragStartBounds.getX() - bounds.getX()

+ mousePoint.getX() - dragStartPoint.getX(),

dragStartBounds.getY() - bounds.getY()

+ mousePoint.getY() - dragStartPoint.getY());

}

}

lastMousePoint = mousePoint;

repaint();

}

});

}

/**

* Paints the graph to the panel.

*

* @paraam g the graphics object on which the graph will be drawn.

*/

public void paintComponent(Graphics g) {

Graphics2D g2 = (Graphics2D) g;

Rectangle2D bounds = getBounds();

Rectangle2D graphBounds = graph.getBounds(g2);

graph.draw(g2);

if (selected instanceof Node) {

Rectangle2D grabberBounds = ((Node) selected).getBounds();

drawGrabber(g2, grabberBounds.getMinX(), grabberBounds.getMinY());

drawGrabber(g2, grabberBounds.getMinX(), grabberBounds.getMaxY());

drawGrabber(g2, grabberBounds.getMaxX(), grabberBounds.getMinY());

drawGrabber(g2, grabberBounds.getMaxX(), grabberBounds.getMaxY());

}

if (selected instanceof Edge) {

Line2D line = ((Edge) selected).getConnectionPoints();

drawGrabber(g2, line.getX1(), line.getY1());

drawGrabber(g2, line.getX2(), line.getY2());

}

if (rubberBandStart != null) {

Color oldColor = g2.getColor();

g2.setColor(PURPLE);

g2.draw(new Line2D.Double(rubberBandStart, lastMousePoint));

g2.setColor(oldColor);

}

}

/**

* Removes the selected node or edge.

*/

public void removeSelected() {

if (selected instanceof Node) {

graph.removeNode((Node) selected);

} else if (selected instanceof Edge) {

graph.removeEdge((Edge) selected);

}

selected = null;

repaint();

}

/**

* Reverses the all Edges

*/

public void reverseEdges() {

graph.reverse();

selected = null;

repaint();

}

/**

* Проверка всех меток графа

*/

public boolean checkLabel() {

if (graph.getNodes().isEmpty()) return false;

for (int i = 0; i < graph.getEdges().size(); i++) {

Edge e = graph.getEdges().get(i);

if (e.getLabel().equals("") ||

e.getStart().getLabel().equals("") ||

e.getEnd().getLabel().equals(""))

return false;

}

return true;

}

/**

* Р'озвращает индекс узла

* @param s метка узла

* @return индекс узла

*/

public int getNodeIndex(String s) {

int i;

for (i = 0; i < graph.getNodes().size(); i++) {

if (graph.getNodes().get(i).getLabel().equals(s)) break;

}

return i;

}

/**

* Р'озвращает индекс ребра

* @param label метка ребра

* @return индекс ребра

*/

public int getEdgeIndex(String label) {

int i;

for (i = 0; i < graph.getEdges().size(); i++) {

if (graph.getEdges().get(i).getLabel().equals(label))

return i;

}

return i;

}

/**

* Р'ыводит РѕРєРЅРѕ СЃ матрицей инциденции

*/

public void incidence() {

JFrame frame = new JFrame("Матрица инциденции");

//frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

if (!checkLabel()) {

JOptionPane.showMessageDialog(null,

"РќРµ РІСЃРµ метки установлены (Р'ыделите элемент графа Рё измените метку РІ меню Редактировать->Свойства)");

return;

}

String[] columnNames = new String[graph.getEdges().size()+1];

String[][] data = new String[graph.getNodes().size()][graph.getEdges().size()+1];

columnNames[0] = "";

for (int i = 0; i < graph.getEdges().size(); i++) {

columnNames[i+1] = graph.getEdges().get(i).getLabel();

}

for (int i = 0; i < graph.getNodes().size(); i++) {

data[i][0] = graph.getNodes().get(i).getLabel();

}

for (int i = 0; i < graph.getNodes().size(); i++) {

for (int j = 1; j < graph.getEdges().size() + 1; j++) {

data[i][j] = "0";

}

}

for (int i = 0; i < graph.getEdges().size(); i++) {

Edge e = graph.getEdges().get(i);

data[getNodeIndex(e.getStart().getLabel())][getEdgeIndex(e.getLabel())+1] = "1";

data[getNodeIndex(e.getEnd().getLabel())][getEdgeIndex(e.getLabel())+1] = "1";

}

JTable table = new JTable(data, columnNames);

JScrollPane scrollPane = new JScrollPane(table);

frame.getContentPane().add(scrollPane);

frame.set...