1: package ste.pendu.wordeditor;
3: import java.io.Serializable;
4: import java.io.IOException;
5: import java.util.Iterator;
6: import java.beans.PropertyChangeListener;
7: import java.util.List;
9: /**
10: * Panier de mots pour jouer au Pendu.
11: *
12: * <p>Cette interface défini la manière d'implémenter un WordListBean
13: * (le bean (visuel) devra étendre javax.swing.JPanel). La fabrique de
14: * contrôleurs attendra comme information cette interface pour pouvoir
15: * construire un contrôleur.</p>
16: *
17: * <p>Les classes implémentant cette interface contiendront un ensemble
18: * de mots que le PenduBean pourrait appeler pour jouer. La classe devra
19: * aussi être capable de récupérer les données qui auront été
20: * sauvegardées sur un disque soit sous forme d'un fichier texte
21: * (extension .txt), soit sous forme d'une instance sérialisée
22: * (extension .ser).</p>
23: *
24: * <p>Attention, il n'y a pas de doublon!</p>
25: *
26: * @see java.beans.PropertyChangeSupport
27: * @see java.util.List
28: * @see java.io.Serializable
29: */
30: public interface WordListModel extends Serializable
31: {
33: /**
34: * Ajout d'un mot à une position précise.
35: *
36: * @param index la position
37: * @param mot le mot à ajouter
38: */
39: public void addWord(int index, String mot);
41: /**
42: * Ajout d'un mot à la suite.
43: *
44: * @param mot le mot à ajouter
45: * @return <code>true</code> comme le demande l'API Collection
46: * @see java.util.List#add(Object)
47: */
48: public boolean addWord(String mot);
50: /**
51: * Efface tous les mots en mémoire.
52: */
53: public void clear();
55: /**
56: * Retourne le nombre de mots.
57: *
58: * @return le nombre de mots
59: */
60: public int getWordListSize();
62: /**
63: * Retourne un tableau de tous les mots.
64: *
65: * @return un tableau contenant tous les mots
66: */
67: public String[] getWords();
69: /**
70: * Retourne le mot à la position indiquée.
71: *
72: * @param index la position du mot recherché
73: * @return le mot à la position 'index'
74: */
75: public String getWord(int index);
77: /**
78: * Retourne l'index du mot passé en argument.
79: *
80: * @param mot
81: * @return l'index du mot recherché
82: */
83: public int indexOfWord(String mot);
85: /**
86: * État de sauvegarde des mots.
87: *
88: * @return s'il n'y a eu aucune modification depuis la dernière
89: * sauvegarde, la valeur retournée est <code>true</code>, mais s'il y
90: * a eu une modification, la valeur retournée est <code>false</code>
91: */
92: public boolean isSaved();
94: /**
95: * Un iterateur sur tous les mots.
96: *
97: * @return l'itérateur avec tous les mots
98: * @see java.util.Iterator
99: */
100: public Iterator iterator();
102: /**
103: * Retire le mot à l'index.
104: *
105: * @param index index du mot à retirer
106: * @return le mot qui a été supprimé
107: */
108: public String removeWord(int index);
110: /**
111: * Retire le mot.
112: *
113: * @param mot le mot à supprimer
114: * @return <code>true</code> si le mot a bien été supprimé,
115: * <code>false</code> si le mot n'était pas dans la liste
116: */
117: public boolean removeWord(String mot);
119: /**
120: * Mise à jour du nom du fichier. Cette méthode force le chargement
121: * des mots qui sont dans le fichier. La méthode pour lire le fichier
122: * sera déterminée en fonction de l'extension du nom de fichier (idem
123: * dans la methode {@link #saveAs(String)}).
124: *
125: * @param fichier le nom du fichier
126: * @exception IOException Exception des entrées/sorties. Par exemple
127: * si le fichier n'est pas trouvé, illisible, ou s'il n'a pas le bon
128: * format!
129: *
130: * <p><b>Un mot sur le format du fichier contenant les mots du Pendu</b></p>
131: *
132: * <ul><li><b>Fichier texte:</b> il contient un mot par ligne;</li>
133: * <li><b>Fichier sérialisé:</b> il s'agit d'une instance de
134: * WordListModel. Au moment du chargement, il faudra donc lire tous les
135: * mots de cette instance et les ajouter à l'instance courante.</li>
136: * </ul>
137: *
138: * @exception IOException si un problème a eu lieu lors de la lecture
139: * du fichier
140: */
141: public void setFileName(String fichier)
142: throws IOException;
144: /**
145: * Récupère le nom du fichier.
146: *
147: * @return le nom du fichier
148: */
149: public String getFileName();
151: /**
152: * Sauvegarde dans le même fichier.
153: *
154: * @exception IOException Exception des entrées/sorties.
155: */
156: public void save()
157: throws IOException;
159: /**
160: * Sauvegarde dans un autre fichier. La méthode pour enregistrer le
161: * fichier sera déterminée en fonction de l'extention (idem dans la
162: * methode {@link #setFileName(String)}).
163: *
164: * @param fichier le nouveau nom de fichier
165: * @exception IOException Exception des entrées/sorties.
166: */
167: public void saveAs(String fichier)
168: throws IOException;
170: /**
171: * Ajoute un écouteur des changements de propriété.
172: *
173: * @param ecouteur l'écouteur des propriétés
174: */
175: public void addPropertyChangeListener(PropertyChangeListener ecouteur);
177: /**
178: * Ajoute un écouteur des changements de propriété.
179: *
180: * @param nom le nom de la propriété à écouter
181: * @param ecouteur l'écouteur des propriétés
182: */
183: public void addPropertyChangeListener(String nom,
184: PropertyChangeListener ecouteur);
185:
186: /**
187: * Retourne les écouteurs de propriété.
188: *
189: * @return les écouteurs
190: */
191: public PropertyChangeListener[] getPropertyChangeListeners();
192:
193: /**
194: * Retourne les écouteurs telle propriété.
195: *
196: * @param nom le nom de la propriété dont on veut récupérer l'écouteur
197: * @return les écouteurs
198: */
199: public PropertyChangeListener[] getPropertyChangeListeners(String nom);
201: /**
202: * Supprimer l'écouteur
203: *
204: * @param ecouteur l'écouteur à supprimer
205: */
206: public void removePropertyChangeListener(PropertyChangeListener ecouteur);
208: /**
209: * Supprimer l'écouteur
210: *
211: * @param nom nom de la propriété
212: * @param ecouteur l'écouteur à supprimer
213: */
214: public void removePropertyChangeListener(String nom, PropertyChangeListener ecouteur);
215:
217: }