Demande d'aide sur les Handlers

Bonjour a tous,

Je cherche a écouter une JFrame, dans le but de récupérer sa position actuelle. J'ai pas mal regardé la Doc Java de Sun, mais rien de vraiment concluant.

Évidemment je n'ai pas accès aux codes sources de la JFrame, sinon ce serait bien plus simple :mouarf:

Des idées?

Effectivement c'est qq chose qui manque et ca ne m'a jamais traverse l'esprit. Mais je dirais un truc du genre peut faire l'affaire mais il peut y avoir plus simple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
import java.util.EventListener;
 
/**
 * Interface that defines a class interrested into listening windows location event.
 * @author Fabrice Bouyé (fabriceb@spc.int)
 */
public interface WindowLocationListener extends EventListener {
    /**
     * This method is called whenever a window is moved accros the sceeen.
     * @param event The window location event.
     */
    public void windowMoved(WindowLocationEvent event);
}

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
import java.awt.AWTEvent;
import java.awt.Point;
import java.awt.Window;
 
/**
 * Class used for broadcasting windows location events.
 * @author Fabrice Bouyé (fabriceb@spc.int)
 */
public class WindowLocationEvent extends AWTEvent {
 
    /**
     * The last location of the window.
     */
    private Point location;
 
    /**
     * Creates a new instance.
     * @param source The source window.
     * @param location The last location of the window.
     */
    public WindowLocationEvent(Window source, Point location) {
        super(source, 0);
        this.location = location;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public Window getSource() {
        return (Window) super.getSource();
    }
 
    /**
     * Gets the last known location of the window.
     */
    public Point getLocation() {
        return location;
    }
}

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
 
import java.awt.Point;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.swing.Timer;
import javax.swing.event.EventListenerList;
 
/**
 * A tracker that broadcasts a window's location change.
 * <br/>This class uses a Swing <code>Timer</code> internally and will listen to the window's state to start and stop this timer.
 * @author Fabrice Bouyé (fabriceb@spc.int)
 */
public class WindowLocationTracker {
 
    /**
     * Default timer delay.
     */
    public static final int DEFAULT_DELAY = 75;
    /**
     * Inner listener.
     */
    private InnerListener innerListener = new InnerListener();
    /**
     * The target <code>Window</code>.
     */
    private Window window;
    /**
     * The timer.
     */
    private Timer timer;
    /**
     * Timer refresh delay.
     */
    private int delay = DEFAULT_DELAY;
 
    /**
     * Creates a new instance.
     * @param window The target <code>Window</code>.
     * @throws IllegalArgumentException If <code>window</code> is <code>null</code>.
     */
    public WindowLocationTracker(Window window) throws IllegalArgumentException {
        if (window == null) {
            throw new IllegalArgumentException("Window cannot be null.");
        }
        this.window = window;
        timer = new Timer(delay, innerListener);
        timer.setRepeats(true);
        window.addWindowListener(innerListener);
    }
 
    /**
     * Start the tracker.
     */
    public void start() {
        if (!timer.isRunning()) {
            timer.start();
        }
    }
 
    /**
     * Stop the tracker.
     */
    public void stop() {
        if (timer.isRunning()) {
            timer.stop();
        }
    }
    /**
     * The last known screen location of the window.
     */
    private Point lastLocation = null;
    /**
     * List that hold listeners.
     */
    private EventListenerList listenerList = new EventListenerList();
 
    /**
     * Registers a listener interrested into listener for window location event.
     * @param listener The listener.
     */
    public void addWindowLocationListener(WindowLocationListener listener) {
        listenerList.add(WindowLocationListener.class, listener);
    }
 
    /**
     * Unregisters a listener interrested into listener for window location event.
     * @param listener The listener.
     */
    public void removeWindowLocationListener(WindowLocationListener listener) {
        listenerList.remove(WindowLocationListener.class, listener);
    }
 
    /**
     * Fires a window location event to registered listeners.
     */
    protected void fireWindowMoved() {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying those that are interested in this event
        WindowLocationEvent event = null;
        for (int i = listeners.length - 2; i >= 0; i -= 2) {
            if (listeners[i] == WindowLocationListener.class) {
                // Lazily create the event:
                if (event == null) {
                    event = new WindowLocationEvent(window, lastLocation);
                }
                ((WindowLocationListener) listeners[i + 1]).windowMoved(event);
            }
        }
    }
 
    /**
     * Inner listener class.
     * @author Fabrice Bouyé (fabriceb@spc.int)
     */
    private class InnerListener implements WindowListener, ActionListener {
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowActivated(WindowEvent e) {
            start();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowClosed(WindowEvent e) {
            stop();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowClosing(WindowEvent e) {
            stop();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowDeactivated(WindowEvent e) {
            stop();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowDeiconified(WindowEvent e) {
            start();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowIconified(WindowEvent e) {
            stop();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void windowOpened(WindowEvent e) {
            start();
        }
 
        /**
         * {@inheritDoc}
         */
        @Override
        public void actionPerformed(ActionEvent e) {
            Point location = window.getLocationOnScreen();
            if (lastLocation == null || !lastLocation.equals(location)) {
                lastLocation = location;
                fireWindowMoved();
            }
        }
    }
}

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
 
import java.awt.Point;
import java.awt.Window;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
 
/**
 * Test the <code>WindowLocationTracker</code>.
 * @author Fabrice Bouyé (fabriceb@spc.int)
 */
public class WindowLocationTrackerTest {
 
    public static void main(String... args) {
        SwingUtilities.invokeLater(new Runnable() {
 
            /**
             * {@inheritDoc}
             */
            @Override
            public void run() {
                JFrame frame = new JFrame("Test");
                frame.setName("Test");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                WindowLocationTracker tracker = new WindowLocationTracker(frame);
                tracker.addWindowLocationListener(new WindowLocationListener() {
 
                    /**
                     * {@inheritDoc}
                     */
                    @Override
                    public void windowMoved(WindowLocationEvent event) {
                        Window window = event.getSource();
                        Point location = event.getLocation();
                        System.out.printf("Window \"%s\" at location \"%s\".", window.getName(), location).println();
                    }
                });
                frame.setVisible(true);
            }
        });
    }
}

A voir aussi si ca ne vaut pas le coup d'ajouter un support de WindowFocusListener a l'interieur du WindowLocationTracker.

C'est facilement adaptable pour tracker la taille de la fenetre egalement (quoi que pour ce dernier c'est un peu inutile car c'est beaucoup plus simple de mettre un ComponentListener sur son contenu ou son contentpane).

Et pour finir :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class MyFrame extends JFrame {
  private WindowLocationTracker tracker = new WindowLocationTracker(this);
 
 [...]
 
 public void addWindowLocationListener(WindowLocationListener listener) {
   tracker.addWindowLocationListener(listener);
 }
 
 public void removeWindowLocationListener(WindowLocationListener listener) {
   tracker.removeWindowLocationListener(listener);
 }
}

Ah oui et sinon le code source de JFrame, JWindow, Frame et Window est disponible dans le fichier src.zip qui est present a la racine du JDK... cependant il est possible que le deplacement des fenetres soit tout simplement gerer par l'OS et non pas par Java.

Citation:

Je cherche a écouter une JFrame, dans le but de récupérer sa position

Il existe le ComponentListener qui normalement permet de faire cela via la méthode componentMoved.

Et la moi je fais /DOH.... :mouarf: trop de JavaFX tue le Java...:oops:

J'essaye vos solutions et je vous tiens informés:aie: :bug:

J'avoue nager un peu dans ce code, pouvez-vous m'éclairer?

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
 
import com.moyosoft.connector.com.ComponentObjectModelException;
import com.moyosoft.connector.exception.LibraryNotFoundException;
import com.moyosoft.connector.ms.outlook.Outlook;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
 
public class MyFrame extends JFrame implements ComponentListener {
 
    public static void main(String args[]) throws Exception {
        MyFrame app =  new MyFrame();
    }
 
    public MyFrame() {
        this.addComponentListener(this);
        try {
            // App java a écouter
            Outlook outlookApplication = new Outlook();
        } catch (ComponentObjectModelException ex) {
            //
        } catch (LibraryNotFoundException ex) {
            //
        }
    }
 
    public void componentResized(ComponentEvent evt) {
    }
 
    public void componentHidden(ComponentEvent evt) {
    }
 
    public void componentShown(ComponentEvent evt) {
        System.out.println("montre toi ->" + evt.getComponent());
    }
 
    public void componentMoved(ComponentEvent evt) {
    }
}

Pour "écouter" le mouvement de ta fenêtre c'est componentMoved qu'il faut utiliser.

Voici un exemple qui fonctionne.

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
package pkg;
 
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
 
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
 
public class TestFrame extends JFrame {
	private static final long serialVersionUID = 1L;
 
 
	public TestFrame() {
		super("TestFrame");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setSize(320, 240);
 
		addComponentListener(new ComponentListener() {
			@Override
			public void componentMoved(ComponentEvent event) {
				System.out.println("componentMoved: "+ event.getComponent().getLocation());
			}
 
			@Override
			public void componentHidden(ComponentEvent event) {
				System.out.println("componentHidden");
			}
 
			@Override
			public void componentResized(ComponentEvent event) {
				System.out.println("componentResized");
			}
 
			@Override
			public void componentShown(ComponentEvent event) {
				System.out.println("componentShown");
			}
		});
	}
 
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
 
			@Override
			public void run() {
				JFrame frame = new TestFrame();
				frame.setLocationRelativeTo(null);
				frame.setVisible(true);
			}
		});
	}
}

Un grand merci :ccool: