JLabel verschieben

[ash34]

Hallo,

ich würde gern ein Element einer Klasse verschieben, die von Jlabel erbt.
Die Klasse nennt sich Box.
Sobald ich auf einen Button (APPEND) drücke, soll ein MouseMotionListener zu einer ganz bestimmten Box hinzugefügt werden, sodass diese verschiebbar ist.
Mein Code kompilliert ohne Fehler, aber die Box lässt sich leider nicht verschieben.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
 
/*
 * ActionListener belonging to the append Button
 */
 
public class AppendListener implements ActionListener {
 
    @Override
    public void actionPerformed(ActionEvent arg0) {
        
        String text = GUI.textField.getText();
        int currentBox = BoxListener.currentBox; 
        // index of clicked box in the boxpanel
        
        if(GUI.gridp.getGridList().size() == BoxPanel.boxChosen){
            
            GUI.gridp.addGrid(GUI.boxp.getBoxList().get(currentBox));
            
            GUI.boxp.getBoxList().remove(currentBox);
            GUI.boxp.paint();
        
        }
        
        int size = GUI.gridp.getGridList().size();
        int x = 300;
        int y = 20;
        int width = GUI.gridp.getByteSize(GUI.sliderValue);
        
        GUI.gridp.getGridList().get(size - 1).setValue(text);
        GUI.gridp.getGridList().get(size - 1).setWidth(width);
        GUI.gridp.getGridList().get(size - 1).setLocation(x,y);
        GUI.gridp.getGridList().get(size - 1).addMouseMotionListener(new MouseMotionListener() {
            
            @Override
            public void mouseMoved(MouseEvent arg0) {}
            
            @Override
            public void mouseDragged(MouseEvent arg0) {
                GUI.gridp.getGridList().get(BoxPanel.boxChosen).setLocation(arg0.getX(), arg0.getY());
            }
        });
        
        GUI.gridp.paint();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Stroke;
 
import javax.swing.JLabel;
 
/**
 * 
 * @author florian  
 * class for creating the boxes
 * 
 */
 
public class Box extends JLabel {
 
      /**
     * 
     */
    
    private static final long serialVersionUID = -2804169159814223929L;
    private int x, y;
    private int width, height;
    private Stroke stroke = new BasicStroke(1); // setting thickness of the strokes
    private Rectangle bounds;
    private Color color;
    private String boxValue = ""; // modifiable text (like 192.168.2.1...)
      
      /**
       * Constructor
       * @param width
       * @param height
       * @param x
       * @param y
       */
      
    public Box(int width, int height, int x, int y, Color color) {
          this.width = width;
          this.height = height;
          this.color = color;
          this.setLocation(x, y);
          this.setFont(new Font("Dialog", 0, 10));
      }
      
     public void setLocation(int x, int y) {
          this.x = x;
          this.y = y;
          bounds = new Rectangle(x, y, width, height);
      }
      
     public Rectangle getBounds() {
          return bounds;
      }
      
     public Color getColor(Box box){
          return this.color;
      }
      
     public int getWidth(){
          return this.width;
      }
 
     public int getHeight(){
          return this.height;
      }
      
     public int getX(){
          return this.x;
      }
      
     public int getY(){
          return this.y;
      }
      
     public void setWidth(int width){
          this.width = width;
      }
      
     public void setColor(Color color){
          this.color = color;
      }      
      
     public void setValue(String str){
          this.boxValue = str;
      }
      
     public void paintComponent(Graphics g) {
          Graphics2D g2 = (Graphics2D)g.create();
       
          g2.setStroke(stroke);
          g2.setColor(color);
          g2.fillRect(x, y, width, height);
          g2.setColor(Color.BLACK);
          g2.drawRect(x, y, width, height);
          g.setFont(this.getFont());
          g.drawString(this.getText(), x+2, y+11);
          g.drawString(boxValue, x+20, y+35);
          g2.dispose();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
 
import javax.swing.JPanel;
 
/**
 * 
 * BoxPanel contains all boxes
 * @author florian
 *
 */
 
public class BoxPanel extends JPanel {
 
    private static final long serialVersionUID = 1L;
        private List<Box> boxList;
        private List<Box> gridList;
        private Color color;
        static final int boxChosen = 23;
        
        private final int standardWidth = 90;
        private final int standardGridWidth = 45;
        private final int standardHeight = 40;
        private final int fourBitWidth = standardGridWidth;
        private final int eightBitWidth = (int) (fourBitWidth*2);
        private final int sixteenBitWidth = (int) (eightBitWidth*2);
        private final int twentyfourBitWidth = sixteenBitWidth + eightBitWidth;
        private final int thirtytwoBitWidth = (int) (sixteenBitWidth*2);
        private final int fourtyeightBitWidth = thirtytwoBitWidth + sixteenBitWidth;
        
        private     Box prae;
        private     Box destEth;
        private     Box sourAddr;
        private     Box lengType;
        private     Box vers;
        private     Box hdrLen;
        private     Box tos;
        
            /**
             * Constructor
             * 
             */
            
    public BoxPanel() {
            
        this.setPreferredSize(new Dimension(1300, 100));
        boxList = new ArrayList<Box>();
        gridList = new ArrayList<Box>();
        
    }
                   
    public void fillBoxPanel(){
            
        String[] boxText = {"Checksum","Code","Data","HdrLen","Hdr Checksum",
                            "FOS","Identifier","Total Length",
                            "Length/Type","Options","Pad","Packet ID",
                            "Protocol","Präambel","SeqNumr",
                            "SourAddr(Eth)","SourAddr(IP)","TarAddr(Eth)",
                            "TarAddr(IP)","TOS","TTL","Type","Vers"};
        
            
        int n = 0;                      // horizontal gap between boxes
        int m = 40;                     // vertical gap between boxes
        int rowCount = 12;              // amount of boxes in one row 
        int x = 45;                     // vertical gap for the first box (related to (0,0))
        int y = 1;                      // horizontal gap for the first box (related to (0,0))
        int width = standardWidth;      // width of a normal box
        int height = standardHeight;    // height of a normal box
        this.color = Color.WHITE;       // color of a normal box
 
//              creating boxes, setting color and text to each of the boxes
                
        for(int i=0; i<boxText.length; i++){
                    
            if(i < rowCount){                   
                Box box = new Box(width, height, x+n, y, color);
                box.setText(boxText[i]);
                box.setColor(color);
                this.addBox(box);
                n = width*(i+1);
                }
                    
            if(i == rowCount){
                n=0;
                Box box = new Box(width, height, x+n, y+m, color);
                box.setText(boxText[i]);
                box.setColor(color);
                this.addBox(box);
                n = width*(i-11);
                }
                    
            if(i > rowCount){
                Box box = new Box(width, height, x+n, y+m, color);
                box.setText(boxText[i]);
                box.setColor(color);
                this.addBox(box);
                n = width*(i-11);
                }
        }
    }
            
    public void fillGrid(){
                
        Color invisibleColor = GUI.frameColor;
        int x = 30;
        int y = 80;
        
        prae = new Box(fourBitWidth, standardHeight,
                            x, y, invisibleColor); 
        destEth = new Box(fourtyeightBitWidth, standardHeight, 
                            x+prae.getWidth(), y, invisibleColor);
        sourAddr = new Box(fourtyeightBitWidth, standardHeight, 
                            destEth.getX()+destEth.getWidth(), y, invisibleColor);
        lengType = new Box(eightBitWidth, standardHeight, 
                            sourAddr.getX()+sourAddr.getWidth(), y, invisibleColor);
        vers = new Box(fourBitWidth, standardHeight, 
                            x, y+standardHeight+2, invisibleColor);
        hdrLen = new Box(fourBitWidth, standardHeight, 
                            x+vers.getWidth(), y+standardHeight+2, invisibleColor);
        tos = new Box(eightBitWidth, standardHeight, 
                            hdrLen.getX()+hdrLen.getWidth(), y+standardHeight+2, invisibleColor);
        Box totLen = new Box(sixteenBitWidth, standardHeight, 
                            tos.getX()+tos.getWidth(), y+standardHeight+2, invisibleColor);
        Box packetID = new Box(sixteenBitWidth, standardHeight, 
                            x, y+standardHeight*2+2, invisibleColor);
        Box fos = new Box(sixteenBitWidth, standardHeight,
                            packetID.getX()+packetID.getWidth(), y+standardHeight*2+2, invisibleColor);
        Box ttl = new Box(eightBitWidth, standardHeight,
                            x, y+standardHeight*3+2, invisibleColor);
        Box protocol = new Box(eightBitWidth, standardHeight,
                            ttl.getX()+ttl.getWidth(), y+standardHeight*3+2, invisibleColor);
        Box hdrCheck = new Box(sixteenBitWidth, standardHeight,
                            protocol.getX()+protocol.getWidth(), y+standardHeight*3+2, invisibleColor);
        Box sourceAddr = new Box(thirtytwoBitWidth, standardHeight,
                            x, y+standardHeight*4+2, invisibleColor);
        Box tarAddr = new Box(thirtytwoBitWidth, standardHeight,
                            x, y+standardHeight*5+2, invisibleColor);
        Box options = new Box(twentyfourBitWidth, standardHeight,
                            x, y+standardHeight*6+2, invisibleColor);
        Box padding = new Box(eightBitWidth, standardHeight,
                            options.getX()+options.getWidth(), y+standardHeight*6+2, invisibleColor);
        Box type = new Box(eightBitWidth, standardHeight,
                            x, y+standardHeight*7+4, invisibleColor);
        Box code = new Box(eightBitWidth, standardHeight,
                            type.getX()+type.getWidth(), y+standardHeight*7+4, invisibleColor);
        Box checkSum = new Box(sixteenBitWidth, standardHeight,
                            code.getX()+code.getWidth(), y+standardHeight*7+4, invisibleColor);
        Box identifier = new Box(sixteenBitWidth, standardHeight,
                            x, y+standardHeight*8+4, invisibleColor);
        Box seqNumber = new Box(sixteenBitWidth, standardHeight,
                            identifier.getX()+identifier.getWidth(), y+standardHeight*8+4, invisibleColor);
        Box data = new Box(thirtytwoBitWidth, standardHeight,
                x, y+standardHeight*9+4, invisibleColor);
        
        
        this.gridList.add(prae);
        this.gridList.add(destEth);
        this.gridList.add(sourAddr);
        this.gridList.add(lengType);
        this.gridList.add(vers);
        this.gridList.add(hdrLen);
        this.gridList.add(tos);
        this.gridList.add(totLen);
        this.gridList.add(packetID);
        this.gridList.add(fos);
        this.gridList.add(ttl);
        this.gridList.add(protocol);
        this.gridList.add(hdrCheck);
        this.gridList.add(sourceAddr);
        this.gridList.add(tarAddr);
        this.gridList.add(options);
        this.gridList.add(padding);
        this.gridList.add(type);
        this.gridList.add(code);
        this.gridList.add(checkSum);
        this.gridList.add(identifier);
        this.gridList.add(seqNumber);
        this.gridList.add(data);
    }
    
    public int getByteSize(int n){
        int result = fourBitWidth;
        
        switch(n){
            case 4:     result = fourBitWidth;
                        break;
            case 8:     result = eightBitWidth;
                        break;
            case 16:    result = sixteenBitWidth;
                        break;
            case 24:    result = twentyfourBitWidth;
                        break;
            case 32:    result = thirtytwoBitWidth;
                        break;
            case 48:    result = fourtyeightBitWidth;
                        break;
        }
        return result;
    }
            
    public void paint(){
        this.repaint();
    }
            
    public void addGrid(Box box){
        this.gridList.add(box);
    }
            
    public void addBox(Box box) {
        this.boxList.add(box);
    }
            
    public List<Box> getBoxList(){
        return this.boxList;
    }
            
    public List<Box> getGridList(){
        return this.gridList;
    }
            
    public void paintComponent(Graphics g) {
       super.paintComponent(g);
         for (Box box: boxList)
           box.paintComponent(g);
         for(Box box: gridList)
            box.paintComponent(g);
    }
}

[SlaterB]

schade dass du kein vollständiges Programm gepostet hast, bis zur Anzeige habe ich es geschafft,
aber mit den Listenern wäre es zuviel Arbeit/ zu unklar ob überhaupt etwas rauskommt, was du in etwa hast,


Vorsicht beim Überschreiben von Methoden, setLocation(int,int) hat JLabel schon und wird von Swing vielleicht allgemein benötigt,
aber wie ich dann gesehen habe, sind die Labels ja gar nicht normal in der GUI eingebunden, es wird nur deren paintComponent
manuell aufgerufen

warum addest du nun bei diesen nicht-Komponenten Listener? da sie nicht in der GUI drin sind bringt das gar nichts,
außerdem hättest du sie wenn dann so gebaut dass sie die ganze Fläche beherrschen und nur in ihrer paint ihre Zeichnung auf einen Teil davon beschränken,
wie sollte ein Mausklick automatisch darauf zurückgerechnet werden? maximal könnte eine Komponente anvisiert werden,
die für die ganze Fläche aktiv ist

es gibts zwei Wege:
1. so wie du ein Panel mit einzelnen paint-Befehlen gestalten, ob durch Unterobjekte oder eine Schleife nur mit draw-Aufruf,
macht für Swing keinen Unterschied,
in diesem Fall musst du einen Listener auf das Panel an sich setzen und anhand der Mausposition selber ausrechnen,
welche Komponente da zuletzt gezeichnet wurde, die Liste durchgehen und die x/y-Positionen vergleichen

2. echte Komponenten auf dem Panel verteilen, die jeweils bei ihren 0,0-Ursprung zeichnen,
aber im übergeordneten Panel durch Layout oder absolute Positionierung an die richtigen Orte verteilt sind,
in diesem Fall kann jeder Komponente ein Listener zugeordnet werden und Swing schafft korrekte Aufrufe nach Mausklick

[bERt0r]

Was ist eigentlich mit dieser Box Klasse? Die stammt doch aus einem Tutorial wie man eine paintComponent überschreibt oder? Ich würd aber mal sagen, das ist ein perfektes Exemplar von Komposition > Vererbung weil was anderes als ein Label mit Border ist das nicht.

[kaetzacoatl]

Zitat:

	Null layout is evil!

In dem fall wärs ganz praktisch!
Mit setBounds könnte man die
Position dann genau bestimmen.

[bERt0r]

Hehe, für alles gibts Layoutmanager: http://www.java-forum.org/awt-swing-...tml#post918513

[kaetzacoatl]

Offtopic:

Ich arbeite IMMER mit
null Layout und hatte
noch nie Probleme,
aber wenn man es
halt nicht mag, dann
mag man es halt nicht.

[bERt0r]

Das ist schön für dich, leider ist der Aufwand den ein null Layout braucht gleich groß wie sich seinen eigenen Layoutmanager zu schreiben. Aber warum einfach wenns kompliziert geht...

[ash34]

Danke für all die Antworten. Ich hab jetzt alles ein bisschen umeschrieben und den MouseMotionListener über Bord geworfen

Ich setzte die Boxen einfach direkt (Auswahl über den Index der Rahmen).

Zitat:

	Was ist eigentlich mit dieser Box Klasse? Die stammt doch aus einem Tutorial wie man eine paintComponent überschreibt oder? Ich würd aber mal sagen, das ist ein perfektes Exemplar von Komposition > Vererbung weil was anderes als ein Label mit Border ist das nicht.

Ich habe die Klasse auf der Suche nach einem passenden Objekt für meine Box gefunden. Die stammt auf jeden Fall hier aus dem Forum.

[bERt0r]

Und ich hab dir glaub ich schon x mal geschrieben dass du das WESENTLICH einfacher mit einem normalen JLabel hinkriegst, dem du einen LineBorder verpasst. Das sind dann 2 Zeilen Code anstatt einer eigenen Klasse.
Anstatt überall die PaintComponent funktionen zu überschreiben solltest du dir mal ein Tutorial durchlesen wie man in Swing GUIs baut. Du machst das viel zu umständlich und das ist auch der grund warum dein MouseMotionListener nicht funktioniert. How to Use Labels (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)

[ash34]

Das geht bei mir leider nicht so einfach.
Jede Box muss sich auf ein Gitter setzen lassen. Dafür muss überprüft werden, ob dort schon eine Box liegt. Wenn ja, welche Box liegt dort. Außerdem muss ich einen Titel für jede Box setzen und im Nachhinein einen Inhalt.
Da wäre die Verwendung von Jlabels nicht viel einfacher (ich kann den Konstruktor nicht nach meinen Wünschen anpassen, etc.).
Würde ich einfach nur ein paar Boxen verschieben wollen, hätte ich nie eine eigene Klasse dafür genutzt.

Mein eigentliches Problem war, dass ich nicht wusste, wie ich für Elemente auf meinem bzw. in meinem jeweiligen JPanel den Listener richtig benutze.

Über die Variante 2 von SlaterB war das aber kein Problem mehr.