Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.image;

import java.util.Iterator;

import org.tela_botanica.client.i18n.Msg;

import org.tela_botanica.client.image.ImageMediateur;

import org.tela_botanica.client.interfaces.ListePaginable;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.objets.ListeObservation;

import org.tela_botanica.client.modeles.objets.Observation;

import org.tela_botanica.client.util.Util;

import org.tela_botanica.client.vues.MiniBarrePaginationVue;

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

import com.gwtext.client.data.Record;

import com.gwtext.client.data.SimpleStore;

import com.gwtext.client.data.Store;

import com.gwtext.client.dd.DragSource;

import com.gwtext.client.dd.DropTarget;

import com.gwtext.client.dd.DropTargetConfig;

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Container;

import com.gwtext.client.widgets.Toolbar;

import com.gwtext.client.widgets.event.ContainerListenerAdapter;

import com.gwtext.client.widgets.form.ComboBox;

import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;

import com.gwtext.client.widgets.grid.CellMetadata;

import com.gwtext.client.widgets.grid.ColumnConfig;

import com.gwtext.client.widgets.grid.ColumnModel;

import com.gwtext.client.widgets.grid.GridDragData;

import com.gwtext.client.widgets.grid.GridPanel;

import com.gwtext.client.widgets.grid.Renderer;

import com.gwtext.client.widgets.grid.RowSelectionModel;

import com.gwtext.client.widgets.grid.event.GridListenerAdapter;

import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;

import com.gwtext.client.widgets.menu.BaseItem;

import com.gwtext.client.widgets.menu.Item;

import com.gwtext.client.widgets.menu.Menu;

import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.core.Ext;

import com.gwtext.client.core.ExtElement;

import com.gwtext.client.dd.DragData;

/**

 * liste d'observation pour l'association d'images aux observations

 * @author aurelien

 *

 */

public class MiniListeObservationVue extends GridPanel implements Rafraichissable, ListePaginable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ImageMediateur iMediateur = null ;

	/**

	 * Booléen d'instanciation

	 */

	private boolean estInstancie = false ;

	/**

	 * Le modèle de colonnes

	 */

	private ColumnModel colModel = null ;

	private SimpleStore store = null ;

	private MiniBarrePaginationVue pgBar = new MiniBarrePaginationVue(this) ;

	private Toolbar bt = new Toolbar() ;

	/**

	 * Combobox permettant de selectionner le mode

	 * modification ou bien création

	 */

	private ComboBox selecteurMode = new ComboBox();

	Store storeMode = null ;

	private boolean liaison;

	int pageEnCours = 0;

	int nbElements = 0;

	int taillePage = 50;

	private String modeleLieu = "IDLOCLOCALITE, LIEUDIT, STATION";

	/**

	 * Nombre de pages totales

	 */

	private int pageMax = 1 ;

	/**

	 * Constructeur avec arguments

	 * @param im le médiateur à associer à la vue

	 */

	public MiniListeObservationVue(ImageMediateur im)

	{

		iMediateur = im ;

		this.setId("x-view-mini-obs") ;

		// on construit le modèle de colonnes

		// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir)

		Renderer colRend = new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {

					return "" ;

				}

				return value.toString() ;

			}

		} ;

		Renderer dateRend = new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {

					return "" ;

				}

				else

				{

					String dateEntiere = value.toString() ;

					String[] dateEtHeure = dateEntiere.split(" ", 2);

					if(verifierFormatDate(dateEtHeure[0])) {

						String[] dateFormateeTab = dateEtHeure[0].split("-",3);

						return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;

					}

				}

				return value.toString() ;

			}

		} ;

		// on crée un store simple contenant un petit set de données et deux colonnes

		store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, getObs());

		ColumnConfig[] columns = {

		new ColumnConfig("", "transmis", 30, true, new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				if(value.equals("1"))

				{

					return "<img src=\"tela.png\"/></img>" ;

				}

				else

				{

					return "" ;

				}

			}

		}),

		new ColumnConfig(Msg.get("taxon"), "plante", 145, true, colRend),

		new ColumnConfig(Msg.get("date"), "date", 68, true, dateRend),

		new ColumnConfig(Msg.get("lieu"), "lieu", 145, true, colRend),

		new ColumnConfig(Msg.get("numero"), "ordre_obs", 50, true, colRend), } ;

        ColumnModel columnModel = new ColumnModel(columns);

        colModel = columnModel ;

        setTitle(Msg.get("observations"));

        // on associe le modèle de colonnes

        setColumnModel(columnModel);

        setAutoScroll(true) ;

        setHeight("100%") ;

		setAutoWidth(true) ;

        // on autorise le drag 'n drop pour un certain groupe

 		this.setEnableDragDrop(true);

 		this.setDdGroup("DragGroupName");

        store.load();

		setStore(store) ;

		setBottomToolbar(pgBar) ;

		Object[][] mode = {{Msg.get("toutes-observations"),false} , {Msg.get("observations-liees"), true} };

		storeMode = new SimpleStore(new String[] { "nom_mode", "mode" },

				mode);

		storeMode.load();

		selecteurMode.setStore(storeMode);

		selecteurMode.setDisplayField("nom_mode") ;

		selecteurMode.setLabel("mode ") ;

		selecteurMode.setForceSelection(true) ;

		selecteurMode.setValue(Msg.get("toutes-observations")) ;

		selecteurMode.setEditable(false) ;

		selecteurMode.setCls("x-selec-consult") ;

		bt = new Toolbar() ;

		bt.addField(selecteurMode) ;

		//this.setAutoExpandColumn("plante");

		setTopToolbar(bt) ;

		selecteurMode.addListener(new ComboBoxListenerAdapter() {

			@Override

			public void onSelect(ComboBox comboBox, Record record, int index) {

				// et on met la valeur à jour dans la combobox

				comboBox.setValue(record.getAsString("nom_mode"));

				setModification(record.getAsString("mode")) ;

			}

		});

		setAutoScroll(true) ;

		// on configure le drag 'n drop

		configDragAndDrop() ;

		this.addGridListener(new GridListenerAdapter() {

			@Override

			public void onContextMenu(EventObject e) {

				// si pas de selection, on selection au moins la ligne sur laquelle on a fait le clic

				if(getSelectionModel().getSelections().length <= 0) {

					int index = getView().findRowIndex(e);

			  		Record rddrop = getStore().getRecordAt(index) ;

					getSelectionModel().selectRecords(rddrop);

				}

				e.stopEvent() ;

				MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ;

				mlv.showAt(e.getXY()) ;

			}

		}) ;

		// TODO: voir s'il existe un autre moyen de désactiver la multiselection

		// ça semble bien compliqué de faire comme ça

		getSelectionModel().addListener(new RowSelectionListenerAdapter() {

			@Override

			public boolean doBeforeRowSelect(RowSelectionModel sm, int rowIndex,

					boolean keepExisting, Record record) {

				sm.clearSelections();

				return true;

			}

		});

		obtenirNombreMiniListeObservations();

	}

	/**

	 * Configure le drag 'n drop pour la liste

	 */

	private void configDragAndDrop()

	{

		// on choisit le texte qui sera affiché lors d'un drag 'n drop

		setDragDropText(Msg.get("glissez-deposer-obs-images")) ;

		//On active le drag 'n drop

		this.setEnableDragDrop(true);

		// on fabrique la nouvelle configuration

		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup

		this.setDdGroup("DragGroupName");

		DropTargetConfig dtc = new DropTargetConfig();

		dtc.setdDdGroup("DragGroupName");

		//La drop target permet de gérer l'évenement onDrop sur l'élement courant

		@SuppressWarnings("unused")

		DropTarget tg = new DropTarget(this, dtc)

		{

			@Override

			public boolean notifyDrop(DragSource source, EventObject e, DragData data){

				// si on reçoit des données provenant d'une grille

				if(data instanceof GridDragData)

		    	  {

					// on la convertit

		    		  	GridDragData gdd = (GridDragData)data ;

		    		  	// et on vérifie que les données ne viennent pas de l'élément courant

		    		  	if(gdd.getGrid().getId().equals("x-view-mini-obs"))

		    		  	{

		    		  		return false ;

		    		  	}

		    		  	else

		    		  	{

		    		  		// on appelle le médiateur

		    		  		return iMediateur.lierImagesDD(source, e, data) ;

		    		  	}

		    	  }

				return false ;

			}

			@Override

			public String notifyOver(DragSource source, EventObject e, DragData data){

			    return "x-dd-drop-ok";

			}

		};

	}

	/**

	 * Méthode héritée de l'interface rafraichissable

	 */

	@Override

	public void rafraichir(Object nouvelleDonnees,

			boolean repandreRaffraichissement) {

		if(nouvelleDonnees instanceof ListeObservation)

		{

			if(this.getView() != null)

			{

				ListeObservation data = (ListeObservation)nouvelleDonnees ;

				String[][] listeObs = new String[data.size()][6] ;

				int i = 0 ;

				for (Iterator it = data.keySet().iterator(); it.hasNext();)

				{

					Observation obs=data.get(it.next());

					listeObs[i][0] = obs.getTransmis();

					listeObs[i][1] = obs.getNomSaisi();

					listeObs[i][2] = obs.getDate() ;

					listeObs[i][3] = Util.formaterLieu(obs, modeleLieu);

					listeObs[i][4] = obs.getNumeroOrdre();

					listeObs[i][5] = obs.getId();

					i++ ;

				}

				store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, listeObs);

				store.load();

				this.reconfigure(store, colModel) ;

			}

			else

			{

				addListener(new ContainerListenerAdapter() {

					@Override

					public void onShow(Component c)

					{

						obtenirNombreMiniListeObservations() ;

					}

					@Override

					public void onAfterLayout(Container c)

					{

						obtenirNombreMiniListeObservations() ;

					}

				}) ;

			}

		}

		// Si on reçoit un tableau d'entiers

		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères

		if(nouvelleDonnees instanceof int[])

		{

			int[] pages = (int[])nouvelleDonnees ;

			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle

			pageMax  = calculerNbPages(pages[0]) ;

			nbElements = pages[0];

			// et on notifie de le mediateur du changement des valeurs

			changerPageMaxEtCourante(pageMax,pageEnCours,taillePage,nbElements) ;

			masquerChargement();

			obtenirMiniListeObservations();

		}

		redimensionner();

		deMasquerChargement() ;

	}

	private void obtenirMiniListeObservations()

	{

		iMediateur.obtenirMiniListeObservations(this, taillePage, pageEnCours) ;

	}

	private void obtenirNombreMiniListeObservations()

	{

		iMediateur.obtenirNombreMiniListeObservations(this) ;

	}

	/**

	 * Renvoie le faux set de données pour le store

	 * @return un tableau à deux colonnes int - String

	 */

	private Object[][] getObs() {

	         return new Object[][]{

	         } ;

	 }

	@Override

	public Store getStore()

	{

		return store ;

	}

	public MiniBarrePaginationVue getBarrePagination()

	{

		return pgBar ;

	}

	private void setModification(String mode)

	{

		if(mode.equals("true")) {

			liaison = true ;

			selecteurMode.removeClass("x-selec-consult") ;

			selecteurMode.setCls("x-selec-liaison") ;

			getBarrePagination().disable();

			doLayout();

		}

		else

		{

			liaison = false ;

			selecteurMode.removeClass("x-selec-liaison") ;

			selecteurMode.setCls("x-selec-consult") ;

			getBarrePagination().enable();

			doLayout();

		}

		store.removeAll() ;

		iMediateur.changerModeLiaison(liaison) ;

	}

	public boolean getMode() {

		return liaison ;

	}

	/**

	 * Recherche l'élement actuellement affiché et affiche son message de chargement

	 */

	public void masquerChargement()

	{

			ExtElement masked = Ext.get(getId()) ;

			if (masked!=null) {

				masked.mask(Msg.get("chargement")) ;

			}

	}

	/**

	 * Recherche l'élement actuellement affiché et affiche son message de chargement

	 */

	public void deMasquerChargement()

	{

			ExtElement masked = Ext.get(getId()) ;

			if (masked!=null) {

				masked.unmask() ;

			}

	}

	public String getIdSelectionnees() {

		Record[] sels = getSelectionModel().getSelections() ;

		String id = "";

		for(int i = 0; i < sels.length; i++) {

			id += ","+sels[i].getAsString("id_obs") ;

		}

		id = id.replaceFirst(",", "");

		return id ;

	}

	public void supprimerLiaison() {

		Record[] rdObs = getSelectionModel().getSelections() ;

		for(int i = 0 ; i < rdObs.length ; i++) {

			getStore().remove(rdObs[i]) ;

			this.getView().refresh() ;

		}

	}

	public void redimensionner() {

		if(getView() != null) {

			int taille = 400;

			if(Window.getClientHeight() > 800 ) {

				taille = Window.getClientHeight() - 350;

			}

			setHeight(taille);

			getView().setForceFit(true);

			doLayout();

		}

		else {

		}

	}

	/**

	 * Montre le menu de liaison aux coordonnées indiquées

	 * @param e

	 */

	public void montrerContextMenuLiaison(EventObject e) {

		final Menu liObs = new Menu();

		final Item lierObservation = new Item(Msg.get("lier-images-selectionnes"));

		liObs.addItem(lierObservation);

		liObs.addListener(new MenuListenerAdapter() {

			// gestion du clic sur un item

			@Override

			public void onItemClick(BaseItem item, EventObject ev) {

				// si c'est la suppression

				if (item.equals(lierObservation)) {

					// on notifie le médiateur

				}

				// enfin, on cache le menu

				liObs.hide();

			}

		});

		liObs.showAt(e.getXY());

	}

	@Override

	public void changerNumeroPage(int pageCourante) {

		pageEnCours = pageCourante ;

		masquerChargement();

		// On lance le chargerment des observations

		iMediateur.obtenirNombreMiniListeObservations(this);

	}

	/**

	 * Appelle le modèle pour qu'il change la taille de page utilisée

	 * @param nouvelleTaillePage la nouvelle taille de page

	 */

	@Override

	public void changerTaillePage(int nouvelleTaillePage)

	{

		taillePage = nouvelleTaillePage ;

		pageEnCours = calculerPageCourante(nbElements) ;

		masquerChargement();

		// On lance le chargerment des observations

		iMediateur.obtenirNombreMiniListeObservations(this);

		// et on met à jour la taille de page dans les barres d'outils

		pgBar.selectionnerTaillePage(nouvelleTaillePage);

	}

	/**

	 * Met à jour les barre d'outils avec des nouvelles valeurs

	 * @param pageMax le nombre de pages

	 * @param pageEncours la page en cours

	 * @param taillePage la taille de page

	 * @param nbElement le nombre d'élements par page

	 */

	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)

	{

		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;

		pgBar.rafraichir(pages, false) ;

	}

	/**

	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page

	 * en cours

	 * @param nbElements le nombre d'élements total

	 * @return le nombre de pages

	 */

	public int calculerNbPages(int nbElements)

	{

		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement

		// pour eviter qu'il arrondisse mal la division

		// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur

		double nPage = (1.0*nbElements)/(1.0*taillePage) ;

		double nPageRound = Math.ceil(nPage) ;

		Double nPageInt = new Double(nPageRound) ;

		// on convertit en entier

		return nPageInt.intValue() ;

	}

	/**

	 * Recalcule la page en cours lors du changement du nombre d'élements

	 * @param nbElements le nombre d'élements total

	 * @return la nouvelle page encours

	 */

	public int calculerPageCourante(int nbElements)

	{

		// on calcule le nombre de page

		int nouvelNbPages = calculerNbPages(nbElements) ;

		// la nouvelle page en cours

		double nPageCourante = (1.0*pageEnCours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;

		// on arrondit au supérieur

		double nPageRound = Math.ceil(nPageCourante) ;

		Double nPageInt = new Double(nPageRound) ;

		// on convertit en entier

		return Math.abs(nPageInt.intValue()) ;

	}

	public boolean verifierFormatDate(String date) {

		String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;

		if(date.matches(regex) && !date.equals("0000-00-00")) {

			return true ;

		}

		else {

			return false;

		}

	}

}