eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/element/AbstractFormSection.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.taxeditor.ui.element;
   5
   6 import java.util.ConcurrentModificationException;
   7 import java.util.HashSet;
   8 import java.util.List;
   9 import java.util.Set;
  10
  11 import org.eclipse.core.runtime.Assert;
  12 import org.eclipse.jface.util.IPropertyChangeListener;
  13 import org.eclipse.jface.util.PropertyChangeEvent;
  14 import org.eclipse.jface.viewers.ISelectionChangedListener;
  15 import org.eclipse.jface.viewers.ISelectionProvider;
  16 import org.eclipse.jface.viewers.IStructuredSelection;
  17 import org.eclipse.jface.viewers.SelectionChangedEvent;
  18 import org.eclipse.jface.viewers.StructuredSelection;
  19 import org.eclipse.swt.SWT;
  20 import org.eclipse.swt.events.SelectionEvent;
  21 import org.eclipse.swt.events.SelectionListener;
  22 import org.eclipse.swt.graphics.Color;
  23 import org.eclipse.swt.widgets.Composite;
  24 import org.eclipse.swt.widgets.Control;
  25 import org.eclipse.swt.widgets.Display;
  26 import org.eclipse.swt.widgets.TypedListener;
  27 import org.eclipse.swt.widgets.Widget;
  28 import org.eclipse.ui.IEditorPart;
  29 import org.eclipse.ui.forms.widgets.Section;
  30 import org.eclipse.ui.forms.widgets.TableWrapLayout;
  31 import org.eclipse.ui.forms.widgets.ToggleHyperlink;
  32
  33 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  34 import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
  35 import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
  36 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  37
  38 /**
  39  * <p>
  40  * Abstract super class for a {@link Section} GUI element that visualizes a CDM
  41  * entity, manages a conversation and listens to selections
  42  * </p>
  43  *
  44  * @param <ENTITY> A CDM entity which should be visualized by this section.
  45  *
  46  * @author n.hoffmann
  47  * @created Feb 22, 2010
  48  * @version 1.0
  49  * @param <T>
  50  */
  51 //TODO shouldn't ENTITY be bound with super class ICdmBase for example (AbstractFormSection<ENTITY extends ICdmBase>)?
  52 public abstract class AbstractFormSection<ENTITY> extends Section implements
  53                 ISelectionChangedListener, IEntityElement<ENTITY>,
  54                 IConversationEnabled {
  55
  56         private ISelectionProvider selectionProvider;
  57
  58         private ENTITY entity;
  59
  60         private final Set<ICdmFormElement> elements = new HashSet<ICdmFormElement>();
  61
  62         protected CdmFormFactory formFactory;
  63
  64         private List<IPropertyChangeListener> propertyChangeListeners;
  65
  66         private ICdmFormElement parentElement;
  67
  68         private Color persistentBackgroundColor;
  69
  70         /**
  71          * <p>
  72          * Constructor for AbstractFormSection.
  73          * </p>
  74          *
  75          * @param conversation
  76          *            TODO
  77          * @param style
  78          *            a int.
  79          * @param formFactory
  80          *            a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory}
  81          *            object.
  82          * @param parentElement
  83          *            a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
  84          *            object.
  85          * @param <ENTITY>
  86          *            a ENTITY object.
  87          */
  88         protected AbstractFormSection(CdmFormFactory formFactory, ICdmFormElement parentElement,
  89                         int style) {
  90                 super(parentElement.getLayoutComposite(), style);
  91
  92                 this.parentElement = parentElement;
  93
  94                 this.formFactory = formFactory;
  95
  96                 this.setLayoutData(LayoutConstants.FILL());
  97
  98                 Composite client = formFactory.createComposite(this, SWT.WRAP);
  99                 client.setBackgroundMode(SWT.INHERIT_DEFAULT);
 100
 101                 TableWrapLayout layout = LayoutConstants.LAYOUT();
 102                 layout.bottomMargin = 10;
 103                 layout.rightMargin = 5;
 104
 105                 client.setLayout(layout);
 106
 107                 this.setClient(client);
 108         }
 109
 110         /**
 111          * <p>
 112          * Constructor for AbstractFormSection.
 113          * </p>
 114          *
 115          * @param formFactory
 116          *            a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory}
 117          *            object.
 118          * @param conversation
 119          *            a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder}
 120          *            object.
 121          * @param parentElement
 122          *            a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
 123          *            object.
 124          * @param selectionProvider
 125          *            a {@link org.eclipse.jface.viewers.ISelectionProvider} object.
 126          * @param style
 127          *            a int.
 128          */
 129         protected AbstractFormSection(CdmFormFactory formFactory,
 130                         ICdmFormElement parentElement,
 131                         ISelectionProvider selectionProvider, int style) {
 132                 this(formFactory, parentElement, style);
 133                 this.selectionProvider = selectionProvider;
 134         }
 135
 136         /**
 137          * <p>
 138          * Getter for the field <code>propertyChangeListeners</code>.
 139          * </p>
 140          *
 141          * @return a {@link java.util.Set} object.
 142          */
 143         @Override
 144     public List<IPropertyChangeListener> getPropertyChangeListeners() {
 145                 return propertyChangeListeners;
 146         }
 147
 148         /** {@inheritDoc} */
 149         @Override
 150     public void setPropertyChangeListeners(
 151                         List<IPropertyChangeListener> propertyChangeListeners) {
 152                 this.propertyChangeListeners = propertyChangeListeners;
 153         }
 154
 155         /**
 156          * <p>
 157          * Setter for the field <code>entity</code>.
 158          * </p>
 159          *
 160          * @param entity
 161          *            a ENTITY object.
 162          */
 163         public void setEntity(ENTITY entity) {
 164                 this.entity = entity;
 165         }
 166
 167         /*
 168          * (non-Javadoc)
 169          *
 170          * @see eu.etaxonomy.taxeditor.forms.IEntityElement#getEntity()
 171          */
 172         /**
 173          * <p>
 174          * Getter for the field <code>entity</code>.
 175          * </p>
 176          *
 177          * @return a ENTITY object.
 178          */
 179         @Override
 180     public ENTITY getEntity() {
 181                 return entity;
 182         }
 183
 184         /**
 185          * <p>
 186          * getToggle
 187          * </p>
 188          *
 189          * @return a {@link org.eclipse.ui.forms.widgets.ToggleHyperlink} object.
 190          */
 191         public ToggleHyperlink getToggle() {
 192                 return this.toggle;
 193         }
 194
 195         /**
 196          * <p>
 197          * getSection
 198          * </p>
 199          *
 200          * @return a {@link eu.etaxonomy.taxeditor.ui.element.AbstractFormSection}
 201          *         object.
 202          */
 203         public AbstractFormSection<ENTITY> getSection() {
 204                 return this;
 205         }
 206
 207         /*
 208          * (non-Javadoc)
 209          *
 210          * @see
 211          * eu.etaxonomy.taxeditor.forms.IPropertyChangeEmitter#firePropertyChangeEvent
 212          * ()
 213          */
 214         /** {@inheritDoc} */
 215         @Override
 216     public void firePropertyChangeEvent(CdmPropertyChangeEvent event) {
 217                 Assert.isNotNull(propertyChangeListeners,
 218                                 "No property change listeners.");
 219                 try {
 220                         for (Object listener : propertyChangeListeners) {
 221                                 ((IPropertyChangeListener) listener).propertyChange(event);
 222                         }
 223                 } catch (ConcurrentModificationException e) {
 224                         AbstractUtility.warn(getClass(),
 225                                         "ConcurrentModificationException while handling PropertyChangeEvents."
 226                                                         + " It seems like this is not critical");
 227                 }
 228         }
 229
 230         /**
 231          * Fires a {@link CdmPropertyChangeEvent} with the given object as source.
 232          *
 233          * @param object
 234          *            the object on which the property changed
 235          */
 236         public void firePropertyChangeEvent(Object object) {
 237                 firePropertyChangeEvent(object, null);
 238         }
 239
 240         /**
 241          * Fires a {@link CdmPropertyChangeEvent} with the given object as source
 242          * also containing the originating event
 243          *
 244          * @param object
 245          *            the object on which the property changed
 246          * @param originatingEvent
 247          *            the originating event
 248          */
 249         public void firePropertyChangeEvent(Object object,
 250                         PropertyChangeEvent originatingEvent) {
 251                 firePropertyChangeEvent(new CdmPropertyChangeEvent(object,
 252                                 originatingEvent));
 253         }
 254
 255         /*
 256          * (non-Javadoc)
 257          *
 258          * @see org.eclipse.swt.widgets.Composite#setFocus()
 259          */
 260         /** {@inheritDoc} */
 261         @Override
 262         public boolean setFocus() {
 263                 return getClient().setFocus();
 264         }
 265
 266         /*
 267          * (non-Javadoc)
 268          *
 269          * @see
 270          * org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse
 271          * .jface.util.PropertyChangeEvent)
 272          */
 273         /** {@inheritDoc} */
 274         @Override
 275     public void propertyChange(PropertyChangeEvent event) {
 276                 firePropertyChangeEvent(new CdmPropertyChangeEvent(this, event));
 277         }
 278
 279         /*
 280          * (non-Javadoc)
 281          *
 282          * @see
 283          * org.eclipse.swt.widgets.Control#setBackground(org.eclipse.swt.graphics
 284          * .Color)
 285          */
 286         /** {@inheritDoc} */
 287         @Override
 288         public void setBackground(Color color) {
 289                 for (ICdmFormElement element : getElements()) {
 290                         element.setBackground(color);
 291                 }
 292                 getLayoutComposite().setBackground(color);
 293                 super.setBackground(color);
 294         }
 295
 296         @Override
 297         public void setPersistentBackground(Color color) {
 298                 persistentBackgroundColor = color;
 299                 setBackground(color);
 300         }
 301
 302         @Override
 303         public Color getPersistentBackground() {
 304                 return persistentBackgroundColor;
 305         }
 306
 307
 308         /**
 309          * <p>
 310          * widgetSelected
 311          * </p>
 312          *
 313          * @param e
 314          *            a {@link org.eclipse.swt.events.SelectionEvent} object.
 315          */
 316         public void widgetSelected(SelectionEvent e) {
 317                 Widget widget = e.widget;
 318
 319                 if (widget instanceof Control) {
 320                         Control control = (Control) widget;
 321                         if (checkControlAncestryForWidget(control)) {
 322                                 if (getEntity() != null) {
 323                                         IStructuredSelection selection = new StructuredSelection(
 324                                                         getEntity());
 325                                         if (selectionProvider != null) {
 326                                                 selectionProvider.setSelection(selection);
 327                                         }
 328                                 }
 329                         }
 330                 }
 331         }
 332
 333         private boolean checkControlAncestryForWidget(Control control) {
 334                 if (control.equals(this)) {
 335                         return true;
 336                 } else {
 337                         Control parent = control.getParent();
 338                         if (parent == null) {
 339                                 return false;
 340                         } else {
 341                                 return checkControlAncestryForWidget(parent);
 342                         }
 343                 }
 344         }
 345
 346         /** {@inheritDoc} */
 347         @Override
 348     public void setSelected(boolean selected) {
 349                 if (selected) {
 350                         setBackground(Display.getCurrent().getSystemColor(
 351                                         SWT.COLOR_LIST_SELECTION));
 352                 } else {
 353                         setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));
 354                 }
 355         }
 356
 357         /** {@inheritDoc} */
 358         @Override
 359     public void selectionChanged(SelectionChangedEvent event) {
 360                 if (event.getSelection() == CdmFormFactory.EMPTY_SELECTION) {
 361                         return;
 362                 }
 363
 364                 IStructuredSelection selection = (IStructuredSelection) event
 365                                 .getSelection();
 366                 setSelected(false);
 367
 368                 Object selectedObject = selection.getFirstElement();
 369
 370                 if (selectedObject != null && selectedObject.equals(getEntity())) {
 371                         setSelected(true);
 372                 }
 373         }
 374
 375         /**
 376          * <p>
 377          * addSelectionListener
 378          * </p>
 379          *
 380          * @param listener
 381          *            a {@link org.eclipse.swt.events.SelectionListener} object.
 382          */
 383         public void addSelectionListener(SelectionListener listener) {
 384                 addListener(SWT.Selection, new TypedListener(listener));
 385         }
 386
 387         /**
 388          * <p>
 389          * removeSelectionListener
 390          * </p>
 391          *
 392          * @param listener
 393          *            a {@link org.eclipse.swt.events.SelectionListener} object.
 394          */
 395         public void removeSelectionListener(SelectionListener listener) {
 396                 removeListener(SWT.Selection, listener);
 397         }
 398
 399         /** {@inheritDoc} */
 400         @Override
 401     public void addElement(ICdmFormElement element) {
 402                 elements.add(element);
 403         }
 404
 405         /**
 406          * <p>
 407          * removeElement
 408          * </p>
 409          *
 410          * @param element
 411          *            a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement}
 412          *            object.
 413          */
 414         protected void removeElement(ICdmFormElement element) {
 415                 elements.remove(element);
 416         }
 417
 418         /**
 419          * <p>
 420          * removeElements
 421          * </p>
 422          */
 423         @Override
 424     public void removeElements() {
 425                 for (ICdmFormElement childElement : getElements()) {
 426                         // recursion
 427                         childElement.removeElements();
 428
 429                         // unregister selection arbitrator
 430                         if (childElement instanceof ISelectableElement) {
 431                                 ISelectableElement selectableElement = (ISelectableElement) childElement;
 432                                 if (selectableElement.getSelectionArbitrator() != null) {
 433                                         formFactory.destroySelectionArbitrator(selectableElement
 434                                                         .getSelectionArbitrator());
 435                                 }
 436                         }
 437
 438                         // unregister propertyChangeListener
 439                         formFactory.removePropertyChangeListener(childElement);
 440
 441                         // dispose of the controls
 442                         for (Control control : childElement.getControls()) {
 443                                 // we added the layoutComposite of the parental element as the
 444                                 // layout composite to this formElement
 445                                 // but we do not want to destroy it.
 446                                 if (control.equals(childElement.getLayoutComposite())) {
 447                                         continue;
 448                                 } else {
 449                                         control.dispose();
 450                                         control = null;
 451                                 }
 452                         }
 453                 }
 454
 455                 elements.clear();
 456         }
 457
 458         /**
 459          * <p>
 460          * Getter for the field <code>parentElement</code>.
 461          * </p>
 462          *
 463          * @return a {@link eu.etaxonomy.taxeditor.ui.element.ICdmFormElement} object.
 464          */
 465         @Override
 466     public ICdmFormElement getParentElement() {
 467                 return parentElement;
 468         }
 469
 470         /**
 471          * <p>
 472          * Getter for the field <code>elements</code>.
 473          * </p>
 474          *
 475          * @return a {@link java.util.Set} object.
 476          */
 477         @Override
 478     public Set<ICdmFormElement> getElements() {
 479                 return elements;
 480         }
 481
 482         /**
 483          * <p>
 484          * getControls
 485          * </p>
 486          *
 487          * @return a {@link java.util.Set} object.
 488          */
 489         @Override
 490     public Set<Control> getControls() {
 491                 Set<Control> controls = new HashSet<Control>();
 492
 493                 for (Control control : getChildren()) {
 494                         controls.add(control);
 495                 }
 496
 497                 return controls;
 498         }
 499
 500         /** {@inheritDoc} */
 501         @Override
 502         public void dispose() {
 503                 removeElements();
 504                 super.dispose();
 505         }
 506
 507         /**
 508          * <p>
 509          * getLayoutComposite
 510          * </p>
 511          *
 512          * @return a {@link org.eclipse.swt.widgets.Composite} object.
 513          */
 514         @Override
 515     public Composite getLayoutComposite() {
 516                 return (Composite) getClient();
 517         }
 518
 519         /** {@inheritDoc} */
 520         @Override
 521     public boolean containsFormElement(ICdmFormElement formElement) {
 522                 if (formElement == this) {
 523                         return true;
 524                 } else {
 525                         for (ICdmFormElement element : getElements()) {
 526                                 boolean contains = element.containsFormElement(formElement);
 527                                 if (contains == true) {
 528                                         return true;
 529                                 }
 530                         }
 531                         return false;
 532                 }
 533         }
 534
 535         /**
 536          * <p>
 537          * Getter for the field <code>formFactory</code>.
 538          * </p>
 539          *
 540          * @return a {@link eu.etaxonomy.taxeditor.ui.element.CdmFormFactory} object.
 541          */
 542         public CdmFormFactory getFormFactory() {
 543                 return formFactory;
 544         }
 545
 546         /*
 547          * (non-Javadoc)
 548          *
 549          * @see eu.etaxonomy.taxeditor.forms.ICdmFormElement#refresh()
 550          */
 551         /**
 552          * <p>
 553          * refresh
 554          * </p>
 555          */
 556         @Override
 557     public void refresh() {
 558                 // empty default implementation
 559
 560         }
 561
 562         /**
 563          * <p>
 564          * getConversationHolder
 565          * </p>
 566          *
 567          * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder}
 568          *         object.
 569          */
 570         @Override
 571     public ConversationHolder getConversationHolder() {
 572                 if(getParentElement() instanceof RootElement || getParentElement() == null){
 573
 574                         IEditorPart activeEditor = AbstractUtility.getActiveEditor();
 575                         if(activeEditor instanceof IConversationEnabled){
 576                                 ConversationHolder conversation = ((IConversationEnabled) AbstractUtility.getActiveEditor()).getConversationHolder();
 577                                 return conversation;
 578                         }
 579                 }else if(getParentElement() instanceof IConversationEnabled){
 580                         return ((IConversationEnabled) getParentElement()).getConversationHolder();
 581                 }
 582                 AbstractUtility.errorDialog("Could not get conversation for AbstractFormSection",
 583                                 getClass(), "There is an error in the implementation. There should have been an active editor but it wasn't",
 584                                 new IllegalArgumentException());
 585                 return null;
 586
 587         }
 588
 589         /** {@inheritDoc} */
 590         @Override
 591     public void update(CdmDataChangeMap changeEvents) {
 592         }
 593
 594
 595 }