# Polygon bewegt sich nach mehreren aufrufen immer schneller



## silvoo (20. Nov 2007)

Hallo,

habe folgens Problem.

Habe ein Tool geschrieben, dass Rechteck- und Polygonzeichnung als Funktion hat.
Die vorhandenen Objekte werden für Rechtecke und Polygone in zwei XML-Dateien festgehalten. Wenn das Tool neugestartet wird, werden, wenn vorhanden, die Objekte(Rechtecke oder Polygone) angezeigt. Wenn eine der beiden Funktionen aufgerufen wird, wird die andere auf null gesetzt. Beim nächsten Aufruf wird dann ein neues Objekt der Funktion erstellt. Soweit ist auch alles in Ordnung.

Beim ersten Aufruf der beiden Funktionen läuft alles wie gewünscht. Nur bei der Polygon-Funktion habe das folgende Problem.

Die Bewegungen der Polygone über die Maus werden nach mehrmaligem switchen der Funktionen immer schneller, was ich mir nicht erklären kann. Wie oben erwähnt, wird die deaktivierte Funktion immer auf null gesetzt und dann bei Bedarf ein neues Objekt erstellt. Deswegen müsste es nicht an den Startwerten liegen. 


```
public void mouseMoved(MouseEvent e) {                                
   if (zF.isPolyMarkierung()) {
                
         // Positionsaenderung
            if(ZeichenFlaeche.showedPolyElements.size() != 0) {
             for(int i = 0; i < ZeichenFlaeche.showedPolyElements.size(); i++) {
                p = ZeichenFlaeche.showedPolyElements.get(i);       
                orgP = ZeichenFlaeche.orgPolyElements.get(i);
                                          
                // Polyon verschieben
                if (p.contains(e.getPoint())
                    && zeigeDynLinie == false ) {                       
                                                  
                   zF.setCursor(new Cursor(13));
                  
                   Point point = e.getPoint();
                   start = point;               
                                             
                   bewegePolygon = true;
                   veraendern = true;
                                         
                   break;
                } else {
                    bewegePolygon = false;
                }
          }
       }
   }
}

public void mouseDragged(MouseEvent e) {
       
    if (zF.isPolyMarkierung()) {
                               
      // Polygon verschieben
      if (bewegePolygon && e.isMetaDown() == false) {                                                                     
        Point end = e.getPoint();
               
        int x = end.x - start.x;
        int y = end.y - start.y;
               
        p.translate(x, y);
                                  
        p.invalidate();
                                  
        start = end;       
                                  
   }
```

Bitte um Hilfe,

silvoo


----------



## Marco13 (20. Nov 2007)

Nee, bitte nicht sowas...
zF.setCursor(new Cursor(13)); 

Ansonsten...


```
int x = end.x - start.x;
int y = end.y - start.y;

System.out.println("start "+start);
System.out.println("end "+end);
System.out.println("move "+x+" "+y);

p.translate(x, y);
```
hilft vielleicht...


----------



## Guest (22. Nov 2007)

Hi,

ich möchte, dass beim Skalieren die Objekte nicht mehr als eine Minimumgröße runterskaliert werden. Habe den folgen Code für Polygonskalierung : 


```
else if (scale) {
 Rectangle oldRect = p.getRect();
 zF.setPolyRect(p.getBounds());
 Rectangle newRect = zF.getPolyRect();
 scaleStartPoint = e.getPoint();
                                  
 currentRectWidth = (int) (zF.getPolyRect().getMaxX()-10);
 currentRectHeight = (int) zF.getPolyRect().getMaxY()-10;
 currentRectX = zF.getPolyRect().x+10;
 currentRectY = zF.getPolyRect().y+10;
                        
 zF.setZeigePolyRect(true);
                                  
 // Skalieren von der oberen Ecke links
 if (aendereObenLinks
     && e.isMetaDown() == false) {                   
                                     
  int x = zF.getPolyRect().x - (last_x + e.getX());
  int y = zF.getPolyRect().y - (last_y + e.getY());
                           
  if (!(scaleStartPoint.x > currentRectWidth)
     && !(scaleStartPoint.y > currentRectHeight)) {
       
    newRect.setRect(last_x + e.getX(), last_y + e.getY(),
                  zF.getPolyRect().width + x,
                  zF.getPolyRect().height + y);
  }
  neuePolyKoorZuweisen(oldRect, newRect);

  p.invalidate();
  saveScaledPoly = true;
}
```

Das Polygon soll in x und/oder y Richtung nicht weniger als 10 px runterskaliert werden, aber größer schon..

Der o.a. Code Code tut folgendes :

Wenn ich Skalieren möchte, werden von dem jeweiligen Polygon ein Copy erstellt, auf dieses die Skalierung ausgeführt wird. Wenn die Maustaste losgelassen wird, wird die Copy dem Originalpolygon zugewiesen.

Wenn die Minimumgrenze beim Skalieren unterschritten wird, wir das Polygon in der Ursprungsgröße angezeigt, wobei es eigentlich einfach in der Minimumgröße zu sehen sein sollte. Sobald man es aber vom minimum aus wieder größer skaliert, ohne die Maus loszulassen, nimmt das Polygon die richtige Skalierungsgröße wieder an. 



Was ist verkehrt  am Code??


----------



## Guest (22. Nov 2007)

Die Lösung des ersten Problems war das Entfernen der Listener. Beim neuen Aufruf werden sie wieder hinzugefügt.


----------

