Quick first remark: OutItem strongly looks like InputItem.
Duplicate code is often a bad idea (if not always). That's the opposite of OOP...
Make one class and either parametrize it for the few differences (if any), or subclass it to make your two variants.

[EDIT] I haven't seen a difference except the way the color is determined...
Some little initial improvements:

1. Item[] inItem = new Item[4];
2. Item[] outItem = new Item[4];
3. int validate1, validate2, validateMouse1, validateMouse2 = 0;
4. float pos1StartX, pos1StartY, pos1EndX, pos1EndY = -999;
5. float pos2StartX, pos2StartY, pos2EndX, pos2EndY = -999;
6.  
7. boolean clickedBall1, clickedBall2, selectBall1, connection = false;
8.  
9. void setup() {
10.   size(800, 480);
11.   noStroke();
12.   smooth();
13.   for (int i = 0; i < 4; i++) {
14.     inItem[i] = new Item(true);
15.     outItem[i] = new Item(false);
16.   }
17. }
18.  
19. void draw() {
20.   background(130);
21.   drawLine();
22.   for (int i = 0; i < 4; i++) {
23.     inItem[i].update();
24.     inItem[i].display();
25.     outItem[i].update();
26.     outItem[i].display();
27.   }
28. }
29.  
30. void mouseReleased() {
31.   if (validateMouse1 == 1 && validate2 == 1) {
32.     connection = true;
33.   }
34.   if (!connection) {
35.     validate1 = 0;
36.     validate2 = 0;
37.     validateMouse1 = 0;
38.     pos1StartX = -999;
39.     pos1StartY = -999;
40.     pos1EndX = -999;
41.     pos1EndY = -999;
42.   }
43. }
44.  
45. void drawLine() {
46.   strokeWeight(2);
47.   pos1StartX = -999;
48.   pos1StartY = -999;
49.   pos1EndX = -999;
50.   pos1EndY = -999;
51.  
52.   if (inItem[0].mouseOverItem()) validate1 = 1;
53.   for (int i = 0; i < inItem.length; i++) {
54.     if (outItem[i].mouseOverItem()) {
55.       validate2 = 1;
56.     }
57.     else {
58.       validate2 = 0;
59.     }
60.  
61.     if (validate1 == 1 && mousePressed && !connection) {
62.       validateMouse1 = 1;
63.       stroke(255, 255, 0, 255);
64.       pos1StartX = inItem[i].location.x;
65.       pos1StartY = inItem[i].location.y;
66.       pos1EndX = mouseX;
67.       pos1EndY = mouseY;
68.       line(pos1StartX, pos1StartY, pos1EndX, pos1EndY);
69.     }
70.     else {
71.       stroke(255, 255, 0, 0);
72.       pos1StartX = -999;
73.       pos1StartY = -999;
74.       pos1EndX = -999;
75.       pos1EndY = -999;
76.     }
77.  
78.     if (connection) {
79.       validate1 = 0;
80.       validate2 = 0;
81.       pos1StartX = inItem[0].location.x;
82.       pos1StartY = inItem[0].location.y;
83.       pos2EndX = outItem[i].location.x;
84.       pos2EndY = outItem[i].location.y;
85.       stroke(255, 255, 255, 255);
86.       line(pos1StartX, pos1StartY, pos2EndX, pos2EndY);
87.     }
88.     else {
89.       pos1StartX = -999;
90.       pos1StartY = -999;
91.       pos1EndX = -999;
92.       pos1EndY = -999;
93.       stroke(255, 255, 255, 0);
94.     }
95.  
96.     if (connection && outItem[i].mouseOverItem() && mousePressed) {
97.       validate1 = 1;
98.       validate2 = 0;
99.       validateMouse1 = 0;
100.       connection = false;
101.     }
102.   }
103. }
104.  
105. class Item {
106.   int circleRadius = 50;
107.   PVector location, offsetLoc;
108.   PVector velocity, velocityStart, velocityStop;
109.   color colObject;
110.  
111.   // Constructor
112.   Item(boolean isInputItem) {
113.     location = new PVector((int) random(width), (int)random (height));
114.     offsetLoc = new PVector(circleRadius, 0);
115.     velocity = new PVector(random(-0.8, 0.8), random(-0.8, 0.8));
116.     velocityStart = new PVector(random(-0.8, 0.8), random(-0.8, 0.8)); 
117.     velocityStop = new PVector(0, 0);
118.     if (isInputItem) {
119.       colObject = color ((int) random (50), 0, (int) random (200));
120.     } else {
121.       colObject = color (200, (int) random (50), 0);
122.     }
123.   }
124.  
125.   void update() {
126.     location.add(velocity);
127.     if (location.x > width - circleRadius) {
128.       velocity.x *= -1;
129.       location.x = width - circleRadius;
130.     }
131.     else if (location.x < circleRadius) {
132.       velocity.x *= -1;
133.       location.x = circleRadius;
134.     }
135.  
136.     if (location.y > height - circleRadius) {
137.       velocity.y *= -1;
138.       location.y = height - circleRadius;
139.     }
140.     else if (location.y < circleRadius) {
141.       velocity.y *= -1;
142.       location.y = circleRadius;
143.     }
144.   }
145.  
146.   void display() {
147.     fill(colObject);
148.     noStroke();
149.     ellipse(location.x, location.y, circleRadius*1.5, circleRadius*1.5);
150.   }
151.  
152.   boolean mouseOverItem() {
153.     float disX = location.x - mouseX;
154.     float disY = location.y - mouseY;
155.     return sqrt(sq(disX) + sq(disY)) < circleRadius;
156.   }
157. }

I think you should memorize the connections and the state of the items: if one has a connection already or not.

PhiLho

Thanks for your suggestions. I am aware of this problem, however, I thought that in this case I need two classes: one which is the input class that allows mouse drag and creates the start of the line, and then the output class that when the mouse is released on its area (circle radius) it will complete the connection.

I have tried different methods but they don't work (as the one I posted earlier). Can someone suggest a way to solve this problem?

Cheers...!

I am thinking of using a multi-dimensional array and a nested for loop to validate all the possible connections (4x4). Does it sound logical to you? If someone has an example or alternative, maybe can share?

maybe this does help you.


(there are states in the program but they are not in use.)

There are 2 classes: the rects with texts and the lines.
Since each rect can have zero, one or many lines, there is an arraylist nested within the class for the rects which is pretty nasty.   This arraylist is a list of the lines (one list for each rect).
Each rect has 4 anchor points (north, east south west) for the lines.
Anyway, thus you can put lines upon lines on one rect.

You can't change the lines with the mouse though.
I just wanted to let you know my underlying data structure.

You can

• drag the individual tiles with mouse (left) and
• scale the whole thing with mouse (right).

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

" I thought that in this case I need two classes: one which is the input class that allows mouse drag and creates the start of the line, and then the output class that when the mouse is released on its area (circle radius) it will complete the connection."
You can make a base class (perhaps abstract), defining most of the common behavior, then make two sub-classes which would need only to define the specific behavior (accept input, accept output...).

I still don't get what you are trying to achieve.

But in another program, a game like chess, I click the start field (where the figure is), release the mouse.
Then I click the field to move to and release the mouse.

I have a boolean var to control this process: e.g. expectingStartfield which is true and when he clicked a correct start field it gets false and after that goal field true again.

Thus we know if the clicked field is a From- or a To-field.

Applies to your program? I recommend to use such a var expectingStartfield.