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             //FIXME: why do we use IOccurrenceService here? is this generic?
 168             //because this method is only invoked by the handler which is used in the
 169             //specimen bulk editor. This is unsafe and should be refactored!
 170             Object object = CdmStore.getService(IOccurrenceService.class).load(((CdmBase)entity).getUuid());
 171             entity = HibernateProxyHelper.deproxy(object);
 172         }
 173
 174         if(entity == null) {
 175             return null;
 176         }
 177         LineAnnotation annotation = createAnnotatedLine(entity);
 178         if (annotation != null) {
 179             annotation.markAsNew(true);
 180         }
 181
 182         return annotation;
 183
 184     }
 185
 186     @Override
 187     public boolean isDirty() {
 188         return super.isDirty();
 189     }
 190
 191     /**
 192      * Creates an annotated line at the end of the document. The annotation contains the entity.
 193      *
 194      * @param entity a {@link java.lang.Object} object.
 195      * @return a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 196      */
 197     public LineAnnotation createAnnotatedLine(Object entity) {
 198
 199         IEditorInput input = getEditorInput();
 200         this.conversation.close();
 201         this.conversation = ((AbstractBulkEditorInput)input).getConversation();
 202         AnnotatedLineDocumentProvider provider = (AnnotatedLineDocumentProvider) getDocumentProvider();
 203
 204         LineAnnotation annotation = null;
 205         try {
 206             annotation = provider.createAnnotatedLine(input, entity);
 207
 208             // Jump to new line
 209             IAnnotationModel model = provider.getAnnotationModel(input);
 210             if(model != null){
 211                 int start= model.getPosition(annotation).getOffset();
 212                 selectAndReveal(start, 0);
 213             }
 214
 215         } catch (BadLocationException e) {
 216             // TODO Auto-generated catch block
 217             e.printStackTrace();
 218         }
 219         return annotation;
 220     }
 221
 222     /**
 223      * <p>removeAnnotatedLine</p>
 224      *
 225      * @param lineno a int.
 226      */
 227     public void removeAnnotatedLine(int lineno) {
 228         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(lineno);
 229     }
 230
 231     /**
 232      * <p>removeAnnotatedLine</p>
 233      *
 234      * @param annotation a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 235      */
 236     public void removeAnnotatedLine(LineAnnotation annotation) {
 237         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(annotation);
 238     }
 239
 240     /* (non-Javadoc)
 241      * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSave(org.eclipse.core.runtime.IProgressMonitor)
 242      */
 243     /** {@inheritDoc} */
 244     @Override
 245     public void doSave(IProgressMonitor progressMonitor) {
 246         if (getConversationHolder() != null) {
 247             if( ! getConversationHolder().isBound()){
 248                 getConversationHolder().bind();
 249             }
 250             super.doSave(progressMonitor);
 251             getConversationHolder().commit(true);
 252         } else {
 253             super.doSave(progressMonitor);
 254         }
 255         firePropertyChange(PROP_DIRTY);
 256     }
 257
 258     /* (non-Javadoc)
 259      * @see org.eclipse.ui.texteditor.AbstractTextEditor#setFocus()
 260      */
 261     /** {@inheritDoc} */
 262     @Override
 263     public void setFocus() {
 264         super.setFocus();
 265         if (getConversationHolder() != null) {
 266             getConversationHolder().bind();
 267         }
 268         ((AbstractBulkEditorInput)getEditorInput()).bind();
 269         PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().setFocus();
 270         // TODO pass focus to underlying widgets
 271     }
 272
 273     /* (non-Javadoc)
 274      * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()
 275      */
 276     /**
 277      * <p>getConversationHolder</p>
 278      *
 279      * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
 280      */
 281     @Override
 282     public ConversationHolder getConversationHolder() {
 283         return conversation;
 284     }
 285
 286     /* (non-Javadoc)
 287      * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)
 288      */
 289     /** {@inheritDoc} */
 290     @Override
 291     public void update(CdmDataChangeMap changeEvents) {}
 292
 293     /**
 294      * Refreshes text in all lines.
 295      */
 296     protected void refreshLineDisplay() {
 297         IDocumentProvider provider = getDocumentProvider();
 298         IEditorInput input = getEditorInput();
 299         IAnnotationModel model = provider.getAnnotationModel(input);
 300         Iterator iter = getDocumentProvider().getAnnotationModel(getEditorInput()).getAnnotationIterator();
 301         while (iter.hasNext()) {
 302             Object next = iter.next();
 303             if (next instanceof LineAnnotation) {
 304                 LineAnnotation annotation = (LineAnnotation) next;
 305                 ((AnnotatedLineDocumentProvider) getDocumentProvider()).
 306                 updateLineFromAnnotation(annotation);
 307             }
 308         }
 309     }
 310
 311     /* (non-Javadoc)
 312      * @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
 313      */
 314     /** {@inheritDoc} */
 315     @Override
 316     public boolean postOperation(CdmBase objectAffectedByOperation) {
 317         refreshLineDisplay();
 318
 319         return true;
 320     }
 321
 322     /* (non-Javadoc)
 323      * @see org.eclipse.ui.editors.text.TextEditor#dispose()
 324      */
 325     /** {@inheritDoc} */
 326     @Override
 327     public void dispose() {
 328         super.dispose();
 329         conversation.close();
 330         ((AbstractBulkEditorInput)getEditorInput()).dispose();
 331     }
 332
 333     /**
 334      * <p>onComplete</p>
 335      *
 336      * @return a boolean.
 337      */
 338     @Override
 339     public boolean onComplete() {
 340         // TODO Auto-generated method stub
 341         return false;
 342     }
 343
 344
 345 }