Thank you very much!

hello,

I have another question.

I have to connect two graphical items with a line (or two lines go from one item to two others).

At the moment the line is a simple class AdaptorType depending from the class GraphicalItem.

But the target GraphicalItem where the line leads to is referred by it's index in the ArrayList (that's done in class AdaptorType, I made the lines bold, see below).

That sounds very unwise since when you remove one item, all indices after it change, right?

So it's unstable / not reliable.

What is the alternative?

Is it possible to make a pointer (direct reference?) to the object itself which would stay the same after removing another?

To do so, could the constructor return this reference?
See line 79ff. where I use the index at the moment.

Thank you!

Greetings, Chrisir      

1. // this prgram provides a flowchart / diagram
2. // http://en.wikipedia.org/wiki/Flowchart
3. ArrayList<GraphicalItem> graphicalItems;
4. //
5. final color lightGreen = color (2, 244, 2, 22);
6. final color lightBlue = color(2, 0, 244, 22);
7. // State of program
8. final int stateNormal = 0;
9. int state=stateNormal;
10. //
11. // for graphical:
12. final int typeOfGraphicalItemStandardWithHeader = 0;
13. final int typeOfGraphicalItemStandardWithoutHeader = 1;
14. final int typeOfGraphicalItemConditional = 2;
15. final int typeOfGraphicalItemStartEnd = 3;
16. //
17. // for graphical: which adaptor is used on a box?
18. // (clockwise) north, east, south or west.
19. final int adaptorNorth=0;
20. final int adaptorEast=1;
21. final int adaptorSouth=2;
22. final int adaptorWest=3;
23. //
24. // for scale and translating
25. float myScale = 1.0;     
26. float myTranslate = 0.0;  // only y-direction
27. // where to place next box vertically
28. int lineY = 40;
29. //
30. // for drag and drop:
31. // mouse dragged?
32. boolean hold=false;   
33. GraphicalItem holdItem ;  // which item is dragged
34. // for drag and drop: difference between the upper left corner
35. // x,y position and where mouse clicked in the graphical item
36. PVector offSet;
37. // ---------------------------------------------------------------
38. void setup() {
39.   // size( screen.width, screen.height );
40.   size( 800, 600 );
41.   smooth();
42.   noStroke();
43.   fill(0);
44.   offSet=new PVector();
45.   // Create an empty ArrayList
46.   graphicalItems = new ArrayList();
47.   // fill the ArrayList
48.   initGraphical() ;
49. } // func
50. //
51. //
52. void draw() {
53.   background(255);
54.   //
55.   if (state==stateNormal) {
56.     scale(myScale);
57.     translate( 0, myTranslate ) ;    
58.     showGraphical();
59.   }
60.   else {
61.     println ("Error 182" );
62.   }
63. } // func
64. //
65. //
66. // =================================================================
67. // Init items
68. void initGraphical() {
69.   // fills the graphicalItems in the arrayList
70.   graphicalItems.clear();
71.   lineY = 40;
72.   //
73.   graphicalItems.add ( new GraphicalItem(
74.   typeOfGraphicalItemStandardWithHeader, 20, lineY,
75.   "Entry 0", "This is interesting",
76.   null,
77.   lightGreen ));
78. 
    
79.   int EntryGreen =  graphicalItems.size()-1;
80. 
    
81.   graphicalItems.add ( new GraphicalItem(
82.   typeOfGraphicalItemStandardWithHeader, 320, lineY,
83.   "Entry 1", "This is lightblue ",
84.   new AdaptorType(EntryGreen, adaptorWest, adaptorEast),
85.   lightBlue ));
86. 
    
87.   int EntryBlue =  graphicalItems.size()-1; 
88.   graphicalItems.add ( new GraphicalItem(
89.   typeOfGraphicalItemConditional,
90.   100, lineY+100,
91.   "", "Conditional",
92.   new AdaptorType(EntryGreen, adaptorNorth, adaptorSouth),
93.   color (0) ));
94.   int EntryConditional =  graphicalItems.size()-1; 
95.   lineY+=70;
96.   graphicalItems.add ( new GraphicalItem(
97.   typeOfGraphicalItemStartEnd,
98.   180, lineY+100,
99.   "", "Test2",
100.   new AdaptorType(EntryConditional, adaptorNorth, adaptorEast),
101.   color (0) ));
102.   lineY+=70;
103.   graphicalItems.add ( new GraphicalItem(
104.   typeOfGraphicalItemStartEnd,
105.   40, lineY+100,
106.   "", "Test3",
107.   new AdaptorType(EntryConditional, adaptorNorth, adaptorWest),
108.   color (0) ));
109.   int EntryStartItem = graphicalItems.size()-1;
110.   graphicalItems.add ( new GraphicalItem(
111.   typeOfGraphicalItemStandardWithoutHeader,
112.   240, lineY+200,
113.   "", "Test3",
114.   new AdaptorType(EntryBlue, adaptorNorth, adaptorSouth),
115.   color (0) ));
116.   //
117.   // add further Line to last item. This line
118.   // goes from the last item (it's west side) to item
119.   // number EntryStartItem (south)
120.   AddLineToElement( graphicalItems.size()-1,
121.   EntryStartItem,
122.   adaptorWest,
123.   adaptorSouth );
124.   //
125. } // func
126. //
127. // Inputs ****************************************************
128. //
129. void mousePressed() {
130.   if (state==stateNormal) {
131.     if (mouseButton==LEFT) {
132.       // drag one item
133.       for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
134.         GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
135.         if (myGraphicalItem1.isMouseOver()) {
136.           hold     = true;
137.           holdItem = myGraphicalItem1;
138.           offSet.x = myGraphicalItem1.Position.x-mouseX;
139.           offSet.y = myGraphicalItem1.Position.y-mouseY;
140.         }
141.       } // for
142.     } // if
143.   } // if
144. } // func
145. //
146. void mouseDragged() {
147.   if (state==stateNormal) {
148.     if (hold) {
149.       // mouseButton is LEFT
150.       holdItem.Position.x = mouseX+offSet.x;
151.       holdItem.Position.y = mouseY+offSet.y;
152.     }
153.     else if (mousePressed && (mouseButton == RIGHT)) {
154.       myScale = map(mouseX, 0, width, 0, 2); 
155.       myTranslate = map(mouseY, 0, height, -height, height);
156.     } // if
157.   } // if
158. } // func
159. //
160. void mouseReleased () {
161.   if (state==stateNormal) {
162.     if (mouseButton == LEFT) {
163.       hold = false;
164.       println("f");
165.     }
166.   }
167. } // function
168. //
169. void keyPressed () {
170.   if (state==stateNormal) {
171.     //
172.     if (key=='r') {
173.       // reset scale and translate
174.       myScale = 1.0;     
175.       myTranslate = 0.0;
176.     }
177.     else
178.     {
179.       // do nothing
180.     }
181.   }
182.   else {
183.     println("Error 429: unknown state ");
184.   }
185. } // keyPressed
186. //-----------------------------------------------------------
187. //
188. void AddLineToElement( int NumberOfStartItem, int NumberOfTargetItem,
189. int adaptor1, int adaptor2) {
190.   // add a line
191.   GraphicalItem itemStart = graphicalItems.get(NumberOfStartItem);
192.   itemStart.addAdaptor ( new AdaptorType(NumberOfTargetItem, adaptor1, adaptor2) );
193. }
194. //
195. void showGraphical() {
196.   // show the graphicalItems from the arrayList
197.   textAlign(LEFT);
198.   text ( "Graphical Representation"
199.     + " - "
200.     + "Move items with left Mouse button. Drag with right mouse button: scale "
201.     + "(x-direction) and up/down (y-direction).", 20, 14 );
202.   if (graphicalItems.isEmpty()) {
203.     text("Graphical Diagram is empty.", 220, 170 );
204.   }
205.   else
206.   {
207.     for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
208.       GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
209.       myGraphicalItem1.display() ;
210.     } // for
211.   } // if else
212. } // func
213. //
214. GraphicalItem getElement( String textHeaderParam, String textNormalParam ) {
215.   // returns object or null
216.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
217.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
218.     if (myGraphicalItem1.textHeader.equals(textHeaderParam) &&
219.       myGraphicalItem1.textNormal.equals(textNormalParam)) {
220.       return myGraphicalItem1;
221.     } // if
222.   } // for
223.   return null;
224. } // func
225. //
226. int getElementNumber( String textHeaderParam, String textNormalParam ) {
227.   // returns number of object or -1
228.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
229.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
230.     if (myGraphicalItem1.textHeader.equals(textHeaderParam) &&
231.       myGraphicalItem1.textNormal.equals(textNormalParam)) {
232.       return i;
233.     } // if
234.   } // for
235.   return -1;
236. } // func
237. //
238. // ==============================================================
239. class GraphicalItem {
240.   //
241.   PVector Position;   // Pos and size of the whole box
242.   PVector boxSize;    // Size
243.   final int headerHeight = 20;  // Height of header text box
244.   color headerColor;   //  color of header box
245.   // the type of the item
246.   int typeOfGraphicalItem;
247.   // texts
248.   String textHeader="";
249.   String textNormal="";
250.   //
251.   // where the adaptors lead to: array of
252.   // AdaptorType (see class AdaptorType)
253.   AdaptorType adaptorTo[] = new AdaptorType [1]; 
254.   //
255.   // Positions of adaptors
256.   PVector adaptorLeft, adaptorRight;
257.   PVector adaptorUp, adaptorDown;
258.   //
259.   // constructor ----------
260.   GraphicalItem(
261.   int _typeOfGraphicalItem,
262.   int _x, int _y,
263.   String _header, String _normalText,
264.   AdaptorType _adaptorTo,
265.   color _tempColor) {
266.     //
267.     // constructor
268.     Position = new PVector( _x, _y);
269.     boxSize  = new PVector( 100, 70 );
270.     textHeader    = _header;
271.     textNormal    = _normalText;
272.     adaptorTo [0] = _adaptorTo;
273.     //
274.     typeOfGraphicalItem=_typeOfGraphicalItem;
275.     //
276.     if (typeOfGraphicalItem == typeOfGraphicalItemConditional) {
277.       // Conditional item = ttiangle
278.       // calculate the four adaptors pos
279.       adaptorUp = new PVector( boxSize.x/2, 0 );
280.       adaptorRight = new PVector( 2*boxSize.x/3+11, boxSize.y/2 );   
281.       // adaptorDown  = new PVector( boxSize.x/2, boxSize.y );
282.       adaptorLeft = new PVector( boxSize.x/3-7, boxSize.y/2 );
283.     }
284.     else {
285.       // calculate the four adaptors pos
286.       adaptorUp = new PVector( boxSize.x/2, 0 );
287.       adaptorRight = new PVector( boxSize.x, boxSize.y/2 );   
288.       adaptorDown  = new PVector( boxSize.x/2, boxSize.y );
289.       adaptorLeft = new PVector( 0, boxSize.y/2 );
290.     }
291.     //
292.     headerColor = _tempColor;
293.     plausibilityCheck();
294.   }// constructor
295.   //
296.   void plausibilityCheck () {
297.     // checks whether there are not plausible parameters, e.g.
298.     // a defined header with a typeOfGraphicalItem that has no
299.     // header.
300.     if (typeOfGraphicalItem == typeOfGraphicalItemConditional ||
301.       typeOfGraphicalItem == typeOfGraphicalItemStandardWithoutHeader ||
302.       typeOfGraphicalItem == typeOfGraphicalItemStartEnd  ) {
303.       if (!textHeader.trim().equals("")) {
304.         println("Remark 285: StandardWithoutHeader or Conditional etc. has defined header (not shown) with header: '"
305.           + textHeader
306.           + "' and normal text: '"
307.           + textNormal
308.           + "'. "
309.           + "Type being: "
310.           + typeOfGraphicalItem
311.           + ". Header ignored.");
312.       }
313.     }
314.   }
315.   //
316.   void display() {
317.     switch (typeOfGraphicalItem) {
318.     case typeOfGraphicalItemStandardWithHeader:
319.       displayStandardWithHeader() ;
320.       break;
321.     case typeOfGraphicalItemStandardWithoutHeader:
322.       displayStandardWithoutHeader();
323.       break;
324.     case typeOfGraphicalItemConditional:
325.       displayConditional();
326.       break;
327.     case typeOfGraphicalItemStartEnd:
328.       displayStartEnd();
329.       break;
330.     default:
331.       println("Error occured 245");
332.       break;
333.     } // switch
334.     //
335.   } // method
336.   //
337.   void displayStandardWithHeader() {
338.     fill (headerColor);
339.     stroke(0);
340.     // header rect
341.     rect (Position.x, Position.y,
342.     boxSize.x, headerHeight);
343.     fill(244);
344.     // rect for normal text field (lower half)
345.     rect (Position.x, Position.y+headerHeight,
346.     boxSize.x, boxSize.y-headerHeight);   
347.     fill (0);
348.     text (textHeader, Position.x+4, Position.y+2, boxSize.x-5, headerHeight);
349.     text (textNormal, Position.x+4, Position.y+headerHeight+2, boxSize.x-5, boxSize.y-headerHeight);
350.     // adaptors --------
351.     for (int i=0; i < adaptorTo.length; i++) {
352.       if (adaptorTo[i] != null) {
353.         adaptorTo[i].display ( this ) ;
354.       } // if
355.     } // for
356.   } // method
357.   //
358.   void displayStandardWithoutHeader() {
359.     fill(244);
360.     // rect for text field
361.     rect (Position.x, Position.y,
362.     boxSize.x, boxSize.y);   
363.     fill (0);
364.     text (textNormal, Position.x+4, Position.y+2, boxSize.x-5, boxSize.y);
365.     // adaptors --------
366.     for (int i=0; i < adaptorTo.length; i++) {
367.       if (adaptorTo[i] != null) {
368.         adaptorTo[i].display ( this ) ;
369.       } // if
370.     } // for
371.   } // method
372.   //
373.   void displayConditional() {
374.     // Conditional is triangle
375.     fill(244);
376.     triangle (Position.x, Position.y,
377.     Position.x+boxSize.x+0, Position.y,
378.     Position.x+boxSize.x/2+5, Position.y + boxSize.y);   
379.     fill (0);
380.     textAlign(CENTER);
381.     text (textNormal,
382.     Position.x+2, Position.y+2,
383.     boxSize.x-5, boxSize.y );
384.     // adaptors ----------
385.     for (int i=0; i < adaptorTo.length; i++) {
386.       if (adaptorTo[i] != null) {
387.         adaptorTo[i].display ( this ) ;
388.       } // if
389.     } // for
390.   } // method
391.   //
392.   void displayStartEnd() {
393.     fill(244);
394.     ellipseMode(CORNER);
395.     ellipse (Position.x, Position.y, boxSize.x, boxSize.y);   
396.     fill (0);
397.     textAlign(CENTER);
398.     text (textNormal,
399.     Position.x+7, Position.y+18,
400.     boxSize.x-5, boxSize.y );
401.     // adaptors ------------
402.     for (int i=0; i < adaptorTo.length; i++) {
403.       if (adaptorTo[i] != null) {
404.         adaptorTo[i].display ( this ) ;
405.       } // if
406.     } // for
407.   } // method
408.   //
409.   void addAdaptor(AdaptorType _adaptorTo) {
410.     // appends one line on a existing GraphicalItem
411.     if (_adaptorTo.adaptorToGraphicalItem > -1) {
412.       adaptorTo = (AdaptorType[])append( adaptorTo, _adaptorTo );
413.     }
414.   } // method
415.   //
416.   boolean isMouseOver() {
417.     if (mouseX/myScale > Position.x
418.       && mouseX/myScale < Position.x + boxSize.x
419.       && mouseY/myScale - myTranslate > Position.y
420.       && mouseY/myScale - myTranslate < Position.y + boxSize.y) {
421.       return true;
422.     } // if
423.     else {
424.       return false;
425.     } // if else
426.   } // method
427.   //
428. } // class
429. // ==============================================================
430. class AdaptorType {
431.   // Represents one connecting line.
432.   //
433.   // Start point (FROM) is a point at
434.   // the GraphicalItem (a box) this
435.   // AdaptorType-object belongs to.
436.   // End point (TO) is another GraphicalItem
437.   // marked by the var adaptorToGraphicalItem
438.   // which is an Index for the ArrayList
439.   // graphicalItems.
440.   // To specify the exakt point at
441.   // the from-GraphicalItem, the var
442.   // fromAdaptor denotes whether it's
443.   // (clockwise) north, east, south or west.
444.   // And: To specify the exakt point at
445.   // the to-GraphicalItem, the var
446.   // toAdaptor denotes whether it's
447.   // (clockwise) north, east, south or west.
448.   //
449.   // Indices of another GraphicalItem
450.   int adaptorToGraphicalItem  = -1;    // other graphical item
451.   // from which Adaptor of the four
452.   int fromAdaptor = 1;   // 0 = north adaptor, 1 = east adaptor, 2 = south adaptor, 3 = west adaptor
453.   // to which Adaptor of the four 
454.   int toAdaptor   = 1;   // 0 = north adaptor, 1 = east adaptor, 2 = south adaptor, 3 = west adaptor
455.   //
456.   AdaptorType (int tempAdaptorToGraphicalItem,
457.   int tempFromAdaptor,
458.   int tempToAdaptor ) {
459.     adaptorToGraphicalItem = tempAdaptorToGraphicalItem;
460.     fromAdaptor = tempFromAdaptor;
461.     toAdaptor = tempToAdaptor;
462.   } //
463.   //
464.   void display(GraphicalItem startGraphicalItem) {
465.     if (adaptorToGraphicalItem > -1) {
466.       PVector startVector = getPVector
467.         (startGraphicalItem, fromAdaptor);
468.       PVector endVector = getPVector
469.         ((GraphicalItem) graphicalItems.get(adaptorToGraphicalItem), toAdaptor);      
470.       //
471.       line ( startVector.x, startVector.y,
472.       endVector.x, endVector.y );
473.     } // if
474.   } // method
475.   //
476.   PVector getPVector(GraphicalItem startGraphicalItem, int whichAdaptor) {
477.     PVector buffer = new PVector ();
478.     //
479.     switch (whichAdaptor) {
480.     case adaptorNorth:
481.       buffer.x=startGraphicalItem.Position.x+startGraphicalItem.adaptorUp.x;
482.       buffer.y=startGraphicalItem.Position.y+startGraphicalItem.adaptorUp.y;
483.       break;
484.     case adaptorEast:
485.       buffer.x=startGraphicalItem.Position.x+startGraphicalItem.adaptorRight.x;
486.       buffer.y=startGraphicalItem.Position.y+startGraphicalItem.adaptorRight.y;
487.       break;
488.     case adaptorSouth:
489.       buffer.x=startGraphicalItem.Position.x+startGraphicalItem.adaptorDown.x;
490.       buffer.y=startGraphicalItem.Position.y+startGraphicalItem.adaptorDown.y;
491.       break;
492.     case adaptorWest:
493.       buffer.x=startGraphicalItem.Position.x+startGraphicalItem.adaptorLeft.x;
494.       buffer.y=startGraphicalItem.Position.y+startGraphicalItem.adaptorLeft.y;
495.       break;
496.     default:
497.       println ("Error 337 - unknown adaptor");
498.       break;
499.     } // switch
500.     return buffer;
501.   } // method
502. } // class
503. // ==============================================================

There are always more ways than one to do it. In all cases you will have to deal with adding/removing/displaying objects and adding/removing/displaying connections.

You could use direct references to the connected objects. But remember that as long as an object is referenced it 'stays in existence', meaning that removing the 'original object' reference from the arraylist will not remove the connection nor the object from memory.

You could give each object a uniqueID. Once each object has a reliable ID you can use it in different ways. You could store and display the connections at the object or the global level. Either way uniqueID's are useful for keeping track of connections etc.

Put something like this at the global level:

1. int id;
2. int getUniqueID() {
3.   return id++;
4. }

Then put something like this in your objects.

1. class SomeObject {
2.       int objectID; // holds the object's unique ID
3. 
   
4.       SomeObject() {
5.         objectID = getUniqueID();
6.       }
7.      
8.       getObjectID() {
9.             return objectID;
10.       }
11. }

Without analyzing deeply your code (a bit long...), I can answer 'yes' to your question: don't pass around indexes, it is indeed very brittle. Just pass the objects themselves, you will pass actually just references to these objects.
Don't do x.add(new Item()) but do Item item = new Item(); x.add(item); so you can pass the item to the next constructor.
Note 1: the cast on graphicalItems.get() isn't necessary (old habit? You omit it elsewhere).
Note 2: for (int i = 0; i <= graphicalItems.size()-1; i++) is more usually written for (int i = 0; i < graphicalItems.size(); i++). For a trained eye, the first form makes the mind to pause and think, while the second one is just glanced at once.
Note 3: When you don't need an index, the new for loop is handy:

1.     for (int i=0; i < adaptorTo.length; i++) {
2.       if (adaptorTo[i] != null) {
3.         adaptorTo[i].display ( this ) ;
4.       } // if
5.     } // for

can be:

1.     for (AdaptorType to : adaptorTo) {
2.       if (to != null) {
3.         to.display ( this ) ;
4.       } // if
5.     } // for

(why you don't use an array list here?)
or:

1.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
2.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
3.     if (myGraphicalItem1.textHeader.equals(textHeaderParam) &&
4.       myGraphicalItem1.textNormal.equals(textNormalParam)) {
5.       return myGraphicalItem1;
6.     } // if
7.   } // for

can be:

1.   for (GraphicalItem myGraphicalItem : graphicalItems) {
2.     if (myGraphicalItem.textHeader.equals(textHeaderParam) &&
3.         myGraphicalItem.textNormal.equals(textNormalParam)) {
4.       return myGraphicalItem;
5.     } // if
6.   } // for

Minor superficial remarks...
I haven't tried yet this sketch, but from the screen shot, it looks impressive.

that's very helpful!

Thank you both!

And thanks for the word "impressive" 

Hello,

I now did what you both told me...

You can drag the items with left mouse,
scale (x and y) and translate (only y) with right mouse (r resets).
When item is selected it is marked with a * and you can remove it by delete.
n = new diagram
u = un-select

It works with an unique ID now.

Works fine.

Thanks again!

Greetings, Chrisir

1. // this program provides a flowchart / diagram
2. // http://en.wikipedia.org/wiki/Flowchart
3. ArrayList<GraphicalItem> graphicalItems;
4. //
5. // State of program
6. final int stateNormal = 0;
7. int state=stateNormal;
8. //
9. // for graphical:
10. final int typeOfGraphicalItemStandardWithHeader = 0;
11. final int typeOfGraphicalItemStandardWithoutHeader = 1;
12. final int typeOfGraphicalItemConditional = 2;
13. final int typeOfGraphicalItemStartEnd = 3;
14. // to be able to name those types we use an array
15. // which order of indices must be according to the consts
16. // above:
17. final String[] typeOfGraphicalItemName = {
18.   "Box with header",
19.   "Box without header",
20.   "Condition",
21.   "Start or End"
22. };
23. //
24. // for graphical: which adaptor is used on a box?
25. // (clockwise) north, east, south or west.
26. final int adaptorNorth=0;
27. final int adaptorEast=1;
28. final int adaptorSouth=2;
29. final int adaptorWest=3;
30. //
31. // colors
32. final color lightGreen = color (2, 244, 2, 22);
33. final color lightBlue = color(2, 0, 244, 22);
34. final color black = color (0);
35. //
36. // for scale and translating
37. float myScale = 1.0;     
38. float myTranslate = 0.0;  // only y-direction
39. //
40. // for drag and drop:
41. // mouse dragged?
42. boolean hold=false;   
43. GraphicalItem holdItem ;  // which item is dragged
44. // for drag and drop: difference between the upper left corner
45. // x,y position and where mouse clicked in the graphical item
46. PVector offSet=new PVector();
47. //
48. // for unique ID
49. int id=1000;
50. // which item is selected
51. int selected = -1;
52. //
53. // Main functions ****************************************************
54. //
55. void setup() {
56.   // size( screen.width, screen.height );
57.   size( 800, 600 );
58.   println("start of the program");
59.   // smooth();
60.   noStroke();
61.   fill(0);
62.   // Create an empty ArrayList
63.   graphicalItems = new ArrayList();
64.   // fill the ArrayList
65.   initGraphical();
66.   println("end of setup()");
67. } // func
68. //
69. //
70. void draw() {
71.   background(255);
72.   // depending on program's state
73.   if (state == stateNormal) {
74.     scale(myScale);
75.     translate( 0, myTranslate ) ;    
76.     showGraphical();
77.   }
78.   else {
79.     println ("Error 182 - unknown state" );
80.   }
81. } // func
82. //
83. // Init diagram ****************************************************
84. //
85. void initGraphical() {
86.   // Init items:
87.   // fill the graphicalItems in the arrayList.
88.   //
89.   // where to place next box vertically
90.   int lineY = 40;  
91.   // clear list  
92.   graphicalItems.clear();
93.   //
94.   // item to be defined
95.   GraphicalItem item;
96.   //
97.   item = new GraphicalItem(
98.   typeOfGraphicalItemStandardWithHeader, 20, lineY,
99.   "Entry 0", "This is interesting",
100.   null,
101.   lightGreen );
102.   graphicalItems.add (item);
103.   int EntryGreen = item.objectID;
104.   item=new GraphicalItem(
105.   typeOfGraphicalItemStandardWithHeader, 320, lineY,
106.   "Entry 1", "This is lightblue ",
107.   new AdaptorType(EntryGreen, adaptorWest, adaptorEast),
108.   lightBlue );
109.   graphicalItems.add ( item );
110.   int EntryBlue = item.objectID;
111.   item=new GraphicalItem(
112.   typeOfGraphicalItemConditional,
113.   100, lineY+100,
114.   "", "Conditional",
115.   new AdaptorType(EntryGreen, adaptorNorth, adaptorSouth),
116.   color (0) );
117.   graphicalItems.add (item);
118.   int EntryConditional = item.objectID;
119.   lineY+=70;
120.   item=new GraphicalItem(
121.   typeOfGraphicalItemStartEnd,
122.   180, lineY+100,
123.   "", "Test 2",
124.   new AdaptorType(EntryConditional, adaptorNorth, adaptorEast),
125.   color (0) );
126.   graphicalItems.add (item);
127.   lineY+=70;
128.   item= new GraphicalItem(
129.   typeOfGraphicalItemStartEnd,
130.   40, lineY+100,
131.   "", "Test3",
132.   new AdaptorType(EntryConditional, adaptorNorth, adaptorWest),
133.   color (0) );
134.   graphicalItems.add (item);
135.   int EntryStartItem = item.objectID;
136.   item= new GraphicalItem(
137.   typeOfGraphicalItemStandardWithoutHeader,
138.   240, lineY+200,
139.   "", "Test3",
140.   new AdaptorType(EntryBlue, adaptorNorth, adaptorSouth),
141.   color (0) );
142.   graphicalItems.add (item);
143.   int WithoutHeaderItem = item.objectID;
144.   //
145.   // add further Line to item WithoutHeaderItem. This line
146.   // goes from the last item (it's west side) to item
147.   // number EntryStartItem (south side)
148.   AddLineToElement( WithoutHeaderItem,
149.   EntryStartItem,
150.   adaptorWest,
151.   adaptorSouth );
152.   //
153. } // func
154. //
155. // Inputs ****************************************************
156. //
157. void mousePressed() {
158.   if (state==stateNormal) {
159.     if (mouseButton==LEFT) {
160.       // drag one item
161.       for (GraphicalItem myGraphicalItem : graphicalItems) {       
162.         if (myGraphicalItem.isMouseOver()) {
163.           selected = myGraphicalItem.getObjectID();
164.           hold     = true;
165.           holdItem = myGraphicalItem;
166.           offSet.x = myGraphicalItem.Position.x-mouseX;
167.           offSet.y = myGraphicalItem.Position.y-mouseY;
168.         } // if
169.       } // for
170.     } // if
171.   } // if
172. } // func
173. //
174. void mouseDragged() {
175.   if (state==stateNormal) {
176.     if (hold) {
177.       // mouseButton is LEFT
178.       holdItem.Position.x = mouseX+offSet.x;
179.       holdItem.Position.y = mouseY+offSet.y;
180.     }
181.     else if (mousePressed && (mouseButton == RIGHT)) {
182.       myScale = map(mouseX, 0, width, 0, 2); 
183.       myTranslate = map(mouseY, 0, height, -height, height);
184.     } // if
185.   } // if
186. } // func
187. //
188. void mouseReleased () {
189.   if (state==stateNormal) {
190.     if (mouseButton == LEFT) {
191.       hold = false;
192.     }
193.   }
194. } // function
195. //
196. void keyPressed () {
197.   if (state==stateNormal) {
198.     keyPressedStateNormal();
199.   }
200.   else {
201.     println("Error 429: unknown state ");
202.   }
203. } // keyPressed
204. //
205. void keyPressedStateNormal() {
206.   // eval keys for state normal
207.   if (!(key==CODED)) {
208.     if (key=='r') {
209.       // reset scale and translate
210.       myScale = 1.0;     
211.       myTranslate = 0.0;
212.     } // the r
213.     else if (key=='n') {
214.       // make new diagram
215.       println ("new diagram ----");
216.       initGraphical();
217.     } // the n
218.     else if (key=='u') { // un-mark
219.       // remove marker
220.       selected=-1;
221.     } // the u
222.     else if (key==DELETE) {
223.       // delete selected item.
224.       // if there are items:
225.       if (!graphicalItems.isEmpty()) {
226.         //get selected
227.         GraphicalItem itemSelected = getElementByID(selected);
228.         if (itemSelected!=null) {
229.           // delete it
230.           itemSelected.delete();
231.           // remove marker
232.           selected=-1;
233.         }
234.         else
235.         {
236.           println ("Delete: Found no selected item. Select with Mouse.");
237.         }
238.       }
239.     } // delete
240.     else
241.     {
242.       // do nothing
243.     } // else
244.   } // if not CODED
245. } // func
246. //
247. // Other, minor functions ****************************************************
248. //
249. void AddLineToElement( int NumberOfStartItem, int NumberOfTargetItem,
250. int adaptor1, int adaptor2) {
251.   // add a line
252.   GraphicalItem itemStart = getElementByID (NumberOfStartItem);
253.   itemStart.addAdaptor ( new AdaptorType(NumberOfTargetItem, adaptor1, adaptor2) );
254. }
255. //
256. void showGraphical() {
257.   // show the graphicalItems from the arrayList
258.   textAlign(LEFT);
259.   text ( "Graphical Representation"
260.     + " - "
261.     + "Move items with left Mouse button. Drag with right mouse button: scale "
262.     + "(x-direction) and up/down (y-direction).", 20, 14 );
263.   if (graphicalItems.isEmpty()) {
264.     text("Graphical Diagram is empty.", 220, 170 );
265.   }
266.   else
267.   {
268.     for (GraphicalItem myGraphicalItem : graphicalItems) {
269.       myGraphicalItem.display() ;
270.     } // for
271.   } // if else
272. } // func
273. //
274. GraphicalItem getElementByID( int myIdParameter ) {
275.   // returns object or null
276.   for (GraphicalItem myGraphicalItem : graphicalItems) {
277.     if (myGraphicalItem.objectID==myIdParameter) {
278.       return myGraphicalItem;
279.     } // if
280.   } // for
281.   return null;
282. } // func
283. //
284. GraphicalItem getElementFromTexts( String textHeaderParam, String textNormalParam ) {
285.   // not in use
286.   // returns object or null
287.   for (GraphicalItem myGraphicalItem : graphicalItems) {
288.     if (myGraphicalItem.textHeader.equals(textHeaderParam) &&
289.       myGraphicalItem.textNormal.equals(textNormalParam)) {
290.       return myGraphicalItem;
291.     } // if
292.   } // for
293.   return null;
294. } // func
295. //
296. int getElementNumberFromTexts( String textHeaderParam, String textNormalParam ) {
297.   // not in use
298.   // returns number of object or -1
299.   for (GraphicalItem myGraphicalItem : graphicalItems) {
300.     if (myGraphicalItem.textHeader.equals(textHeaderParam) &&
301.       myGraphicalItem.textNormal.equals(textNormalParam)) {
302.       // return i;
303.       return myGraphicalItem.getObjectID();
304.     } // if
305.   } // for
306.   return -1;
307. } // func
308. //
309. // ==============================================================
310. class GraphicalItem {
311.   //
312.   PVector Position;   // Pos and size of the whole box
313.   PVector boxSize;    // Size
314.   final int headerHeight = 20;  // Height of header text box
315.   color headerColor;   //  color of header box
316.   // the type of the item
317.   int typeOfGraphicalItem;
318.   // texts
319.   String textHeader="";
320.   String textNormal="";
321.   //
322.   // where the adaptors lead to: ArrayList of
323.   // AdaptorType (see class AdaptorType)
324.   ArrayList<AdaptorType> adaptorTo;  
325.   //
326.   // Positions of items own adaptors as x,y
327.   PVector adaptorNorth;
328.   PVector adaptorEast;
329.   PVector adaptorSouth;
330.   PVector adaptorWest;
331.   //
332.   // holds the object's unique ID
333.   int objectID;
334.   //
335.   // constructor ----------
336.   GraphicalItem(
337.   int _typeOfGraphicalItem,
338.   int _x, int _y,
339.   String _header, String _normalText,
340.   AdaptorType _adaptorTo,
341.   color _tempColor) {
342.     //
343.     Position = new PVector( _x, _y);
344.     boxSize  = new PVector( 100, 70 );
345.     textHeader    = _header;
346.     textNormal    = _normalText;
347.     adaptorTo = new ArrayList();
348.     if (_adaptorTo!=null) {
349.       adaptorTo.add (new AdaptorType(
350.       _adaptorTo.adaptorToGraphicalItem,
351.       _adaptorTo.fromAdaptor,
352.       _adaptorTo.toAdaptor));
353.       //adaptorTo [0] = _adaptorTo;
354.     }
355.     //
356.     // type
357.     typeOfGraphicalItem=_typeOfGraphicalItem;
358.     //
359.     if (typeOfGraphicalItem == typeOfGraphicalItemConditional) {
360.       // Conditional item = triangle
361.       // calculate the four adaptors pos
362.       adaptorNorth  = new PVector( boxSize.x/2, 0 );
363.       adaptorEast   = new PVector( 2*boxSize.x/3+11, boxSize.y/2 );   
364.       adaptorWest   = new PVector( boxSize.x/3-7, boxSize.y/2 );     
365.       // rarely used with Conditional:
366.       adaptorSouth  = new PVector( boxSize.x/2 + 4, boxSize.y );
367.     }
368.     else {
369.       // item = all except Conditional / triangle     
370.       // calculate the four adaptors pos
371.       adaptorNorth  = new PVector( boxSize.x/2, 0 );
372.       adaptorEast   = new PVector( boxSize.x, boxSize.y/2 );   
373.       adaptorSouth  = new PVector( boxSize.x/2, boxSize.y );
374.       adaptorWest   = new PVector( 0, boxSize.y/2 );
375.     }
376.     //
377.     headerColor = _tempColor;
378.     objectID = getUniqueID();
379.     //
380.     plausibilityCheck();
381.   }// constructor
382.   //
383.   private void plausibilityCheck () {
384.     // checks whether there are not plausible parameters, e.g.
385.     // a defined header with a typeOfGraphicalItem that has no
386.     // header (header text ignored).
387.     // Same for color with colorless types.
388.     //
389.     // check header text
390.     if (typeOfGraphicalItem == typeOfGraphicalItemConditional ||
391.       typeOfGraphicalItem == typeOfGraphicalItemStandardWithoutHeader ||
392.       typeOfGraphicalItem == typeOfGraphicalItemStartEnd  ) {
393.       if (!textHeader.trim().equals("")) {
394.         println("Remark 285: StandardWithoutHeader or Conditional etc. "
395.           + "has defined header (not shown) with header: '"
396.           + textHeader
397.           + "' and normal text: '"
398.           + textNormal
399.           + "'. "
400.           + "Type being: "
401.           + typeOfGraphicalItemName[typeOfGraphicalItem]
402.           + ". Header ignored.");
403.       }
404.     } // if
405.     // check color
406.     if (typeOfGraphicalItem != typeOfGraphicalItemStandardWithHeader &&
407.       headerColor != black) {
408.       println("Remark 325: color is set for header "
409.         + "(headerColor <> 0). Header being: '"
410.         + textHeader
411.         + "' and normal text: '"
412.         + textNormal
413.         + "'. "
414.         + "Type being: "
415.         + typeOfGraphicalItemName[typeOfGraphicalItem]
416.         + ". Color ignored.");
417.     } // if
418.   } // func
419.   //
420.   void display() {
421.     // display a star in the text when selected
422.     if (selected == objectID) {
423.       if (textNormal.charAt(textNormal.length()-1) != '*') {
424.         textNormal+="*";
425.       }
426.     }
427.     else {
428.       if (textNormal.charAt(textNormal.length()-1) == '*') {
429.         // un-select
430.         textNormal=textNormal.substring(0, textNormal.length()-1);
431.       }
432.     }
433.     // display it
434.     switch (typeOfGraphicalItem) {
435.     case typeOfGraphicalItemStandardWithHeader:
436.       displayStandardWithHeader() ;
437.       break;
438.     case typeOfGraphicalItemStandardWithoutHeader:
439.       displayStandardWithoutHeader();
440.       break;
441.     case typeOfGraphicalItemConditional:
442.       displayConditional();
443.       break;
444.     case typeOfGraphicalItemStartEnd:
445.       displayStartEnd();
446.       break;
447.     default:
448.       println("Error occured 245 - unknown typeOfGraphicalItem");
449.       break;
450.     } // switch
451.     //
452.   } // method
453.   //
454.   private void displayStandardWithHeader() {
455.     fill (headerColor);
456.     stroke(0);
457.     // header rect
458.     rect (Position.x, Position.y,
459.     boxSize.x, headerHeight);
460.     fill(244);
461.     // rect for normal text field (lower half)
462.     rect (Position.x, Position.y+headerHeight,
463.     boxSize.x, boxSize.y-headerHeight);   
464.     fill (0);
465.     text (textHeader, Position.x+4, Position.y+2, boxSize.x-5, headerHeight);
466.     text (textNormal, Position.x+4, Position.y+headerHeight+2, boxSize.x-5, boxSize.y-headerHeight);
467.     // adaptors --------   
468.     showAdaptors(adaptorTo);
469.   } // method
470.   //
471.   private void displayStandardWithoutHeader() {
472.     fill(244);
473.     // rect for text field
474.     rect (Position.x, Position.y,
475.     boxSize.x, boxSize.y);   
476.     fill (0);
477.     text (textNormal,
478.     Position.x+4, Position.y+2,
479.     boxSize.x-5, boxSize.y);
480.     // adaptors --------
481.     showAdaptors(adaptorTo) ;
482.   } // method
483.   //
484.   private void displayConditional() {
485.     // Conditional is triangle
486.     fill(244);
487.     triangle (Position.x, Position.y,
488.     Position.x+boxSize.x+0, Position.y,
489.     Position.x+boxSize.x/2+5, Position.y + boxSize.y);   
490.     fill (0);
491.     textAlign(CENTER);
492.     text (textNormal,
493.     Position.x+2, Position.y+2,
494.     boxSize.x-5, boxSize.y );
495.     // adaptors ----------
496.     showAdaptors(adaptorTo) ;
497.   } // method
498.   //
499.   private void displayStartEnd() {
500.     fill(244);
501.     ellipseMode(CORNER);
502.     ellipse (Position.x, Position.y, boxSize.x, boxSize.y);   
503.     fill (0);
504.     textAlign(CENTER);
505.     text (textNormal,
506.     Position.x+7, Position.y+18,
507.     boxSize.x-5, boxSize.y );
508.     // adaptors ------------
509.     showAdaptors(adaptorTo) ;
510.   } // method
511.   //
512.   private void showAdaptors(ArrayList<AdaptorType> adaptorTo) {
513.     // adaptors --------
514.     for (AdaptorType adaptorThis : adaptorTo) {
515.       if (adaptorThis != null) {
516.         adaptorThis.display ( this ) ;
517.       } // if
518.     } // for
519.   } // method
520.   //
521.   void addAdaptor(AdaptorType _adaptorTo) {
522.     // appends one line on a existing GraphicalItem
523.     if (_adaptorTo.adaptorToGraphicalItem > -1) {
524.       adaptorTo.add (_adaptorTo);
525.     } // if
526.   } // method
527.   //
528.   boolean isMouseOver() {
529.     if (mouseX/myScale > Position.x
530.       && mouseX/myScale < Position.x + boxSize.x
531.       && mouseY/myScale - myTranslate > Position.y
532.       && mouseY/myScale - myTranslate < Position.y + boxSize.y) {
533.       return true;
534.     } // if
535.     else {
536.       return false;
537.     } // if else
538.   } // method
539.   //
540.   int getObjectID() {
541.     return objectID;
542.   } // method
543.   //
544.   void delete() {
545.     // delete one item in 3 steps:
546.     // 1. delete outgoing Adaptors
547.     adaptorTo.clear();
548.     // 2. delete incoming Adaptors   
549.     deleteAllIncomingAdaptors(this);
550.     // 3. delete graphicalItem itself
551.     graphicalItems.remove(this);
552.   } // method
553.   //
554.   private void deleteAllIncomingAdaptors( GraphicalItem myGraphicalItemParameter ) {
555.     // delete
556.     // go through all graphicalItems
557.     for (GraphicalItem myGraphicalItem : graphicalItems) {     
558.       // when it's different from the one being tested:
559.       if (myGraphicalItemParameter.objectID != myGraphicalItem.objectID) {
560.         // check its adaptors --------
561.         for (AdaptorType adaptorThis : adaptorTo) {
562.           // When it's leading to the item being deleted
563.           if (adaptorThis.adaptorToGraphicalItem==myGraphicalItemParameter.objectID) {
564.             myGraphicalItem.adaptorTo.remove(adaptorThis);
565.             // adaptorThis.remove();
566.           } // if
567.         } // for
568.       } // for
569.     } // if
570.   } // method
571.   //
572.   private int getUniqueID() {
573.     return id++;
574.   }
575.   //
576. } // class
577. // ==============================================================
578. class AdaptorType {
579.   // Represents one connecting line.
580.   //
581.   // Start point (FROM) is a point at
582.   // the GraphicalItem (a box) this
583.   // AdaptorType-object belongs to.
584.   // End point (TO) is another GraphicalItem
585.   // marked by the var adaptorToGraphicalItem
586.   // which is an Index for the ArrayList
587.   // graphicalItems.
588.   // To specify the exakt point at
589.   // the from-GraphicalItem, the var
590.   // fromAdaptor denotes whether it's
591.   // (clockwise) north, east, south or west.
592.   // And: To specify the exakt point at
593.   // the to-GraphicalItem, the var
594.   // toAdaptor denotes whether it's
595.   // (clockwise) north, east, south or west.
596.   //
597.   // Indices of another GraphicalItem
598.   int adaptorToGraphicalItem  = -1;    // other graphical item
599.   // from which Adaptor of the four
600.   int fromAdaptor = adaptorEast;  
601.   // to which Adaptor of the four 
602.   int toAdaptor   = adaptorEast;   
603.   //
604.   // constructor
605.   AdaptorType ( int tempAdaptorToGraphicalItem,
606.   int tempFromAdaptor,
607.   int tempToAdaptor ) {
608.     adaptorToGraphicalItem = tempAdaptorToGraphicalItem;
609.     fromAdaptor = tempFromAdaptor;
610.     toAdaptor = tempToAdaptor;
611.   } // constructor
612.   //
613.   void display(GraphicalItem startGraphicalItem) {
614.     // show the line
615.     if (startGraphicalItem!=null) {
616.       if (adaptorToGraphicalItem > -1) {
617.         PVector startVector = getPVector
618.           (startGraphicalItem, fromAdaptor);
619.         GraphicalItem toItem = getElementByID(adaptorToGraphicalItem);
620.         if (toItem!=null) {
621.           PVector endVector = getPVector
622.             (toItem, toAdaptor);
623.           line ( startVector.x, startVector.y,
624.           endVector.x, endVector.y );
625.         } // if
626.       } // if
627.     } // if
628.   } // method
629.   //
630.   private PVector getPVector(GraphicalItem graphicalItem, int whichAdaptor) {
631.     // returns x,y for one adaptor "whichAdaptor" on the
632.     // GraphicalItem named "startGraphicalItem".
633.     // Can therefore be used for the start point and the end point of
634.     // a line.
635.     PVector buffer = new PVector ();
636.     //
637.     switch (whichAdaptor) {
638.     case adaptorNorth:
639.       buffer.x=graphicalItem.Position.x+graphicalItem.adaptorNorth.x;
640.       buffer.y=graphicalItem.Position.y+graphicalItem.adaptorNorth.y;
641.       break;
642.     case adaptorEast:
643.       buffer.x=graphicalItem.Position.x+graphicalItem.adaptorEast.x;
644.       buffer.y=graphicalItem.Position.y+graphicalItem.adaptorEast.y;
645.       break;
646.     case adaptorSouth:
647.       buffer.x=graphicalItem.Position.x+graphicalItem.adaptorSouth.x;
648.       buffer.y=graphicalItem.Position.y+graphicalItem.adaptorSouth.y;
649.       break;
650.     case adaptorWest:
651.       buffer.x=graphicalItem.Position.x+graphicalItem.adaptorWest.x;
652.       buffer.y=graphicalItem.Position.y+graphicalItem.adaptorWest.y;
653.       break;
654.     default:
655.       println ("Error 337 - unknown adaptor");
656.       break;
657.     } // switch
658.     return buffer;
659.   } // method
660.   //
661. } // class
662. // ==============================================================