Discussion :

[CyaNnOrangehead]

Rien que ça !!!!

Après mon petit article sur le pattern Foncteur en java (ICI) il y a une idée qui me trotte dans la tête depuis quelques jours.
Le functional reactive programming, comment ça marche ? Et surtout, cela peu-t-il fonctionner en Java ?

Du coup, je me suis décidé à lancer mon petit IDE préféré et zou, j'ai tenté l'aventure. J'ai écrit ma petite librairie et voici comment l'utiliser :

Voici un exemple qui fait la chose suivante : Une évènement sur le mouvement et le click de la souris mais qui ce déclenchent que toutes les 250 milli secondes. Je veux également que cet évènement prenne fin au bout de 2 secondes. (rien que l'énoncé, avec les évènements traditionnels, ça fait pâlir).

Voici concrètement ce que cela donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter(new Function<Boolean, Arguments1<React>>() {
 
		@Override
		public Boolean invoke(Arguments1<React> arguments) {
			React r = arguments.getArgument1();
			return (r.getTimeElapsed() > 250L);
		}
	})
	.onReact(new Procedure<Arguments1<React>>() {
 
		@Override
		public void invoke(Arguments1<React> arguments) {
			MouseReact r = (MouseReact) arguments.getArgument1();
			log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
		}
	});
 
new React().once(2000L).onReact(new Procedure<Arguments1<React>>() {
 
	@Override
	public void invoke(Arguments1<React> arguments) {
                log("REACT until 2 seconds ");
		myReact.dispose();
	}
});

Voilà comment utiliser la dite librairie. Pas mal non ?
Il faut voir cela comme un map/filter/reduce, mais appliqué aux évènements et aux threads (ce qu'il y a dans la librairie en réalité), le tout architecturé sur des monades (encore un truc issu du fonctionnel).

Maintenant, j'aimerai vos avis sur la chose, vos idées.
Je suis en train de me demander si je ne ferai pas un article sur la FRP en java dans la même veine que sur les foncteurs....

Voilà, toute idée est la bienvenue.

[adiGuba]

Salut,


J'ai survolé l'article vite fait et cela a l'air très complet
J'essayerais de prendre le temps de m'y attarder un peu plus


Au passage ce type d'API vont sûrement fleurir avec Java 8 et les lambdas, qui permettront d'éviter toutes les lourdeurs des classes anonymes.

Le bout de code que tu donnes pourra s'utiliser comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter( (arguments) -> arguments.getArgument1().getTimeElapsed() > 250L )
	.onReact( (arguments) -> {
		MouseReact r = (MouseReact) arguments.getArgument1();
		log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
	});
 
 
new React().once(2000L).onReact( (arguments) -> {
	log("REACT until 2 seconds ");
	myReact.dispose();
});

De plus l'API standard adoptera un "map-filter-reduce" via l'API des Streams


a++

[CyaNnOrangehead]

Oui tout à fait adiGuba. Vivement le jdk8.
Seulement, d'après ce que j'ai compris, il n'est pas prêt de voir le jour.

Effectivement les lambdas simplifient grandement la lecture. Je pensais aussi créer des interface spécifiques qui éviteraient cette bataille avec les arguments.

En fait ce que je suis en train d'essayer de faire, en plus de fair joujou avec java, c'est de l'implémenter dans mon langage AL (www.algoid,net)
Si je parviens à écrir une librairie correcte en java, je pourrai la porter en AL facilement.
Quand je voie ce qu'offre un tel idiom de programmation, ça me démange de l'implémenter.... lol

J'ai vu que ça existait aussi en Scala et en c#. Je vais my pencher pour m'en inspirer dés que j'ai 5mn.

[adiGuba]

Oui tout à fait adiGuba. Vivement le jdk8.
Seulement, d'après ce que j'ai compris, il n'est pas prêt de voir le jour.

La "developer-preview" est déjà disponible depuis quelques temps... et la version finale est prévu pour mars 2014 soit dans moins de 6 mois


a++

[thierryler]

Ca a l'air pas mal ;-) je vais lire ça à tête reposée.

[CyaNnOrangehead]

J'ai encore ce vilain problème de cast :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
public void invoke(Arguments1<React> arguments) {
			MouseReact r = (MouseReact) arguments.getArgument1();

J'ai un sur type React, un sous type MouseReact.
React contient une liste de React qui m'oblige à caster le type en sortie....
Je ne sais pas encore comment solutioner ce problème. (aime pas les casts)

[tchize_]

Le bout de code que tu donnes pourra s'utiliser comme ceci :

Ha? Moi je verrais plutôt ceci dans la logique des lambdas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter( (it) -> it.getTimeElapsed() > 250L )
	.onReact( (r) -> {
		log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
	});
 
 
new React().once(2000L).onReact(it -> {
	log("REACT until 2 seconds ");
	myReact.dispose();
});

Ben oui, sa classse "Arguments" devient inutile ^^

[tchize_]

J'ai encore ce vilain problème de cast :

Tu ne pourra pas te passer du cast dans ce cas là, puisque Arguments se base sur des Reacts et, dans ton code, tu suppose que ce sont des MouseReact. Rien ne te le garantis du point de vue de la compilation.

[adiGuba]

Ha? Moi je verrais plutôt ceci dans la logique des lambdas:

Ben oui, sa classse "Arguments" devient inutile ^^

Le code que je donnais devrait fonctionner sans modification dans le code de son API
(c'est aussi une force des lambdas de pouvoir s'adapter aux codes existants)





@CyaNnOrangehead : Je n'ai pas trouvé le code de ta classe React, mais je suppose qu'il faut la paramétrer (un peu comme pour l'API Stream de Java 8 justement).

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface Predicate<T> {
	public boolean accept(T value);
}
 
interface Function<T> {
	public void invoke(T value);
}
 
class React<T> {
 
	public React<T> filter(Predicate<T> predicate) {
		...
	}
 
	public void onReact(Function<T> function) {
		...
	}
 
}

Et fait de chaque implémentation une version spécifique (MouseReact sera un React<MouseEvent> par exemple)


a++


a++

[CyaNnOrangehead]

Et fait de chaque implémentation une version spécifique (MouseReact sera un React<MouseEvent> par exemple)

Oui je pensais faire un truc dans ce genre.
J'ai un peu regardé hier soir, mais je n'ai pas eu le temps de tout faire, ce n'est qu'un premier jet écrit en 2h ! Pour ça que je n'ai pas fournis les sources de la librairie pour le moment qui ne ressemblent à rien ^_^.

Je regarde en fin de semaine pour refactorer un peu tout ça et résoudre ce problème de type.
Je pense passer par une classe abstraite React et des classes concrètes ReactTime, ReactMouse etc....
Un template method devrait me permettre de faire de la factory par type (pour le chaînage)....

[CyaNnOrangehead]

Bon voilà après un petit refactoring de la chose, ce que ça donne :

L'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
final React react = TimeReact.tick(500L).<TimeReact>filter(new Predicate1<TimeReact>() {
 
	@Override
	public boolean invoke(TimeReact react) {
		if (react.getIteration() % 3 == 0) {
			return true;
		} else {
			return false;
		}
	}
}).combine(TimeReact.tick(250L)).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact react) {
		System.out.println("TICK ! " + react.getTimeFromStart());
	}
}).onPause(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("PAUSED !");
	}
}).onResume(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("RESUME !");
	}
}).onDispose(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("DISPOSE !");
	}
});
 
TimeReact.once(3200L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.pause();
	}
});
 
TimeReact.once(5000L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.resume();
	}
});
 
TimeReact.once(7500L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.dispose();
	}
});

L'interface React (avec des génériques c'est mieux) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public interface React<R extends React> {
 
	int getIteration();
 
	long getTimeFromStart();
 
	long getTimeFromLast();
 
	void fireOnReact();
 
	/**
        Call function automatically in case of event occured
        @param function function to call by react
        @return returm this
         */
	React onReact(Procedure1<R> function);
	React onPause(Procedure1<R> function);
	React onResume(Procedure1<R> function);
	React onDispose(Procedure1<R> function);
 
	/**
        Merge reactor with another one and couple the events between
        @param <R2> the second react type
        @param react the second react
        @return return this
         */
	 <R2 extends React> R combine(final R2 react);
 
	/**
        Filter events according predicate criteria.
        @param predicate return true if event should be active, else not
        @return return this
         */
	 <R0 extends React> React filter(Predicate1<R0> predicate);
 
	/**
        Pause the react execution
         */
	void pause();
 
	/**
        Resume the react execution
         */
	void resume();
 
	/**
        Dispose all react and dependents ones
        Terminate all events
         */
	void dispose();
}

La classe abstraite qui mutualise pas mal de comportements :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public abstract class ReactBase<R extends React> implements React<R> {
 
	// event
	private List<Procedure1<R>> onReactFunctions;
	private List<Procedure1<R>> onPauseFunctions;
	private List<Procedure1<R>> onResumeFunctions;
	private List<Procedure1<R>> onDisposeFunctions;
	// chain
	private React parent;
	private List<React> children;
	// attributes
	private int iteration = 0;
	private long startTime = System.currentTimeMillis();
	private long lastTime = System.currentTimeMillis();
 
	protected ReactBase() {
		onReactFunctions = new ArrayList<Procedure1<R>>();
		onPauseFunctions = new ArrayList<Procedure1<R>>();
		onResumeFunctions = new ArrayList<Procedure1<R>>();
		onDisposeFunctions = new ArrayList<Procedure1<R>>();
		this.parent = null;
	}
 
	protected ReactBase(React parent) {
		this();
		this.parent = parent;
	}
 
	public abstract R getInstance(React parent);
 
	private void addChild(React react) {
		if (children == null) {
			children = new ArrayList<React>();
		}
		children.add(react);
	}
 
	private void fireEvent (List<Procedure1<R>> functions) {
		for (Procedure1<R> function : functions) {
			function.invoke((R) this);
		}
	}
 
	@Override
	public void fireOnReact() {
		iteration++;
		fireEvent(onReactFunctions);
		lastTime = System.currentTimeMillis();
	}
 
	@Override
	public int getIteration() {
		return iteration;
	}
 
	@Override
	public long getTimeFromStart() {
		return System.currentTimeMillis() - startTime;
	}
 
	@Override
	public long getTimeFromLast() {
		return System.currentTimeMillis() - lastTime;
	}
 
	@Override
	public React onReact(Procedure1<R> function) {
		onReactFunctions.add(function);
		return this;
	}
 
	@Override
	public React onPause(Procedure1<R> function) {
		onPauseFunctions.add(function);
		return this;
	}
 
	@Override
	public React onResume(Procedure1<R> function) {
		onResumeFunctions.add(function);
		return this;
	}
 
	@Override
	public React onDispose(Procedure1<R> function) {
		onDisposeFunctions.add(function);
		return this;
	}
 
	@Override
	public <R2 extends React> R combine(R2 react) {
		addChild(react);
 
		react.onReact(new Procedure1<R2>() {
 
			@Override
			public void invoke(R2 arg1) {
				ReactBase.this.fireOnReact();
			}
		});
		return (R) this;
	}
 
	@Override
	public <R0 extends React> React filter(final Predicate1<R0> predicate) {
		final R react = getInstance(this);
 
		this.onReact(new Procedure1<R>() {
 
			@Override
			public void invoke(R arg1) {
 
				if (predicate.invoke((R0) ReactBase.this)) {
					react.fireOnReact();
				}
 
			}
		});
 
		return react;
	}
 
	abstract protected void applyPause();
 
	@Override
	public void pause() {
		fireEvent(onPauseFunctions);
 
		if (parent != null) {
			parent.pause();
		}
		if (children != null) {
			for (React child : children) {
				child.pause();
			}
		}
		applyPause();
	}
 
	abstract protected void applyResume();
 
	@Override
	public void resume() {
		fireEvent(onResumeFunctions);
 
		if (parent != null) {
			parent.resume();
		}
		if (children != null) {
			for (React child : children) {
				child.resume();
			}
		}
		applyResume();
	}
 
	abstract protected void applyDispose();
 
	@Override
	public void dispose() {
		fireEvent(onDisposeFunctions);
 
		if (parent != null) {
			parent.dispose();
		}
		if (children != null) {
			for (React child : children) {
				child.dispose();
			}
		}
 
		// empty lists
		if (onReactFunctions != null) {
			onReactFunctions.clear();
		}
 
		applyDispose();
	}
}

(du coup, je me demande si c'est vraiment util d'avoir une interface + une classe abstraite)

Et enfin une classe concrète (TimeReact) qui gère le temps, threads tout ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public class TimeReact extends ReactBase<TimeReact> {
 
	private Thread thread;
 
	public TimeReact() {
	}
 
	public TimeReact(React parent) {
		super(parent);
	}
 
	@Override
	public final TimeReact getInstance(React parent) {
		return new TimeReact(parent);
	}
 
	@Override
	protected final void applyPause() {
		if (thread != null) {
			synchronized (thread) {
				thread.suspend();
			}
		}
	}
 
	@Override
	protected final void applyResume() {
		if (thread != null) {
			synchronized (thread) {
				thread.resume();
			}
		}
	}
 
	@Override
	protected void applyDispose() {
		if (thread != null) {
			thread.interrupt();
			thread = null;
		}
	}
 
	public static TimeReact tick(final long timeout) {
		final TimeReact react = new TimeReact();
 
		react.thread = new Thread() {
 
			@Override
			public void run() {
				try {
 
					while (!isInterrupted()) {
						Thread.sleep(timeout);
 
						react.fireOnReact();
					}
				} catch (InterruptedException ex) {
 
					// do nothing
				}
 
			}
		};
 
		react.thread.start();
 
		return react;
	}
 
	public static TimeReact once(final long timeout) {
		final TimeReact react = new TimeReact();
 
		react.thread = new Thread() {
 
			@Override
			public void run() {
				try {
 
					Thread.sleep(timeout);
 
					react.fireOnReact();
				} catch (InterruptedException ex) {
					// do nothing
				}
 
			}
		};
 
		react.thread.start();
 
		return react;
	}
 
}

En gros cette dernière présente des factories (tick, once etc...) d'elle même.

[CyaNnOrangehead]

Je progresse.

Voici un cas d'utilisation pour les trucs qui ce redessines quand le bouton souris est maintenu (un moteur 3d par exemple) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
MouseReact.hold().when(new Function<React>() {
	@Override
	public React invoke() {
		return TimeReact.framePerSecond(30);
	}
}).onReact(new Procedure1<MouseReact>() {
	@Override
	public void invoke(MouseReact arg1) {
		log("FRAME PER SECOND " + arg1.getTimeFromLast());
	}
});

[CyaNnOrangehead]

Maintenant, la même chose, mais avec un délai à la fin de 500 millis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
MouseReact.pressed().until(new Function<React>() {
	@Override
	public React invoke() {
		return MouseReact.released().when(new Function<React>() {
 
			@Override
			public React invoke() {
				return TimeReact.once(500L);
			}
		});
	}
}).when(new Function<React>() {
	@Override
	public React invoke() {
		return TimeReact.framePerSecond(30);
	}
}).onReact(new Procedure1<MouseReact>() {
	@Override
	public void invoke(MouseReact arg1) {
		log("FRAME PER SECOND " + arg1.getTimeFromLast());
	}
});

J'aime quand ça deviens modulaire à souhaits.
Vivement les closures pour simplifier ces écritures.

[CyaNnOrangehead]

J'ai retrouvé le papier initiale qui m'a inspiré tout ça, un truc écrit par, entre autre Martin Odersky, un prof d'EPFL et auteur du très célèbre langage Scala.
http://lampwww.epfl.ch/~imaier/pub/D...versTR2010.pdf

Voici le code scala du package scala.react :

Code scala :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
val a = new Var(1)
val b = new Var(2)
val sum = Signal{ a()+b() }
observe(sum) { x => println(x) }
a()= 7
b()= 35

Voilà ce que j'obtiens après quelques tribulations :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
final Var<Integer> a = new Var<Integer>(1);
final Var<Integer> b = new Var<Integer>(2);
VarReact<Integer> sum = new VarReact<Integer>(new Function<Integer>() {
	@Override
	public Integer invoke() {
		return a.getValue() + b.getValue();
	}
}, a, b);
 
sum.subscribe(new Procedure1<Integer>() {
	@Override
	public void invoke(Integer value) {
		System.out.println("Sum result = " + value);
	}
});
 
System.out.println(sum.getValue());
a.setValue(5);
b.setValue(7);

C'est moins concis, mais l'idée est là.

[CyaNnOrangehead]

Boah.... y a pas foule...

Bon voici le code source, le wiki et le bug tracker du projet :
https://bitbucket.org/yann_caron/java.react/wiki/Home

Open source, le projet donc....

[thierryler]

Je vais essayer de lire ça dans la journée...

[thierryler]

Je ne comprend pas bien. C'est un article que tu écris ? ou un programme ?

Sinon j'avoue ne rien avoir compris, même si ça a l'air bien foutu... En fait ça sert à quoi ? D'après ce que je vois ça ressemble à un listener...

[CyaNnOrangehead]

Salut Thierry,
Oui ça m'a paru très confus aussi la première fois.
L'idée ce base sur ce document écrit pas Ingo Mayer et Martin Odersky http://infoscience.epfl.ch/record/17...ervers2012.pdf (des profs de l'EPFL, en Suisse... s'ont fort c'est p'tits Suisses)

En fait ma librairie consiste à traduire en objet la façon dont on traite les évènements en fonctionnel.
L'idée est assez récente (1997) autant dire hier dans le monde de la recherche, du coup c'est assez peu connu.

En gros, il existe deux type de réaction :
- discrètes : qui sont des listeners accés sur des valeurs. Il faut voir les valeur comme des entités qui évoluent au file du temps.
- continues : gérer les évenements du système avec une approche fonctionnel (avec des monade comme map / filter, tiens ça nous rappelle nos précédente aventures).

Pour le moment je me contente d'écrire une librairie qui fait ça en Java. Puis je vais la porter dans mon langage AL.
Je pense à des syntaxes très simples comme ça :

Code AL :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// réaction discrète
set a = 1;
set b = 1;
set sum = {a} + {b} // reaction discrète
 
sum.map(function (sum) {
  return "La somme de a et b est de " .. sum; // on change le type et construit le message
}).onChange (function (msg) {
  print (msg); // on écrit le message
});
 
a = 7;
// La somme de a et b est de 8
a = 7
// La somme de a et b est de 14

Ce que ça donne en réaction continue.

Code AL :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
// réaction continue
set react = Mouse.press ().merge (Time.every (250))
  .onChange (function (ev) {
    // action
  });
 
Mouse.release().onChange (function (ev) {
  react.stop ();
});

Et enfin, si ça intéresse la communauté DVP, oui pourquoi pas écrire un article (en Java hein), un peu dans la même veine que le premier. Un truc qui fait mal à la tête, mais c'est tellement bon ;-)


Je voie l'intérêt de tels librairie dans les HMI et surtout dans la création de jeux vidéos.
Par exemple, un vaisseau tire un missile. Le sprite missile déclenche une réaction de type Time.framePerSecond(). Un fois le bord de l'écran ou la cible atteinte, la réaction est détruite.
Ca donnerai l'écriture assez concise suivante :

Code AL :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
vaisseau.fire.onChange (function () {
  set m1 = missil.clone();
  set react = Time.framePerSecond (30).onChange (function () {
    m1.goForward(10);
    m1.draw();
  });
 
  m1.collide.onChange (function () {
    react.stop();
  });
});

C'est un code hypothétique hein, mais l'idée me séduit assez.
Ca simplifie grandement la gestion des threads et des évènements.
Note que la méthode collide est une réaction discrète qui agit sur la réaction continue react.....
Note également la concision du code obtenir par rapport à la complexité demandé. Avec des Thread en java, ça prend un petit bout de temps avant de réussie à faire fonctionner ce genre de comportement.

[thierryler]

Je ne comprend toujours pas...

Par contre si tu fais un article, je veux bien le relire.

[CyaNnOrangehead]

Voilà pour les reactions continues : https://bitbucket.org/yann_caron/java.react/wiki/Home

L'idée, c'est d'écrire un label dont la valeur se met automatiquement à jour selon les évènements de la souris.
Le label contiens les informations suivantes : si le bouton est appuyé ou pas ainsi que la position du curseur.
Pour cela il faut faire un merge entre l'évènement hold (maintien du bouton) et celui du déplacement de la souris (move).
Les méthodes maps servent à convertir et à mettre en forme la valeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
Signal<String> mouseAndTime = MouseReact.hold(1).map(new Function1<String, MouseEvent>() {
 
    @Override
    public String invoke(MouseEvent value) {
        // when mouse button is pressed
        return "button pressed";
    }
}).otherwise(new Function1<String, String>() {
 
    @Override
    public String invoke(String arg1) {
        // when it is released
        return "button released";
    }
}).merge(MouseReact.move()).map(new Function1<String, Tuple<String, MouseEvent>>() {
 
    @Override
    public String invoke(Tuple<String, MouseEvent> values) {
        // concatenate with mouse move event position
        return values.getFirst() + " at (x= " + values.getSecond().getX() + ", y= " + values.getSecond().getY() + ")";
    }
});
 
label1.setText(mouseAndTime);

Voilà ce que cela nous donne :


Pour plus de détails allez voir la page wiki du projet (en début de poste)

On peu imaginer des combinaisons de toutes sorte de comportements.
Par exemple concaténer l'heure dans le label et que celui-ci ce mette à jour automatiquement. etc.

Un exemple sur la réalisation avec des éléments graphiques animés suivra pour mieux illustrer les possibilités.