Déplacement d'un label accompagné d'un JTextField

Version imprimable

Bonsoir,
Je suis un nouveau menbre de ce forum. Ce qui m'a poussé à m'inscrire est dû à un probléme qui traine depuis fort longtemps.
J'ai créée une fenétre avec un label "nom" suivi d'une zone de saisie en premier lieu. Je veux déplacer le "nom" suivi d'une zone de saisie, en enfonçant le bouton gauche de la souris. Ca fait des semaines que je fais des recherches sur cela à travers les forums et les tuto mais j'ai du mal à trouver les bonnes solutions.

Voici ici un exemple :
Code:

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 import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JComboBox; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.JTextField; public class Test extends JFrame { String[] genre = {" Masculin ", " Feminin "}; public Test(){ this.setTitle("Deplacement"); this.setSize(500, 300); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setLocationRelativeTo(null); this.getContentPane().setLayout(new FlowLayout()); add(new JLabel("Nom:")); add(new JTextField(10)); add(new JLabel("Prénom:")); add(new JTextField(12)); add(new JLabel(" Sexe:")); add(new JComboBox(genre)); this.setVisible(true); } public static void main(String[] main){ Test fen = new Test(); } }

Salut,

Bienvenue sur le forum Developpez.

Pour déplacer un composant, il faut déjà définir ce qu'on entend par déplacer. S'il s'agit de modifier ses coordonnées de manière continue (on pourrait aussi entendre par déplacer, changer l'ordre d'affichage des différents couples label/field), il faut d'abord se passer de Layout Manager, parce que celui-ci décide justement du placement (et de la taille) des composants, donc ça s'oppose au fait qu'on puisse déplacer les composants. Sans Layout Manager, il faudra placer et dimensionner tous les composants soi-même, en appelant les méthodes setLocation() et setSize().

Ensuite, pour réagir à la souris on utilise un MouseListener (voir documentation Oracle ou FAQ Developpez). Pour détecter le déplacement de la souris pendant que le bouton est enfoncé, on utilisera un MouseMotionListener. On peut utiliser un MouseAdapter qui est une classe qui combine les 2 comportements.

Le principe est le suivant :

lorsque le bouton gauche est enfoncé, on enregistre le fait qu'on déplace un bouton
lorsqu'on déplace la souris et que le bouton est enfoncé (drag en anglait/Java), on modifie les coordonnées des composants en fonction du déplacement
lorsque le bouton est relaché, on désenregistre le fait qu'on déplace un composant

A noter que lorsqu'un composant reçoit un évenement souris, la position de la souris est relative au composant : il est donc nécessaire de mémoriser cette position relative pour que lorsqu'on déplace le composant, on prenne bien en compte ce décalage.

Voici un exemple de principe :

Code:

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
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
 
public class Test extends JFrame {
	private String[] genre = { " Masculin ", " Feminin " };
 
	public Test() {
		this.setTitle("Deplacement");
		this.setSize(500, 300);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocationRelativeTo(null);
		this.getContentPane().setLayout(null); // on n'utilise pas de Layout Manager
 
		// on créé 2 tableaux pour stocker les composants, parce qu'on a besoin de leurs références pour les déplacer
		JLabel[] labels = new JLabel[3];
		JComponent[] fields = new JComponent[3];
 
		labels[0] = new JLabel("Nom:");
		fields[0] = new JTextField(10);
 
		labels[1] = new JLabel("Prénom:");
		fields[1] = new JTextField(10);
 
		labels[2] = new JLabel("Sexe:");
		fields[2] = new JComboBox<String>(genre);
 
		// le fait qu'on ait des tableaux permet de gérer les composants en boucle
		for(int i=0; i<3; i++) {
			add(labels[i]);
			add(fields[i]);
			// on place et dimensionne les composants parce qu'il n'y a pas de Layout Manager qui le fait
			labels[i].setSize(labels[i].getPreferredSize());
			fields[i].setSize(fields[i].getPreferredSize());
			if (i>0){
				labels[i].setLocation(fields[i-1].getX()+fields[i-1].getWidth(), 0);
			}
			fields[i].setLocation(labels[i].getX()+labels[i].getWidth(), 0);
 
			// on créé le MouseAdapter
			MouseAdapter mouseAdapter = new MoveMouseAdapter(labels[i], fields[i]);
 
			labels[i].addMouseListener(mouseAdapter); // on enregistre le MouseAdapter comme MouseListener sur le label (pour détecter l'enfoncement et le relachement du bouton
			labels[i].addMouseMotionListener(mouseAdapter); // on enregistre le MouseAdapter comme MouseMotionListener sur le label (pour détecter le mouvement de la souris)
		}
 
		this.setVisible(true);
	}
 
	public static void main(String[] main) {
		 new Test();
	}
 
	private static class MoveMouseAdapter extends MouseAdapter {
		private boolean moved;
		private int dx;
		private int dy;
		private JLabel label;
		private JComponent field;
 
		public MoveMouseAdapter(JLabel label, JComponent field) {
			this.label=label;
			this.field=field;
		}
 
		@Override
		public void mousePressed(MouseEvent e) {
			if ( e.getButton()==MouseEvent.BUTTON1 ) { // sur le bouton gauche
				startMove(e);
			}
		}
 
		private void startMove(MouseEvent e) {
			moved=true; 
			// on mémorise la position relative de la souris par rapport au composant
			dx=e.getX(); 
			dy=e.getY();
 
		}
 
		@Override
		public void mouseDragged(MouseEvent e) {
			if (moved) {
				doMove(e);
			}
		}
 
		private void doMove(MouseEvent e) {
			// on déplace
			// la nouvelle position est l'ancienne plus la différence entre la position actuelle de la souris et la position relative de la souris au démarrage du déplacement
			label.setLocation(label.getX() + e.getX() - dx, label.getY() + e.getY() - dy);
			field.setLocation(label.getX()+label.getWidth(), label.getY());
		}
 
		@Override
		public void mouseReleased(MouseEvent e) {
			if ( e.getButton()==MouseEvent.BUTTON1 && moved) {
				stopMove();
			}
		}
 
		private void stopMove() {
			moved=false;
		}
 
	}
 
}

08/10/2014, 19h38
AmadouTidiane

déplacement d'une label accompagné d'un JTextField

Vous m'avez rendu un grand service.Je ne peux que vous remercier.Merci donc!!!
Mais un probléme surgit .Le premier est que je veux éviter de superposer plusieurs composants à la fois.La façon dont je veux le résoudre est que lorsqu'on déplace un composant en enfonçant le bouton guauche de la souris et si des possiblités de superposition se présentent que le composant déplacé retourne à sa positon initial en relachant le bouton guauche de la souris.
08/10/2014, 19h59
joel.drigo

Pour faire retourner le composant à sa position initiale, il suffit de la mémoriser dans une variable au moment où le bouton est enfoncé (dans startMove()). Ensuite, pendant le déplacement, tu peux détecter si le composant déplacé est en intersection avec l'un des deux autres, (de base, une simple comparaison de coordonnées et de tailles (un if), mais il existe aussi des méthodes dans la classe java.awt.Rectangle qui permet de tester une intersection plus facilement).

Par contre, je ne suis pas sur de comprendre le fonctionnement : tu voudrais que si, pendant le déplacement d'un composant (label+field), il se superpose à un autre, alors, lorsqu'on relève le bouton de la souris, alors le composant revient à sa position initiale c'est ça ? Dans ce cas, il suffit d'un flag booléen : on le met à true dès qu'il y a intersection détectée, et dans le stopMove, on teste ce booléen pour savoir si on doit remettre les composants en position initiale (celle qu'on a mémoriser dans startMove()). Et pendant qu'on le déplace, et qu'il se superpose, on peut continuer à le déplacer, ou alors il bloque au bord (dans ce cas, il suffit de ne pas faire doMove() si l'intersection est vérifiée).
09/10/2014, 04h42
AmadouTidiane

déplacement d'une label accompagné d'un JTextField

Bonsoir
Je crois bien que c'est l'idée<< tu voudrais que si, pendant le déplacement d'un composant (label+field), il se superpose à un autre, alors, lorsqu'on relève le bouton de la souris, alors le composant revient à sa position initiale c'est ça ?>> Oui c'est ça . Je veux utiliser les rectangles pour détecter les intersections.Mais je n'ai pas trop de connaissances sur les rectangles.Grace au rectangles je peux les pivoter aussi . Si on travaillez au niveau des rectangle ça sera mieux.Si vous avez des tutos intéréssants à me proposer ils sont les biens venus.Pour l'instant travaillons surr le probléme de superposition des classes en utilisant les rectangles.Voici une classe qui regroupe plusieurs choses sur les rectangles au niveau de ce site (en Anglais) http://developer.classpath.org/doc/j...source.html.Vu la traduction il y'a beaucoups de chose intéréssant mais je ne comprends pas au niveau du code.Merci beaucoups pour le soutien et les clarificationss apportées.
09/10/2014, 08h51
joel.drigo
La classe Rectangle représente un rectangle horizontal/vertical, mais ne pourra pas représenter un rectangle "pivoté" (Mais il est possible de le transformer par rotation en une forme (java.awt.Shape) qui représente un rectangle "pivoté", mais je n'en vois pas trop pourquoi tu voudrais le faire dans le cadre de ce que tu cherches à faire).

Tu trouveras la documentation officielle Oracle sur cette classe ici (pour Java 8).

Ensuite, un composant SWING est de forme rectangulaire à la base : même si son dessin est d'une autre forme (un bouton rond par exemple), il s'agira d'un dessin à l'intérieur d'un rectangle. La méthode getBounds() permet de récupérer ce rectangle, qui correspond en fait à la surface occupée par le rectangle, en position relative à son parent — le composant dans lequel il se trouve). Les 2 composants label et field étant juxtaposés, on peut connaitre le rectangle correspondant aux deux en faisant l'union des bounds de chacun, comme ça (si label est la variable pour le label et field celle pour le champ) :
Code:

1 2 3 public static Rectangle getBounds(JLabel label, JComponent field) { return label.getBounds().union(field.getBounds()); }
Ensuite la méthode intersects de Rectangle te permettra de tester si 2 rectangles sont en intersection.

Dans mon exemple, j'ai utilisé 2 tableaux pour stocker les labels et fields. Tu peux facilement faire une boucle pour créer un nouveau tableau de Rectangle qui contient les bounds des couples de composants (dans startMove, pour avoir les bounds au moment de début de déplacement, en ignorant bien sûr l'index du couple traité par le MoveMouseAdapter) : pour ça il te faudra passer les tableaux au constructeur de MoveMouseAdapter, et l'index du couple traité, pour les stocker en variable membre de cette classe.

Ensuite, pour tester, il suffira de parcourir ce tableau de Rectangle, et si le rectangle du couple label/field déplacé est en intersection avec l'un des rectangles du tableau, alors il se superpose à un autre couple de composants...
11/10/2014, 00h49
AmadouTidiane

déplacement d'une label accompagné d'un JTextField

Vous ne croyez pas qu'un exemple peut m'aider à comprendre ce que vous voulez dire .Méme si la procédure est bien claire par ce que tous cela c'est du nouveau.Un exemple veut mieux.Merci
13/10/2014, 01h38
AmadouTidiane

déplacement d'une label accompagné d'un JTextField

Salut
Je solicite vraiment votre aide en me donnant un exemple pour mieux voir les rectangles.

Code:

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
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
 
public class Test extends JFrame {
	private String[] genre = { " Masculin ", " Feminin " };
 
	public Test() {
		this.setTitle("Deplacement");
		this.setSize(500, 300);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocationRelativeTo(null);
		this.getContentPane().setLayout(null); // on n'utilise pas de Layout Manager
 
		// on créé 2 tableaux pour stocker les composants, parce qu'on a besoin de leurs références pour les déplacer
		JLabel[] labels = new JLabel[3];
		JComponent[] fields = new JComponent[3];
 
		labels[0] = new JLabel("Nom:");
		fields[0] = new JTextField(10);
 
		labels[1] = new JLabel("Prénom:");
		fields[1] = new JTextField(10);
 
		labels[2] = new JLabel("Sexe:");
		fields[2] = new JComboBox<String>(genre);
 
		// le fait qu'on ait des tableaux permet de gérer les composants en boucle
		for(int i=0; i<3; i++) {
			add(labels[i]);
			add(fields[i]);
			// on place et dimensionne les composants parce qu'il n'y a pas de Layout Manager qui le fait
			labels[i].setSize(labels[i].getPreferredSize());
			fields[i].setSize(fields[i].getPreferredSize());
			if (i>0){
				labels[i].setLocation(fields[i-1].getX()+fields[i-1].getWidth(), 0);
			}
			fields[i].setLocation(labels[i].getX()+labels[i].getWidth(), 0);
 
			// on créé le MouseAdapter
			MouseAdapter mouseAdapter = new MoveMouseAdapter(i, labels, fields);
 
			labels[i].addMouseListener(mouseAdapter); // on enregistre le MouseAdapter comme MouseListener sur le label (pour détecter l'enfoncement et le relachement du bouton
			labels[i].addMouseMotionListener(mouseAdapter); // on enregistre le MouseAdapter comme MouseMotionListener sur le label (pour détecter le mouvement de la souris)
		}
 
		this.setVisible(true);
	}
 
	public static void main(String[] main) {
		 new Test();
	}
 
	private static class MoveMouseAdapter extends MouseAdapter {
		private boolean moved; // lorsque true, indique que le déplacement est en cours
		private int dx; // décalage initial entre la position x de la souris et la position x du label déplacé
		private int dy; // décalage initial entre la position y de la souris et la position y du label déplacé
		private final JLabel label; // le label déplacé
		private final JComponent field; // champ déplacé
		private final int index; // numéro d'index du label déplacé
		private final JLabel[] labels; // tableau des labels
		private final JComponent[] fields; // tableau des champs
		private Rectangle[] bounds; // contient les dimensions des label/fields autres que celui déplacé au démarrage du déplacement 
		private int startLocationX; // position x du label déplacé au démarrage (permettant de revenir à la position initiale)
		private int startLocationY; // position y du label déplacé au démarrage (permettant de revenir à la position initiale)
		private boolean overlayed; // lorsque true, indique qu'il y a eu superposition
 
		public MoveMouseAdapter(int index, JLabel[] labels, JComponent[] fields) {
			this.index=index;
			this.label=labels[index];
			this.field=fields[index];
			this.labels=labels;
			this.fields=fields;
		}
 
		@Override
		public void mousePressed(MouseEvent e) {
			if ( e.getButton()==MouseEvent.BUTTON1 ) { // sur le bouton gauche
				startMove(e);
			}
		}
 
		private void startMove(MouseEvent e) {
			moved=true; 
			// on mémorise la position relative de la souris par rapport au composant
			dx=e.getX(); 
			dy=e.getY();
			// on mémorise les bounds de tous les autres composants
                        bounds = getOtherComponentsBounds();
                       // on mémorise la position au démarrage
                      startLocationX=label.getX();
                      startLocationY=label.getY();
		}
 
		/*
		 * Mémorise les bounds de tous les couples label/fields autre que celui déplacé
		 */
		private Rectangle[] getOtherComponentsBounds() {
			Rectangle[] bounds = new Rectangle[labels.length-1];
			for(int i=0, j=0; i<labels.length; i++) {
				if ( i!=index ) {
					bounds[j]=getBounds(labels[i],fields[i]);
					j++;
				}
			}
			return bounds;
		}
 
		/*
		 * Calcule les bounds d'un couple label/field
		 */
		private Rectangle getBounds(JLabel label, JComponent field) {
			return label.getBounds().union(field.getBounds());
		}
 
		@Override
		public void mouseDragged(MouseEvent e) {
			if (moved) {
				// on simule le mouvement pour déterminer s'il peut y avoir superposition
				Rectangle newBounds = prepareMove(e);
				//s'il n'y a pas superposition on déplacer
				if ( !overlays(newBounds) ) {
					doMove(newBounds);
				}
				else {
					// sinon on mémorise qu'on a eu superposition
					overlayed=true;
				}
			}
		}
 
		/**
                 * Simule le mouvement en le stockant dans un Rectangle
                 */
		private Rectangle prepareMove(MouseEvent e) {
			Rectangle bounds = getBounds(label, field);
			bounds.setLocation(label.getX() + e.getX() - dx, label.getY() + e.getY() - dy);
			return bounds;
		}
 
		/*
		 * Teste si le rectangle passé en argument se superpose à l'un des rectangles mémorisés dans bounds[]
		 */
		private boolean overlays(Rectangle movedBounds) {
			for(Rectangle rbound : bounds) {
				if ( rbound.intersects(movedBounds) ) {
					return true;
				}
			}
			return false;
		}
 
		/*
		 * Applique le mouvement stocké dans le tableau
		 */
		private void doMove(Rectangle newBounds) {
			// on déplace
			// la nouvelle position est l'ancienne plus la différence entre la position actuelle de la souris et la position relative de la souris au démarrage du déplacement
			setLocation(newBounds.x, newBounds.y);
		}
 
		/*
		 * Mets un couple label/field en position passée en argument
		 */
		private void setLocation(int x, int y) {
			label.setLocation(x, y);
			field.setLocation(label.getX()+label.getWidth(), label.getY());
		}
 
		@Override
		public void mouseReleased(MouseEvent e) {
			if ( e.getButton()==MouseEvent.BUTTON1 && moved) {
				stopMove();
			}
		}
 
		private void stopMove() {
			moved=false;
			if ( overlayed ) {
				// remet le couple label/field à la position mémorisée au démarrage si on a eu superposition
				setLocation(startLocationX, startLocationY);
				overlayed=false;
			}
		}
 
	}
 
}

28/12/2014, 01h48
kassadiallo

Bonsoir
J'étais trés heureux quand j'ai vu cette discution car moi aussi j'avais ce meme probléme et ça faisait des semaines que je cherchais cela.Dans mon cas la maniere dont je doit déplacer les composants est la suite
-Lorsque j'enfoncce la souris pour déplacer le composant je fais apparaitre l'ombre de cette composant .le composant reste sur place mais je déplace l'ombre.
-Apres quand je relache la souris l'ombre du composant disparait et le composant prend la place de l'ombre en ce positionnant là ou est relaché la souris
ce que je veux reléve du graphisme et j'aimérai que vous m'aidez.

Salut,

Utiliser le glasspane d'une JFrame est une solution pour faire ce genre de chose.

Un exemple de principe :

Code:

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
public class ShadowExemple  {
 
	private static final int SIZE = 300;
	private static final Color SHADOW_COLOR = Color.DARK_GRAY;
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(()-> new ShadowExemple());
	}
 
	public ShadowExemple() {
		JFrame frame = new JFrame("Exemple");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		Container panel = createPanel();
		frame.setContentPane(panel);
 
		ShadowMoveAdapter mouseAdapter = new ShadowMoveAdapter(frame, panel, SHADOW_COLOR);
 
		panel.addMouseListener(mouseAdapter);
		panel.addMouseMotionListener(mouseAdapter);
 
		frame.setSize(SIZE, SIZE);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
 
	private Container createPanel() {
		JPanel panel = new JPanel();
		panel.setLayout(null);
		Random random = new Random(System.currentTimeMillis());
		for(int i=10; i>0; i--) {
			JLabel label = new JLabel("label "+i);
			panel.add(label);
			Dimension labelSize = label.getPreferredSize();
			label.setLocation(random.nextInt(SIZE-labelSize.width), random.nextInt(SIZE-labelSize.height));
			label.setSize(labelSize);
		}
		return panel;
	}
 
	private static class ShadowPane extends JPanel {
 
		private final Color shadowColor;
		private Rectangle rectangle;
 
		public ShadowPane(Color shadowColor) {
			setOpaque(false);
			this.shadowColor=shadowColor;
		}
 
		public void setShadow(Rectangle rectangle) {
			this.rectangle=rectangle;
		}
 
		@Override
		public void paint(Graphics g) {
			super.paint(g);
			if ( rectangle!=null ) {
				g.setColor(shadowColor);
				((Graphics2D)g).fill(rectangle);
			}
		}
 
	}
 
	private static class ShadowMoveAdapter extends MouseAdapter {
 
		private final Container panel;
		private final ShadowPane glassPane;
 
		private Component movedComponent;
		private Rectangle rectangle;
		private int x;
		private int y;
 
		public ShadowMoveAdapter(JFrame frame, Container panel, Color shadowColor) {
			this.panel=panel;
			this.glassPane = new ShadowPane(new Color( shadowColor.getRed(), shadowColor.getGreen(), shadowColor.getBlue(), 128));
			glassPane.setVisible(false);
			frame.setGlassPane(glassPane);
		}
 
		@Override
		public void mousePressed(MouseEvent e) {
			movedComponent = panel.getComponentAt(e.getX(), e.getY());
			if ( movedComponent!=null ) {
				if ( movedComponent==panel ) {
					movedComponent=null;
				}
				else {
					startMove(e.getPoint());
				}
			}
		}
 
		@Override
		public void mouseDragged(MouseEvent e) {
			if ( movedComponent!=null ) {
				doMove(e.getPoint());
			}
		}
 
		@Override
		public void mouseReleased(MouseEvent e) {
			if ( movedComponent!=null ) {
				stopMove();
			}
		}
 
		private void doMove(Point mouseLocation) {
			rectangle.setLocation(mouseLocation.x-x, mouseLocation.y-y);
			glassPane.repaint();
		}
 
		private void startMove(Point mouseLocation) {
			glassPane.setVisible(true);
			rectangle = movedComponent.getBounds();
			x = mouseLocation.x - rectangle.x;
			y = mouseLocation.y - rectangle.y;
			glassPane.setShadow(rectangle);
			glassPane.repaint();
		}
 
		private void stopMove() {
			glassPane.setShadow(null);
			glassPane.setVisible(false);
			movedComponent.setBounds(rectangle);
			movedComponent=null;
		}
 
	}
 
}