Laboratoire ICAR » Plateforme TXM

package org.txm.annotation.urs.toolbar;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Vector;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.dialogs.InputDialog;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.ComboViewer;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.events.TypedEvent;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.FontData;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.Text;

import org.txm.annotation.rcp.editor.AnnotationArea;

import org.txm.annotation.rcp.editor.AnnotationExtension;

import org.txm.annotation.urs.URSCorpora;

import org.txm.concordance.core.functions.Concordance;

import org.txm.concordance.core.functions.Line;

import org.txm.concordance.rcp.editors.ConcordanceEditor;

import org.txm.concordance.rcp.editors.ConcordanceEditor.ConcordanceColumnSizeControlListener;

import org.txm.core.results.TXMResult;

import org.txm.objects.Match;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.swt.GLComposite;

import org.txm.rcp.swt.provider.SimpleLabelProvider;

import org.txm.rcp.utils.JobHandler;

import org.txm.searchengine.cqp.corpus.CQPCorpus;

import org.txm.utils.logger.Log;

import visuAnalec.donnees.Corpus;

import visuAnalec.elements.Unite;

public class UnitConcordanceToolbar extends AnnotationArea {

	/**

	 * the limit number of annotation when a confirm dialog box is shown

	 */

	protected static final int NALERTAFFECTANNOTATIONS = 100;

	public static final String EMPTYTEXT = ""; //$NON-NLS-1$

	protected ConcordanceEditor editor;

	/**

	 * All available annotation types

	 */

	protected List<String> typeValuesList;

	/**

	 * display the annotation values of the current shown concordance lines

	 */

	protected TableColumn annotationColumn;

	protected ComboViewer annotationTypesCombo;

	/** add a new type of annotation */

	private Button addAnnotationTypeButton;

	protected Label equalLabel;

	protected Text annotationValuesText;

	protected Button affectAnnotationButton;

	protected Button deleteAnnotationButton;

	private Button affectAllAnnotationButton;

	protected Vector<String> typesList = new Vector<String>(); 

	protected Concordance concordance;

	private CQPCorpus corpus;

	private TableViewerColumn annotationColumnViewer;

	private Font annotationColummnFont;

	private Font defaultColummnFont;

	private Corpus annotManager;

	private HashMap<Line, ArrayList<Unite>> annotations;

	protected String unitType;

	protected String unitProperty;

	private ComboViewer annotationPropertiesCombo;

	public String getName() {

		return "Unit (URS)";

	}

	@Override

	public boolean allowMultipleAnnotations() {

		return true;

	}

	public UnitConcordanceToolbar() {

	}

	@Override

	public boolean install(TXMEditor<? extends TXMResult> txmeditor, AnnotationExtension ext, Composite parent, int position) throws Exception {

		this.extension = ext;

		this.editor = (ConcordanceEditor)txmeditor;

		this.concordance = this.editor.getConcordance();

		this.corpus = concordance.getCorpus();

		this.annotations = new HashMap<Line, ArrayList<Unite>>();

		this.annotManager = URSCorpora.getCorpus(corpus);

		TableViewer viewer = this.editor.getLineTableViewer();

		// RESULT

		if (position < 0) {

			position = 3 + extension.getNumberOfAnnotationArea(); // after keyword column and previous annotation columns

		}

		typesList.clear();

		for (String type : this.annotManager.getStructure().getUnites()) {

			typesList.add(type);

		}

		if (typesList.size() > 0) {

			this.unitType = typesList.get(0);

		}

		annotationColumnViewer = new TableViewerColumn(viewer, SWT.CENTER, position);

		annotationColumn = annotationColumnViewer.getColumn();

		annotationColumn.setText("Unit");

		annotationColumn.setToolTipText("Unit (URS)");

		annotationColumn.setAlignment(SWT.CENTER);

		annotationColumn.pack();

		annotationColumn.setResizable(true);

		annotationColumn.addControlListener(new ConcordanceColumnSizeControlListener(annotationColumn));

		defaultColummnFont = editor.getContainer().getFont();

		FontData fdata = defaultColummnFont.getFontData()[0];

		annotationColummnFont = new Font(Display.getCurrent(), fdata.getName(), fdata.getHeight(), SWT.ITALIC);

		annotationColumnViewer.setLabelProvider(new ColumnLabelProvider() {

			@Override

			public String getText(Object element) {

				Line line = (Line)element;

				ArrayList<Unite> a = annotations.get(line);

				if (a.size() == 0) return "<none>";

				StringBuffer buffer = new StringBuffer();

				for (Unite unite : a) {

					String value = unite.getProp(unitProperty);

					if (value != null) {

						if (unite.getDeb() < line.matchGetStart() - line.getLeftContextSize()) {

							value = "… "+value; //$NON-NLS-1$

						}

						if (unite.getFin() > line.matchGetEnd() + line.getRightContextSize()) {

							value = value+" …"; //$NON-NLS-1$

						}

						if (buffer.length() > 0) buffer.append(", ");

						buffer.append(value);

					} else {

						buffer.append("[]");

					}

				}

				return buffer.toString();

			}

		});

		if (unitType != null) {

			annotationColumn.setText(unitType);

		}

		annotationArea = new GLComposite(parent, SWT.NONE, "Unit URS");

		annotationArea.getLayout().numColumns = 12;

		annotationArea.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));

		GridData gdata = new GridData(SWT.CENTER, SWT.CENTER, false, false);

		gdata.widthHint = 90;

		// UNIT TYPE

		annotationTypesCombo = new ComboViewer(annotationArea, SWT.SINGLE);

		annotationTypesCombo.setContentProvider(new ArrayContentProvider());

		annotationTypesCombo.setLabelProvider(new SimpleLabelProvider());

		annotationTypesCombo.getCombo().addKeyListener(new KeyListener() {

			@Override

			public void keyReleased(KeyEvent e) {

				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

					String name = annotationTypesCombo.getCombo().getText();

					if (typesList.contains(name)) {

						StructuredSelection selection = new StructuredSelection(name);

						annotationTypesCombo.setSelection(selection, true);

					} else {

						createNewType(e, name);

					}

				}

			}

			@Override

			public void keyPressed(KeyEvent e) { }

		});

		gdata = new GridData(SWT.CENTER, SWT.CENTER, false, false);

		gdata.widthHint = 200;

		annotationTypesCombo.getCombo().setLayoutData(gdata);

		annotationTypesCombo.setInput(typesList);

		annotationTypesCombo.getCombo().select(0);

		annotationTypesCombo.addSelectionChangedListener(new ISelectionChangedListener() {

			@Override

			public void selectionChanged(SelectionChangedEvent event) {

				onAnnotationTypeSelected(event);

			}

		});

		// WITH

		equalLabel = new Label(annotationArea, SWT.NONE);

		equalLabel.setText("with"); //$NON-NLS-1$

		equalLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		// PROPERTY

		annotationPropertiesCombo = new ComboViewer(annotationArea, SWT.SINGLE);

		annotationPropertiesCombo.setContentProvider(new ArrayContentProvider());

		annotationPropertiesCombo.setLabelProvider(new SimpleLabelProvider());

		annotationPropertiesCombo.getCombo().addKeyListener(new KeyListener() {

			@Override

			public void keyReleased(KeyEvent e) {

				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

					String name = annotationTypesCombo.getCombo().getText();

					if (typesList.contains(name)) {

						StructuredSelection selection = new StructuredSelection(name);

						annotationTypesCombo.setSelection(selection, true);

					} else {

						createNewType(e, name);

					}

				}

			}

			@Override

			public void keyPressed(KeyEvent e) { }

		});

		gdata = new GridData(SWT.CENTER, SWT.CENTER, false, false);

		gdata.widthHint = 200;

		annotationPropertiesCombo.getCombo().setLayoutData(gdata);

		ArrayList<String> properties = new ArrayList<String>();

		properties.add("");

		properties.addAll(annotManager.getStructure().getNomsProps(Unite.class, unitType));

		annotationPropertiesCombo.setInput(properties);

		annotationPropertiesCombo.getCombo().select(0);

		annotationPropertiesCombo.addSelectionChangedListener(new ISelectionChangedListener() {

			@Override

			public void selectionChanged(SelectionChangedEvent event) {

				onAnnotationPropertySelected(event);

			}

		});

		equalLabel = new Label(annotationArea, SWT.NONE);

		equalLabel.setText("="); //$NON-NLS-1$

		equalLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		annotationValuesText = new Text(annotationArea, SWT.BORDER);

		annotationValuesText.setToolTipText("value");

		GridData gdata2 = new GridData(SWT.FILL, SWT.CENTER, false, false);

		gdata2.widthHint = 200;

		annotationValuesText.setLayoutData(gdata2);

		annotationValuesText.addKeyListener(new KeyListener() {

			@Override

			public void keyReleased(KeyEvent e) {

				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

					affectAnnotationToSelection(editor.getLineTableViewer().getSelection());

				}

			}

			@Override

			public void keyPressed(KeyEvent e) { }

		});

		affectAnnotationButton = new Button(annotationArea, SWT.PUSH);

		affectAnnotationButton.setText("Create");

		affectAnnotationButton.setToolTipText("Create unit for each selected line.");

		affectAnnotationButton.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		affectAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				affectAnnotationToSelection(editor.getLineTableViewer().getSelection());

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		deleteAnnotationButton = new Button(annotationArea, SWT.PUSH);

		deleteAnnotationButton.setText("Delete");

		deleteAnnotationButton.setToolTipText("Delete unit for each selected line.");

		deleteAnnotationButton.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		deleteAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				deleteAnnotationValues(editor.getLineTableViewer().getSelection());

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		affectAllAnnotationButton = new Button(annotationArea, SWT.PUSH);

		affectAllAnnotationButton.setText("All");

		affectAllAnnotationButton.setToolTipText("Create unit for all lines");

		affectAllAnnotationButton.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false));

		affectAllAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				try {

					List<? extends Match> matches = concordance.getMatches();

					affectMatchesToSelection(matches);

				} catch (Exception e1) {

					Log.severe(NLS.bind("** Error: {0}", e1.getLocalizedMessage()));

					Log.printStackTrace(e1);

					return;

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

		Button closeButton = new Button(annotationArea, SWT.PUSH);

		closeButton.setToolTipText("End URS annotation");

		closeButton.setImage(IImageKeys.getImage(IImageKeys.ACTION_REMOVE));

		closeButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				extension.removeAnnotationArea(UnitConcordanceToolbar.this);

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

		updateAnnotationWidgetStates();

		editor.layout(true);

		ext.getSaveButton().setEnabled(true);

		return true;

	}

	private void updateAnnotationWidgetStates() {

		// TODO Auto-generated method stub

	}

	protected void affectMatchesToSelection(final List<? extends Match> matches) {

		final String value = annotationValuesText.getText();

		JobHandler job = new JobHandler("Creating units...", true) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					for (Match m : matches) {

						HashMap<String, String> props = new HashMap<String, String>();

						props.put(unitProperty, value);

						Unite u = annotManager.addUniteSaisie(unitType, m.getStart(), m.getEnd(), props);

					}

				} catch(Exception e) {

					Log.severe(NLS.bind("** Error: {0}", e));

					Log.printStackTrace(e);

					return Status.CANCEL_STATUS;

				} catch(ThreadDeath td) {

					System.out.println("Canceled");

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		job.startJob(true);

	}

	protected void deleteAnnotationValues(ISelection selection) {

		final IStructuredSelection lineSelection = (IStructuredSelection) selection;

		List<Line> lines = lineSelection.toList();

		ArrayList<Match> matches = new ArrayList<Match>();

		for (Line l : lines) {

			matches.add(l.getMatch());

		}

	}

	protected void affectAnnotationToSelection(ISelection selection) {

		final IStructuredSelection lineSelection = (IStructuredSelection) selection;

		List<Line> lines = lineSelection.toList();

		ArrayList<Match> matches = new ArrayList<Match>();

		for (Line l : lines) {

			matches.add(l.getMatch());

		}

		affectMatchesToSelection(matches);

	}

	protected void onAnnotationPropertySelected(SelectionChangedEvent event) {

		IStructuredSelection sel = (IStructuredSelection) annotationPropertiesCombo.getSelection();

		String type = (String) sel.getFirstElement();

		if (type == null) return;

		unitProperty = type;

		try {

			editor.refresh(false);

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		updateAnnotationWidgetStates();

	}

	protected void onAnnotationTypeSelected(SelectionChangedEvent event) {

		IStructuredSelection sel = (IStructuredSelection) annotationTypesCombo.getSelection();

		String type = (String) sel.getFirstElement();

		if (type == null) return;

		unitType = type;

		annotationColumn.setText(type);

		ArrayList<String> properties = new ArrayList<String>();

		properties.add("");

		properties.addAll(annotManager.getStructure().getNomsProps(Unite.class, unitType));

		annotationPropertiesCombo.setInput(properties);

		annotationPropertiesCombo.getCombo().select(0);

		try {

			editor.refresh(false);

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		updateAnnotationWidgetStates();

	}

	protected void createNewType(TypedEvent e, String typeName) {

		if (typeName == null) typeName = ""; //$NON-NLS-1$

		if (typesList.contains(typeName)) return;

		InputDialog dialog = new InputDialog(e.widget.getDisplay().getActiveShell(), "Nouveau type d'unite", "avec le nom", typeName, null); //$NON-NLS-3$

		if (dialog.open() == InputDialog.OK) {

			String name = dialog.getValue();

			if (name.trim().length() == 0) return;

			annotManager.getStructure().ajouterType(Unite.class, name);

			typesList.add(name);

			annotationTypesCombo.refresh();

			StructuredSelection selection = new StructuredSelection(name);

			annotationTypesCombo.setSelection(selection, true);

		} else {

			System.out.println("Creation aborted."); //$NON-NLS-1$

		}

	}

	@Override

	public boolean save() {

		try {

			return URSCorpora.saveCorpus(corpus);

		} catch(Exception ex) {

			ex.printStackTrace();

			return false;

		}

	}

	@Override

	public boolean hasChanges() {

		return annotManager.isModifie();

	}

	@Override

	public boolean notifyEndOfCompute() throws Exception {

		return true;

	}

	public boolean isAnnotationEnable() {

		return annotationArea != null;

	}

	@Override

	public void notifyStartOfRefresh() throws Exception {

		List<Line> lines = concordance.getLines(concordance.getTopIndex(), concordance.getTopIndex()+concordance.getNLinePerPage());

		annotations.clear();

		ArrayList<Unite> units = annotManager.getUnites(unitType);

//		int iUnit = 0;

//		int iLine = 0;

//		for (; iUnit < units.size() && iLine < lines.size();) {

//			Line line = lines.get(iLine);

//			Unite unite = units.get(iUnit);

//			if (unite.getFin() < line.getMatch().getStart()) {

//				iUnit++;

//			} else if (line.getMatch().getEnd() < unite.getDeb()) {

//				iLine++;

//			} else {

//				annotations.put(line, unite);

//				iLine++;

//			}

//		}

		for (Line line : lines) {

			ArrayList<Unite> lineUnites = new ArrayList<Unite>();

			annotations.put(line, lineUnites); //ok test next one

			for (int iUnit = 0; iUnit < units.size(); iUnit++) {

				Unite unite = units.get(iUnit);

				if (unite.getFin() < line.getMatch().getStart()) {

					continue;

				} else if (line.getMatch().getEnd() < unite.getDeb()) {

					break; //no need to go further

				} else {

					lineUnites.add(unite);

				}

			}

		}

		updateAnnotationWidgetStates();

		// update annotation column width

		if (annotationArea != null) {

			annotationColumn.pack();

			annotationColumn.setResizable(true);

		} else { 

			annotationColumn.setWidth(0);

		}

	}

	@Override

	protected void _close() {

		if (!annotationColumn.isDisposed()) annotationColumn.dispose();

		if (!annotationArea.isDisposed()) annotationArea.dispose();

		extension.layout();

	}

	@Override

	public void notifyEndOfRefresh() throws Exception {

		// TODO Auto-generated method stub

	}

	@Override

	public void notifyStartOfCreatePartControl() throws Exception {

		// TODO Auto-generated method stub

	}

	public void notifyEndOfCreatePartControl() throws Exception {

		// TODO Auto-generated method stub

	}

	@Override

	public Class<? extends TXMResult> getAnnotatedTXMResultClass() {

		return Concordance.class;

	}

	@Override

	public boolean isDirty() {

		return annotManager.isModifie();

	}

	@Override

	public boolean discardChanges() {

		return false;

	}

	@Override

	public boolean needToUpdateIndexes() {

		return true;

	}

	@Override

	public boolean notifyStartOfCompute() throws Exception {

		return true;

	}

}

      <annotationtoolbar

            class="org.txm.annotation.urs.toolbar.UnitConcordanceToolbar"

            position="4">

      </annotationtoolbar>

      <annotationtoolbar

            class="org.txm.annotation.urs.toolbar.UnitConcordanceToolbar"

            position="4">

      </annotationtoolbar>

      <annotationtoolbar

            class="org.txm.annotation.urs.rcp.AnnotationArea:1"

            position="4">

      </annotationtoolbar>