# Objekte in JPanel bewegen



## MK234 (17. Okt 2011)

Hallo,
ich schreibe an einem Programm in welchem in ein JPanel verschiedene Objekte gezeichnet werden
können z.B. Kreise, Rechtecke etc.
Diese Objekte können über Linien miteinander verbunden werden.
Es soll möglich sein mehrere Kreise und Rechtecke gleichzeitig verschieben zu können, wobei 
die Linien dementsprechend verlängert oder verkürzt werden.
Mein Programm funktioniert fehlerfrei wenn ich nur ein Objekt verschiebe, versuche ich mehrere Objekte
zu verschieben, so lassen sich zwar alle ausgewählten Objekte verschieben, aber nicht alle Verbindungs-
linien bewegen sich mit.

Anbei die relevanten Code-Abschnitte:

```
//zu verschiebenden Elemente werden gekennzeichnet mit gelb
    	 if(model.getVerschKenn()) {
    		
    		 for(int i=0; i < model.Trans_Array.size(); i++) {
    			 if(x >= model.Trans_Array.get(i).trans_x_kor && 
    					 x <= model.Trans_Array.get(i).trans_x_kor+groesseWidth &&
    					 y >= model.Trans_Array.get(i).trans_y_kor && 
    					 y <= model.Trans_Array.get(i).trans_y_kor+groesseHeight) { 
    				model.Trans_Array.get(i).versch_kenn = true;  
    				
    				
    			 }   
    		 }
    		 for(int j=0; j < model.Stellen_Array.size(); j++) {
    			 if(x >= model.Stellen_Array.get(j).stelle_x_kor && x 
    					 <= model.Stellen_Array.get(j).stelle_x_kor+groesseWidth &&
    					 y >= model.Stellen_Array.get(j).stelle_y_kor && 
    					 y <= model.Stellen_Array.get(j).stelle_y_kor+groesseHeight) {
    				 model.Stellen_Array.get(j).versch_kenn = true;    				
    			 }
    		 }
    		 repaint();
    	 }
```


```
//mehrere Elemente, welche zuvor gelb gekennzeichnet wurden, werden jetzt gleichzeitig verschoben
    	 if(model.getMehrVerschieben()) {     	
    		 
    		 for(int i=0; i < model.Trans_Array.size(); i++) {
    			 if(x >= model.Trans_Array.get(i).trans_x_kor && 
    					 x <= model.Trans_Array.get(i).trans_x_kor+groesseWidth &&
    					 y >= model.Trans_Array.get(i).trans_y_kor && 
    					 y <= model.Trans_Array.get(i).trans_y_kor+groesseHeight &&
    					 model.Trans_Array.get(i).versch_kenn) {     				
    				
    				 xOffset = x - model.Trans_Array.get(i).trans_x_kor;    				
    				 yOffset = y - model.Trans_Array.get(i).trans_y_kor; 				
    				
     				 merke = i;
     				 schiebtTransition = true;
     				 schiebtStelle = false;
     				 model.VerschElem_Array.add(new VerschiebenElemente(merke, 1, 0, 0));  
     				for(int q=0; q < model.Trans_Array.size(); q++) {
    					 if(q == i) {
    						 //do nothing
    					 } else if(model.Trans_Array.get(q).versch_kenn) {
    						 int zahl1 = model.Trans_Array.get(merke).trans_x_kor -
    								 model.Trans_Array.get(q).trans_x_kor;
    						 int zahl2 = model.Trans_Array.get(merke).trans_y_kor -
    								 model.Trans_Array.get(q).trans_y_kor;
    						 
    						 model.VerschElem_Array.add(new VerschiebenElemente(q, 1, zahl1, zahl2));   						
    					 }
    				 }
     				for(int q=0; q < model.Stellen_Array.size(); q++) {
    					if(model.Stellen_Array.get(q).versch_kenn) {
    						 int zahl1 = model.Trans_Array.get(merke).trans_x_kor -
    								 model.Stellen_Array.get(q).stelle_x_kor;
    						 int zahl2 = model.Trans_Array.get(merke).trans_y_kor -
    								 model.Stellen_Array.get(q).stelle_y_kor;
    						 model.VerschElem_Array.add(new VerschiebenElemente(q, 2, zahl1, zahl2));
    					 }
    				 }
    			 }  
    		 }
    		 for(int i=0; i < model.Stellen_Array.size(); i++) {
    			 if(x >= model.Stellen_Array.get(i).stelle_x_kor && 
    					 x <= model.Stellen_Array.get(i).stelle_x_kor+groesseWidth &&
    					 y >= model.Stellen_Array.get(i).stelle_y_kor && 
    					 y <= model.Stellen_Array.get(i).stelle_y_kor+groesseHeight&&
    					 model.Stellen_Array.get(i).versch_kenn) {
    				 
    				 xOffset =  x - model.Stellen_Array.get(i).stelle_x_kor;
    				 yOffset =  y - model.Stellen_Array.get(i).stelle_y_kor;
    				 merke = i;
    				 schiebtTransition = false;
     				 schiebtStelle = true;
     				 model.VerschElem_Array.add(new VerschiebenElemente(merke, 2, 0, 0));
     				 for(int q=0; q < model.Stellen_Array.size(); q++) {
     					 if(q == i) {
     						 //do nothing
     					 } else if(model.Stellen_Array.get(q).versch_kenn) {
     						 int zahl1 = model.Stellen_Array.get(merke).stelle_x_kor -
     								 model.Stellen_Array.get(q).stelle_x_kor;
     						 int zahl2 = model.Stellen_Array.get(merke).stelle_y_kor -
     								 model.Stellen_Array.get(q).stelle_y_kor;
     						 model.VerschElem_Array.add(new VerschiebenElemente(q, 2, zahl1, zahl2));
     					 }
     				 }
     				for(int q=0; q < model.Trans_Array.size(); q++) {
   					 if(model.Trans_Array.get(q).versch_kenn) {
   						 int zahl1 = model.Stellen_Array.get(merke).stelle_x_kor -
   								 model.Trans_Array.get(q).trans_x_kor;
   						 int zahl2 = model.Stellen_Array.get(merke).stelle_y_kor -
   								 model.Trans_Array.get(q).trans_y_kor;
   						 
   						 model.VerschElem_Array.add(new VerschiebenElemente(q, 1, zahl1, zahl2));   						
   					 }
   				 }
    			 }
    		 }  
    		 
    		 //repaint in MouseDragged
    	 }
```




```
} else if (model.getMehrVerschieben()) {    		      		  
    		
    		  for(int p=0; p < model.VerschElem_Array.size(); p++) {
    			  z_trans.clear();
  	    		  v_trans.clear();
  	    		  z_stelle.clear();
        		  v_stelle.clear();   
  	    		  
    			
    			  if(model.VerschElem_Array.get(p).Sorte == 1) {
    				  int abstandX = model.VerschElem_Array.get(p).AbstandX;
  	 				  int abstandY = model.VerschElem_Array.get(p).AbstandY;
  	 				
  	 				  model.Trans_Array.set(model.VerschElem_Array.get(p).Pos,
  							 (new Transition( 
  									  e.getX()- abstandX - xOffset, 
  							 e.getY() - abstandY - yOffset, 
  							 model.Trans_Array.get(p).trans_laenge, 
  							 model.Trans_Array.get(p).trans_breite, 
  							 model.Trans_Array.get(p).trans_color, 
  							 model.Trans_Array.get(p).text,
  							 model.Trans_Array.get(p).trans_aktiv,
  							 true)));   
  	 				
  	 				
  	 				 
  	 				for(int r=0; r < model.Verb_Array.size(); r++) {
  	 					if(model.Verb_Array.get(r).von_Trans && 
  	 							model.Verb_Array.get(r).zu_Stelle &&
  	 							model.Verb_Array.get(r).index_Trans == p) {
  	 						v_trans.add(r);
  	 					} else if(model.Verb_Array.get(r).zu_Trans &&
  	 							model.Verb_Array.get(r).von_Stelle &&
  	 							model.Verb_Array.get(r).index_Trans == p ) {
  	 						z_trans.add(r);
  	 					}
  	 				}
  	 				
  	 				
  	 				if(v_trans.size() > 0) {
  	 					for(int s=0; s < v_trans.size(); s++) {
  	 						int in = v_trans.get(s);
  	 						model.Verb_Array.set(in, new Verbindung(
  	 								model.Trans_Array.get(p).trans_x_kor+(groesseWidth/2),
  	 								model.Trans_Array.get(p).trans_y_kor+(groesseHeight/2),
  	 								model.Verb_Array.get(in).xEnde,
  	 								model.Verb_Array.get(in).yEnde,
  	 								model.Verb_Array.get(in).color,
  	 								model.Verb_Array.get(in).von_Trans,
  	 								model.Verb_Array.get(in).von_Stelle,
  	 								model.Verb_Array.get(in).zu_Trans,
  	 								model.Verb_Array.get(in).zu_Stelle,
  	 								model.Verb_Array.get(in).index_Trans,
  	 								model.Verb_Array.get(in).index_Stelle));
  	 					 repaint();
  	 					} 	 					
  	 				}
  	 				
  	 				if(z_trans.size() > 0) {
  	 					for(int s=0; s < z_trans.size(); s++) {
  	 						int in = z_trans.get(s);
  	 						model.Verb_Array.set(in, new Verbindung(
  	 								model.Verb_Array.get(in).xAnfang,
  	 								model.Verb_Array.get(in).yAnfang,
  	 								model.Trans_Array.get(p).trans_x_kor+(groesseWidth/2),
  	 								model.Trans_Array.get(p).trans_y_kor+(groesseHeight/2),
  	 								model.Verb_Array.get(in).color,
  	 								model.Verb_Array.get(in).von_Trans,
  	 								model.Verb_Array.get(in).von_Stelle,
  	 								model.Verb_Array.get(in).zu_Trans,
  	 								model.Verb_Array.get(in).zu_Stelle,
  	 								model.Verb_Array.get(in).index_Trans,
  	 								model.Verb_Array.get(in).index_Stelle));
  	 					 repaint();  	 					
  	 					} 	 					
  	 				}  	 				

  	 				
  	 				
  	 				
    			  }	else if(model.VerschElem_Array.get(p).Sorte == 2) {
    				  int abstandX = model.VerschElem_Array.get(p).AbstandX;
    	 				int abstandY = model.VerschElem_Array.get(p).AbstandY;
    	 				model.Stellen_Array.set(model.VerschElem_Array.get(p).Pos,
    	 						new Stelle(e.getX() - abstandX - xOffset,
    	 								e.getY() - abstandY - yOffset,
    	 								model.Stellen_Array.get(p).stelle_laenge,
    	 								model.Stellen_Array.get(p).stelle_breite,
    	 								model.Stellen_Array.get(p).anzahl_Markierungen,
    	 								model.Stellen_Array.get(p).stelle_color,
    	 								model.Stellen_Array.get(p).tex,
    	 								true));
    	 				
    	 				for(int r=0; r < model.Verb_Array.size();r++) {
    	 					if(model.Verb_Array.get(r).von_Stelle && 
      	 							model.Verb_Array.get(r).zu_Trans &&
      	 							model.Verb_Array.get(r).index_Stelle == p) {    	 						
      	 						v_stelle.add(r);
      	 					} else if(model.Verb_Array.get(r).zu_Stelle &&
      	 							model.Verb_Array.get(r).von_Trans &&
      	 							model.Verb_Array.get(r).index_Stelle == p) {
      	 						z_stelle.add(r);
      	 					}
    	 				}
    	 				
    	 				if(v_stelle.size() > 0) {
      	 					for(int s=0; s < v_stelle.size(); s++) {
      	 						int in = v_stelle.get(s);
      	 						model.Verb_Array.set(in, new Verbindung(
      	 								model.Stellen_Array.get(p).stelle_x_kor+(groesseWidth/2),
      	 								model.Stellen_Array.get(p).stelle_y_kor+(groesseHeight/2),
      	 								model.Verb_Array.get(in).xEnde,
      	 								model.Verb_Array.get(in).yEnde,
      	 								model.Verb_Array.get(in).color,
      	 								model.Verb_Array.get(in).von_Trans,
      	 								model.Verb_Array.get(in).von_Stelle,
      	 								model.Verb_Array.get(in).zu_Trans,
      	 								model.Verb_Array.get(in).zu_Stelle,
      	 								model.Verb_Array.get(in).index_Trans,
      	 								model.Verb_Array.get(in).index_Stelle));
      	 					 repaint();
      	 					}      	 					
      	 				}
    	 				
    	 				if(z_stelle.size() > 0) {
      	 					for(int s=0; s < z_stelle.size(); s++) {
      	 						int in = z_stelle.get(s);
      	 						model.Verb_Array.set(in, new Verbindung(
      	 								model.Verb_Array.get(in).xAnfang,
      	 								model.Verb_Array.get(in).yAnfang,
      	 								model.Stellen_Array.get(p).stelle_x_kor+(groesseWidth/2),
      	 								model.Stellen_Array.get(p).stelle_y_kor+(groesseHeight/2),
      	 								model.Verb_Array.get(in).color,
      	 								model.Verb_Array.get(in).von_Trans,
      	 								model.Verb_Array.get(in).von_Stelle,
      	 								model.Verb_Array.get(in).zu_Trans,
      	 								model.Verb_Array.get(in).zu_Stelle,
      	 								model.Verb_Array.get(in).index_Trans,
      	 								model.Verb_Array.get(in).index_Stelle));
      	 					 repaint();
      	 					} 
      	 				}
    			  }
			  
	 		  }   		 
    	  }    	  
    	  repaint();
      }
```


Hat irgendjemand schon mal ein ähnliches Problem gehabt? Ich sitze seit heute Vormittag daran und
kann den Fehler einfach nicht finden.


----------



## SlaterB (17. Okt 2011)

genau so ein Programm habe ich auch mal geschrieben, könnte ich bei Bedarf heraussuchen,

um mit deinem Code irgendwas anzufangen sollte der schon vollständig sein, wo du jetzt soviel Verschiebe-Logik gepostet hast kann ja 
nicht mehr viel spannendes zu verheimlichen sein, falls viel anderes drinsteckt einfach kürzen kürzen kürzen

den geposteten Code selber solltest du auch noch überarbeiten bevor du ihn jemanden zumutest,
in der ersten Schleife im ersten geposteten Code-Block könntest du eine Variable
Typ m = model.Trans_Array.get(i);
definieren und an den folgenden Stellen überall m verwenden, schon sind fast 50% schiere Zeichenanzahl weg, der Code wird lesbarer,

allein dieser einfache Schritt überall angewandt verändert das Code-Bild deutlich zum Besseren, die Zeit dafür solltest du immer investieren,
wenn schon nicht für dich, dann wenn du anderen den Code zumutest

bei später
model.Trans_Array.get(i)
model.Trans_Array.get(q)
model.Trans_Array.get(merke)
musst du ja nicht alle ersetzen, besonders nicht model.Trans_Array.get(merke) mit variablen merke-Index,
aber allein diesen Block

```
for(int q=0; q < model.Trans_Array.size(); q++) {
                         if(q == i) {
                             //do nothing
                         } else if(model.Trans_Array.get(q).versch_kenn) {
                             int zahl1 = model.Trans_Array.get(merke).trans_x_kor -
                                     model.Trans_Array.get(q).trans_x_kor;
                             int zahl2 = model.Trans_Array.get(merke).trans_y_kor -
                                     model.Trans_Array.get(q).trans_y_kor;
                             
                             model.VerschElem_Array.add(new VerschiebenElemente(q, 1, zahl1, zahl2));                           
                         }
                     }
```
sehe ich mit knappen Änderungen 4x, kann der nicht in eine Untermethode mit variablen Parametern?

wenn es zu kompliziert ist und du vielleicht Fehler einbaust, dann verzichte vorerst darauf,
aber solange du solche Wiederholungen hast ist es kein schönes Programm, 
das ist eine ganz wichtige Grundvoraussetzung für gutes Programmieren


ach ja, und 150 Zeilen und mehr ohne Kommentare durchzuackern macht auch keinen Spaß, was ist denn jeweils der Ziel des Codes?
alle 20 Zeilen bei jedem größeren Block eine kleine Erklärung als Kommentar schadet doch nicht,
ich sollte wohl wirklich versuchen meinen Code zu finden, paar Elemente verschieben braucht eigentlich nicht so viel an Logik


----------



## MK234 (17. Okt 2011)

Sorry,
das der Code so schlecht lesbar ist, ist mir bei der ganzen Fehlersucherei gar nicht mehr aufgefallen.
Das Programm ist aber sehr sehr lange, weil noch viele andere Funktionen drinstecken und noch
reingesteckt werden sollen..


Ich werde an dem Programm bestimmt noch viele viele Kürzungen vornehmen müssen. Doch habe ich 
diese Programmteile bewußt so gelassen, weil ich dadurch gehofft habe, evtl. den Fehler leichter
ausfindig zu machen.

Ich habe die Codeabschnitte jetzt mehr auskommentiert. Ich hoffe sie sind jetzt besser lesbar.



```
//hier werden die zu verschiebenden Elemente gelb gekennzeichnet
         if(model.getVerschKenn()) {
            
             //hier werden alle ausgewählten Rechtecke gelb gekennzeichnet
             for(int i=0; i < model.Trans_Array.size(); i++) {
                 if(x >= model.Trans_Array.get(i).trans_x_kor && 
                         x <= model.Trans_Array.get(i).trans_x_kor+groesseWidth &&
                         y >= model.Trans_Array.get(i).trans_y_kor && 
                         y <= model.Trans_Array.get(i).trans_y_kor+groesseHeight) { 
                    model.Trans_Array.get(i).versch_kenn = true;  
                    
                    
                 }   
             }
             //hier werden alle Kreise gelb gekennzeichnet
             for(int j=0; j < model.Stellen_Array.size(); j++) {
                 if(x >= model.Stellen_Array.get(j).stelle_x_kor && x 
                         <= model.Stellen_Array.get(j).stelle_x_kor+groesseWidth &&
                         y >= model.Stellen_Array.get(j).stelle_y_kor && 
                         y <= model.Stellen_Array.get(j).stelle_y_kor+groesseHeight) {
                     model.Stellen_Array.get(j).versch_kenn = true;                 
                 }
             }
             repaint();
         }
```



```
//In diesem Abschnitt wird nach dem Rechteck bzw. Kreis gesucht auf welchen mit der
         //Maus gepresst wurde, wird das entsprechende Objekt gefunden, wird dieses in einem
         //neuen Array gespeichert. Alle anderen gelben Objekte werden ebenfalls in diesem Array
         //gespeichert unter Angabe des jeweiligen Abstands zum gepressten Objekt
         if(model.getMehrVerschieben()) {       
             //hier wird der Array in welchem alle Rechtecke gespeichert sind durchlaufen und überprüft
             //ob mit der Maus auf ein gelbes Rechteck gepresst wurde (MousePressed      
             //nicht MouseClicked)
             for(int i=0; i < model.Trans_Array.size(); i++) {
                 if(x >= model.Trans_Array.get(i).trans_x_kor && 
                         x <= model.Trans_Array.get(i).trans_x_kor+groesseWidth &&
                         y >= model.Trans_Array.get(i).trans_y_kor && 
                         y <= model.Trans_Array.get(i).trans_y_kor+groesseHeight &&
                         model.Trans_Array.get(i).versch_kenn) {                    
                    
                     //wenn tatsächlich auf ein gelbes Rechteck geklickt wurde, wird der Offset            
                     //berechnet                    
                     xOffset = x - model.Trans_Array.get(i).trans_x_kor;                    
                     yOffset = y - model.Trans_Array.get(i).trans_y_kor;                
                                        
                     schiebtTransition = true;
                     schiebtStelle = false;

                     //das mit der Maus gepresste Rechteck wird in einem weiteren Array gepeichert
                     //i = Index in welchem sich das Rechteck im model.Trans_Array befindet
                     //1 = Typ, also das es ein Rechteck ist eine 2 wäre ein Kreis
                    // dei beiden Nullen bedeuten jeweils das der Abstand zu x und y Null ist
                     model.VerschElem_Array.add(new VerschiebenElemente(i, 1, 0, 0));  

                    //die restlichen gelben markierten Rechtecke werden ebenfalls in den
                   // Array übertragen, wobei der unter zahl1 und zahl2 jeweils der x und y-Abstand
                   //zwischen dem gepressten Rechteck und dem jeweils
                   //anderen gelben Rechteck berechnet wird 
                    for(int q=0; q < model.Trans_Array.size(); q++) {
                         if(q == i) {
                             //do nothing
                         } else if(model.Trans_Array.get(q).versch_kenn) {
                             int zahl1 = model.Trans_Array.get(merke).trans_x_kor -
                                     model.Trans_Array.get(q).trans_x_kor;
                             int zahl2 = model.Trans_Array.get(merke).trans_y_kor -
                                     model.Trans_Array.get(q).trans_y_kor;
                             
                             model.VerschElem_Array.add(new VerschiebenElemente(q, 1, zahl1, zahl2));                           
                         }
                     }

                   //hier wird der Array in welchem sich die Kreise befinden,  nach
                   //nach gelben Kreisen durchsucht und diese werden auch in den
                   //Array gespeichert
                    for(int q=0; q < model.Stellen_Array.size(); q++) {
                        if(model.Stellen_Array.get(q).versch_kenn) {
                             int zahl1 = model.Trans_Array.get(merke).trans_x_kor -
                                     model.Stellen_Array.get(q).stelle_x_kor;
                             int zahl2 = model.Trans_Array.get(merke).trans_y_kor -
                                     model.Stellen_Array.get(q).stelle_y_kor;
                             model.VerschElem_Array.add(new VerschiebenElemente(q, 2, zahl1, zahl2));
                         }
                     }
                 }  
             }

             //hier wird der Array mit den Kreisen durchsucht, ob evtl. auf einen gelben Kreis
             //gedrückt wurde,......Vorgehensweise wie oben beim pressen auf ein gelbes Rechteck
             for(int i=0; i < model.Stellen_Array.size(); i++) {
                 if(x >= model.Stellen_Array.get(i).stelle_x_kor && 
                         x <= model.Stellen_Array.get(i).stelle_x_kor+groesseWidth &&
                         y >= model.Stellen_Array.get(i).stelle_y_kor && 
                         y <= model.Stellen_Array.get(i).stelle_y_kor+groesseHeight&&
                         model.Stellen_Array.get(i).versch_kenn) {
                     
                     //wenn tatsächlich auf einen gelben Kreis gedrückt wurde, wird der Offset            
                     //berechnet 
                     xOffset =  x - model.Stellen_Array.get(i).stelle_x_kor;
                     yOffset =  y - model.Stellen_Array.get(i).stelle_y_kor;
                     merke = i;
                     schiebtTransition = false;
                     schiebtStelle = true;
                     model.VerschElem_Array.add(new VerschiebenElemente(merke, 2, 0, 0));
                     for(int q=0; q < model.Stellen_Array.size(); q++) {
                         if(q == i) {
                             //do nothing
                         } else if(model.Stellen_Array.get(q).versch_kenn) {
                             int zahl1 = model.Stellen_Array.get(merke).stelle_x_kor -
                                     model.Stellen_Array.get(q).stelle_x_kor;
                             int zahl2 = model.Stellen_Array.get(merke).stelle_y_kor -
                                     model.Stellen_Array.get(q).stelle_y_kor;
                             model.VerschElem_Array.add(new VerschiebenElemente(q, 2, zahl1, zahl2));
                         }
                     }
                    for(int q=0; q < model.Trans_Array.size(); q++) {
                     if(model.Trans_Array.get(q).versch_kenn) {
                         int zahl1 = model.Stellen_Array.get(merke).stelle_x_kor -
                                 model.Trans_Array.get(q).trans_x_kor;
                         int zahl2 = model.Stellen_Array.get(merke).stelle_y_kor -
                                 model.Trans_Array.get(q).trans_y_kor;
                         
                         model.VerschElem_Array.add(new VerschiebenElemente(q, 1, zahl1, zahl2));                           
                     }
                 }
                 }
             }  
             
             //repaint in MouseDragged
         }
```




```
} else if (model.getMehrVerschieben()) {    		      		  
    		
    		  //Array mit allen gelben Objekten wird durchsucht
    		  for(int p=0; p < model.VerschElem_Array.size(); p++) {
    			  
    			  //z_trans, v_trans.....sind LinkedLists in welchem die Pfeile zwischengespeichert werden
    			  //welche zu den gelb markierten Objekten hin- oder wegführen
    			  z_trans.clear(); //Pfeile hin zum Rechteck
  	    		  v_trans.clear(); //Pfeile weg vom Rechteck
  	    		  z_stelle.clear(); //Pfeile in zum Kreis
        		  v_stelle.clear();    //Pfeile weg vom Kreis
  	    		  
    			  //hier wird getestet ob es ein Rechteck ist	
    			  if(model.VerschElem_Array.get(p).Sorte == 1) {
    				  //wenn ja wird der jeweilige x- und y-Abstand zum gepressten
    				  //Objekt ausgelesen
    				  int abstandX = model.VerschElem_Array.get(p).AbstandX;
  	 				  int abstandY = model.VerschElem_Array.get(p).AbstandY;
  	 				
  	 				  //hier wird das Rechteck mit den neuen Koordinaten erneuert
  	 				  model.Trans_Array.set(model.VerschElem_Array.get(p).Pos,
  							 (new Transition( 
  									  e.getX()- abstandX - xOffset, 
  							 e.getY() - abstandY - yOffset, 
  							 model.Trans_Array.get(p).trans_laenge, 
  							 model.Trans_Array.get(p).trans_breite, 
  							 model.Trans_Array.get(p).trans_color, 
  							 model.Trans_Array.get(p).text,
  							 model.Trans_Array.get(p).trans_aktiv,
  							 true)));   
  	 				
  	 				
  	 				 //hier wird der Array mit den Pfeilen durchsucht,
  	 				  //ob bestimmte Pfeile zum Rechteck hin- oder wegführen, wenn ja
  	 				  //dann werden diese jeweils getrennt zwischengespeichert
  	 				for(int r=0; r < model.Verb_Array.size(); r++) {
  	 					if(model.Verb_Array.get(r).von_Trans && 
  	 							model.Verb_Array.get(r).zu_Stelle &&
  	 							model.Verb_Array.get(r).index_Trans == p) {
  	 						v_trans.add(r);
  	 					} else if(model.Verb_Array.get(r).zu_Trans &&
  	 							model.Verb_Array.get(r).von_Stelle &&
  	 							model.Verb_Array.get(r).index_Trans == p ) {
  	 						z_trans.add(r);
  	 					}
  	 				}
  	 				
  	 				//Pfeile welche vom Rechteck wegführen werden verlängert/verkürzt
  	 				if(v_trans.size() > 0) {
  	 					for(int s=0; s < v_trans.size(); s++) {
  	 						int in = v_trans.get(s);
  	 						model.Verb_Array.set(in, new Verbindung(
  	 								model.Trans_Array.get(p).trans_x_kor+(groesseWidth/2),
  	 								model.Trans_Array.get(p).trans_y_kor+(groesseHeight/2),
  	 								model.Verb_Array.get(in).xEnde,
  	 								model.Verb_Array.get(in).yEnde,
  	 								model.Verb_Array.get(in).color,
  	 								model.Verb_Array.get(in).von_Trans,
  	 								model.Verb_Array.get(in).von_Stelle,
  	 								model.Verb_Array.get(in).zu_Trans,
  	 								model.Verb_Array.get(in).zu_Stelle,
  	 								model.Verb_Array.get(in).index_Trans,
  	 								model.Verb_Array.get(in).index_Stelle));
  	 					 repaint();
  	 					} 	 					
  	 				}
  	 				//Pfeile welche zum Rechteck hinführen werden verlängert/verkürzt
  	 				if(z_trans.size() > 0) {
  	 					for(int s=0; s < z_trans.size(); s++) {
  	 						int in = z_trans.get(s);
  	 						model.Verb_Array.set(in, new Verbindung(
  	 								model.Verb_Array.get(in).xAnfang,
  	 								model.Verb_Array.get(in).yAnfang,
  	 								model.Trans_Array.get(p).trans_x_kor+(groesseWidth/2),
  	 								model.Trans_Array.get(p).trans_y_kor+(groesseHeight/2),
  	 								model.Verb_Array.get(in).color,
  	 								model.Verb_Array.get(in).von_Trans,
  	 								model.Verb_Array.get(in).von_Stelle,
  	 								model.Verb_Array.get(in).zu_Trans,
  	 								model.Verb_Array.get(in).zu_Stelle,
  	 								model.Verb_Array.get(in).index_Trans,
  	 								model.Verb_Array.get(in).index_Stelle));
  	 					 repaint();  	 					
  	 					} 	 					
  	 				}  	 				
//  	    		  z_trans.clear();
//  	    		  v_trans.clear();
  	 				
  	 				
  	 				//hier wird getestet ob es ein Kreis ist.....Ablauf ist in etwa derselbe
  	 				//wie bei den Rechtecken oben
    			  }	else if(model.VerschElem_Array.get(p).Sorte == 2) {
    				  int abstandX = model.VerschElem_Array.get(p).AbstandX;
    	 				int abstandY = model.VerschElem_Array.get(p).AbstandY;
    	 				model.Stellen_Array.set(model.VerschElem_Array.get(p).Pos,
    	 						new Stelle(e.getX() - abstandX - xOffset,
    	 								e.getY() - abstandY - yOffset,
    	 								model.Stellen_Array.get(p).stelle_laenge,
    	 								model.Stellen_Array.get(p).stelle_breite,
    	 								model.Stellen_Array.get(p).anzahl_Markierungen,
    	 								model.Stellen_Array.get(p).stelle_color,
    	 								model.Stellen_Array.get(p).tex,
    	 								true));
    	 				
    	 				for(int r=0; r < model.Verb_Array.size();r++) {
    	 					if(model.Verb_Array.get(r).von_Stelle && 
      	 							model.Verb_Array.get(r).zu_Trans &&
      	 							model.Verb_Array.get(r).index_Stelle == p) {    	 						
      	 						v_stelle.add(r);
      	 					} else if(model.Verb_Array.get(r).zu_Stelle &&
      	 							model.Verb_Array.get(r).von_Trans &&
      	 							model.Verb_Array.get(r).index_Stelle == p) {
      	 						z_stelle.add(r);
      	 					}
    	 				}
    	 				//Pfeile welche vom Kreis wegführen werden verlängert/verkürzt
    	 				if(v_stelle.size() > 0) {
      	 					for(int s=0; s < v_stelle.size(); s++) {
      	 						int in = v_stelle.get(s);
      	 						model.Verb_Array.set(in, new Verbindung(
      	 								model.Stellen_Array.get(p).stelle_x_kor+(groesseWidth/2),
      	 								model.Stellen_Array.get(p).stelle_y_kor+(groesseHeight/2),
      	 								model.Verb_Array.get(in).xEnde,
      	 								model.Verb_Array.get(in).yEnde,
      	 								model.Verb_Array.get(in).color,
      	 								model.Verb_Array.get(in).von_Trans,
      	 								model.Verb_Array.get(in).von_Stelle,
      	 								model.Verb_Array.get(in).zu_Trans,
      	 								model.Verb_Array.get(in).zu_Stelle,
      	 								model.Verb_Array.get(in).index_Trans,
      	 								model.Verb_Array.get(in).index_Stelle));
      	 					 repaint();
      	 					}      	 					
      	 				}
    	 				//Pfeile welche zum Kreis hinführen werden verlängert/verkürzt
    	 				if(z_stelle.size() > 0) {
      	 					for(int s=0; s < z_stelle.size(); s++) {
      	 						int in = z_stelle.get(s);
      	 						model.Verb_Array.set(in, new Verbindung(
      	 								model.Verb_Array.get(in).xAnfang,
      	 								model.Verb_Array.get(in).yAnfang,
      	 								model.Stellen_Array.get(p).stelle_x_kor+(groesseWidth/2),
      	 								model.Stellen_Array.get(p).stelle_y_kor+(groesseHeight/2),
      	 								model.Verb_Array.get(in).color,
      	 								model.Verb_Array.get(in).von_Trans,
      	 								model.Verb_Array.get(in).von_Stelle,
      	 								model.Verb_Array.get(in).zu_Trans,
      	 								model.Verb_Array.get(in).zu_Stelle,
      	 								model.Verb_Array.get(in).index_Trans,
      	 								model.Verb_Array.get(in).index_Stelle));
      	 					 repaint();
      	 					} 
      	 				}
    			  }
			  
	 		  }   		 
    	  }    	  
    	  repaint();
      }
```


----------



## SlaterB (17. Okt 2011)

ohne Ausführbarkeit finde ich das leider weiterhin ziemlich untestbar,
als weitere anzusprechende Vereinfachung aus den Kommentaren:
verzichte erstmal auf Pfeilspitzen oder ähnliche Spezialitäten/ Unterscheidungen, male ganz einfache Linien

hier mein Code von vor 5 Jahren, radikal zusammengekürzt, 
ging mal um Darstellung von Bündnissen verschiedener Fraktionen 

AO ist ein Objekt, als Rechteck dargestellt, kann mit anderen AO verknüpft sein, 
eine AOList ist eine Liste von AOs, auch Basisklasse von AO um die Bündnisse aufzunehmen, eher ungünstig

P2 ist ein einfacher Punkt

BuendPanel macht die Hauptarbeit, malt die AO, reagiert auf Mausereignisse,
ich speichere hier das Graphics-Objekt für die Zeit eines paintComponent-Aufrufs in einem Attribut um nicht überall
als Parameter herumzureichen, nicht ideal

zeichneAOL() ist eine recht übersichtliche Zeichenmethode, erst alle Kanten malen, 
dann die Kanten des aktuell markierten, weil besondere Farbe, 
dann alle AO malen, spätere AO in der Liste werden im Moment über vorderen gemalt

zeichneAO() malt ein Element, zeichneKanten() malt die Kanten eines AO,
beim aktuell markierten/ bewegten wird bisschen anders gemalt

sonst gibts noch bisschen Code für MouseListener zur Markierung/ Positionsänderung



```
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Buend {

	public static void main(String[] args) {
		AO a = new AO("Test A");
		AO b = new AO("Test B");
		AO c = new AO("Test C");
		AO d = new AO("Test D");
		AO e = new AO("Test E");
		a.addB(b);
		a.addB(c);
		a.addB(d);
		a.addB(e);
		AOList aoL = new AOList(300);
		aoL.addAO(a);
		aoL.addAO(b);
		aoL.addAO(c);
		aoL.addAO(d);
		aoL.addAO(e);

		JFrame f = new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setSize(700, 500);

		BuendPanel bP = new BuendPanel(aoL);
		f.add(bP);
		f.setVisible(true);
	}

}

class BuendPanel extends JPanel implements MouseListener, MouseMotionListener {

	private boolean move = false;

	private AOList aOL = new AOList(300);

	private AO marked;
	private Graphics g;

	public BuendPanel(AOList newAOL) {
		aOL = newAOL;
		addMouseListener(this);
		addMouseMotionListener(this);
	}

	private void zeichneAOL() {
		g.setColor(Color.BLUE);
		AO ao = null;
		for (int i = 0; i < aOL.size(); i++) {
			ao = aOL.getAO(i);
			zeichneKanten(ao);
		}
		if (marked != null) {
			zeichneKanten(marked);
		}
		for (int i = 0; i < aOL.size(); i++) {
			ao = aOL.getAO(i);
			zeichneAO(ao);
		}
	}

	private void zeichneKanten(AO ao) {
		g.setColor(Color.BLACK);
		if (ao == marked) {
			g.setColor(Color.WHITE);
		}
		AO b = null;
		for (int i = 0; i < ao.size(); i++) {
			b = ao.getAO(i);
			if (aOL.contains(b)) {
				linie(ao.pos.x, ao.pos.y, b.pos.x, b.pos.y);
			}
		}
	}

	private void zeichneAO(AO ao) {
		int olx = ao.getOLX();
		int oly = ao.getOLY();
		g.setColor(ao.color);

		kasten(olx, oly, ao.length, AO.HEIGHT, true);
		g.setColor(Color.YELLOW);
		schreibe(ao.getName(), olx + 5, oly + 5 + 20);
		if (marked == ao) {
			g.setColor(Color.GREEN);
		} else if ((marked != null) && (marked.contains(ao))) {
			if (ao.size() == 1) {
				g.setColor(Color.RED);
			} else {
				g.setColor(Color.WHITE);
			}
		} else {
			g.setColor(Color.DARK_GRAY);
		}
		kasten(olx, oly, ao.length, AO.HEIGHT, false);
	}

	protected void kasten(int x, int y, int breite, int hoehe, boolean fuellen) {
		if (fuellen) {
			g.fillRect(x, y, breite, hoehe);
		} else {
			g.drawRect(x, y, breite, hoehe);
		}
	}

	protected void schreibe(String st, int x, int y) {
		g.drawString(st, x, y);
	}

	protected void linie(int ax, int ay, int ex, int ey) {
		g.drawLine(ax, ay, ex, ey);
	}

	public void paintComponent(Graphics gr) {
		super.paintComponent(gr);
		g = gr;
		zeichneAOL();
	}

	public void mouseClicked(MouseEvent e) {
	}

	public void mousePressed(MouseEvent e) {
		if (marked != null) {
			move = true;
			pressX = e.getX();
			pressY = e.getY();
		}
	}

	int pressX;
	int pressY;

	public void mouseReleased(MouseEvent e) {
		move = false;
	}

	public void mouseEntered(MouseEvent e) {
	}

	public void mouseExited(MouseEvent e) {
	}

	public void mouseDragged(MouseEvent e) {
		if (!move)
			return;
		marked.pos.x += e.getX() - pressX;
		marked.pos.y += e.getY() - pressY;
		pressX = e.getX();
		pressY = e.getY();
		repaint();
	}

	public void mouseMoved(MouseEvent e) {
		if (move)
			return;
		AO neu = aOL.getMarked(e.getX(), e.getY());
		if (marked != neu) {
			marked = neu;
			repaint();
		}
	}

}

class AOList {

	private ArrayList aoList;

	public AOList(int anz) {
		aoList = new ArrayList(anz);
	}

	public AO getAO(int i) {
		return (AO) aoList.get(i);
	}

	public int size() {
		return aoList.size();
	}

	public void addAO(AO newAO) {
		aoList.add(newAO);
	}

	public AO getMarked(int x, int y) {
		for (int i = size() - 1; i >= 0; i--) {
			if (getAO(i).isMarked(x, y)) {
				return getAO(i);
			}
		}
		return null;
	}

	public boolean contains(AO ao) {
		return aoList.contains(ao);
	}

}

class AO extends AOList {

	public static int HEIGHT = 30;
	public P2 pos;
	public int length = 50;
	private String name;
	public Color color = Color.GRAY;

	private static Random r = new Random();

	public AO(String newName) {
		super(10);
		name = newName;
		pos = new P2(200 + r.nextInt(280), 100 + r.nextInt(260));
	}

	public void addB(AO newAO) {
		if (!contains(newAO)) {
			addAO(newAO);
			newAO.addAO((AO) this);
		}
	}

	public String getName() {
		return name;
	}

	public boolean isMarked(int x, int y) {
		return (length > 0) && (x >= getOLX()) && (x <= getOLX() + length)
				&& (y >= getOLY()) && (y <= getOLY() + HEIGHT);
	}

	public int getOLX() {
		return pos.x - length / 2;
	}

	public int getOLY() {
		return pos.y - HEIGHT / 2;
	}

	public String toString() {
		return getName();
	}
}

class P2 {

	public int x;
	public int y;

	public P2(int x, int y) {
		this.x = x;
		this.y = y;
	}
}
```


----------



## MK234 (18. Okt 2011)

die Funktion mit dem parallelen Verschieben klappt jetzt, habe ein paar Variablen falsch zugeordnet.

Vielen Dank SlaterB für Dein Programm und Dein Bemühen, obwohl das Nachvollziehen meines Programms
so wie ich es jetzt sehe ein ziemliches Unding war. Werde mir in Zukunft hinter die Ohren schreiben, daß
ich mein Programm besser auskommentiere bzw. so kurz wie möglich gestalte, bevor ich es anderen
zum Prüfen gebe.


----------

