Subversion Repositories eFlore/Applications.coel

Compare Revisions

Ignore whitespace Rev 933 → Rev 934

/trunk/src/org/tela_botanica/client/composants/ChampMultiValeursImage.java
4,7 → 4,7
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.vues.ContenuVue;
import org.tela_botanica.client.vues.collection.ContenuVue;
 
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.SelectionListener;
/trunk/src/org/tela_botanica/client/Mediateur.java
37,10 → 37,6
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.vues.CollectionForm;
import org.tela_botanica.client.vues.CollectionListeVue;
import org.tela_botanica.client.vues.CollectionVue;
import org.tela_botanica.client.vues.ContenuVue;
import org.tela_botanica.client.vues.EnteteVue;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.PersonneForm;
55,6 → 51,10
import org.tela_botanica.client.vues.StructureVue;
import org.tela_botanica.client.vues.MenuVue;
import org.tela_botanica.client.vues.accueil.AccueilVue;
import org.tela_botanica.client.vues.collection.CollectionForm;
import org.tela_botanica.client.vues.collection.CollectionListeVue;
import org.tela_botanica.client.vues.collection.CollectionVue;
import org.tela_botanica.client.vues.collection.ContenuVue;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.LayoutRegion;
/trunk/src/org/tela_botanica/client/vues/CollectionFormPublication.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionListeVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionFormGeneral.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionFormPersonne.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionDetailVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionFormInventaire.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/CollectionFormContenu.java
File deleted
/trunk/src/org/tela_botanica/client/vues/CollectionVue.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/CollectionForm.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/DetailVue.java
File deleted
\ No newline at end of file
/trunk/src/org/tela_botanica/client/vues/CollectionFormDescription.java
File deleted
/trunk/src/org/tela_botanica/client/vues/ContenuVue.java
File deleted
/trunk/src/org/tela_botanica/client/vues/PersonneForm.java
24,8 → 24,6
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.util.Pattern;
33,7 → 31,6
 
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.HorizontalAlignment;
import com.extjs.gxt.ui.client.Style.IconAlign;
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.Style.VerticalAlignment;
60,7 → 57,6
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.DateField;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.LabelField;
import com.extjs.gxt.ui.client.widget.form.Radio;
import com.extjs.gxt.ui.client.widget.form.RadioGroup;
70,13 → 66,11
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.layout.ColumnData;
import com.extjs.gxt.ui.client.widget.layout.ColumnLayout;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.layout.RowLayout;
import com.extjs.gxt.ui.client.widget.layout.TableData;
import com.extjs.gxt.ui.client.widget.layout.TableLayout;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.user.client.Window;
999,9 → 993,7
public void reinitialiserFormulaire() {
mediateur.afficherPopinChargement();
mettreAJourPersonne(personneSauvegarde);
mediateur.masquerPopinChargement();
}
1163,29 → 1155,7
return strValeur;
}
 
@Override
protected SelectionListener<ButtonEvent> creerEcouteurValidation() {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
soumettreFormulaire();
clicBoutonvalidation = true;
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
mediateur.clicMenu(menuIdCourant);
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
reinitialiserFormulaire();
}
}
};
return ecouteur;
}
 
protected boolean soumettreFormulaire() {
public boolean soumettreFormulaire() {
if (verifierFormulaire()) {
mediateur.enregistrerPersonne(this, personneSelectionnee);
}
1192,7 → 1162,7
return true;
}
 
protected boolean verifierFormulaire() {
public boolean verifierFormulaire() {
boolean success = true;
LinkedList<String> lstMessageErreur = new LinkedList<String>();
/trunk/src/org/tela_botanica/client/vues/StructureForm.java
6,7 → 6,6
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.configuration.Configuration;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
31,7 → 30,6
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.GridEvent;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
238,32 → 236,15
return ongletsStructure;
}
protected SelectionListener<ButtonEvent> creerEcouteurValidation() {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
soumettreFormulaire();
clicBoutonvalidation = true;
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
mediateur.clicMenu(menuIdCourant);
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
if (mode.equals(StructureForm.MODE_MODIFIER)) {
mediateur.afficherFormStructure(identification.getId());
} else {
mediateur.afficherFormStructure(null);
}
}
}
};
return ecouteur;
public void reinitialiserFormulaire() {
if (mode.equals(StructureForm.MODE_MODIFIER)) {
mediateur.afficherFormStructure(identification.getId());
} else {
mediateur.afficherFormStructure(null);
}
}
protected boolean soumettreFormulaire() {
public boolean soumettreFormulaire() {
// Vérification de la validité des champs du formulaire
boolean fomulaireValide = verifierFormulaire();
if (fomulaireValide) {
308,7 → 289,7
return fomulaireValide;
}
protected boolean verifierFormulaire() {
public boolean verifierFormulaire() {
ArrayList<String> messages = new ArrayList<String>();
// Vérification des infos sur le nom de la structure
1776,7 → 1757,7
return identifiants;
}
protected void afficherChampSupplementaire(Radio radioBtn) {
public void afficherChampSupplementaire(Radio radioBtn) {
//GWT.log("Nom btn : "+radioBtn.getName()+" - Nom group : "+radioBtn.getGroup().getName(), null);
// Valeur du bouton radio déclenchant l'affichage des composants cachés
String valeurPourAfficher = "oui";
/trunk/src/org/tela_botanica/client/vues/ProjetForm.java
16,12 → 16,9
import org.tela_botanica.client.util.UtilString;
 
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.CheckBox;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
395,7 → 392,7
return formulaireValideOk;
}
protected boolean verifierFormulaire() {
public boolean verifierFormulaire() {
boolean valide = true;
ArrayList<String> messages = new ArrayList<String>();
523,7 → 520,7
return projetARetourner;
}
protected void reinitialiserFormulaire() {
public void reinitialiserFormulaire() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.afficherFormProjet(projet.getId());
} else {
530,27 → 527,5
mediateur.afficherFormProjet(null);
}
}
@Override
protected SelectionListener<ButtonEvent> creerEcouteurValidation() {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
soumettreFormulaire();
clicBoutonvalidation = true;
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
mediateur.clicMenu(menuIdCourant);
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
reinitialiserFormulaire();
}
}
};
return ecouteur;
}
 
}
/trunk/src/org/tela_botanica/client/vues/PersonneDetailVue.java
15,6 → 15,7
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.vues.collection.DetailVue;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.Scroll;
/trunk/src/org/tela_botanica/client/vues/PublicationForm.java
14,7 → 14,6
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.PublicationAPersonne;
import org.tela_botanica.client.modeles.PublicationAPersonneListe;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.util.Pattern;
534,7 → 533,7
}
}
protected boolean verifierFormulaire() {
public boolean verifierFormulaire() {
boolean valide = true;
ArrayList<String> messages = new ArrayList<String>();
659,7 → 658,7
return publicationARetourner;
}
protected void reinitialiserFormulaire() {
public void reinitialiserFormulaire() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.afficherFormPublication(publication.getId());
} else {
682,27 → 681,4
return "";
}
}
@Override
protected SelectionListener<ButtonEvent> creerEcouteurValidation() {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
soumettreFormulaire();
clicBoutonvalidation = true;
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
mediateur.clicMenu(menuIdCourant);
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
reinitialiserFormulaire();
}
}
};
return ecouteur;
}
}
/trunk/src/org/tela_botanica/client/vues/StructureDetailVue.java
15,6 → 15,7
import org.tela_botanica.client.modeles.StructureConservation;
import org.tela_botanica.client.modeles.StructureValorisation;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.collection.DetailVue;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.util.Format;
/trunk/src/org/tela_botanica/client/vues/Formulaire.java
27,6 → 27,7
import com.extjs.gxt.ui.client.widget.Slider;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.TabPanel;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.CheckBox;
import com.extjs.gxt.ui.client.widget.form.CheckBoxGroup;
49,19 → 50,19
public static final String MODE_AJOUTER = "AJOUT";
public static final String MODE_MODIFIER = "MODIF";
protected Constantes i18nC = null;
protected Mediateur mediateur = null;
protected Configuration config = null;
public Constantes i18nC = null;
public Mediateur mediateur = null;
public Configuration config = null;
protected String mode = null;
protected int tabIndex = 100;
public String mode = null;
public int tabIndex = 100;
protected FormPanel panneauFormulaire = null;
protected ButtonBar barreOutilsValidation = null;
public FormPanel panneauFormulaire = null;
public ButtonBar barreOutilsValidation = null;
protected String menuIdCourant = null;
protected static Boolean clicBoutonvalidation = false;
protected Rafraichissable vueExterneARafraichirApresValidation = null;
public String menuIdCourant = null;
public static Boolean clicBoutonvalidation = false;
public Rafraichissable vueExterneARafraichirApresValidation = null;
 
public FormPanel getFormulaire() {
return panneauFormulaire;
99,13 → 100,34
add(panneauFormulaire);
}
protected abstract SelectionListener<ButtonEvent> creerEcouteurValidation();
public SelectionListener<ButtonEvent> creerEcouteurValidation() {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
soumettreFormulaire();
clicBoutonvalidation = true;
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
mediateur.clicMenu(menuIdCourant);
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
reinitialiserFormulaire();
}
}
};
return ecouteur;
}
protected abstract boolean verifierFormulaire();
public abstract boolean verifierFormulaire();
protected abstract boolean soumettreFormulaire();
public abstract boolean soumettreFormulaire();
protected TabItem creerOnglet(String nom, String id) {
public abstract void reinitialiserFormulaire();
public TabItem creerOnglet(String nom, String id) {
TabItem onglet = new TabItem();
onglet.setId(id);
onglet.setText(nom);
113,7 → 135,7
return onglet;
}
 
protected void controlerFermetureApresRafraichissement() {
public void controlerFermetureApresRafraichissement() {
// Si le bouton Valider a été cliqué, nous affichons la liste des structures
if (clicBoutonvalidation) {
fermerFormulaire();
120,7 → 142,7
}
}
protected void fermerFormulaire() {
public void fermerFormulaire() {
clicBoutonvalidation = false;
panneauFormulaire.setEnabled(false);
mediateur.clicMenu(menuIdCourant);
149,7 → 171,7
* @param listeNom nom de la liste de valeur
* @return
*/
protected RadioGroup creerChoixUniqueRadioGroupe(String groupeNom, String listeNom) {
public RadioGroup creerChoixUniqueRadioGroupe(String groupeNom, String listeNom) {
groupeNom += "_grp";
// NOTE : il semblerait qu'il faille aussi utiliser setName() pour éviter tout problème...
RadioGroup radioGroup = new RadioGroup(groupeNom);
165,7 → 187,7
return radioGroup;
}
protected void creerChoixUniqueBoutonRadio(RadioGroup radioGroupe, ValeurListe listeValeurs) {
public void creerChoixUniqueBoutonRadio(RadioGroup radioGroupe, ValeurListe listeValeurs) {
for (Iterator<String> it = listeValeurs.keySet().iterator(); it.hasNext();) {
Valeur val = listeValeurs.get(it.next());
190,7 → 212,7
}
}
protected void afficherChampSupplementaire(Radio radioBtn) {
public void afficherChampSupplementaire(Radio radioBtn) {
GWT.log("Vous devez redéfinir la méthode afficherChampSupplementaire(Radio radioBtn) dans votre classe formulaire.", null);
};
/trunk/src/org/tela_botanica/client/vues/ProjetDetailVue.java
7,6 → 7,7
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.collection.DetailVue;
 
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormGeneral.java
New file
0,0 → 1,419
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.composants.ChampMultiValeurs;
import org.tela_botanica.client.composants.ConteneurMultiChamps;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireOnglet;
 
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.HiddenField;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.HBoxLayoutData;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.NumberFormat;
 
public class CollectionFormGeneral extends FormulaireOnglet implements Rafraichissable {
private Collection collection = null;
private Collection collectionCollectee = null;
 
private HiddenField<String> idCollectionChp;
private ComboBox<Projet> projetsCombo = null;
private ComboBox<Structure> structuresCombo = null;
private ComboBox<Collection> collectionsCombo = null;
private ChampComboBoxListeValeurs groupementPrincipeCombo;
private ChampMultiValeurs lieuCouvertureChp = null;
 
private ChampComboBoxListeValeurs specimenTypeCombo = null;
private ChampComboBoxListeValeurs precisionTypeNbreCombo = null;
private NumberField nbreTypeChp = null;
private ChampComboBoxListeValeurs classementSpecimenTypeCombo;
private ChampComboBoxListeValeurs typeDepotCombo = null;
private TextField<String> coteChp = null;
private ChampMultiValeurs idAlternatifsChp = null;
private ChampMultiValeurs nomsAlternatifsChp = null;
private ChampMultiValeurs codesAlternatifsChp = null;
private TextArea descriptionSpecialisteChp = null;
private TextArea descriptionChp = null;
private TextArea historiqueChp = null;
private ChampMultiValeurs urlsChp = null;
 
private ChampComboBoxListeValeurs butRealisationCombo = null;
public CollectionFormGeneral(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("general");
setText(Mediateur.i18nC.collectionGeneral());
creerChampsCache();
creerFieldsetLiaison();
creerFieldsetAdministratif();
creerFieldsetDescription();
creerFieldsetCouverture();
creerFieldsetType();
}
 
private void initialiserCollection() {
collection = ((CollectionForm) formulaire).collection;
collectionCollectee = ((CollectionForm) formulaire).collectionCollectee;
}
private void creerChampsCache() {
// Champs cachés
idCollectionChp = new HiddenField<String>();
this.add(idCollectionChp);
}
private void creerFieldsetLiaison() {
FieldSet liaisonFieldSet = new FieldSet();
liaisonFieldSet.setHeading(i18nC.liaisonTitreCollection());
liaisonFieldSet.setCollapsible(true);
liaisonFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
projetsCombo = new ComboBox<Projet>();
projetsCombo.setTabIndex(tabIndex++);
projetsCombo.setFieldLabel(i18nC.projetChamp());
projetsCombo.setDisplayField("nom");
projetsCombo.setForceSelection(true);
projetsCombo.setValidator(new Validator() {
@Override
public String validate(Field<?> field, String value) {
String retour = null;
if (field.getRawValue().equals("")) {
field.setValue(null);
} else if (projetsCombo.getStore().findModel("nom", field.getRawValue()) == null) {
String contenuBrut = field.getRawValue();
field.setValue(null);
field.setRawValue(contenuBrut);
retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
}
return retour;
}
});
projetsCombo.setTriggerAction(TriggerAction.ALL);
projetsCombo.setStore(new ListStore<Projet>());
liaisonFieldSet.add(projetsCombo, new FormData(450, 0));
mediateur.selectionnerProjet(this, null);
structuresCombo = new ComboBox<Structure>();
structuresCombo.setTabIndex(tabIndex++);
structuresCombo.setFieldLabel(i18nC.lienStructureCollection());
structuresCombo.setDisplayField("nom");
structuresCombo.setForceSelection(true);
structuresCombo.setValidator(new Validator() {
@Override
public String validate(Field<?> field, String value) {
String retour = null;
if (field.getRawValue().equals("")) {
field.setValue(null);
} else if (structuresCombo.getStore().findModel("nom", field.getRawValue()) == null) {
String contenuBrut = field.getRawValue();
field.setValue(null);
field.setRawValue(contenuBrut);
retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
}
return retour;
}
});
structuresCombo.setTriggerAction(TriggerAction.ALL);
structuresCombo.setStore(new ListStore<Structure>());
liaisonFieldSet.add(structuresCombo, new FormData(450, 0));
mediateur.selectionnerStructureParProjet(this, null);
collectionsCombo = new ComboBox<Collection>();
collectionsCombo.setTabIndex(tabIndex++);
collectionsCombo.setFieldLabel(i18nC.lienMereCollection());
collectionsCombo.setDisplayField("nom");
collectionsCombo.setForceSelection(true);
collectionsCombo.setValidator(new Validator() {
@Override
public String validate(Field<?> field, String value) {
String retour = null;
if (field.getRawValue().equals("")) {
field.setValue(null);
} else if (collectionsCombo.getStore().findModel("nom", field.getRawValue()) == null) {
String contenuBrut = field.getRawValue();
field.setValue(null);
field.setRawValue(contenuBrut);
retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
}
GWT.log("Validation : "+field.getRawValue()+"-"+field.getValue(), null);
return retour;
}
});
collectionsCombo.setTriggerAction(TriggerAction.ALL);
collectionsCombo.setStore(new ListStore<Collection>());
liaisonFieldSet.add(collectionsCombo, new FormData(450, 0));
mediateur.selectionnerCollectionParProjet(this, null);
this.add(liaisonFieldSet);
}
private void creerFieldsetAdministratif() {
// Fieldset ADMINISTRATIF
FieldSet administratifFieldSet = new FieldSet();
administratifFieldSet.setHeading(i18nC.collectionGeneralTitre());
administratifFieldSet.setCollapsible(true);
administratifFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
typeDepotCombo = new ChampComboBoxListeValeurs(i18nC.typeDepot(), "typeDepot", tabIndex++);
administratifFieldSet.add(typeDepotCombo);
coteChp = new TextField<String>();
coteChp.setTabIndex(tabIndex++);
coteChp.setFieldLabel(i18nC.cote());
administratifFieldSet.add(coteChp, new FormData(450, 0));
idAlternatifsChp = new ChampMultiValeurs(i18nC.idAlternatifCollection());
administratifFieldSet.add(idAlternatifsChp);
nomsAlternatifsChp = new ChampMultiValeurs(i18nC.intituleAlternatifCollection());
administratifFieldSet.add(nomsAlternatifsChp);
codesAlternatifsChp = new ChampMultiValeurs(i18nC.codeAlternatifCollection());
administratifFieldSet.add(codesAlternatifsChp);
this.add(administratifFieldSet);
}
private void creerFieldsetDescription() {
// Fieldset DESCRIPTION
FieldSet descriptionFieldSet = new FieldSet();
descriptionFieldSet.setHeading(i18nC.collectionDescriptionTitre());
descriptionFieldSet.setCollapsible(true);
descriptionFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
 
descriptionChp = new TextArea();
descriptionChp.setFieldLabel(i18nC.description());
descriptionFieldSet.add(descriptionChp, new FormData(550, 0));
descriptionSpecialisteChp = new TextArea();
descriptionSpecialisteChp.setFieldLabel(i18nC.descriptionSpecialiste());
descriptionFieldSet.add(descriptionSpecialisteChp, new FormData(550, 0));
historiqueChp = new TextArea();
historiqueChp.setFieldLabel(i18nC.historique());
descriptionFieldSet.add(historiqueChp, new FormData(550, 0));
urlsChp = new ChampMultiValeurs(i18nC.urlsCollection());
descriptionFieldSet.add(urlsChp);
 
this.add(descriptionFieldSet);
}
private void creerFieldsetCouverture() {
FieldSet couvertureFieldSet = new FieldSet();
couvertureFieldSet.setHeading("Couvertures");
couvertureFieldSet.setCollapsible(true);
couvertureFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
groupementPrincipeCombo = new ChampComboBoxListeValeurs(i18nC.groupementPrincipeCollection(), "groupementPrincipe", tabIndex++);
groupementPrincipeCombo.setToolTip(i18nC.groupementPrincipeCollectionInfo());
couvertureFieldSet.add(groupementPrincipeCombo);
butRealisationCombo = new ChampComboBoxListeValeurs(i18nC.butCollection(), "realisationBut", tabIndex++);
couvertureFieldSet.add(butRealisationCombo);
lieuCouvertureChp = new ChampMultiValeurs(i18nC.lieuCouvertureCollection());
couvertureFieldSet.add(lieuCouvertureChp);
this.add(couvertureFieldSet);
}
private void creerFieldsetType() {
FieldSet typeFieldSet = new FieldSet();
typeFieldSet.setHeading("Spécimens «types»");
typeFieldSet.setCollapsible(true);
typeFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
specimenTypeCombo = new ChampComboBoxListeValeurs(i18nC.specimenTypeCollection(), "onpi", tabIndex++);
typeFieldSet.add(specimenTypeCombo);
ConteneurMultiChamps nbreTypeConteneur = new ConteneurMultiChamps(i18nC.nbreSpecimenTypeCollection());
nbreTypeChp = new NumberField();
nbreTypeChp.setFormat(NumberFormat.getFormat("#"));
nbreTypeConteneur.ajouterChamp(nbreTypeChp, new HBoxLayoutData(new Margins(0, 20, 0, 0)));
precisionTypeNbreCombo = new ChampComboBoxListeValeurs(null, "ea");
precisionTypeNbreCombo.setTrie("id_valeur");
precisionTypeNbreCombo.setEmptyText(i18nC.precisionNbreSpecimenTypeCollectionChpVide());
nbreTypeConteneur.ajouterChamp(precisionTypeNbreCombo);
typeFieldSet.add(nbreTypeConteneur);
classementSpecimenTypeCombo = new ChampComboBoxListeValeurs(i18nC.classementSpecimenTypeCollection(), "typeClassement", tabIndex++);
typeFieldSet.add(classementSpecimenTypeCombo);
Text infoType = new Text(i18nC.specimenTypeCollectionInfo());
typeFieldSet.add(infoType);
this.add(typeFieldSet);
}
public void peupler() {
initialiserCollection();
if (collection != null) {
idCollectionChp.setValue(collection.getId());
setValeurComboProjets();
setValeurComboStructures();
setValeurComboCollections();
typeDepotCombo.peupler(collection.getTypeDepot());
coteChp.setValue(collection.getCote());
idAlternatifsChp.peupler(collection.getIdAlternatif());
nomsAlternatifsChp.peupler(collection.getNomAlternatif());
codesAlternatifsChp.peupler(collection.getCode());
descriptionChp.setValue(collection.getDescription());
descriptionSpecialisteChp.setValue(collection.getDescriptionSpecialiste());
historiqueChp.setValue(collection.getHistorique());
urlsChp.peupler(collection.getUrls());
groupementPrincipeCombo.peupler(collection.getGroupementPrincipe());
butRealisationCombo.peupler(collection.getGroupementBut());
lieuCouvertureChp.peupler(collection.getCouvertureLieu());
specimenTypeCombo.peupler(collection.getSpecimenType());
nbreTypeChp.setValue((collection.getSpecimenTypeNbre().equals("") ? 0 : Integer.parseInt(collection.getSpecimenTypeNbre())));
precisionTypeNbreCombo.peupler(collection.getSpecimenTypeNbrePrecision());
classementSpecimenTypeCombo.peupler(collection.getSpecimenTypeClassement());
}
}
public ArrayList<String> verifier() {
ArrayList<String> messages = new ArrayList<String>();
if (projetsCombo.getValue() == null || projetsCombo.getValue().equals("") || collection.getIdProjet().equals("")) {
messages.add("Veuillez sélectionner un projet pour la collection.");
}
return messages;
}
public void collecter() {
initialiserCollection();
if (etreAccede()) {
collectionCollectee.setId(idCollectionChp.getValue());
collectionCollectee.setCollectionMereId(getValeurComboProjets());
collectionCollectee.setIdStructure(getValeurComboStructures());
collectionCollectee.setCollectionMereId(getValeurComboCollections());
collectionCollectee.setTypeDepot(typeDepotCombo.getValeur());
collectionCollectee.setCote(coteChp.getValue());
collectionCollectee.setIdAlternatif(idAlternatifsChp.getValeurs());
collectionCollectee.setNomAlternatif(nomsAlternatifsChp.getValeurs());
collectionCollectee.setCode(codesAlternatifsChp.getValeurs());
collectionCollectee.setDescription(descriptionChp.getValue());
collectionCollectee.setDescriptionSpecialiste(descriptionSpecialisteChp.getValue());
collectionCollectee.setHistorique(historiqueChp.getValue());
collectionCollectee.setUrls(urlsChp.getValeurs());
collectionCollectee.setGroupementPrincipe(groupementPrincipeCombo.getValeur());
collectionCollectee.setGroupementBut(butRealisationCombo.getValeur());
collectionCollectee.setCouvertureLieu(lieuCouvertureChp.getValeurs());
collectionCollectee.setSpecimenType(specimenTypeCombo.getValeur());
collectionCollectee.setSpecimenTypeNbre(nbreTypeChp.getValue().toString());
collectionCollectee.setSpecimenTypeNbrePrecision(precisionTypeNbreCombo.getValeur());
collectionCollectee.setSpecimenTypeClassement(classementSpecimenTypeCombo.getValeur());
}
}
private String getValeurComboProjets() {
String valeur = "";
if (projetsCombo.getValue() != null) {
valeur = projetsCombo.getValue().getId();
}
return valeur;
}
private void setValeurComboProjets() {
if (projetsCombo.getStore() != null && collection != null) {
projetsCombo.setValue(projetsCombo.getStore().findModel("id_projet", collection.getIdProjet()));
}
}
private String getValeurComboStructures() {
String valeur = "";
if (structuresCombo.getValue() != null) {
valeur = structuresCombo.getValue().getId();
}
return valeur;
}
private void setValeurComboStructures() {
if (structuresCombo.getStore() != null && collection != null) {
structuresCombo.setValue(structuresCombo.getStore().findModel("id_structure", collection.getIdStructure()));
}
}
private String getValeurComboCollections() {
String valeur = "";
if (collectionsCombo.getValue() != null) {
valeur = collectionsCombo.getValue().getId();
}
return valeur;
}
private void setValeurComboCollections() {
if (collectionsCombo.getStore() != null && collection != null) {
collectionsCombo.setValue(collectionsCombo.getStore().findModel("id_collection", collection.getCollectionMereId()));
}
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof ProjetListe) {
ProjetListe projets = (ProjetListe) nouvellesDonnees;
Formulaire.rafraichirComboBox(projets, projetsCombo);
setValeurComboProjets();
} else if (nouvellesDonnees instanceof StructureListe) {
StructureListe structures = (StructureListe) nouvellesDonnees;
Formulaire.rafraichirComboBox(structures, structuresCombo);
setValeurComboStructures();
} else if (nouvellesDonnees instanceof CollectionListe) {
CollectionListe collections = (CollectionListe) nouvellesDonnees;
Formulaire.rafraichirComboBox(collections, collectionsCombo);
setValeurComboCollections();
} else if (nouvellesDonnees instanceof ValeurListe) {
ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
rafraichirValeurListe(listeValeurs);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
private void rafraichirValeurListe(ValeurListe listeValeurs) {
if (listeValeurs.getId().equals(config.getListeId("typeDepot"))) {
Formulaire.rafraichirComboBox(listeValeurs, typeDepotCombo);
} else {
GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
}
}
 
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionDetailVue.java
New file
0,0 → 1,500
package org.tela_botanica.client.vues.collection;
 
import java.util.Iterator;
 
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.ComposantId;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionAPersonne;
import org.tela_botanica.client.modeles.CollectionAPersonneListe;
import org.tela_botanica.client.modeles.CollectionAPublication;
import org.tela_botanica.client.modeles.CollectionAPublicationListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.ValeurListe;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Html;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.TabPanel;
import com.extjs.gxt.ui.client.widget.layout.AnchorLayout;
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
import com.google.gwt.core.client.GWT;
 
public class CollectionDetailVue extends DetailVue implements Rafraichissable {
 
private Collection collection = null;
private boolean collectionChargementOk = false;
private boolean personnesLieesChargementOk = false;
private boolean publicationsLieesChargementOk = false;
private Structure structure = null;
 
private String enteteTpl = null;
private String generalTpl = null;
private String personneTpl = null;
private String tableauPersonnesLieesTpl = null;
private String lignePersonneLieeTpl = null;
private String publicationTpl = null;
private String tableauPublicationsLieesTpl = null;
private String lignePublicationLieeTpl = null;
private String descriptionTpl = null;
private String contenuTpl = null;
private String inventaireTpl = null;
private ContentPanel panneauPrincipal = null;
private Html entete = null;
private TabPanel onglets = null;
private TabItem generalOnglet = null;
private TabItem personneOnglet = null;
private TabItem publicationOnglet = null;
private TabItem descriptionOnglet = null;
private TabItem contenuOnglet = null;
private TabItem inventaireOnglet = null;
 
public CollectionDetailVue(Mediateur mediateurCourant) {
super(mediateurCourant);
initialiserTousLesTpl();
chargerOntologie();
panneauPrincipal = new ContentPanel();
panneauPrincipal.setLayout(new FlowLayout());
panneauPrincipal.setHeaderVisible(false);
panneauPrincipal.setBodyBorder(false);
entete = new Html();
entete.setId(ComposantId.ZONE_DETAIL_ENTETE);
panneauPrincipal.setTopComponent(entete);
onglets = new TabPanel();
onglets.setId(ComposantId.ZONE_DETAIL_CORPS);
onglets.setHeight("100%");
onglets.setBodyBorder(false);
 
generalOnglet = new TabItem(i18nC.structureInfoGeneral());
generalOnglet.setLayout(new AnchorLayout());
generalOnglet.setScrollMode(Scroll.AUTO);
onglets.add(generalOnglet);
personneOnglet = new TabItem(i18nC.collectionPersonne());
personneOnglet.setLayout(new AnchorLayout());
personneOnglet.setScrollMode(Scroll.AUTO);
onglets.add(personneOnglet);
publicationOnglet = new TabItem(i18nC.collectionPublication());
publicationOnglet.setLayout(new AnchorLayout());
publicationOnglet.setScrollMode(Scroll.AUTO);
onglets.add(publicationOnglet);
descriptionOnglet = new TabItem(i18nC.collectionDescription());
descriptionOnglet.setLayout(new AnchorLayout());
descriptionOnglet.setScrollMode(Scroll.AUTO);
onglets.add(descriptionOnglet);
contenuOnglet = new TabItem(i18nC.collectionContenu());
contenuOnglet.setLayout(new AnchorLayout());
contenuOnglet.setScrollMode(Scroll.AUTO);
onglets.add(contenuOnglet);
inventaireOnglet = new TabItem(i18nC.collectionInventaire());
inventaireOnglet.setLayout(new AnchorLayout());
inventaireOnglet.setScrollMode(Scroll.AUTO);
onglets.add(inventaireOnglet);
panneauPrincipal.add(onglets);
add(panneauPrincipal);
}
private void initialiserTousLesTpl() {
initialiserEnteteHtmlTpl();
initialiserGeneralTpl();
initialiserPersonneTpl();
initialiserTableauPersonnesLieesTpl();
initialiserLignePersonneLieeTpl();
initialiserPublicationTpl();
initialiserTableauPublicationsLieesTpl();
initialiserLignePublicationLieeTpl();
initialiserContenuTpl();
initialiserDescriptionTpl();
initialiserInventaireTpl();
}
private void initialiserEnteteHtmlTpl() {
enteteTpl =
"<div id='{css_id}'>"+
" <h1>{nom}</h1>"+
" <h2>{structure}<span class='{css_meta}'>{projet} <br /> {i18n_id}:{id} - {guid}</span></h2>" +
"</div>";
}
private void initialiserGeneralTpl() {
generalTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_identification}</h2>"+
" <span class='{css_label}'>{i18n_nom_alternatif} :</span> {nom_alternatif}<br />"+
" <span class='{css_label}'>{i18n_acronyme} :</span> {acronyme}<br />"+
" <span class='{css_label}'>{i18n_code} :</span> {code}<br />"+
" <span class='{css_label}'>{i18n_cote} :</span> {cote}<br />"+
" <span class='{css_label}'>{i18n_mere} :</span> {mere}<br />"+
" <span class='{css_label}'>{i18n_type_ncd} :</span> {type_ncd}<br />"+
" <span class='{css_label}'>{i18n_type_depot} :</span> {type_depot}<br />"+
" </div>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_general_collection_titre}</h2>"+
" <span class='{css_label}'>{i18n_description} :</span> {description}<br />"+
" <span class='{css_label}'>{i18n_description_specialiste} :</span> {description_specialiste}<br />"+
" <span class='{css_label}'>{i18n_historique} :</span> {historique}<br />"+
" <span class='{css_label}'>{i18n_web} :</span> {web}<br />"+
" <span class='{css_label}'>{i18n_groupement_principe} :</span> {groupement_principe}<br />"+
" <span class='{css_label}'>{i18n_groupement_but} :</span> {groupement_but}<br />"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void initialiserPersonneTpl() {
personneTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_personne}</h2>"+
" {tableau_personnes_liees}"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void initialiserTableauPersonnesLieesTpl() {
tableauPersonnesLieesTpl =
"<h3>{i18n_titre_membre}</h3>"+
"<table>"+
" <thead>"+
" <tr>" +
" <th>{i18n_prenom}</th>" +
" <th>{i18n_nom}</th>" +
" </tr>"+
" </thead>"+
" <tbody>"+
" {lignes}"+
" </tbody>"+
"</table>";
}
private void initialiserLignePersonneLieeTpl() {
lignePersonneLieeTpl =
"<tr>"+
" <td>{prenom}</td>"+
" <td>{nom}</td>"+
"</tr>";
}
private void initialiserPublicationTpl() {
publicationTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_publication}</h2>"+
" {tableau_publications_liees}"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void initialiserTableauPublicationsLieesTpl() {
tableauPublicationsLieesTpl =
"<table>"+
" <thead>"+
" <tr>" +
" <th>{i18n_auteur}</th>" +
" <th>{i18n_titre}</th>" +
" </tr>"+
" </thead>"+
" <tbody>"+
" {lignes}"+
" </tbody>"+
"</table>";
}
private void initialiserLignePublicationLieeTpl() {
lignePublicationLieeTpl =
"<tr>"+
" <td>{auteur}</td>"+
" <td>{titre}</td>"+
"</tr>";
}
private void initialiserDescriptionTpl() {
descriptionTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_description}</h2>"+
" <span class='{css_label}'>{i18n_type_botanique} :</span> {type_botanique}<br />"+
" <span class='{css_label}'>{i18n_nbre_echantillon} :</span> {nbre_echantillon}<br />"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void initialiserContenuTpl() {
contenuTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_contenu}</h2>"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void initialiserInventaireTpl() {
inventaireTpl =
"<div class='{css_corps}'>"+
" <div class='{css_fieldset}'>"+
" <h2>{i18n_titre_inventaire}</h2>"+
" </div>"+
" <hr class='{css_clear}'/>"+
"</div>";
}
private void chargerOntologie() {
String[] listesCodes = {"typeCollectionBota", "typeCollectionNcd", "typeDepot", "groupementPrincipe", "realisationBut"};
lancerChargementListesValeurs(listesCodes);
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof Collection) {
collection = (Collection) nouvellesDonnees;
collectionChargementOk = true;
} else if (nouvellesDonnees instanceof ProjetListe) {
projets = (ProjetListe) nouvellesDonnees;
projetsChargementOk = true;
} else if (nouvellesDonnees instanceof ValeurListe) {
ValeurListe listeValeursReceptionnee = (ValeurListe) nouvellesDonnees;
receptionerListeValeurs(listeValeursReceptionnee);
} else if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
if (info.getType().equals("liste_collection_a_personne")) {
lierCollectionAPersonne((CollectionAPersonneListe) info.getDonnee(0));
} else if (info.getType().equals("liste_collection_a_publication")) {
lierCollectionAPublication((CollectionAPublicationListe) info.getDonnee(0));
}
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
if (avoirDonneesChargees()) {
afficherDetail();
}
}
protected void lierCollectionAPersonne(CollectionAPersonneListe personnes) {
collection.setPersonnesLiees(personnes);
personnesLieesChargementOk = true;
}
protected void lierCollectionAPublication(CollectionAPublicationListe publications) {
collection.setPublicationsLiees(publications);
publicationsLieesChargementOk = true;
}
private boolean avoirDonneesChargees() {
boolean ok = false;
if (projetsChargementOk && collectionChargementOk && ontologieChargementOk && personnesLieesChargementOk && publicationsLieesChargementOk) {
ok = true;
}
return ok;
}
private void afficherDetail() {
if (collection != null) {
afficherEntete();
afficherIdentification();
afficherPersonne();
afficherPublication();
afficherDescription();
afficherContenu();
afficherInventaire();
}
layout();
}
private void afficherEntete() {
Params enteteParams = new Params();
enteteParams.set("css_id", ComposantId.ZONE_DETAIL_ENTETE);
enteteParams.set("css_meta", ComposantClass.META);
enteteParams.set("i18n_id", i18nC.id());
enteteParams.set("nom", collection.getNom());
enteteParams.set("structure", collection.getStructureNom());
enteteParams.set("id", collection.getId());
enteteParams.set("guid", collection.getGuid());
enteteParams.set("projet", construireTxtProjet(collection.getIdProjet()));
String eHtml = Format.substitute(enteteTpl, enteteParams);
entete.getElement().setInnerHTML(eHtml);
}
private void afficherIdentification() {
Params generalParams = new Params();
generalParams.set("i18n_titre_identification", i18nC.titreAdministratif());
generalParams.set("i18n_nom_alternatif", i18nC.nomAlternatif());
generalParams.set("i18n_acronyme", i18nC.acronyme());
generalParams.set("i18n_code", i18nC.code());
generalParams.set("i18n_cote", i18nC.cote());
generalParams.set("i18n_mere", i18nC.collectionMere());
generalParams.set("i18n_type_ncd", i18nC.typeCollectionNcd());
generalParams.set("i18n_type_depot", i18nC.typeDepot());
 
generalParams.set("i18n_general_collection_titre", i18nC.collectionGeneralTitre());
generalParams.set("i18n_description", i18nC.description());
generalParams.set("i18n_description_specialiste", i18nC.descriptionSpecialiste());
generalParams.set("i18n_historique", i18nC.historique());
generalParams.set("i18n_web", i18nC.siteWeb());
generalParams.set("i18n_groupement_principe", i18nC.groupementPrincipe());
generalParams.set("i18n_groupement_but", i18nC.groupementBut());
String acronyme = construireTxtTruck(collection.getIdAlternatif());
String code = construireTxtTruck(collection.getCode());
String nomAlternatif = construireTxtTruck(collection.getNomAlternatif());
String urls = construireTxtTruck(collection.getUrls());
String typeNcd = construireTxtListeOntologie(collection.getTypeNcd());
String typeDepot = construireTxtListeOntologie(collection.getTypeDepot());
String groupementBut = construireTxtListeOntologie(collection.getGroupementBut());
String groupementPrincipe = construireTxtListeOntologie(collection.getGroupementPrincipe());
generalParams.set("nom_alternatif", nomAlternatif);
generalParams.set("acronyme", acronyme);
generalParams.set("code", code);
generalParams.set("cote", collection.getCote());
generalParams.set("mere", collection.getCollectionMereNom());
generalParams.set("type_ncd", typeNcd);
generalParams.set("type_depot", typeDepot);
 
generalParams.set("description", collection.getDescription());
generalParams.set("description_specialiste", collection.getDescriptionSpecialiste());
generalParams.set("historique", collection.getHistorique());
generalParams.set("web", urls);
generalParams.set("groupement_principe", groupementPrincipe);
generalParams.set("groupement_but", groupementBut);
afficherOnglet(generalTpl, generalParams, generalOnglet);
}
private void afficherPersonne() {
String tableauPersonneHtml = "";
if (collection.getPersonnesLiees() != null && collection.getPersonnesLiees().size() > 0) {
tableauPersonneHtml = construireTableauPersonnesLiees();
}
Params personneParams = new Params();
personneParams.set("i18n_titre_personne", i18nC.collectionPersonneTitre());
personneParams.set("tableau_personnes_liees", tableauPersonneHtml);
afficherOnglet(personneTpl, personneParams, personneOnglet);
}
private String construireTableauPersonnesLiees() {
Params contenuParams = new Params();
contenuParams.set("i18n_prenom", i18nC.personnePrenom());
contenuParams.set("i18n_nom", i18nC.personneNom());
String lignesPersonnel = "";
Iterator<String> it = collection.getPersonnesLiees().keySet().iterator();
while (it.hasNext()) {
CollectionAPersonne relationCollectionAPersonne = collection.getPersonnesLiees().get(it.next());
Personne personne = relationCollectionAPersonne.getPersonne();
Params ligneParams = new Params();
ligneParams.set("prenom", personne.getPrenom());
ligneParams.set("nom", personne.getNom());
lignesPersonnel += Format.substitute(lignePersonneLieeTpl, ligneParams);
}
contenuParams.set("lignes", lignesPersonnel);
String cHtml = Format.substitute(tableauPersonnesLieesTpl, contenuParams);
return cHtml;
}
private void afficherPublication() {
Params publicationParams = new Params();
publicationParams.set("i18n_titre_publication", i18nC.collectionPublicationTitre());
String tableauPublicationHtml = "";
if (collection.getPersonnesLiees() != null && collection.getPersonnesLiees().size() > 0) {
tableauPublicationHtml = construireTableauPublicationsLiees();
}
publicationParams.set("tableau_publications_liees", tableauPublicationHtml);
afficherOnglet(publicationTpl, publicationParams, publicationOnglet);
}
private String construireTableauPublicationsLiees() {
Params contenuParams = new Params();
contenuParams.set("i18n_auteur", i18nC.publicationAuteurs());
contenuParams.set("i18n_titre", i18nC.publicationTitre());
String lignesPublication = "";
Iterator<String> it = collection.getPublicationsLiees().keySet().iterator();
while (it.hasNext()) {
CollectionAPublication relationCollectionAPublication = collection.getPublicationsLiees().get(it.next());
Publication publication = relationCollectionAPublication.getPublication();
Params ligneParams = new Params();
ligneParams.set("auteur", publication.getAuteur());
ligneParams.set("titre", publication.getTitre());
lignesPublication += Format.substitute(lignePublicationLieeTpl, ligneParams);
}
contenuParams.set("lignes", lignesPublication);
String cHtml = Format.substitute(tableauPublicationsLieesTpl, contenuParams);
return cHtml;
}
private void afficherDescription() {
Params descriptionParams = new Params();
descriptionParams.set("i18n_titre_description", i18nC.collectionDescriptionTitre());
descriptionParams.set("i18n_type_botanique", i18nC.typeCollectionBotanique());
descriptionParams.set("i18n_nbre_echantillon", i18nC.nbreEchantillon());
String typeBota = construireTxtListeOntologie(collection.getBotanique().getType());
descriptionParams.set("type_botanique", typeBota);
descriptionParams.set("nbre_echantillon", collection.getBotanique().getNbreEchantillon());
afficherOnglet(descriptionTpl, descriptionParams, descriptionOnglet);
}
private void afficherContenu() {
Params contenuParams = new Params();
contenuParams.set("i18n_titre_contenu", i18nC.collectionContenuTitre());
afficherOnglet(contenuTpl, contenuParams, contenuOnglet);
}
private void afficherInventaire() {
Params inventaireParams = new Params();
inventaireParams.set("i18n_titre_inventaire", i18nC.collectionInventaireTitre());
afficherOnglet(inventaireTpl, inventaireParams, inventaireOnglet);
}
protected String getNomStructure() {
String nomStructure = "";
if (structure != null) {
nomStructure = structure.getNom();
} else {
nomStructure = collection.getIdStructure();
}
return nomStructure;
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionForm.java
New file
0,0 → 1,328
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.util.UtilArray;
import org.tela_botanica.client.util.UtilString;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.StructureForm;
 
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.TabPanel;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.google.gwt.core.client.GWT;
 
public class CollectionForm extends Formulaire implements Rafraichissable {
 
protected Collection collection = null;
protected Collection collectionCollectee = null;
 
private ChampComboBoxListeValeurs typesCollectionCombo = null;
private TabPanel onglets = null;
private CollectionFormGeneral generalOnglet = null;
private CollectionFormPersonne personneOnglet = null;
private CollectionFormPublication publicationOnglet = null;
private CollectionFormDescription descriptionOnglet = null;
private CollectionFormContenu contenuOnglet = null;
private CollectionFormInventaire inventaireOnglet = null;
private TextField<String> nomChp = null;
public CollectionForm(Mediateur mediateurCourrant, String collectionId) {
initialiserCollectionForm(mediateurCourrant, collectionId);
}
private void initialiserCollectionForm(Mediateur mediateurCourrant, String collectionId) {
collection = new Collection();
collection.setId(collectionId);
String modeDeCreation = (UtilString.isEmpty(collection.getId()) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
initialiserFormulaire(mediateurCourrant, modeDeCreation, MenuApplicationId.COLLECTION);
creerFieldsetPrincipal();
if (modeDeCreation.equals(Formulaire.MODE_MODIFIER)) {
mediateurCourrant.selectionnerCollection(this, collectionId);
mediateurCourrant.selectionnerCollectionAPersonne(this, collectionId, null);
mediateurCourrant.selectionnerCollectionAPublication(this, collectionId);
}
}
private void creerFieldsetPrincipal() {
FieldSet principalFieldSet = new FieldSet();
principalFieldSet.setHeading("Info");
principalFieldSet.setCollapsible(true);
principalFieldSet.setLayout(Formulaire.creerFormLayout(150, LabelAlign.LEFT));
nomChp = new TextField<String>();
nomChp.setTabIndex(tabIndex++);
nomChp.setFieldLabel(i18nC.nomCollection());
nomChp.setAllowBlank(false);
nomChp.getMessages().setBlankText(i18nC.champObligatoire());
principalFieldSet.add(nomChp, new FormData(450, 0));
typesCollectionCombo = new ChampComboBoxListeValeurs(i18nC.typeCollectionNcd(), "typeCollectionNcd", tabIndex++);
typesCollectionCombo.peupler(Valeur.COLLECTION_NCD_HERBIER);
typesCollectionCombo.addListener(Events.Select, new Listener<BaseEvent>() {
@Override
public void handleEvent(BaseEvent be) {
Valeur valeur = typesCollectionCombo.getValue();
panneauFormulaire.remove(onglets);
mediateur.activerChargement("");
if (valeur != null && valeur.getId().equals(Valeur.COLLECTION_NCD_HERBIER)) {
onglets = creerOngletsHerbier();
panneauFormulaire.add(onglets);
} else {
onglets = creerOngletsDefaut();
panneauFormulaire.add(onglets);
}
mediateur.desactiverChargement();
panneauFormulaire.layout();
}
});
principalFieldSet.add(typesCollectionCombo, new FormData(150, 0));
typesCollectionCombo.fireEvent(Events.Select);
panneauFormulaire.setTopComponent(principalFieldSet);
}
protected TabPanel creerOngletsDefaut() {
TabPanel ongletsCollectionDefaut = new TabPanel();
// Onlget formulaire GENERAL
ongletsCollectionDefaut.add(creerOngletGeneral());
// Onlget formulaire AUTEUR
ongletsCollectionDefaut.add(creerOngletPersonne());
 
return ongletsCollectionDefaut;
}
protected TabPanel creerOngletsHerbier() {
TabPanel ongletsCollectionHerbier = new TabPanel();
// NOTE : pour faire apparaître les scrollBar il faut définir la hauteur du panneau d'onglets à 100% (autoHeight ne semble pas fonctionner)
ongletsCollectionHerbier.setHeight("100%");
// Onlget formulaire GENERAL
ongletsCollectionHerbier.add(creerOngletGeneral());
// Onlget formulaire AUTEUR
ongletsCollectionHerbier.add(creerOngletPersonne());
// Onlget formulaire PUBLICATION
ongletsCollectionHerbier.add(creerOngletPublication());
// Onlget formulaire DESCRIPTION
ongletsCollectionHerbier.add(creerOngletDescription());
// Onlget formulaire CONTENU
ongletsCollectionHerbier.add(creerOngletContenu());
// Onlget formulaire INVENTAIRE
ongletsCollectionHerbier.add(creerOngletInventaire());
// Sélection de l'onglet par défaut
ongletsCollectionHerbier.setSelection(generalOnglet);
return ongletsCollectionHerbier;
}
private TabItem creerOngletGeneral() {
generalOnglet = new CollectionFormGeneral(this);
return generalOnglet;
}
private TabItem creerOngletPersonne() {
personneOnglet = new CollectionFormPersonne(this);
return personneOnglet;
}
private TabItem creerOngletPublication() {
publicationOnglet = new CollectionFormPublication(this);
return publicationOnglet;
}
private TabItem creerOngletDescription() {
descriptionOnglet = new CollectionFormDescription(this);
return descriptionOnglet;
}
private TabItem creerOngletContenu() {
contenuOnglet = new CollectionFormContenu(this);
return contenuOnglet;
}
private TabItem creerOngletInventaire() {
inventaireOnglet = new CollectionFormInventaire(this);
return inventaireOnglet;
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
rafraichirInformation(info);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
controlerFermetureApresRafraichissement();
}
 
private void rafraichirInformation(Information info) {
if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
GWT.log("MESSAGES:\n"+info.getMessages().toString(), null);
}
if (info.getType().equals("modif_collection")) {
Info.display("Modification d'une collection", info.toString());
} else if (info.getType().equals("selection_collection")) {
Info.display("Modification d'une collection", info.toString());
if (info.getDonnee(0) != null) {
collection = (Collection) info.getDonnee(0);
}
peupler();
actualiserTitrePanneau();
} else if (info.getType().equals("ajout_collection")) {
if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
String collectionId = (String) info.getDonnee(0);
Info.display("Ajout d'une collection", "La collection '"+collectionId+"' a bien été ajoutée");
// Suite à la récupération de l'id de l'institution nouvellement ajoutée nous ajoutons les personnes et les publications liées
personneOnglet.rafraichir(info);
publicationOnglet.rafraichir(info);
} else {
Info.display("Ajout d'une Institution", info.toString());
}
} else if (info.getType().equals("liste_collection_a_personne")) {
personneOnglet.rafraichir(info);
} else if (info.getType().equals("liste_collection_a_publication")) {
publicationOnglet.rafraichir(info);
}
}
private void peupler() {
if (collection != null) {
nomChp.setValue(collection.getNom());
typesCollectionCombo.peupler(collection.getTypeNcd());
peuplerOnglets();
}
}
 
private void peuplerOnglets() {
generalOnglet.peupler();
}
 
private void actualiserTitrePanneau() {
String titre = i18nC.titreModifFormCollection();
// Composition du titre
titre += " - ID : "+collection.getId();
panneauFormulaire.setHeading(titre);
}
 
public boolean soumettreFormulaire() {
// Vérification de la validité des champs du formulaire
boolean fomulaireValide = verifierFormulaire();
if (fomulaireValide) {
// Collecte des données du formulaire
Collection collection = collecterCollection();
if (mode.equals(MODE_AJOUTER)) {
mediateur.ajouterCollection(this, collection);
} else if (mode.equals(MODE_MODIFIER)) {
if (collection == null) {
Info.display("Modification d'une collection", "Rien n'a été enregistré car le formulaire n'a pas été modifié.");
} else {
mediateur.modifierCollection(this, collection);
}
}
soumettreOnglets();
}
return fomulaireValide;
}
private void soumettreOnglets() {
personneOnglet.soumettre();
publicationOnglet.soumettre();
}
public void reinitialiserFormulaire() {
if (mode.equals(StructureForm.MODE_MODIFIER)) {
mediateur.afficherFormCollection(collection.getId());
} else {
mediateur.afficherFormCollection(null);
}
}
private Collection collecterCollection() {
collectionCollectee = (Collection) collection.cloner(new Collection());
this.collecter();
collecterOnglets();
Collection collectionARetourner = null;
if (!collectionCollectee.comparer(collection)) {
collectionARetourner = collection = collectionCollectee;
}
return collectionARetourner;
}
private void collecter() {
collectionCollectee.setNom(nomChp.getValue());
collectionCollectee.setTypeNcd(typesCollectionCombo.getValue().getId());
}
private void collecterOnglets() {
generalOnglet.collecter();
personneOnglet.collecter();
publicationOnglet.collecter();
}
public boolean verifierFormulaire() {
ArrayList<String> messages = new ArrayList<String>();
// Vérification des infos sur le nom de la collection
if (nomChp.getValue() == null || nomChp.getValue().equals("") || collection.getNom().equals("")) {
messages.add("Veuillez donner un nom à la collection.");
}
// Vérification des infos sur le type de collection
if (typesCollectionCombo.getValue() == null || typesCollectionCombo.getValue().equals("") || collection.getIdProjet().equals("")) {
messages.add("Veuillez sélectionner un type pour la collection.");
}
messages.addAll(verifierOnglets());
// Affichage des messages d'alerte
if (messages.size() != 0) {
String[] tableauDesMessages = {};
tableauDesMessages = messages.toArray(tableauDesMessages);
MessageBox.alert("Erreurs de saisies", UtilArray.implode(tableauDesMessages, "<br />"), null);
return false;
}
return true;
}
private ArrayList<String> verifierOnglets() {
ArrayList<String> messages = new ArrayList<String>();
messages.addAll(generalOnglet.verifier());
messages.addAll(personneOnglet.verifier());
return messages;
}
}
/trunk/src/org/tela_botanica/client/vues/collection/DetailVue.java
New file
0,0 → 1,263
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.configuration.Configuration;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.util.UtilString;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;
import com.extjs.gxt.ui.client.widget.HtmlContainer;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.google.gwt.core.client.GWT;
 
public abstract class DetailVue extends LayoutContainer implements Rafraichissable {
 
protected Mediateur mediateur = null;
protected Constantes i18nC = null;
 
protected HashMap<String, Valeur> ontologie = null;
protected boolean ontologieChargementOk = false;
private HashMap<Integer, String> ontologiesEnAttenteDeReception = null;
protected ProjetListe projets = null;
protected boolean projetsChargementOk = false;
protected String sautLigneTpl = null;
public DetailVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
i18nC = Mediateur.i18nC;
initialiserSautLigneTpl();
ontologie = new HashMap<String, Valeur>();
ontologieChargementOk = false;
ontologiesEnAttenteDeReception = new HashMap<Integer, String>();
chargerProjets();
setLayout(new FitLayout());
setBorders(false);
setScrollMode(Scroll.AUTO);
}
private void initialiserSautLigneTpl() {
sautLigneTpl = "<br />\n";
}
private void chargerProjets() {
mediateur.selectionnerProjet(this, null);
}
protected String construireTxtProjet(String idProjet) {
String chaineARetourner = idProjet;
if (projets != null) {
Projet projet = projets.get(idProjet);
if (projet != null) {
String nomDuProjet = projet.getNom();
if (!nomDuProjet.equals("")) {
chaineARetourner = nomDuProjet;
}
}
}
return chaineARetourner;
}
protected String construireTxtTruck(String chaineAAnalyser) {
ArrayList<String> termes = new ArrayList<String>();
if ((chaineAAnalyser != null) && (!chaineAAnalyser.trim().equals(""))) {
String[] valeurs = chaineAAnalyser.split(";;");
int nbreValeurs = valeurs.length;
if (nbreValeurs > 0) {
for (int i = 0; i < nbreValeurs; i++) {
String valeur = valeurs[i];
String valeurFormatee = formaterValeurTruck(valeur);
termes.add(valeurFormatee);
}
}
}
String chaineARetourner = formaterTableauDeTxt(termes);
return chaineARetourner;
}
private String formaterValeurTruck(String valeur) {
String chaineARetourner = "";
if (valeur.matches("^[^#]+##[^$]+$")) {
String[] cleValeur = valeur.split("##");
chaineARetourner = cleValeur[1]+" "+formaterParenthese(cleValeur[0]);
} else if (!valeur.equals("")) {
chaineARetourner = valeur;
} else {
GWT.log("Valeur truck posant problèlme :"+valeur, null);
}
return chaineARetourner;
}
protected String formaterParenthese(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = "("+chaineAAfficher+")";
}
return chaineAAfficher;
}
protected String formaterTableauDeTxt(ArrayList<String> tableauDeTxt) {
String chaineAAfficher = "";
int tailleDuTableau = tableauDeTxt.size();
if (tailleDuTableau > 0) {
int indexAvtDernier = tailleDuTableau - 1;
for (int i = 0; i < tailleDuTableau; i++) {
String mot = tableauDeTxt.get(i);
if (i != indexAvtDernier) {
chaineAAfficher += mot+", ";
} else {
chaineAAfficher += nettoyerPointFinal(mot)+".";
}
}
}
return UtilString.ucFirst(chaineAAfficher);
}
protected String nettoyerPointFinal(String mot) {
mot = mot.replaceAll("[.]$", "");
return mot;
}
protected String formaterContenu(String template, Params parametres) {
String cHtml = Format.substitute(template, parametres);
Params cssParams = new Params();
cssParams.set("css_corps", ComposantClass.DETAIL_CORPS_CONTENU);
cssParams.set("css_label", ComposantClass.LABEL);
cssParams.set("css_indentation", ComposantClass.INDENTATION);
cssParams.set("css_fieldset", ComposantClass.FIELDSET);
cssParams.set("css_clear", ComposantClass.CLEAR);
cHtml = Format.substitute(cHtml, cssParams);
return cHtml;
}
protected void afficherOnglet(String template, Params parametres, TabItem onglet) {
String cHtml = formaterContenu(template, parametres);
HtmlContainer corpsConteneurDuHtml = new HtmlContainer(cHtml);
onglet.removeAll();
onglet.add(corpsConteneurDuHtml);
}
protected String formaterAutre(String chaineAAfficher) {
if (!chaineAAfficher.equals("")) {
chaineAAfficher = " ["+i18nC.autres()+" : "+chaineAAfficher+"]";
}
return chaineAAfficher;
}
protected String formaterOuiNon(String chaineAFormater) {
String txtARetourner = "";
if (chaineAFormater.equals("0")) {
txtARetourner = i18nC.non();
} else if (chaineAFormater.equals("1")) {
txtARetourner = i18nC.oui();
}
return txtARetourner;
}
protected String formaterSautDeLigne(String chaineAFormater) {
String txtARetourner = chaineAFormater.replaceAll("\n", sautLigneTpl);
return txtARetourner;
}
protected void lancerChargementListesValeurs(String[] listesCodes) {
Configuration configuration = (Configuration) Registry.get(RegistreId.CONFIG);
for (int i = 0; i < listesCodes.length ; i++) {
String code = listesCodes[i];
ontologiesEnAttenteDeReception.put(configuration.getListeId(code), code);
mediateur.obtenirListeValeurEtRafraichir(this, code);
}
}
protected void receptionerListeValeurs(ValeurListe listeValeursReceptionnee) {
mettreAJourOntologieEnAttenteDeReception(listeValeursReceptionnee);
ajouterListeValeursAOntologie(listeValeursReceptionnee);
}
protected void mettreAJourOntologieEnAttenteDeReception(ValeurListe listeValeursReceptionnee) {
ontologiesEnAttenteDeReception.remove(listeValeursReceptionnee.getId());
if (ontologiesEnAttenteDeReception.size() == 0) {
ontologieChargementOk = true;
}
}
protected void ajouterListeValeursAOntologie(ValeurListe listeValeursReceptionnee) {
Iterator<String> it = listeValeursReceptionnee.keySet().iterator();
while (it.hasNext()) {
String cle = it.next();
Valeur valeur = listeValeursReceptionnee.get(cle);
if (valeur != null) {
ontologie.put(cle, valeur);
}
}
}
protected String construireTxtListeOntologie(String chaineAAnalyser) {
ArrayList<String> termes = new ArrayList<String>();
ArrayList<String> autres = new ArrayList<String>();
if ((chaineAAnalyser != null) && (!chaineAAnalyser.trim().equals(""))) {
String[] valeurs = chaineAAnalyser.split(";;");
int nbreValeurs = valeurs.length;
if (nbreValeurs > 0) {
for (int i = 0; i < nbreValeurs; i++) {
String id = valeurs[i];
if (id.matches("^[0-9]+[\\#]{2}.+$")) {
//Chaine truk typé : type##valeur;
if (id.contains("AUTRE##")) {
String txt = id.replaceFirst("^AUTRE##", "");
if (!txt.equals("")) {
autres.add(txt);
}
} else {
String type = id.substring(0, id.indexOf("##"));
Valeur valeur = ontologie.get(type);
String txt = id.replaceFirst("^" + type + "##", valeur.getNom() + ": ");
termes.add(txt);
}
} else if (id.matches("^[0-9]+$")) {
if (ontologie != null) {
Valeur valeur = ontologie.get(id);
if (valeur != null) {
String termeOntologie = valeur.getNom();
termes.add(termeOntologie);
}
}
}
}
}
}
String chaineTermes = formaterTableauDeTxt(termes);
String chaineAutres = formaterTableauDeTxt(autres);
String chaineARetourner = chaineTermes+formaterAutre(chaineAutres);
return chaineARetourner;
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormDescription.java
New file
0,0 → 1,585
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampCaseACocher;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.composants.ChampMultiValeursMultiTypes;
import org.tela_botanica.client.composants.ChampSliderPourcentage;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.InterneValeur;
import org.tela_botanica.client.modeles.UniteBase;
import org.tela_botanica.client.modeles.UniteRangement;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireOnglet;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.grid.AggregationRowConfig;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.HeaderGroupConfig;
import com.extjs.gxt.ui.client.widget.grid.SummaryType;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.NumberFormat;
 
public class CollectionFormDescription extends FormulaireOnglet implements Rafraichissable {
private ChampComboBoxListeValeurs typesCollectionBotaCombo = null;
private NumberField nbreEchantillonChp = null;
private Grid<UniteRangement> uniteRangementGrille = null;
private ChampComboBoxListeValeurs etatUniteRangementCombo = null;
private Grid<UniteBase> uniteBaseGrille = null;
private ChampCaseACocher typePapierConservationChp = null;
private ChampCaseACocher methodeConservationChp = null;
private ChampSliderPourcentage specimenFixationPourcentChp = null;
private ChampSliderPourcentage etiquetteFixationPourcentChp = null;
private ChampCaseACocher specimentMethodeFixationChp = null;
private ChampCaseACocher etiquetteMethodeFixationSurSupportChp = null;
private ChampCaseACocher etiquetteMethodeFixationSurSpecimenChp = null;
private ChampCaseACocher typeEcritureChp = null;
private ChampComboBoxListeValeurs traitementCombo = null;
private ChampCaseACocher poisonTraitementChp = null;
private ChampCaseACocher insecteTraitementChp = null;
private ChampComboBoxListeValeurs etatGeneralCombo = null;
private ChampComboBoxListeValeurs determinationCombo = null;
private ChampMultiValeursMultiTypes specimenDegradationChp = null;
private ChampMultiValeursMultiTypes presentationDegradationChp = null;
public CollectionFormDescription(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("description");
setText(Mediateur.i18nC.collectionDescription());
 
FormLayout formulaireLayout = (FormLayout) this.getLayout();
formulaireLayout.setLabelAlign(LabelAlign.LEFT);
formulaireLayout.setLabelWidth(300);
creerFieldsetPrecision();
creerUniteRangement();
creerUniteBase();
creerFieldsetConservation();
creerFieldsetEtiquette();
creerFieldsetTraitement();
creerFieldsetEtat();
layout();
}
private void creerFieldsetPrecision() {
FieldSet precisionFieldSet = new FieldSet();
precisionFieldSet.setHeading("Précision");
precisionFieldSet.setCollapsible(true);
precisionFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
typesCollectionBotaCombo = new ChampComboBoxListeValeurs(i18nC.typeCollectionBotanique(), "typeCollectionBota");
typesCollectionBotaCombo.setTabIndex(tabIndex++);
precisionFieldSet.add(typesCollectionBotaCombo, new FormData(250, 0));
nbreEchantillonChp = new NumberField();
nbreEchantillonChp.setFieldLabel(i18nC.nbreEchantillon());
nbreEchantillonChp.setToolTip(i18nC.nbreEchantillonInfo());
nbreEchantillonChp.setFormat(NumberFormat.getFormat("#"));
precisionFieldSet.add(nbreEchantillonChp);
this.add(precisionFieldSet);
}
private void creerUniteRangement() {
ContentPanel panneauGrille = creerPanneauContenantGrille(i18nC.collectionUniteRangementTitre());
uniteRangementGrille = creerGrilleUniteRangement();
mediateur.obtenirListeValeurEtRafraichir(this, "typeUniteRangement");
panneauGrille.add(uniteRangementGrille);
ToolBar barreOutils = creerBarreOutilsGrilleUniteRangement();
panneauGrille.setTopComponent(barreOutils);
add(panneauGrille);
}
private ContentPanel creerPanneauContenantGrille(String titre) {
ContentPanel panneau = new ContentPanel();
panneau.setHeading(titre);
panneau.setIcon(Images.ICONES.table());
panneau.setLayout(new FitLayout());
panneau.setFrame(true);
panneau.setScrollMode(Scroll.AUTO);
panneau.setCollapsible(true);
panneau.setStyleAttribute("margin", "5px 0");
return panneau;
}
private Grid<UniteRangement> creerGrilleUniteRangement() {
ListStore<UniteRangement> storeGrille = new ListStore<UniteRangement>();
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(new ColumnConfig("type", i18nC.collectionUniteType(), 150));
NumberField champNombre = new NumberField();
champNombre.setFormat(NumberFormat.getFormat("#"));
CellEditor editeurNombre = new CellEditor(champNombre);
ColumnConfig nombreColonne = new ColumnConfig("nombre", i18nC.collectionUniteNbre(), 50);
nombreColonne.setEditor(editeurNombre);
colonnes.add(nombreColonne);
ListStore<InterneValeur> precisionStore = new ListStore<InterneValeur>();
precisionStore.add(new InterneValeur(UniteRangement.COMPTE_APPROXIMATIF, i18nC.precisionApproximatif()));
precisionStore.add(new InterneValeur(UniteRangement.COMPTE_EXACT, i18nC.precisionExact()));
final ComboBox<InterneValeur> precisionCombo = new ComboBox<InterneValeur>();
precisionCombo.setForceSelection(true);
precisionCombo.setTriggerAction(TriggerAction.ALL);
precisionCombo.setDisplayField("nom");
precisionCombo.setStore(precisionStore);
precisionCombo.setEditable(false);
CellEditor editeurPrecision = new CellEditor(precisionCombo) {
@Override
public Object preProcessValue(Object valeur) {
InterneValeur retour = null;
if (valeur != null ) {
if (precisionCombo.getStore().findModel("nom", valeur.toString()) != null) {
retour = precisionCombo.getStore().findModel("nom", valeur.toString());
} else if (precisionCombo.getStore().findModel("abr", valeur.toString()) != null) {
retour = precisionCombo.getStore().findModel("abr", valeur.toString());
}
}
return retour;
}
 
@Override
public Object postProcessValue(Object valeur) {
String retour = null;
if (valeur != null ) {
if (valeur instanceof InterneValeur) {
InterneValeur valeurInterne = (InterneValeur) valeur;
retour = valeurInterne.getNom();
}
}
return retour;
}
};
ColumnConfig precisionColonne = new ColumnConfig("precision", i18nC.collectionUnitePrecision(), 50);
precisionColonne.setEditor(editeurPrecision);
colonnes.add(precisionColonne);
TextField<String> formatChp = new TextField<String>();
formatChp.setAllowBlank(false);
 
ColumnConfig formatColonne = new ColumnConfig("format", i18nC.collectionUniteFormat(), 100);
formatColonne.setEditor(new CellEditor(formatChp));
colonnes.add(formatColonne);
GridSelectionModel<UniteRangement> modeleDeSelection = new GridSelectionModel<UniteRangement>();
ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
EditorGrid<UniteRangement> grilleUniteRangement = new EditorGrid<UniteRangement>(storeGrille, modeleDeColonnes);
grilleUniteRangement.setHeight(300);
grilleUniteRangement.setBorders(true);
grilleUniteRangement.setSelectionModel(modeleDeSelection);
grilleUniteRangement.getView().setForceFit(true);
grilleUniteRangement.getView().setAutoFill(true);
grilleUniteRangement.setAutoExpandColumn("type");
grilleUniteRangement.setStripeRows(true);
grilleUniteRangement.setTrackMouseOver(true);
return grilleUniteRangement;
}
private ToolBar creerBarreOutilsGrilleUniteRangement() {
ToolBar barreOutils = new ToolBar();
Button ajouterBouton = creerBoutonAjouterUniteRangement();
barreOutils.add(ajouterBouton);
barreOutils.add(new SeparatorToolItem());
Button supprimerBouton = creerBoutonSupprimerUniteRangement();
barreOutils.add(supprimerBouton);
barreOutils.add(new SeparatorToolItem());
barreOutils.add(new Text(i18nC.collectionUniteRangementEtatGeneralLabel()));
etatUniteRangementCombo = new ChampComboBoxListeValeurs("", "etat");
etatUniteRangementCombo.setEmptyText(i18nC.collectionUniteRangementEtatGeneral());
etatUniteRangementCombo.setToolTip(i18nC.collectionUniteRangementEtatGeneralInfo());
etatUniteRangementCombo.setTrie("id_valeur");
etatUniteRangementCombo.setWidth(300);
barreOutils.add(etatUniteRangementCombo);
return barreOutils;
}
private Button creerBoutonAjouterUniteRangement() {
Button bouton = new Button(i18nC.ajouter());
bouton.setIcon(Images.ICONES.ajouter());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
final MessageBox box = MessageBox.prompt(i18nC.collectionUniteType(), i18nC.collectionUniteRangementSaisirType());
box.addCallback(new Listener<MessageBoxEvent>() {
public void handleEvent(MessageBoxEvent be) {
final UniteRangement unite = new UniteRangement();
unite.setType(be.getValue());
unite.setTypeAutre(true);
uniteRangementGrille.getStore().add(unite);
}
});
}
});
return bouton;
}
private Button creerBoutonSupprimerUniteRangement() {
Button bouton = new Button(i18nC.supprimer());
bouton.setIcon(Images.ICONES.supprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
UniteRangement uniteRangementSelectionnee = uniteRangementGrille.getSelectionModel().getSelectedItem();
if (uniteRangementSelectionnee == null) {
Info.display(i18nC.informationTitreGenerique(), Mediateur.i18nM.veuillezSelectionner(i18nC.selectionnerUniteRangement()));
} else if (uniteRangementSelectionnee.getTypeAutre() == false) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerUniteRangementAjoute());
} else {
uniteRangementGrille.getStore().remove(uniteRangementSelectionnee);
}
}
});
return bouton;
}
private void creerUniteBase() {
ContentPanel panneauGrille = creerPanneauContenantGrille(i18nC.collectionUniteBaseTitre());
uniteBaseGrille = creerGrilleUniteBase();
mediateur.obtenirListeValeurEtRafraichir(this, "typeUniteBase");
panneauGrille.add(uniteBaseGrille);
ToolBar barreOutils = creerBarreOutilsGrilleUniteBase();
panneauGrille.setTopComponent(barreOutils);
add(panneauGrille);
}
private Grid<UniteBase> creerGrilleUniteBase() {
ListStore<UniteBase> storeGrille = new ListStore<UniteBase>();
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(new ColumnConfig("type", i18nC.collectionUniteType(), 150));
NumberField champNombre = new NumberField();
champNombre.setFormat(NumberFormat.getFormat("#"));
CellEditor editeurNombre = new CellEditor(champNombre);
ColumnConfig nombreColonne = new ColumnConfig("nombre", i18nC.collectionUniteNbre(), 50);
nombreColonne.setEditor(editeurNombre);
colonnes.add(nombreColonne);
ListStore<InterneValeur> precisionStore = new ListStore<InterneValeur>();
precisionStore.add(new InterneValeur(UniteRangement.COMPTE_APPROXIMATIF, i18nC.precisionApproximatif()));
precisionStore.add(new InterneValeur(UniteRangement.COMPTE_EXACT, i18nC.precisionExact()));
final ComboBox<InterneValeur> precisionCombo = new ComboBox<InterneValeur>();
precisionCombo.setForceSelection(true);
precisionCombo.setTriggerAction(TriggerAction.ALL);
precisionCombo.setDisplayField("nom");
precisionCombo.setStore(precisionStore);
precisionCombo.setEditable(false);
CellEditor editeurPrecision = new CellEditor(precisionCombo) {
@Override
public Object preProcessValue(Object valeur) {
InterneValeur retour = null;
if (valeur != null ) {
if (precisionCombo.getStore().findModel("nom", valeur.toString()) != null) {
retour = precisionCombo.getStore().findModel("nom", valeur.toString());
} else if (precisionCombo.getStore().findModel("abr", valeur.toString()) != null) {
retour = precisionCombo.getStore().findModel("abr", valeur.toString());
}
}
return retour;
}
 
@Override
public Object postProcessValue(Object valeur) {
String retour = null;
if (valeur != null ) {
if (valeur instanceof InterneValeur) {
InterneValeur valeurInterne = (InterneValeur) valeur;
retour = valeurInterne.getNom();
}
}
return retour;
}
};
ColumnConfig precisionColonne = new ColumnConfig("precision", i18nC.collectionUnitePrecision(), 50);
precisionColonne.setEditor(editeurPrecision);
colonnes.add(precisionColonne);
TextField<String> formatChp = new TextField<String>();
formatChp.setAllowBlank(false);
 
ColumnConfig formatColonne = new ColumnConfig("format", i18nC.collectionUniteFormat(), 100);
formatColonne.setEditor(new CellEditor(formatChp));
colonnes.add(formatColonne);
ColumnConfig partNombreColonne = new ColumnConfig("nombre_part", i18nC.collectionUniteNbre(), 50);
partNombreColonne.setEditor(editeurNombre);
colonnes.add(partNombreColonne);
ColumnConfig partPrecisionColonne = new ColumnConfig("precision_part", i18nC.collectionUnitePrecision(), 50);
partPrecisionColonne.setEditor(editeurPrecision);
colonnes.add(partPrecisionColonne);
ColumnConfig spNombreColonne = new ColumnConfig("nombre_sp", i18nC.collectionUniteNbre(), 50);
spNombreColonne.setEditor(editeurNombre);
colonnes.add(spNombreColonne);
ColumnConfig spPrecisionColonne = new ColumnConfig("precision_sp", i18nC.collectionUnitePrecision(), 50);
spPrecisionColonne.setEditor(editeurPrecision);
colonnes.add(spPrecisionColonne);
GridSelectionModel<UniteBase> modeleDeSelection = new GridSelectionModel<UniteBase>();
ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
modeleDeColonnes.addHeaderGroup(0, 0, new HeaderGroupConfig(i18nC.collectionUniteBase(), 1, 4));
modeleDeColonnes.addHeaderGroup(0, 4, new HeaderGroupConfig(i18nC.collectionUniteBasePart(), 1, 2));
modeleDeColonnes.addHeaderGroup(0, 6, new HeaderGroupConfig(i18nC.collectionUniteBaseSp(), 1, 2));
AggregationRowConfig<UniteBase> total = new AggregationRowConfig<UniteBase>();
total.setHtml("type", "TOTAL");
total.setSummaryType("nombre", SummaryType.SUM);
total.setSummaryFormat("nombre", NumberFormat.getFormat("#"));
total.setSummaryType("nombre_part", SummaryType.SUM);
total.setSummaryFormat("nombre_part", NumberFormat.getFormat("#"));
total.setSummaryType("nombre_sp", SummaryType.SUM);
total.setSummaryFormat("nombre_sp", NumberFormat.getFormat("#"));
modeleDeColonnes.addAggregationRow(total);
EditorGrid<UniteBase> grilleUniteBase = new EditorGrid<UniteBase>(storeGrille, modeleDeColonnes);
grilleUniteBase.setHeight(200);
grilleUniteBase.setBorders(true);
grilleUniteBase.setSelectionModel(modeleDeSelection);
grilleUniteBase.getView().setForceFit(true);
grilleUniteBase.getView().setAutoFill(true);
grilleUniteBase.setAutoExpandColumn("type");
grilleUniteBase.setStripeRows(true);
grilleUniteBase.setTrackMouseOver(true);
return grilleUniteBase;
}
private ToolBar creerBarreOutilsGrilleUniteBase() {
ToolBar barreOutils = new ToolBar();
Button ajouterBouton = creerBoutonAjouterUniteBase();
barreOutils.add(ajouterBouton);
barreOutils.add(new SeparatorToolItem());
Button supprimerBouton = creerBoutonSupprimerUniteBase();
barreOutils.add(supprimerBouton);
return barreOutils;
}
private Button creerBoutonAjouterUniteBase() {
Button bouton = new Button(i18nC.ajouter());
bouton.setIcon(Images.ICONES.ajouter());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
final MessageBox box = MessageBox.prompt(i18nC.collectionUniteType(), i18nC.collectionUniteBaseSaisirType());
box.addCallback(new Listener<MessageBoxEvent>() {
public void handleEvent(MessageBoxEvent be) {
final UniteBase unite = new UniteBase();
unite.setType(be.getValue());
unite.setTypeAutre(true);
uniteBaseGrille.getStore().add(unite);
}
});
}
});
return bouton;
}
private Button creerBoutonSupprimerUniteBase() {
Button bouton = new Button(i18nC.supprimer());
bouton.setIcon(Images.ICONES.supprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
UniteBase uniteBaseSelectionnee = uniteBaseGrille.getSelectionModel().getSelectedItem();
if (uniteBaseSelectionnee == null) {
Info.display(i18nC.informationTitreGenerique(), Mediateur.i18nM.veuillezSelectionner(i18nC.selectionnerUniteBase()));
} else if (uniteBaseSelectionnee.getTypeAutre() == false) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerUniteBaseAjoute());
} else {
uniteBaseGrille.getStore().remove(uniteBaseSelectionnee);
}
}
});
return bouton;
}
private void creerFieldsetConservation() {
FieldSet conservationFieldSet = new FieldSet();
conservationFieldSet.setHeading("Conservation");
conservationFieldSet.setCollapsible(true);
conservationFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
typePapierConservationChp = new ChampCaseACocher(i18nC.typePapierConservation(), "typePapier", true);
conservationFieldSet.add(typePapierConservationChp);
methodeConservationChp = new ChampCaseACocher(i18nC.methodeConservation(), "methodeRangement", true);
conservationFieldSet.add(methodeConservationChp);
this.add(conservationFieldSet);
}
private void creerFieldsetEtiquette() {
FieldSet etiquetteFieldSet = new FieldSet();
etiquetteFieldSet.setHeading("Conservation");
etiquetteFieldSet.setCollapsible(true);
etiquetteFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
Text fixationPoucentLabel = new Text(i18nC.fixationPourcent());
etiquetteFieldSet.add(fixationPoucentLabel);
specimenFixationPourcentChp = new ChampSliderPourcentage(i18nC.specimenFixationPourcent());
etiquetteFieldSet.add(specimenFixationPourcentChp, new FormData(200, 0));
etiquetteFixationPourcentChp = new ChampSliderPourcentage(i18nC.etiquetteFixationPourcent());
etiquetteFieldSet.add(etiquetteFixationPourcentChp, new FormData(200, 0));
specimentMethodeFixationChp = new ChampCaseACocher(i18nC.specimenMethodeFixation(), "methodeFixation", true);
etiquetteFieldSet.add(specimentMethodeFixationChp);
etiquetteMethodeFixationSurSupportChp = new ChampCaseACocher(i18nC.etiquetteMethodeFixationSurSupport(), "methodeFixation", true);
etiquetteFieldSet.add(etiquetteMethodeFixationSurSupportChp);
etiquetteMethodeFixationSurSpecimenChp = new ChampCaseACocher(i18nC.etiquetteMethodeFixationSurSpecimen(), "methodeFixationSurSpecimen", true);
etiquetteFieldSet.add(etiquetteMethodeFixationSurSpecimenChp);
typeEcritureChp = new ChampCaseACocher(i18nC.typeEcriture(), "typeEcriture", false);
etiquetteFieldSet.add(typeEcritureChp);
this.add(etiquetteFieldSet);
}
private void creerFieldsetTraitement() {
FieldSet traitementFieldSet = new FieldSet();
traitementFieldSet.setHeading("Traitements");
traitementFieldSet.setCollapsible(true);
traitementFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
traitementCombo = new ChampComboBoxListeValeurs(i18nC.collectionTraitement(), "onpi");
traitementCombo.setTrie("id_valeur");
traitementFieldSet.add(traitementCombo, new FormData(300, 0));
poisonTraitementChp = new ChampCaseACocher(i18nC.collectionTraitementPoison(), "poisonTraitement", true);
traitementFieldSet.add(poisonTraitementChp);
insecteTraitementChp = new ChampCaseACocher(i18nC.collectionTraitementInsecte(), "insecteTraitement", true);
traitementFieldSet.add(insecteTraitementChp);
 
this.add(traitementFieldSet);
}
private void creerFieldsetEtat() {
FieldSet etatFieldSet = new FieldSet();
etatFieldSet.setHeading("État général et dégradation");
etatFieldSet.setCollapsible(true);
etatFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
etatGeneralCombo = new ChampComboBoxListeValeurs(i18nC.collectionEtatGeneral(), "etat");
etatGeneralCombo.setToolTip(i18nC.collectionEtatGeneralInfo());
etatGeneralCombo.setTrie("id_valeur");
etatFieldSet.add(etatGeneralCombo, new FormData(300, 0));
specimenDegradationChp = new ChampMultiValeursMultiTypes(i18nC.degradationSpecimen(), 150, true);
specimenDegradationChp.initialiserType("specimenDegradation");
specimenDegradationChp.initialiserCombobox("niveauImportance");
etatFieldSet.add(specimenDegradationChp);
presentationDegradationChp = new ChampMultiValeursMultiTypes(i18nC.degradationPresentation(), 150, 200, true);
presentationDegradationChp.initialiserType("supportDegradation");
presentationDegradationChp.initialiserCombobox("niveauImportance");
etatFieldSet.add(presentationDegradationChp);
determinationCombo = new ChampComboBoxListeValeurs(i18nC.collectionDetermination(), "niveauDetermination");
determinationCombo.setTrie("id_valeur");
etatFieldSet.add(determinationCombo, new FormData(450, 0));
this.add(etatFieldSet);
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof ValeurListe) {
ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
rafraichirValeurListe(listeValeurs);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
private void rafraichirValeurListe(ValeurListe listeValeurs) {
if (listeValeurs.getId().equals(config.getListeId("typeCollectionBota"))) {
Formulaire.rafraichirComboBox(listeValeurs, typesCollectionBotaCombo);
} else if (listeValeurs.getId().equals(config.getListeId("typeUniteRangement"))) {
Iterator<String> it = listeValeurs.keySet().iterator();
while (it.hasNext()) {
Valeur valeur = listeValeurs.get(it.next());
UniteRangement unite = new UniteRangement();
unite.setType(valeur.getNom());
unite.setTypeAutre(false);
uniteRangementGrille.getStore().add(unite);
}
} else if (listeValeurs.getId().equals(config.getListeId("typeUniteBase"))) {
Iterator<String> it = listeValeurs.keySet().iterator();
while (it.hasNext()) {
Valeur valeur = listeValeurs.get(it.next());
UniteBase unite = new UniteBase();
unite.setType(valeur.getNom());
unite.setTypeAutre(false);
uniteBaseGrille.getStore().add(unite);
}
} else {
GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
}
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormInventaire.java
New file
0,0 → 1,70
package org.tela_botanica.client.vues.collection;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampCaseACocher;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.composants.ChampSliderPourcentage;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireOnglet;
 
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.google.gwt.core.client.GWT;
 
public class CollectionFormInventaire extends FormulaireOnglet {
 
private ChampComboBoxListeValeurs existenceInventaireCombo = null;
private ChampComboBoxListeValeurs auteurInventaireCombo = null;
private ChampComboBoxListeValeurs formeInventaireCombo = null;
private TextArea infoInventaireChp = null;
private ChampCaseACocher digitalInventaireChp = null;
private ChampSliderPourcentage pourcentDigitalInventaireChp = null;
private ChampComboBoxListeValeurs etatInventaireCombo = null;
private TextArea typeDonneeInventaireChp = null;
 
public CollectionFormInventaire(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("inventaire");
setText(Mediateur.i18nC.collectionInventaire());
int tabIndex = formulaireCourrant.tabIndex;
existenceInventaireCombo = new ChampComboBoxListeValeurs(i18nC.existenceInventaireCollection(), "onpi", tabIndex++);
existenceInventaireCombo.setTrie("id_valeur");
add(existenceInventaireCombo, new FormData(300, 0));
auteurInventaireCombo = new ChampComboBoxListeValeurs(i18nC.auteurInventaireCollection(), "onpi", tabIndex++);
auteurInventaireCombo.setTrie("id_valeur");
auteurInventaireCombo.setTabIndex(tabIndex++);
add(auteurInventaireCombo, new FormData(300, 0));
formeInventaireCombo = new ChampComboBoxListeValeurs(i18nC.formeInventaireCollection(), "inventaireForme", tabIndex++);
formeInventaireCombo.setTabIndex(tabIndex++);
add(formeInventaireCombo, new FormData(300, 0));
infoInventaireChp = new TextArea();
infoInventaireChp.setTabIndex(tabIndex++);
infoInventaireChp.setFieldLabel(i18nC.infoInventaireCollection());
add(infoInventaireChp, new FormData(550, 0));
digitalInventaireChp = new ChampCaseACocher(i18nC.digitalInventaireCollection(), "inventaireLogiciel", true);
add(digitalInventaireChp);
pourcentDigitalInventaireChp = new ChampSliderPourcentage(i18nC.pourcentDigitalInventaireCollection());
pourcentDigitalInventaireChp.setTabIndex(tabIndex++);
add(pourcentDigitalInventaireChp, new FormData(200, 0));
etatInventaireCombo = new ChampComboBoxListeValeurs(i18nC.etatInventaireCollection(), "inventaireEtat", tabIndex++);
etatInventaireCombo.setTabIndex(tabIndex++);
add(etatInventaireCombo, new FormData(300, 0));
typeDonneeInventaireChp = new TextArea();
typeDonneeInventaireChp.setTabIndex(tabIndex++);
typeDonneeInventaireChp.setFieldLabel(i18nC.typeDonneeInventaireCollection());
add(typeDonneeInventaireChp, new FormData(550, 0));
}
public void rafraichir(Object nouvellesDonnees) {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormPersonne.java
New file
0,0 → 1,654
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionAPersonne;
import org.tela_botanica.client.modeles.CollectionAPersonneListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.InterneValeur;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.StructureAPersonne;
import org.tela_botanica.client.modeles.UniteBase;
import org.tela_botanica.client.modeles.UniteRangement;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.vues.FenetreForm;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireBarreValidation;
import org.tela_botanica.client.vues.FormulaireOnglet;
import org.tela_botanica.client.vues.PersonneForm;
 
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.EventType;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Record;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnData;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridCellRenderer;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.HeaderGroupConfig;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.KeyCodes;
 
public class CollectionFormPersonne extends FormulaireOnglet implements Rafraichissable {
private Collection collection = null;
private static int idGenere = 1;
private ContentPanel panneauPrincipal = null;
private ToolBar barreOutils = null;
private EditorGrid<CollectionAPersonne> grille;
private ComboBox<Valeur> typeRelationCombo = null;
private CollectionAPersonneListe personnesAjoutees = null;
private CollectionAPersonneListe personnesSupprimees = null;
private ComboBox<Personne> personnesSaisisComboBox = null;
private Button personnesBoutonSupprimer = null;
private Button personnesBoutonModifier = null;
private ListStore<Valeur> listeIon = null;
private FenetreForm fenetreFormulaire = null;
public CollectionFormPersonne(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("personne");
setText(Mediateur.i18nC.collectionPersonne());
setStyleAttribute("padding", "0");
panneauPrincipal = creerPanneauContenantGrille();
barreOutils = creerBarreOutilsGrille();
panneauPrincipal.setTopComponent(barreOutils);
grille = creerGrille();
panneauPrincipal.add(grille);
mediateur.obtenirListeValeurEtRafraichir(this, "ion");
mediateur.obtenirListeValeurEtRafraichir(this, "relationPersonneCollection");
add(panneauPrincipal);
initialiser();
}
private void initialiser() {
// Remise à zéro des modification dans la liste des auteurs
idGenere = 1;
personnesAjoutees = new CollectionAPersonneListe();
personnesSupprimees = new CollectionAPersonneListe();
// Actualisation de l'état des boutons de la barre d'outils
actualiserEtatBoutonsBarreOutils();
collection = ((CollectionForm) formulaire).collection;
}
private ContentPanel creerPanneauContenantGrille() {
ContentPanel panneau = new ContentPanel();
panneau.setHeading(i18nC.collectionPersonneTitre());
panneau.setIcon(Images.ICONES.table());
panneau.setLayout(new FitLayout());
panneau.setFrame(true);
return panneau;
}
 
private ToolBar creerBarreOutilsGrille() {
ToolBar barreOutils = new ToolBar();
Button ajouterPersonneBouton = creerBoutonAjouter();
barreOutils.add(ajouterPersonneBouton);
barreOutils.add(new Text(" ou "));
personnesSaisisComboBox = creerComboBoxPersonnesSaisies();
barreOutils.add(personnesSaisisComboBox);
barreOutils.add(new SeparatorToolItem());
personnesBoutonModifier = creerBoutonModifier();
barreOutils.add(personnesBoutonModifier);
barreOutils.add(new SeparatorToolItem());
personnesBoutonSupprimer = creerBoutonSupprimer();
barreOutils.add(personnesBoutonSupprimer);
barreOutils.add(new SeparatorToolItem());
Button rafraichirPersonneBouton = creerBoutonRafraichir();
barreOutils.add(rafraichirPersonneBouton);
return barreOutils;
}
 
private Button creerBoutonAjouter() {
Button bouton = new Button(i18nC.ajouter());
bouton.setIcon(Images.ICONES.vcardAjouter());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
 
@Override
public void componentSelected(ButtonEvent ce) {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
fenetreFormulaire.show();
}
});
return bouton;
}
private Button creerBoutonModifier() {
Button bouton = new Button(i18nC.modifier());
bouton.setIcon(Images.ICONES.vcardModifier());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
CollectionAPersonne personneSaisiSelectionne = grille.getSelectionModel().getSelectedItem();
if (personneSaisiSelectionne == null) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
} else {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
fenetreFormulaire.show();
}
}
});
return bouton;
}
private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
String personneId = null;
if (mode.equals(Formulaire.MODE_MODIFIER)) {
CollectionAPersonne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
personneId = personneSaisieSelectionnee.getIdPersonne();
}
final FenetreForm fenetre = new FenetreForm("");
final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
fenetre.add(formulaire);
return fenetre;
}
private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, String personneId) {
PersonneForm formulaire = new PersonneForm(mediateur, personneId, this);
FormPanel panneauFormulaire = formulaire.getFormulaire();
fenetre.setHeading(panneauFormulaire.getHeading());
panneauFormulaire.setHeaderVisible(false);
panneauFormulaire.setTopComponent(null);
 
// TODO : gérer la barre d'outil avec des évènements spécifique au contexte de fenêtre modale
SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulaire);
final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
panneauFormulaire.setBottomComponent(barreValidation);
return formulaire;
}
private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
if (formulaire.soumettreFormulaire()) {
fenetre.hide();
}
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
formulaire.soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
fenetre.hide();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
fenetreFormulaire.hide();
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
fenetreFormulaire.show();
}
}
};
return ecouteur;
}
private Button creerBoutonSupprimer() {
Button bouton = new Button(i18nC.supprimer());
bouton.setIcon(Images.ICONES.vcardSupprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
CollectionAPersonne personneSaisiSelectionnee = grille.getSelectionModel().getSelectedItem();
if (personneSaisiSelectionnee == null) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
} else {
supprimerDansGrille(personneSaisiSelectionnee);
}
}
});
return bouton;
}
private Button creerBoutonRafraichir() {
Button bouton = new Button(i18nC.rafraichir());
bouton.setIcon(Images.ICONES.rafraichir());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
actualiserGrille();
}
});
return bouton;
}
private ComboBox<Personne> creerComboBoxPersonnesSaisies() {
ListStore<Personne> personnesSaisiesStore = new ListStore<Personne>();
personnesSaisiesStore.add(new ArrayList<Personne>());
ComboBox<Personne> comboBox = new ComboBox<Personne>();
comboBox.setWidth(200);
comboBox.setEmptyText(i18nC.chercherPersonneSaisi());
comboBox.setTriggerAction(TriggerAction.ALL);
comboBox.setEditable(true);
comboBox.setDisplayField("fmt_nom_complet");
comboBox.setStore(personnesSaisiesStore);
comboBox.addKeyListener(new KeyListener() {
public void componentKeyUp(ComponentEvent ce) {
if (personnesSaisisComboBox.getRawValue() != null && personnesSaisisComboBox.getRawValue().length() > 0) {
if (!ce.isNavKeyPress()) {
obtenirPersonnesSaisis(personnesSaisisComboBox.getRawValue());
}
}
}
});
comboBox.addListener(Events.Select, new Listener<BaseEvent>() {
@Override
public void handleEvent(BaseEvent be) {
if (personnesSaisisComboBox.getValue() instanceof Personne) {
Personne personneSaisiSelectionnee = personnesSaisisComboBox.getValue();
ajouterDansGrille(personneSaisiSelectionnee);
personnesSaisisComboBox.setValue(null);
}
}
});
return comboBox;
}
private void ajouterDansGrille(Personne personne) {
ajouterDansGrille(personne, 0);
}
private void ajouterDansGrille(Personne personne, int index) {
if (personne != null) {
CollectionAPersonne relationCollectionPersonne = new CollectionAPersonne();
relationCollectionPersonne.setPersonne(personne);
relationCollectionPersonne.setIdPersonne(personne.getId());
// Gestion de l'id de la collection
if (mode.equals(Formulaire.MODE_MODIFIER)) {
relationCollectionPersonne.setIdCollection(collection.getId());
}
relationCollectionPersonne.set("_etat_", aDonnee.ETAT_AJOUTE);
corrigerChampsGrille(relationCollectionPersonne);
// Ajout à la grille
grille.stopEditing();
grille.getStore().insert(relationCollectionPersonne, index);
grille.startEditing(index, 0);
grille.getSelectionModel().select(index, false);
}
}
private void supprimerDansGrille(CollectionAPersonne relationCollectionPersonne) {
if (relationCollectionPersonne != null) {
// Ajout de la personne supprimée à la liste
if ((relationCollectionPersonne.get("_etat_").equals("") || !relationCollectionPersonne.get("_etat_").equals(aDonnee.ETAT_AJOUTE))
&& relationCollectionPersonne.getId() != null
&& !relationCollectionPersonne.getId().equals("")) {
Debug.log("Nbre personnes supprimées avant:"+personnesSupprimees.size());
personnesSupprimees.put("id"+idGenere++, relationCollectionPersonne);
GWT.log("Personne supprimées : "+relationCollectionPersonne.getPersonne().getId()+" "+relationCollectionPersonne.getPersonne().getPrenom()+" "+relationCollectionPersonne.getPersonne().getNom(), null);
Debug.log("Nbre personnes supprimées :"+personnesSupprimees.size());
}
// Suppression de l'enregistrement de la grille
grille.getStore().remove(relationCollectionPersonne);
}
}
 
private EditorGrid<CollectionAPersonne> creerGrille() {
ListStore<CollectionAPersonne> storeGrille = new ListStore<CollectionAPersonne>();
storeGrille.addListener(Store.Add, new Listener<StoreEvent<CollectionAPersonne>>() {
public void handleEvent(StoreEvent<CollectionAPersonne> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
storeGrille.addListener(Store.Remove, new Listener<StoreEvent<CollectionAPersonne>>() {
public void handleEvent(StoreEvent<CollectionAPersonne> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
storeGrille.addListener(Store.Update, new Listener<StoreEvent<CollectionAPersonne>>() {
public void handleEvent(StoreEvent<CollectionAPersonne> ce) {
if (ce.getRecord().isModified("_role_") && !ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
Debug.log("id role modifié");
ce.getModel().set("_etat_", aDonnee.ETAT_MODIFIE);
}
}
});
RowNumberer pluginLigneNumero = new RowNumberer();
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(pluginLigneNumero);
typeRelationCombo = new ComboBox<Valeur>();
typeRelationCombo.setForceSelection(true);
typeRelationCombo.setTriggerAction(TriggerAction.ALL);
typeRelationCombo.setDisplayField("nom");
typeRelationCombo.setStore(new ListStore<Valeur>());
typeRelationCombo.setEditable(false);
CellEditor editeurRelation = new CellEditor(typeRelationCombo) {
@Override
public Object preProcessValue(Object valeur) {
Valeur retour = null;
if (valeur != null ) {
Debug.log(valeur.toString());
if (typeRelationCombo.getStore().findModel("nom", valeur.toString()) != null) {
retour = typeRelationCombo.getStore().findModel("nom", valeur.toString());
} else if (typeRelationCombo.getStore().findModel("abr", valeur.toString()) != null) {
retour = typeRelationCombo.getStore().findModel("abr", valeur.toString());
} else if (typeRelationCombo.getStore().findModel("id_valeur", valeur.toString()) != null) {
retour = typeRelationCombo.getStore().findModel("id_valeur", valeur.toString());
}
}
return retour;
}
 
@Override
public Object postProcessValue(Object valeur) {
String retour = null;
if (valeur != null ) {
if (valeur instanceof Valeur) {
Valeur valeurOntologie = (Valeur) valeur;
retour = valeurOntologie.getNom();
}
}
return retour;
}
};
GridCellRenderer<CollectionAPersonne> relationRendu = new GridCellRenderer<CollectionAPersonne>() {
@Override
public String render(CollectionAPersonne modele, String property, ColumnData config, int rowIndex, int colIndex, ListStore<CollectionAPersonne> store, Grid<CollectionAPersonne> grid) {
String role = modele.get("_role_");
if (typeRelationCombo.getStore() != null && role.matches("[0-9]+")) {
role = typeRelationCombo.getStore().findModel("id_valeur", role).getNom();
}
modele.set("_role_", role);
return role;
}
};
ColumnConfig typeRelationColonne = new ColumnConfig("_role_", i18nC.typeRelationPersonneCollection(), 75);
typeRelationColonne.setEditor(editeurRelation);
typeRelationColonne.setRenderer(relationRendu);
colonnes.add(typeRelationColonne);
colonnes.add(new ColumnConfig("fmt_nom_complet", i18nC.personneNomComplet(), 150));
colonnes.add(new ColumnConfig("nom", i18nC.personneNom(), 75));
colonnes.add(new ColumnConfig("prenom", i18nC.personnePrenom(), 75));
colonnes.add(new ColumnConfig("naissance_date", i18nC.date(), 75));
colonnes.add(new ColumnConfig("naissance_lieu", i18nC.lieu(), 100));
colonnes.add(creerColonneDeces());
colonnes.add(new ColumnConfig("deces_date", i18nC.date(), 75));
colonnes.add(new ColumnConfig("deces_lieu", i18nC.lieu(), 100));
GridSelectionModel<CollectionAPersonne> modeleDeSelection = new GridSelectionModel<CollectionAPersonne>();
ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
modeleDeColonnes.addHeaderGroup(0, 1, new HeaderGroupConfig(i18nC.personneIdentite(), 1, 4));
modeleDeColonnes.addHeaderGroup(0, 5, new HeaderGroupConfig(i18nC.personneNaissance(), 1, 2));
modeleDeColonnes.addHeaderGroup(0, 7, new HeaderGroupConfig(i18nC.personneDeces(), 1, 3));
EditorGrid<CollectionAPersonne> grillePersonne = new EditorGrid<CollectionAPersonne>(storeGrille, modeleDeColonnes);
grillePersonne.setHeight("100%");
grillePersonne.setBorders(true);
grillePersonne.setSelectionModel(modeleDeSelection);
grillePersonne.addPlugin(pluginLigneNumero);
grillePersonne.getView().setForceFit(true);
grillePersonne.setAutoExpandColumn("fmt_nom_complet");
grillePersonne.setStripeRows(true);
grillePersonne.setTrackMouseOver(true);
return grillePersonne;
}
public ColumnConfig creerColonneDeces() {
GridCellRenderer<CollectionAPersonne> decesRendu = new GridCellRenderer<CollectionAPersonne>() {
@Override
public String render(CollectionAPersonne modele, String property, ColumnData config, int rowIndex, int colIndex, ListStore<CollectionAPersonne> store, Grid<CollectionAPersonne> grid) {
String deces = modele.getPersonne().getDeces();
if (listeIon != null && modele.getPersonne().getDeces().matches("[0-9]+")) {
deces = listeIon.findModel("id_valeur", modele.getPersonne().getDeces()).getNom();
}
modele.set("_deces_", deces);
return deces;
}
};
ColumnConfig decesColonne = new ColumnConfig("_deces_", Mediateur.i18nC.personneDecedeeInterogation(), 50);
decesColonne.setRenderer(decesRendu);
return decesColonne;
}
public void actualiserEtatBoutonsBarreOutils() {
// Activation des boutons si la grille contient un élément
if (grille.getStore().getCount() > 0) {
personnesBoutonSupprimer.enable();
personnesBoutonModifier.enable();
}
// Désactivation des boutons si la grille ne contient plus d'élément
if (grille.getStore().getCount() == 0) {
personnesBoutonSupprimer.disable();
personnesBoutonModifier.disable();
}
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof ValeurListe) {
ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
rafraichirValeurListe(listeValeurs);
} else if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
rafraichirInformation(info);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
private void rafraichirValeurListe(ValeurListe listeValeurs) {
if (listeValeurs.getId().equals(config.getListeId("ion"))) {
listeIon = new ListStore<Valeur>();
listeIon.add(listeValeurs.toList());
} else if (listeValeurs.getId().equals(config.getListeId("relationPersonneCollection"))) {
Formulaire.rafraichirComboBox(listeValeurs, typeRelationCombo);
} else {
GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
}
}
public void rafraichirInformation(Information info) {
if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
GWT.log("MESSAGES:\n"+info.getMessages().toString(), null);
}
String type = info.getType();
if (type.equals("liste_personne")) {
if (info.getDonnee(0) != null) {
PersonneListe personnes = (PersonneListe) info.getDonnee(0);
List<Personne> liste = personnes.toList();
personnesSaisisComboBox.getStore().removeAll();
personnesSaisisComboBox.getStore().add(liste);
personnesSaisisComboBox.expand();
}
} else if (info.getType().equals("ajout_collection")) {
if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
String collectionId = (String) info.getDonnee(0);
// Suite à la récupération de l'id de la collection nouvellement ajoutée nous ajoutons les personnes liées
// En mode AJOUT, il ne peut que y avoir des personnes liées ajoutées
mediateur.ajouterCollectionAPersonne(this, collectionId, personnesAjoutees);
}
} else if (type.equals("personne_modifiee")) {
if (info.getDonnee(0) != null) {
Personne personne = (Personne) info.getDonnee(0);
CollectionAPersonne personneDansGrille = grille.getStore().findModel("id_personne", personne.getId());
int index = grille.getStore().indexOf(personneDansGrille);
grille.getStore().remove(personneDansGrille);
ajouterDansGrille(personne, index);
}
} else if (type.equals("personne_ajoutee")) {
if (info.getDonnee(0) != null) {
Personne personne = (Personne) info.getDonnee(0);
ajouterDansGrille(personne);
}
} else if (info.getType().equals("modif_collection_a_personne")) {
Info.display("Modification des personnes liées à la collection", info.toString());
} else if (info.getType().equals("suppression_collection_a_personne")) {
Info.display("Suppression des personnes liées à la collection", info.toString());
} else if (info.getType().equals("ajout_collection_a_personne")) {
Info.display("Ajout des personnes liées à la collection", info.toString());
} else if (info.getType().equals("liste_collection_a_personne")) {
if (info.getDonnee(0) != null) {
initialiser();
collection.setPersonnesLiees((CollectionAPersonneListe) info.getDonnee(0));
peupler();
}
}
}
public void peupler() {
grille.getStore().removeAll();
grille.getStore().add(collection.getPersonnesLiees().toList());
layout();
Info.display(i18nC.chargementPersonne(), i18nC.ok());
}
public ArrayList<String> verifier() {
ArrayList<String> messages = new ArrayList<String>();
String personneNumero = "";
int nbrePersonne = grille.getStore().getCount();
if (nbrePersonne > 0) {
for (int i = 0; i < nbrePersonne; i++) {
CollectionAPersonne personne = grille.getStore().getAt(i);
if (personne.get("_role_").equals("")) {
personneNumero += (i != 0 ? ", " : "")+(i+1);
}
}
if (!personneNumero.equals("")) {
messages.add("Veuillez indiquez le type de relation existant entre la collection et les personnes numéros : "+personneNumero);
}
}
return messages;
}
public void collecter() {
if (etreAccede()) {
int nbrePersonne = grille.getStore().getCount();
for (int i = 0; i < nbrePersonne; i++) {
CollectionAPersonne relationCollectionPersonne = grille.getStore().getAt(i);
if (relationCollectionPersonne.get("_etat_") != null) {
if (relationCollectionPersonne.get("_etat_").equals(aDonnee.ETAT_MODIFIE)) {
// Comme il est impossible de modifier les relations nous supprimons l'ancien enregistrement et ajoutons un nouveau avec le nouveau id_role
personnesSupprimees.put("id"+idGenere++, relationCollectionPersonne);
Debug.log("AVANT:"+relationCollectionPersonne.getIdRole());
CollectionAPersonne relationAAjouter = (CollectionAPersonne) relationCollectionPersonne.cloner(new CollectionAPersonne());
corrigerChampsGrille(relationAAjouter);// Nous modifions l'id_role
Debug.log("APRES:"+relationAAjouter.getIdRole());
personnesAjoutees.put("id"+idGenere++, relationAAjouter);
GWT.log("Personne modifiées : "+relationAAjouter.getPersonne().getPrenom()+" "+relationAAjouter.getPersonne().getNom(), null);
}
if (relationCollectionPersonne.get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
corrigerChampsGrille(relationCollectionPersonne);// Nous modifions l'id_role
personnesAjoutees.put("id"+idGenere++, relationCollectionPersonne);
GWT.log("Personne ajoutées : "+relationCollectionPersonne.getPersonne().getPrenom()+" "+relationCollectionPersonne.getPersonne().getNom(), null);
}
// Initialisation de la grille
relationCollectionPersonne.set("_etat_", "");
}
}
grille.getStore().commitChanges();
}
}
private void corrigerChampsGrille(CollectionAPersonne relationCollectionPersonne) {
String role = relationCollectionPersonne.get("_role_");
String champModele = "nom";
if (role.matches("[0-9]+")) {
champModele = "id_valeur";
}
if (typeRelationCombo.getStore().findModel(champModele, role) != null) {
String idRole = typeRelationCombo.getStore().findModel(champModele, role).getId();
relationCollectionPersonne.setIdRole(idRole);
}
}
 
public void soumettre() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
if (personnesAjoutees.size() == 0 && personnesSupprimees.size() == 0) {
Info.display("Modification des personnes liées", "Rien n'a été enregistré car le formulaire n'a pas été modifié.");
} else {
// Ajout des relations CollectionAPersonne
if (personnesAjoutees.size() != 0) {
mediateur.ajouterCollectionAPersonne(this, collection.getId(), personnesAjoutees);
}
// Suppression des relations StructureAPersonne
if (personnesSupprimees.size() != 0) {
mediateur.supprimerCollectionAPersonne(this, personnesSupprimees);
Debug.log("Nbre personnes supprimées :"+personnesSupprimees.size());
}
}
}
}
private void obtenirPersonnesSaisis(String nom) {
mediateur.selectionnerPersonneParNomComplet(this, null, nom+"%");
}
private void actualiserGrille() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.selectionnerCollectionAPersonne(this, collection.getId(), null);
} else {
grille.getStore().removeAll();
layout();
}
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormPublication.java
New file
0,0 → 1,538
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.List;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionAPublication;
import org.tela_botanica.client.modeles.CollectionAPublicationListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.vues.FenetreForm;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireBarreValidation;
import org.tela_botanica.client.vues.FormulaireOnglet;
import org.tela_botanica.client.vues.PublicationForm;
 
import com.extjs.gxt.ui.client.core.XTemplate;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnData;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridCellRenderer;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.RowExpander;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
 
public class CollectionFormPublication extends FormulaireOnglet implements Rafraichissable {
private Collection collection = null;
private static int idGenere = 1;
private ContentPanel panneauPrincipal = null;
private ToolBar barreOutils = null;
private EditorGrid<CollectionAPublication> grille;
private CollectionAPublicationListe publicationsAjoutees = null;
private CollectionAPublicationListe publicationsSupprimees = null;
private ComboBox<Publication> publicationsSaisiesComboBox = null;
private Button publicationsBoutonSupprimer = null;
private Button publicationsBoutonModifier = null;
private FenetreForm fenetreFormulaire = null;
public CollectionFormPublication(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("publication");
setText(Mediateur.i18nC.collectionPublication());
setStyleAttribute("padding", "0");
panneauPrincipal = creerPanneauContenantGrille();
barreOutils = creerBarreOutilsGrille();
panneauPrincipal.setTopComponent(barreOutils);
grille = creerGrille();
panneauPrincipal.add(grille);
add(panneauPrincipal);
initialiser();
}
private void initialiser() {
// Remise à zéro des modification dans la liste des auteurs
idGenere = 1;
publicationsAjoutees = new CollectionAPublicationListe();
publicationsSupprimees = new CollectionAPublicationListe();
// Actualisation de l'état des boutons de la barre d'outils
actualiserEtatBoutonsBarreOutils();
collection = ((CollectionForm) formulaire).collection;
}
private ContentPanel creerPanneauContenantGrille() {
ContentPanel panneau = new ContentPanel();
panneau.setHeading(i18nC.collectionPublicationTitre());
panneau.setIcon(Images.ICONES.table());
panneau.setLayout(new FitLayout());
panneau.setFrame(true);
return panneau;
}
 
private ToolBar creerBarreOutilsGrille() {
ToolBar barreOutils = new ToolBar();
Button ajouterBouton = creerBoutonAjouter();
barreOutils.add(ajouterBouton);
barreOutils.add(new Text(" ou "));
publicationsSaisiesComboBox = creerComboBoxPublicationsSaisis();
barreOutils.add(publicationsSaisiesComboBox);
barreOutils.add(new SeparatorToolItem());
publicationsBoutonModifier = creerBoutonModifier();
barreOutils.add(publicationsBoutonModifier);
barreOutils.add(new SeparatorToolItem());
publicationsBoutonSupprimer = creerBoutonSupprimer();
barreOutils.add(publicationsBoutonSupprimer);
barreOutils.add(new SeparatorToolItem());
Button rafraichirBouton = creerBoutonRafraichir();
barreOutils.add(rafraichirBouton);
return barreOutils;
}
 
private Button creerBoutonAjouter() {
Button bouton = new Button(i18nC.ajouter());
bouton.setIcon(Images.ICONES.vcardAjouter());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
fenetreFormulaire.show();
}
});
return bouton;
}
private Button creerBoutonModifier() {
Button bouton = new Button(i18nC.modifier());
bouton.setIcon(Images.ICONES.vcardModifier());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
CollectionAPublication publicationSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
if (publicationSaisieSelectionnee == null) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
} else {
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
fenetreFormulaire.show();
}
}
});
return bouton;
}
private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
String publicationId = null;
if (mode.equals(Formulaire.MODE_MODIFIER)) {
CollectionAPublication publicationSaisiSelectionne = grille.getSelectionModel().getSelectedItem();
publicationId = publicationSaisiSelectionne.getIdPublication();
}
final FenetreForm fenetre = new FenetreForm("");
final PublicationForm formulaire = creerFormulairePublication(fenetre, publicationId);
fenetre.add(formulaire);
return fenetre;
}
private PublicationForm creerFormulairePublication(final FenetreForm fenetre, final String publicationId) {
PublicationForm formulairePublication = new PublicationForm(mediateur, publicationId, this);
FormPanel panneauFormulaire = formulairePublication.getFormulaire();
fenetre.setHeading(panneauFormulaire.getHeading());
panneauFormulaire.setHeaderVisible(false);
panneauFormulaire.setTopComponent(null);
 
// TODO : gérer la barre d'outil avec des évènements spécifique au contexte de fenêtre modale
SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePublication(fenetre, formulairePublication);
final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
panneauFormulaire.setBottomComponent(barreValidation);
return formulairePublication;
}
private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePublication(final FenetreForm fenetre, final PublicationForm formulaire) {
SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
String code = ((Button) ce.getComponent()).getData("code");
if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
if (formulaire.soumettreFormulaire()) {
fenetre.hide();
}
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
formulaire.soumettreFormulaire();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
fenetre.hide();
} else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
fenetreFormulaire.hide();
fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
fenetreFormulaire.show();
}
}
};
return ecouteur;
}
private Button creerBoutonSupprimer() {
Button bouton = new Button(i18nC.supprimer());
bouton.setIcon(Images.ICONES.vcardSupprimer());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
CollectionAPublication publicationSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
if (publicationSaisieSelectionnee == null) {
Info.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
} else {
supprimerDansGrille(publicationSaisieSelectionnee);
}
}
});
return bouton;
}
private Button creerBoutonRafraichir() {
Button bouton = new Button(i18nC.rafraichir());
bouton.setIcon(Images.ICONES.rafraichir());
bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
@Override
public void componentSelected(ButtonEvent ce) {
actualiserGrille();
}
});
return bouton;
}
private void actualiserGrille() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
mediateur.selectionnerCollectionAPublication(this, collection.getId());
} else {
grille.getStore().removeAll();
layout();
}
}
private ComboBox<Publication> creerComboBoxPublicationsSaisis() {
ListStore<Publication> publicationsSaisiesStore = new ListStore<Publication>();
ComboBox<Publication> comboBox = new ComboBox<Publication>();
comboBox.setWidth(400);
comboBox.setEmptyText(i18nC.chercherPublicationSaisi());
comboBox.setTriggerAction(TriggerAction.ALL);
comboBox.setEditable(true);
comboBox.setDisplayField("fmt_nom_complet");
comboBox.setStore(publicationsSaisiesStore);
comboBox.addKeyListener(new KeyListener() {
public void componentKeyUp(ComponentEvent ce) {
if (publicationsSaisiesComboBox.getRawValue() != null && publicationsSaisiesComboBox.getRawValue().length() > 0) {
if (!ce.isNavKeyPress()) {
obtenirPublicationsSaisies(publicationsSaisiesComboBox.getRawValue());
}
}
}
});
comboBox.addListener(Events.Select, new Listener<BaseEvent>() {
@Override
public void handleEvent(BaseEvent be) {
if (publicationsSaisiesComboBox.getValue() instanceof Publication) {
Publication publicationSaisieSelectionne = publicationsSaisiesComboBox.getValue();
ajouterDansGrille(publicationSaisieSelectionne);
publicationsSaisiesComboBox.setValue(null);
}
}
});
return comboBox;
}
private void ajouterDansGrille(Publication publication) {
ajouterDansGrille(publication, 0);
}
private void ajouterDansGrille(Publication publication, int index) {
if (publication != null) {
CollectionAPublication publicationLiee = new CollectionAPublication();
publicationLiee.setPublication(publication);
publicationLiee.setIdPublication(publication.getId());
// Gestion de l'id de la collection
if (mode.equals(Formulaire.MODE_MODIFIER)) {
publicationLiee.setIdCollection(collection.getId());
}
publicationLiee.set("_etat_", aDonnee.ETAT_AJOUTE);
// Ajout à la grille
grille.stopEditing();
grille.getStore().insert(publicationLiee, 0);
grille.startEditing(index, 0);
grille.getSelectionModel().select(index, false);
}
}
private void supprimerDansGrille(CollectionAPublication publicationLiee) {
if (publicationLiee != null) {
// Ajout de la personne supprimée à la liste
if ((publicationLiee.get("_etat_").equals("") || !publicationLiee.get("_etat_").equals(aDonnee.ETAT_AJOUTE))
&& publicationLiee.getId() != null
&& !publicationLiee.getId().equals("")) {
Debug.log("Nbre publications supprimées avant:"+publicationsSupprimees.size());
publicationsSupprimees.put("id"+idGenere++, publicationLiee);
GWT.log("Publications supprimée : "+publicationLiee.getPublication().getId()+" "+publicationLiee.getPublication().getNomComplet(), null);
Debug.log("Nbre publications supprimées :"+publicationsSupprimees.size());
}
// Suppression de l'enregistrement de la grille
grille.getStore().remove(publicationLiee);
}
}
 
private EditorGrid<CollectionAPublication> creerGrille() {
ListStore<CollectionAPublication> storeGrille = new ListStore<CollectionAPublication>();
storeGrille.addListener(Store.Add, new Listener<StoreEvent<CollectionAPublication>>() {
public void handleEvent(StoreEvent<CollectionAPublication> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
storeGrille.addListener(Store.Remove, new Listener<StoreEvent<CollectionAPublication>>() {
public void handleEvent(StoreEvent<CollectionAPublication> ce) {
actualiserEtatBoutonsBarreOutils();
}
});
RowNumberer numeroPlugin = new RowNumberer();
numeroPlugin.setHeader("#");
XTemplate infoTpl = XTemplate.create("<p>"+
"<span style='font-weight:bold;'>"+i18nC.publicationAuteurs()+" :</span> {fmt_auteur}<br />"+
"<span style='font-weight:bold;'>"+i18nC.publicationTitre()+" :</span> {titre}<br />"+
"<span style='font-weight:bold;'>"+i18nC.publicationRevueCollection()+" :</span> {collection}<br />"+
"<span style='font-weight:bold;'>"+i18nC.publicationEditeur()+" :</span> {_editeur_}"+
"</p>");
RowExpander expansionPlugin = new RowExpander();
expansionPlugin.setTemplate(infoTpl);
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(expansionPlugin);
colonnes.add(numeroPlugin);
colonnes.add(new ColumnConfig("fmt_auteur", i18nC.publicationAuteurs(), 150));
colonnes.add(new ColumnConfig("titre", i18nC.publicationTitre(), 150));
colonnes.add(new ColumnConfig("collection", i18nC.publicationRevueCollection(), 75));
colonnes.add(creerColonneEditeur());
colonnes.add(creerColonneAnneePublication());
colonnes.add(new ColumnConfig("indication_nvt", i18nC.publicationNvt(), 75));
colonnes.add(new ColumnConfig("fascicule", i18nC.publicationFascicule(), 75));
colonnes.add(new ColumnConfig("truk_pages", i18nC.publicationPage(), 50));
GridSelectionModel<CollectionAPublication> modeleDeSelection = new GridSelectionModel<CollectionAPublication>();
ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
modeleDeColonnes.getColumn(0).setWidget(Images.ICONES.information().createImage(), "Info");
EditorGrid<CollectionAPublication> grillePublications = new EditorGrid<CollectionAPublication>(storeGrille, modeleDeColonnes);
grillePublications.setHeight("100%");
grillePublications.setBorders(true);
grillePublications.setSelectionModel(modeleDeSelection);
grillePublications.addPlugin(expansionPlugin);
grillePublications.addPlugin(numeroPlugin);
grillePublications.getView().setForceFit(true);
grillePublications.setAutoExpandColumn("titre");
grillePublications.setStripeRows(true);
grillePublications.setTrackMouseOver(true);
return grillePublications;
}
private ColumnConfig creerColonneEditeur() {
GridCellRenderer<CollectionAPublication> editeurRendu = new GridCellRenderer<CollectionAPublication>() {
@Override
public String render(CollectionAPublication model, String property, ColumnData config, int rowIndex, int colIndex, ListStore<CollectionAPublication> store, Grid<CollectionAPublication> grid) {
String editeur = model.getPublication().getNomEditeur();
model.set("_editeur_", editeur);
return editeur;
}
};
ColumnConfig editeurColonne = new ColumnConfig("_editeur_", Mediateur.i18nC.publicationEditeur(), 135);
editeurColonne.setRenderer(editeurRendu);
return editeurColonne;
}
private ColumnConfig creerColonneAnneePublication() {
GridCellRenderer<CollectionAPublication> datePublicationRendu = new GridCellRenderer<CollectionAPublication>() {
@Override
public String render(CollectionAPublication model, String property, ColumnData config, int rowIndex, int colIndex, ListStore<CollectionAPublication> store, Grid<CollectionAPublication> grid) {
String annee = model.getPublication().getAnneeParution();
model.set("_annee_", annee);
return annee;
}
};
ColumnConfig datePublicationColonne = new ColumnConfig("_annee_", Mediateur.i18nC.publicationDateParution(), 75);
datePublicationColonne.setRenderer(datePublicationRendu);
return datePublicationColonne;
}
 
public void actualiserEtatBoutonsBarreOutils() {
// Activation des boutons si la grille contient un élément
if (grille.getStore().getCount() > 0) {
publicationsBoutonSupprimer.enable();
publicationsBoutonModifier.enable();
}
// Désactivation des boutons si la grille ne contient plus d'élément
if (grille.getStore().getCount() == 0) {
publicationsBoutonSupprimer.disable();
publicationsBoutonModifier.disable();
}
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
rafraichirInformation(info);
} else if (nouvellesDonnees instanceof PublicationListe) {
PublicationListe listePublications = (PublicationListe) nouvellesDonnees;
rafraichirPublicationListe(listePublications);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
private void rafraichirPublicationListe(PublicationListe listePublications) {
publicationsSaisiesComboBox.getStore().removeAll();
publicationsSaisiesComboBox.getStore().add(listePublications.toList());
publicationsSaisiesComboBox.expand();
}
public void rafraichirInformation(Information info) {
if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
GWT.log("MESSAGES:\n"+info.getMessages().toString(), null);
}
String type = info.getType();
if (type.equals("liste_collection_a_publication")) {
if (info.getDonnee(0) != null) {
initialiser();
collection.setPublicationsLiees((CollectionAPublicationListe) info.getDonnee(0));
peupler();
}
} else if (type.equals("publication_modifiee")) {
if (info.getDonnee(0) != null) {
Publication publication = (Publication) info.getDonnee(0);
CollectionAPublication publicationDansGrille = grille.getStore().findModel("id_publication", publication.getId());
int index = grille.getStore().indexOf(publicationDansGrille);
grille.getStore().remove(publicationDansGrille);
ajouterDansGrille(publication, index);
}
} else if (type.equals("publication_ajoutee")) {
if (info.getDonnee(0) != null) {
Publication publication = (Publication) info.getDonnee(0);
ajouterDansGrille(publication);
}
} else if (type.equals("suppression_collection_a_publication")) {
Info.display("Suppression des publications liées à la collection", info.toString());
} else if (type.equals("ajout_collection_a_publication")) {
Info.display("Ajout des publications liées à la collection", info.toString());
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(info.getClass(), this.getClass()), null);
}
}
 
public void peupler() {
grille.getStore().removeAll();
grille.getStore().add(collection.getPublicationsLiees().toList());
layout();
Info.display(i18nC.chargementPublication(), i18nC.ok());
}
 
public void collecter() {
if (etreAccede()) {
int nbrePublication = grille.getStore().getCount();
for (int i = 0; i < nbrePublication; i++) {
CollectionAPublication publicationLiee = grille.getStore().getAt(i);
if (publicationLiee.get("_etat_") != null) {
if (publicationLiee.get("_etat_").equals(aDonnee.ETAT_MODIFIE)) {
// Comme il est impossible de modifier les relations nous supprimons l'ancien enregistrement et ajoutons un nouveau avec le nouveau id_role
publicationsSupprimees.put("id"+idGenere++, publicationLiee);
CollectionAPublication relationAAjouter = (CollectionAPublication) publicationLiee.cloner(new CollectionAPublication());
publicationsAjoutees.put("id"+idGenere++, relationAAjouter);
Debug.log(publicationLiee.toString());
}
if (publicationLiee.get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
publicationsAjoutees.put("id"+idGenere++, publicationLiee);
Debug.log(publicationLiee.toString());
}
// Initialisation de la grille
publicationLiee.set("_etat_", "");
}
}
grille.getStore().commitChanges();
}
}
public void soumettre() {
if (mode.equals(Formulaire.MODE_MODIFIER)) {
if (publicationsAjoutees.size() == 0 && publicationsSupprimees.size() == 0) {
Info.display("Modification des publications liées", "Rien n'a été enregistré car le formulaire n'a pas été modifié.");
} else {
// Ajout des relations CollectionAPublication
if (publicationsAjoutees.size() != 0) {
mediateur.ajouterCollectionAPublication(this, collection.getId(), publicationsAjoutees);
Debug.log("Nbre publications ajoutées :"+publicationsAjoutees.size());
}
// Suppression des relations CollectionAPublication
if (publicationsSupprimees.size() != 0) {
mediateur.supprimerCollectionAPublication(this, publicationsSupprimees);
Debug.log("Nbre publications supprimées :"+publicationsSupprimees.size());
}
}
}
}
private void obtenirPublicationsSaisies(String nom) {
mediateur.selectionnerPublicationParNomComplet(this, null, nom+"%");
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormContenu.java
New file
0,0 → 1,209
package org.tela_botanica.client.vues.collection;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampCaseACocher;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.composants.ChampSliderPourcentage;
import org.tela_botanica.client.composants.ConteneurMultiChamps;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireOnglet;
 
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.form.DateField;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.HBoxLayoutData;
import com.google.gwt.core.client.GWT;
 
public class CollectionFormContenu extends FormulaireOnglet implements Rafraichissable {
private ChampCaseACocher natureChp = null;
private TextArea specialiteChp = null;
private ChampCaseACocher periodeConstitutionChp = null;
private ChampComboBoxListeValeurs dateDebutCombo = null;
private ChampComboBoxListeValeurs dateFinCombo = null;
private DateField dateDebutChp = null;
private DateField dateFinChp = null;
private TextArea annotationClassementChp = null;
private ChampComboBoxListeValeurs etatClassementCombo = null;
private ChampComboBoxListeValeurs precisionDateCombo = null;
private ChampComboBoxListeValeurs precisionLocaliteCombo = null;
private TextArea etiquetteAnnotationChp = null;
private ChampComboBoxListeValeurs integreCollectionCombo = null;
private ChampComboBoxListeValeurs infoIntegreCollectionCombo = null;
private ChampSliderPourcentage auteurTitrePourcentChp;
private ChampSliderPourcentage famillePourcentChp;
private ChampSliderPourcentage genrePourcentChp;
private ChampSliderPourcentage spPourcentChp;
private ChampSliderPourcentage auteurSpPourcentChp;
private ChampSliderPourcentage localitePourcentChp;
private ChampSliderPourcentage datePourcentChp;
 
public CollectionFormContenu(Formulaire formulaireCourrant) {
initialiserOnglet(formulaireCourrant);
setId("contenu");
setText(Mediateur.i18nC.collectionContenu());
creerFieldsetNature();
// TODO : réaliser un champ couverture géographique détaillé
creerFieldsetPeriode();
creerFieldsetClassement();
creerFieldsetEtiquette();
creerFieldsetIntegration();
}
private void creerFieldsetNature() {
FieldSet natureFieldSet = new FieldSet();
natureFieldSet.setHeading("Nature");
natureFieldSet.setCollapsible(true);
natureFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
natureChp = new ChampCaseACocher(i18nC.natureVegetaleContenu(), "natureVegetale", false);
natureFieldSet.add(natureChp);
specialiteChp = new TextArea();
specialiteChp.setFieldLabel(i18nC.specialiteCollection());
specialiteChp.setToolTip(i18nC.specialiteCollectionInfo());
natureFieldSet.add(specialiteChp, new FormData(550, 0));
add(natureFieldSet);
}
private void creerFieldsetPeriode() {
FieldSet periodeFieldSet = new FieldSet();
periodeFieldSet.setHeading("Période de constitution");
periodeFieldSet.setCollapsible(true);
periodeFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
periodeConstitutionChp = new ChampCaseACocher(i18nC.periodeConstitution(), "siecleNaturaliste", false);
periodeFieldSet.add(periodeConstitutionChp);
 
ConteneurMultiChamps dateDebutConteneur = new ConteneurMultiChamps(i18nC.dateDebutCollection());
dateDebutChp = new DateField();
dateDebutConteneur.ajouterChamp(dateDebutChp, new HBoxLayoutData(new Margins(0, 20, 0, 0)));
dateDebutCombo = new ChampComboBoxListeValeurs(null, "dateDebut");
dateDebutCombo.setTrie("id_valeur");
dateDebutConteneur.ajouterChamp(dateDebutCombo);
periodeFieldSet.add(dateDebutConteneur);
ConteneurMultiChamps dateFinConteneur = new ConteneurMultiChamps(i18nC.dateFinCollection());
dateFinChp = new DateField();
dateFinConteneur.ajouterChamp(dateFinChp, new HBoxLayoutData(new Margins(0, 20, 0, 0)));
dateFinCombo = new ChampComboBoxListeValeurs(null, "dateFin");
dateFinCombo.setTrie("id_valeur");
dateFinConteneur.ajouterChamp(dateFinCombo);
periodeFieldSet.add(dateFinConteneur);
add(periodeFieldSet);
}
private void creerFieldsetClassement() {
FieldSet classementFieldSet = new FieldSet();
classementFieldSet.setHeading("Classement");
classementFieldSet.setCollapsible(true);
classementFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
 
etatClassementCombo = new ChampComboBoxListeValeurs(i18nC.etatClassementCollection(), "etat", tabIndex++);
classementFieldSet.add(etatClassementCombo);
 
annotationClassementChp = new TextArea();
annotationClassementChp.setFieldLabel(i18nC.annotationClassementCollection());
classementFieldSet.add(annotationClassementChp, new FormData(550, 0));
Text infoClassement = new Text(i18nC.annotationClassementCollectionInfo());
classementFieldSet.add(infoClassement);
add(classementFieldSet);
}
private void creerFieldsetEtiquette() {
FieldSet etiquetteFieldSet = new FieldSet();
etiquetteFieldSet.setHeading("Étiquette");
etiquetteFieldSet.setCollapsible(true);
etiquetteFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
Text renseignementPoucentLabel = new Text(i18nC.renseignementEtiquetteCollection());
renseignementPoucentLabel.setTagName("label");
renseignementPoucentLabel.setStyleName("x-form-item-label");
etiquetteFieldSet.add(renseignementPoucentLabel);
auteurTitrePourcentChp = new ChampSliderPourcentage(i18nC.auteurTitrePourcentCollection());
etiquetteFieldSet.add(auteurTitrePourcentChp, new FormData(200, 0));
famillePourcentChp = new ChampSliderPourcentage(i18nC.famillePourcentCollection());
etiquetteFieldSet.add(famillePourcentChp, new FormData(200, 0));
genrePourcentChp = new ChampSliderPourcentage(i18nC.genrePourcentCollection());
etiquetteFieldSet.add(genrePourcentChp, new FormData(200, 0));
spPourcentChp = new ChampSliderPourcentage(i18nC.spPourcentCollection());
etiquetteFieldSet.add(spPourcentChp, new FormData(200, 0));
auteurSpPourcentChp = new ChampSliderPourcentage(i18nC.auteurSpPourcentCollection());
etiquetteFieldSet.add(auteurSpPourcentChp, new FormData(200, 0));
localitePourcentChp = new ChampSliderPourcentage(i18nC.localitePourcentCollection());
etiquetteFieldSet.add(localitePourcentChp, new FormData(200, 0));
datePourcentChp = new ChampSliderPourcentage(i18nC.datePourcentCollection());
etiquetteFieldSet.add(datePourcentChp, new FormData(200, 0));
precisionLocaliteCombo = new ChampComboBoxListeValeurs(i18nC.precisionLocaliteCollection(), "onep", tabIndex++);
etiquetteFieldSet.add(precisionLocaliteCombo);
precisionDateCombo = new ChampComboBoxListeValeurs(i18nC.precisionDateCollection(), "onep", tabIndex++);
etiquetteFieldSet.add(precisionDateCombo);
 
etiquetteAnnotationChp = new TextArea();
etiquetteAnnotationChp.setFieldLabel(i18nC.etiquetteAnnotationCollection());
etiquetteAnnotationChp.setToolTip(i18nC.etiquetteAnnotationCollectionInfo());
etiquetteFieldSet.add(etiquetteAnnotationChp, new FormData(550, 0));
add(etiquetteFieldSet);
}
private void creerFieldsetIntegration() {
FieldSet integrationFieldSet = new FieldSet();
integrationFieldSet.setHeading("Collections intégrées");
integrationFieldSet.setCollapsible(true);
integrationFieldSet.setLayout(Formulaire.creerFormLayout(350, alignementLabelDefaut));
integreCollectionCombo = new ChampComboBoxListeValeurs(i18nC.integreCollection(), "onpi", tabIndex++);
integrationFieldSet.add(integreCollectionCombo);
infoIntegreCollectionCombo = new ChampComboBoxListeValeurs(i18nC.infoIntegreCollection(), "onp", tabIndex++);
integrationFieldSet.add(infoIntegreCollectionCombo);
Text infoIntegration = new Text(i18nC.infoIntegrationCollection());
integrationFieldSet.add(infoIntegration);
add(integrationFieldSet);
}
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof ValeurListe) {
ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
rafraichirValeurListe(listeValeurs);
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
private void rafraichirValeurListe(ValeurListe listeValeurs) {
if (listeValeurs.getId().equals(config.getListeId(""))) {
} else {
GWT.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!", null);
}
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionVue.java
New file
0,0 → 1,58
package org.tela_botanica.client.vues.collection;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Information;
 
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
import com.google.gwt.core.client.GWT;
 
public class CollectionVue extends LayoutContainer implements Rafraichissable {
 
private Mediateur mediateur = null;
private CollectionListeVue listeCollectionPanneau = null;
private CollectionDetailVue detailCollectionPanneau = null;
 
public CollectionVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
BorderLayout layout = new BorderLayout();
layout.setEnableState(false);
setLayout(layout);
 
listeCollectionPanneau = new CollectionListeVue(mediateur);
add(listeCollectionPanneau, new BorderLayoutData(LayoutRegion.CENTER));
 
detailCollectionPanneau = new CollectionDetailVue(mediateur);
BorderLayoutData dispositionSud = new BorderLayoutData(LayoutRegion.SOUTH, .5f, 200, 1000);
dispositionSud.setSplit(true);
dispositionSud.setMargins(new Margins(5, 0, 0, 0));
add(detailCollectionPanneau, dispositionSud);
}
 
public void rafraichir(Object nouvellesDonnees) {
// Nous passons l'objet aux méthodes rafraichir des panneaux composant le panneau principal Structure
if (nouvellesDonnees instanceof Collection) {
detailCollectionPanneau.rafraichir(nouvellesDonnees);
} else if (nouvellesDonnees instanceof CollectionListe) {
listeCollectionPanneau.rafraichir(nouvellesDonnees);
mediateur.desactiverChargement();
} else if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
if (info.getType().equals("liste_collection_a_personne")
|| info.getType().equals("liste_collection_a_publication")
|| info.getType().equals("liste_collection_a_commentaire")) {
detailCollectionPanneau.rafraichir(nouvellesDonnees);
}
}else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
}
}
/trunk/src/org/tela_botanica/client/vues/collection/ContenuVue.java
New file
0,0 → 1,71
package org.tela_botanica.client.vues.collection;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.StructureListe;
 
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.google.gwt.core.client.GWT;
 
public class ContenuVue extends LayoutContainer implements Rafraichissable {
private Mediateur mediateur = null;
public ContenuVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
setLayout(new FitLayout());
setBorders(true);
}
public Rafraichissable getContenu() {
Rafraichissable contenuPanneauCentre = null;
if (getItems() != null && getItems().size() == 1) {
contenuPanneauCentre = (Rafraichissable) getItem(0);
}
return contenuPanneauCentre;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// RAFRAICHISSEMENT
//+----------------------------------------------------------------------------------------------------------------+
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof StructureListe) {
mediateur.afficherListeStructures((StructureListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof CollectionListe) {
mediateur.afficherListeCollections((CollectionListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof PublicationListe) {
mediateur.afficherListePublication((PublicationListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof PersonneListe) {
mediateur.afficherListePersonnes((PersonneListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof ProjetListe) {
GWT.log("reception d'une liste de projets", null);
mediateur.afficherListeProjets((ProjetListe) nouvellesDonnees);
} else if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
if (info.getType().equals("maj_utilisateur")) {
if (getContenu() != null) {
getContenu().rafraichir(info);
}
} else {
// Affichage des éventuels messages de déboguage ou d'alerte
if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
GWT.log(info.getMessages().toString(), null);
}
// Traitement en fonction des types d'information
if (info.getType().equals("liste_personne")) {
mediateur.afficherListePersonnes((PersonneListe) info.getDonnee(0));
Info.display("Chargement d'une liste de personnes", "");
}
}
}
mediateur.desactiverChargement();
}
}
/trunk/src/org/tela_botanica/client/vues/collection/CollectionListeVue.java
New file
0,0 → 1,190
package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Collection;
import org.tela_botanica.client.modeles.CollectionListe;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.Utilisateur;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
 
public class CollectionListeVue extends ContentPanel implements Rafraichissable {
private Mediateur mediateur = null;
private Constantes i18nC = null;
 
private Grid<Collection> grille = null;
private ListStore<Collection> store = null;
 
private Button modifier;
private Button supprimer;
private Button ajouter;
 
public CollectionListeVue(Mediateur mediateurCourant) {
mediateur = mediateurCourant;
i18nC = Mediateur.i18nC;
setLayout(new FitLayout());
setHeading(i18nC.collectionListeTitre());
ToolBar toolBar = new ToolBar();
ajouter = new Button(i18nC.ajouter());
ajouter.setIcon(Images.ICONES.ajouter());
ajouter.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
mediateur.clicAjouterCollection();
}
});
toolBar.add(ajouter);
 
modifier = new Button(i18nC.modifier());
modifier.setIcon(Images.ICONES.formModifier());
modifier.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
mediateur.clicModifierCollection(grille.getSelectionModel().getSelectedItems());
}
});
toolBar.add(modifier);
supprimer = new Button(i18nC.supprimer());
supprimer.setIcon(Images.ICONES.supprimer());
supprimer.addSelectionListener(new SelectionListener<ButtonEvent>() {
public void componentSelected(ButtonEvent ce) {
clicSupprimerCollection(grille.getSelectionModel().getSelectedItems());
}
});
toolBar.add(supprimer);
 
setTopComponent(toolBar);
 
List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
colonnes.add(new ColumnConfig("nom", i18nC.personneNom(), 300));
colonnes.add(new ColumnConfig("structure_nom", i18nC.structure(), 200));
colonnes.add(new ColumnConfig("structure_ville", i18nC.ville(), 150));
colonnes.get(1).setHidden(true);
ColumnModel modeleDeColonne = new ColumnModel(colonnes);
GridSelectionModel<Collection> modeleDeSelection = new GridSelectionModel<Collection>();
modeleDeSelection.addSelectionChangedListener(new SelectionChangedListener<Collection>() {
public void selectionChanged(SelectionChangedEvent<Collection> event) {
Collection collectionSelectionnee = (Collection) event.getSelectedItem();
clicListe(collectionSelectionnee);
}
});
store = new ListStore<Collection>();
store.sort("nom", SortDir.ASC);
grille = new Grid<Collection>(store, modeleDeColonne);
grille.setWidth("100%");
grille.setAutoExpandColumn("nom");
grille.getView().setAutoFill(true);
grille.getView().setForceFit(true);
grille.setSelectionModel(modeleDeSelection);
grille.addListener(Events.ViewReady, new Listener<BaseEvent>() {
@Override
public void handleEvent(BaseEvent be) {
grille.getSelectionModel().select(0, false);
}
});
grille.addListener(Events.OnDoubleClick, new Listener<BaseEvent>() {
@Override
public void handleEvent(BaseEvent be) {
modifier.fireEvent(Events.Select);
}
});
add(grille);
}
 
private void clicListe(Collection collection) {
if (collection != null && store.getCount() > 0) {
mediateur.clicListeCollection(collection);
}
}
private void clicSupprimerCollection(List<Collection> collectionsASupprimer) {
if (store.getCount() > 0) {
mediateur.clicSupprimerCollection(this, collectionsASupprimer);
}
}
private void gererEtatActivationBouton() {
int nbreElementDuMagazin = store.getCount();
ajouter.enable();
if (nbreElementDuMagazin == 0) {
supprimer.disable();
modifier.disable();
} else if (nbreElementDuMagazin > 0) {
modifier.enable();
if (((Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT)).isIdentifie()) {
supprimer.enable();
}
}
}
 
public void rafraichir(Object nouvellesDonnees) {
if (nouvellesDonnees instanceof CollectionListe) {
CollectionListe collections = (CollectionListe) nouvellesDonnees;
 
if (collections != null) {
List<Collection> liste = collections.toList();
store.removeAll();
store.add(liste);
mediateur.actualiserPanneauCentral();
}
} else if (nouvellesDonnees instanceof Information) {
Information info = (Information) nouvellesDonnees;
if (info.getType().equals("suppression_collection")) {
// Affichage d'un message d'information
Info.display(i18nC.suppressionCollection(), info.toString().replaceAll("\n", "<br />"));
 
supprimerCollectionsSelectionnees();
gererEtatActivationBouton();
} else if (info.getType().equals("maj_utilisateur")) {
gererEtatActivationBouton();
}
} else {
GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
}
layout();
}
private void supprimerCollectionsSelectionnees() {
List<Collection> collectionsSelectionnees = grille.getSelectionModel().getSelectedItems();
Iterator<Collection> it = collectionsSelectionnees.iterator();
while (it.hasNext()) {
grille.getStore().remove(it.next());
}
layout(true);
}
}
/trunk/src/org/tela_botanica/client/vues/PublicationDetailVue.java
6,6 → 6,7
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.vues.collection.DetailVue;
 
import com.extjs.gxt.ui.client.util.Format;
import com.extjs.gxt.ui.client.util.Params;