Laboratoire ICAR » Plateforme TXM

	 * 

	 * CQP Annotations must be shadowed by temporary annotations of the same type and positions

	 */

		List<Annotation> temporaryAnnotations = null;

		List<Annotation> resultAnnotations = new ArrayList<>();

		try {

			// System.out.println("Temporary annotations: "+temporaryAnnotations);

			// System.out.println("CQP annotations: "+cqpAnnotations);

				Log.info("ERROR in getAnnotationsForMatches methods! "); //$NON-NLS-1$

			}

			// merge the 2 results

				if (cqpAnnotations.get(i) == null && temporaryAnnotations.get(i) == null) {

					resultAnnotations.add(null);

				}

		}

		catch (Exception e) {

			e.printStackTrace();

		}

		return resultAnnotations;

	}

		return temporaryAnnotations;

	}

	}

	public void closeAll() {

		Log.fine("Closing annotation manager of " + corpus); //$NON-NLS-1$

		tempManager.close();

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.osgi.service.prefs.BackingStoreException;

import org.txm.annotation.kr.core.repository.AnnotationEffect;

	 * @throws IOException

	 */

	public List<Annotation> getAnnotations(AnnotationType type, Match match, String value, boolean overlap) throws CqiClientException, IOException, CqiServerError {

		HashMap<StructuralUnitProperty, AnnotationType> supList = new HashMap<StructuralUnitProperty, AnnotationType>();

		// TODO add a corpus parameters for structures that code annotations

package org.txm.edition.rcp.editors;

import java.io.File;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import org.txm.rcp.editors.TXMBrowserEditor;

import org.txm.rcp.editors.menu.PagePropertiesMenu;

import org.txm.rcp.utils.IOClipboard;

import org.txm.utils.io.IOUtils;

import org.txm.utils.logger.Log;

	/**

	 * Next text.

	 */

		// Text current = this.currentPage.getEdition().getText();

		Project project = currentText.getProject();

		String id;

				}

			}

		if (nextText != null) {

			String editionName = currentEdition.getName();

			Edition tmp = nextText.getEdition(editionName);

package org.txm.edition.rcp.editors;

import java.awt.Color;

public class RGBA {

	public int r=0, g=0, b=0;

	public RGBA(String rgbOrrgba) {

		if (rgbOrrgba.startsWith("#")) { //$NON-NLS-1$

			this.r = c.getRed();

			this.g = c.getGreen();

		this.a = a;

	}

	/**

	 * Converts a hex string to a color. If it can't be converted null is returned.

	 * @param hex (i.e. #CCCCCCFF or CCCCCC)

	 * @return Color

	 */

	    hex = hex.replace("#", ""); //$NON-NLS-1$ //$NON-NLS-2$

	    switch (hex.length()) {

	        case 6:

	            return new Color(

	@Override

	public void clearHighlight() {

		if (previousSelectedUnitIDS != null) {

				editor.removeHighlightWordsById(selected_unit_color, previousSelectedUnitIDS);

				editor.removeFontWeightWordsById(previousSelectedUnitIDS);

			}

		final KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

		value_to_add = kr.getValue(type, svalue);

		if (value_to_add == null && kr instanceof LocalKnowledgeRepository) { // create or not the annotation is simple mode

			value_to_add = kr.addValue(svalue, svalue, type.getId());

		}

package org.txm.annotation.kr.rcp.edition;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Vector;

import java.util.logging.Level;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.txm.annotation.kr.core.repository.TypedValue;

import org.txm.annotation.kr.rcp.commands.InitializeKnowledgeRepository;

import org.txm.annotation.kr.rcp.commands.SaveAnnotations;

import org.txm.annotation.kr.rcp.messages.Messages;

import org.txm.annotation.kr.rcp.views.knowledgerepositories.KRView;

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

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

import org.txm.concordance.rcp.messages.ConcordanceUIMessages;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.TXMResult;

import org.txm.edition.rcp.editors.SynopticEditionEditor;

import org.txm.objects.Match;

import org.txm.objects.Match2P;

import org.txm.rcp.swt.dialog.ConfirmDialog;

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

import org.txm.rcp.utils.JobHandler;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

import org.txm.utils.AsciiUtils;

import org.txm.utils.logger.Log;

public class WordAnnotationToolbar 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$

	/** The annotation service */

	protected AnnotationManager annotManager;

	protected SynopticEditionEditor editor;

	/**

	 * The concordance annotations to show in the concordance column table

	 */

	private EditionAnnotations annotations = null;

	/**

	 * All available annotation types

	 */

	protected List<TypedValue> typeValuesList;

	protected ComboViewer annotationTypesCombo;

	protected Label equalLabel;

	protected Text annotationValuesText;

	protected Button affectAnnotationButton;

	protected Button deleteAnnotationButton;

	protected KnowledgeRepository currentKnowledgeRepository = null;

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

	protected AnnotationType tagAnnotationType; // the tag annotation type if annotation mode is simple

	protected TypedValue value_to_add;

	//protected Concordance concordance;

	private CQPCorpus corpus;

	private TableViewerColumn annotationColumnViewer;

	private Font annotationColummnFont;

	private Font defaultColummnFont;

	private Button addAnnotationTypeLink;

	private Button addTypedValueLink;

	@Override

	public String getName() {

		return Messages.motsPropritsInfDfaut;

	}

	@Override

	public boolean allowMultipleAnnotations() {

		return true;

	}

	public WordAnnotationToolbar() {}

	protected AnnotationType getSelectedAnnotationType() {

		return annotations.getViewAnnotation();

	}

	public void updateAnnotationWidgetStates() {

		if (annotationArea == null) return; // :)

		if (getSelectedAnnotationType() != null) {

			annotationValuesText.setEnabled(true);

			affectAnnotationButton.setEnabled(true);

			deleteAnnotationButton.setEnabled(false);

		}

	}

	protected void affectAnnotationToSelection(String[] word_selection) {

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

		try {

			int[] indexes = CQPSearchEngine.getCqiClient().str2Id(corpus.getProperty("id").getQualifiedName(), word_selection);

			int[] allPositions = CQPSearchEngine.getCqiClient().idList2Cpos(corpus.getProperty("id").getQualifiedName(), indexes);

				matches.add(new Match2P(p));

			}

			affectAnnotationsToMatches(matches);

			e.printStackTrace();

		}

	}

	protected void affectAnnotationValues(final List<? extends Match> matches, final AnnotationType type, final String svalue, JobHandler job) {

		value_to_add = null; // reset

		if (matches == null || matches.size() == 0) {

			return;

		}

		if (type == null) return; // no type, no annotation

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				if (matches.size() > NALERTAFFECTANNOTATIONS) {

							"confirm_annotate",  //$NON-NLS-1$

							Messages.confirmAnnotationAffectation,

							NLS.bind(Messages.youAreAboutToAnnotateP0ElementsContinue, matches.size()));

					if (dialog.open() == ConfirmDialog.CANCEL) {

						Log.info("Annotation aborted by user.");

						matches.clear();

				}

			}

		});

		// get value from combo text value

		Log.fine(NLS.bind(Messages.lookingForTypedValueWithIdEqualsP0, svalue));

		final KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

		value_to_add = kr.getValue(type, svalue);

		if (value_to_add == null && kr instanceof LocalKnowledgeRepository) { // create or not the annotation is simple mode

			value_to_add = kr.addValue(svalue, svalue, type.getId());

		}

		if (value_to_add == null) {

			job.syncExec(new Runnable() {

				@Override

				public void run() {

					String mess = Messages.bind(Messages.noValueFoundWithTheP0Id, svalue);

			});

			return;

		}

		Log.info(TXMCoreMessages.bind(Messages.AffectP0ToP1SelectionEqualsP2, value_to_add.getId(), value_to_add.getTypeID(), matches.size()));

		// finally we can 'try' to create the annotations \o/

		try {

			HashMap<Match, List<Annotation>> existingAnnots = annotManager.createAnnotations(type, value_to_add, matches, job);

			// did we had problems ?

			if (existingAnnots != null && existingAnnots.size() > 0) {

				String message = NLS.bind(Messages.couldNotAnnotateTheValueP0OnCertainSequences, value_to_add.getStandardName());

				for (Match m : existingAnnots.keySet()) {

					message += NLS.bind(Messages.theSequenceP0IsOverlappingWith, m);

					for (Annotation existingAnnot : existingAnnots.get(m)) {

						if (existingAnnot.getStart() < m.getStart()) {

							message += TXMCoreMessages.bind(Messages.theEndOfAStructureP0AtP1P2, existingAnnot.getType(), existingAnnot.getStart(), existingAnnot.getEnd());

				}

				final String final_message = message;

				job.syncExec(new Runnable() {

					@Override

					public void run() {

						MessageDialog.openInformation(editor.getSite().getShell(), Messages.aboutAnnotations, final_message);

			}

			// if (history != null && !history.get(type).contains(value_to_add))

			// history.get(type).add(value_to_add);

			if (Log.getLevel().intValue() < Level.INFO.intValue() && annotManager != null) {

				annotManager.checkData();

			}

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				try {

			}

		});

	}

	protected void deleteAnnotationValues(String[] word_selection) {

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

		try {

			int[] indexes = CQPSearchEngine.getCqiClient().str2Id(corpus.getProperty("id").getQualifiedName(), word_selection);

		catch (Exception e) {

			e.printStackTrace();

		}

	}

	protected void deleteAnnotationValues(final List<Match> matches) {

		final AnnotationType type = getSelectedAnnotationType();

		JobHandler job = new JobHandler(Messages.annotatingConcordanceSelection, true) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					deleteAnnotationValues(matches, type, this);

				}

				catch (Exception e) {

					Log.severe(NLS.bind(Messages.errorWhileAnnotatingConcordanceSelectionColonP0, e));

					Log.info(Messages.annotationCanceledByUser);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		job.startJob(true);

	}

	protected void deleteAnnotationValues(List<Match> matches, AnnotationType type, JobHandler job) {

		if (matches.size() == 0) {

			Log.warning("No lines selected. Aborting.");

			return;

		}

		if (type == null) {

			return;

		}

		try {

			if (annotManager != null && annotManager.deleteAnnotations(type, matches, job)) {

				if (Log.getLevel().intValue() < Level.INFO.intValue()) annotManager.checkData();

			}

			else {

				return;

			Log.printStackTrace(e1);

			return;

		}

		job.syncExec(new Runnable() {

			@Override

			public void run() {

				try {

				}

				catch (Exception e) {

					Log.printStackTrace(e);

			}

		});

	}

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

		final AnnotationType type = getSelectedAnnotationType();

		final String svalue = annotationValuesText.getText();

		JobHandler job = new JobHandler(Messages.annotatingConcordanceSelection, true) {

			@Override

			protected IStatus run(IProgressMonitor monitor) {

				this.runInit(monitor);

				try {

					affectAnnotationValues(matches, type, svalue, this);

				}

				catch (Exception e) {

					Log.severe(NLS.bind(Messages.errorWhileAnnotatingConcordanceSelectionColonP0, e));

					Log.info(Messages.annotationCanceledByUser);

					return Status.CANCEL_STATUS;

				}

				return Status.OK_STATUS;

			}

		};

		job.startJob(true);

	}

	@Override

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

		this.extension = ext;

		this.editor = (SynopticEditionEditor) txmeditor;

		this.corpus = editor.getCorpus();

		this.annotManager = KRAnnotationEngine.getAnnotationManager(corpus);

		this.annotations = new EditionAnnotations(this.editor);

		// TODO install browser listeners here

		List<KnowledgeRepository> krs = InitializeKnowledgeRepository.get(corpus.getMainCorpus());

		typesList.clear();

		Log.fine("Corpus KRs: " + krs); //$NON-NLS-1$

		currentKnowledgeRepository = KnowledgeRepositoryManager.getKnowledgeRepository(corpus.getMainCorpus().getID());

		if (currentKnowledgeRepository == null) {

			HashMap<String, HashMap<String, ?>> conf = new HashMap<>();

			conf.put(KRAnnotationEngine.KNOWLEDGE_TYPES, fields);

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

			conf.put(KRAnnotationEngine.KNOWLEDGE_STRINGS, strings);

			access.put("mode", DatabasePersistenceManager.ACCESS_FILE); //$NON-NLS-1$

			access.put("version", "0"); //$NON-NLS-1$ //$NON-NLS-2$

			currentKnowledgeRepository = KnowledgeRepositoryManager.createKnowledgeRepository(corpus.getMainCorpus().getID(), conf);

			KnowledgeRepositoryManager.registerKnowledgeRepository(currentKnowledgeRepository);

			// KRAnnotationEngine.registerKnowledgeRepositoryName(corpus, corpus.getMainCorpus().getID());

		}

		List<WordProperty> wordProperties = corpus.getProperties();

		for (WordProperty p : wordProperties) {

			if (p.getName().equals("id")) continue; //$NON-NLS-1$

				type.setEffect(AnnotationEffect.TOKEN);

			}

		}

		Log.fine("KR: " + currentKnowledgeRepository); //$NON-NLS-1$

		List<AnnotationType> krtypes = currentKnowledgeRepository.getAllAnnotationTypes();

		for (AnnotationType type : krtypes) {

				typesList.add(type);

			}

		}

		Log.fine(NLS.bind(Messages.availableAnnotationTypesColonP0, typesList));

		annotationArea = new GLComposite(parent, SWT.NONE, Messages.concordanceAnnotationArea);

		annotationArea.getLayout().numColumns = 12;

		annotationArea.getLayout().horizontalSpacing = 2;

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

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

		gdata.widthHint = 90;

		new Label(annotationArea, SWT.NONE).setText(TXMCoreMessages.common_property);

		// Display combo with list of Annotation Type

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

		annotationTypesCombo.setContentProvider(new ArrayContentProvider());

		annotationTypesCombo.setLabelProvider(new SimpleLabelProvider() {

			@Override

			public String getColumnText(Object element, int columnIndex) {

				return ((AnnotationType) element).getName();

			}

			@Override

			public String getText(Object element) {

				return ((AnnotationType) element).getName();

		// @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);

		// annotationColumn.setText(name);

		// }

		// }

		annotationTypesCombo.addSelectionChangedListener(new ISelectionChangedListener() {

			@Override

			public void selectionChanged(SelectionChangedEvent event) {

				onAnnotationTypeSelected(event);

			}

		});

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

		addAnnotationTypeLink.setToolTipText(Messages.addANewCategory);

		addAnnotationTypeLink.setImage(IImageKeys.getImage(IImageKeys.ACTION_ADD));

		addAnnotationTypeLink.setEnabled(true);

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

		addAnnotationTypeLink.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				if (currentKnowledgeRepository == null) return;

				if (!(currentKnowledgeRepository instanceof LocalKnowledgeRepository)) return;

				LocalKnowledgeRepository kr = (LocalKnowledgeRepository) currentKnowledgeRepository;

				InputDialog dialog = new InputDialog(e.widget.getDisplay().getActiveShell(), "New property", "Enter the new property name", "", null);

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

					String name = dialog.getValue();

					}

					AnnotationType type = kr.addType(name, id, "", AnnotationEffect.TOKEN); //$NON-NLS-1$

					typesList.add(type);

					if (annotationTypesCombo != null) annotationTypesCombo.refresh();

					if (typesList.size() == 1) {

						if (annotationTypesCombo != null) annotationTypesCombo.getCombo().select(typesList.size() - 1);

						annotations.setViewAnnotation(type);

						annotations.setAnnotationOverlap(true);

						try {

							e1.printStackTrace();

						}

						annotationArea.layout(true);

					}

					else {

						if (typesList.size() > 1) {

					Log.info("Creation aborted.");

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

		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(Messages.enterAValueForAnId);

		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.getEditionPanel(0).getWordSelection());

				}

			}

			@Override

			public void keyPressed(KeyEvent e) {}

		});

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

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

		addTypedValueLink.setToolTipText(Messages.selectAValueAmongTheList);

		addTypedValueLink.setEnabled(true);

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

		addTypedValueLink.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				if (currentKnowledgeRepository == null) return;

				if (!(currentKnowledgeRepository instanceof LocalKnowledgeRepository)) return;

				AnnotationType type = getSelectedAnnotationType();

				if (type == null) return;

				LocalKnowledgeRepository kr = (LocalKnowledgeRepository) currentKnowledgeRepository;

				ListDialog dialog = new ListDialog(e.widget.getDisplay().getActiveShell());

				String title = currentKnowledgeRepository.getString(editor.getCorpus().getLang(), "ConcordancesEditor_100"); //$NON-NLS-1$

				if (title == null) title = Messages.availableValuesForP0;

				dialog.setTitle(ConcordanceUIMessages.bind(title, type.getName()));// +"valeurs de "+type.getName());

				dialog.setContentProvider(new ArrayContentProvider());

				dialog.setLabelProvider(new SimpleLabelProvider() {

					@Override

					public String getColumnText(Object element, int columnIndex) {

						if (element instanceof TypedValue) {

					TypedValue value = (TypedValue) dialog.getResult()[0];

					String name = value.getId();

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

					annotationValuesText.setText(name);

				}

				else {

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

		new Label(annotationArea, SWT.NONE).setText(" ");

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

		affectAnnotationButton.setText(Messages.oK);

		affectAnnotationButton.setToolTipText(Messages.proceedToAnnotation);

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

		affectAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				affectAnnotationToSelection(editor.getEditionPanel(0).getWordSelection());

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

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

		deleteAnnotationButton.setText(Messages.delete);

		deleteAnnotationButton.setToolTipText(Messages.delete);

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

		deleteAnnotationButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				deleteAnnotationValues(editor.getEditionPanel(0).getWordSelection());

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

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

		closeButton.setToolTipText(Messages.closeTheToolbarWithoutSaving);

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

		closeButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				extension.closeArea(WordAnnotationToolbar.this, true);

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		});

		updateAnnotationWidgetStates();

		editor.layout(true);

		return true;

	}

	protected void onAnnotationTypeSelected(SelectionChangedEvent event) {

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

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

		if (type == null) return;

		if (type.getSize() != AnnotationType.ValuesSize.LARGE) {

			try {

				KnowledgeRepository kr = KnowledgeRepositoryManager.getKnowledgeRepository(type.getKnowledgeRepository());

				e.printStackTrace();

			}

		}

		annotations.setViewAnnotation(type);

		annotations.setAnnotationOverlap(true);

		try {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		updateAnnotationWidgetStates();

	}

	protected void createNewType(TypedEvent e, String typeName) {

		if (currentKnowledgeRepository == null) return;

		if (!(currentKnowledgeRepository instanceof LocalKnowledgeRepository)) return;

		LocalKnowledgeRepository kr = (LocalKnowledgeRepository) currentKnowledgeRepository;

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

		InputDialog dialog = new InputDialog(e.widget.getDisplay().getActiveShell(), Messages.nouvelleProprit, Messages.nomDeLaPropritPatternEqualsazaz09Plus, typeName,

			annotationTypesCombo.refresh();

			StructuredSelection selection = new StructuredSelection(type);

			annotationTypesCombo.setSelection(selection, true);

			// if (annotationTypesCombo != null) annotationTypesCombo.refresh();

			// if (typesList.size() == 1) {

			// if (annotationTypesCombo != null) annotationTypesCombo.getCombo().select(0);

			// }

			// KRView.refresh();

			// updateAnnotationWidgetStates();

			// onAnnotationTypeSelected(null);

		}

		else {

			Log.info("Creation aborted.");

		}

	}

	@Override

	public boolean save() {

		try {

			return false;

		}

	}

	@Override

	public boolean hasChanges() {

		AnnotationManager am;

			return false;

		}

	}

	@Override

	public boolean notifyStartOfCompute() throws Exception {

		if (annotationArea == null) return false;

		if (annotationArea.isDisposed()) return false;

		AnnotationType type = getSelectedAnnotationType();

		if (type != null) {

			annotations.setViewAnnotation(type);

			annotations.setAnnotationOverlap(true);

		}

		return true;

	}

	@Override

	public boolean notifyEndOfCompute() throws Exception {

		return true;

	}

	@Override

	public boolean isAnnotationEnable() {

		return annotationArea != null;

	}

	@Override

	public void notifyStartOfRefresh() throws Exception {

		if (annotationArea == null) return;

		if (annotationArea.isDisposed()) return;

		Page currentPage = editor.getEditionPanel(0).getCurrentPage();

		if (currentPage == null) return;

		String startID = currentPage.getWordId();

		Page nextPage = currentPage.getEdition().getNextPage(currentPage);

		String endID = nextPage.getWordId();

		annotations.computeStrings(startID, endID);

		updateAnnotationWidgetStates();

	}

	@Override

	protected void _close() {

		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

	}

	@Override

	public Class<? extends TXMResult> getAnnotatedTXMResultClass() {

		return org.txm.objects.Text.class;

	}

	@Override

	public boolean isDirty() {

		if (annotManager != null) {

		}

		return false;

	}

	@Override

	public boolean discardChanges() {

		return false;

	}

	@Override

	public boolean needToUpdateIndexes() {

		return KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.UPDATE);

	}

	@Override

	public boolean needToUpdateEditions() {

		return KRAnnotationPreferences.getInstance().getBoolean(KRAnnotationPreferences.UPDATE_EDITION);

           class="org.txm.annotation.kr.rcp.concordance.SimpleKRAnnotation"

           position="2">

     </annotationtoolbar>

  </extension>

</plugin>