eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/annotatedlineeditor/AnnotatedLineEditor.java

   1 // $Id$
   2 /**
   3  * Copyright (C) 2007 EDIT
   4  * European Distributed Institute of Taxonomy
   5  * http://www.e-taxonomy.eu
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version 1.1
   8  * See LICENSE.TXT at the top of this package for the full license terms.
   9  */
  10 package eu.etaxonomy.taxeditor.annotatedlineeditor;
  11
  12 import java.util.Iterator;
  13
  14 import org.eclipse.core.runtime.CoreException;
  15 import org.eclipse.core.runtime.IProgressMonitor;
  16 import org.eclipse.jface.text.BadLocationException;
  17 import org.eclipse.jface.text.source.IAnnotationModel;
  18 import org.eclipse.jface.text.source.ISourceViewer;
  19 import org.eclipse.jface.text.source.IVerticalRuler;
  20 import org.eclipse.swt.widgets.Composite;
  21 import org.eclipse.ui.IEditorInput;
  22 import org.eclipse.ui.PlatformUI;
  23 import org.eclipse.ui.editors.text.TextEditor;
  24 import org.eclipse.ui.texteditor.IDocumentProvider;
  25
  26 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  27 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  28 import eu.etaxonomy.cdm.api.service.IOccurrenceService;
  29 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  30 import eu.etaxonomy.cdm.model.common.CdmBase;
  31 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  32 import eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput;
  33 import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
  34 import eu.etaxonomy.taxeditor.store.CdmStore;
  35
  36 /**
  37  * A list-based editor, where each line in the editor's document is associated with a domain object.
  38  * <p>
  39  * Extending classes must set:
  40  * <ul>
  41  * <li>an {@link IEntityPersistenceService} for interacting with the persistence layer; and
  42  * <li>an {@link ILineDisplayStrategy} for various visual manifestations of the domain object.
  43  * </ul>
  44  *
  45  * @author p.ciardelli
  46  * @created 25.06.2009
  47  * @version 1.0
  48  */
  49 public class AnnotatedLineEditor extends TextEditor implements IConversationEnabled, IPostOperationEnabled {
  50
  51     protected ConversationHolder conversation;
  52
  53     private IEntityPersistenceService persistenceService;
  54     protected ILineDisplayStrategy lineDisplayStrategy;
  55
  56
  57     /**
  58      * <p>Constructor for AnnotatedLineEditor.</p>
  59      *
  60      * @param conversation a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
  61      */
  62     public AnnotatedLineEditor(ConversationHolder conversation) {
  63         this.conversation = conversation;
  64     }
  65
  66     /* (non-Javadoc)
  67      * @see org.eclipse.ui.editors.text.TextEditor#doSetInput(org.eclipse.ui.IEditorInput)
  68      */
  69     /** {@inheritDoc} */
  70     @Override
  71     protected void doSetInput(IEditorInput input) throws CoreException {
  72
  73         AnnotatedLineDocumentProvider provider = new AnnotatedLineDocumentProvider(input);
  74
  75         provider.setLineDisplayStrategy(lineDisplayStrategy, input);
  76         setDocumentProvider(provider);
  77
  78         super.doSetInput(input);
  79     }
  80
  81     /**
  82      * <p>Setter for the field <code>persistenceService</code>.</p>
  83      *
  84      * @param persistenceService a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityPersistenceService} object.
  85      */
  86     protected void setPersistenceService(
  87             IEntityPersistenceService persistenceService) {
  88         this.persistenceService = persistenceService;
  89     }
  90
  91     /**
  92      * <p>Getter for the field <code>persistenceService</code>.</p>
  93      *
  94      * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityPersistenceService} object.
  95      */
  96     protected IEntityPersistenceService getPersistenceService() {
  97         return persistenceService;
  98     }
  99
 100     /**
 101      * <p>Setter for the field <code>lineDisplayStrategy</code>.</p>
 102      *
 103      * @param lineDisplayStrategy a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.ILineDisplayStrategy} object.
 104      */
 105     protected void setLineDisplayStrategy(
 106             ILineDisplayStrategy lineDisplayStrategy) {
 107         this.lineDisplayStrategy = lineDisplayStrategy;
 108     }
 109
 110     /** {@inheritDoc} */
 111     @Override
 112     protected ISourceViewer createSourceViewer(Composite parent,
 113             IVerticalRuler ruler, int styles) {
 114
 115         fAnnotationAccess= getAnnotationAccess();
 116         fOverviewRuler= createOverviewRuler(getSharedColors());
 117         LineSelectionViewer viewer = new LineSelectionViewer(parent, ruler, getOverviewRuler(),
 118                 isOverviewRulerVisible(), styles);
 119         //                                              isOverviewRulerVisible(), styles | SWT.WRAP);
 120         getSourceViewerDecorationSupport(viewer);
 121
 122         return viewer;
 123     }
 124
 125     /**
 126      * Create an annotated line with an "empty" entity, i.e. using the editor
 127      * input's default entity type and a zero-length title cache.
 128      *
 129      * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 130      */
 131     public LineAnnotation createAnnotatedLineNewObject() {
 132
 133         // Create new object
 134
 135         AnnotatedLineDocumentProvider documentProvider = (AnnotatedLineDocumentProvider) getDocumentProvider();
 136         IEntityCreator entityCreator = documentProvider.getEntityCreator(getEditorInput());
 137         Object entity = entityCreator.createEntity(null);
 138
 139         LineAnnotation annotation = createAnnotatedLine(entity);
 140         if (annotation != null) {
 141             annotation.markAsNew(true);
 142         }
 143         return annotation;
 144     }
 145
 146     /**
 147      * Create an annotated line, first creating an entity of type "key" - this key
 148      * must be recognized by the editor's entity creator.
 149      *
 150      * @param key a {@link java.lang.Object} object.
 151      * @param titleCache a {@link java.lang.String} object.
 152      * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 153      */
 154     public LineAnnotation createAnnotatedLineNewObject(Object key, String titleCache) {
 155
 156
 157
 158         // Create new object
 159         Object entity = ((AnnotatedLineDocumentProvider) getDocumentProvider()).
 160                 getEntityCreator(getEditorInput()).createEntity(key, titleCache);
 161         // checks if the creator also saves the entity (in a different conversation), in which case
 162         // we need to bind back this editors conversation
 163         // we also need to reload the entity because the conversation used to
 164         // to create / save the entity may have been closed
 165         if(entity != null && ((AnnotatedLineDocumentProvider) getDocumentProvider()).getEntityCreator(getEditorInput()).savesEntity()) {
 166             getConversationHolder().bind();
 167             Object object = CdmStore.getService(IOccurrenceService.class).load(((CdmBase)entity).getUuid());
 168             entity = HibernateProxyHelper.deproxy(object);
 169         }
 170
 171         if(entity == null) {
 172             return null;
 173         }
 174         LineAnnotation annotation = createAnnotatedLine(entity);
 175         if (annotation != null) {
 176             annotation.markAsNew(true);
 177         }
 178
 179         return annotation;
 180
 181     }
 182
 183     @Override
 184     public boolean isDirty() {
 185         return super.isDirty();
 186     }
 187
 188     /**
 189      * Creates an annotated line at the end of the document. The annotation contains the entity.
 190      *
 191      * @param entity a {@link java.lang.Object} object.
 192      * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 193      */
 194     public LineAnnotation createAnnotatedLine(Object entity) {
 195
 196         IEditorInput input = getEditorInput();
 197         AnnotatedLineDocumentProvider provider = (AnnotatedLineDocumentProvider) getDocumentProvider();
 198
 199         LineAnnotation annotation = null;
 200         try {
 201             annotation = provider.createAnnotatedLine(input, entity);
 202
 203             // Jump to new line
 204             IAnnotationModel model = provider.getAnnotationModel(input);
 205             if(model != null){
 206                 int start= model.getPosition(annotation).getOffset();
 207                 selectAndReveal(start, 0);
 208             }
 209
 210         } catch (BadLocationException e) {
 211             // TODO Auto-generated catch block
 212             e.printStackTrace();
 213         }
 214         return annotation;
 215     }
 216
 217     /**
 218      * <p>removeAnnotatedLine</p>
 219      *
 220      * @param lineno a int.
 221      */
 222     public void removeAnnotatedLine(int lineno) {
 223         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(lineno);
 224     }
 225
 226     /**
 227      * <p>removeAnnotatedLine</p>
 228      *
 229      * @param annotation a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 230      */
 231     public void removeAnnotatedLine(LineAnnotation annotation) {
 232         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(annotation);
 233     }
 234
 235     /* (non-Javadoc)
 236      * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSave(org.eclipse.core.runtime.IProgressMonitor)
 237      */
 238     /** {@inheritDoc} */
 239     @Override
 240     public void doSave(IProgressMonitor progressMonitor) {
 241         if (getConversationHolder() != null) {
 242             if( ! getConversationHolder().isBound()){
 243                 getConversationHolder().bind();
 244             }
 245             super.doSave(progressMonitor);
 246             getConversationHolder().commit(true);
 247         } else {
 248             super.doSave(progressMonitor);
 249         }
 250         firePropertyChange(PROP_DIRTY);
 251     }
 252
 253     /* (non-Javadoc)
 254      * @see org.eclipse.ui.texteditor.AbstractTextEditor#setFocus()
 255      */
 256     /** {@inheritDoc} */
 257     @Override
 258     public void setFocus() {
 259         super.setFocus();
 260         if (getConversationHolder() != null) {
 261             getConversationHolder().bind();
 262         }
 263         ((AbstractBulkEditorInput)getEditorInput()).bind();
 264         PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().setFocus();
 265         // TODO pass focus to underlying widgets
 266     }
 267
 268     /* (non-Javadoc)
 269      * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()
 270      */
 271     /**
 272      * <p>getConversationHolder</p>
 273      *
 274      * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
 275      */
 276     @Override
 277     public ConversationHolder getConversationHolder() {
 278         return conversation;
 279     }
 280
 281     /* (non-Javadoc)
 282      * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)
 283      */
 284     /** {@inheritDoc} */
 285     @Override
 286     public void update(CdmDataChangeMap changeEvents) {}
 287
 288     /**
 289      * Refreshes text in all lines.
 290      */
 291     protected void refreshLineDisplay() {
 292         IDocumentProvider provider = getDocumentProvider();
 293         IEditorInput input = getEditorInput();
 294         IAnnotationModel model = provider.getAnnotationModel(input);
 295         Iterator iter = getDocumentProvider().getAnnotationModel(getEditorInput()).getAnnotationIterator();
 296         while (iter.hasNext()) {
 297             Object next = iter.next();
 298             if (next instanceof LineAnnotation) {
 299                 LineAnnotation annotation = (LineAnnotation) next;
 300                 ((AnnotatedLineDocumentProvider) getDocumentProvider()).
 301                 updateLineFromAnnotation(annotation);
 302             }
 303         }
 304     }
 305
 306     /* (non-Javadoc)
 307      * @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
 308      */
 309     /** {@inheritDoc} */
 310     @Override
 311     public boolean postOperation(CdmBase objectAffectedByOperation) {
 312         refreshLineDisplay();
 313
 314         return true;
 315     }
 316
 317     /* (non-Javadoc)
 318      * @see org.eclipse.ui.editors.text.TextEditor#dispose()
 319      */
 320     /** {@inheritDoc} */
 321     @Override
 322     public void dispose() {
 323         super.dispose();
 324         conversation.close();
 325         ((AbstractBulkEditorInput)getEditorInput()).dispose();
 326     }
 327
 328     /**
 329      * <p>onComplete</p>
 330      *
 331      * @return a boolean.
 332      */
 333     @Override
 334     public boolean onComplete() {
 335         // TODO Auto-generated method stub
 336         return false;
 337     }
 338
 339
 340 }