Package org.eclipse.nebula.widgets.nattable.edit.gui

Class AbstractDialogCellEditor

java.lang.Object
org.eclipse.nebula.widgets.nattable.edit.gui.AbstractDialogCellEditor
All Implemented Interfaces:
ICellEditor, ICellEditDialog
Direct Known Subclasses:
FileDialogCellEditor
public abstract class AbstractDialogCellEditor extends Object implements ICellEditor, ICellEditDialog
Abstract implementation of a ICellEditor that is also a ICellEditDialog. By creating a ICellEditor based on this abstract implementation, you are able to create an editor that wraps a SWT or JFace dialog. As SWT and JFace dialogs does not extend the same base classes, the local instance for the wrapped dialog is of type object in here. In the concrete implementation the getDialogInstance() should return the concrete dialog type that is wrapped.

By using this implementation, the CellEditDialogFactory will return the instance of this editor, after it was activated previously.

  • Field Details

    • parent

      protected org.eclipse.swt.widgets.Composite parent
      The parent Composite, needed for the creation of the dialog.

    • dialog

      protected Object dialog
      The Dialog that should be used as a cell editor.

    • layerCell

      protected ILayerCell layerCell
      The cell whose editor should be activated.

    • editHandler

      protected DialogEditHandler editHandler
      The ICellEditHandler that will be used on commit.

    • displayConverter

      protected IDisplayConverter displayConverter
      The IDisplayConverter that should be used to convert the input value to the canonical value and vice versa.

    • dataValidator

      protected IDataValidator dataValidator
      The IDataValidator that should be used to validate the input value prior committing.

    • conversionEditErrorHandler

      protected IEditErrorHandler conversionEditErrorHandler
      The error handler that will be used to show conversion errors.

    • validationEditErrorHandler

      protected IEditErrorHandler validationEditErrorHandler
      The error handler that will be used to show validation errors.

    • configRegistry

      protected IConfigRegistry configRegistry
      The IConfigRegistry containing the configuration of the current NatTable instance. This is necessary because the editors in the current architecture are not aware of the NatTable instance they are running in.

    • editDialogSettings

      protected Map<String,Object> editDialogSettings
      Map that contains custom configurations for this CellEditDialog. We do not use the IDialogSettings provided by JFace, because they are used to store and load the settings in XML rather than overriding the behaviour.

  • Constructor Details

    • AbstractDialogCellEditor

      public AbstractDialogCellEditor()

  • Method Details

    • getEditType

      public EditTypeEnum getEditType()
      Specified by:
      getEditType in interface ICellEditDialog
      Returns:
      The edit type that has impact on how the set value will be updated to the data model. By default EditTypeEnum.SET is returned, which will simply set the committed value to the data model. Every other edit type will do some calculation based on the committed value and the current value in the data model.

    • calculateValue

      public Object calculateValue(Object currentValue, Object processValue)
      Description copied from interface: ICellEditDialog
      In case ICellEditDialog.getEditType() returns an edit type for processing values, this method should implemented to do that transformation.
      Specified by:
      calculateValue in interface ICellEditDialog
      Parameters:
      currentValue - The current value for the cell before data model update
      processValue - The value committed to the editor that should be used for calculation on the current value.
      Returns:
      The value that should be used to update the data model.

    • open

      public abstract int open()
      Description copied from interface: ICellEditDialog
      Opens this dialog, creating it first if it has not yet been created.

      Specified in here for convenience so we only need to check against this interface for a dialog.

      Specified by:
      open in interface ICellEditDialog
      Returns:
      the return code

    • activateCell

      public org.eclipse.swt.widgets.Control activateCell(org.eclipse.swt.widgets.Composite parent, Object originalCanonicalValue, EditModeEnum editMode, ICellEditHandler editHandler, ILayerCell cell, IConfigRegistry configRegistry)
      Description copied from interface: ICellEditor
      This method will be called by the framework to activate this cell editor. It initializes the the values needed for further processing of the editor and will add listeners for general behavior of the editor control.
      Specified by:
      activateCell in interface ICellEditor
      Parameters:
      parent - The parent Composite, needed for the creation of the editor control.
      originalCanonicalValue - The value that should be put to the activated editor control.
      editMode - The EditModeEnum which is used to activate special behavior and styling. This is needed because activating an editor inline will have different behavior (e.g. moving the selection after commit) and styling than rendering the editor on a subdialog.
      editHandler - The ICellEditHandler that will be used on commit.
      cell - The cell whose corresponding editor should be activated.
      configRegistry - The IConfigRegistry containing the configuration of the current NatTable instance. This is necessary because the editors in the current architecture are not aware of the NatTable instance they are running in.
      Returns:
      The SWT Control to be used for capturing the new cell value.

    • createDialogInstance

      public abstract Object createDialogInstance()
      Will create the dialog instance that should be wrapped by this AbstractDialogCellEditor. Note that you always need to create and return a new instance because on commit or close the dialog will be closed, which disposes the shell of the dialog. Therefore the instance will not be usable after commit/close.
      Returns:
      The dialog instance that should be wrapped by this AbstractDialogCellEditor

    • getDialogInstance

      public abstract Object getDialogInstance()
      Returns:
      The current dialog instance that is wrapped by this AbstractDialogCellEditor

    • getEditorValue

      public abstract Object getEditorValue()
      Description copied from interface: ICellEditor
      Returns the current value in this editor prior to conversion. For a text editor that is used to edit integer values, this would mean it returns the text value instead of the converted integer value. This method is only intended to be used internally .
      Specified by:
      getEditorValue in interface ICellEditor
      Returns:
      The current value in this editor prior to conversion.

    • setEditorValue

      public abstract void setEditorValue(Object value)
      Description copied from interface: ICellEditor
      Sets the given value to editor control. This method is used to put the display values to the wrapped editor.
      Specified by:
      setEditorValue in interface ICellEditor
      Parameters:
      value - The display value to set to the wrapped editor control.

    • getCanonicalValue

      public Object getCanonicalValue()
      Description copied from interface: ICellEditor
      Converts the current value in this editor using the configured IDisplayConverter. If there is no IDisplayConverter registered for this editor, the value itself will be returned.
      Specified by:
      getCanonicalValue in interface ICellEditor
      Returns:
      The canonical value after converting the current value or the value itself if no IDisplayConverter is configured.
      See Also:

    • getCanonicalValue

      public Object getCanonicalValue(IEditErrorHandler conversionErrorHandler)
      Description copied from interface: ICellEditor
      Converts the current value in this editor using the configured IDisplayConverter. If there is no IDisplayConverter registered for this editor, the value itself will be returned. Will use the specified IEditErrorHandler for handling conversion errors.
      Specified by:
      getCanonicalValue in interface ICellEditor
      Parameters:
      conversionErrorHandler - The error handler that will be activated in case of conversion errors.
      Returns:
      The canonical value after converting the current value or the value itself if no IDisplayConverter is configured.
      See Also:

    • setCanonicalValue

      public void setCanonicalValue(Object canonicalValue)
      Description copied from interface: ICellEditor
      Sets the given canonical value to the wrapped editor control. Prior to setting the value it needs to be converted to the display value, using the configured IDisplayConverter.
      Specified by:
      setCanonicalValue in interface ICellEditor
      Parameters:
      canonicalValue - The canonical value to be set to the wrapped editor control.

    • validateCanonicalValue

      public boolean validateCanonicalValue(Object canonicalValue)
      Description copied from interface: ICellEditor
      Validates the given value using the configured IDataValidator. This method should be called with the value converted before by using ICellEditor.getCanonicalValue().
      Specified by:
      validateCanonicalValue in interface ICellEditor
      Parameters:
      canonicalValue - The canonical value to validate.
      Returns:
      true if the current value in this editor is valid or no IDataValidator is registered, false if the value is not valid.

    • validateCanonicalValue

      public boolean validateCanonicalValue(Object canonicalValue, IEditErrorHandler validationErrorHandler)
      Description copied from interface: ICellEditor
      Validates the current value in this editor using the configured IDataValidator. Validates the given value using the configured IDataValidator. This method should be called with the value converted before by using ICellEditor.getCanonicalValue(). Will use the specified IEditErrorHandler for handling validation errors.
      Specified by:
      validateCanonicalValue in interface ICellEditor
      Parameters:
      canonicalValue - The canonical value to validate.
      validationErrorHandler - The error handler that will be activated in case of validation errors.
      Returns:
      true if the current value in this editor is valid or no IDataValidator is registered, false if the value is not valid.

    • commit

      public boolean commit(SelectionLayer.MoveDirectionEnum direction)
      Description copied from interface: ICellEditor
      Commits the current value of this editor. Will first try to convert and validate the current value, and if that succeeds and the value can be committed to the data model, the editor will be closed afterwards.
      Specified by:
      commit in interface ICellEditor
      Parameters:
      direction - The direction the selection within the NatTable should move after commit has finished.
      Returns:
      true if the commit operation succeeded, false if the current value could not be committed. A value might not be committed for example if the conversion or the validation failed.

    • commit

      public boolean commit(SelectionLayer.MoveDirectionEnum direction, boolean closeAfterCommit)
      Description copied from interface: ICellEditor
      Commits the current value of this editor. Will first try to convert the current value. Then it is checked if the validation should be executed which can be specified via parameter. If that succeeds and the value can be committed to the data model, the editor will be closed afterwards.
      Specified by:
      commit in interface ICellEditor
      Parameters:
      direction - The direction the selection within the NatTable should move after commit has finished.
      closeAfterCommit - flag to tell whether this editor needs to closed after the commit or if it should stay open.
      Returns:
      true if the commit operation succeeded, false if the current value could not be committed. A value might not be committed for example if the conversion or the validation failed.

    • commit

      public boolean commit(SelectionLayer.MoveDirectionEnum direction, boolean closeAfterCommit, boolean skipValidation)
      Description copied from interface: ICellEditor
      Commits the current value of this editor.
      Specified by:
      commit in interface ICellEditor
      Parameters:
      direction - The direction the selection within the NatTable should move after commit has finished.
      closeAfterCommit - flag to tell whether this editor needs to closed after the commit or if it should stay open.
      skipValidation - Flag to specify whether the current value in this editor should be validated or not.
      Returns:
      true if the commit operation succeeded, false if the current value could not be committed. A value might not be committed for example if the conversion or the validation failed.

    • getCommittedValue

      public Object getCommittedValue()
      Specified by:
      getCommittedValue in interface ICellEditDialog
      Returns:
      The canonical value that was committed to the editor control.

    • close

      public abstract void close()
      Description copied from interface: ICellEditor
      Close/dispose the contained Control
      Specified by:
      close in interface ICellEditor

    • isClosed

      public abstract boolean isClosed()
      Specified by:
      isClosed in interface ICellEditor
      Returns:
      true if this editor has been closed already, false if it is still open

    • getEditorControl

      public org.eclipse.swt.widgets.Control getEditorControl()
      Specified by:
      getEditorControl in interface ICellEditor
      Returns:
      The editor control that is wrapped by this ICellEditor.

    • createEditorControl

      public org.eclipse.swt.widgets.Control createEditorControl(org.eclipse.swt.widgets.Composite parent)
      Description copied from interface: ICellEditor
      Creates the editor control that is wrapped by this ICellEditor. Will use the style configurations in ConfigRegistry for styling the control.
      Specified by:
      createEditorControl in interface ICellEditor
      Parameters:
      parent - The Composite that will be the parent of the new editor control. Can not be null
      Returns:
      The created editor control that is wrapped by this ICellEditor.

    • openInline

      public boolean openInline(IConfigRegistry configRegistry, List<String> configLabels)
      Description copied from interface: ICellEditor
      Determines whether the editor should be opened inline or using a dialog. By default it will check this by configuration attribute EditConfigAttributes.OPEN_IN_DIALOG. If there is no configuration found for this, true will be returned for backwards compatibility.

      If this method returns true, the editor will be opened inline (default).

      There might be editors that are only able to be opened in a dialog. These implementations need to override this method to always return false, so the editor never gets opened inline.

      Specified by:
      openInline in interface ICellEditor
      Parameters:
      configRegistry - The IConfigRegistry to retrieve the configuration for inline/dialog editing out of. Needed here because the instance IConfigRegistry might not be set on calling this method.
      configLabels - The labels out of the LabelStack of the cell whose editor should be activated. Needed here because this method needs to be called prior to activation to determine where to activate it.
      Returns:
      true if the editor should opened inline, false if not.
      See Also:

    • supportMultiEdit

      public boolean supportMultiEdit(IConfigRegistry configRegistry, List<String> configLabels)
      Description copied from interface: ICellEditor
      Determines whether this editor supports multi edit behavior or not. If this method returns true, on selecting and pressing F2 on several cells that are editable, having the same editor type and converter registered, a multi edit dialog will open. By default this method will return true. You can change this behavior by setting the configuration attribute EditConfigAttributes.SUPPORT_MULTI_EDIT.

      You should consider returning false e.g. if the update operation is complex or you use conditional validation, where a value is validated against another value in the data model.

      Specified by:
      supportMultiEdit in interface ICellEditor
      Parameters:
      configRegistry - The IConfigRegistry to retrieve the configuration for multi edit support out of. Needed here because the instance IConfigRegistry might not be set on calling this method.
      configLabels - The labels out of the LabelStack of the cell whose editor should be activated. Needed here because this method needs to be called prior to activation to determine where to activate it.
      Returns:
      true if this editor will open in a subdialog for multi editing, false if the multi editing of this kind of cell editor is not supported.
      See Also:

    • openMultiEditDialog

      public boolean openMultiEditDialog()
      Description copied from interface: ICellEditor
      This is a very special configuration to tell whether an ICellEditor should open a multi edit dialog for multi editing or not. Usually for multi editing there should be always a multi edit dialog be opened. There are only special cases where this doesn't make sense. The only types of ICellEditors that shouldn't open multi edit dialogs are editors that change their values directly and there is no interactively editor control opened, e.g. checkboxes.
      Specified by:
      openMultiEditDialog in interface ICellEditor
      Returns:
      true if for multi editing a multi edit dialog should be opened, false if the multi editing should be performed directly without opening a multi edit dialog. Note: true is the default value and changing it to false for a custom editor might cause issues if not dealed correctly.

    • openAdjacentEditor

      public boolean openAdjacentEditor()
      Description copied from interface: ICellEditor
      Determines behavior after committing the value of this editor in combination with selection movement. If this method return true and the selection is moved after committing, the editor for the newly selected cell will be activated immediately. If this method returns false or the selection is not moved after commit, no action should be executed.

      The behavior previous to this configuration was to not open the adjacent editor. So if there is no configuration registered for this, false will be returned by default.

      Note: It only makes sense to call this method if the editor is already activated. Calling this method on an editor that has not been activated already will lead to exceptions.

      Specified by:
      openAdjacentEditor in interface ICellEditor
      Returns:
      true if the adjacent editor should be opened if the selection moves after commit, false if not.
      See Also:

    • activateAtAnyPosition

      public boolean activateAtAnyPosition()
      Description copied from interface: ICellEditor
      This method is intended to be used by IMouseEventMatcher implementations that need to check for the editor and the click position to determine whether an editor should be activated or not. By default this method will return true. Special implementations that need a different behavior need to return false instead. E.g. checkbox editors should only be activated in case the icon that represents the checkbox is clicked.
      Specified by:
      activateAtAnyPosition in interface ICellEditor
      Returns:
      true if this ICellEditor should be activated by clicking at any position in the corresponding cell, false if there need to be a special position clicked.

    • activateOnTraversal

      public boolean activateOnTraversal(IConfigRegistry configRegistry, List<String> configLabels)
      Description copied from interface: ICellEditor
      This method is asked on tab traversal whether this ICellEditor should be automatically activated or not. This is necessary to avoid automatically changing the value of a checkbox or opening a dialog editor on traversal.
      Specified by:
      activateOnTraversal in interface ICellEditor
      Parameters:
      configRegistry - The IConfigRegistry to retrieve the configuration out of. Needed here because the instance IConfigRegistry might not be set on calling this method.
      configLabels - The labels out of the LabelStack of the cell whose editor should be activated.
      Returns:
      true if this ICellEditor should be activated in case of tab traversal, false if not.
      See Also:

    • addEditorControlListeners

      public void addEditorControlListeners()
      Description copied from interface: ICellEditor
      This method is intended to add listeners to the wrapped editor control to add context related behavior. For example, in EditModeEnum.INLINE by default this should add a FocusListener that commits the current value if the editor control loses focus.

      This method was introduced mainly because of two issues:

      1. On Mac OS calling setBounds() on a Control will cause losing focus. So listeners need to be added after this method is called by the EditController, otherwise on activating the editor it will be closed immediately after the correct size is calculated.
      2. The main concept for cell editor activation is, that the editor control is disposed on closing the editor. This way everytime the cell editor is activated, a new editor control will be created. If an editor is implemented that needs to keep the editor control after closing the editor, it needs to be ensured that the listeners are removed again. Otherwise the listeners would be added again everytime the editor is activated.
      This method will be called automatically by EditController.editCell(ILayerCell, Composite, Object, IConfigRegistry).
      Specified by:
      addEditorControlListeners in interface ICellEditor

    • removeEditorControlListeners

      public void removeEditorControlListeners()
      Description copied from interface: ICellEditor
      This method is intended to remove listeners from the wrapped editor control that was added by ICellEditor.addEditorControlListeners() before to add context related behavior.

      This method was introduced to add the possibility to create an ICellEditor whose wrapped editor control should not be disposed on closing the editor.

      The main concept for cell editor activation is, that the editor control is disposed on closing the editor. This way everytime the cell editor is activated, a new editor control will be created. If an editor is implemented that needs to keep the editor control after closing the editor, it needs to be ensured that the listeners are removed again. Otherwise the listeners would be added again everytime the editor is activated.

      This method needs to be called on ICellEditor.close(). There is no automatical call by the framework if you are not using the abstract implementation of ICellEditor.
      Specified by:
      removeEditorControlListeners in interface ICellEditor

    • calculateControlBounds

      public org.eclipse.swt.graphics.Rectangle calculateControlBounds(org.eclipse.swt.graphics.Rectangle cellBounds)
      Description copied from interface: ICellEditor
      This method is used to calculate the bounds of the edit control when opened inline. By default it should return the given cell bounds to match the cell structure in NatTable. For several cases it might be useful to return the preferred size to show all content rather than trimming the control to the cell size.

      Note: By changing the bounds you should ensure to only modify width and height attributes and not x and y coordinate, otherwise the editor control will show up somewhere else and not in place of the cell that is edited.

      Specified by:
      calculateControlBounds in interface ICellEditor
      Parameters:
      cellBounds - The bounds of the cell for which the editor is opened.
      Returns:
      The bounds of the editor control that should be applied. By default the cell bounds for several cases bigger.

    • setDialogSettings

      public void setDialogSettings(Map<String,Object> editDialogSettings)
      Description copied from interface: ICellEditDialog
      Allows to customize the appearance of the dialog. This method will be called by the framework at creation time of the dialog via the CellEditDialogFactory.

      The map containing the settings can be registered to the IConfigRegistry for the key EditConfigAttributes.EDIT_DIALOG_SETTINGS . The keys that are valid for this map are specified below.

      Specified by:
      setDialogSettings in interface ICellEditDialog
      Parameters:
      editDialogSettings - Map containing the settings to customize the edit dialog appearance.
      See Also:

    • getColumnIndex

      public int getColumnIndex()
      Specified by:
      getColumnIndex in interface ICellEditor
      Returns:
      The column index of the cell to which this editor is attached.

    • getRowIndex

      public int getRowIndex()
      Specified by:
      getRowIndex in interface ICellEditor
      Returns:
      The row index of the cell to which this editor is attached.

    • getColumnPosition

      public int getColumnPosition()
      Specified by:
      getColumnPosition in interface ICellEditor
      Returns:
      The column position of the cell to which this editor is attached.

    • getRowPosition

      public int getRowPosition()
      Specified by:
      getRowPosition in interface ICellEditor
      Returns:
      The row position of the cell to which this editor is attached.