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         AnnotatedLineDocumentProvider provider = (AnnotatedLineDocumentProvider) getDocumentProvider();
 201
 202         LineAnnotation annotation = null;
 203         try {
 204             annotation = provider.createAnnotatedLine(input, entity);
 205
 206             // Jump to new line
 207             IAnnotationModel model = provider.getAnnotationModel(input);
 208             if(model != null){
 209                 int start= model.getPosition(annotation).getOffset();
 210                 selectAndReveal(start, 0);
 211             }
 212
 213         } catch (BadLocationException e) {
 214             // TODO Auto-generated catch block
 215             e.printStackTrace();
 216         }
 217         return annotation;
 218     }
 219
 220     /**
 221      * <p>removeAnnotatedLine</p>
 222      *
 223      * @param lineno a int.
 224      */
 225     public void removeAnnotatedLine(int lineno) {
 226         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(lineno);
 227     }
 228
 229     /**
 230      * <p>removeAnnotatedLine</p>
 231      *
 232      * @param annotation a {@link eu.etaxonomy.taxeditor.annotatedlineeditor.LineAnnotation} object.
 233      */
 234     public void removeAnnotatedLine(LineAnnotation annotation) {
 235         ((AnnotatedLineDocumentProvider) getDocumentProvider()).removeAnnotatedLine(annotation);
 236     }
 237
 238     /* (non-Javadoc)
 239      * @see org.eclipse.ui.texteditor.AbstractTextEditor#doSave(org.eclipse.core.runtime.IProgressMonitor)
 240      */
 241     /** {@inheritDoc} */
 242     @Override
 243     public void doSave(IProgressMonitor progressMonitor) {
 244         if (getConversationHolder() != null) {
 245             if( ! getConversationHolder().isBound()){
 246                 getConversationHolder().bind();
 247             }
 248             super.doSave(progressMonitor);
 249             getConversationHolder().commit(true);
 250         } else {
 251             super.doSave(progressMonitor);
 252         }
 253         firePropertyChange(PROP_DIRTY);
 254     }
 255
 256     /* (non-Javadoc)
 257      * @see org.eclipse.ui.texteditor.AbstractTextEditor#setFocus()
 258      */
 259     /** {@inheritDoc} */
 260     @Override
 261     public void setFocus() {
 262         super.setFocus();
 263         if (getConversationHolder() != null) {
 264             getConversationHolder().bind();
 265         }
 266         ((AbstractBulkEditorInput)getEditorInput()).bind();
 267         PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().setFocus();
 268         // TODO pass focus to underlying widgets
 269     }
 270
 271     /* (non-Javadoc)
 272      * @see eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder()
 273      */
 274     /**
 275      * <p>getConversationHolder</p>
 276      *
 277      * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder} object.
 278      */
 279     @Override
 280     public ConversationHolder getConversationHolder() {
 281         return conversation;
 282     }
 283
 284     /* (non-Javadoc)
 285      * @see eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update(eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)
 286      */
 287     /** {@inheritDoc} */
 288     @Override
 289     public void update(CdmDataChangeMap changeEvents) {}
 290
 291     /**
 292      * Refreshes text in all lines.
 293      */
 294     protected void refreshLineDisplay() {
 295         IDocumentProvider provider = getDocumentProvider();
 296         IEditorInput input = getEditorInput();
 297         IAnnotationModel model = provider.getAnnotationModel(input);
 298         Iterator iter = getDocumentProvider().getAnnotationModel(getEditorInput()).getAnnotationIterator();
 299         while (iter.hasNext()) {
 300             Object next = iter.next();
 301             if (next instanceof LineAnnotation) {
 302                 LineAnnotation annotation = (LineAnnotation) next;
 303                 ((AnnotatedLineDocumentProvider) getDocumentProvider()).
 304                 updateLineFromAnnotation(annotation);
 305             }
 306         }
 307     }
 308
 309     /* (non-Javadoc)
 310      * @see eu.etaxonomy.taxeditor.operations.IPostOperationEnabled#postOperation(eu.etaxonomy.cdm.model.common.CdmBase)
 311      */
 312     /** {@inheritDoc} */
 313     @Override
 314     public boolean postOperation(CdmBase objectAffectedByOperation) {
 315         refreshLineDisplay();
 316
 317         return true;
 318     }
 319
 320     /* (non-Javadoc)
 321      * @see org.eclipse.ui.editors.text.TextEditor#dispose()
 322      */
 323     /** {@inheritDoc} */
 324     @Override
 325     public void dispose() {
 326         super.dispose();
 327         conversation.close();
 328         ((AbstractBulkEditorInput)getEditorInput()).dispose();
 329     }
 330
 331     /**
 332      * <p>onComplete</p>
 333      *
 334      * @return a boolean.
 335      */
 336     @Override
 337     public boolean onComplete() {
 338         // TODO Auto-generated method stub
 339         return false;
 340     }
 341
 342
 343 }