sounds like a job for regular expressions!

Unfortunately it does have to be done in Processing the teacher is a Java person and wants it in Java or Processing. I'll look at what you said, but it looks like that might be a way to go. Thanks     

We would be much more forthcoming with help if you could write the algorithm to do this out in some sort of pseudo code / in English.

Course name

Side Note: The problem in figuring the shortest time or the fewest courses to graduate is a   scheduling problem. Given constraints , either how soon, i.e time, or the fewest courses, i.e cost, one could plot out a schedule.   S cheduling problems, see   http://en.wikipedia.org/wiki/Job_shop_scheduling , are typically hard problems. 

No need for regular expressions, a simple split() should do the parsing job.

umh... this sentence kind of comes as a surprise:

 I need someway of finding what classes you need to take when you input a course name.

Do you mean
    I need someway of finding what classes you need to take when you input a CLASS name?

Or do courses (degrees?) consist of a number of classes? Then you would need to have a list that tells what classes are required for a certain course...

Greetings, Chrisir  

Hello,

ok, I made a kick-off

actually I didn't use outgoing proficiencies, the classes just know which other class is necessary (required) to attend them.

there's one recursive part: displayRequired. That's a bit clever. Try class 5.

If you would have students you could make a note which class she attended already.

Greetings, Chrisir  

1. // https://forum.processing.org/topic/help-with-a-class-assignment
2. /*
3.  I'm working on an assignment where I need to make an interactive course catalog.
4.  
5.  I'm suposed to read from two text files, one that
6.  * list the classes and the outgoing proficiencies
7.  * the other lists the classes and the need proficiencies to take that class.
8.  The files are formated such that the first thing in each line is the class name then a comma
9.  followed by the first proficiency the class gives you then a comma and so on.
10.  
11.  
12.  I need someway of finding what classes you need to take when you input a course name.
13.  
14.  
15.  */
16. // ArrayList students;
17. ArrayList <Classes> classes;
18. // ArrayList courses;
19. //
20. int classChosen=-1;
21. void setup() {
22.   size(800, 600);
23.   smooth();
24.   noStroke();
25.   // ------------------------------------------
26.   /*
27.   // Create an empty ArrayList
28.    students = new ArrayList();
29.   
30.    // Start by adding elements
31.    students.add(new Student("Peter", "413 Some Road"));
32.    students.add(new Student("Paul", "7 Other Road")); 
33.    students.add(new Student("Mary", "127 Yes Street"));
34.    */
35.   // ------------------------------------------
36.   // Create an empty ArrayList
37.   classes = new ArrayList();
38.   // Start by adding elements
39.   classes.add(new Classes("Paint a Circle", 0));
40.   classes.add(new Classes("Paint a rectangle", 1)); 
41.   classes.add(new Classes("Paint a Bike", 2));
42.   classes.add(new Classes("Paint a house", 3));
43.   classes.add(new Classes("Paint a village", 4)); 
44.   classes.add(new Classes("Paint a city", 5));
45.   classes.add(new Classes("Paint a car", 6));
46.   classes.add(new Classes("Paint a street", 7));
47.   //
48.   // enter required in the data
49.   Classes class1;
50.   //
51.   class1 = (Classes) classes.get(0);
52.   // none
53.   class1 = (Classes) classes.get(1);
54.   // none
55.   class1 = (Classes) classes.get(2);
56.   class1.addRequired ( 1 ) ;
57.   class1.addRequired ( 0 ) ;
58. 
    
59.   class1 = (Classes) classes.get(3);
60.   class1.addRequired ( 1 ) ;
61.   class1.addRequired ( 0 ) ;
62.   //
63.   class1 = (Classes) classes.get(4);
64.   class1.addRequired ( 3 ) ;
65.   //
66.   class1 = (Classes) classes.get(5);
67.   class1.addRequired ( 4 ) ;
68.   class1.addRequired ( 6 ) ;   
69.   class1.addRequired ( 7 ) ;     
70.   //
71.   class1 = (Classes) classes.get(6);
72.   class1.addRequired ( 1 ) ;
73.   class1.addRequired ( 0 ) ; 
74.   //
75.   class1 = (Classes) classes.get(7);
76.   class1.addRequired ( 1 ) ;
77. }
78. void draw() {
79.   background(255);
80.   //
81.   if  (classChosen<0) {
82.     mainMenu();
83.   }
84.   else
85.   {
86.     showOneClass ();
87.   } // if
88. } // func
89. // ------------------
90. void mainMenu() {
91.   // With an array, we say classes.length, with an ArrayList, we say classes.size()
92.   // The length of an ArrayList is dynamic
93.   for (int i = 0; i <= classes.size()-1; i++ ) {
94.     // An ArrayList doesn't know what it is storing so we have to cast the object coming out
95.     Classes class1 = (Classes) classes.get(i);
96.     class1.display(  i, 20, i*20+20  );
97.   }
98.   /*
99.   for (int i = students.size()-1; i >= 0; i--) {
100.    // An ArrayList doesn't know what it is storing so we have to cast the object coming out
101.    Student student = (Student) students.get(i);
102.    // students.move();
103.    student.display(  20, i*20+120  );
104.    if (student.finished()) {
105.    // Items can be deleted with remove()
106.    students.remove(i);
107.    }
108.    }
109.    */
110.   text ( "Please enter the class you want to take. ",
111.   20, classes.size() *20+40  );
112. }
113. // ----------------
114. void showOneClass () {
115.   if (classChosen < classes.size() ) {
116.     Classes class1 = (Classes) classes.get(classChosen);
117.     text ( "You chose:  " + class1.index
118.       + ". "
119.       + class1.className, 20, 20  );
120.     text("required classes : ", 20, 50 );    
121.     String result = class1.displayRequired( 0 );
122.     if (trim(result).equals("")) {
123.       text("Nothing.", 20, 70);
124.     }
125.     else {
126.       text(result, 20, 70);
127.     }
128.     text("Return to continue", 20, height-20);
129.   }
130.   else {
131.     text("This class doesn't exist yet", 20, 60);
132.     text("Return to continue", 20, 90);
133.   }
134. }
135. // ----------------
136. void mousePressed() {
137.   // mouse
138. }
139. //
140. void keyPressed () {
141.   // key
142.   if (key >= '0' && key <= '9') {
143.     // when class is not chosen
144.     if (classChosen < 0) {
145.       // take the ascii and make it 0..9
146.       // choose class
147.       classChosen = int(key)-48;
148.     } // if
149.   }
150.   else if (key == RETURN || key == ENTER) {
151.     // reset
152.     // println("return");
153.     // when class is chosen
154.     if (classChosen > -1) {
155.       // un-choose class, return to main menu
156.       classChosen = -1;
157.     }
158.   }
159.   else if (key == 'n') {
160.     //
161.     // do nothing
162.   }
163.   else {
164.     // do nothing
165.   } // else
166. } // keyPressed
167. //
168. // =========================================
169. // Simple classes
170. //
171. class Classes {
172.   String className;
173.   int index;
174.   //
175.   // what you need when you start that class  
176.   int[] classesNeeded = new int[32];         //  array
177.   // what you have when you finish that class  
178.   // int[] classesOutgoing ;                    //  array
179.   //
180.   int countclassesNeeded = 0;
181.   // constructor
182.   Classes(String tempClassName, int tempIndex) {
183.     className = tempClassName;
184.     index=tempIndex;
185.     countclassesNeeded=0;
186.   }  // constructor
187.   //
188.   void display( int i, int x, int y) {
189.     // Display
190.     fill(0);
191.     text(index
192.       + ". "
193.       + className
194.       + " ("
195.       + i
196.       + ").", x, y);
197.   }
198.   //
199.   void addRequired (int i ) {
200.     // within the class is an array
201.     // here you put something in it
202.     classesNeeded[ countclassesNeeded ] = i;
203.     countclassesNeeded++;
204.   }
205.   //
206.   String displayRequired( int depth) {
207.     // give back String
208.     String buffer="";
209.     fill(0);
210.     //
211.     for (int i = 0; i < countclassesNeeded; i++) {
212.       Classes class1 = (Classes) classes.get( classesNeeded[i] );
213.       buffer=buffer + giveSpaceSigns(depth*5)+class1.className + "\n";
214.       // recursive
     
215.       buffer=buffer + class1.displayRequired(depth+1);
216.       // text( class1.className + ".", x, y + 50 + i * 20  );
217.     }
218.     return buffer;
219.   } // method
220.   //
221.   String giveSpaceSigns(int spacesNeeded) {
222.     String buffer = "";
223.     for (int i = 0; i < spacesNeeded; i++) {
224.       buffer += " ";
225.     }
226.     return buffer;
227.   }
228.   //
229. } // class
230. //
231. // =========================================
232. /*
233. class Student {
234.  
235.  String studentName;
236.  String studentAdress;
237.  String studentBirthday; 
238.  
239.  String courseAim;
240.  int[] classesTaken;    //  array
241.  int[] classsTaken;   //  array
242.  
243.  
244.  Student(String tempName, String tempAdress) {
245.  studentName=tempName;
246.  studentAdress=tempAdress;
247.  }
248.  
249.  void move() {
250.  //
251.  }
252.  
253.  boolean finished() {
254.  //
255.  if (false) {
256.  return true;
257.  }
258.  else {
259.  return false;
260.  }
261.  }
262.  
263.  void display( int x, int y) {
264.  // Display
265.  fill(0);
266.  text(studentName, x, y);
267.  }
268.  } 
269.  
270.  */
271. // ==============================================================

Now the full blown program with loading of csv, do a split() and show on screen in a class menu.

It has now Proficiencies.

It has no recursion anymore.

More Info in the header of the program.

[Edited:

• It would be cleaner to have Proficiencies as an ArrayList as well and let the class needed and outgoing refer to the elements therein.
• Also if you want to check for errors in the data: check if all classes have outgoing Proficiencies, check if all needed Proficiencies are outgoing Proficiencies from another class (otherwise nobody ever will attend the class) or whether there are circle dependencies (you need class 1 to do class 2 to do class 1 or with three or more classes 1 - 2 - 3 - 1).Those classes would stay empty as well.
  
• Also a graphical view of the classes and the connections would be nice. ]

Greetings, Chrisir   

1. // https://forum.processing.org/topic/help-with-a-class-assignment
2. /*
3.  in the data folder
4.  one file needed.csv, content is:
5.  Class Three 194,
6.  Class One 194, Proficiency One, Proficiency Two, Proficiency Three
7.  Class Two 294, Proficiency 4, Proficiency 5, Proficiency 6
8.  Class Three 394, Proficiency One, Proficiency Two, Proficiency 6
9.  
10.  other file outgoing.csv
11.  Class One 194,Proficiency One, Proficiency Two,Proficiency Three
12.  Class Two 294, Proficiency 4, Proficiency 5,Proficiency 6
13.  Class Three 394, Proficiency 11
14.  
15.  
16.  I'm working on an assignment where I need to make an interactive course catalog.
17.  
18.  I'm suposed to read from two text files, one that
19.  * list the classes and the outgoing proficiencies
20.  * the other lists the classes and the need proficiencies to take that class.
21.  The files are formated such that the first thing in each line is the class name then a comma
22.  followed by the first proficiency the class gives you then a comma and so on.
23.  
24.  
25.  I need someway of finding what classes you need to take when you input a course name.
26.  
27.  */
28. // ArrayList students;
29. ArrayList<OneClass> classes;
30. //
31. int intClassCounter=0;
32. int classChosen=-1;
33. //
34. void setup() {
35.   size(800, 600);
36.   smooth();
37.   noStroke();
38.   println("Start");
39.   //
40.   //load
41.   String NeededForClassline[] = loadStrings("needed.csv");
42.   println("there are " + NeededForClassline.length + " lines");
43.   //
44.   //load
45.   String outgoingProficienciesOfClassline[] = loadStrings("outgoing.csv");
46.   println("there are " + outgoingProficienciesOfClassline.length + " lines");
47.   //
48.   // Create an empty ArrayList
49.   classes = new ArrayList();
50.   //
51.   // load data in the ArrayList
52.   // Needed
53.   for (int i = 0; i <= NeededForClassline.length-1; i++ ) { 
54.     // not empty
55.     if (!NeededForClassline[i].equals("")) {
56.       int currentElement;
57.       String[] thisLine=split (NeededForClassline[i], ",");
58.       // eval lines element #0 = class
59.       thisLine[0] = thisLine[0].trim();
60.       // if new
61.       if (!isInArraylist (thisLine[0], classes)) {
62.         classes.add(new OneClass(thisLine[0], intClassCounter));
63.         currentElement= intClassCounter;
64.         intClassCounter++;
65.       }
66.       else
67.       {
68.         currentElement=whereInArraylist (thisLine[0], classes )  ;
69.       }
70.       // eval lines element #1 and following
71.       for (int iItem = 1; iItem <= thisLine.length-1; iItem++ ) { 
72.         thisLine[iItem] = thisLine[iItem].trim();     
73.         OneClass class1 = (OneClass) classes.get(currentElement);
74.         class1.addRequired ( thisLine[iItem] ) ;
75.       }
76.     }
77.   }
78.   //
79.   // load data in the ArrayList
80.   // outgoing
81.   for (int i = 0; i <= outgoingProficienciesOfClassline.length-1; i++ ) { 
82.     if (!outgoingProficienciesOfClassline[i].equals("")) {
83.       String[] thisLine=split (outgoingProficienciesOfClassline[i], ",");
84.       int currentElement;
85.       // eval lines element #0 = class
86.       thisLine[0] = thisLine[0].trim();
87.       // if new
88.       if (!isInArraylist (thisLine[0], classes)) {
89.         classes.add(new OneClass(thisLine[0], intClassCounter));
90.         currentElement= intClassCounter;
91.         intClassCounter++;
92.       }
93.       else
94.       {
95.         currentElement=whereInArraylist (thisLine[0], classes )  ;
96.       }
97.       // eval lines element #1 and following
98.       for (int iItem = 1; iItem <= thisLine.length-1; iItem++ ) { 
99.         thisLine[iItem] = thisLine[iItem].trim();
100.         OneClass class1 = (OneClass) classes.get(currentElement);
101.         class1.addOutgoing ( thisLine[iItem] ) ;
102.       }
103.     }
104.   }
105.   // ------------------------------------------
106.   //  data reliable check
107.   // to do
108.   // ------------------------------------------
109.   /*
110.    // Create an empty ArrayList
111.    students = new ArrayList();
112.    // Start by adding elements
113.    students.add(new Student("Peter", "413 Some Road"));
114.    students.add(new Student("Paul", "7 Other Road"));
115.    students.add(new Student("Mary", "127 Yes Street"));
116.    */
117.   // ------------------------------------------
118. } // func
119. //
120. //
121. void draw() {
122.   background(255);
123.   //
124.   if  (classChosen<0) {
125.     mainMenu();
126.   }
127.   else
128.   {
129.     showOneClass ();
130.   } // if
131. } // func
132. //
133. // ------------------
134. //
135. void mainMenu() {
136.   // With an array, we say classes.length, with an ArrayList, we say classes.size()
137.   // The length of an ArrayList is dynamic
138.   for (int i = 0; i <= classes.size()-1; i++ ) {
139.     // An ArrayList doesn't know what it is storing so we have to cast the object coming out
140.     OneClass class1 = (OneClass) classes.get(i);
141.     class1.display(  i, 20, i*20+20  );
142.   }
143.   /*
144.       for (int i = students.size()-1; i >= 0; i--) {
145.    // An ArrayList doesn't know what it is storing so we have to cast the object coming out
146.    Student student = (Student) students.get(i);
147.    // students.move();
148.    student.display(  20, i*20+120  );
149.    if (student.finished()) {
150.    // Items can be deleted with remove()
151.    students.remove(i);
152.    }
153.    }
154.    */
155.   text ( "Please enter the class you want to see. ",
156.   20, classes.size() *20+40  );
157. }
158. // ----------------
159. void showOneClass () {
160.   if (classChosen < classes.size() ) {
161.     OneClass class1 = (OneClass) classes.get(classChosen);
162.     text ( "You chose:  "
163.       + class1.className, 20, 20  );
164.     text("required Proficiencies : ", 20, 50 );   
165.     String result = class1.getRequired( 0 );
166.     if (trim(result).equals("")) {
167.       text("Nothing.", 20, 70);
168.     }
169.     else {
170.       text(result, 20, 70);
171.     }
172.     //
173.     result = "";
174.     text("outgoing Proficiencies : ", 20, 240 );     
175.     result = class1.getOutgoing( 0 );
176.     if (trim(result).equals("")) {
177.       text("Nothing.", 20, 260);
178.     }
179.     else {
180.       text(result, 20, 260);
181.     }   
182.     text("Return to continue", 20, height-20);
183.   }
184.   else {
185.     text("This class doesn't exist yet", 20, 60);
186.     text("Return to continue", 20, 90);
187.   }
188. }
189. // ----------------
190. // Inputs *******************************
191. void mousePressed() {
192.   // mouse
193. }
194. //
195. void keyPressed () {
196.   // key
197.   if (key >= '0' && key <= '9') {
198.     // when class is not chosen
199.     if (classChosen < 0) {
200.       // take the ascii and make it 0..9
201.       // choose class
202.       classChosen = int(key)-48;
203.     } // if
204.   }
205.   else if (key == RETURN || key == ENTER) {
206.     // reset
207.     // println("return");
208.     // when class is chosen
209.     if (classChosen > -1) {
210.       // un-choose class, return to main menu
211.       classChosen = -1;
212.     }
213.   }
214.   else if (key == 'n') {
215.     //
216.     // do nothing
217.   }
218.   else {
219.     // do nothing
220.   } // else
221. } // keyPressed
222. //
223. // ----------------
224. // minor tools *******************************
225. boolean isInArraylist (String thisLine, ArrayList ArraylistTest) {
226.   // checks if thisLine is in the ArrayList
227.   for (int i = 0; i <= classes.size()-1; i++ ) {
228.     // An ArrayList doesn't know what it is storing so we have to cast the object coming out
229.     OneClass class1 = (OneClass) classes.get(i);
230.     if (class1.className.equals( thisLine)) {
231.       return true;
232.     }
233.   }
234.   return false;
235. }
236. //
237. int whereInArraylist (String thisLine, ArrayList ArraylistTest) {
238.   // assumes thisLine is in the ArrayList and returns the pos
239.   for (int i = 0; i <= classes.size()-1; i++ ) {
240.     // An ArrayList doesn't know what it is storing so we have to cast the object coming out
241.     OneClass class1 = (OneClass) classes.get(i);
242.     if (class1.className.equals( thisLine)) {
243.       return i;
244.     }
245.   }
246.   return -1;
247. }
248. //
249. String whichClassHasAsOutgoing (String testing) {
250.   // checks which class(es) has / have the outgoing testing
251.   String buffer="provided by ";
252.   for (int i = 0; i <= classes.size()-1; i++ ) {
253.     // An ArrayList doesn't know what it is storing so we have to cast the object coming out
254.     OneClass class1 = (OneClass) classes.get(i);
255.     if (class1.doesHaveOutgoing(testing)) {
256.       buffer+=class1.className+ ", ";
257.     }
258.   }
259.   buffer= buffer.trim();
260.   if (buffer.charAt(buffer.length()-1)==',') {
261.     buffer=buffer.substring(0, buffer.length()-1);
262.   }
263.   return buffer;
264. }
265. //
266. //
267. // =========================================
268. // classes
269. //
270. class OneClass {
271.   String className;
272.   int index;
273.   //
274.   // what you need when you start that class 
275.   String[] Needed = new String[32];    //  array
276.   // what you have when you finish that class 
277.   String[] Outgoing = new String[32];  //  array
278.   //
279.   int countNeeded ;
280.   int countOutgoing ;
281.   //
282.   //
283.   // constructor
284.   OneClass(String tempClassName, int tempIndex) {
285.     className = tempClassName;
286.     index=tempIndex;
287.     countNeeded=0;
288.     countOutgoing = 0;
289.   }  // constructor
290.   //
291.   void display( int i, int x, int y) {
292.     // display
293.     fill(0);
294.     text(index
295.       + ". "
296.       + className,
297.     x, y);
298.   } // method
299.   //
300.   void addRequired (String s ) {
301.     // within the class is an array
302.     // here you put something in it
303.     Needed[ countNeeded ] = s;
304.     countNeeded++;
305.   } // method
306.   //
307.   void addOutgoing (String s ) {
308.     // within the class is an array
309.     // here you put something in it
310.     Outgoing[ countOutgoing ] = s;
311.     countOutgoing++;
312.   } // method
313.   //
314.   String getRequired( int depth) {
315.     // give back String
316.     // returns required and the class(es) which provide(s) it
317.     String buffer="";
318.     for (int i = 0; i < countNeeded; i++) {
319.       if (!Needed[i].equals("")) {
320.         buffer += Needed[i]
321.           + " ("
322.           + whichClassHasAsOutgoing (Needed[i]) 
323.           + ")"
324.             + "\n";
325.       } // if
326.     } // for
327.     return buffer;
328.   } // method
329.   //
330.   String getOutgoing( int depth) {
331.     // give back String
332.     String buffer="";
333.     for (int i = 0; i < countOutgoing; i++) {
334.       buffer=buffer +  Outgoing[i]  + "\n";
335.     } // for
336.     return buffer;
337.   } // method
338.   //
339.   boolean doesHaveOutgoing(String testing) {
340.     // checks if the class has the outgoing testing
341.     for (int i = 0; i < countOutgoing; i++) {
342.       if (Outgoing[i].equals(testing) ) {
343.         return true;
344.       } // if
345.     }  // for
346.     return false;
347.   } // method
348.   // 
349.   /*
350.   String giveSpaceSigns(int spacesNeeded) {
351.    String buffer = "";
352.    for (int i = 0; i < spacesNeeded; i++) {
353.    buffer += " ";
354.    }
355.    return buffer;
356.    } // method */
357.   //
358. } // class
359. //
360. // =========================================
361. /*
362.     class Student {
363.  
364.  String studentName;
365.  String studentAdress;
366.  String studentBirthday;
367.  
368.  String classAim;
369.  int[] classesTaken;    //  array
370.  int[] classsTaken;   //  array
371.  
372.  
373.  Student(String tempName, String tempAdress) {
374.  studentName=tempName;
375.  studentAdress=tempAdress;
376.  }
377.  
378.  void move() {
379.  //
380.  }
381.  
382.  boolean finished() {
383.  //
384.  if (false) {
385.  return true;
386.  }
387.  else {
388.  return false;
389.  }
390.  }
391.  
392.  void display( int x, int y) {
393.  // Display
394.  fill(0);
395.  text(studentName, x, y);
396.  }
397.  }
398.  
399.  */
400. // ==============================================================

Hello,

just for fun, I did a small graphical representation of the courses and dependencies. 

I can drag the graphical boxes with my mouse ok.
But I realised when I use scale / translate this does not work anymore.

Without looking in the Code, it's probably too long: Any ideas on this?


Greetings, Chrisir  

1. // https://forum.processing.org/topic/help-with-a-class-assignment
2. /* in the data folder
3.  one file needed.csv, content is:
4.  Class Three 194,
5.  Class One 194, Proficiency One, Proficiency Two, Proficiency Three
6.  Class Two 294, Proficiency 4, Proficiency 5, Proficiency 6
7.  Class Three 394, Proficiency One, Proficiency Two, Proficiency 6
8.  
9.  other file outgoing.csv
10.  Class One 194,Proficiency One, Proficiency Two,Proficiency Three
11.  Class Two 294, Proficiency 4, Proficiency 5,Proficiency 6
12.  Class Three 394, Proficiency 11
13.  
14.  I'm working on an assignment where I need to make an interactive course catalog.
15.  
16.  I'm suposed to read from two text files, one that
17.  * list the classes and the outgoing proficiencies
18.  * the other lists the classes and the need proficiencies to take that class.
19.  The files are formated such that the first thing in each line is the class name then a comma
20.  followed by the first proficiency the class gives you then a comma and so on.
21.  I need someway of finding what classes you need to take when you input a course name. */
22. //
23. // ArrayList students;
24. ArrayList<OneClass> classes;
25. ArrayList<GraphicalItem> graphicalItems;
26. //
27. final color lightGreen = color (2, 244, 2, 22);
28. final color lightBlue = color(2, 0, 244, 22);
29. //
30. // State of programs
31. final int stateNormal = 0;
32. final int stateGraphical = 1;
33. final int stateTextual = 2;
34. int state=stateNormal;
35. //
36. // paths
37. // Editor program
38. final String strEditor = "notepad.exe";
39. // data
40. final String stringNeededCsv = "needed.csv";
41. final String stringOutgoingCsv = "outgoing.csv";
42. //
43. int intClassCounter=0;
44. int classChosen=-1;
45. //
46. // for graphical 
47. float myScale = 1.0;      // for scale and translating
48. float myTranslate = 0.0;
49. int lineY = 40;        // where to place net box vertically
50. boolean hold=false;    // mouse dragged?
51. GraphicalItem holdItem ;  // which item is dragged
52. //
53. // ---------------------------------------------------------------
54. void setup() {
55.   size( screen.width, screen.height );
56.   smooth();
57.   noStroke();
58.   fill(0);
59.   println("Start");
60.   //
61.   //load
62.   String NeededForClassline[] = loadStrings(stringNeededCsv);
63.   println("There are " + NeededForClassline.length
64.     + " lines for needed Proficiencies.");
65.   //
66.   //load
67.   String outgoingProficienciesOfClassline[] = loadStrings(stringOutgoingCsv);
68.   println("There are " + outgoingProficienciesOfClassline.length
69.     + " lines for outgoing Proficiencies.");
70.   //
71.   // Create an empty ArrayList
72.   classes = new ArrayList();
73.   //
74.   // load data in the ArrayList
75.   // Needed
76.   for (int i = 0; i <= NeededForClassline.length-1; i++ ) { 
77.     // not empty
78.     if (!NeededForClassline[i].equals("")) {
79.       int currentElement;
80.       String[] thisLine = split (NeededForClassline[i], ",");
81.       // eval lines element #0 = class
82.       thisLine[0] = thisLine[0].trim();
83.       // if new
84.       if (!isInArraylist (thisLine[0], classes)) {
85.         classes.add(new OneClass(thisLine[0], intClassCounter));
86.         currentElement= intClassCounter;
87.         intClassCounter++;
88.       }
89.       else
90.       {
91.         currentElement=whereInArraylist (thisLine[0], classes )  ;
92.       }
93.       // eval lines element #1 and following
94.       for (int iItem = 1; iItem <= thisLine.length-1; iItem++ ) { 
95.         thisLine[iItem] = thisLine[iItem].trim();     
96.         if (!thisLine[iItem].equals("")) {       
97.           OneClass class1 = classes.get(currentElement);
98.           class1.addNeeded ( thisLine[iItem] ) ;
99.         }
100.       }
101.     }
102.   }
103.   //
104.   // load data in the ArrayList
105.   // outgoing
106.   for (int i = 0; i <= outgoingProficienciesOfClassline.length-1; i++ ) { 
107.     if (!outgoingProficienciesOfClassline[i].equals("")) {
108.       String[] thisLine=split (outgoingProficienciesOfClassline[i], ",");
109.       int currentElement;
110.       // eval lines element #0 = class
111.       thisLine[0] = thisLine[0].trim();
112.       // if new
113.       if (!isInArraylist (thisLine[0], classes)) {
114.         classes.add(new OneClass(thisLine[0], intClassCounter));
115.         currentElement= intClassCounter;
116.         intClassCounter++;
117.       }
118.       else
119.       {
120.         currentElement=whereInArraylist (thisLine[0], classes )  ;
121.       }
122.       // eval lines element #1 and following
123.       for (int iItem = 1; iItem <= thisLine.length-1; iItem++ ) { 
124.         thisLine[iItem] = thisLine[iItem].trim();
125.         if (!thisLine[iItem].equals("")) {
126.           OneClass class1 = classes.get(currentElement);
127.           class1.addOutgoing ( thisLine[iItem] ) ;
128.         }
129.       }
130.     }
131.   }
132.   // ------------------------------------------
133.   //  data reliable check
134.   // to do
135.   // ------------------------------------------
136.   /*
137.    // Create an empty ArrayList
138.    students = new ArrayList();
139.    // Start by adding elements
140.    students.add(new Student("Peter", "413 Some Road"));
141.    students.add(new Student("Paul", "7 Other Road"));
142.    students.add(new Student("Mary", "127 Yes Street"));
143.    */
144.   // ------------------------------------------
145.   //
146.   // Create an empty ArrayList
147.   graphicalItems = new ArrayList();
148.   //
149.   holdItem = new GraphicalItem( 0, 0,
150.   "Dummy", "Dummy",
151.   -1, -1, -1, -1,
152.   lightBlue);
153.   //
154. } // func
155. //
156. //
157. void draw() {
158.   background(255);
159.   //
160.   if (state==stateNormal) {
161.     if  (classChosen<0) {
162.       mainMenu();
163.     }
164.     else
165.     {
166.       showOneClass ();
167.     } // if
168.   }
169.   else if (state==stateTextual) {
170.     showTextual();
171.   }
172.   else if (state==stateGraphical) {
173.     scale(myScale);
174.     translate( 0, myTranslate ) ;    
175.     showGraphical();
176.   }
177.   else {
178.     println ("Error 182" );
179.   }
180. } // func
181. //
182. // --------------------------------------------------------------------
183. //
184. void mainMenu() {
185.   text ( "List of the classes. ", 20, 20 );
186.   // With an array, we say classes.length, with an ArrayList, we say classes.size()
187.   // The length of an ArrayList is dynamic
188.   for (int i = 0; i <= classes.size()-1; i++ ) {
189.     // ArrayList
190.     OneClass class1 = classes.get(i);
191.     class1.display(  i, 20, i*20+50  );
192.   }
193.   text ( "Please enter the class you want to see (0-9, afterwards return to come back here).",
194.   20, classes.size() *20+60  );
195.   text ( "Or use: o / n load outgoing / needed; t textual, g graphical.",
196.   20, classes.size() *20+80  );
197. } // func
198. //
199. // -------------------------------------------
200. //
201. void showOneClass () {
202.   // shows one class as text with needed and outgoing
203.   if (classChosen < classes.size() ) {
204.     // show class
205.     OneClass class1 = classes.get(classChosen);
206.     text ( "You chose:  "
207.       + class1.className, 20, 20  );
208.     // needed Proficiencies     
209.     text("Required Proficiencies : ", 20, 50 );   
210.     String result = class1.getNeeded( 0 );
211.     if (trim(result).equals("")) {
212.       text("Nothing.", 20, 70);
213.     }
214.     else {
215.       text(result, 20, 70);
216.     }
217.     // outgoing Proficiencies
218.     result = "";
219.     stroke(209);
220.     line(20, 225, 220, 225);
221.     text("outgoing Proficiencies : ", 20, 240 );     
222.     result = class1.getOutgoing( 0 );
223.     if (trim(result).equals("")) {
224.       fill(244, 2, 2);
225.       text("Nothing. Error: No outgoing Proficiencies. ", 20, 260);
226.       fill(0);
227.     }
228.     else {
229.       text(result, 20, 260);
230.     }   
231.     text("Return to continue", 20, height-20);
232.   }
233.   else {
234.     text("This class doesn't exist yet", 20, 60);
235.     text("Return to continue", 20, 90);
236.   }
237. } // func
238. //
239. // -------------------------------------------------------------------------
240. //
241. //
242. // Inputs ****************************************************
243. //
244. void mousePressed() {
245.   if (state==stateGraphical) {
246.     if (mouseButton==LEFT) {
247.       for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
248.         GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
249.         if (myGraphicalItem1.isMouseOver()) {
250.           // return myGraphicalItem1;
251.           println(true);
252.           hold=true;
253.           holdItem=myGraphicalItem1;
254.         }
255.       } // for
256.     } // if
257.   } // if
258. } // func
259. //
260. void mouseDragged() {
261.   if (state==stateGraphical) {
262.     if (hold) {
263.       holdItem.Position.x = mouseX;
264.       holdItem.Position.y = mouseY;
265.     }
266.     if (mousePressed && mouseButton == RIGHT) {
267.       myScale=(map(mouseX, 0, width, 0, 2)); 
268.       myTranslate =  map(mouseY, 0, height, -height, height) ;
269.     } // if
270.   } // if
271. } // func
272. //
273. void mouseReleased () {
274.   if (state==stateGraphical) {
275.     if (mouseButton == LEFT) {
276.       hold = false;
277.     }
278.   }
279. }
280. //
281. void keyPressed () {
282.   if (state==stateNormal) {
283.     keyPressedStateNormal();
284.   }
285.   else if (state==stateGraphical) {
286.     //keyPressedStateGraphical
287.     if (key == RETURN || key == ENTER) {
288.       // return to main menu
289.       state=stateNormal;
290.       // un-choose class, return to main menu
291.       classChosen = -1;
292.       // println("main menu");
293.     }
294.   }
295.   else if (state==stateTextual) {
296.     if (key == RETURN || key == ENTER) {
297.       // return to main menu
298.       state=stateNormal;
299.       // un-choose class, return to main menu
300.       classChosen = -1;
301.       // println("main menu");
302.     }
303.   }
304.   else {
305.     println("Error 429");
306.   }
307. } // keyPressed
308. void keyPressedStateNormal() {
309.   // key
310.   if (key >= '0' && key <= '9') {
311.     // when class is not chosen
312.     if (classChosen < 0) {
313.       // take the ascii and make it 0..9
314.       // choose class
315.       classChosen = int(key)-48;
316.     } // if
317.   }
318.   else if (key == RETURN || key == ENTER) {
319.     // reset
320.     // println("return");
321.     // when class is chosen
322.     if (classChosen > -1) {
323.       // un-choose class, return to main menu
324.       classChosen = -1;
325.     }
326.   }
327.   else if (key == 'n') {
328.     //
329.     // open needed
330.     open( strEditor
331.       + " "
332.       + dataPath("")
333.       + stringNeededCsv  );
334.   }
335.   else if (key == 'o') {
336.     //
337.     // open outgoing
338.     open( strEditor
339.       + " "
340.       + dataPath("")
341.       + stringOutgoingCsv );
342.   }
343.   else if (key == 'g') {
344.     // go graphical
345.     myScale     = 1.0; // reset
346.     myTranslate = 0.0;
347.     initGraphical();
348.     state=stateGraphical;
349.   }
350.   else if (key == 't') { 
351.     state=stateTextual;
352.   }
353.   else {
354.     // do nothing
355.   } // else
356. }
357. //
358. // =================================================================
359. //
360. void initGraphical() {
361.   // only fills the graphicalItems from the arrayList
362.   graphicalItems.clear();
363.   lineY = 40;
364.   //
365.   // loop over all classes
366.   for (int i = 0; i <= classes.size()-1; i++ ) {
367.     // get it from ArrayList
368.     OneClass class1 = classes.get(i);
369.     // if it's a Beginner class (no Proficiency required)
370.     if (class1.countNeeded==0) {
371.       graphicalItems.add ( new GraphicalItem( 20, lineY,
372.       "Class 0", class1.className,
373.       -1, -1, -1, -1,
374.       lightGreen ));
375.       // now show outgoing Proficiencies and from there
376.       // all Proficiencies and classes.
377.       // Recursive
378.       showOutgoing( class1, graphicalItems.size()-1, 0 );
379.       lineY+=160;
380.     } // if
381.   } // for
382. } // func
383. //
384. //
385. void showOutgoing(OneClass class1, int myPointerToClass, int depth) {
386.   // only fills the graphicalItems from the arrayList
387.   // with outgoing Proficiencies & classes - recursive.
388.   // Since it's recursive we need a depth.
389.   int myPointer=0;
390.   // loop through outgoing Proficiencies of class1
391.   for (int j = 0; j < class1.countOutgoing; j++) {
392.     // try get the proficiency
393.     GraphicalItem theProficiencyGraphic =
394.       getElement("Proficiency", class1.Outgoing[j]);
395.     // Is it new?
396.     if (theProficiencyGraphic == null) {         
397.       graphicalItems.add ( new GraphicalItem( (depth+1)*290-120, lineY,
398.       "Proficiency", class1.Outgoing[j],
399.       -1, -1, -1, myPointerToClass,
400.       lightBlue));
401.       myPointer = graphicalItems.size()-1;
402.       lineY+=77;
403.     }
404.     else {
405.       // not new
406.       // add new line at "theProficiencyGraphic"
407.       int intNumber = getElementNumber("Proficiency", class1.Outgoing[j]);
408.       if (intNumber!=-1) {
409.         theProficiencyGraphic.addAdaptor ( -1, -1, -1, myPointerToClass );
410.         myPointer = intNumber;
411.         lineY-=77;
412.       }
413.     }
414.     int myPointerToClass2=-1;
415.     // now search classes that have those outgoing proficiencies as needed
416.     for (int k = 0; k <= classes.size()-1; k++ ) {
417.       // class to test
418.       OneClass class2 = classes.get(k);
419.       // is it needed?
420.       if (class2.doesHaveNeeded(class1.Outgoing[j])) {
421.         // try get the class
422.         GraphicalItem theClassGraphic=getElement("Class", class2.className);
423.         // Is it new?
424.         if (theClassGraphic == null) {
425.           // it's new, add it
426.           graphicalItems.add ( new GraphicalItem ( ((depth+1)*290), lineY,
427.           "Class", class2.className,
428.           -1, -1, -1, myPointer,
429.           lightGreen ));
430.           myPointerToClass2=graphicalItems.size()-1;
431.           lineY+=130;
432.         }
433.         else
434.         {
435.           // It's old 
436.           // add new line adaptor
437.           int intNumber = getElementNumber("Class", class2.className); 
438.           if (intNumber!=-1) {
439.             theClassGraphic.addAdaptor ( -1, -1, -1, myPointer );
440.             myPointerToClass2=intNumber ;
441.           }
442.         }
443.         // recursive
444.         showOutgoing(class2, myPointerToClass2, depth+1);
445.       } // if
446.     } // for
447.   } // for
448. } // func
449. //
450. void showGraphical() {
451.   // only shows the graphicalItems from the arrayList
452.   text ( "Graphical Representation  "
453.     + "                  "
454.     + "Return to continue. Drag with right mouse button: scale (x-direction) and up/down (y-direction)", 20, 14 );
455.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
456.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
457.     myGraphicalItem1.display() ;
458.   } // for
459. } // func
460. //
461. GraphicalItem getElement( String textHeaderParam, String textNormalParam ) {
462.   // returns object or null
463.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
464.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
465.     if (myGraphicalItem1.textHeader.equals(textHeaderParam) &&
466.       myGraphicalItem1.textNormal.equals(textNormalParam)) {
467.       return myGraphicalItem1;
468.     } // if
469.   } // for
470.   return null;
471. } // func
472. //
473. int getElementNumber( String textHeaderParam, String textNormalParam ) {
474.   // returns object or null
475.   for (int i = 0; i <= graphicalItems.size()-1; i++ ) {
476.     GraphicalItem myGraphicalItem1 = graphicalItems.get(i);
477.     if (myGraphicalItem1.textHeader.equals(textHeaderParam) &&
478.       myGraphicalItem1.textNormal.equals(textNormalParam)) {
479.       return i;
480.     } // if
481.   } // for
482.   return -1;
483. } // func
484. //
485. // =====================================================================
486. // minor tools *******************************
487. boolean isInArraylist (String thisLine, ArrayList ArraylistTest) {
488.   // checks if thisLine is in the ArrayList
489.   for (int i = 0; i <= classes.size()-1; i++ ) {
490.     // ArrayList
491.     OneClass class1 = classes.get(i);
492.     if (class1.className.equals( thisLine)) {
493.       return true;
494.     }
495.   }
496.   return false;
497. }
498. //
499. int whereInArraylist (String thisLine, ArrayList ArraylistTest) {
500.   // assumes thisLine is in the ArrayList and returns the pos
501.   for (int i = 0; i <= classes.size()-1; i++ ) {
502.     // ArrayList
503.     OneClass class1 = classes.get(i);
504.     if (class1.className.equals( thisLine)) {
505.       return i;
506.     }
507.   }
508.   return -1;
509. }
510. //
511. String whichClassHasAsOutgoing (String testing) {
512.   // checks which class(es) has / have the outgoing testing
513.   final String bufferInitial="provided by ";
514.   String buffer=bufferInitial;
515.   //
516.   for (int i = 0; i <= classes.size()-1; i++ ) {
517.     // ArrayList
518.     OneClass class1 = classes.get(i);
519.     if (class1.doesHaveOutgoing(testing)) {
520.       buffer+=class1.className+ ", ";
521.     }
522.   }
523.   buffer = buffer.trim();
524.   if (buffer.charAt(buffer.length()-1)==',') {
525.     buffer=buffer.substring(0, buffer.length()-1);
526.   }
527.   buffer=buffer.trim();
528.   if (buffer.trim().equals(trim(bufferInitial))) {
529.     buffer = "Error: No class provides this.";
530.     // println("Error");
531.   }
532.   return buffer;
533. }
534. //
535. void showTextual() {
536.   //
537.   text ("Textual Representation (classes and outgoing)", 20, 14 );
538.   int lineY = 40;
539.   for (int i = 0; i <= classes.size()-1; i++ ) {
540.     // ArrayList
541.     OneClass class1 = classes.get(i);
542.     class1.display(  i, 20, lineY );
543.     lineY+=17;
544.     // give back String
545.     String buffer="";
546.     for (int j = 0; j < class1.countOutgoing; j++) {
547.       buffer=buffer +  class1.Outgoing[j]  + "\n";
548.       text (class1.Outgoing[j], 49, lineY );
549.       lineY+=17;
550.     } // for
551.     lineY+=9;
552.   } //
553.   text("Return to continue", 20, height-40);
554. } // func
555. //
556. // ===========================================================
557. // classes
558. //
559. class OneClass {
560.   String className;
561.   int index;
562.   //
563.   // what you need when you start that class 
564.   String[] Needed = new String[32];    //  array
565.   // what you have when you finish that class 
566.   String[] Outgoing = new String[32];  //  array
567.   //
568.   int countNeeded ;
569.   int countOutgoing ;
570.   //
571.   //
572.   // constructor
573.   OneClass(String tempClassName, int tempIndex) {
574.     className = tempClassName;
575.     index=tempIndex;
576.     countNeeded=0;
577.     countOutgoing = 0;
578.   }  // constructor
579.   //
580.   void display( int i, int x, int y) {
581.     // display
582.     fill(0);
583.     text(index
584.       + ". "
585.       + className,
586.     x, y);
587.   } // method
588.   //
589.   // adding methods -------
590.   void addNeeded (String s ) {
591.     // within the class is an array
592.     // here you put something in it
593.     Needed[ countNeeded ] = s;
594.     countNeeded++;
595.   } // method
596.   //
597.   void addOutgoing (String s ) {
598.     // within the class is an array
599.     // here you put something in it
600.     Outgoing[ countOutgoing ] = s;
601.     countOutgoing++;
602.   } // method
603.   //
604.   // getting methods -------
605.   String getNeeded( int depth) {
606.     // give back String
607.     // returns Needed / required and the class(es) which provide(s) it
608.     String buffer="";
609.     for (int i = 0; i < countNeeded; i++) {
610.       if (!Needed[i].equals("")) {
611.         buffer += Needed[i]
612.           + " ("
613.           + whichClassHasAsOutgoing (Needed[i]) 
614.           + ")"
615.             + "\n";
616.       } // if
617.     } // for
618.     return buffer;
619.   } // method
620.   //
621.   String getOutgoing( int depth) {
622.     // give back String
623.     String buffer="";
624.     for (int i = 0; i < countOutgoing; i++) {
625.       buffer=buffer +  Outgoing[i]  + "\n";
626.     } // for
627.     return buffer;
628.   } // method
629.   //
630.   // does have methods
631.   boolean doesHaveNeeded(String testing) {
632.     // checks if the class has the outgoing "testing"
633.     for (int i = 0; i < countNeeded; i++) {
634.       if (Needed[i].equals(testing) ) {
635.         return true;
636.       } // if
637.     }  // for
638.     return false;
639.   } // method
640.   //
641.   boolean doesHaveOutgoing(String testing) {
642.     // checks if the class has the outgoing "testing"
643.     for (int i = 0; i < countOutgoing; i++) {
644.       if (Outgoing[i].equals(testing) ) {
645.         return true;
646.       } // if
647.     }  // for
648.     return false;
649.   } // method 
650.   //
651. } // class
652. //
653. // =========================================
654. /* class Student {
655.  
656.  String studentName;
657.  String studentAdress;
658.  String studentBirthday;
659.  
660.  String classAim;
661.  int[] classesTaken;    //  array
662.  int[] classsTaken;   //  array
663.  
664.  
665.  Student(String tempName, String tempAdress) {
666.  studentName=tempName;
667.  studentAdress=tempAdress;
668.  }
669.  
670.  void move() {
671.  //
672.  }
673.  
674.  boolean finished() {
675.  //
676.  if (false) {
677.  return true;
678.  }
679.  else {
680.  return false;
681.  }
682.  }
683.  
684.  void display( int x, int y) {
685.  // Display
686.  fill(0);
687.  text(studentName, x, y);
688.  }
689.  }
690.  
691.  */
692. // ==============================================================
693. class GraphicalItem {
694.   //
695.   PVector Position;   // Pos and size of the whole box
696.   PVector boxSize;    // Size
697.   final int headerHeight = 20;  // Height of header text
698.   color headerColor;
699.   //
700.   String textHeader="";
701.   String textNormal="";
702.   //
703.   PVector adaptorLeft, adaptorRight;  // Positions of adaptors
704.   PVector adaptorUp, adaptorDown; 
705.   //
706.   // where the adaptors lead to: array of
707.   // Indices of another GraphicalItem
708.   int adaptorUpTo[]     = new int [1]  ; 
709.   int adaptorRightTo[]  = new int [1]  ; 
710.   int adaptorDownTo[]   = new int [1]  ; 
711.   int adaptorLeftTo[]   = new int [1]  ; 
712.   //
713.   // constructor ---------------------------------------------------
714.   GraphicalItem(int _x, int _y,
715.   String _header, String _normalText,
716.   int _adaptorUpTo, int _adaptorRightTo,
717.   int _adaptorDownTo, int _adaptorLeftTo,
718.   color _tempColor) {
719.     // constructor
720.     Position = new PVector();
721.     boxSize = new PVector( 100, 70 );
722.     Position.x=_x;
723.     Position.y=_y;
724.     //
725.     textHeader=_header;
726.     textNormal=_normalText;
727.     //
728.     adaptorUpTo [0]   = _adaptorUpTo;
729.     adaptorRightTo[0] = _adaptorRightTo;
730.     adaptorDownTo [0] = _adaptorDownTo;
731.     adaptorLeftTo [0] = _adaptorLeftTo;
732.     //
733.     adaptorLeft = new PVector( 0, boxSize.y/2 );
734.     adaptorRight = new PVector( boxSize.x, boxSize.y/2 );   
735.     adaptorUp = new PVector( boxSize.x/2, 0 );
736.     adaptorDown  = new PVector( boxSize.x/2, boxSize.y );
737.     //
738.     headerColor = _tempColor;
739.   }// constructor
740.   //
741.   void display() {
742.     fill (headerColor);
743.     stroke(0);
744.     // header rect
745.     rect (Position.x, Position.y,
746.     boxSize.x, headerHeight);
747.     fill(244);
748.     // rect for normal text field (lower half)
749.     rect (Position.x, Position.y+headerHeight,
750.     boxSize.x, boxSize.y-headerHeight);   
751.     // horizontal line between header text and normal text
752.     // text 
753.     fill (0);
754.     text (textHeader, Position.x+4, Position.y+2, boxSize.x-5, headerHeight);
755.     text (textNormal, Position.x+4, Position.y+headerHeight+2, boxSize.x-5, boxSize.y-headerHeight);
756.     // adaptors
757.     GraphicalItem myGraphicalItem1;
758.     for (int i=0; i < adaptorLeftTo.length; i++) {
759.       if (adaptorLeftTo[i]>-1) {
760.         myGraphicalItem1 = graphicalItems.get( adaptorLeftTo[i] );
761.         line (Position.x+adaptorLeft.x,
762.         Position.y+adaptorLeft.y,
763.         myGraphicalItem1.Position.x + myGraphicalItem1.adaptorRight.x,
764.         myGraphicalItem1.Position.y + myGraphicalItem1.adaptorRight.y);
765.       }
766.     }
767.   } // method
768.   //
769.   void addAdaptor( 
770.   int _adaptorUpTo, int _adaptorRightTo,
771.   int _adaptorDownTo, int _adaptorLeftTo) {
772.     //
773.     if (_adaptorLeftTo>-1) {
774.       adaptorLeftTo=append(adaptorLeftTo, _adaptorLeftTo );
775.     }
776.   } // method
777.   //
778.   boolean isMouseOver() {
779.     if (mouseX>Position.x && mouseX<Position.x+boxSize.x &&
780.       mouseY>Position.y && mouseY<Position.y+boxSize.y) {
781.       return true;
782.     }
783.     else
784.     {
785.       return false;
786.     }
787.   } // method
788. } // class
789. // ==============================================================