EDIT

/**

* Copyright (C) 2014 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.molecular.editor;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URI;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import org.biojava.bio.chromatogram.ChromatogramFactory;

import org.biojava.bio.chromatogram.UnsupportedChromatogramFormatException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IActionBars;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.part.EditorPart;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;

import eu.etaxonomy.cdm.model.media.MediaUtils;

import eu.etaxonomy.cdm.model.molecular.Sequence;

import eu.etaxonomy.cdm.model.molecular.SequenceString;

import eu.etaxonomy.cdm.model.molecular.SingleRead;

import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.molecular.TaxeditorMolecularPlugin;

import eu.etaxonomy.taxeditor.molecular.handler.ToggleInsertOverwriteHandler;

import eu.etaxonomy.taxeditor.molecular.handler.ToggleLeftRightInsertionHandler;

import eu.etaxonomy.taxeditor.molecular.l10n.Messages;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.derivateSearch.DerivateLabelProvider;

import info.bioinfweb.commons.swt.SWTUtils;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import info.bioinfweb.libralign.alignmentarea.selection.SelectionModel;

import info.bioinfweb.libralign.alignmentarea.tokenpainter.NucleotideTokenPainter;

import info.bioinfweb.libralign.dataarea.implementations.ConsensusSequenceArea;

import info.bioinfweb.libralign.dataarea.implementations.pherogram.PherogramArea;

import info.bioinfweb.libralign.dataarea.implementations.sequenceindex.SequenceIndexArea;

import info.bioinfweb.libralign.editsettings.EditSettingsChangeEvent;

import info.bioinfweb.libralign.editsettings.EditSettingsListener;

import info.bioinfweb.libralign.model.AlignmentModel;

import info.bioinfweb.libralign.model.AlignmentModelChangeListener;

import info.bioinfweb.libralign.model.adapters.StringAdapter;

import info.bioinfweb.libralign.model.events.SequenceChangeEvent;

import info.bioinfweb.libralign.model.events.SequenceRenamedEvent;

import info.bioinfweb.libralign.model.events.TokenChangeEvent;

import info.bioinfweb.libralign.model.implementations.PackedAlignmentModel;

import info.bioinfweb.libralign.model.tokenset.CharacterTokenSet;

import info.bioinfweb.libralign.model.tokenset.TokenSet;

import info.bioinfweb.libralign.model.utils.AlignmentModelUtils;

import info.bioinfweb.libralign.multiplealignments.AlignmentAreaList;

import info.bioinfweb.libralign.multiplealignments.MultipleAlignmentsContainer;

import info.bioinfweb.libralign.pherogram.model.PherogramAlignmentRelation;

import info.bioinfweb.libralign.pherogram.model.PherogramAreaModel;

import info.bioinfweb.libralign.pherogram.model.ShiftChange;

import info.bioinfweb.libralign.pherogram.provider.BioJavaPherogramProvider;

import info.bioinfweb.libralign.pherogram.provider.PherogramProvider;

import info.bioinfweb.libralign.pherogram.provider.ReverseComplementPherogramProvider;

import info.bioinfweb.tic.SWTComponentFactory;

/**

 * Editor component to edit a contig alignment used to combine different overlapping pherograms from Sanger sequencing to

 * a consensus sequence.

 * <p>

 * The contained GUI components used to edit the alignment come from <a href="http://bioinfweb.info/LibrAlign/">LibrAlign</a>.

 *

 * @author Ben Stöver

 * @author pplitzner

 * @date 04.08.2014

 */

public class AlignmentEditor extends EditorPart {

    public static final String ID = "eu.etaxonomy.taxeditor.molecular.AlignmentEditor"; //$NON-NLS-1$

	public static final int READS_AREA_INDEX = 1;

    public static final int EDITABLE_CONSENSUS_AREA_INDEX = READS_AREA_INDEX + 1;

    public static final int CONSENSUS_HINT_AREA_INDEX = EDITABLE_CONSENSUS_AREA_INDEX + 1;

	public static final int PHEROGRAM_AREA_INDEX = 0;

	public static final int CONSENSUS_DATA_AREA_INDEX = 0;

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

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

    private final ConversationHolder conversationHolder;

	private final AlignmentModelChangeListener DIRTY_LISTENER = new AlignmentModelChangeListener() {

				@Override

				public <T> void afterTokenChange(TokenChangeEvent<T> e) {

					setDirty();

				}

				@Override

				public <T> void afterSequenceRenamed(SequenceRenamedEvent<T> e) {

					setDirty();

				}

				@Override

				public <T> void afterSequenceChange(SequenceChangeEvent<T> e) {

					setDirty();

				}

				@Override

				public <T, U> void afterProviderChanged(AlignmentModel<T> oldProvider,

						AlignmentModel<U> newProvider) {  // Not expected.

					setDirty();

				}

			};

	private final AlignmentEditorActionUpdater ACTION_UPDATER = new AlignmentEditorActionUpdater();

	public final Clipboard CLIPBOARD = new Clipboard(Display.getCurrent());  //TODO Move to global EDITor class.

    private MultipleAlignmentsContainer alignmentsContainer = null;

    private final Map<String, SingleReadAlignment> cdmMap = new TreeMap<String, SingleReadAlignment>();  //TODO Move this to ContigSequenceDataProvider

    private boolean dirty = false;

    public AlignmentEditor() {

    	super();

    	conversationHolder = CdmStore.createConversation();

    	//conversationHolder = null;

    }

    private void refreshToolbarElement(String id) {

		ICommandService commandService =

				(ICommandService)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(ICommandService.class);

		if (commandService != null) {

			commandService.refreshElements(id, Collections.EMPTY_MAP);

		}

    }

    private void registerEditSettingListener(MultipleAlignmentsContainer container) {

        container.getEditSettings().addListener(new EditSettingsListener() {

            @Override

            public void workingModeChanged(EditSettingsChangeEvent e) {}  // Currently nothing to do

            @Override

            public void insertLeftInDataAreaChanged(EditSettingsChangeEvent e) {

                updateStatusBar();

                refreshToolbarElement(ToggleLeftRightInsertionHandler.COMMAND_ID);

            }

            @Override

            public void insertChanged(EditSettingsChangeEvent e) {

                updateStatusBar();

                refreshToolbarElement(ToggleInsertOverwriteHandler.COMMAND_ID);

            }

        });

    }

    private AlignmentArea createIndexArea(MultipleAlignmentsContainer container, AlignmentArea labeledArea) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(false);

		result.getDataAreas().getTopAreas().add(new SequenceIndexArea(result.getContentArea(), labeledArea));

		return result;

    }

    private AlignmentArea createEditableAlignmentArea(MultipleAlignmentsContainer container, boolean allowVerticalScrolling) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(allowVerticalScrolling);

		CharacterTokenSet tokenSet = CharacterTokenSet.newDNAInstance();  //TODO Should NUCLEOTIDE be used instead?

		AlignmentModel<Character> model = new PackedAlignmentModel<Character>(tokenSet);

		result.setAlignmentModel(model, false);

		model.getChangeListeners().add(DIRTY_LISTENER);

		result.getPaintSettings().getTokenPainterList().set(0, new NucleotideTokenPainter());

		return result;

	}

    private AlignmentArea createConsensusHintArea(MultipleAlignmentsContainer container,

    		AlignmentArea labeledArea) {

		AlignmentArea result = new AlignmentArea(container);

		result.setAllowVerticalScrolling(false);

		result.getDataAreas().getBottomAreas().add(

				new ConsensusSequenceArea(result.getContentArea(), labeledArea));

		return result;

    }

    private MultipleAlignmentsContainer getAlignmentsContainer() {

    	if (alignmentsContainer == null) {

    		alignmentsContainer = new MultipleAlignmentsContainer();

    		AlignmentAreaList list = alignmentsContainer.getAlignmentAreas();

    		AlignmentArea readsArea = createEditableAlignmentArea(alignmentsContainer, true);

    		readsArea.getSelection().addSelectionListener(ACTION_UPDATER);

    	    list.add(createIndexArea(alignmentsContainer, readsArea));

    		list.add(readsArea);  // Make sure READS_AREA_INDEX is correct.

    		AlignmentArea editableConsensusArea = createEditableAlignmentArea(alignmentsContainer, false);

    		editableConsensusArea.getSelection().addSelectionListener(ACTION_UPDATER);

    		list.add(editableConsensusArea);  // Make sure COMSENSUS_AREA_INDEX is correct.

    		list.add(createConsensusHintArea(alignmentsContainer, readsArea));

    		registerEditSettingListener(alignmentsContainer);

       	}

		return alignmentsContainer;

	}

    public AlignmentArea getReadsArea() {

    	return getAlignmentsContainer().getAlignmentAreas().get(READS_AREA_INDEX);

    }

    public AlignmentArea getEditableConsensusArea() {

    	return getAlignmentsContainer().getAlignmentAreas().get(EDITABLE_CONSENSUS_AREA_INDEX);

    }

    /**

     * Checks whether {@link #getReadsArea()} or {@link #getEditableConsensusArea()} currently

     * have the user focus and returns the according component.

     *

     * @return either the reads or the consensus alignment area or {@code null} if none of these

     *         components is currently focused

     */

    public AlignmentArea getFocusedArea() {

    	AlignmentArea result = getReadsArea();

    	if (hasFocus(result)) {

    		return result;

    	}

    	else {

    		result = getEditableConsensusArea();

        	if (hasFocus(result)) {

        		return result;

        	}

        	else {

        		return null;

        	}

    	}

    }

    /**

     * Checks whether the specified alignment area or one of its subcomponents currently has the

     * focus.

     *

     * @param area the alignment area to be checked (Can only be {@link #getReadsArea()} or

     *        {@link #getEditableConsensusArea()}.)

     * @return {@code true} if the specified component is focused and is either equal to

     *         {@link #getReadsArea()} or {@link #getEditableConsensusArea()}or {@code false} otherwise

     */

    private boolean hasFocus(AlignmentArea area) {

    	return SWTUtils.childHasFocus((Composite)area.getToolkitComponent());

    }

    public boolean hasPherogram(String sequenceID) {

        return getReadsArea().getDataAreas().getSequenceAreas(sequenceID).size() > PHEROGRAM_AREA_INDEX;

    }

    public PherogramArea getPherogramArea(String sequenceID) {

        if (hasPherogram(sequenceID)) {

            return (PherogramArea)getReadsArea().getDataAreas().getSequenceAreas(sequenceID).get(PHEROGRAM_AREA_INDEX);

        }

        else {

            return null;

        }

    }

    private ConsensusSequenceArea getConsensusHintDataArea() {

        return (ConsensusSequenceArea)getAlignmentsContainer().getAlignmentAreas().

                get(CONSENSUS_HINT_AREA_INDEX).getDataAreas().getBottomAreas().

                get(CONSENSUS_DATA_AREA_INDEX);

    }

    @Deprecated  //TODO Remove as soon as testing period is over

    private void createTestContents() {

		// Just for testing:

		try {

			addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/JR430_JR-P01.ab1").toURI(), false); //$NON-NLS-1$

            //addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/JR444_JR-P05.ab1").toURI(), false);

            addRead(new File("D:/Users/BenStoever/ownCloud/Dokumente/Projekte/EDITor/Quelltexte/LibrAlign branch/Repository/eu.etaxonomy.taxeditor.editor/src/main/resources/AlignmentTestData/Test_qualityScore.scf").toURI(), false); //$NON-NLS-1$

			// Add test consensus sequence:

			AlignmentModel consensusModel = getEditableConsensusArea().getAlignmentModel();

			String id = consensusModel.addSequence(CONSENSUS_NAME);

			Collection<Object> tokens = new ArrayList<Object>();  // First save tokens in a collection to avoid GUI updated for each token.

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("A")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("C")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("G")); //$NON-NLS-1$

			tokens.add(consensusModel.getTokenSet().tokenByRepresentation("T")); //$NON-NLS-1$

			consensusModel.insertTokensAt(id, 0, tokens);

		}

		catch (Exception e) {

			throw new RuntimeException(e);

		}

    }

    private void readCDMData(Sequence sequenceNode) {

    	//TODO If called from somewhere else than createPartControl() the editorInput needs to be checked and previous contents need to be cleared (or updated).

		// Add reads:

		for (SingleReadAlignment singleReadAlignment : sequenceNode.getSingleReadAlignments()) {

			try {

				SingleRead pherogramInfo = singleReadAlignment.getSingleRead();

				String id = addRead(DerivateLabelProvider.getDerivateText(pherogramInfo, conversationHolder),

						getPherogramURI(pherogramInfo),

						singleReadAlignment.isReverseComplement(),

						singleReadAlignment.getEditedSequence(),

						singleReadAlignment.getFirstSeqPosition(),

						singleReadAlignment.getLeftCutPosition(),

						singleReadAlignment.getRightCutPosition(),

						singleReadAlignment.getShifts());

				cdmMap.put(id, singleReadAlignment);

			}

			catch (Exception e) {  // Usually due to an error while trying to read the pherogram (e.g. due to an unsupported format or an invalid URI).

                MessagingUtils.errorDialog(Messages.AlignmentEditor_ERROR_SINGLE_READ, null, Messages.AlignmentEditor_ERROR_SINGLE_READ_MESSAGE +

                        e.getLocalizedMessage(), TaxeditorMolecularPlugin.PLUGIN_ID, e, false);

			}

		}

		// Set consensus sequence:

		AlignmentModel consensusModel = getEditableConsensusArea().getAlignmentModel();

		String id = consensusModel.addSequence(CONSENSUS_NAME);

		consensusModel.insertTokensAt(id, 0, AlignmentModelUtils.charSequenceToTokenList(

				sequenceNode.getConsensusSequence().getString(), consensusModel.getTokenSet()));

		//TODO Can the consensus sequence also be null? / Should it be created here, if nothing is in the DB?

    }

    @Override

    public void createPartControl(Composite parent) {

		SWTComponentFactory.getInstance().getSWTComponent(getAlignmentsContainer(), parent, SWT.NONE);

		Display.getCurrent().addFilter(SWT.FocusIn, ACTION_UPDATER);

		Display.getCurrent().addFilter(SWT.FocusOut, ACTION_UPDATER);

		updateStatusBar();

		if (getEditorInput() instanceof AlignmentEditorInput) {

			if (((AlignmentEditorInput)getEditorInput()).getSequenceNodeUuid() != null) {

			    Sequence sequenceNode = CdmStore.getService(ISequenceService.class).load(((AlignmentEditorInput)getEditorInput()).getSequenceNodeUuid());

		        //re-load into the current session if it is already persisted in the DB

		        if(sequenceNode!=null && sequenceNode.getId()!=0){

		            sequenceNode = CdmStore.getService(ISequenceService.class).load(sequenceNode.getUuid());

		        }

				readCDMData(sequenceNode);

			}

			else {

				createTestContents();  // This case will removed after the test phase and an exception should probably be thrown.

			}

		}

		else {

			throw new IllegalArgumentException(String.format(Messages.AlignmentEditor_MUST_HAVE_TYPE,

					AlignmentEditorInput.class.getCanonicalName()));  //TODO What should be done here?

		}

	}

    @Override

	public void dispose() {

		Display.getCurrent().removeFilter(SWT.FocusIn, ACTION_UPDATER);

		Display.getCurrent().removeFilter(SWT.FocusOut, ACTION_UPDATER);

		CLIPBOARD.dispose();

        ((AlignmentEditorInput)getEditorInput()).dispose();

		super.dispose();

	}

	private void updateStatusBar() {

        IActionBars bars = getEditorSite().getActionBars();

        bars.getStatusLineManager().setMessage(

                Messages.AlignmentEditor_EDIT_MODE + (getReadsArea().getEditSettings().isInsert() ? Messages.AlignmentEditor_INSERT : Messages.AlignmentEditor_OVERWRITE) + "  " + //$NON-NLS-1$

        		Messages.AlignmentEditor_INSERTION_PHEROGRAM +

	       		(getReadsArea().getEditSettings().isInsertLeftInDataArea() ? Messages.AlignmentEditor_LEFT : Messages.AlignmentEditor_RIGHT));  //TODO multi language

    }

    private SingleReadAlignment.Shift[] convertToCDMShifts(PherogramAreaModel model) {

    	Iterator<ShiftChange> iterator = model.shiftChangeIterator();

    	List<SingleReadAlignment.Shift> shifts = new ArrayList<SingleReadAlignment.Shift>();

    	while (iterator.hasNext()) {

    		ShiftChange shiftChange = iterator.next();

    		shifts.add(new SingleReadAlignment.Shift(shiftChange.getBaseCallIndex(), shiftChange.getShiftChange()));

    	}

    	return shifts.toArray(new SingleReadAlignment.Shift[shifts.size()]);

    }

    @Override

    public void doSave(IProgressMonitor monitor) {

    	if (getEditorInput() instanceof AlignmentEditorInput) {

        	String taskName = Messages.AlignmentEditor_SAVING_ALIGNMENT;  //TODO multi language

            monitor.beginTask(taskName, 3);

            //re-loading sequence to avoid session conflicts

    		Sequence sequenceNode = CdmStore.getService(ISequenceService.class).load(((AlignmentEditorInput)getEditorInput()).getSequenceNodeUuid());

    		((AlignmentEditorInput)getEditorInput()).setSequenceNode(sequenceNode);

    		StringAdapter stringProvider = new StringAdapter(getEditableConsensusArea().getAlignmentModel(), false);  // Throws an exception if a token has more than one character.

    		// Write consensus sequence:

    		SequenceString consensusSequenceObj = sequenceNode.getConsensusSequence();

    		String newConsensusSequence = stringProvider.getSequence(

    				getEditableConsensusArea().getAlignmentModel().sequenceIDByName(CONSENSUS_NAME));

    		if (consensusSequenceObj == null) {

    			sequenceNode.setConsensusSequence(SequenceString.NewInstance(newConsensusSequence));

    		}

    		else {

    			consensusSequenceObj.setString(newConsensusSequence);

    		}

    		// Write single reads:

    		stringProvider.setUnderlyingModel(getReadsArea().getAlignmentModel());

    		sequenceNode.getSingleReadAlignments().retainAll(cdmMap.values());  // Remove all reads that are not in the alignment anymore.

    		Iterator<String> iterator = getReadsArea().getAlignmentModel().sequenceIDIterator();

    		while (iterator.hasNext()) {

    			String id = iterator.next();

    			SingleReadAlignment singleRead = cdmMap.get(id);

    			if (singleRead == null) {

    			    throw new InternalError(Messages.AlignmentEditor_NEW_READ_FAILURE);  //TODO multi language

    				//TODO Create new read object. => Shall it be allowed to add reads in the alignment editor which are not represented in the CDM tree before the alignment editor is saved?

    				//singleRead = SingleReadAlignment.NewInstance(consensusSequence, singleRead, shifts, editedSequence);

    			}

    			singleRead.setEditedSequence(stringProvider.getSequence(id));

    			PherogramArea pherogramArea = getPherogramArea(id);

    			if (pherogramArea != null) {

        			PherogramAreaModel model = pherogramArea.getModel();

        			singleRead.setReverseComplement(model.getPherogramProvider() instanceof ReverseComplementPherogramProvider);  // Works only if ReverseComplementPherogramProvider instances are not nested.

        			singleRead.setShifts(convertToCDMShifts(getPherogramArea(id).getModel()));

        			singleRead.setFirstSeqPosition(model.getFirstSeqPos());

        			singleRead.setLeftCutPosition(model.getLeftCutPosition());

        			singleRead.setRightCutPosition(model.getRightCutPosition());

    			}

    		}

    		if (!conversationHolder.isBound()) {

                conversationHolder.bind();

            }

            monitor.worked(1);

            ((AlignmentEditorInput)getEditorInput()).merge();

            // Commit the conversation and start a new transaction immediately:

            conversationHolder.commit(true);

            monitor.worked(1);

            dirty = false;

            monitor.worked(1);

            monitor.done();

            firePropertyChange(PROP_DIRTY);

    	}

    	else {

    		//TODO Throw exception as soon as testing period which allows unlinked AlignmentEditor is over.

    	}

    }

    @Override

    public void doSaveAs() {}

    @Override

    public void init(IEditorSite site, IEditorInput input) throws PartInitException {

        setSite(site);

        setInput(input);

    }

    @Override

    public boolean isDirty() {

        return dirty;

    }

    private void setDirty() {

    	dirty = true;

    	firePropertyChange(IEditorPart.PROP_DIRTY);

    }

    @Override

    public boolean isSaveAsAllowed() {

        return false;  // "Save as" not allowed.

    }

    @Override

    public void setFocus() {

        if(conversationHolder != null){

            conversationHolder.bind();

        }

        ((AlignmentEditorInput)getEditorInput()).bind();

    }

    public boolean isInsertMode() {

        return getAlignmentsContainer().getEditSettings().isInsert();

    }

    public boolean isInsertLeftInPherogram() {

        return getAlignmentsContainer().getEditSettings().isInsertLeftInDataArea();

    }

    public void toggleLeftRightInsertionInPherogram() {

    	getAlignmentsContainer().getEditSettings().toggleInsertLeftInDataArea();

    }

    public void toggleInsertOverwrite() {

    	getAlignmentsContainer().getEditSettings().toggleInsert();

    }

    private String cutPherogram(boolean left) {

        SelectionModel selection = getReadsArea().getSelection();

        if (selection.getCursorHeight() != 1) {

            return Messages.AlignmentEditor_CUTTING_FAILURE;  //TODO multi language

        }

        else {

            PherogramArea pherogramArea =

                    getPherogramArea(getReadsArea().getSequenceOrder().idByIndex(selection.getCursorRow()));

            if (pherogramArea == null) {

                return Messages.AlignmentEditor_NO_ATTACHED_PHEROGRAM;  //TODO multi language

            }

            else {

                if (left) {

                    if (pherogramArea.setLeftCutPositionBySelection()) {

                        return null;

                    }

                    else {

                        return Messages.AlignmentEditor_LEFT_END_OUTSIDE;  //TODO multi language

                    }

                }

                else {

                    if (pherogramArea.setRightCutPositionBySelection()) {

                        return null;

                    }

                    else {

                        return Messages.AlignmentEditor_RIGHT_END_OUTSIDE;  //TODO multi language

                    }

                }

            }

        }

    }

    public String cutPherogramLeft() {

        return cutPherogram(true);

    }

    public String cutPherogramRight() {

        return cutPherogram(false);

    }

    public void reverseComplementSelectedSequences() {

    	SelectionModel selection = getReadsArea().getSelection();

    	AlignmentModel<?> model = getReadsArea().getAlignmentModel();

    	for (int row = selection.getFirstRow(); row < selection.getFirstRow() + selection.getCursorHeight(); row++) {

    		String sequenceID = getReadsArea().getSequenceOrder().idByIndex(row);

			PherogramArea area = getPherogramArea(sequenceID);

			PherogramAreaModel pherogramAlignmentModel = area.getModel();

            PherogramAlignmentRelation rightRelation = pherogramAlignmentModel.editableIndexByBaseCallIndex(

                    pherogramAlignmentModel.getRightCutPosition());

            int rightBorder;

            if (rightRelation.getCorresponding() == PherogramAlignmentRelation.OUT_OF_RANGE) {

                rightBorder = rightRelation.getBeforeValidIndex() + 1;

            }

            else {

                rightBorder = rightRelation.getAfterValidIndex();

            }

			AlignmentModelUtils.reverseComplement(model, sequenceID,

			        pherogramAlignmentModel.editableIndexByBaseCallIndex(

			                pherogramAlignmentModel.getLeftCutPosition()).getBeforeValidIndex(),

			        rightBorder);

			pherogramAlignmentModel.reverseComplement();

		}

    }

    /**

     * Recreates the whole consensus sequence from all single read sequences. The previous consensus

     * sequence is overwritten.

     */

    @SuppressWarnings("unchecked")

    public <T> void createConsensusSequence() {

        ConsensusSequenceArea area = getConsensusHintDataArea();

        AlignmentModel<T> model = (AlignmentModel<T>)getEditableConsensusArea().getAlignmentModel();

        String sequenceID = model.sequenceIDIterator().next();  // There is always one sequence contained.

        int length = getReadsArea().getAlignmentModel().getMaxSequenceLength();

        Collection<T> tokens = new ArrayList<T>(length);

        for (int column = 0; column < length; column++) {

            tokens.add(model.getTokenSet().tokenByRepresentation(area.getConsensusToken(column)));

        }

        model.removeTokensAt(sequenceID, 0, model.getSequenceLength(sequenceID));

        model.insertTokensAt(sequenceID, 0, tokens);

    }

    /**

     * Updates the current consensus sequence by replacing gaps by the according consensus tokens

     * calculated from the single read sequences and extends the consensus sequence if necessary.

     */

    @SuppressWarnings("unchecked")

    public <T> void updateConsensusSequence() {

        ConsensusSequenceArea area = getConsensusHintDataArea();

        AlignmentModel<T> model = (AlignmentModel<T>)getEditableConsensusArea().getAlignmentModel();

        TokenSet<T> tokenSet = model.getTokenSet();

        String sequenceID = model.sequenceIDIterator().next();  // There is always one sequence contained.

        int currentConsensusLength = model.getSequenceLength(sequenceID);

        int overallLength = getReadsArea().getAlignmentModel().getMaxSequenceLength();

        // Replace gaps by new information:

        for (int column = 0; column < currentConsensusLength; column++) {

            if (tokenSet.isGapToken(model.getTokenAt(sequenceID, column))) {

                T newToken = tokenSet.tokenByRepresentation(area.getConsensusToken(column));

                if (!tokenSet.isGapToken(newToken)) {

                    model.setTokenAt(sequenceID, column, newToken);

                }

            }

        }

        // Append additional tokens:

        if (overallLength > currentConsensusLength) {

            Collection<T> tokens = new ArrayList<T>(overallLength);

            for (int column = currentConsensusLength; column < overallLength; column++) {

                tokens.add(tokenSet.tokenByRepresentation(area.getConsensusToken(column)));

            }

            model.appendTokens(sequenceID, tokens);

        }

    }

	public static PherogramProvider readPherogram(URI uri) throws IOException, UnsupportedChromatogramFormatException {

	    PherogramProvider result;

		InputStream stream = uri.toURL().openStream();

		try {

			result = new BioJavaPherogramProvider(ChromatogramFactory.create(stream));

		}

		finally {

			stream.close();

		}

		return result;

	}

	private String newReadName() {

		int index = 1;

		while (getReadsArea().getAlignmentModel().sequenceIDByName(DEFAULT_READ_NAME_PREFIX + index) != null) {

			index++;

		}

		return DEFAULT_READ_NAME_PREFIX + index;

	}

    public void addRead(URI pherogramURI, boolean reverseComplemented) throws IOException, UnsupportedChromatogramFormatException {

    	addRead(newReadName(), pherogramURI, reverseComplemented, null, null, null, null, null);

    }

    /**

     * Adds a new sequence with attached phergram data area to the reads alignment.

     * <p>

     * If {@code null} is specified as {@code editedSequence} the base call sequence from the pherogram will

     * be set as the edited sequence. If {@code null} is specified as {@code shifts} no shifts between the edited

     * and the base calls sequence are assumed.

     *

     * @param name the name of the new sequence

     * @param pherogramURI the URI where the associated pherogram file is located

     * @param reverseComplemented Specify {@code true} here, if the reverse complement of the pherogram data should

     *        be added, {@code false} otherwise.

     * @param editedSequence the edited version of the base call sequence (May be {@code null}.)

     * @param shifts the alignment information that links the edited and the base call sequence (May be {@code null}.)

     * @return the sequence ID of the added read

     * @throws IOException if an error occurred when trying to read the pherogram file

     * @throws UnsupportedChromatogramFormatException if the format of the pherogram file is not supported

     */

    public String addRead(String name, URI pherogramURI, boolean reverseComplemented, String editedSequence,

            Integer firstSeqPos, Integer leftCutPos, Integer rightCutPos, SingleReadAlignment.Shift[] shifts)

            throws IOException, UnsupportedChromatogramFormatException {

		AlignmentModel model = getReadsArea().getAlignmentModel();

		PherogramProvider pherogramProvider = null;

		if (pherogramURI != null) {

		    pherogramProvider = readPherogram(pherogramURI);  // Must happen before a sequence is added, because it might throw an exception.

            if (reverseComplemented) {

                pherogramProvider = new ReverseComplementPherogramProvider(pherogramProvider);

            }

		}

        // Create sequence:

		model.addSequence(name);

		String id = model.sequenceIDByName(name);

		// Set edited sequence:

		Collection<Object> tokens = null;  // First save tokens in a collection to avoid GUI updated for each token.

		if (editedSequence != null) {

			tokens = AlignmentModelUtils.charSequenceToTokenList(editedSequence, model.getTokenSet());

		}

		else if (pherogramProvider != null) {  // Copy base call sequence into alignment:

			tokens = new ArrayList<Object>();

			for (int i = 0; i < pherogramProvider.getSequenceLength(); i++) {

				tokens.add(model.getTokenSet().tokenByRepresentation(

					Character.toString(pherogramProvider.getBaseCall(i))));

			}

			setDirty();

		}

		if (tokens != null) {  // If either an edited sequence or a pherogram URI was provided.

		    model.insertTokensAt(id, 0, tokens);

		    if (pherogramProvider != null) {

		        // Create pherogram area:

		        PherogramArea pherogramArea = new PherogramArea(getReadsArea().getContentArea(),

		                new PherogramAreaModel(pherogramProvider));

		        // Set position properties and shifts:

		        PherogramAreaModel phergramModel = pherogramArea.getModel();

		        if ((firstSeqPos != null) && (leftCutPos != null)) {

		            phergramModel.setFirstSeqLeftCutPos(firstSeqPos, leftCutPos);

		        }

		        if (rightCutPos != null) {

		            phergramModel.setRightCutPosition(rightCutPos);

		        }

		        if ((shifts != null) && (shifts.length > 0)) {

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

		                phergramModel.addShiftChange(shifts[i].position, shifts[i].shift);

		            }

		            setDirty();

		        }

		        // Add pherogram area to GUI:

		        pherogramArea.addMouseListener(new PherogramMouseListener(pherogramArea));

		        getReadsArea().getDataAreas().getSequenceAreas(id).add(pherogramArea);

		    }

		}

		return id;

	}

    public static URI getPherogramURI(SingleRead pherogramInfo) {

        if (pherogramInfo.getPherogram() != null) {

            return MediaUtils.getFirstMediaRepresentationPart(pherogramInfo.getPherogram()).getUri();

        }

        else {

            return null;

        }

    }

}

 * 

	private static final String[] IDS = {ActionFactory.COPY.getCommandId(), ActionFactory.CUT.getCommandId(), 

		ICommandService service = (ICommandService)PlatformUI.getWorkbench().getService(ICommandService.class);

		AlignmentEditor editor = AbstractAlignmentEditorHandler.getActiveAlignmentEditor();

		AlignmentEditor editor = AbstractAlignmentEditorHandler.getActiveAlignmentEditor();

			if ((e.getSource() == editor.getReadsArea().getSelection()) || 

import org.eclipse.ui.PartInitException;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.molecular.TaxeditorMolecularPlugin;

import eu.etaxonomy.taxeditor.molecular.handler.ShowPherogramHandler;

import eu.etaxonomy.taxeditor.molecular.l10n.Messages;

		if (event.getClickCount() == 2) {  // Double click

			try {

			    ShowPherogramHandler.showPherogram(area.getModel());

			}

			catch (PartInitException e) {

                MessagingUtils.errorDialog(Messages.PherogramMouseListener_UNABLE_TO_CREATE_VIEW, null, e.getLocalizedMessage(),

                        TaxeditorMolecularPlugin.PLUGIN_ID,  e, false);  //TODO set pluginID

			}

            return true;

		}

		else {

		}

import eu.etaxonomy.taxeditor.molecular.handler.ToggleInsertOverwriteHandler;

import eu.etaxonomy.taxeditor.molecular.handler.ToggleLeftRightInsertionHandler;

                refreshToolbarElement(ToggleLeftRightInsertionHandler.COMMAND_ID);

                refreshToolbarElement(ToggleInsertOverwriteHandler.COMMAND_ID);

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * {@link AlignmentEditor}.

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * Handler that pastes the current contents of the clipboard into an active instance of {@link AlignmentEditor}.

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * of {@link AlignmentEditor}. A previously present consensus sequence will be overwritten.

 * @see AlignmentEditor#createConsensusSequence()

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * Handler that loads an additional read into the contig alignment displayed by an instance of {@link AlignmentEditor}.

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * Reverse complements the single read sequence in an active {@link AlignmentEditor}, where the alignment cursor

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

import eu.etaxonomy.taxeditor.molecular.editor.PherogramViewPart;

 * Displays an undistorted pherogram with {@link PherogramViewPart}.

			        pherogramPart.init(new PherogramComponentModel(AlignmentEditor.readPherogram(uri)));

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * Switches an {@link AlignmentEditor} between insertion and overwrite mode.

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * Switches an {@link AlignmentEditor} between insertion in the base sequence to

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

import eu.etaxonomy.taxeditor.molecular.editor.PherogramViewPart;

 * in pherogram areas of {@link AlignmentEditor} or {@link PherogramViewPart}.

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

 * {@link AlignmentEditor}.

	public static AlignmentEditor getActiveAlignmentEditor() {

        if (activeEditor instanceof AlignmentEditor) {

            return (AlignmentEditor)activeEditor;

    	AlignmentEditor editor = getActiveAlignmentEditor();

    protected abstract void doExecute(ExecutionEvent event, AlignmentEditor editor) throws ExecutionException;

package eu.etaxonomy.taxeditor.molecular.handler;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

public abstract class AbstractFocusedAlignmentAreaHandler extends AbstractAlignmentEditorHandler {

	@Override

	protected void doExecute(ExecutionEvent event, AlignmentEditor editor) throws ExecutionException {

    	AlignmentArea focusedArea = editor.getFocusedArea();

    	if (focusedArea != null) {

    		doExecute2(event, editor, focusedArea);

    	}

	}

	protected abstract void doExecute2(ExecutionEvent event, AlignmentEditor editor, AlignmentArea focusedArea);

}

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.molecular.handler;

import java.util.Iterator;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

import eu.etaxonomy.taxeditor.molecular.editor.PherogramViewPart;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import info.bioinfweb.libralign.dataarea.implementations.pherogram.PherogramArea;

import info.bioinfweb.libralign.pherogram.PherogramComponent;

/**

 * Abstract handler implementation allows to performs the concrete operation either on an instance of

 * {@link PherogramViewPart} or all {@link AlignmentArea}s inside an instance of {@link AlignmentEditor}.

 *

 * @author Ben Stöver

 * @date 23.06.2015

 */

public abstract class AbstractPherogramComponentHandler extends AbstractHandler {

    @Override

    public Object execute(ExecutionEvent event) throws ExecutionException {

        Object activePart = AbstractUtility.getActivePart();

        if (activePart instanceof AlignmentEditor) {

            AlignmentEditor editor = (AlignmentEditor)activePart;

            Iterator<String> idIterator = editor.getReadsArea().getAlignmentModel().sequenceIDIterator();

            while (idIterator.hasNext()) {

                PherogramArea area = editor.getPherogramArea(idIterator.next());

                if (area != null) {

                    doExecute(event, area);

                }

            }

        }

        else if (activePart instanceof PherogramViewPart) {

            doExecute(event, ((PherogramViewPart)activePart).getPherogramView().getTraceCurveView());

        }

        return null;

    }

    public abstract void doExecute(ExecutionEvent event, PherogramComponent component) throws ExecutionException;

}

package eu.etaxonomy.taxeditor.molecular.handler;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import info.bioinfweb.libralign.alignmentarea.selection.SelectionModel;

import info.bioinfweb.libralign.model.utils.AlignmentModelUtils;

import java.util.Map;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.swt.dnd.TextTransfer;

import org.eclipse.swt.dnd.Transfer;

import org.eclipse.ui.commands.IElementUpdater;

import org.eclipse.ui.menus.UIElement;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

/**

 * Handler that copies the currently selected nucleotides from an alignment editor to the clipboard.

 * <p>

 * The copied contents either come from the single reads or the consensus sequence alignment area,

 * depending on which component currently has the focus. If none of these components has the focus,

 * nothing will be copied, even if nucleotides are currently selected.

 * <p>

 * If the selection contains parts of multiple sequence, these are separated by the line separator

 * of the current operating system.

 *

 * @author Ben Stöver

 * @date 25.08.2015

 */

public class AlignmentEditorCopyHandler extends AbstractFocusedAlignmentAreaHandler implements IElementUpdater {

    @Override

	@SuppressWarnings("unchecked")

	protected void doExecute2(ExecutionEvent event, AlignmentEditor editor, AlignmentArea focusedArea) {

    	SelectionModel selection = focusedArea.getSelection();

    	if (!selection.isEmpty()) {

    		editor.CLIPBOARD.setContents(new Object[]{AlignmentModelUtils.selectionAsString(focusedArea, false)},

            		new Transfer[]{TextTransfer.getInstance()});

    	}

	}

	@Override

	public boolean isEnabled() {

		AlignmentEditor editor = getActiveAlignmentEditor();

		if (editor != null) {

			AlignmentArea focusedArea = editor.getFocusedArea();

			if (focusedArea != null) {

				return !focusedArea.getSelection().isEmpty();

			}

		}

		return false;

	}

	@Override

	public void updateElement(UIElement element, @SuppressWarnings("rawtypes") Map parameters) {

		setBaseEnabled(isEnabled());

    }

}

package eu.etaxonomy.taxeditor.molecular.handler;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import org.eclipse.core.commands.ExecutionEvent;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

/**

 * Handler that cuts the currently selected nucleotides from an alignment editor to the clipboard.

 * <p>

 * The cut contents either come from the single reads or the consensus sequence alignment area,

 * depending on which component currently has the focus. If none of these components has the focus,

 * nothing will be cut, even if nucleotides are currently selected.

 * <p>

 * If the selection contains parts of multiple sequence, these are separated by the line separator

 * of the current operating system.  

 * 

 * @author Ben Stöver

 * @date 25.08.2015

 */

public class AlignmentEditorCutHandler extends AlignmentEditorCopyHandler {

	@Override

	protected void doExecute2(ExecutionEvent event, AlignmentEditor editor,	AlignmentArea focusedArea) {

		super.doExecute2(event, editor, focusedArea);  // Copy selected contents.

		focusedArea.getActionProvider().deleteSelection();

	}

}

package eu.etaxonomy.taxeditor.molecular.handler;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.dnd.TextTransfer;

import org.eclipse.ui.commands.IElementUpdater;

import org.eclipse.ui.handlers.HandlerUtil;

import org.eclipse.ui.menus.UIElement;

import eu.etaxonomy.taxeditor.molecular.editor.AlignmentEditor;

import eu.etaxonomy.taxeditor.molecular.l10n.Messages;

import info.bioinfweb.libralign.alignmentarea.AlignmentArea;

import info.bioinfweb.libralign.alignmentarea.order.SequenceOrder;

import info.bioinfweb.libralign.alignmentarea.selection.SelectionModel;

import info.bioinfweb.libralign.model.AlignmentModel;

import info.bioinfweb.libralign.model.utils.AlignmentModelUtils;

/**

 * Handler that pastes the current contents of the clipboard into an active instance of {@link AlignmentEditor}.

 *

 * @author Ben Stöver

 * @date 26.08.2015

 */

public class AlignmentEditorPasteHandler extends AbstractFocusedAlignmentAreaHandler implements IElementUpdater {

	private void pasteString(AlignmentArea area, String sequenceID, String content) {

		area.getActionProvider().deleteSelection();  // Overwrite selected tokens.

		area.getActionProvider().elongateSequence(sequenceID, area.getSelection().getCursorColumn());

		@SuppressWarnings("unchecked")

		AlignmentModel<Object> alignmentModel = (AlignmentModel<Object>)area.getAlignmentModel();

		alignmentModel.insertTokensAt(sequenceID, area.getSelection().getCursorColumn(),

				AlignmentModelUtils.charSequenceToTokenList(content, alignmentModel.getTokenSet(),

						true, alignmentModel.getTokenSet().getGapToken()));

	}

	@Override

	protected void doExecute2(ExecutionEvent event, AlignmentEditor editor, AlignmentArea focusedArea) {

		SelectionModel selection = focusedArea.getSelection();

		String clipboardText = (String)editor.CLIPBOARD.getContents(TextTransfer.getInstance());

		if (clipboardText != null) {

			List<String> lines = new ArrayList<String>();

			Scanner scanner = new Scanner(clipboardText);

			try {

				while (scanner.hasNext()) {

					lines.add(scanner.nextLine());

				}

				if (lines.get(lines.size() - 1).equals("")) { //$NON-NLS-1$

					lines.remove(lines.size() - 1);

				}

			}

			finally {

				scanner.close();

			}

			if (!lines.isEmpty()) { //TODO Can lines be empty? (Can an empty string "" be copied to the clipboard?)

				if (selection.getCursorHeight() == 1) {  // If the consensus sequence is focused, this is the only possible case.

					String sequenceID = focusedArea.getSequenceOrder().idByIndex(selection.getCursorRow());

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

						pasteString(focusedArea, sequenceID, lines.get(0));

					}

					else {

						MessageDialog dialog = new MessageDialog(HandlerUtil.getActiveWorkbenchWindow(event).getShell(),  //TODO Can the window be null?

								Messages.AlignmentEditorPasteHandler_PASTING_LINES, null,

								String.format(Messages.AlignmentEditorPasteHandler_PASTING_LINES_QUESTION, lines.size()),

								MessageDialog.QUESTION,

								new String[]{Messages.AlignmentEditorPasteHandler_PASTING_LINES_IGNORE,

										Messages.AlignmentEditorPasteHandler_PASTING_LINES_FIRST_LINE, Messages.AlignmentEditorPasteHandler_CANCEL},

								0);

						//TODO Does the dialog have to be disposed in some way?

						switch (dialog.open()) {

							case 0:  // Paste all lines in one sequence.

								pasteString(focusedArea, sequenceID, clipboardText);

								break;

							case 1:  // Paste only first line.

								pasteString(focusedArea, sequenceID, lines.get(0));

								break;

						}

					}

				}

				else {

					if (selection.getCursorHeight() == lines.size()) {

						SequenceOrder order = focusedArea.getSequenceOrder();

						for (int i = 0; i < selection.getCursorHeight(); i++) {

							pasteString(focusedArea, order.idByIndex(selection.getCursorRow() + i), lines.get(i));  // Multiple calls of deleteSelection() in here are unnecessary, but should have no effect.

						}

					}

					else {

						MessageDialog.openError(HandlerUtil.getActiveWorkbenchWindow(event).getShell(),  //TODO Can the window be null?

								Messages.AlignmentEditorPasteHandler_PASTE_FAILURE,

								String.format(Messages.AlignmentEditorPasteHandler_PASTE_FAILURE_MESSAGE, selection.getCursorHeight(), lines.size(), System.getProperty("line.separator"))); //$NON-NLS-1$

					}

				}

			}

		}

	}

	@Override

	public boolean isEnabled() {