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         List<Integer> bounds = new ArrayList<Integer>();
 332         if (PreferencesUtil.isShowRankInChecklistEditor()){
 333             Collections.addAll(titles, "Taxon",  "Rank");
 334             Collections.addAll(bounds, 300, 200);
 335         } else{
 336             Collections.addAll(titles, "Taxon");
 337             Collections.addAll(bounds, 300);
 338         }
 339
 340
 341         Map<Integer, Boolean> restoreValuesForColumnWidth = restoreValuesForColumnWidth(titles, bounds);
 342         createInitalDistributionColumns(table, titles, bounds, restoreValuesForColumnWidth);
 343         table.setSortDirection(SWT.DOWN);
 344         table.setHeaderVisible(true);
 345         table.setLinesVisible(true);
 346         }
 347     /**
 348      * This method creates initially the distribution columns for a table. It should only be called for creation.<br>
 349      *<p>
 350      *
 351      *<b>Notice:</b> If you want to add additional columns later please use <b>addTableViewerColumn()</b>
 352      *
 353      * @param table
 354      * @param titles
 355      * @param bounds
 356      * @param restoreValuesForColumnWidth
 357      */
 358         private void createInitalDistributionColumns(Table table,
 359                         List<String> titles, List<Integer> bounds, Map<Integer, Boolean> restoreValuesForColumnWidth) {
 360                 for (int columnIndex = 0; columnIndex < titles.size(); columnIndex++) {
 361             TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 362             column.getColumn().setText(titles.get(columnIndex));
 363             column.getColumn().setWidth(bounds.get(columnIndex));
 364             column.getColumn().setResizable(true);
 365             column.getColumn().setMoveable(true);
 366             column.getColumn().addSelectionListener(getSelectionAdapter(column.getColumn(), columnIndex));
 367             if (columnIndex == 0) {
 368                 table.setSortColumn(column.getColumn());
 369             }
 370             if (columnIndex == 1 && PreferencesUtil.isShowRankInChecklistEditor()) {
 371                 /** uncommented it for now because no rank editing is wanted **/
 372 //                column.setEditingSupport(new RankEditingSupport(viewer, this));
 373             }
 374             if ((columnIndex == 1 && !PreferencesUtil.isShowRankInChecklistEditor()) || columnIndex >= 2 ) {
 375                 //read PrefrenceStore to setWidth according to last saved state
 376                 if(restoreValuesForColumnWidth.get(columnIndex)){
 377                     column.getColumn().setWidth(50);
 378                 }else{
 379                     column.getColumn().setWidth(50);
 380                 }
 381                 column.setEditingSupport(new DistributionEditingSupport(viewer, this, columnIndex));
 382             }
 383         }
 384         }
 385
 386     /**
 387      * This methods loads the last opened distribution columns for the table viewer from the prefrence store.<br>
 388      *<p>
 389      * <b>Notice:</b> It adds also the TitleCache to the titles list for the header of each column.<p>
 390      *
 391      * @param titles
 392      * @param bounds
 393      * @return Map<Integer, Boolean>
 394      */
 395         private Map<Integer, Boolean> restoreValuesForColumnWidth(List<String> titles,
 396                         List<Integer> bounds) {
 397                 Map<Integer, Boolean> restoreColumnWidth = new HashMap<Integer, Boolean>();
 398                 if (terms != null) {
 399                     int columnIndex;
 400                     if (PreferencesUtil.isShowRankInChecklistEditor()){
 401                         columnIndex = 2;
 402                     } else{
 403                         columnIndex = 1;
 404                     }
 405             for (DefinedTermBase<DefinedTermBase> term : terms) {
 406                 if(term != null){
 407                     restoreColumnWidth.put(columnIndex, PreferencesUtil.getPreferenceStore().getBoolean(term.getUuid().toString()));
 408                     if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
 409                         if (term.getIdInVocabulary() != null){
 410                             titles.add(term.getIdInVocabulary());
 411                         } else{
 412                             titles.add(term.getTitleCache());
 413                         }
 414                     }else{
 415                         titles.add(term.getTitleCache());
 416                     }
 417                     bounds.add(200);
 418                     columnIndex++;
 419                 }
 420             }
 421         }
 422                 return restoreColumnWidth;
 423         }
 424
 425     /**
 426      * This method adds new DistributionColumns to an existing table.
 427      *
 428      * @param title
 429      * @param bound
 430      * @param colNumber
 431      * @return
 432      */
 433     private TableViewerColumn addTableViewerColumn(String title, int bound, final int colNumber) {
 434         final TableViewerColumn viewerColumn = new TableViewerColumn(viewer, SWT.NONE);
 435         final TableColumn column = viewerColumn.getColumn();
 436         column.setText(title);
 437         column.setWidth(200);
 438         viewerColumn.setEditingSupport(new DistributionEditingSupport(viewer, this, colNumber));
 439         column.setResizable(true);
 440         column.setMoveable(true);
 441         return viewerColumn;
 442       }
 443
 444
 445
 446     /**
 447      *
 448      * pull data from database and set input for view
 449      *
 450      */
 451     private void loadDataInput() {
 452         Classification classification = checklistEditorInput.getClassification();
 453         TaxonNode taxonNode = checklistEditorInput.getTaxonNode();
 454         if (classification != null && taxonNode == null) {
 455             countNodes = taxonNodeService.countAllNodesForClassification(classification);
 456             statusLabel.setText("Anzahl der Elemente: " + (countNodes != null ? countNodes : "unknown"));
 457             // This should not kill the view nor the editor if something goes
 458             // wrong
 459             // TODO: don't load the whole taxonNode Object but rather a small
 460             // and simple Solution
 461             // FIXME: May be don't open classification which are greater than
 462             // 3000 Taxa
 463             selectedTaxonNodes = taxonNodeService.listAllNodesForClassification(classification, 0, countNodes);
 464             getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 465         }
 466         if (taxonNode != null) {
 467             selectedTaxonNodes = taxonNodeService.loadChildNodesOfTaxonNode(taxonNode, NODE_INIT_STRATEGY, true, null);
 468             getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 469         }
 470     }
 471
 472     /** {@inheritDoc} */
 473     @Override
 474     public void dispose() {
 475         cdmEntitySession.dispose();
 476         super.dispose();
 477     }
 478
 479     /** {@inheritDoc} */
 480     @Override
 481     public void setFocus() {
 482         cdmEntitySession.bind();
 483         viewer.getControl().setFocus();
 484     }
 485
 486     /*
 487      * (non-Javadoc)
 488      *
 489      * @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)
 490      */
 491     /** {@inheritDoc} */
 492     @Override
 493     public void showBusy(boolean busy) {
 494         super.showBusy(busy);
 495         // viewer.getTable().setEnabled(!busy);
 496         if (busy) {
 497             partNameCache = getPartName();
 498             setPartName("Loading " + countNodes + " Taxa...");
 499         } else {
 500             if (partNameCache != null) {
 501                 setPartName(partNameCache);
 502             }
 503         }
 504     }
 505
 506     /**
 507      * <p>
 508      * Getter for the field <code>viewer</code>.
 509      * </p>
 510      *
 511      * @return a {@link org.eclipse.jface.viewers.StructuredViewer} object.
 512      */
 513     public StructuredViewer getViewer() {
 514         return viewer;
 515     }
 516
 517     public void refresh() {
 518         viewer.refresh();
 519     }
 520
 521     /**
 522      * This method should only be called for adding new Distribution columns and reloading the table.<br>
 523      * It will hide the old distribution column and load the newly added columns.<br>
 524      * <p>
 525      * <b>Notice:</b> for data update please use <b>refresh()</b>
 526      *
 527      */
 528     @SuppressWarnings({ "unchecked", "rawtypes" })
 529         public void reload(){
 530         //create new Items for Dropdown menue
 531         Table table = viewer.getTable();
 532         table.setRedraw(false);
 533         SortedSet<DefinedTermBase> oldTerms = terms;
 534
 535 //      if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){
 536 //
 537 //      } else{
 538 //          terms = (SortedSet<DefinedTermBase>) labelProvider.getTermsOrderedByLabels(labelProvider.getNamedAreas(), CdmStore.getDefaultLanguage());
 539 //      }
 540         SortedSet<DefinedTermBase> newTerms = labelProvider.getNamedAreas();
 541         toolItem.removeSelectionListener(dropListener);
 542         hideDistributionColumns(oldTerms);
 543         createToolbarItems();
 544         toolItem.addSelectionListener(dropListener);
 545         for(DefinedTermBase term:newTerms){
 546                 int count = viewer.getTable().getColumnCount();
 547                 addTableViewerColumn(term.getTitleCache(), 200, count);
 548                 acitivateNewColumnInDropDownMenu(term);
 549         }
 550         viewer.setLabelProvider(labelProvider);
 551         getService().schedule(new ChecklistJob("loading Taxa", selectedTaxonNodes), Job.LONG);
 552         table.setRedraw(true);
 553         viewer.refresh();
 554     }
 555
 556         private void acitivateNewColumnInDropDownMenu(DefinedTermBase term) {
 557                 Menu menu = dropListener.getMenu();
 558                 MenuItem[] items = menu.getItems();
 559                 for(MenuItem item: items){
 560                         if(item.getText().equalsIgnoreCase(term.getTitleCache())){
 561                                 item.setSelection(true);
 562                                 PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), true);
 563                         }
 564                 }
 565         }
 566
 567         private void hideDistributionColumns(SortedSet<DefinedTermBase> oldTerms) {
 568                 TableColumn[] columns = viewer.getTable().getColumns();
 569         for(int i=4; i<columns.length; i++){
 570                 //remove all columns
 571                 columns[i].dispose();
 572                 Menu menu = dropListener.getMenu();
 573                 int itemCount = menu.getItemCount();
 574                 MenuItem item = menu.getItem(i-3);
 575                 item.setSelection(false);
 576         }
 577         if(oldTerms != null){
 578                 for(DefinedTermBase term : oldTerms){
 579                         PreferencesUtil.getPreferenceStore().setValue(term.getUuid().toString(), false);
 580                 }
 581         }
 582         }
 583
 584     /**
 585      * <p>
 586      * Getter for the field <code>service</code>.
 587      * </p>
 588      *
 589      * @return the service
 590      */
 591     public IWorkbenchSiteProgressService getService() {
 592         return service;
 593     }
 594
 595     private SelectionAdapter getSelectionAdapter(final TableColumn column, final int index) {
 596         SelectionAdapter selectionAdapter = new SelectionAdapter() {
 597             @Override
 598             public void widgetSelected(SelectionEvent e) {
 599                 comparator.setColumn(index);
 600                 int dir = viewer.getTable().getSortDirection();
 601                 if (viewer.getTable().getSortColumn() == column) {
 602                     dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
 603                 } else {
 604                     dir = SWT.DOWN;
 605                 }
 606                 viewer.getTable().setSortDirection(dir);
 607                 viewer.getTable().setSortColumn(column);
 608                 viewer.refresh();
 609             }
 610         };
 611         return selectionAdapter;
 612     }
 613
 614     @Override
 615     public void doSave(IProgressMonitor monitor) {
 616         try {
 617             monitor.beginTask("Saving Editor", 1);
 618             getConversationHolder().bind();
 619             getConversationHolder().commit(true);
 620             setDirty(false);
 621             monitor.worked(1);
 622         } finally {
 623             monitor.done();
 624         }
 625
 626     }
 627
 628     @Override
 629     public void doSaveAs() {
 630     }
 631
 632     @Override
 633     public void init(IEditorSite site, IEditorInput input) throws PartInitException {
 634         setSite(site);
 635         setInput(input);
 636         if (input instanceof ChecklistEditorInput) {
 637             checklistEditorInput = (ChecklistEditorInput) input;
 638             setPartName(getPartName() + ": " + checklistEditorInput.getName());
 639             conversation = ((ChecklistEditorInput) input).getConversationHolder();
 640         }
 641         simpleSelectionProvider = new SimpleSelectionProvider();
 642         getSite().setSelectionProvider(simpleSelectionProvider);
 643     }
 644
 645     @Override
 646     public boolean isSaveAsAllowed() {
 647         return false;
 648     }
 649
 650     /*
 651      * (non-Javadoc)
 652      *
 653      * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.
 654      * IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
 655      */
 656     @Override
 657     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 658     }
 659
 660     /*
 661      * (non-Javadoc)
 662      *
 663      * @see
 664      * eu.etaxonomy.cdm.persistence.hibernate.ICdmPostDataChangeObserver#update
 665      * (eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap)
 666      */
 667     @Override
 668     public void update(CdmDataChangeMap changeEvents) {
 669
 670     }
 671
 672     /*
 673      * (non-Javadoc)
 674      *
 675      * @see
 676      * eu.etaxonomy.cdm.api.conversation.IConversationEnabled#getConversationHolder
 677      * ()
 678      */
 679     @Override
 680     public ConversationHolder getConversationHolder() {
 681         return conversation;
 682     }
 683
 684     /*
 685      * (non-Javadoc)
 686      *
 687      * @see
 688      * eu.etaxonomy.taxeditor.model.IContextListener#contextAboutToStop(org.
 689      * eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 690      */
 691
 692     @Override
 693     public void contextAboutToStop(IMemento memento, IProgressMonitor monitor) {
 694
 695     }
 696
 697     /*
 698      * (non-Javadoc)
 699      *
 700      * @see
 701      * eu.etaxonomy.taxeditor.model.IContextListener#contextStop(org.eclipse
 702      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 703      */
 704     @Override
 705     public void contextStop(IMemento memento, IProgressMonitor monitor) {
 706 //        IStructuredSelection sel = (IStructuredSelection) this.viewer.getSelection();
 707 //        if (sel.isEmpty()) {
 708 //            return;
 709 //        }
 710 //        memento = memento.createChild("tree-selections");
 711 //        Iterator iter = sel.iterator();
 712 //        while (iter.hasNext()) {
 713 //            String nodeName = (String) iter.next();
 714 //            memento.createChild("selected-nodes", nodeName);
 715 //        }
 716     }
 717
 718     /*
 719      * (non-Javadoc)
 720      *
 721      * @see
 722      * eu.etaxonomy.taxeditor.model.IContextListener#contextStart(org.eclipse
 723      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 724      */
 725     @Override
 726     public void contextStart(IMemento memento, IProgressMonitor monitor) {
 727
 728     }
 729
 730     /*
 731      * (non-Javadoc)
 732      *
 733      * @see
 734      * eu.etaxonomy.taxeditor.model.IContextListener#contextRefresh(org.eclipse
 735      * .core.runtime.IProgressMonitor)
 736      */
 737     @Override
 738     public void contextRefresh(IProgressMonitor monitor) {
 739     }
 740
 741     /*
 742      * (non-Javadoc)
 743      *
 744      * @see
 745      * eu.etaxonomy.taxeditor.model.IContextListener#workbenchShutdown(org.eclipse
 746      * .ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 747      */
 748     @Override
 749     public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 750         conversation.clear();
 751         conversation.close();
 752         conversation = null;
 753     }
 754
 755     private static final List<String> NODE_INIT_STRATEGY = Arrays.asList(new String[] { "descriptions",
 756             "descriptions.*", "description.state", "feature", "feature.*", "childNodes", "childNodes.taxon",
 757             "childNodes.taxon.name", "taxonNodes", "taxonNodes.*", "taxonNodes.taxon.*", "taxon.*",
 758             "taxon.descriptions", "taxon.sec", "taxon.name.*", "taxon.synonymRelations", "terms", "name.*",
 759             "name.rank.representations", "name.status.type.representations", "sources.$", "stateData.$" });
 760
 761     /*
 762      * (non-Javadoc)
 763      *
 764      * @see
 765      * eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#changed(
 766      * java.lang.Object)
 767      */
 768     @Override
 769     public void changed(Object element) {
 770         if (element != null) {
 771             viewer.update(element, null);
 772             setDirty(true);
 773             firePropertyChange(PROP_DIRTY);
 774         }
 775     }
 776
 777     /* (non-Javadoc)
 778      * @see eu.etaxonomy.taxeditor.model.IDirtyMarkableSelectionProvider#forceDirty()
 779      */
 780     @Override
 781     public void forceDirty() {
 782         changed(null);
 783     }
 784
 785     public void setDirty(boolean dirty) {
 786         this.dirty = dirty;
 787         firePropertyChange(PROP_DIRTY);
 788     }
 789
 790     /*
 791      * (non-Javadoc)
 792      *
 793      * @see org.eclipse.ui.forms.editor.FormEditor#isDirty()
 794      */
 795     @Override
 796     public boolean isDirty() {
 797         return dirty;
 798     }
 799
 800     /* (non-Javadoc)
 801      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getCdmEntitySession()
 802      */
 803     @Override
 804     public ICdmEntitySession getCdmEntitySession() {
 805         // TODO Auto-generated method stub
 806         return null;
 807     }
 808
 809     /* (non-Javadoc)
 810      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getRootEntities()
 811      */
 812     @Override
 813     public <T extends CdmBase> Collection<T> getRootEntities() {
 814         // TODO Auto-generated method stub
 815         return null;
 816     }
 817
 818     /* (non-Javadoc)
 819      * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled#getPropertyPathsMap()
 820      */
 821     @Override
 822     public Map<Object, List<String>> getPropertyPathsMap() {
 823         // TODO Auto-generated method stub
 824         return null;
 825     }
 826
 827     /**
 828      * @return the labelProvider
 829      */
 830     public ChecklistLabelProvider getLabelProvider() {
 831         return labelProvider;
 832     }
 833 }