0001: // The UMLet source code is distributed under the terms of the GPL; see license.txt
0002: package com.umlet.element.base;
0003:
0004: import java.awt.*;
0005: import java.awt.font.*;
0006: import java.awt.geom.*;
0007: import java.util.*;
0008:
0009: import com.umlet.control.*;
0010: import com.umlet.element.base.detail.*;
0011:
0012: /**
0013: * <p>Title:</p>
0014: * <p>Description:</p>
0015: * <p>Copyright: Copyright (c) 2001</p>
0016: * <p>Company:</p>
0017: *
0018: * @author unascribed
0019: * @version 1.0
0020: */
0021:
0022: public class Relation extends Entity {
0023:
0024: String beginQualifier;
0025: String endQualifier;
0026: String beginArrow;
0027: String endArrow;
0028: String beginMultiplicity;
0029: String endMultiplicity;
0030: String beginRole;
0031: String endRole;
0032: String lineType;
0033: String eerRelDir;
0034:
0035: Vector<String> _strings;
0036:
0037: // A.Mueller start
0038: String clientServer;
0039: // A.Mueller end
0040:
0041: // G.Mueller start
0042: String beginPort;
0043: String endPort;
0044: String middleArrow;
0045: String csdStartText; // Arrow-Text for composite structure diagram
0046: String csdEndText;
0047:
0048: // G.Mueller end
0049:
0050: private Vector<String> getStrings() {
0051: if (_strings == null) {
0052: _strings = new Vector<String>();
0053: }
0054: return _strings;
0055: }
0056:
0057: private void setStrings(Vector<String> v) {
0058: _strings = v;
0059: }
0060:
0061: private Point getCenterOfLine() {
0062: Point ret = new Point();
0063: if (this .getLinePoints().size() % 2 == 1)
0064: ret = this .getLinePoints().elementAt(
0065: this .getLinePoints().size() / 2);
0066: else {
0067: Point p1 = this .getLinePoints().elementAt(
0068: this .getLinePoints().size() / 2);
0069: Point p2 = this .getLinePoints().elementAt(
0070: this .getLinePoints().size() / 2 - 1);
0071: ret.x = (p1.x + p2.x) / 2;
0072: ret.y = (p1.y + p2.y) / 2;
0073: }
0074: return ret;
0075: }
0076:
0077: public String getAdditionalAttributes() {
0078: Vector<String> tmp = new Vector<String>();
0079: // tmp.add(beginQualifier);
0080: // tmp.add(endQualifier);
0081: // tmp.add(beginArrow);
0082: // tmp.add(endArrow);
0083: // tmp.add(beginMultiplicity);
0084: // tmp.add(endMultiplicity);
0085: // tmp.add(beginRole);
0086: // tmp.add(endRole);
0087: // tmp.add(lineType);
0088:
0089: /*
0090: * tmp.add(""+this.getX()); tmp.add(""+this.getY());
0091: * tmp.add(""+this.getWidth()); tmp.add(""+this.getHeight());
0092: */
0093:
0094: for (int i = 0; i < this .getLinePoints().size(); i++) {
0095: Point p = this .getLinePoints().elementAt(i);
0096: String s1 = "" + p.x;
0097: String s2 = "" + p.y;
0098: tmp.add(s1);
0099: tmp.add(s2);
0100: }
0101:
0102: String ret = Constants.composeStrings(tmp,
0103: Constants.DELIMITER_ADDITIONAL_ATTRIBUTES);
0104: return ret;
0105: }
0106:
0107: public void setHiddenState(String s) {
0108: Vector<String> tmp = Constants
0109: .decomposeStringsIncludingEmptyStrings(s,
0110: Constants.DELIMITER_FIELDS);
0111: // 9 attributes, 4 for start/end point, 4 for x,y,w,h
0112: if (tmp.size() < 17)
0113: throw new RuntimeException(
0114: "UMLet: Error in Relation.setHiddenState(), state value = "
0115: + s);
0116:
0117: beginQualifier = tmp.elementAt(0);
0118: endQualifier = tmp.elementAt(1);
0119: beginArrow = tmp.elementAt(2);
0120: endArrow = tmp.elementAt(3);
0121: beginMultiplicity = tmp.elementAt(4);
0122: endMultiplicity = tmp.elementAt(5);
0123: beginRole = tmp.elementAt(6);
0124: endRole = tmp.elementAt(7);
0125: lineType = tmp.elementAt(8);
0126:
0127: int x = Integer.parseInt(tmp.elementAt(9));
0128: int y = Integer.parseInt(tmp.elementAt(10));
0129: int w = Integer.parseInt(tmp.elementAt(11));
0130: int h = Integer.parseInt(tmp.elementAt(12));
0131: this .setBounds(x, y, w, h);
0132:
0133: for (int i = 13; i < tmp.size(); i = i + 2) {
0134: int xx = Integer.parseInt(tmp.elementAt(i));
0135: int yy = Integer.parseInt(tmp.elementAt(i + 1));
0136: Point p = new Point(xx, yy);
0137: this .getLinePoints().add(p);
0138: }
0139: }
0140:
0141: public void setAdditionalAttributes(String s) {
0142: Vector<String> tmp = Constants
0143: .decomposeStringsIncludingEmptyStrings(s,
0144: Constants.DELIMITER_ADDITIONAL_ATTRIBUTES);
0145: // 9 attributes, 4 for start/end point, 4 for x,y,w,h
0146: /*
0147: * if (tmp.size()<17) throw new RuntimeException("UMLet: Error in
0148: * Relation.setHiddenState(), state value = "+s);
0149: *
0150: * beginQualifier=(String)tmp.elementAt(0);
0151: * endQualifier=(String)tmp.elementAt(1);
0152: * beginArrow=(String)tmp.elementAt(2);
0153: * endArrow=(String)tmp.elementAt(3);
0154: * beginMultiplicity=(String)tmp.elementAt(4);
0155: * endMultiplicity=(String)tmp.elementAt(5);
0156: * beginRole=(String)tmp.elementAt(6); endRole=(String)tmp.elementAt(7);
0157: * lineType=(String)tmp.elementAt(8);
0158: *
0159: * int x=Integer.parseInt((String)tmp.elementAt(9)); int
0160: * y=Integer.parseInt((String)tmp.elementAt(10)); int
0161: * w=Integer.parseInt((String)tmp.elementAt(11)); int
0162: * h=Integer.parseInt((String)tmp.elementAt(12));
0163: * this.setBounds(x,y,w,h);
0164: */
0165:
0166: for (int i = 0; i < tmp.size(); i = i + 2) {
0167: int xx = Integer.parseInt(tmp.elementAt(i));
0168: int yy = Integer.parseInt(tmp.elementAt(i + 1));
0169: Point p = new Point(xx, yy);
0170: this .getLinePoints().add(p);
0171: }
0172: }
0173:
0174: public void setState(String state) {
0175: beginQualifier = "";
0176: endQualifier = "";
0177: beginArrow = "";
0178: endArrow = "";
0179: beginMultiplicity = "";
0180: endMultiplicity = "";
0181: beginRole = "";
0182: endRole = "";
0183: lineType = "-";
0184: eerRelDir = "";
0185: // G.Mueller.Start
0186: middleArrow = "";
0187: beginPort = "";
0188: endPort = "";
0189: //G.Mueller. End
0190: this .setStrings(null);
0191:
0192: _state = state;
0193:
0194: Vector<String> tmp = Constants.decomposeStrings(state, "\n");
0195:
0196: for (int i = 0; i < tmp.size(); i++) {
0197: String s = tmp.elementAt(i);
0198: if (s.startsWith("q1=") & s.length() > 3) {
0199: beginQualifier = s.substring(3, s.length());
0200: } else if (s.startsWith("q2=") & s.length() > 3) {
0201: endQualifier = s.substring(3, s.length());
0202: } else if (s.startsWith("m1=") & s.length() > 3) {
0203: beginMultiplicity = s.substring(3, s.length());
0204: } else if (s.startsWith("m2=") & s.length() > 3) {
0205: endMultiplicity = s.substring(3, s.length());
0206: } else if (s.startsWith("r1=") & s.length() > 3) {
0207: beginRole = s.substring(3, s.length());
0208: } else if (s.startsWith("r2=") & s.length() > 3) {
0209: endRole = s.substring(3, s.length());
0210: } else if (s.startsWith("p1=") & s.length() > 3) {
0211: beginPort = s.substring(3, s.length());
0212: } else if (s.startsWith("p2=") & s.length() > 3) {
0213: endPort = s.substring(3, s.length());
0214: } else if (s.startsWith("lt=") & s.length() > 3) {
0215:
0216: // Mueller G. Beginn
0217:
0218: csdStartText = "";
0219: csdEndText = "";
0220:
0221: // ***
0222:
0223: if (s.indexOf("<[") >= 0) {
0224: beginArrow = "compStart";
0225: if (s.length() > 6) {
0226: csdStartText = getCSDText(s)[0];
0227: s = s.replace("<[" + csdStartText + "]", "<[]");
0228: }
0229: }
0230:
0231: if (s.indexOf("]>") >= 0) {
0232: endArrow = "compEnd";
0233: if (s.length() > 6) {
0234: csdEndText = getCSDText(s)[1];
0235: s = s.replace("[" + csdEndText + "]>", "[]>");
0236: }
0237: }
0238:
0239: if (s.indexOf("]<") >= 0) {
0240: beginArrow = beginArrow + "del";
0241: }
0242:
0243: if (s.indexOf(">[") >= 0) {
0244: endArrow = endArrow + "del";
0245: }
0246:
0247: // Mueller G. End
0248:
0249: if (s.indexOf(">>>>>") >= 0) { //LME_A
0250: endArrow = "<<<";
0251: } else if (s.indexOf(">>>>") >= 0) {
0252: endArrow = "X";
0253: } else if (s.indexOf(">>>") >= 0) {
0254: endArrow = "x";
0255: } else if (s.indexOf(">>") >= 0) {
0256: endArrow = "<<";
0257: } else if (s.indexOf(">") >= 0) {
0258: if (endArrow.equals(""))
0259: endArrow = "<";
0260: }
0261:
0262: if (s.indexOf("<<<<<") >= 0) { //LME: filled arrow head
0263: beginArrow = "<<<";
0264: } else if (s.indexOf("<<<<") >= 0) {
0265: beginArrow = "X";
0266: } else if (s.indexOf("<<<") >= 0) {
0267: beginArrow = "x";
0268: } else if (s.indexOf("<<") >= 0) {
0269: beginArrow = "<<";
0270: } else if (s.indexOf("<") >= 0) {
0271: if (beginArrow.equals(""))
0272: beginArrow = "<";
0273: }
0274:
0275: if (s.indexOf("<EER>") >= 0) {
0276: beginArrow = "";
0277: endArrow = "";
0278: eerRelDir = "EER1";
0279: } else if (s.indexOf("<EER") >= 0) {
0280: beginArrow = "";
0281: endArrow = "";
0282: eerRelDir = "EER2";
0283: } else if (s.indexOf("EER>") >= 0) {
0284: beginArrow = "";
0285: endArrow = "";
0286: eerRelDir = "EER3";
0287: } else if (s.indexOf("EER") >= 0) {
0288: beginArrow = "";
0289: endArrow = "";
0290: eerRelDir = "EER_SUBCLASS";
0291: }
0292:
0293: // A.Mueller Beginn
0294: clientServer = "";
0295:
0296: // ***
0297:
0298: if (s.indexOf("(()") >= 0) {
0299: //beginArrow = ""; G.Mueller
0300: clientServer = "provideRequire";
0301: } else if (s.indexOf("())") >= 0) {
0302: //endArrow = ""; G.Mueller
0303: clientServer = "requireProvide";
0304: }
0305:
0306: if (s.indexOf("<(+)") >= 0) {
0307: beginArrow = "packageStart";
0308: clientServer = " ";
0309: } else if (s.indexOf("<()") >= 0) {
0310: clientServer = "start"; // used for setting the startpoint
0311: // nonstickable
0312: beginArrow = "require";
0313: } else if (s.indexOf("<(") >= 0) {
0314: clientServer = "start"; // used for setting the
0315: // startpoint
0316: // not stickable
0317: beginArrow = "provide";
0318:
0319: } else if (s.indexOf("<x") >= 0) {
0320: beginArrow = "n";
0321: }
0322:
0323: if (s.indexOf("(+)>") >= 0) {
0324: endArrow = "packageEnd";
0325: clientServer = " ";
0326: } else if (s.indexOf("()>") >= 0) {
0327: clientServer = "end"; // used for setting the endpoint
0328: // nonstickable
0329: endArrow = "require";
0330: } else if (s.indexOf(")>") >= 0) {
0331: clientServer = "end"; // used for setting the endpoint
0332: // nonstickable
0333: endArrow = "provide";
0334: } else if (s.indexOf("x>") >= 0) {
0335: endArrow = "n";
0336: }
0337: // A.Mueller End
0338: // Mueller G. End
0339:
0340: // Mueller G. Start
0341:
0342: if (s.indexOf(">()") >= 0 && clientServer.equals("")) {
0343: middleArrow = "delegationArrowRight";
0344: if (endArrow.equals("<"))
0345: endArrow = "";
0346: } else if (s.indexOf("()<") >= 0
0347: && clientServer.equals("")) {
0348: middleArrow = "delegationArrowLeft";
0349: if (beginArrow.equals("<"))
0350: beginArrow = "";
0351: } else if (s.indexOf("()") >= 0
0352: && clientServer.equals("")) {
0353: middleArrow = "delegation";
0354: } else if (s.indexOf("(") >= 0
0355: && clientServer.equals("")) {
0356: middleArrow = "delegationStart";
0357: lineType = "-.";
0358: } else if (s.indexOf(")") >= 0
0359: && clientServer.equals("")) {
0360: middleArrow = "delegationEnd";
0361: lineType = ".-";
0362: }
0363: // G.Mueller: LineTyp check here:
0364:
0365: if (s.indexOf(".") >= 0
0366: & s.indexOf("-") >= s.indexOf(".")) {
0367: lineType = ".-";
0368: } else if (s.indexOf("-") >= 0
0369: & s.indexOf(".") >= s.indexOf("-")) {
0370: lineType = "-.";
0371: } else if (s.indexOf(".") >= 0) {
0372: lineType = ".";
0373: } else if (s.indexOf("-") >= 0) {
0374: lineType = "-";
0375: }
0376:
0377: // Mueller G. End
0378:
0379: } else {
0380: this .getStrings().add(s);
0381: }
0382: }
0383: } // Created objects have no sideeffects
0384:
0385: // Only exception: no point is outside shape
0386: // At least 2 points must be provided
0387: public static Vector<Point> getIntersectingLineSegment(Area r,
0388: Vector<Point> points) {
0389: Vector<Point> ret = new Vector<Point>();
0390:
0391: // If no segment found, take last two points
0392: Point pp_end = points.elementAt(points.size() - 1);
0393: Point pp_start = points.elementAt(points.size() - 2);
0394:
0395: for (int i = 1; i < points.size(); i++) {
0396: pp_end = points.elementAt(i);
0397: if (!r.contains(pp_end)) {
0398: // End point of intersecting line found
0399: pp_start = points.elementAt(i - 1);
0400:
0401: ret.add(pp_start);
0402: ret.add(pp_end);
0403: return ret;
0404: }
0405: }
0406:
0407: ret.add(pp_start);
0408: ret.add(pp_end);
0409: return ret;
0410: }
0411:
0412: public static Point moveNextTo(Area rFixed, Rectangle rMovable,
0413: Point pStart, Point pEnd) {
0414: // These ints can simply be added to line
0415: int centerDiffX = (int) -rMovable.getWidth() / 2;
0416: int centerDiffY = (int) -rMovable.getHeight() / 2;
0417:
0418: int vectorX = pEnd.x - pStart.x;
0419: int vectorY = pEnd.y - pStart.y;
0420:
0421: int startx = pStart.x;
0422: int starty = pStart.y;
0423: int endx = pEnd.x;
0424: int endy = pEnd.y;
0425:
0426: for (int i = 0;; i++) {
0427: endx += vectorX;
0428: endy += vectorY;
0429: rMovable
0430: .setLocation(endx + centerDiffX, endy + centerDiffY);
0431: if (!rFixed.intersects(rMovable))
0432: break;
0433: }
0434:
0435: int newx = 0;
0436: int newy = 0;
0437: for (int i = 0; i < 10; i++) {
0438: newx = (endx + startx) / 2;
0439: newy = (endy + starty) / 2;
0440: rMovable
0441: .setLocation(newx + centerDiffX, newy + centerDiffY);
0442: if (rFixed.intersects(rMovable)) {
0443: startx = newx;
0444: starty = newy;
0445: } else {
0446: endx = newx;
0447: endy = newy;
0448: }
0449: }
0450:
0451: Point ret = new Point(newx + centerDiffX, newy + centerDiffY);
0452: return ret;
0453: }
0454:
0455: public static boolean lineUp(Vector<Rectangle> shapes,
0456: Vector<Point> points, int hotspotx, int hotspoty) {
0457: // Remove point with the same coordinates
0458: for (int i = points.size() - 1; i > 0; i--) {
0459: Point p1 = points.elementAt(i);
0460: Point p2 = points.elementAt(i - 1);
0461: if (p1.x == p2.x & p1.y == p2.y)
0462: points.removeElementAt(i);
0463: }
0464: if (points.size() <= 1)
0465: return false;
0466:
0467: if (shapes.size() <= 1)
0468: return true;
0469:
0470: // Vector ret=new Vector();
0471:
0472: // Rectangle rFixed;
0473: Rectangle rMovable;
0474: Area tmpArea = new Area();
0475: for (int i = 0; i < shapes.size() - 1; i++) {
0476: Rectangle r = shapes.elementAt(i);
0477: if (i == 0) { // The hotspot of the first element is set
0478: Point p = points.elementAt(0);
0479: r.setLocation(p.x - hotspotx, p.y - hotspoty);
0480: }
0481: Area a = new Area(r);
0482: tmpArea.add(a);
0483:
0484: // rFixed=(Rectangle)shapes.elementAt(i);
0485: rMovable = shapes.elementAt(i + 1);
0486:
0487: /*
0488: * if (i==0) { // The hotspot of the first element is set Point
0489: * p=(Point)points.elementAt(0);
0490: * rFixed.setLocation(p.x-hotspotx,p.y-hotspoty); }
0491: */
0492:
0493: Vector<Point> tmp = getIntersectingLineSegment(tmpArea,
0494: points);
0495: Point startIntersectingLine = tmp.elementAt(0);
0496: Point endIntersectingLine = tmp.elementAt(1);
0497:
0498: Point res = moveNextTo(tmpArea, rMovable,
0499: startIntersectingLine, endIntersectingLine);
0500: // ret.add(res);
0501:
0502: if (rMovable instanceof Arrow) {
0503: Arrow arrow = (Arrow) rMovable;
0504:
0505: Point diffA = new Point(-startIntersectingLine.x
0506: + endIntersectingLine.x,
0507: -startIntersectingLine.y
0508: + endIntersectingLine.y);
0509: Point diffB1 = new Point(diffA.y, -diffA.x);
0510: Point diffB2 = new Point(-diffB1.x, -diffB1.y);
0511: Point a1 = new Point(2 * diffA.x + diffB1.x, 2
0512: * diffA.y + diffB1.y);
0513: Point a2 = new Point(2 * diffA.x + diffB2.x, 2
0514: * diffA.y + diffB2.y);
0515:
0516: a1 = Constants.normalize(a1, Constants.getFontsize());
0517: a2 = Constants.normalize(a2, Constants.getFontsize());
0518:
0519: arrow.setArrowEndA(a1);
0520: arrow.setArrowEndB(a2);
0521:
0522: // A.Mueller start
0523: if (arrow.getString().equals("n")) {
0524: // this is pretty much the same as above, but it
0525: // was hard to work out what it does so here it
0526: // is repeated with better names and some
0527: // comments. I only made the original vector longer and
0528: // increased the pixelsize(fontsize)
0529: // to get the point further towards the center.
0530: Point start = startIntersectingLine;
0531: Point end = endIntersectingLine;
0532: // vectorA is the vector between the two points which is the
0533: // line between the points...
0534: Point vectorA = new Point(-start.x + end.x,
0535: -start.y + end.y);
0536: // vector down is a vector standing 90 degrees on the line,
0537: // vector up is the same in the opposite direction..
0538: Point vectorDown = new Point(vectorA.y, -vectorA.x);
0539: Point vectorUp = new Point(-vectorDown.x,
0540: -vectorDown.y);
0541: Point newA1 = new Point(4 * vectorA.x
0542: + vectorDown.x, 4 * vectorA.y
0543: + vectorDown.y);
0544: Point newA2 = new Point(4 * vectorA.x + vectorUp.x,
0545: 4 * vectorA.y + diffB2.y);
0546:
0547: // this calculates the proportion of the two dimensions of
0548: // the point compared to each other
0549: // (which means propX + propY = 1) and multiplies it with
0550: // the second parameter...
0551: newA1 = Constants.normalize(newA1, Constants
0552: .getFontsize() * 2);
0553: newA2 = Constants.normalize(newA2, Constants
0554: .getFontsize() * 2);
0555:
0556: arrow.setCrossEndA(newA1);
0557: arrow.setCrossEndB(newA2);
0558: } else if (arrow.getString().equals("require")) {
0559: Point start = startIntersectingLine;
0560: Point end = endIntersectingLine;
0561: Point upperLeft = new Point();
0562: Point bottomDown = new Point();
0563: if (start.getX() > end.getX()) {
0564: upperLeft = new Point(0, -20 / 2);
0565: bottomDown = new Point(20, 20 / 2);
0566:
0567: } else if (start.getX() < end.getX()) {
0568: upperLeft = new Point(-20, -20 / 2);
0569: bottomDown = new Point(0, 20 / 2);
0570: } else if (start.getX() == end.getX()) {
0571: if (start.getY() < end.getY()) {
0572: upperLeft = new Point(-20 / 2, -20);
0573: bottomDown = new Point(20 / 2, 0);
0574: } else if (start.getY() > end.getY()) {
0575: upperLeft = new Point(-20 / 2, 0);
0576: bottomDown = new Point(20 / 2, 20);
0577: }
0578: }
0579: arrow.setCrossEndA(upperLeft);
0580: arrow.setCrossEndB(bottomDown);
0581:
0582: } else if (arrow.getString().equals("provide")) {
0583: Point start = startIntersectingLine;
0584: Point end = endIntersectingLine;
0585: Point upperLeft = new Point();
0586: Point bottomDown = new Point();
0587: if (start.getX() > end.getX()) {
0588: upperLeft = new Point(0, -30 / 2);
0589: bottomDown = new Point(30, 30 / 2);
0590: arrow.setArcStart(90);
0591: arrow.setArcEnd(180);
0592:
0593: } else if (start.getX() < end.getX()) {
0594: upperLeft = new Point(-30, -30 / 2);
0595: bottomDown = new Point(0, 30 / 2);
0596: arrow.setArcStart(90);
0597: arrow.setArcEnd(-180);
0598: } else if (start.getX() == end.getX()) {
0599: if (start.getY() < end.getY()) {
0600: upperLeft = new Point(-30 / 2, -30);
0601: bottomDown = new Point(30 / 2, 0);
0602: arrow.setArcStart(0);
0603: arrow.setArcEnd(-180);
0604: } else if (start.getY() > end.getY()) {
0605: upperLeft = new Point(-30 / 2, 0);
0606: bottomDown = new Point(30 / 2, 30);
0607: arrow.setArcStart(0);
0608: arrow.setArcEnd(180);
0609: }
0610: }
0611: arrow.setCrossEndA(upperLeft);
0612: arrow.setCrossEndB(bottomDown);
0613:
0614: // A.Mueller end
0615: }
0616:
0617: }
0618:
0619: // ATTENTION: this Recangle will become the rFixed in the next loop
0620: rMovable.setLocation(res);
0621: }
0622:
0623: return true;
0624: }
0625:
0626: public boolean isOnLine(int i) {
0627: if (i - 1 >= 0 & i + 1 < getLinePoints().size()) {
0628: Point x1 = getLinePoints().elementAt(i - 1);
0629: Point x2 = getLinePoints().elementAt(i + 1);
0630: Point p = getLinePoints().elementAt(i);
0631: if (pyth(p, x1) + pyth(p, x2) < pyth(x1, x2) + 5)
0632: return true;
0633: }
0634: return false;
0635: }
0636:
0637: public int getWhereToInsert(Point p) {
0638: for (int i = 0; i < getLinePoints().size() - 1; i++) {
0639: Point x1 = getLinePoints().elementAt(i);
0640: Point x2 = getLinePoints().elementAt(i + 1);
0641: if (pyth(p, x1) + pyth(p, x2) < pyth(x1, x2) + 5)
0642: return i + 1;
0643: }
0644: return -1;
0645: }
0646:
0647: public int getLinePoint(Point p) {
0648: for (int i = 0; i < getLinePoints().size(); i++) {
0649: Point x = getLinePoints().elementAt(i);
0650: if (pyth(p, x) < 15)
0651: return i;
0652: }
0653: return -1;
0654: }
0655:
0656: private int pyth(Point x1, Point x2) {
0657: int a = x1.x - x2.x;
0658: int b = x1.y - x2.y;
0659: return (int) Math.sqrt(a * a + b * b);
0660: }
0661:
0662: private <T> Vector<T> flipVector(Vector<T> v) {
0663: Vector<T> ret = new Vector<T>();
0664: for (int i = v.size() - 1; i >= 0; i--) {
0665: ret.add(v.elementAt(i));
0666: }
0667: return ret;
0668: }
0669:
0670: public boolean contains(Point p) {
0671:
0672: for (int i = 0; i < getLinePoints().size(); i++) {
0673: Point x = getLinePoints().elementAt(i);
0674: if (pyth(p, x) < 15)
0675: return true;
0676: }
0677:
0678: for (int i = 0; i < getLinePoints().size() - 1; i++) {
0679: Point x1 = getLinePoints().elementAt(i);
0680: Point x2 = getLinePoints().elementAt(i + 1);
0681:
0682: if (pyth(p, x1) + pyth(p, x2) > pyth(x1, x2) + 5)
0683: continue;
0684:
0685: //system origin translated to x1
0686: double p1x = x2.getX() - x1.getX();
0687: double p1y = x2.getY() - x1.getY();
0688: double p2x = p.getX() - x1.getX();
0689: double p2y = p.getY() - x1.getY();
0690: //constant - calculated constant by rotating line + calculation intersection point
0691: double c = (p1x * p2x + p1y * p2y)
0692: / (p1x * p1x + p1y * p1y);
0693:
0694: //intersection point
0695: double i1x = p1x * c;
0696: double i1y = p1y * c;
0697:
0698: //abstand
0699: double ax = i1x - p2x;
0700: double ay = i1y - p2y;
0701: double a = Math.sqrt(ax * ax + ay * ay);
0702:
0703: if (a < 5)
0704: return true;
0705: }
0706: return false;
0707: }
0708:
0709: public boolean contains(int x, int y) {
0710: return contains(new Point(x, y));
0711: }
0712:
0713: private Vector<Point> _points;
0714:
0715: public Vector<Point> getLinePoints() {
0716: if (_points == null) {
0717: _points = new Vector<Point>();
0718: }
0719: return _points;
0720: }
0721:
0722: public void setLinePoints(Vector<Point> v) {
0723: _points = v;
0724: }
0725:
0726: public Entity CloneFromMe() {
0727: Relation c = new Relation();
0728:
0729: c.setState(this .getPanelAttributes());
0730: c.setAdditionalAttributes(this .getAdditionalAttributes());
0731:
0732: c.setVisible(true);
0733: c.setBounds(this .getBounds());
0734: return c;
0735: }
0736:
0737: public Relation() {
0738: super ();
0739: }
0740:
0741: public Relation(String s) {
0742: super (s);
0743: }
0744:
0745: //Polygon to draw the move wohle line rectangle + check if it contains the mouse
0746: public Polygon getWholeLinePolygon() {
0747: Polygon p = new Polygon();
0748: Point mid;
0749: int s = this .getLinePoints().size();
0750: if (s % 2 == 0 && s > 0)
0751: mid = this .getCenterOfLine();
0752: else if (s > 2) {
0753: Point p1 = this .getLinePoints().elementAt(
0754: this .getLinePoints().size() / 2);
0755: Point p2 = this .getLinePoints().elementAt(
0756: this .getLinePoints().size() / 2 + 1);
0757: mid = new Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
0758: } else
0759: return null;
0760:
0761: int size = 10;
0762: size = size / 2;
0763: p.addPoint(mid.x - size, mid.y - size);
0764: p.addPoint(mid.x + size, mid.y - size);
0765: p.addPoint(mid.x + size, mid.y + size);
0766: p.addPoint(mid.x - size, mid.y + size);
0767: return p;
0768: }
0769:
0770: //checks if the point is contained in the polygon above
0771: public boolean isWholeLine(int x, int y) {
0772: Polygon p = this .getWholeLinePolygon();
0773: if (p == null)
0774: return false;
0775: if (p.contains(x, y))
0776: return true;
0777: return false;
0778: }
0779:
0780: public void paint(Graphics g) {
0781: Graphics2D g2 = (Graphics2D) g;
0782: g2.setFont(Constants.getFont());
0783: g2.setColor(_activeColor);
0784: Constants.getFRC(g2); // Just to set anti-aliasing, even if no text
0785: // operations occur
0786:
0787: // g2.setColor(Color.MAGENTA);
0788: // g2.drawLine(0,0,0,2);
0789: // g2.drawLine(0,0,2,0);
0790: // g2.drawLine(this.getWidth()-1-2,this.getHeight()-1, this.getWidth()-1,this.getHeight()-1);
0791: // g2.drawLine(this.getWidth()-1,this.getHeight()-1-2, this.getWidth()-1,this.getHeight()-1);
0792: // g2.setColor(_activeColor);
0793:
0794: Vector<Rectangle> startShapes = new Vector<Rectangle>();
0795: Vector<Rectangle> endShapes = new Vector<Rectangle>();
0796:
0797: startShapes.add(new NoShape());
0798: endShapes.add(new NoShape());
0799:
0800: if (beginQualifier != null && beginQualifier.length() > 0) {
0801: TextLayout tl = new TextLayout(beginQualifier, Constants
0802: .getFont(), Constants.getFRC(g2));
0803: Qualifier q = new Qualifier(beginQualifier, 0, 0, (int) tl
0804: .getBounds().getWidth()
0805: + Constants.getFontsize() * 2, (int) tl.getBounds()
0806: .getHeight()
0807: + Constants.getFontsize() / 2);
0808: startShapes.add(q);
0809: }
0810: if (endQualifier != null && endQualifier.length() > 0) {
0811: TextLayout tl = new TextLayout(endQualifier, Constants
0812: .getFont(), Constants.getFRC(g2));
0813: Qualifier q = new Qualifier(endQualifier, 0, 0, (int) tl
0814: .getBounds().getWidth()
0815: + Constants.getFontsize() * 2, (int) tl.getBounds()
0816: .getHeight()
0817: + Constants.getFontsize() / 2);
0818: endShapes.add(q);
0819: }
0820: if (beginArrow != null && beginArrow.length() > 0) {
0821: Arrow a = new Arrow(beginArrow);
0822: startShapes.add(a);
0823: }
0824: if (endArrow != null && endArrow.length() > 0) {
0825: Arrow a = new Arrow(endArrow);
0826: endShapes.add(a);
0827: }
0828: if (beginMultiplicity != null && beginMultiplicity.length() > 0) {
0829: EmptyShape e = new EmptyShape();
0830: startShapes.add(e);
0831: TextLayout tl = new TextLayout(beginMultiplicity, Constants
0832: .getFont(), Constants.getFRC(g2));
0833: Multiplicity m = new Multiplicity(beginMultiplicity, 0, 0,
0834: (int) tl.getBounds().getWidth(), (int) tl
0835: .getBounds().getHeight());
0836: startShapes.add(m);
0837: }
0838: if (endMultiplicity != null && endMultiplicity.length() > 0) {
0839: EmptyShape e = new EmptyShape();
0840: endShapes.add(e);
0841: TextLayout tl = new TextLayout(endMultiplicity, Constants
0842: .getFont(), Constants.getFRC(g2));
0843: Multiplicity m = new Multiplicity(endMultiplicity, 0, 0,
0844: (int) tl.getBounds().getWidth(), (int) tl
0845: .getBounds().getHeight());
0846: endShapes.add(m);
0847: }
0848: if (beginRole != null && beginRole.length() > 0) {
0849: EmptyShape e = new EmptyShape();
0850: startShapes.add(e);
0851: // A.Mueller start
0852: // calculating the width if we break lines...
0853:
0854: int position = 0;
0855: int lineBreaks = 0;
0856: double broadestText = Constants
0857: .getPixelWidth(g2, beginRole);
0858: while (position != 1) {
0859: int positionNew = beginRole.indexOf("\\\\", position);
0860: if (position == 0 && positionNew != -1)
0861: broadestText = 0;
0862:
0863: if (positionNew != -1) {
0864:
0865: broadestText = Math.max(broadestText, Constants
0866: .getPixelWidth(g2, beginRole.substring(
0867: position, positionNew)));
0868: if (beginRole.lastIndexOf("\\\\") + 2 != beginRole
0869: .length())
0870: broadestText = Math
0871: .max(
0872: broadestText,
0873: Constants
0874: .getPixelWidth(
0875: g2,
0876: beginRole
0877: .substring(
0878: beginRole
0879: .lastIndexOf("\\\\") + 2,
0880: beginRole
0881: .length())));
0882: lineBreaks++;
0883: }
0884:
0885: position = positionNew + 2;
0886: }
0887: Role r = new Role(beginRole, 0, 0, (int) broadestText,
0888: lineBreaks * Constants.getFontsize()
0889: + (lineBreaks + 2)
0890: * Constants.getDistTextToText());
0891:
0892: // <OLDCODE>
0893: /*
0894: * TextLayout tl = new TextLayout(beginRole, Constants.getFont(),
0895: * Constants.getFRC(g2)); Role r = new Role(beginRole, 0, 0, (int)
0896: * tl.getBounds().getWidth(), (int) tl.getBounds().getHeight());
0897: */
0898: // </OLDCODE>
0899: // A.Mueller end
0900: startShapes.add(r);
0901: }
0902: if (endRole != null && endRole.length() > 0) {
0903: EmptyShape e = new EmptyShape();
0904: endShapes.add(e);
0905: // A.Mueller start
0906: // calculating the width if we break lines...
0907: int position = 0;
0908: int lineBreaks = 0;
0909: double broadestText = Constants.getPixelWidth(g2, endRole);
0910: while (position != 1) {
0911: int positionNew = endRole.indexOf("\\\\", position);
0912: if (position == 0 && positionNew != -1)
0913: broadestText = 0;
0914:
0915: if (positionNew != -1) {
0916:
0917: broadestText = Math.max(broadestText, Constants
0918: .getPixelWidth(g2, endRole.substring(
0919: position, positionNew)));
0920: if (endRole.lastIndexOf("\\\\") + 2 != endRole
0921: .length())
0922: broadestText = Math
0923: .max(
0924: broadestText,
0925: Constants
0926: .getPixelWidth(
0927: g2,
0928: endRole
0929: .substring(
0930: endRole
0931: .lastIndexOf("\\\\") + 2,
0932: endRole
0933: .length())));
0934: lineBreaks++;
0935: }
0936:
0937: position = positionNew + 2;
0938: }
0939: Role r = new Role(endRole, 0, 0, (int) broadestText,
0940: lineBreaks * Constants.getFontsize()
0941: + (lineBreaks + 2)
0942: * Constants.getDistTextToText());
0943:
0944: // <OLDCODE>
0945: /*
0946: * TextLayout tl = new TextLayout(endRole, Constants.getFont(),
0947: * Constants.getFRC(g2)); Role r = new Role(endRole, 0, 0, (int)
0948: * tl.getBounds().getWidth(), (int) tl.getBounds().getHeight());
0949: */
0950: // </OLDCODE>
0951: // A.Mueller end
0952: endShapes.add(r);
0953: }
0954: // G.Mueller start
0955: if (beginPort != null && beginPort.length() > 0) {
0956:
0957: EmptyShape e = new EmptyShape();
0958: startShapes.add(e);
0959: TextLayout tl = new TextLayout(beginPort, Constants
0960: .getFont(), Constants.getFRC(g2));
0961: Port p = new Port(beginPort, 0, 0, (int) tl.getBounds()
0962: .getWidth(), (int) tl.getBounds().getHeight());
0963:
0964: startShapes.add(p);
0965:
0966: }
0967: if (endPort != null && endPort.length() > 0) {
0968: EmptyShape e = new EmptyShape();
0969: endShapes.add(e);
0970: TextLayout tl = new TextLayout(endPort,
0971: Constants.getFont(), Constants.getFRC(g2));
0972: Port p = new Port(endPort, 0, 0, (int) tl.getBounds()
0973: .getWidth(), (int) tl.getBounds().getHeight());
0974: endShapes.add(p);
0975: }
0976: //G.Mueller end
0977:
0978: //******************************************************************
0979:
0980: Vector<Point> startPoints = new Vector<Point>(this
0981: .getLinePoints());
0982: Vector<Point> endPoints = flipVector(startPoints);
0983:
0984: boolean a = lineUp(startShapes, startPoints, 0, 0);
0985: boolean b = lineUp(endShapes, endPoints, 0, 0);
0986:
0987: if (a == false || b == false) {
0988: return;
0989: }
0990:
0991: // G.Mueller change begin
0992:
0993: if (lineType.equals("-."))
0994: g2.setStroke(Constants.getStroke(0, 1));
0995: else if (lineType.equals(".-"))
0996: g2.setStroke(Constants.getStroke(1, 1));
0997: else if (lineType.equals("-"))
0998: g2.setStroke(Constants.getStroke(0, 1));
0999: else if (lineType.equals("."))
1000: g2.setStroke(Constants.getStroke(1, 1));
1001:
1002: for (int i = 0; i < getLinePoints().size() - 1; i++) {
1003:
1004: if (i == Math.floor((getLinePoints().size() - 1) / 2)) {
1005:
1006: Point p1 = getLinePoints().elementAt(i);
1007: Point p2 = getLinePoints().elementAt(i + 1);
1008: // G.Mueller start
1009: Point pm = new Point(p1.x - (p1.x - p2.x) / 2, p1.y
1010: - (p1.y - p2.y) / 2);
1011: g2.drawLine(p1.x, p1.y, pm.x, pm.y);
1012: if (lineType.equals("-."))
1013: g2.setStroke(Constants.getStroke(1, 1));
1014: if (lineType.equals(".-"))
1015: g2.setStroke(Constants.getStroke(0, 1));
1016: g2.drawLine(pm.x, pm.y, p2.x, p2.y);
1017: //g2.drawLine(p1.x, p1.y, p2.x, p2.y);
1018: // G. Mueller end
1019:
1020: // ##########################################################################################
1021: // ##########################################################################################
1022: if (eerRelDir.indexOf("EER_SUBCLASS") >= 0) {
1023: Point px1 = getLinePoints().elementAt(i);
1024: Point px2 = getLinePoints().elementAt(i + 1);
1025: Point mitte = new Point(
1026: px1.x - (px1.x - px2.x) / 2, px1.y
1027: - (px1.y - px2.y) / 2);
1028:
1029: AffineTransform at = g2.getTransform();
1030: AffineTransform at2 = (AffineTransform) at.clone();
1031: int cx = mitte.x;
1032: int cy = mitte.y;
1033: double winkel = Constants.getAngle(px1.x, px1.y,
1034: px2.x, px2.y);
1035: at2.rotate(winkel, cx, cy);
1036: g2.setTransform(at2);
1037: g2.setColor(_activeColor);
1038: g2.setStroke(Constants.getStroke(0, 2));
1039: g2.drawArc(mitte.x, mitte.y - 10, 20, 20, 90, 180);
1040: g2.setStroke(Constants.getStroke(0, 1));
1041: g2.setTransform(at);
1042:
1043: } else if (eerRelDir.indexOf("EER") >= 0) {
1044: Point px1 = getLinePoints().elementAt(i);
1045: Point px2 = getLinePoints().elementAt(i + 1);
1046: Point mitte = new Point(
1047: px1.x - (px1.x - px2.x) / 2, px1.y
1048: - (px1.y - px2.y) / 2);
1049: int recSize = 20;
1050: Point r1 = new Point(mitte.x, mitte.y - recSize);
1051: Point r2 = new Point(mitte.x + recSize, mitte.y);
1052: Point r3 = new Point(mitte.x, mitte.y + recSize);
1053: Point r4 = new Point(mitte.x - recSize, mitte.y);
1054:
1055: Polygon po1 = new Polygon();
1056: po1.addPoint(r1.x, r1.y);
1057: po1.addPoint(r2.x, r2.y);
1058: po1.addPoint(r3.x, r3.y);
1059:
1060: Polygon po2 = new Polygon();
1061: po2.addPoint(r1.x, r1.y);
1062: po2.addPoint(r3.x, r3.y);
1063: po2.addPoint(r4.x, r4.y);
1064:
1065: AffineTransform at = g2.getTransform();
1066: AffineTransform at2 = (AffineTransform) at.clone();
1067: int cx = mitte.x;
1068: int cy = mitte.y;
1069: double winkel = Constants.getAngle(px1.x, px1.y,
1070: px2.x, px2.y);
1071: at2.rotate(winkel, cx, cy);
1072: g2.setTransform(at2);
1073:
1074: if (eerRelDir.equals("EER1")) {
1075: g2.setColor(_activeColor);
1076: g2.fillPolygon(po1);
1077: g2.fillPolygon(po2);
1078: } else if (eerRelDir.equals("EER2")) {
1079: g2.setColor(_fillColor);
1080: g2.fillPolygon(po2);
1081: g2.setColor(_activeColor);
1082: g2.fillPolygon(po1);
1083: } else if (eerRelDir.equals("EER3")) {
1084: g2.setColor(_fillColor);
1085: g2.fillPolygon(po1);
1086: g2.setColor(_activeColor);
1087: g2.fillPolygon(po2);
1088: }
1089: g2.setColor(_activeColor);
1090: g2.draw(po1);
1091: g2.draw(po2);
1092: g2.setTransform(at);
1093: }
1094:
1095: // A.Mueller start
1096: else if (clientServer != null
1097: && clientServer.indexOf("rovide") >= 0) {
1098: Point px1 = getLinePoints().elementAt(i);
1099: Point px2 = getLinePoints().elementAt(i + 1);
1100: Point mitte = new Point(
1101: px1.x - (px1.x - px2.x) / 2, px1.y
1102: - (px1.y - px2.y) / 2);
1103:
1104: AffineTransform at = g2.getTransform();
1105: AffineTransform at2 = (AffineTransform) at.clone();
1106: int cx = mitte.x;
1107: int cy = mitte.y;
1108: double winkel = Constants.getAngle(px1.x, px1.y,
1109: px2.x, px2.y);
1110: at2.rotate(winkel, cx, cy);
1111: g2.setTransform(at2);
1112:
1113: Point outerArc = new Point(mitte.x - 15,
1114: mitte.y - 15);
1115: Point innerCircle = new Point();
1116:
1117: g2.setColor(Color.white);
1118: g2.fillOval(outerArc.x, outerArc.y, 30, 30);
1119: g2.setColor(_activeColor);
1120: g2.setStroke(Constants.getStroke(0, 1));
1121:
1122: if (clientServer.equals("provideRequire")) {
1123: g2.drawArc(outerArc.x, outerArc.y, 30, 30, 90,
1124: 180);
1125: innerCircle = new Point(mitte.x - 5,
1126: mitte.y - 10);
1127: } else if (clientServer.equals("requireProvide")) {
1128: g2.drawArc(outerArc.x, outerArc.y, 30, 30, 90,
1129: -180);
1130:
1131: innerCircle = new Point(mitte.x - 15,
1132: mitte.y - 10);
1133: }
1134:
1135: g2.drawOval(innerCircle.x, innerCircle.y, 20, 20);
1136: g2.setTransform(at);
1137: }
1138: // A.Mueller end
1139: // G.Mueller start
1140: else if (middleArrow.startsWith("delegation")) {
1141:
1142: Point px1 = getLinePoints().elementAt(i);
1143: Point px2 = getLinePoints().elementAt(i + 1);
1144: Point mitte = new Point(
1145: px1.x - (px1.x - px2.x) / 2, px1.y
1146: - (px1.y - px2.y) / 2);
1147:
1148: AffineTransform at = g2.getTransform();
1149: AffineTransform at2 = (AffineTransform) at.clone();
1150: int cx = mitte.x;
1151: int cy = mitte.y;
1152: double winkel = Constants.getAngle(px1.x, px1.y,
1153: px2.x, px2.y);
1154: at2.rotate(winkel, cx, cy);
1155: g2.setTransform(at2);
1156:
1157: Point circle = new Point(mitte.x - 15, mitte.y - 15);
1158: if (middleArrow.equals("delegation")) {
1159: g2.setColor(Color.white);
1160: g2.fillOval(circle.x + 5, circle.y + 5, 20, 20);
1161: g2.setColor(_activeColor);
1162: g2.setStroke(Constants.getStroke(0, 1));
1163: g2.drawOval(circle.x + 5, circle.y + 5, 20, 20);
1164: }
1165: if (middleArrow.startsWith("delegationArrow")) {
1166: g2.setStroke(Constants.getStroke(0, 1));
1167: if (middleArrow.equals("delegationArrowRight")) {
1168: g2.drawLine(circle.x + 5, circle.y + 15,
1169: circle.x - 5, circle.y + 9);
1170: g2.drawLine(circle.x + 5, circle.y + 15,
1171: circle.x - 5, circle.y + 20);
1172: }
1173: if (middleArrow.equals("delegationArrowLeft")) {
1174: g2.drawLine(circle.x + 25, circle.y + 15,
1175: circle.x + 35, circle.y + 9);
1176: g2.drawLine(circle.x + 25, circle.y + 15,
1177: circle.x + 35, circle.y + 20);
1178: }
1179:
1180: g2.setColor(Color.white);
1181: g2.fillOval(circle.x + 5, circle.y + 5, 20, 20);
1182: g2.setColor(_activeColor);
1183: g2.setStroke(Constants.getStroke(0, 1));
1184: g2.drawOval(circle.x + 5, circle.y + 5, 20, 20);
1185:
1186: }
1187: if (middleArrow.equals("delegationStart")) {
1188: g2.setColor(Color.white);
1189: g2.fillArc(circle.x, circle.y, 30, 30, 90, 180);
1190: g2.setColor(_activeColor);
1191: g2.setStroke(Constants.getStroke(0, 1));
1192: g2.drawArc(circle.x, circle.y, 30, 30, 90, 180);
1193: }
1194: if (middleArrow.equals("delegationEnd")) {
1195: g2.setColor(Color.white);
1196: g2
1197: .fillArc(circle.x, circle.y, 30, 30,
1198: 90, -180);
1199: g2.setColor(_activeColor);
1200: g2.setStroke(Constants.getStroke(0, 1));
1201: g2
1202: .drawArc(circle.x, circle.y, 30, 30,
1203: 90, -180);
1204: }
1205:
1206: g2.setTransform(at);
1207:
1208: }
1209:
1210: // G.Mueller end
1211:
1212: // ##########################################################################################
1213: // ##########################################################################################
1214: if (lineType.equals("-."))
1215: g2.setStroke(Constants.getStroke(1, 1));
1216: if (lineType.equals(".-"))
1217: g2.setStroke(Constants.getStroke(0, 1));
1218:
1219: } else {
1220:
1221: Point p1 = getLinePoints().elementAt(i);
1222: Point p2 = getLinePoints().elementAt(i + 1);
1223: g2.drawLine(p1.x, p1.y, p2.x, p2.y);
1224: }
1225: }
1226:
1227: g2.setStroke(Constants.getStroke(0, 1));
1228: if (_selected) {
1229: for (int i = 0; i < getLinePoints().size(); i++) {
1230: Point p = getLinePoints().elementAt(i);
1231: g2.drawOval(p.x - 10, p.y - 10, 20, 20);
1232: }
1233:
1234: //DRAW Moveall Rect
1235: Polygon poly = this .getWholeLinePolygon();
1236: if (poly != null)
1237: g2.drawPolygon(poly);
1238: }
1239:
1240: Vector<Rectangle> tmp = new Vector<Rectangle>(startShapes);
1241: tmp.addAll(endShapes);
1242: for (int i = 0; i < tmp.size(); i++) {
1243: Rectangle r = tmp.elementAt(i);
1244: if (r instanceof Qualifier) {
1245:
1246: Qualifier q = (Qualifier) r;
1247:
1248: // begin B. Buckl
1249: g.setColor(_fillColor);
1250: g.fillRect((int) r.getX(), (int) r.getY(), (int) r
1251: .getWidth(), (int) r.getHeight());
1252: g.setColor(_activeColor);
1253: // end
1254: g.drawRect((int) r.getX(), (int) r.getY(), (int) r
1255: .getWidth(), (int) r.getHeight());
1256: Constants.write(g2, q.getString(), (int) r.getX()
1257: + Constants.getFontsize(), (int) r.getY()
1258: + Constants.getFontsize(), false);
1259:
1260: } else if (r instanceof Arrow) {
1261: Arrow arrow = (Arrow) r;
1262: // A.Mueller Start
1263: if (!arrow.getString().equals("n")
1264: && !arrow.getString().equals("require")
1265: && !arrow.getString().equals("provide")
1266: && !arrow.getString().startsWith("package")
1267: && !arrow.getString().startsWith("comp")) {
1268: // A.Mueller end
1269: g2.drawLine((int) arrow.getX(), (int) arrow.getY(),
1270: (int) arrow.getX()
1271: + (int) arrow.getArrowEndA().x,
1272: (int) arrow.getY()
1273: + (int) arrow.getArrowEndA().y);
1274: g2.drawLine((int) arrow.getX(), (int) arrow.getY(),
1275: (int) arrow.getX()
1276: + (int) arrow.getArrowEndB().x,
1277: (int) arrow.getY()
1278: + (int) arrow.getArrowEndB().y);
1279: // A.Mueller start
1280: }
1281: // A.Mueller end
1282:
1283: // System.out.println(arrow.getString());
1284:
1285: if (arrow.getString().equals("<<<")) { //LME
1286: //filled arrow head
1287: int[] ax = new int[3];
1288: int[] ay = new int[3];
1289: ax[0] = (int) arrow.getX();
1290: ax[1] = (int) arrow.getX()
1291: + (int) arrow.getArrowEndA().x;
1292: ax[2] = (int) arrow.getX()
1293: + (int) arrow.getArrowEndB().x;
1294: ay[0] = (int) arrow.getY();
1295: ay[1] = (int) arrow.getY()
1296: + (int) arrow.getArrowEndA().y;
1297: ay[2] = (int) arrow.getY()
1298: + (int) arrow.getArrowEndB().y;
1299: Polygon myPg = new Polygon(ax, ay, 3);
1300: g2.fill(myPg);
1301: g2.draw(myPg);
1302: } else if (arrow.getString().equals("<<")) {
1303: // begin B. Buckl
1304: int[] ax = new int[3];
1305: int[] ay = new int[3];
1306: ax[0] = (int) arrow.getX();
1307: ax[1] = (int) arrow.getX()
1308: + (int) arrow.getArrowEndA().x;
1309: ax[2] = (int) arrow.getX()
1310: + (int) arrow.getArrowEndB().x;
1311: ay[0] = (int) arrow.getY();
1312: ay[1] = (int) arrow.getY()
1313: + (int) arrow.getArrowEndA().y;
1314: ay[2] = (int) arrow.getY()
1315: + (int) arrow.getArrowEndB().y;
1316: Polygon myPg = new Polygon(ax, ay, 3);
1317: g2.setColor(_fillColor);
1318: g2.fill(myPg);
1319: g2.setColor(_activeColor);
1320: g2.draw(myPg);
1321:
1322: // g2.drawLine((int)arrow.getX()+(int)arrow.getArrowEndA().x,
1323: // (int)arrow.getY()+(int)arrow.getArrowEndA().y,
1324: // (int)arrow.getX()+(int)arrow.getArrowEndB().x,
1325: // (int)arrow.getY()+(int)arrow.getArrowEndB().y);
1326: } // end B. Buckl
1327: else if (arrow.getString().equals("x")) {
1328: int[] ax = new int[4];
1329: int[] ay = new int[4];
1330: ax[0] = (int) arrow.getX();
1331: ay[0] = (int) arrow.getY();
1332: ax[1] = (int) arrow.getX()
1333: + (int) arrow.getArrowEndA().x;
1334: ay[1] = (int) arrow.getY()
1335: + (int) arrow.getArrowEndA().y;
1336: ax[3] = (int) arrow.getX()
1337: + (int) arrow.getArrowEndB().x;
1338: ay[3] = (int) arrow.getY()
1339: + (int) arrow.getArrowEndB().y;
1340:
1341: ax[2] = -(int) arrow.getX() + ax[1] + ax[3];
1342: ay[2] = -(int) arrow.getY() + ay[1] + ay[3];
1343:
1344: // begin B. Buckl
1345: Polygon myPg = new Polygon(ax, ay, 4);
1346: g2.setColor(_fillColor);
1347: g2.fill(myPg);
1348: g2.setColor(_activeColor);
1349: g2.draw(myPg);
1350: // end B. Buckl
1351: } else if (arrow.getString().equals("X")) {
1352: int[] ax = new int[4];
1353: int[] ay = new int[4];
1354: ax[0] = (int) arrow.getX();
1355: ay[0] = (int) arrow.getY();
1356: ax[1] = (int) arrow.getX()
1357: + (int) arrow.getArrowEndA().x;
1358: ay[1] = (int) arrow.getY()
1359: + (int) arrow.getArrowEndA().y;
1360: ax[3] = (int) arrow.getX()
1361: + (int) arrow.getArrowEndB().x;
1362: ay[3] = (int) arrow.getY()
1363: + (int) arrow.getArrowEndB().y;
1364:
1365: ax[2] = -(int) arrow.getX() + ax[1] + ax[3];
1366: ay[2] = -(int) arrow.getY() + ay[1] + ay[3];
1367:
1368: g2.fill(new Polygon(ax, ay, 4));
1369: }
1370: // A.Mueller Begin
1371: else if (arrow.getString().equals("n")) {
1372: Point a1 = arrow.getCrossEndA();
1373: Point a2 = arrow.getCrossEndB();
1374: g2
1375: .drawLine((int) (arrow.getX() + arrow
1376: .getArrowEndA().x), (int) (arrow
1377: .getY() + arrow.getArrowEndA().y),
1378: (int) (arrow.getX() + a2.x),
1379: (int) (arrow.getY() + a2.y));
1380: g2
1381: .drawLine((int) (arrow.getX() + arrow
1382: .getArrowEndB().x), (int) (arrow
1383: .getY() + arrow.getArrowEndB().y),
1384: (int) (arrow.getX() + a1.x),
1385: (int) (arrow.getY() + a1.y));
1386:
1387: } else if (arrow.getString().equals("require")) {
1388:
1389: int width = arrow.getCrossEndB().x
1390: - arrow.getCrossEndA().x;
1391: int height = arrow.getCrossEndB().y
1392: - arrow.getCrossEndA().y;
1393: g2.drawOval((int) arrow.getX()
1394: + arrow.getCrossEndA().x, (int) arrow
1395: .getY()
1396: + arrow.getCrossEndA().y, width, height);
1397:
1398: } else if (arrow.getString().equals("provide")) {
1399: int width = arrow.getCrossEndB().x
1400: - arrow.getCrossEndA().x;
1401: int height = arrow.getCrossEndB().y
1402: - arrow.getCrossEndA().y;
1403: g2.drawArc((int) arrow.getX()
1404: + arrow.getCrossEndA().x, (int) arrow
1405: .getY()
1406: + arrow.getCrossEndA().y, width, height,
1407: arrow.getArcStart(), arrow.getArcEnd());
1408: // A.Mueller End
1409: // G.Mueller Start
1410: } else if (arrow.getString().startsWith("package")) {
1411: Point px1;
1412: Point px2;
1413: if (arrow.getString().equals("packageStart")) {
1414: px1 = getStartPoint();
1415: px2 = getLinePoints().elementAt(1);
1416: } else {
1417: px1 = getEndPoint();
1418: px2 = getLinePoints().elementAt(
1419: getLinePoints().size() - 2);
1420: }
1421: AffineTransform at = g2.getTransform();
1422: AffineTransform at2 = (AffineTransform) at.clone();
1423: int cx = px1.x;
1424: int cy = px1.y;
1425: double winkel = Constants.getAngle(px1.x, px1.y,
1426: px2.x, px2.y);
1427: at2.rotate(winkel, cx, cy);
1428: g2.setTransform(at2);
1429: g2.setColor(_fillColor);
1430: g2.fillOval(px1.x, px1.y - 10, 20, 20);
1431: g2.setColor(_activeColor);
1432: g2.drawOval(px1.x, px1.y - 10, 20, 20);
1433: g2.drawLine(px1.x + 10, px1.y - 5, px1.x + 10,
1434: px1.y + 5);
1435: g2.drawLine(px1.x + 15, px1.y, px1.x + 5, px1.y);
1436: g2.setTransform(at);
1437:
1438: // ***
1439: // Wirrer G. Start
1440: } else if (arrow.getString().startsWith("fill_poly")) {
1441:
1442: Point px1;
1443: Point px2;
1444: if (beginArrow.startsWith("fill_poly_start")) {
1445: px1 = getStartPoint();
1446: px2 = getLinePoints().elementAt(1);
1447: AffineTransform at = g2.getTransform();
1448: AffineTransform at2 = (AffineTransform) at
1449: .clone();
1450: double winkel = Constants.getAngle(px1.x,
1451: px1.y, px2.x, px2.y);
1452: at2.rotate(winkel, px1.x, px1.y);
1453: g2.setTransform(at2);
1454: int[] x_cord = { px1.x, px1.x + 13, px1.x + 13 };
1455: int[] y_cord = { px1.y, px1.y - 7, px1.y + 7 };
1456: Polygon x = new Polygon(x_cord, y_cord, 3);
1457: g2.fillPolygon(x);
1458: g2.setTransform(at);
1459: }
1460: if (endArrow.startsWith("fill_poly_end")) {
1461: px1 = getEndPoint();
1462: px2 = getLinePoints().elementAt(
1463: getLinePoints().size() - 2);
1464: AffineTransform at = g2.getTransform();
1465: AffineTransform at2 = (AffineTransform) at
1466: .clone();
1467: double winkel = Constants.getAngle(px2.x,
1468: px2.y, px1.x, px1.y);
1469: at2.rotate(winkel, px1.x, px1.y);
1470: g2.setTransform(at2);
1471: int[] x_cord = { px1.x, px1.x - 13, px1.x - 13 };
1472: int[] y_cord = { px1.y, px1.y - 7, px1.y + 7 };
1473: Polygon x = new Polygon(x_cord, y_cord, 3);
1474: g2.fillPolygon(x);
1475: g2.setTransform(at);
1476: }
1477: // Wirrer G. End
1478: } else if (arrow.getString().startsWith("comp")) {
1479:
1480: Point px1;
1481: Point px2;
1482: int s;
1483:
1484: //if (beginCSDArrow.equals("compStart")) {
1485: if (beginArrow.startsWith("compStart")) {
1486:
1487: s = 20;
1488:
1489: if (!csdStartText.equals(""))
1490: s = Constants.getPixelWidth(g2,
1491: csdStartText);
1492: if (s < 25)
1493: s = 20;
1494:
1495: px1 = getStartPoint();
1496: px2 = getLinePoints().elementAt(1);
1497: g2.setColor(_fillColor);
1498: g2.fillRect((int) (px1.x - s / 2),
1499: (int) (px1.y - s / 2), s, s);
1500: g2.setColor(_activeColor);
1501: g2.drawRect((int) (px1.x - s / 2),
1502: (int) (px1.y - s / 2), s, s);
1503: g2
1504: .setFont(new Font("SansSerif",
1505: Font.PLAIN, 10));
1506: if (csdStartText.equals(">")) {
1507: int[] tmpX = { px1.x - 5, px1.x + 5,
1508: px1.x - 5 };
1509: int[] tmpY = { px1.y - 5, px1.y, px1.y + 5 };
1510: g2.fillPolygon(tmpX, tmpY, 3);
1511: } else if (csdStartText.equals("<")) {
1512: int[] tmpX = { px1.x + 5, px1.x - 5,
1513: px1.x + 5 };
1514: int[] tmpY = { px1.y - 5, px1.y, px1.y + 5 };
1515: g2.fillPolygon(tmpX, tmpY, 3);
1516: } else if (csdStartText.equals("v")) {
1517: int[] tmpX = { px1.x - 5, px1.x, px1.x + 5 };
1518: int[] tmpY = { px1.y - 5, px1.y + 5,
1519: px1.y - 5 };
1520: g2.fillPolygon(tmpX, tmpY, 3);
1521: } else if (csdStartText.equals("^")) {
1522: int[] tmpX = { px1.x - 5, px1.x, px1.x + 5 };
1523: int[] tmpY = { px1.y + 5, px1.y - 5,
1524: px1.y + 5 };
1525: g2.fillPolygon(tmpX, tmpY, 3);
1526: } else if (csdStartText.equals("=")) {
1527: g2.drawLine(px1.x - 6, px1.y - 2,
1528: px1.x + 6, px1.y - 2);
1529: g2.drawLine(px1.x + 6, px1.y - 2,
1530: px1.x + 1, px1.y - 6);
1531: g2.drawLine(px1.x - 6, px1.y + 2,
1532: px1.x + 6, px1.y + 2);
1533: g2.drawLine(px1.x - 6, px1.y + 2,
1534: px1.x - 1, px1.y + 6);
1535: } else {
1536: if (!csdStartText.equals(""))
1537: Constants.write(g2, csdStartText,
1538: px1.x + 3, px1.y + 5, true);
1539: }
1540:
1541: if (beginArrow.equals("compStartdel")) {
1542: AffineTransform at = g2.getTransform();
1543: AffineTransform at2 = (AffineTransform) at
1544: .clone();
1545: int cx = px1.x;
1546: int cy = px1.y;
1547: double winkel = Constants.getAngle(px1.x,
1548: px1.y, px2.x, px2.y);
1549: at2.rotate(winkel, cx, cy);
1550: g2.setTransform(at2);
1551: g2.drawLine((int) (px1.x + s / 2 + 2),
1552: px1.y, (int) (px1.x + s / 2 + 12),
1553: px1.y - 6);
1554: g2.drawLine((int) (px1.x + s / 2 + 2),
1555: px1.y, (int) (px1.x + s / 2 + 12),
1556: px1.y + 6);
1557: g2.setTransform(at);
1558: }
1559:
1560: }
1561: //if (endCSDArrow.equals("compEnd")) {
1562: if (endArrow.startsWith("compEnd")) {
1563:
1564: s = 20;
1565:
1566: if (!csdEndText.equals(""))
1567: s = Constants.getPixelWidth(g2, csdEndText);
1568: if (s < 20)
1569: s = 20;
1570:
1571: px1 = getEndPoint();
1572: px2 = getLinePoints().elementAt(
1573: getLinePoints().size() - 2);
1574: g2.setColor(_fillColor);
1575: g2.fillRect((int) (px1.x - s / 2),
1576: (int) (px1.y - s / 2), s, s);
1577: g2.setColor(_activeColor);
1578: g2.drawRect((int) (px1.x - s / 2),
1579: (int) (px1.y - s / 2), s, s);
1580: g2
1581: .setFont(new Font("SansSerif",
1582: Font.PLAIN, 10));
1583: if (csdEndText.equals(">")) {
1584: int[] tmpX = { px1.x - 5, px1.x + 5,
1585: px1.x - 5 };
1586: int[] tmpY = { px1.y - 5, px1.y, px1.y + 5 };
1587: g2.fillPolygon(tmpX, tmpY, 3);
1588: } else if (csdEndText.equals("<")) {
1589: int[] tmpX = { px1.x + 5, px1.x - 5,
1590: px1.x + 5 };
1591: int[] tmpY = { px1.y - 5, px1.y, px1.y + 5 };
1592: g2.fillPolygon(tmpX, tmpY, 3);
1593: } else if (csdEndText.equals("v")) {
1594: int[] tmpX = { px1.x - 5, px1.x, px1.x + 5 };
1595: int[] tmpY = { px1.y - 5, px1.y + 5,
1596: px1.y - 5 };
1597: g2.fillPolygon(tmpX, tmpY, 3);
1598: } else if (csdEndText.equals("^")) {
1599: int[] tmpX = { px1.x - 5, px1.x, px1.x + 5 };
1600: int[] tmpY = { px1.y + 5, px1.y - 5,
1601: px1.y + 5 };
1602: g2.fillPolygon(tmpX, tmpY, 3);
1603: } else if (csdEndText.equals("=")) {
1604: g2.drawLine(px1.x - 6, px1.y - 2,
1605: px1.x + 6, px1.y - 2);
1606: g2.drawLine(px1.x + 6, px1.y - 2,
1607: px1.x + 1, px1.y - 6);
1608: g2.drawLine(px1.x - 6, px1.y + 2,
1609: px1.x + 6, px1.y + 2);
1610: g2.drawLine(px1.x - 6, px1.y + 2,
1611: px1.x - 1, px1.y + 6);
1612: } else {
1613: if (!csdEndText.equals(""))
1614: Constants.write(g2, csdEndText,
1615: px1.x + 3, px1.y + 5, true);
1616: }
1617:
1618: if (endArrow.equals("compEnddel")) {
1619: AffineTransform at = g2.getTransform();
1620: AffineTransform at2 = (AffineTransform) at
1621: .clone();
1622: int cx = px1.x;
1623: int cy = px1.y;
1624: double winkel = Constants.getAngle(px1.x,
1625: px1.y, px2.x, px2.y);
1626: at2.rotate(winkel, cx, cy);
1627: g2.setTransform(at2);
1628: g2.drawLine((int) (px1.x + s / 2 + 2),
1629: px1.y, (int) (px1.x + s / 2 + 12),
1630: px1.y - 6);
1631: g2.drawLine((int) (px1.x + s / 2 + 2),
1632: px1.y, (int) (px1.x + s / 2 + 12),
1633: px1.y + 6);
1634: g2.setTransform(at);
1635: }
1636:
1637: }
1638:
1639: g2.setFont(Constants.getFont()); //reset font
1640:
1641: }
1642: // G.Mueller End
1643:
1644: } else if (r instanceof Multiplicity) {
1645: Multiplicity m = (Multiplicity) r;
1646: // g.drawRect((int)r.getX(), (int)r.getY(), (int)r.getWidth(),
1647: // (int)r.getHeight());
1648: Constants.write(g2, m.getString(), (int) r.getX(),
1649: (int) r.getY() + Constants.getFontsize() + 2
1650: * Constants.getDistTextToText(), false); // B. Buckl
1651: // added
1652: // +2*Constants.getDistTextToText()
1653: } else if (r instanceof Role) {
1654: Role role = (Role) r;
1655: // A.Mueller start
1656: boolean underline = false;
1657: boolean italic = false;
1658: String str = role.getString();
1659: if (str.startsWith("/") && str.endsWith("/")
1660: && str.length() > 1) {
1661: italic = true;
1662: str = str.substring(1, str.length() - 1);
1663: }
1664: if (str.startsWith("_") && str.endsWith("_")
1665: && str.length() > 1) {
1666: underline = true;
1667: str = str.substring(1, str.length() - 1);
1668: }
1669:
1670: int position = 0;
1671: int y = 4 * Constants.getDistLineToText();
1672: while (position != -1) {
1673: position = str.indexOf("\\\\");
1674:
1675: if (position != -1) {
1676: String s = str.substring(0, position);
1677: if (italic)
1678: s = "/" + s + "/";
1679: if (underline)
1680: s = "_" + s + "_";
1681:
1682: Constants.write(g2, s, (int) r.getX(), (int) r
1683: .getY()
1684: + y, false);
1685:
1686: y = y + Constants.getFontsize();
1687: str = str.substring(position + 2, str.length());
1688: } else {
1689: if (italic)
1690: str = "/" + str + "/";
1691: if (underline)
1692: str = "_" + str + "_";
1693: Constants.write(g2, str, (int) r.getX(),
1694: (int) r.getY() + y, false);
1695:
1696: }
1697:
1698: }
1699:
1700: // <OLDCODE>
1701: /*
1702: * Constants.write(g2, role.getString(), (int) r.getX(), (int) r
1703: * .getY() + Constants.getFontsize() + 2
1704: * Constants.getDistTextToText(), false); // B. Buckl // added //
1705: * +2*Constants.getDistTextToText()
1706: */
1707: // </OLDCODE>
1708: // A.Mueller end
1709: // G.Mueller Start
1710: } else if (r instanceof Port) {
1711: Port p = (Port) r;
1712:
1713: Constants.write(g2, p.getString(), (int) (r.getX()),
1714: (int) (r.getY()), false);
1715:
1716: }
1717: //G.Mueller end
1718: }
1719:
1720: if (this .getStrings() != null) {
1721: if (this .getStrings().size() > 0) {
1722: Point start = this .getCenterOfLine();
1723: int yPos = start.y - Constants.getDistTextToText(); // B. Buckl
1724: // added
1725: // -Constants.getDistTextToText()
1726: int xPos = start.x;
1727: for (int i = 0; i < getStrings().size(); i++) {
1728: String s = this .getStrings().elementAt(i);
1729:
1730: // A.Mueller Begin...
1731: if (s.startsWith(">") || s.endsWith(">")
1732: || s.startsWith("<") || s.endsWith("<")) {
1733: // starts or ends with an arrow, check if it is the only
1734: // one..
1735: if ((s.indexOf(">") == s.lastIndexOf(">") && s
1736: .indexOf(">") != -1)
1737: || (s.indexOf("<") == s
1738: .lastIndexOf("<") && s
1739: .indexOf("<") != -1)) {
1740: // decide where and what to draw...
1741: int fontHeight = g2.getFontMetrics(
1742: Constants.getFont()).getHeight()
1743: - g2.getFontMetrics(
1744: Constants.getFont())
1745: .getDescent()
1746: - g2.getFontMetrics(
1747: Constants.getFont())
1748: .getLeading();
1749: fontHeight = fontHeight / 3 * 2;
1750: if (s.endsWith(">")) {
1751:
1752: s = s.substring(0, s.length() - 1);
1753: int fontWidth = Constants
1754: .getPixelWidth(g2, s);
1755: xPos = xPos - (fontHeight + 4) / 2;
1756: int startDrawX = xPos + fontWidth / 2
1757: + 4;
1758: Polygon temp = new Polygon();
1759: temp.addPoint(startDrawX, yPos);
1760: temp.addPoint(startDrawX, yPos
1761: - fontHeight);
1762: temp.addPoint(startDrawX + fontHeight
1763: - 1, yPos - fontHeight / 2);
1764: g2.fillPolygon(temp);
1765:
1766: } else if (s.endsWith("<")) {
1767: s = s.substring(0, s.length() - 1);
1768: int fontWidth = Constants
1769: .getPixelWidth(g2, s);
1770: xPos = xPos - (fontHeight + 4) / 2;
1771: int startDrawX = xPos + fontWidth / 2
1772: + 4;
1773: Polygon temp = new Polygon();
1774: temp.addPoint(startDrawX + fontHeight
1775: - 1, yPos);
1776: temp.addPoint(startDrawX + fontHeight
1777: - 1, yPos - fontHeight);
1778: temp.addPoint(startDrawX, yPos
1779: - fontHeight / 2);
1780: g2.fillPolygon(temp);
1781: } else if (s.startsWith(">")) {
1782: s = s.substring(1, s.length());
1783: int fontWidth = Constants
1784: .getPixelWidth(g2, s);
1785: xPos = xPos + (fontHeight + 4) / 2;
1786: int startDrawX = xPos - fontWidth / 2
1787: - 4;
1788: Polygon temp = new Polygon();
1789: temp.addPoint(startDrawX - fontHeight
1790: + 1, yPos);
1791: temp.addPoint(startDrawX - fontHeight
1792: + 1, yPos - fontHeight);
1793: temp.addPoint(startDrawX, yPos
1794: - fontHeight / 2);
1795: g2.fillPolygon(temp);
1796: } else if (s.startsWith("<")) {
1797:
1798: s = s.substring(1, s.length());
1799: int fontWidth = Constants
1800: .getPixelWidth(g2, s);
1801: xPos = xPos + (fontHeight + 4) / 2;
1802: int startDrawX = xPos - fontWidth / 2
1803: - 4;
1804: Polygon temp = new Polygon();
1805: temp.addPoint(startDrawX, yPos);
1806: temp.addPoint(startDrawX, yPos
1807: - fontHeight);
1808: temp.addPoint(startDrawX - fontHeight
1809: + 1, yPos - fontHeight / 2);
1810: g2.fillPolygon(temp);
1811:
1812: }
1813:
1814: }
1815:
1816: }
1817: // A.Mueller end...
1818:
1819: Constants.write(g2, s, xPos, yPos, true);
1820: yPos += Constants.getFontsize();
1821: yPos += Constants.getDistTextToText();
1822: }
1823: }
1824: }
1825:
1826: Vector<Point> criticalPoints = new Vector<Point>();
1827: for (int i = 1; i < startShapes.size(); i++) {
1828: Rectangle r = startShapes.elementAt(i);
1829: Point p1 = new Point((int) r.getX() - 2, (int) r.getY() - 2);
1830: Point p2 = new Point((int) r.getX() + (int) r.getWidth()
1831: + 2, (int) r.getY() + (int) r.getHeight() + 2);
1832: criticalPoints.add(p1);
1833: criticalPoints.add(p2);
1834: }
1835: for (int i = 1; i < endShapes.size(); i++) {
1836: Rectangle r = endShapes.elementAt(i);
1837: Point p1 = new Point((int) r.getX() - 2, (int) r.getY() - 2);
1838: Point p2 = new Point((int) r.getX() + (int) r.getWidth()
1839: + 2, (int) r.getY() + (int) r.getHeight() + 2);
1840: criticalPoints.add(p1);
1841: criticalPoints.add(p2);
1842: }
1843: if (this .getStrings() != null) {
1844: if (this .getStrings().size() > 0) {
1845: Point start = this .getCenterOfLine();
1846: int yPos = start.y;
1847: int xPos = start.x;
1848: for (int i = 0; i < getStrings().size(); i++) {
1849: String s = this .getStrings().elementAt(i);
1850: int width = Constants.getPixelWidth(g2, s);
1851: criticalPoints.add(new Point(xPos - width / 2 - 20,
1852: yPos - Constants.getFontsize() - 20));
1853: criticalPoints.add(new Point(xPos + width / 2 + 20,
1854: yPos + 20));
1855: yPos += Constants.getFontsize();
1856: yPos += Constants.getDistTextToText();
1857: }
1858: }
1859: }
1860:
1861: {
1862: int minx = 99999;
1863: int maxx = -99999;
1864: int miny = 99999;
1865: int maxy = -99999;
1866: for (int i = 0; i < getLinePoints().size(); i++) {
1867: Point p = getLinePoints().elementAt(i);
1868: minx = Math.min(minx, p.x);
1869: miny = Math.min(miny, p.y);
1870: maxx = Math.max(maxx, p.x);
1871: maxy = Math.max(maxy, p.y);
1872:
1873: // TEST
1874: minx = Math.min(minx, p.x - 20);
1875: miny = Math.min(miny, p.y - 20);
1876: maxx = Math.max(maxx, p.x + 20);
1877: maxy = Math.max(maxy, p.y + 20);
1878: }
1879: for (int i = 0; i < criticalPoints.size(); i++) {
1880: Point p = criticalPoints.elementAt(i);
1881: minx = Math.min(minx, p.x);
1882: miny = Math.min(miny, p.y);
1883: maxx = Math.max(maxx, p.x);
1884: maxy = Math.max(maxy, p.y);
1885: }
1886:
1887: int diffminx = minx;
1888: int diffminy = miny;
1889: int diffmaxx = maxx - getWidth();
1890: int diffmaxy = maxy - getHeight();
1891:
1892: if (minx != 0) {
1893: Controller.getInstance().executeCommandWithoutUndo(
1894: new Resize(this , 8, diffminx, 0));
1895: }
1896: if (maxx != 0) {
1897: Controller.getInstance().executeCommandWithoutUndo(
1898: new Resize(this , 2, diffmaxx, 0));
1899: }
1900: if (miny != 0) {
1901: Controller.getInstance().executeCommandWithoutUndo(
1902: new Resize(this , 1, 0, diffminy));
1903: }
1904: if (maxy != 0) {
1905: Controller.getInstance().executeCommandWithoutUndo(
1906: new Resize(this , 4, 0, diffmaxy));
1907: }
1908: if (minx != 0 | miny != 0) {
1909: for (int i = 0; i < getLinePoints().size(); i++) {
1910: Point p = getLinePoints().elementAt(i);
1911: p.x += -minx;
1912: p.y += -miny;
1913: }
1914: }
1915: }
1916: }
1917:
1918: private Point getStartPoint() {
1919: Point ret = this .getLinePoints().elementAt(0);
1920: return ret;
1921: }
1922:
1923: private Point getEndPoint() {
1924: Point ret = this .getLinePoints().elementAt(
1925: this .getLinePoints().size() - 1);
1926: return ret;
1927: }
1928:
1929: public Point getAbsoluteCoorStart() {
1930: Point ret = new Point();
1931: ret.x = this .getX() + this .getStartPoint().x;
1932: ret.y = this .getY() + this .getStartPoint().y;
1933: return ret;
1934: }
1935:
1936: public Point getAbsoluteCoorEnd() {
1937: Point ret = new Point();
1938: ret.x = this .getX() + this .getEndPoint().x;
1939: ret.y = this .getY() + this .getEndPoint().y;
1940: return ret;
1941: }
1942:
1943: public int getConnectedLinePoint(Entity e, int action) {
1944: int ret1 = -1;
1945: int ret2 = -1;
1946:
1947: Point p = this .getStartPoint();
1948: Point abs = new Point((int) (this .getX() + p.getX()),
1949: (int) (this .getY() + p.getY()));
1950: int where = e.doesCoordinateAppearToBeConnectedToMe(abs);
1951: if ((where > 0) && ((where & action) > 0))
1952: ret1 = 0;
1953:
1954: p = this .getEndPoint();
1955: abs = new Point((int) (this .getX() + p.getX()), (int) (this
1956: .getY() + p.getY()));
1957: where = e.doesCoordinateAppearToBeConnectedToMe(abs);
1958: if ((where > 0) && ((where & action) > 0))
1959: ret2 = this .getLinePoints().size() - 1;
1960:
1961: // A.Mueller start
1962: if (clientServer != null && clientServer.equals("start"))
1963: ret1 = -1;
1964: if (clientServer != null && clientServer.equals("end"))
1965: ret2 = -1;
1966: // A.Mueller end
1967:
1968: ret1++;
1969: ret2++;
1970:
1971: return ret1 + 1000 * ret2;
1972: }
1973:
1974: // G.Mueller start
1975: public String[] getCSDText(String str) { // for the Composite Structure Diagram Text
1976:
1977: String tmp[] = new String[4];
1978: int to = 0;
1979: int from = 0;
1980: tmp[0] = " ";
1981: tmp[1] = " ";
1982: tmp[2] = " ";
1983: tmp[3] = " ";
1984:
1985: if (str.length() > 3) {
1986:
1987: // if (str.indexOf("<[") >=3) tmp[2] =
1988: // str.substring(3,str.indexOf("<["));
1989: // if (str.lastIndexOf("[") >=3 && str.lastIndexOf("[")-1 !=
1990: // str.lastIndexOf("<[")) tmp[3] = str.substring(str.indexOf("[",
1991: // str.length()));
1992:
1993: from = str.indexOf("<[") + 2;
1994: if (from >= 2)
1995: to = str.indexOf("]");
1996: if (from >= 2 && to >= 0 && from < to)
1997: tmp[0] = str.substring(from, to);
1998:
1999: from = str.indexOf("[", to) + 1;
2000: if (from >= 1)
2001: to = str.indexOf("]>", to);
2002: if (from >= 1 && to >= 0 && from < to)
2003: tmp[1] = str.substring(from, to);
2004:
2005: }
2006:
2007: return tmp;
2008:
2009: }
2010:
2011: //G.Mueller end
2012:
2013: public StickingPolygon getStickingBorder() { // LME
2014: return null;
2015: }
2016:
2017: public void reLocate() { //LME
2018: Relation r = (Relation) this ;
2019: Vector<Point> ve = r.getLinePoints();
2020: for (int vi = 0; vi < ve.size(); vi++) {
2021: Point p = r.getLinePoints().elementAt(vi);
2022: int gridUnit = Umlet.getInstance().getMainUnit();
2023: int dux = this .getX() + p.x;
2024: int duy = this .getY() + p.y;
2025: int dxr = ((dux % gridUnit) < (gridUnit / 2)) ? ((dux % gridUnit) * (-1))
2026: : ((dux % gridUnit));
2027: int dyr = ((duy % gridUnit) < (gridUnit / 2)) ? ((duy % gridUnit) * (-1))
2028: : ((duy % gridUnit));
2029: super.setLocation(this.getX() + dxr, this.getY() + dyr);
2030: r.repaint();
2031: }
2032: }
2033: }
|