eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/checklist/ChecklistEditor.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
  11 package eu.etaxonomy.taxeditor.editor.view.checklist;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.Collections;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.SortedSet;
  20
  21 import org.apache.log4j.Logger;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.IStatus;
  24 import org.eclipse.core.runtime.Status;
  25 import org.eclipse.core.runtime.jobs.Job;
  26 import org.eclipse.jface.viewers.ISelection;
  27 import org.eclipse.jface.viewers.StructuredViewer;
  28 import org.eclipse.jface.viewers.TableViewer;
  29 import org.eclipse.jface.viewers.TableViewerColumn;
  30 import org.eclipse.swt.SWT;
  31 import org.eclipse.swt.events.ModifyListener;
  32 import org.eclipse.swt.events.SelectionAdapter;
  33 import org.eclipse.swt.events.SelectionEvent;
  34 import org.eclipse.swt.layout.GridData;
  35 import org.eclipse.swt.layout.GridLayout;
  36 import org.eclipse.swt.widgets.Composite;
  37 import org.eclipse.swt.widgets.Display;
  38 import org.eclipse.swt.widgets.Label;
  39 import org.eclipse.swt.widgets.Menu;
  40 import org.eclipse.swt.widgets.MenuItem;
  41 import org.eclipse.swt.widgets.Table;
  42 import org.eclipse.swt.widgets.TableColumn;
  43 import org.eclipse.swt.widgets.Text;
  44 import org.eclipse.swt.widgets.ToolBar;
  45 import org.eclipse.swt.widgets.ToolItem;
  46 import org.eclipse.ui.IEditorInput;
  47 import org.eclipse.ui.IEditorSite;
  48 import org.eclipse.ui.IMemento;
  49 import org.eclipse.ui.ISelectionListener;
  50 import org.eclipse.ui.ISelectionService;
  51 import org.eclipse.ui.IWorkbenchPart;
  52 import org.eclipse.ui.PartInitException;
  53 import org.eclipse.ui.part.EditorPart;
  54 import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
  55
  56 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  57 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  58 import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
  59 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  60 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  61 import eu.etaxonomy.cdm.model.taxon.Classification;
  62 import eu.etaxonomy.cdm.model.taxon.Taxon;
  63 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  64 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  65 import eu.etaxonomy.taxeditor.editor.EditorUtil;
  66 import eu.etaxonomy.taxeditor.editor.SimpleSelectionProvider;
  67 import eu.etaxonomy.taxeditor.editor.view.checklist.edit.DistributionEditingSupport;
  68 import eu.etaxonomy.taxeditor.editor.view.checklist.filter.ChecklistEditorFilter;
  69 import eu.etaxonomy.taxeditor.editor.view.checklist.listener.ChecklistDropdownSelectionListener;
  70 import eu.etaxonomy.taxeditor.editor.view.checklist.listener.ChecklistFocusListener;
  71 import eu.etaxonomy.taxeditor.editor.view.checklist.listener.ChecklistModifyListener;
  72 import eu.etaxonomy.taxeditor.model.IContextListener;
  73 import eu.etaxonomy.taxeditor.model.IDirtyMarkable;
  74 import eu.etaxonomy.taxeditor.model.IPartContentHasDetails;
  75 import eu.etaxonomy.taxeditor.model.IPartContentHasFactualData;
  76 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  77 import eu.etaxonomy.taxeditor.preference.Resources;
  78 import eu.etaxonomy.taxeditor.store.CdmStore;
  79
  80 /**
  81  * <p>
  82  * ChecklistViewPart class.
  83  * </p>
  84  *
  85  * @author a.oppermann
  86  * @created 30.04.2014
  87  * @version 1.0
  88  */
  89 public class ChecklistEditor extends EditorPart implements ISelectionListener, IPartContentHasFactualData,
  90         IConversationEnabled, IContextListener, IPartContentHasDetails, IDirtyMarkable {
  91
  92     private static final Logger logger = Logger.getLogger(ChecklistEditor.class);
  93     /**
  94      * Key used for storing Checklist Editor View
  95      */
  96     private static final String CHECKLIST_EDITOR_MEMENTO_KEY = "checklistEditor";
  97
  98     private class ChecklistJob extends Job {
  99
 100         private List<TaxonNode> taxonNodes;
 101
 102         /**
 103          * @param name
 104          */
 105         public ChecklistJob(String title, List<TaxonNode> listTaxonNodes) {
 106             super(title);
 107             this.taxonNodes = listTaxonNodes;
 108
 109         }
 110
 111         /*
 112          * (non-Javadoc)
 113          *
 114          * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.
 115          * IProgressMonitor)
 116          */
 117         @Override
 118         public IStatus run(final IProgressMonitor monitor) {
 119             try {
 120                 logger.debug("Begin of eclipse core runtime Job to Retrieve datasources");
 121                 monitor.beginTask("Retrieving TaxonNodes", taxonNodes.size() + 1);
 122
 123                 final List<Taxon> taxonList = new ArrayList<Taxon>();
 124
 125                 for (TaxonNode taxonNode : taxonNodes) {
 126                     HibernateProxyHelper hh = new HibernateProxyHelper();
 127                     Taxon taxon = hh.deproxy(taxonNode.getTaxon(), Taxon.class);
 128                     taxonList.add(taxon);
 129                 }
 130                 // set View input
 131                 Display.getDefault().asyncExec(new Runnable() {
 132
 133                     @Override
 134                     public void run() {
 135                         viewer.setInput(taxonList);
 136                     }
 137                 });
 138                 monitor.worked(1);
 139
 140             } finally {
 141                 monitor.done();
 142                 taxonNodes = null;
 143             }
 144             return Status.OK_STATUS;
 145         }
 146     }
 147
 148     /**
 149      * Constant
 150      * <code>ID="eu.etaxonomy.taxeditor.store.datasource"{trunked}</code>
 151      */
 152     public static String ID = "eu.etaxonomy.taxeditor.editor.view.checklist.ChecklistEditor";
 153
 154     private TableViewer viewer;
 155
 156     private String partNameCache;
 157
 158     private IWorkbenchSiteProgressService service;
 159
 160     private ITaxonNodeService taxonNodeService;
 161
 162     private ChecklistEditorComparator comparator;
 163
 164     private ChecklistEditorInput checklistEditorInput;
 165
 166     private SimpleSelectionProvider simpleSelectionProvider;
 167
 168     private ISelectionService selectionService;
 169
 170     private ConversationHolder conversation;
 171
 172     private Integer countNodes;
 173
 174     private List<TaxonNode> selectedTaxonNodes;
 175
 176     private boolean dirty;
 177
 178     private ChecklistEditorFilter filter;
 179
 180     private Menu headerMenu;
 181
 182     private Label statusLabel;
 183
 184     private SortedSet<DefinedTermBase> terms = null;
 185         private ToolItem toolItem;
 186         private ChecklistDropdownSelectionListener dropListener;
 187
 188     /**
 189      * @return the selectedTaxonNodes
 190      */
 191     public List<TaxonNode> getSelectedTaxonNodes() {
 192         return selectedTaxonNodes;
 193     }
 194
 195     /**
 196      * @param selectedTaxonNodes
 197      *            the selectedTaxonNodes to set
 198      */
 199     public void setSelectedTaxonNodes(List<TaxonNode> selectedTaxonNodes) {
 200         this.selectedTaxonNodes = selectedTaxonNodes;
 201     }
 202
 203     /**
 204      * <p>
 205      * Constructor for CdmDataSourceViewPart.
 206      * </p>
 207      */
 208     public ChecklistEditor() {
 209     }
 210
 211     /** {@inheritDoc} */
 212     @Override
 213     public void createPartControl(Composite parent) {
 214         service = (IWorkbenchSiteProgressService) getSite().getAdapter(IWorkbenchSiteProgressService.class);
 215         taxonNodeService = CdmStore.getService(ITaxonNodeService.class);
 216         selectionService = getSite().getWorkbenchWindow().getSelectionService();
 217         selectionService.addSelectionListener(this);
 218         filter = new ChecklistEditorFilter();
 219         ChecklistLabelProvider labelProvider = new ChecklistLabelProvider();
 220         terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(),
 221                 CdmStore.getDefaultLanguage());
 222         createTopComposite(parent);
 223         loadDataInput();
 224     }
 225
 226     /**
 227      * @param parent
 228      */
 229     private void createTopComposite(Composite parent) {
 230         GridLayout gridLayout = new GridLayout(3, false);
 231         gridLayout.marginWidth = 0;
 232         gridLayout.marginHeight = 0;
 233         parent.setLayout(gridLayout);
 234
 235         final Text searchText = createSearchBar(parent);
 236         createToolbar(parent);
 237         viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
 238         getSite().setSelectionProvider(viewer);
 239
 240         final ModifyListener modifyListener = new ChecklistModifyListener(viewer, filter, searchText);
 241
 242         searchText.addFocusListener(new ChecklistFocusListener(searchText, modifyListener));
 243         searchText.addModifyListener(modifyListener);
 244         createGridDataForViewerLayout();
 245
 246         viewer.addFilter(filter);
 247         createTable();
 248
 249         viewer.setContentProvider(new ChecklistContentProvider());
 250         viewer.setLabelProvider(new ChecklistLabelProvider(viewer));
 251         comparator = new ChecklistEditorComparator();
 252         viewer.setComparator(comparator);
 253
 254         createStatusBar(parent);
 255     }
 256
 257         private void createGridDataForViewerLayout() {
 258                 GridData gridData = new GridData();
 259                 gridData.verticalAlignment = GridData.FILL;
 260         gridData.horizontalSpan = 3;
 261         gridData.grabExcessHorizontalSpace = true;
 262         gridData.grabExcessVerticalSpace = true;
 263         gridData.horizontalAlignment = GridData.FILL;
 264         viewer.getControl().setLayoutData(gridData);
 265         }
 266
 267     /**
 268      * @param parent
 269      * @return
 270      */
 271     private Text createSearchBar(Composite parent) {
 272         Label searchLabel = new Label(parent, SWT.NONE);
 273         searchLabel.setText("Search: ");
 274         final Text searchText = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH | SWT.CANCEL);
 275         searchText.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL));
 276         searchText.setForeground(EditorUtil.getColor(Resources.SEARCH_VIEW_FOREGROUND));
 277         searchText.setText("type filter text");
 278         return searchText;
 279     }
 280
 281     /**
 282      * @param parent
 283      */
 284     private void createToolbar(Composite parent) {
 285         ToolBar toolBar = new ToolBar(parent, SWT.NONE);
 286         toolItem = new ToolItem(toolBar, SWT.DROP_DOWN | SWT.BORDER);
 287         toolItem.setText("Distribution Status");
 288         toolItem.setToolTipText("Show Distribution Status for selected Areas");
 289         createToolbarItems();
 290         toolItem.addSelectionListener(dropListener);
 291         toolBar.pack();
 292     }
 293
 294         private void createToolbarItems() {
 295                 dropListener = new ChecklistDropdownSelectionListener(toolItem, this, terms);
 296         for (DefinedTermBase<DefinedTermBase> term : terms) {
 297             if(term!=null){
 298                 dropListener.add(term);
 299             }
 300         }
 301         }
 302
 303     private void createStatusBar(Composite composite) {
 304         GridData gridData = new GridData();
 305         gridData.horizontalSpan = 3;
 306         gridData.grabExcessHorizontalSpace = true;
 307         gridData.horizontalAlignment = GridData.FILL;
 308
 309         statusLabel = new Label(composite, SWT.LEFT);
 310         statusLabel.setText("Anzahl der Elemente: " + (countNodes != null ? countNodes : "uknown"));
 311         statusLabel.setLayoutData(gridData);
 312     }
 313
 314     private void createTable() {
 315         Table table = viewer.getTable();//new Table(parent, viewer.getTable().getStyle());
 316         List<String> titles = new ArrayList<String>();
 317         Collections.addAll(titles, "Taxon", "Author", "Rank");
 318         List<Integer> bounds = new ArrayList<Integer>();
 319         Collections.addAll(bounds, 300, 200, 200);
 320         Map<Integer, Boolean> restoreValuesForColumnWidth = restoreValuesForColumnWidth(titles, bounds);
 321         createInitalDistributionColumns(table, titles, bounds, restoreValuesForColumnWidth);
 322         table.setSortDirection(SWT.DOWN);
 323         table.setHeaderVisible(true);
 324         table.setLinesVisible(true);
 325         }
 326     /**
 327      * This method creates initially the distribution columns for a table. It should only be called for creation.<br>
 328      *<p>
 329      *
 330      *<b>Notice:</b> If you want to add additional columns later please use <b>addTableViewerColumn()</b>
 331      *
 332      * @param table
 333      * @param titles
 334      * @param bounds
 335      * @param restoreValuesForColumnWidth
 336      */
 337         private void createInitalDistributionColumns(Table table,
 338                         List<String> titles, List<Integer> bounds,
 339                         Map<Integer, Boolean> restoreValuesForColumnWidth) {
 340                 for (int columnIndex = 0; columnIndex < titles.size(); columnIndex++) {
 341             TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 342             column.getColumn().setText(titles.get(columnIndex));
 343             column.getColumn().setWidth(bounds.get(columnIndex));
 344             column.getColumn().setResizable(true);
 345             column.getColumn().setMoveable(true);
 346             column.getColumn().addSelectionListener(getSelectionAdapter(column.getColumn(), columnIndex));
 347             if (columnIndex == 1) {
 348                 table.setSortColumn(column.getColumn());
 349             }
 350             if (columnIndex == 2) {
 351                 /** uncommented it for now because no rank editing is wanted **/
 352 //                column.setEditingSupport(new RankEditingSupport(viewer, this));
 353             }
 354             if (columnIndex >= 3) {
 355                 //read PrefrenceStore to setWidth according to last saved state
 356                 if(restoreValuesForColumnWidth.get(columnIndex)){
 357                     column.getColumn().setWidth(100);
 358                 }else{
 359                     column.getColumn().setWidth(0);
 360                 }
 361                 column.setEditingSupport(new DistributionEditingSupport(viewer, this, columnIndex));
 362             }
 363         }
 364         }
 365
 366     /**
 367      * This methods loads the last opened distribution columns for the table viewer from the prefrence store.<br>
 368      *<p>
 369      * <b>Notice:</b> It adds also the TitleCache to the titles list for the header of each column.<p>
 370      *
 371      * @param titles
 372      * @param bounds
 373      * @return Map<Integer, Boolean>
 374      */
 375         private Map<Integer, Boolean> restoreValuesForColumnWidth(List<String> titles,
 376                         List<Integer> bounds) {
 377                 Map<Integer, Boolean> restoreColumnWidth = new HashMap<Integer, Boolean>();
 378                 if (terms != null) {
 379             int columnIndex = 4;
 380             for (DefinedTermBase<DefinedTermBase> term : terms) {
 381                 if(term != null){
 382                     restoreColumnWidth.put(columnIndex, PreferencesUtil.getPreferenceStore().getBoolean(term.getUuid().toString()));
 383                     titles.add(term.getTitleCache());
 384                     bounds.add(200);
 385                     columnIndex++;
 386                 }
 387             }
 388         }
 389                 return restoreColumnWidth;
 390         }
 391
 392     /**
 393      * This method adds new DistributionColumns to an existing table.
 394      *
 395      * @param title
 396      * @param bound
 397      * @param colNumber
 398      * @return
 399      */
 400     private TableViewerColumn addTableViewerColumn(String title, int bound, final int colNumber) {
 401         final TableViewerColumn viewerColumn = new TableViewerColumn(viewer, SWT.NONE);
 402         final TableColumn column = viewerColumn.getColumn();
 403         column.setText(title);
 404         column.setWidth(200);
 405         viewerColumn.setEditingSupport(new DistributionEditingSupport(viewer, this, colNumber));
 406         column.setResizable(true);
 407         column.setMoveable(true);
 408         return viewerColumn;
 409       }
 410
 411
 412
 413     /**
 414      *
 415      * pull data from database and set input for view
 416      *
 417      */
 418     private void loadDataInput() {
 419         Classification classification = checklistEditorInput.getClassification();
 420         TaxonNode taxonNode = checklistEditorInput.getTaxonNode();
 421         if (classification != null && taxonNode == null) {
 422             countNodes = taxonNodeService.countAllNodesForClassification(classification);
 423             statusLabel.setText("Anzahl der Elemente: " + (countNodes != null ? countNodes : "uknown"));
 424             // This should not kill the view nor the editor if something goes
 425             // wrong
 426             // TODO: don't load the whole taxonNode Object but rather a small
 427             // and simple Solution
 428             // FIXME: May be don't open classification which are greater than
 429             // 3000 Taxa
 430             selectedTaxonNodes = taxonNodeService.listAllNodesForClassification(classification, 0, countNodes);
 431             getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 432         }
 433         if (taxonNode != null) {
 434             selectedTaxonNodes = taxonNodeService.loadChildNodesOfTaxonNode(taxonNode, NODE_INIT_STRATEGY, true, null);
 435             getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 436         }
 437     }
 438
 439     /** {@inheritDoc} */
 440     @Override
 441     public void dispose() {
 442         super.dispose();
 443     }
 444
 445     /** {@inheritDoc} */
 446     @Override
 447     public void setFocus() {
 448         viewer.getControl().setFocus();
 449     }
 450
 451     /*
 452      * (non-Javadoc)
 453      *
 454      * @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)
 455      */
 456     /** {@inheritDoc} */
 457     @Override
 458     public void showBusy(boolean busy) {
 459         super.showBusy(busy);
 460         // viewer.getTable().setEnabled(!busy);
 461         if (busy) {
 462             partNameCache = getPartName();
 463             setPartName("Loading " + countNodes + " Taxa...");
 464         } else {
 465             if (partNameCache != null) {
 466                 setPartName(partNameCache);
 467             }
 468         }
 469     }
 470
 471     /**
 472      * <p>
 473      * Getter for the field <code>viewer</code>.
 474      * </p>
 475      *
 476      * @return a {@link org.eclipse.jface.viewers.StructuredViewer} object.
 477      */
 478     public StructuredViewer getViewer() {
 479         return viewer;
 480     }
 481
 482     public void refresh() {
 483         viewer.refresh();
 484     }
 485
 486     /**
 487      * This method should only be called for adding new Distribution columns and reloading the table.<br>
 488      * It will hide the old distribution column and load the newly added columns.<br>
 489      * <p>
 490      * <b>Notice:</b> for data update please use <b>refresh()</b>
 491      *
 492      */
 493     @SuppressWarnings({ "unchecked", "rawtypes" })
 494         public void reload(){
 495         //create new Items for Dropdown menue
 496         Table table = viewer.getTable();
 497         table.setRedraw(false);
 498         SortedSet<DefinedTermBase> oldTerms = terms;
 499         ChecklistLabelProvider labelProvider = new ChecklistLabelProvider();
 500         terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(), CdmStore.getDefaultLanguage());
 501         SortedSet<DefinedTermBase> newTerms = terms;
 502         toolItem.removeSelectionListener(dropListener);
 503         hideDistributionColumns(oldTerms);
 504         createToolbarItems();
 505         toolItem.addSelectionListener(dropListener);
 506         for(DefinedTermBase term:newTerms){
 507                 int count = viewer.getTable().getColumnCount();
 508                 addTableViewerColumn(term.getTitleCache(), 200, count);
 509                 acitivateNewColumnInDropDownMenu(term);
 510         }
 511         viewer.setLabelProvider(new ChecklistLabelProvider(viewer));
 512         getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 513         table.setRedraw(true);
 514         viewer.refresh();
 515     }
 516
 517         private void acitivateNewColumnInDropDownMenu(DefinedTermBase term) {
 518                 Menu menu = dropListener.getMenu();
 519                 MenuItem[] items = menu.getItems();
 520                 for(MenuItem item: items){
 521                         if(item.getText().equalsIgnoreCase(term.getTitleCache())){
 522                                 item.setSelection(true);
 523                                 PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), true);
 524                         }
 525                 }
 526         }
 527
 528         private void hideDistributionColumns(SortedSet<DefinedTermBase> oldTerms) {
 529                 TableColumn[] columns = viewer.getTable().getColumns();
 530         for(int i=4; i<columns.length; i++){
 531                 //remove all columns
 532                 columns[i].dispose();
 533                 Menu menu = dropListener.getMenu();
 534                 int itemCount = menu.getItemCount();
 535                 MenuItem item = menu.getItem(i-3);
 536                 item.setSelection(false);
 537         }
 538         if(oldTerms != null){
 539                 for(DefinedTermBase term : oldTerms){
 540                         PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), false);
 541                 }
 542         }
 543         }
 544
 545     /**
 546      * <p>
 547      * Getter for the field <code>service</code>.
 548      * </p>
 549      *
 550      * @return the service
 551      */
 552     public IWorkbenchSiteProgressService getService() {
 553         return service;
 554     }
 555
 556     private SelectionAdapter getSelectionAdapter(final TableColumn column, final int index) {
 557         SelectionAdapter selectionAdapter = new SelectionAdapter() {
 558             @Override
 559             public void widgetSelected(SelectionEvent e) {
 560                 comparator.setColumn(index);
 561                 int dir = viewer.getTable().getSortDirection();
 562                 if (viewer.getTable().getSortColumn() == column) {
 563                     dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
 564                 } else {
 565                     dir = SWT.DOWN;
 566                 }
 567                 viewer.getTable().setSortDirection(dir);
 568                 viewer.getTable().setSortColumn(column);
 569                 viewer.refresh();
 570             }
 571         };
 572         return selectionAdapter;
 573     }
 574
 575     @Override
 576     public void doSave(IProgressMonitor monitor) {
 577         try {
 578             monitor.beginTask("Saving Editor", 1);
 579             getConversationHolder().bind();
 580             getConversationHolder().commit(true);
 581             setDirty(false);
 582             monitor.worked(1);
 583         } finally {
 584             monitor.done();
 585         }
 586
 587     }
 588
 589     @Override
 590     public void doSaveAs() {
 591     }
 592
 593     @Override
 594     public void init(IEditorSite site, IEditorInput input) throws PartInitException {
 595         setSite(site);
 596         setInput(input);
 597         if (input instanceof ChecklistEditorInput) {
 598             checklistEditorInput = (ChecklistEditorInput) input;
 599             setPartName(getPartName() + ": " + checklistEditorInput.getName());
 600             conversation = ((ChecklistEditorInput) input).getConversationHolder();
 601         }
 602         simpleSelectionProvider = new SimpleSelectionProvider();
 603         getSite().setSelectionProvider(simpleSelectionProvider);
 604     }
 605
 606     @Override
 607     public boolean isSaveAsAllowed() {
 608         return false;
 609     }
 610
 611     /*
 612      * (non-Javadoc)
 613      *
 614      * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.
 615      * IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
 616      */
 617     @Override
 618     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 619     }
 620
 621     /*
 622      * (non-Javadoc)
 623      *
 624      * @see
 625      * eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update
 626      * (eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)
 627      */
 628     @Override
 629     public void update(CdmDataChangeMap changeEvents) {
 630
 631     }
 632
 633     /*
 634      * (non-Javadoc)
 635      *
 636      * @see
 637      * eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder
 638      * ()
 639      */
 640     @Override
 641     public ConversationHolder getConversationHolder() {
 642         return conversation;
 643     }
 644
 645     /*
 646      * (non-Javadoc)
 647      *
 648      * @see
 649      * eu.etaxonomy.taxeditor.model.IContextListener#contextAboutToStop(org.
 650      * eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 651      */
 652
 653     @Override
 654     public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {
 655
 656     }
 657
 658     /*
 659      * (non-Javadoc)
 660      *
 661      * @see
 662      * eu.etaxonomy.taxeditor.model.IContextListener#contextStop(org.eclipse
 663      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 664      */
 665     @Override
 666     public void contextStop(IMemento memento, IProgressMonitor monitor) {
 667 //        IStructuredSelection sel = (IStructuredSelection) this.viewer.getSelection();
 668 //        if (sel.isEmpty()) {
 669 //            return;
 670 //        }
 671 //        memento = memento.createChild("tree-selections");
 672 //        Iterator iter = sel.iterator();
 673 //        while (iter.hasNext()) {
 674 //            String nodeName = (String) iter.next();
 675 //            memento.createChild("selected-nodes", nodeName);
 676 //        }
 677     }
 678
 679     /*
 680      * (non-Javadoc)
 681      *
 682      * @see
 683      * eu.etaxonomy.taxeditor.model.IContextListener#contextStart(org.eclipse
 684      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 685      */
 686     @Override
 687     public void contextStart(IMemento memento, IProgressMonitor monitor) {
 688
 689     }
 690
 691     /*
 692      * (non-Javadoc)
 693      *
 694      * @see
 695      * eu.etaxonomy.taxeditor.model.IContextListener#contextRefresh(org.eclipse
 696      * .core.runtime.IProgressMonitor)
 697      */
 698     @Override
 699     public void contextRefresh(IProgressMonitor monitor) {
 700     }
 701
 702     /*
 703      * (non-Javadoc)
 704      *
 705      * @see
 706      * eu.etaxonomy.taxeditor.model.IContextListener#workbenchShutdown(org.eclipse
 707      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 708      */
 709     @Override
 710     public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 711         conversation.clear();
 712         conversation.close();
 713         conversation = null;
 714     }
 715
 716     private static final List<String> NODE_INIT_STRATEGY = Arrays.asList(new String[] { "descriptions",
 717             "descriptions.*", "description.state", "feature", "feature.*", "childNodes", "childNodes.taxon",
 718             "childNodes.taxon.name", "taxonNodes", "taxonNodes.*", "taxonNodes.taxon.*", "taxon.*",
 719             "taxon.descriptions", "taxon.sec", "taxon.name.*", "taxon.synonymRelations", "terms", "name.*",
 720             "name.rank.representations", "name.status.type.representations", "sources.$", "stateData.$" });
 721
 722     /*
 723      * (non-Javadoc)
 724      *
 725      * @see
 726      * eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#changed(
 727      * java.lang.Object)
 728      */
 729     @Override
 730     public void changed(Object element) {
 731         if (element != null) {
 732             viewer.update(element, null);
 733             setDirty(true);
 734             firePropertyChange(PROP_DIRTY);
 735         }
 736     }
 737
 738     /* (non-Javadoc)
 739      * @see eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#forceDirty()
 740      */
 741     @Override
 742     public void forceDirty() {
 743         changed(null);
 744     }
 745
 746     public void setDirty(boolean dirty) {
 747         this.dirty = dirty;
 748         firePropertyChange(PROP_DIRTY);
 749     }
 750
 751     /*
 752      * (non-Javadoc)
 753      *
 754      * @see org.eclipse.ui.forms.editor.FormEditor#isDirty()
 755      */
 756     @Override
 757     public boolean isDirty() {
 758         return dirty;
 759     }
 760 }