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