Ajouter les fonctions undo et redo

Version imprimable

Bonjour,

Je suis en train de réaliser une application android, ou j'ajoute des lignes et des cercles sur un plan quadrillé. J'ai une fonction doBitmap qui permet d'insérer mes éléments sur le plan, je suis en train d'essayer de faire les fonctions undo et redo mais j'éprouve quelques difficultés. Les boutons sont créés. Mon code concernant la ligne est le suivant :

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
 
public class Ligne extends EltPlan {
	private static final int epaisseur = 8;
	private int a, b;
 
	private Ligne(int x, int y, int width, int height) {
		super(x, y, width, height);
	}
 
	public static Ligne LigneHorizontal(int x, int y, int lgr) {
		return new Ligne(x, y, lgr, epaisseur);
	}
 
	public static Ligne LigneVertical(int x, int y, int lgr) {
		return new Ligne(x, y, epaisseur, lgr);
	}
 
	public void doBitmap() {
		// Si la ligne est selectionné on l'encadre en rouge
		if (isSelected()) {
			setBitmap(Bitmap.createBitmap(getPixelsWidth() + 10,
					getPixelsHeight() + 10, Config.ARGB_8888));
			for (b = 5; b < getBitmap().getHeight() - 5; b++) {
				for (a = 5; a < getBitmap().getWidth() - 5; a++)
					getBitmap().setPixel(a, b, Color.GRAY);
			}
			for (a = 0; a < getBitmap().getWidth(); a++)
				getBitmap().setPixel(a, 0, Color.RED);
			for (a = 0; a < getBitmap().getWidth(); a++)
				getBitmap().setPixel(a, getBitmap().getHeight() - 1, Color.RED);
			for (b = 0; b < getBitmap().getHeight(); b++)
				getBitmap().setPixel(0, b, Color.RED);
			for (b = 0; b < getBitmap().getHeight(); b++)
				getBitmap().setPixel(getBitmap().getWidth() - 1, b, Color.RED);
		} else {
			setBitmap(Bitmap.createBitmap(getPixelsWidth(), getPixelsHeight(),
					Config.ARGB_8888));
			for (b = 0; b < getBitmap().getHeight(); b++) {
				for (a = 0; a < getBitmap().getWidth(); a++)
					getBitmap().setPixel(a, b, Color.GRAY);
			}
		}
	}
}

Je ne sais pas si j'ai bien compris le fonctionnement mais j'ai l'impression que ma fonction doBitmap pourrait etre une fonction redo ?
Ensuite ma classe EltPlan :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public abstract class EltPlan {
 
 
	private Point position = null;
	private float x;
	private float y;
	private int pixelsHeight;
	private int pixelsWidth;
 
 
	public EltPlan(int x, int y, int pixelsWidth,
			int pixelsHeight) {
		position = new Point(x, y);
		setX(x);
		setY(y);
		setPixelsWidth(pixelsWidth);
		setPixelsHeight(pixelsHeight);
	}
 
	public abstract void doBitmap();
}

Et j'ai ma classe principale ensuite ou je gère les actions pour mes boutons.

Merci de votre aide

La fonctionnalité do/undo nécessite l'utilisation du pattern "Processeur de commande".
Wikipédia :
http://fr.wikipedia.org/wiki/Command..._conception%29

L'idée est :
Chaque commande est réalisé par le processeur ET mémoriser dans l'historique par celui-ci !
Quand tu veux faire un undo, tu demande au processeur de défaire la dernière action.

En général tu as :
Code:

1 2 3 4 5 6 7 8 9 public interface Command { void do(); void undo(); // permet de savoir si on peut appeler le undo boolean canBeUnDone(); // permet de savoir si on a à historiser la commande // Exemple de commande qui retourne faux : Sauvegarder boolean isHistorisable(); }
Cordialement,
Patrick Kolodziejczyk.

03/11/2014, 11h50
lass7

Je vous remercie de votre réponse, j'ai lu l'article, et je comprends bien la manière de procéder seulement dans mon cas lorsque je suis arrivée le code été fait comme cela et il y a plein d'autre classe qui on été faite et dont la fonction dobitmap dépend, du coup j'ai l'impression que dans mon cas je ne peux pas procéder de cette manière.
03/11/2014, 13h14
Népomucène

Reprenons à la base :
Est-ce que pour ajouter une ligne tu crées un nouvel objet Ligne
que tu ajoutes dans sur un plan et qui est ensuite dessiné ?

Logiquement,Ligne n'est qu'un élément de ton plan.
A un endroit, tu dois avoir un ajouterElement(elt), qui ajoute à la liste tout des éléments le nouvelle éléments crée.
C'est là que doit intervenir ta commande.
Tu dois avoir quelque chose comme :
Code:

1 2 3 Plan p; Ligne l; p.ajouterElement(l);
A la place tu dois avoir :
Code:

1 2 3 4 5 6 Plan p; Ligne l; Commande commande = AjoutCommande(p,l); // On suppose que le processeur est un singleton dans l'exemple ! Processeur.getInstance().execute(commande);
Avec :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class AjoutCommande extends Commande { private Plan p; private Element e; AjoutCommande(Plan p, Element e){ this.p=p; this.e=e; } public void execute(){ this.p.ajouterElement(this.e); } public void undo(){ this.p.supprimerElement(this.e); } public boolean canBeUnDone(){ return true; } public boolean isHistorisable(){ return true; } }
Cordialement,
Patrick Kolodziejczyk.

Alors comme je l'expliquais dans le premier poste afin de dessiner ma ligne sur ma tablette j'utilise seulement doBitmap et ce qui me permet de la dessiner c'est cette partie du code :
Code:

1 2 3 4 5 6 setBitmap(Bitmap.createBitmap(getPixelsWidth(), getPixelsHeight(),Config.ARGB_8888)); for (b = 0; b < getBitmap().getHeight(); b++) { for (a = 0; a < getBitmap().getWidth(); a++) getBitmap().setPixel(a, b, Color.GRAY); }
Du coup lorsque je clique sur l'icone ligne avec mon doigt j'appuie une premiere fois sur l'ecran pour l'origine de ma ligne et une seconde fois pour la fin, je ne sais pas si c'est cela que vous vouliez savoir

Merci

03/11/2014, 15h00
kolodz

Citation:

Je ne sais pas si j'ai bien compris le fonctionnement mais j'ai l'impression que ma fonction doBitmap pourrait etre une fonction redo ?

Ta fonction doBitmap() ne peux pas être une fonction redo.

La fonction doBitmap() permet just pour chaque ligne de l'afficher correctement dans ta Bitmap. Il est fort probable que tu ai une liste à un endroit qui réalise un foreach pour l'ensemble des éléments de ton Plan/Dessin. Pour annuler, ta ligne il faut simplement enlever cette ligne de ta liste et demande un rafraichissement de ta Bitmap (qui fait le foreach).
Le "redo" qui correspond à relancer la méthode exécuter de la commande :

1.Ajouter la ligne à la liste
2.Refaire la Bitmap avec le foreach

Il faut que tu intervienne au niveau du modèle de donnée et non dans les fonctions (qui dessinent).

Cordialement,
Patrick Kolodziejczyk.

Du coup, en suivant tes conseils, j'ai donc fait une classe Command :

Code:

1
2
3
4
5
6
7
8
9
 
public interface Command {
	void redo();
	void undo();
	// permet de savoir si on peut appeler le undo
	boolean canBeUndone();
	// permet de savoir si on a à historiser la commande
	boolean isHistorisable();
}

Ensuite j'ai fait un singletion CommandManager :

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
 
public class CommandManager {
 
	private ArrayList<Command> redoList = new ArrayList<Command>();
	private ArrayList<Command> undoList = new ArrayList<Command>();
	private boolean reallyDirty = false;
	static CommandManager _instance = null;
 
	public static CommandManager getInstance() {
 
		if (_instance == null)
			_instance = new CommandManager();
		return _instance;
	}
 
	public static void execute(Command command) {
		getInstance().performAction(command);
	}
 
	public static void undo() {
		getInstance().performUndo();
	}
 
	public static void redo() {
		getInstance().performRedo();
	}
 
	public boolean isDirty() {
		return this.reallyDirty || !hasUndo();
	}
 
	public boolean hasUndo() {
		return !this.undoList.isEmpty();
	}
 
	public boolean hasRedo() {
		return !this.redoList.isEmpty();
	}
 
	public void performAction(Command command) {
		command.redo();
		this.redoList.clear();
		if (command instanceof Command) {
			this.undoList.add((Command) command);
		} else {
			this.undoList.clear();
			this.reallyDirty = true;
		}
	}
 
	public void performRedo() {
		if (!this.redoList.isEmpty()) {
			Command command = this.redoList.get(this.redoList.size() - 1);
			this.redoList.remove(this.redoList.size() - 1);
			command.redo();
			this.undoList.add(command);
		}
	}
 
	public void performUndo() {
		if (!this.undoList.isEmpty()) {
			Command command = this.undoList.get(this.undoList.size() - 1);
			this.undoList.remove(this.undoList.size() - 1);
			command.undo();
			this.redoList.add(command);
		}
	}
 
	public void reset() {
		this.undoList.clear();
		this.redoList.clear();
		this.reallyDirty = false;
	}
 
	private CommandManager() {
	}
}

Dans ma classe pour insérer un ligne, j'avais bien comme tu me l'as dit, plan.add(ligne);
J'ai donc mis ceci :

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
 
public class InsertionLigneListener implements OnTouchListener  {
 
	private Plan plan;
	Ligne nvlElt;
	Command command; 
	private int lastEltX, lastEltY;
	private int selection;
	private boolean onRight = false;
 
	public static final int NO_SELECTION = 0;
	public static final int SELECT_LIGNE = 1;
 
	public InsertionLigneListener(Plan plan) {
		this.plan = plan;
	}
 
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		v.performClick();
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			onTouchDown(event);
			return true;
		case MotionEvent.ACTION_MOVE:
			onTouchMove(event);
			return true;
		case MotionEvent.ACTION_UP:
			onTouchUp(event);
			break;
		}
		return false;
	}
 
	private void onTouchDown(MotionEvent event) {
 
	}
 
	private void onTouchMove(MotionEvent evnet) {
 
	}
 
 
	private void onTouchUp(MotionEvent event) {
		switch (selection) {
		case SELECT_LIGNE:
			if (lastEltX == -1) {
				lastEltX = (int) event.getX();
				lastEltY = (int) event.getY();
			} else {
				int departX, departY;
				if (Math.abs((int) event.getY() - lastEltY) > Math
						.abs((int) event.getX() - lastEltX)) {
 
					// Ligne vertical
					if ((int) event.getY() > lastEltY){
						departY = lastEltY;
					}else{
						departY = (int) event.getY();
					}
					departX = lastEltX;
					if (onRight) {
						nvlElt = Ligne.LigneVertical(departX, departY,
								Math.abs((int) event.getY() - lastEltY));
						 nvlElt.setPixelsHeight(nvlElt.getPixelsHeight()
								+ nvlElt.getPixelsWidth());
					} else {
						nvlElt = Ligne.LigneVertical(departX, departY,
								Math.abs((int) event.getY() - lastEltY));
					}
 
					lastEltY = (int) event.getY();
					onRight = false;
 
				} else {
					// Ligne horizontal
					if ((int) event.getX() > lastEltX) {
						onRight = true;
						departX = lastEltX;
					} else {
						onRight = false;
						departX = (int) event.getX();
					}
					departY = lastEltY;
					nvlElt = Ligne.LigneHorizontal(departX, departY,
							Math.abs((int) event.getX() - lastEltX));
					lastEltX = (int) event.getX();
				}
 
				command = AddCommand(plan,nvlElt);
				CommandManager.getInstance();
				CommandManager.execute(command);
				//plan.add(nvlElt);
 
				plan.invalidate();
			}
			break;
		}
	}

Et du coup j'ai crée une classe AddCommand :

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
 
public class AddCommand implements Command {
 
	private Plan plan;
	private Ligne ligne;
 
	AddCommand(Plan p, Ligne l) {
		this.plan = p;
		this.ligne = l;
	}
 
	public void execute() {
		this.plan.add(this.ligne);
	}
 
	@Override
	public void redo() {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void undo() {
		this.plan.deleteLigne(this.ligne);
	}
 
	@Override
	public boolean canBeUndone() {
		return true;
	}
 
	@Override
	public boolean isHistorisable() {
		return true;
	}
}

Voila je voulais savoir si c'est comme cela qu'il faut faire ou pas ? qu'est ce que je dois améliorer pour que çà fonctionne

Merci

05/11/2014, 12h11
kolodz

Ne pouvant pas tester votre code.
Je me suis permis d'écrire un article sur comment réalisé le undo/redo avec un processeur de commande :
http://www.developpez.net/forums/blo...principe-base/

D'après ce que je vois votre implémentation me semble correcte. Il me semble que tu ne vérifie pas le cas de la commande qui n'est pas annulable. Ce qui peut-être problématique !

Cordialement,
Patrick Kolodziejczyk.
06/11/2014, 17h24
lass7
Je n'arrive pas a voir la différence entre mon singleton commandManager et la classe addCommand ?

Si je rajoute çà :
Code:

1 2 3 4 command = AddCommand(plan,nvlElt); CommandManager.getInstance(); CommandManager.execute(command);
Comme vous me l'avez conseillé, il faut donc que je rajoute dans la même classe la methode addCommand
07/11/2014, 10h24
kolodz
Dans ta class AddCommand, tu as deux méthodes :
Code:

1 2 3 4 5 6 7 8 9 public void execute() { this.plan.add(this.ligne); } @Override public void redo() { // TODO Auto-generated method stub }
Cela n'est pas normal, tu dois avoir seulement execute(), une commande n'a pas à savoir si c'est la première fois qu'on l'exécute ou non. Et cela ne doit pas changer son comportement.

Donc, tu replace tout test redo() par execute(). Seul le processeur à besoin de savoir qu'il faut refaire la dernière commande annuler. (Pour savoir qu'elle commande il doit lancer) D'ailleurs normalement, redo() à le comportent suivant :
[CODE]public void redo(){
Command command = this.getLastCommandUndo();
this.execute(command);
this.removeLastCommandUndo();
}[/CODE
Car basiquement redo() et un execute() sans paramètre !

Cordialement,
Patrick Kolodziejczyk.

Du coup ma classe addCommand est une classe abstract, sinon on me demande d'ajouter les méthodes de mon interface Command vu que ma classe addCommand implements Command.

Ma classe addCommand est donc comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public abstract class AddCommand implements Command {
 
	private Plan plan;
	private Ligne ligne;
 
	AddCommand(Plan p, Ligne l {
		this.plan = p;
		this.ligne = l;
	}
 
	public void execute() {
		this.plan.add(this.ligne);
	}
 
}

ma classe commandManager est comme ceci :

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
 
public class CommandManager {
 
	private ArrayList<Command> redoList; 
	private ArrayList<Command> undoList;
	private boolean reallyDirty = false;
	static CommandManager _instance = null;
 
	public static CommandManager getInstance() {
 
		if (_instance == null)
			_instance = new CommandManager();
		return _instance;
	}
 
	public static void execute(Command command) {
		getInstance().performAction(command);
	}
 
	public static void undo() {
		getInstance().performUndo();
	}
 
	public static void redo() {
		getInstance().performRedo();
	}
 
	public boolean isDirty() {
		return this.reallyDirty || !hasUndo();
	}
 
	public boolean hasUndo() {
		return !this.undoList.isEmpty();
	}
 
	public boolean hasRedo() {
		return !this.redoList.isEmpty();
	}
 
	public void performAction(Command command) {
		command.redo();
		this.redoList.clear();
		if (command instanceof Command) {
			this.undoList.add((Command) command);
		} else {
			this.undoList.clear();
			this.reallyDirty = true;
		}
	}
 
	public void performRedo() {
		if (!this.redoList.isEmpty()) {
			Command command = this.redoList.get(this.redoList.size() - 1);
			this.redoList.remove(this.redoList.size() - 1);
			command.redo();
			this.undoList.add(command);
		}else{
			System.out.println("Debug processor : No command to redo");
		}
	}
 
	public void performUndo() {
		if (!this.undoList.isEmpty()) {
			Command command = this.undoList.get(this.undoList.size() - 1);
			this.undoList.remove(this.undoList.size() - 1);
			command.undo();
			this.redoList.add(command);
		}else{
			System.out.println("Debug processor : No command to undo");
		}
	}
 
	public void reset() {
		this.undoList.clear();
		this.redoList.clear();
		this.reallyDirty = false;
	}
 
	private CommandManager() {
		redoList = new ArrayList<Command>();
		undoList = new ArrayList<Command>();
	}

et mon interface Command est comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public interface Command {
	void redo();
 
	void undo();
 
	/** permet de savoir si on peut appeler le undo **/
	boolean canBeUndone();
 
	/** permet de savoir si on a à historiser la commande **/
	boolean isHistorisable();
 
}

Du coup maintenant il me reste à faire quoi ? dans ma classe insertionLigneListener à la place de plan.add(nvlElt);

Je remplace par :

Code:

1
2
3
4
 
command = AddCommand(plan,nvlElt);
CommandManager.getInstance();
CommandManager.execute(command);

Mais du coup AddCommand je dois l'impémenter dans ma classe insertionLigneListener ?

et j'ai ajouter dan ma classe MainActivity cela :

Code:

1
2
3
4
5
6
7
8
 
public void onClick(View v) {	
 
  if (v == btnUndo) { 
    CommandManager.undo();
  }
 
}

Merci

Ton interface doit avoir seulement execute(). C'est sa principale fonction !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public interface Command { void execute(); void undo(); /** permet de savoir si on peut appeler le undo **/ boolean canBeUndone(); /** permet de savoir si on a à historiser la commande **/ boolean isHistorisable(); }
undo() est un plus pour faire l'inverse.
Il est totalement possible d'imaginé une implémentation ou ce n'est pas à la commande de s'annuler. Le processeur de commande pourrai par exemple avoir un private Command getOpositeCommand(Command command) Et de faire un execute() sur celle-ci !

canBeUndone() se dans le cas de l'exemple précédent l’existence d'une commande inverse ie (si private Command getOpositeCommand(Command command) retourne autre chose que null)

isHistorisable() est un plus pour faire des commandes qui n'impacte pas l'historique.

Donc l'interface Command, c'est à 95%execute() !!!

Cordialement,
Patrick Kolodziejczyk.

D'accord donc pour l'interface je ne mets que execute et du coup pour ma fonction undo c'est dans mon singleton que je l'a mets.
Car dans ma classe commandManager je ne peux donc pas faire cela :
Code:

1 2 3 4 5 6 7 8 9 10 11 public void performAction(Command command) { command.redo(); this.redoList.clear(); if (command instanceof Command) { this.undoList.add((Command) command); } else { this.undoList.clear(); this.reallyDirty = true; } }

07/11/2014, 13h48
kolodz

Non !!!
Ce que j'explique dans mon exemple, c'est que undo(). C'est qu'un "bonus" dans l'interface. Mais que ce n'est pas son bût principale.

Par contre au regarde ce ce que tu as tu le laisse là !

Il te sera bien plus facile pour toi de faire faire la fonction undo() dans la commande, que de crée une commande inverse...

Cordialement,
Patrick Kolodziejczyk.

a oui voila, c'est pour çà je ne comprennais plus rien. Du coup mon interface est comme cela:
Code:

1 2 3 4 5 6 7 8 public interface Command { void execute(); void undo(); void redo(); }
et ma classe addCommand est comme cela :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public abstract class AddCommand implements Command { private Plan plan; private Ligne ligne; AddCommand(Plan p, Ligne l) { this.plan = p; this.ligne = l; } public void execute() { this.plan.add(this.ligne); } }
Maintenant qu'est ce que je dois ajouter ou modifier pour que çà marche, dans ma classe insertionLigneListener je dois faire une méthode addcommand ?

07/11/2014, 14h11
kolodz

Dégage moi ce redo() de cette interface !
...Tu va pas me faire une fonction reredo() en plus non ?

Et ta commande n'est pas abstract ! Tu veux en crée une instance pour la donner à ton Processeur de commande !

K

Ok, du coup redo c'est la même chose que execute, j'avais pas saisie cela, du coup mon interface Command est :

Code:

1
2
3
4
5
6
7
 
public interface Command {
	void execute();
 
	void undo();
 
}

et ma classe addCommand est :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public class AddCommand implements Command {
 
	private Plan plan;
	private Ligne ligne;
 
	AddCommand(Plan p, Ligne l) {
		this.plan = p;
		this.ligne = l;
	}
 
	public void execute() {
		this.plan.add(this.ligne);
	}
 
	@Override
	public void undo() {
 
	}
 
}

Du coup dans ma classe commandManager je dois changer des choses, car le redo n'est plus reconnu donc je le remplace par execute:

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
 
 
public class CommandManager {
 
	private ArrayList<Command> redoList; 
	private ArrayList<Command> undoList;
	private boolean reallyDirty = false;
	static CommandManager _instance = null;
 
	public static CommandManager getInstance() {
 
		if (_instance == null)
			_instance = new CommandManager();
		return _instance;
	}
 
	public static void execute(Command command) {
		getInstance().performAction(command);
	}
 
	public static void undo() {
		getInstance().performUndo();
	}
 
	public static void execute() {
		getInstance().performExecute();
	}
 
	public boolean isDirty() {
		return this.reallyDirty || !hasUndo();
	}
 
	public boolean hasUndo() {
		return !this.undoList.isEmpty();
	}
 
	public boolean hasExecute() {
		return !this.redoList.isEmpty();
	}
 
	public void performAction(Command command) {
		command.execute();
		this.redoList.clear();
		if (command instanceof Command) {
			this.undoList.add((Command) command);
		} else {
			this.undoList.clear();
			this.reallyDirty = true;
		}
	}
 
	public void performExecute() {
		if (!this.redoList.isEmpty()) {
			Command command = this.redoList.get(this.redoList.size() - 1);
			this.redoList.remove(this.redoList.size() - 1);
			command.execute();
			this.undoList.add(command);
		}else{
			System.out.println("Debug processor : No command to redo");
		}
	}
 
	public void performUndo() {
		if (!this.undoList.isEmpty()) {
			Command command = this.undoList.get(this.undoList.size() - 1);
			this.undoList.remove(this.undoList.size() - 1);
			command.undo();
			this.redoList.add(command);
		}else{
			System.out.println("Debug processor : No command to undo");
		}
	}
 
	public void reset() {
		this.undoList.clear();
		this.redoList.clear();
		this.reallyDirty = false;
	}
 
	private CommandManager() {
		redoList = new ArrayList<Command>();
		undoList = new ArrayList<Command>();
	}
}

Merci

07/11/2014, 15h25
kolodz
Vue que tu ne veux pas juste un historique des commandes, tu va vouloir implémenté le code dans AddCommand:
Code:

1 2 3 4 @Override public void undo() { this.plan.remove(this.ligne); }
Sinon, tu va annuler la commande qui ne fera rien à son annulation et tu va chercher pourquoi ça fonctionne pas...

Cordialement,
Patrick Kolodziejczyk.

Oui voila c'est juste, je te remercie, et maintenant du coup dans ma classe insertionListeListener :

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
 
 
 
public class InsertionLigneListener implements OnTouchListener  {
 
	private Plan plan;
	Ligne nvlLigne; 
	private int lastEltX, lastEltY;
	private int selection;
	private boolean onRight = false;
 
	public static final int NO_SELECTION = 0;
	public static final int SELECT_LIGNE = 1;
 
	public InsertionLigneListener(Plan plan) {
		this.plan = plan;
	}
 
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		v.performClick();
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			onTouchDown(event);
			return true;
		case MotionEvent.ACTION_MOVE:
			onTouchMove(event);
			return true;
		case MotionEvent.ACTION_UP:
			onTouchUp(event);
			break;
		}
		return false;
	}
 
	private void onTouchDown(MotionEvent event) {
 
	}
 
	private void onTouchMove(MotionEvent evnet) {
 
	}
 
 
	private void onTouchUp(MotionEvent event) {
		switch (selection) {
		case SELECT_LIGNE:
			if (lastEltX == -1) {
				lastEltX = (int) event.getX();
				lastEltY = (int) event.getY();
			} else {
				int departX, departY;
				if (Math.abs((int) event.getY() - lastEltY) > Math
						.abs((int) event.getX() - lastEltX)) {
 
					// Ligne vertical
					if ((int) event.getY() > lastEltY){
						departY = lastEltY;
					}else{
						departY = (int) event.getY();
					}
					departX = lastEltX;
					if (onRight) {
						nvlLigne = Ligne.LigneVertical(departX, departY,
								Math.abs((int) event.getY() - lastEltY));
						 nvlLigne.setPixelsHeight(nvlLigne.getPixelsHeight()
								+ nvlLigne.getPixelsWidth());
					} else {
						nvlLigne = Ligne.LigneVertical(departX, departY,
								Math.abs((int) event.getY() - lastEltY));
					}
 
					lastEltY = (int) event.getY();
					onRight = false;
 
				} else {
					// Ligne horizontal
					if ((int) event.getX() > lastEltX) {
						onRight = true;
						departX = lastEltX;
					} else {
						onRight = false;
						departX = (int) event.getX();
					}
					departY = lastEltY;
					nvlLigne = Ligne.LigneHorizontal(departX, departY,
							Math.abs((int) event.getX() - lastEltX));
					lastEltX = (int) event.getX();
				}
 
				plan.add(nvlLigne);
 
				plan.invalidate();
			}
			break;
	}
 
 
 
	public void reinitialize() {
		lastEltX = -1;
		lastEltY = -1;
		onRight = false;
	}
 
	public void setSelection(int selection) {
		this.selection = selection;
	}
 
	public int getLastEltX() {
		return lastEltX;
	}
 
	public void setLastEltX(int lastEltX) {
		this.lastEltX = lastEltX;
	}
 
	public int getLastEltY() {
		return lastEltY;
	}
 
	public void setLastEltY(int lastEltY) {
		this.lastEltY = lastEltY;
	}
 
 
}

je remplace :

Code:

1
2
 
plan.add(nvlLigne);

par quoi ?

Code:

1
2
AddCommand command = AddCommand(plan,nvlElt);
CommandManager.getInstance().execute(command);

Tu l'avais déjà écris ...

07/11/2014, 15h52
lass7
oui mais lorsque j'écris cela :
Code:

1 2 3 AddCommand command = AddCommand(plan,nvlElt); CommandManager.getInstance().execute(command);
pour la premiere ligne on me met une erreur au deuxieme AddCommand, il faut rajouter un new, je pense non ?
et pour la deuxieme ligne elle est souligné en jaune avec ce message :

The static method execute(Command) from the type CommandManager should be accessed in a static way

j'ai donc remplacé par cela :
Code:

1 2 3 4 AddCommand command = new AddCommand(plan,nvlElt); CommandManager.getInstance(); CommandManager.execute(command);
et du coup lorsque je dessine une ligne et que j'appuie sur mon bouton undo il m'affiche ce message :

Debug processor : No command to undo

c'est celle que j'affiche dans mon commandManager ici :
Code:

1 2 3 4 5 6 7 8 9 10 11 public void performUndo() { if (!this.undoList.isEmpty()) { Command command = this.undoList.get(this.undoList.size() - 1); this.undoList.remove(this.undoList.size() - 1); command.undo(); this.redoList.add(command); }else{ System.out.println("Debug processor : No command to undo"); } }
Pourquoi çà ne marche pas ?

Cela veux dire que tu n'as pas la commande dans ta liste d'historique.

Remplacement moi ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	public static void execute(Command command) {
		getInstance().performAction(command);
	}
 
public void performAction(Command command) {
		command.execute();
		this.redoList.clear();
		if (command instanceof Command) {
			this.undoList.add((Command) command);
		} else {
			this.undoList.clear();
			this.reallyDirty = true;
		}
	}

Par :

Code:

1
2
3
4
5
6
7
8
	public void execute(Command command) {
System.out.println("Debug processor : Commande exécuté :"+command.getClass().getName());
		command.execute();
System.out.println("Debug processor : List redo vidé");
		this.redoList.clear();
System.out.println("Debug processor : List undo : élément ajouté !");
		this.undoList.add(command);
	}

ma classe commandManager est maintenant comme cela :

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
 
 
public class CommandManager {
 
	private ArrayList<Command> redoList;
	private ArrayList<Command> undoList;
	private boolean reallyDirty = false;
	static CommandManager _instance = null;
 
	public static CommandManager getInstance() {
 
		if (_instance == null)
			_instance = new CommandManager();
		return _instance;
	}
 
	public static void undo() {
		getInstance().performUndo();
	}
 
	public static void execute() {
		getInstance().performExecute();
	}
 
	public boolean isDirty() {
		return this.reallyDirty || !hasUndo();
	}
 
	public boolean hasUndo() {
		return !this.undoList.isEmpty();
	}
 
	public boolean hasExecute() {
		return !this.redoList.isEmpty();
	}
 
	public void execute(Command command) {
		System.out.println("Debug processor : Commande exécuté :"
				+ command.getClass().getName());
		command.execute();
		System.out.println("Debug processor : List redo vidé");
		this.redoList.clear();
		System.out.println("Debug processor : List undo : élément ajouté");
		this.undoList.add(command);
	}
 
	public void performExecute() {
		if (!this.redoList.isEmpty()) {
			Command command = this.redoList.get(this.redoList.size() - 1);
			this.redoList.remove(this.redoList.size() - 1);
			command.execute();
			this.undoList.add(command);
		} else {
			System.out.println("Debug processor : No command to redo");
		}
	}
 
	public void performUndo() {
		if (!this.undoList.isEmpty()) {
			Command command = this.undoList.get(this.undoList.size() - 1);
			this.undoList.remove(this.undoList.size() - 1);
			command.undo();
			this.redoList.add(command);
		} else {
			System.out.println("Debug processor : No command to undo");
		}
	}
 
	public void reset() {
		this.undoList.clear();
		this.redoList.clear();
		this.reallyDirty = false;
	}
 
	private CommandManager() {
		redoList = new ArrayList<Command>();
		undoList = new ArrayList<Command>();
	}
}

et dans ma classe insertionLigneListener j'ai bien cela :

Code:

1
2
3
 
AddCommand command = new AddCommand(plan,nvlElt);
CommandManager.getInstance().execute(command);

et lorsque je selectionne sur le bouton undo après avoir ajouter une ligne il me m'est le message suivant :

Code:

1
2
 
11-07 17:26:03.486: I/System.out(5785): Debug processor : No command to undo

Et plus haut il y a marqué cela :

Code:

1
2
3
4
 
11-07 17:25:54.121: I/System.out(5785): Debug processor : Commande exécuté :com.exemple.ligne.AddCommand
11-07 17:25:54.121: I/System.out(5785): Debug processor : List redo vidé
11-07 17:25:54.121: I/System.out(5785): Debug processor : List undo : élément ajouté

je précise aussi que ma classe Main est dans un package et les autres classes insertion, ligne, addcomand, commandManager et l'interface command dans un autre, je ne sais pas si cela change quelque chose.
Je trouve bizarre car vu les messages que tu m'a dit d'ajouter, on voit bien que l'élément à été ajouté mais il indique que ma liste est vide

10/11/2014, 13h06
kolodz

A mon avis tu devrait faire un peu de debug sur ton application et voir quand ta liste est vidé.
Car tu la remplis à un moment, et quand tu fait le undo(), celle-ci est vide. Cela veux dire qu'elle a été vidé par quelqu'un à un moment...

Cordialement,
Patrick Kolodziejczyk.
14/11/2014, 17h25
lass7

Le fonctionnement marche bien car lorsque je dessine une ligne et que j'appuie sur le bouton undo et le bouton redo je vois bien que cela marche, lorsque je vérifie en mode débug seulement ma ligne ne s'efface pas de mon plan. Il faut peu être que je fasse appel a ma méthode doBitmap a nouveau ? je ne sais pas ce que vous en penser car je n'utilise pas paint
24/11/2014, 11h22
lass7

J'ai donc résolu le problème en faisant appel à la méthode invalidate() au niveau de ma classe AddCommand dans mes méthodes execute et undo.
Je remercie tous ce qui ont pu m'aider

J'ai un autre petit problème c'est que j'ai la possibiliter de rajouter une fenetre sur ma ligne, qui n'est autre qu'une autre ligne d'une autre couleur ma classe et la suivante :

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
 
private void onTouchDown(MotionEvent event) {
 
		if (ligneSelected != null) {
			if (ligneSelected.isVertical()) {
				if (selection == SELECT_WINDOW)
					selectedWindow = ligneSelected.getFenetreAt(
							ligneSelected.getPosition().x, (int) event.getY());
				} else {
				if (selection == SELECT_WINDOW)
					selectedWindow = ligneSelected.getFenetreAt(
							(int) event.getX(), ligneSelected.getPosition().y);
			}
		}
 
		if (plan.getSelectedLigne() == null
				|| (selectedWindow == null)) {
 
			if (plan.getSelectedLigne() == null)
				plan.setSelectedLigne(plan.getCurrentFloor().getSelectedLigne(
						(int) event.getX(), (int) event.getY()));
 
			ligneSelected = plan.getSelectedLigne();
 
			if (ligneSelected != null) {
				ligneSelected.setSelected(true);
				if (ligneSelected.isVertical()) {
					switch (plan.getEltBatToInsert()) {
					case Plan.FENETRE: {
						nvlEltF = Fenetre.FenetreVerticale("FENETRE_1",
								ligneSelected.getPosition().x,
								(int) event.getY(), 0);
						nvlEltF.setMeterThickness(nvlEltF.getPixelsThickness()
								/ plan.getScale());
 
						/** Largeur de la fenetre **/
						nvlEltF.setMeterLength(nvlEltF.getPixelsLength()
								/ plan.getScale());
 
						/** Ajout de la fenêtre à la ligne **/
 
						ligneSelected.add(nvlEltF);
						selectedWindow = nvlEltF;
						break;
					}
					}
				} else {
					switch (plan.getEltBatToInsert()) {
					case Plan.FENETRE: {
						nvlEltF = Fenetre.FenetreHorizontale("FENETRE_",
								(int) event.getX(),
								ligneSelected.getPosition().y, 0);
						nvlEltF.setMeterLength(nvlEltF.getPixelsThickness()
								/ plan.getScale());
						nvlEltF.setMeterThickness(nvlEltF.getPixelsLength()
								/ plan.getScale());
						ligneSelected.add(nvlEltF);
						selectedWindow = nvlEltF;
						break;
					}
					}
				}
 
			}
		} else {
			if (ligneSelected.isVertical()) {
				if (selection == SELECT_WINDOW)
					selectedWindow = ligneSelected.getFenetreAt(
							ligneSelected.getPosition().x, (int) event.getY());
				} else {
				if (selection == SELECT_WINDOW)
					selectedWindow = ligneSelected.getFenetreAt(
							(int) event.getX(), ligneSelected.getPosition().y);
				}
		}
		plan.invalidate();
	}

et du coup comme pour l'exemple précédent j'ai voulu remplacer :

Code:

1
2
 
ligneSelected.add(nvlEltF);

par :

Code:

1
2
3
 
command = new AddCommand(ligneSelected, nvlEltF);
CommandManager.getInstance().execute(command);

Donc du coup de la même maniere j'ai ajouter a ma classe addCommand :

Code:

1
2
3
4
5
 
	public AddCommand(Ligne ligneSelected, Fenetre nvlEltF) {
		this.ligne = ligneSelected;
		this.fenetre = nvlEltF;
	}

et dans ma méthode execute :

Code:

1
2
3
4
5
 
if (fenetre != null) {
	    	this.plan.add(this.fenetre);
	    	plan.invalidate();
	    }

Mais çà ne veut pas inserer ma fenetre sur la ligne, alors que çà le faisait bien avec juste :

Code:

1
2
 
ligneSelected.add(nvlEltF);

J'ai besoin de cela car pour l'instant si je dessine une ligne avec une fenêtre si je fais mon bouton undo alors la ligne s’enlève au premier clic sur le bouton alors que la fenêtre devrait s'enlever avant,

merci

Bonjour, j'ai toujours le même problème si quelqu'un pouvait m'aider,

j'ai donc dans ma classe AddCommand le code suivant :

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
 
public class AddCommand implements Command {
 
	private Plan plan;
	private Ligne ligne;
	private Porte porte;
	private EltPlan elt;
 
	AddCommand(Plan p, Ligne l) {
		this.plan = p;
		this.ligne = l;
	}
 
	AddCommand(Ligne l, Porte p) {
		this.ligne = l;
		this.porte = p;
	}
 
 
	public AddCommand(Ligne ligneSelected, EltPlan elt) {
		this.ligne = ligneSelected;
		this.setElt(elt);
	}
 
	public void execute() {
		if ((ligne != null && porte == null)) {
			this.plan.add(this.ligne);
		}
		if((porte != null)){
			this.ligne.add(this.porte);
		}
		plan.invalidate();
	}
 
	@Override
	public void undo() {
		if (ligne != null)
			this.plan.remove(this.ligne);
		if (porte != null)
			this.ligne.remove(this.porte);
		plan.invalidate();
	}
 
	public EltPlan getElt() {
		return elt;
	}
 
	public void setElt(EltPlan elt) {
		this.elt = elt;
	}
}

et ma classe InsertionPorte et la suivante :

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
 
public class InsertionPorteListener implements OnTouchListener {
	private Plan plan;
	private Ligne ligneSelected;
	private EltPlan selectedDoor;
	public AddCommand command;
	private Porte nvlEltP;
	private int selection = 0;
 
	public static final int NO_SELECTION = 0;
	public static final int SELECT_DOOR = 1;
 
	public InsertionPorteListener(Plan plan) {
		this.plan = plan;
	}
 
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		v.performClick();
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN: {
			onTouchDown(event);
			return true;
		}
		case MotionEvent.ACTION_MOVE: {
			onTouchMove(event);
			return true;
		}
		case MotionEvent.ACTION_UP: {
			onTouchUp(event);
			break;
		}
		}
		return false;
	}
 
	private void onTouchDown(MotionEvent event) {
 
		if (ligneSelected != null) {
			if (ligneSelected.isVertical()) {
				if (selection == SELECT_DOOR)
					selectedDoor = ligneSelected.getPorteAt(
							ligneSelected.getPosition().x, (int) event.getY());
			} else {
				if (selection == SELECT_DOOR)
					selectedDoor = ligneSelected.getPorteAt((int) event.getX(),
							ligneSelected.getPosition().y);
			}
		}
 
		if (plan.getSelectedLigne() == null || (selectedDoor == null)) {
 
			/** Si on sélectionne rien on peut ajouter une porte **/
			if (plan.getSelectedLigne() == null)
				plan.setSelectedLigne(plan.getCurrentFloor().getSelectedLigne(
						(int) event.getX(), (int) event.getY()));
 
			/** indication de sélection de la ligne **/
			ligneSelected = plan.getSelectedLigne();
 
			/** Si ligne sélectionné **/
			if (ligneSelected != null) {
				ligneSelected.setSelected(true);
				if (ligneSelected.isVertical()) {
					switch (plan.getEltBatToInsert()) {
					case Plan.PORTE: {
						nvlEltP = Porte.PorteVerticale("PORTE_1",
								ligneSelected.getPosition().x,
								(int) event.getY(), 0);
						nvlEltP.setMeterThickness(nvlEltP.getPixelsThickness()
								/ Plan.getScale());
						nvlEltP.setMeterLength(nvlEltP.getPixelsLength()
								/ Plan.getScale());
 
						command = new AddCommand(ligneSelected, nvlEltP);
						CommandManager.getInstance().execute(command);
 
						// ligneSelected.add(nvlEltP);
						selectedDoor = nvlEltP;
						break;
					}
					}
				} else {
					switch (plan.getEltBatToInsert()) {
					case Plan.PORTE: {
						nvlEltP = Porte.PorteHorizontale("PORTE_2",
								(int) event.getX(),
								ligneSelected.getPosition().y, 0);
						nvlEltP.setMeterLength(nvlEltP.getPixelsThickness()
								/ Plan.getScale());
						nvlEltP.setMeterThickness(nvlEltP.getPixelsLength()
								/ Plan.getScale());
 
						command = new AddCommand(ligneSelected, nvlEltP);
						CommandManager.getInstance().execute(command);
 
						ligneSelected.add(nvlEltP);
						selectedDoor = nvlEltP;
						break;
					}
					}
				}
 
			}
		} else {
			if (ligneSelected.isVertical()) {
				if (selection == SELECT_DOOR)
					selectedDoor = ligneSelected.getPorteAt(
							ligneSelected.getPosition().x, (int) event.getY());
			} else {
				if (selection == SELECT_DOOR)
					selectedDoor = ligneSelected.getPorteAt((int) event.getX(),
							ligneSelected.getPosition().y);
			}
		}
		plan.invalidate();
	}
 
	private void onTouchMove(MotionEvent event) {
 
		if (selectedDoor != null) {
			if (ligneSelected.isVertical())
				selectedDoor
						.setPosition(selectedDoor.getPosition().x, (int) (event
								.getY() - selectedDoor.getPixelsLength() / 2));
			else
				selectedDoor
						.setPosition((int) (event.getX() - selectedDoor
								.getPixelsThickness() / 2), selectedDoor
								.getPosition().y);
		}
 
		plan.invalidate();
 
	}
 
	private void onTouchUp(MotionEvent event) {
 
	}
 
	public void reinitialize() {
		setSelectedLigne(null);
		setSelectedPorte(null);
	}
 
	public void setSelectedLigne(Ligne l) {
		ligneSelected = l;
	}
 
	public void setSelectedPorte(Porte porte) {
		selectedDoor = porte;
	}
 
	public void setSelection(int selection) {
		this.selection = selection;
	}
}

Je n'arrive donc pas à ajouter une porte sur mon mur et donc l'ajouter dans ma pile afin de pouvoir utiliser par la suite mon bouton undo

J'ai changer quelque truc dans mon code qui me permettent maintenant d'ajouter ma porte sur ma ligne, voici mon code :
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 public class AddCommand implements Command { private Plan plan; private Ligne ligne; private Porte porte; private EltPlan elt; AddCommand(Plan p, Ligne l) { this.plan = p; this.ligne = l; } AddCommand(Ligne l, Porte p) { this.ligne = l; this.porte = p; } public AddCommand(Ligne ligneSelected, EltPlan elt) { this.ligne = ligneSelected; this.setElt(elt); } public void execute() { if ((ligne != null)) { if (porte != null) { this.ligne.add(this.porte); } else { this.plan.add(this.ligne); plan.invalidate(); } } } @Override public void undo() { if (ligne != null) { if (porte != null) { this.ligne.remove(this.porte); //plan.invalidate(); } else { this.plan.remove(this.ligne); plan.invalidate(); } } } public EltPlan getElt() { return elt; } public void setElt(EltPlan elt) { this.elt = elt; } }
avant lorsque je faisais un redo mais que je n'indiquer pas plan.invalidate(); on ne voyais rien sur l’écran changer, maintenant on voit bien la suppression de la ligne j'ai voulu ajouter cela pour ma porte mais il m'indique une erreur lorsque je l'ajoute j'ai l'impression que tout est bon mais qu'il faudrait un truc pour rafraîchir le plan ou la ligne pour voir la suppression de la porte

21/01/2015, 10h57
kolodz
Code:

1 2 3 4 5 6 if (porte != null) { this.ligne.add(this.porte); } else { this.plan.add(this.ligne); plan.invalidate(); }
Si j'ai bien compris ton invalidate() déclenche la mise à jour de ce que tu affiche.
Comment est mise à jour la ligne dans ce cas là ? Doit-elle faire ligne.getPlan().invalidate() ?

De manière général, quand tu as une vue qui affiche/représent le modèle pour l'utilisateur. Il est intéressant d'avoir un mécanisme pour invalider l'ensemble de la vue. Ainsi, avoir une mise à jour propre par rapport au modèle. (Particulièrement dans ces cas de débug.)

Cordialement,
Patrick Kolodziejczyk.

Oui, exactement lorsque j'enleve plan.invalidate() et que j'appuie sur undo à l'écran rien ne ce passe ma ligne est toujours présente alors que j'affiche dans ma console qu'il y a un element dans ma pile. Justement je ne sais pas comment faire pour mettre à jour ma ligne, j'ai essayer comme vous m'avez indiqué mais il ne le reconnait pas. Je vous aurait bien envoyé mon projet pour que vous puissiez voir par vous même mais il est trop gros pour une pièce jointe.

J'ai donc defini une variable plan dans ma classe ligne et j'ai donc ajouté comme vous me l'avez dit : ligne.getPlan().invalidate() mais çà ne marche pas et lorsque j'appuie sur undo j'ai ce message dans la console :
Code:

1 2 3 4 5 6 7 01-21 11:04:55.471: E/AndroidRuntime(12644): FATAL EXCEPTION: main 01-21 11:04:55.471: E/AndroidRuntime(12644): java.lang.NullPointerException 01-21 11:04:55.471: E/AndroidRuntime(12644): at com.example.ligne.indoor.AddCommand.undo(AddCommand.java:43) 01-21 11:04:55.471: E/AndroidRuntime(12644): at com.example.ligne.indoor.CommandManager.performUndo(CommandManager.java:64) 01-21 11:04:55.471: E/AndroidRuntime(12644): at com.example.ligne.indoor.CommandManager.undo(CommandManager.java:20) 01-21 11:04:55.471: E/AndroidRuntime(12644): at com.example.ligne.IndoorActivity.onClick(IndoorActivity.java:489)

21/01/2015, 11h16
lass7

3 pièce(s) jointe(s)

Pièce jointe 166839 Pièce jointe 166840 Pièce jointe 166841
21/01/2015, 11h18
kolodz

L'erreur est dû au fait que votre ligne n'a pas de plan associé.

Il est très probable que quand vous ajoutez votre ligne à votre plan. Vous ne référencez pas le plan dans votre ligne :

Code:

this.plan.add(this.ligne);

Par exemple :

Code:

this.ligne.setContainer(this.plan);

Ce qui te permet d'invalider ce qui contient ta ligne :

Code:

this.ligne.getContainer().invalidate();

Note :
Tu aurai dû crée deux commandes distincte l'une ajoutant une Porte à une Ligne et l'autre une Ligne à un Plan. (Les deux héritant de le la même classe.)
Ou avoir une commande plus générique avec :

Code:

AddCommand(Elt contenant, Elt Contenu)

Avec Plan/Ligne/Porte héritant de Elt.

Et fait la fonction qui met à jour tout. Tu verra que c'est utile.

Cordialement,
Patrick Kolodziejczyk.
21/01/2015, 11h26
lass7
D'accord donc pour vous je devrais revoir un peu ma conception et comment je pourrais le faire ?
setContainer je le fait ou ?
Je declarer une variable container dans ligne avec Plan en parametre ?
Et container est de quel type ?
Dans ma classe Addcommand qu'est ce que je dois changer ?

Dans mon cas la classe Porte herite de EltPlan et Ligne herite de EltPlan

Et du coup tu me dis de faire de méthode car pour le moment je n'ai que celle là ?
Code:

1 2 3 4 5 public AddCommand(Ligne ligneSelected, EltPlan elt) { this.ligne = ligneSelected; this.setElt(elt); }
il faudrait :
Code:

1 2 3 4 5 public AddCommand(Porte porteSelected, Ligne ligneSelected){ this.porte = porteSelected; this.setLigne(porteSelected); }
Je vous remercie de votre réponse
21/01/2015, 11h43
kolodz
Votre container doit-être au niveau de votre EltPlan.
Cependant, celui-ci doit-être soit un EltPlan soit un Plan. Ce qui implique une classe parent entre les deux. Si plan n'est pas déjà un EltPlan.

Il n'y a rien à ajouter dans votre classe AddCommand.
Le mieux serai de revoir votre méthode add(EltPlan element). Celle-ci devrait :
1. Vérifier si votre élément n'est pas déjà dans un autre container. (Si c'est le cas agir en conséquence erreur, ou l’enlever de l'ancien container.)
2. Ajouter l’élément au container.
3. Indiquer à l'élément qui le contient via le setContainer.
Ainsi, lorsque que vous manipulez un élément, vous êtes toujours en mesure de retrouver son container. Et donc l'invalider si nécessaire.

Vous devriez regarder comment cela est fait dans Swing. Car, c'est exactement les mêmes concepts qui sont utilisés. Il y a la même problématique de parcours arborescence, d'invalidation des composants(repaint.), de transmissions d’événement (Comment savoir si vous avez cliqué sur tel ou tel composant ?)

Cordialement,
Patrick Kolodziejczyk.

Je vous remercie de votre réponse, j'ai fait cela est tout marche :

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
 
public class AddCommand implements Command {
 
	private Plan plan;
	private Ligne ligne;
	private Porte porte;
	private EltPlan elt;
 
	AddCommand(Plan p, Ligne l) {
		this.plan = p;
		this.ligne = l;
	}
 
	AddCommand(Ligne l, Porte p) {
		this.ligne = l;
		this.porte = p;
	}
 
	public AddCommand(Ligne ligneSelected, EltPlan elt) {
		this.ligne = ligneSelected;
		this.setElt(elt);
	}
 
 
	public void execute() {
		if ((ligne != null)) {
			if (porte != null) {
				this.ligne.add(this.porte);
				this.ligne.getPlan().invalidate();
			} else {
				this.ligne.setPlan(this.plan);
				this.plan.add(this.ligne);
				plan.invalidate();
			}
		}
 
	}
 
	@Override
	public void undo() {
		if (ligne != null) {
			if (porte != null) {
				this.ligne.remove(this.porte);
				this.ligne.getPlan().invalidate();
			} else {
				this.plan.remove(this.ligne);
				plan.invalidate();
			}
 
		}
	}
 
	public EltPlan getElt() {
		return elt;
	}
 
	public void setElt(EltPlan elt) {
		this.elt = elt;
	}
 
	public Plan getPlan() {
		return plan;
	}
 
	public void setPlan(Plan plan) {
		this.plan = plan;
	}
 
	public Ligne getLigne() {
		return ligne;
	}
 
	public void setLigne(Ligne ligne) {
		this.ligne = ligne;
	}
 
	public Porte getPorte() {
		return porte;
	}
 
	public void setPorte(Porte porte) {
		this.porte = porte;
	}
}

Merci encore