Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.vues.projet;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

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.composants.ChampFiltreRecherche;

import org.tela_botanica.client.composants.InfoLogger;

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.Information;

import org.tela_botanica.client.modeles.Utilisateur;

import org.tela_botanica.client.modeles.projet.Projet;

import org.tela_botanica.client.modeles.projet.ProjetListe;

import org.tela_botanica.client.modeles.publication.Publication;

import org.tela_botanica.client.modeles.structure.StructureListe;

import org.tela_botanica.client.util.Debug;

import org.tela_botanica.client.util.UtilString;

import org.tela_botanica.client.vues.BarrePaginationVue;

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.store.StoreSorter;

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;

import com.google.gwt.user.client.Window;

public class ProjetListeVue extends ContentPanel implements Rafraichissable {

	private Mediateur mediateur = null;

	private Constantes i18nC = null;

	private Grid<Projet> grille = null;

	private ListStore<Projet> store = null;

	private ColumnModel modeleDesColonnes = null;

	private ChampFiltreRecherche champFiltreRecherche = null;

	private BarrePaginationVue pagination = null;

	private Button ajouter;

	private Button modifier;

	private Button supprimer;

	private int indexElementSelectionne = 0;

	private Projet projetSelectionne = null;

	public ProjetListeVue(Mediateur mediateurCourant) {

		super();

		mediateur = mediateurCourant;

		i18nC = Mediateur.i18nC;

		setLayout(new FitLayout());

		setHeadingHtml("Projets");

		ToolBar toolBar = new ToolBar();

		ajouter = new Button(i18nC.ajouter());

		ajouter.setIcon(Images.ICONES.ajouter());

		ajouter.addSelectionListener(new SelectionListener<ButtonEvent>() {

			public void componentSelected(ButtonEvent be) {

				mediateur.clicAjouterProjet();

			}

		});

		ajouter.setToolTip(i18nC.indicationCreerUneFiche()+" "+i18nC.projetSingulier());

		toolBar.add(ajouter);

		modifier = new Button(i18nC.modifier());

		modifier.setIcon(Images.ICONES.formModifier());

		modifier.addSelectionListener(new SelectionListener<ButtonEvent>() {

			public void componentSelected(ButtonEvent be) {

				mediateur.clicModifierProjet(grille.getSelectionModel().getSelectedItems());

				indexElementSelectionne = store.indexOf(grille.getSelectionModel().getSelectedItem());

			}

		});

		modifier.setToolTip(i18nC.indicationModifierUneFiche());

		toolBar.add(modifier);

		supprimer = new Button(i18nC.supprimer());

		supprimer.setIcon(Images.ICONES.supprimer());

		supprimer.addSelectionListener(new SelectionListener<ButtonEvent>() {

			public void componentSelected(ButtonEvent be) {

				mediateur.clicSupprimerProjet(grille.getSelectionModel().getSelectedItems());

			}

		});

		supprimer.setToolTip(i18nC.indicationSupprimerUneFiche());

		toolBar.add(supprimer);

		setTopComponent(toolBar);

		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();

		// ATTENTION : les noms des colonnes doivent correspondre aux noms variables de la classe utilisée dans la liste

		colonnes.add(new ColumnConfig("id_projet", i18nC.id(), 20));

		colonnes.add(new ColumnConfig("nom", i18nC.nom(), 200));

		colonnes.add(new ColumnConfig("abreviation", i18nC.projetAbreviation(), 200));

		colonnes.add(new ColumnConfig("resume", i18nC.projetResume(), 300));

		colonnes.add(new ColumnConfig("url", i18nC.projetUrl(), 200));

		colonnes.add(new ColumnConfig("mot_cles", i18nC.projetMotsCles(), 280));

		modeleDesColonnes = new ColumnModel(colonnes);

		GridSelectionModel<Projet> modeleDeSelection = new GridSelectionModel<Projet>();

		modeleDeSelection.addSelectionChangedListener(new SelectionChangedListener<Projet>() {

			public void selectionChanged(SelectionChangedEvent<Projet> event) {

				projetSelectionne = (Projet) event.getSelectedItem();

				clicListe(projetSelectionne);

			}

		});

		store = new ListStore<Projet>();

		Comparator<Object> compStp = new Comparator<Object>() {

			@Override

			public int compare(Object o1, Object o2) {

				return comparerNaturellementChampProjet(o1,o2);

			}

		};

		StoreSorter<Projet> stp = new StoreSorter<Projet>(compStp);

		store.setStoreSorter(stp);

		store.sort("id_projet", SortDir.ASC);

		grille = new Grid<Projet>(store, modeleDesColonnes);

		grille.setWidth("100%");

		grille.setAutoExpandColumn("nom");

		grille.getView().setAutoFill(true);

		grille.getView().setForceFit(true);

		grille.setSelectionModel(modeleDeSelection);

		grille.addListener(Events.ViewReady, new Listener<BaseEvent>() {

			public void handleEvent(BaseEvent be) {

				grille.getSelectionModel().select(0, false);

			}

		});

		grille.addListener(Events.OnDoubleClick, new Listener<BaseEvent>(){

			public void handleEvent(BaseEvent be) {

				modifier.fireEvent(Events.Select);

			}

		});

		add(grille);

		ProjetListe projetListe = new ProjetListe();

		champFiltreRecherche = new ChampFiltreRecherche(mediateurCourant, toolBar, projetListe);

		// Définition de la barre de pagination

		pagination = new BarrePaginationVue(projetListe, mediateur);

		setBottomComponent(pagination);

	}

	private int comparerNaturellementChampProjet(Object o1, Object o2) {

		int compare = 0;

		String s1 = (String)o1;

		String s2 = (String)o2;

		try {

			Integer i1 = Integer.parseInt(s1);

			Integer i2 = Integer.parseInt(s2);

			compare = i1.compareTo(i2);

		} catch (NumberFormatException e) {

			compare = s1.compareTo(s2);

		}

		return compare;

	}

	public ListStore<Projet> getStore() {

		return store;

	}

	private void clicListe(Projet projet) {

		mediateur.clicListeProjet(projet);

	}

	private void gererEtatActivationBouton() {

		int nbreElementDuMagazin = store.getCount();

		ajouter.enable();

		if (nbreElementDuMagazin <= 0) {

			supprimer.disable();

			modifier.disable();

		} else if (nbreElementDuMagazin > 0) {

			modifier.enable();

			if (mediateur.getUtilisateur().isIdentifie()) {

				supprimer.enable();

			}

		}

	}

	public void rafraichir(Object nouvellesDonnees) {

		if (nouvellesDonnees instanceof ProjetListe) {

			ProjetListe projets = (ProjetListe) nouvellesDonnees;

			champFiltreRecherche.setListePaginable(projets);

			pagination.setlistePaginable(projets);

			pagination.rafraichir(projets.getPageTable());

			if (projets != null) {

				List<Projet> projetsListe = projets.toList();

				store.removeAll();

				if (mediateur.getProjetId() != null) {

					String projetIdSelectionne = mediateur.getProjetId();

					Iterator<Projet> it = projetsListe.iterator();

					while (it.hasNext()) {

						Projet projetCourant = it.next();

						if (projetCourant.getId().equals(projetIdSelectionne)) {

							store.add(projetCourant);

						}

					}

				} else {

					store.add(projetsListe);

				}

				mediateur.actualiserPanneauCentral();

			}

		} else if (nouvellesDonnees instanceof Information) {

			Information info = (Information) nouvellesDonnees;

			if (info.getType().equals("maj_utilisateur")) {

				gererEtatActivationBouton();

			} else if (info.getType().equals("projet_modifie")) {

				if(projetSelectionne != null) {

					store.remove(indexElementSelectionne);

					projetSelectionne = null;

				}

				Projet projetModifie = (Projet)info.getDonnee(0);

				// au cas ou le bouton appliquer aurait été cliqué avant de valider

				store.remove(projetModifie);

				store.insert(projetModifie, indexElementSelectionne);

				projetSelectionne = projetModifie;

				int indexElementSelectionne = store.indexOf(projetSelectionne);

				grille.getSelectionModel().select(indexElementSelectionne, false);

				grille.getView().focusRow(indexElementSelectionne);

				clicListe(projetModifie);

			} else if (info.getType().equals("suppression_projet")) {

				String message = info.toString();

				if (info.getDonnee(0) != null) {

					message = (String) info.getDonnee(0);

				}

				String idsNonSuppr = info.getDonnee(1).toString();

				if (!UtilString.isEmpty(idsNonSuppr))	{

					message = "Les projets " + idsNonSuppr + " n'ont pas été supprimés car ils sont liés à d'autres éléments";

				}

				InfoLogger.display(i18nC.projetTitreSuppression(), message, true);

				supprimerProjetsSelectionnees(Arrays.asList(idsNonSuppr.split(",")));

				gererEtatActivationBouton();

			}

		} else {

			Debug.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()));

		}

		layout();

	}

	public void supprimerProjetsSelectionnees(List<String> idsNonSuppr) {

		List<Projet> selPub = grille.getSelectionModel().getSelectedItems();

		for (Iterator<Projet> it = selPub.iterator(); it.hasNext();) {

			Projet projetCourant = it.next();

			if (!idsNonSuppr.contains(projetCourant.getId().toString()))	{

				grille.getStore().remove(projetCourant);

			}

		}

		//Mettre à jour les filtres

		mediateur.mettreFiltreAJour(grille.getStore().getModels());

		layout(true);

	}

}