eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/checklist/ChecklistEditor.java

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