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