From 605d50f8f6fd440c36ba4ba3f6bf935ada1e6ac2 Mon Sep 17 00:00:00 2001 From: vlorenzo Date: Wed, 5 Feb 2014 14:55:36 +0100 Subject: 423675: ENTER & ALT-ENTER shortcuts in textual cells of the new tables are counter-intuitive (opposite of Excel) https://bugs.eclipse.org/bugs/show_bug.cgi?id=423675 --- .../config/EStructuralFeatureEditorConfig.java | 4 +- .../provider/EMFFeatureHeaderLabelProvider.java | 9 +- .../celleditor/MultiLineTextCellEditor.java | 90 ++++ .../celleditor/MultiLineTextCellEditorEx.java | 107 +++++ .../infra/nattable/celleditor/TextCellEditor.java | 457 +++++++++++++++++++++ .../nattable/listener/NatTableDropListener.java | 24 +- .../manager/table/NattableModelManager.java | 2 +- 7 files changed, 677 insertions(+), 16 deletions(-) create mode 100644 plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditor.java create mode 100644 plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditorEx.java create mode 100644 plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/TextCellEditor.java diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/celleditor/config/EStructuralFeatureEditorConfig.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/celleditor/config/EStructuralFeatureEditorConfig.java index bd4b3073ac1..845a33a53fd 100644 --- a/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/celleditor/config/EStructuralFeatureEditorConfig.java +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/celleditor/config/EStructuralFeatureEditorConfig.java @@ -32,13 +32,13 @@ import org.eclipse.nebula.widgets.nattable.edit.editor.CheckBoxCellEditor; import org.eclipse.nebula.widgets.nattable.edit.editor.ComboBoxCellEditor; import org.eclipse.nebula.widgets.nattable.edit.editor.ICellEditor; import org.eclipse.nebula.widgets.nattable.edit.editor.IComboBoxDataProvider; -import org.eclipse.nebula.widgets.nattable.edit.editor.MultiLineTextCellEditor; import org.eclipse.nebula.widgets.nattable.edit.editor.TextCellEditor; import org.eclipse.nebula.widgets.nattable.painter.cell.ComboBoxPainter; import org.eclipse.nebula.widgets.nattable.painter.cell.ICellPainter; import org.eclipse.nebula.widgets.nattable.painter.cell.TextPainter; import org.eclipse.nebula.widgets.nattable.style.DisplayMode; import org.eclipse.papyrus.infra.emf.utils.EMFHelper; +import org.eclipse.papyrus.infra.nattable.celleditor.MultiLineTextCellEditorEx; import org.eclipse.papyrus.infra.nattable.celleditor.config.AbstractCellEditorConfiguration; import org.eclipse.papyrus.infra.nattable.manager.table.ITableAxisElementProvider; import org.eclipse.papyrus.infra.nattable.model.nattable.Table; @@ -98,7 +98,7 @@ public class EStructuralFeatureEditorConfig extends AbstractCellEditorConfigurat ICellEditor editor = null; switch(editorKind) { case SINGLE_STRING: - editor = new MultiLineTextCellEditor(true); + editor = new MultiLineTextCellEditorEx(true); break; case SINGLE_INTEGER: editor = new TextCellEditor(); diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/provider/EMFFeatureHeaderLabelProvider.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/provider/EMFFeatureHeaderLabelProvider.java index dc801b897db..3c7eb83fcd9 100644 --- a/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/provider/EMFFeatureHeaderLabelProvider.java +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.emf.nattable/src/org/eclipse/papyrus/infra/emf/nattable/provider/EMFFeatureHeaderLabelProvider.java @@ -155,8 +155,8 @@ public class EMFFeatureHeaderLabelProvider extends EMFEObjectHeaderLabelProvider if(value instanceof EStructuralFeatureAxis) { feature = ((EStructuralFeatureAxis)value).getElement(); alias = ((EStructuralFeatureAxis)value).getAlias(); - } else if(feature instanceof EStructuralFeature) { - feature = (EStructuralFeature)((ILabelProviderContextElementWrapper)element).getObject(); + } else if(value instanceof EStructuralFeature) { + feature = (EStructuralFeature)value; } String returnedValue = null; @@ -201,7 +201,7 @@ public class EMFFeatureHeaderLabelProvider extends EMFEObjectHeaderLabelProvider if(object instanceof EStructuralFeatureAxis) { feature = ((EStructuralFeatureAxis)object).getElement(); } else if(object instanceof EStructuralFeature) { - feature = (EStructuralFeature)((ILabelProviderContextElementWrapper)element).getObject(); + feature = (EStructuralFeature)object; } if(feature instanceof EAttribute) { return EStructuralFeatureImageRegistry.getAttributeIcon(); @@ -209,6 +209,9 @@ public class EMFFeatureHeaderLabelProvider extends EMFEObjectHeaderLabelProvider } else if(feature instanceof EReference) { return getEReferenceImage((EReference)feature); } + if(feature==null){ + return null; + } return super.getImage(feature); } diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditor.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditor.java new file mode 100644 index 00000000000..604c258a822 --- /dev/null +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditor.java @@ -0,0 +1,90 @@ +/******************************************************************************* + * Copyright (c) 2013 Dirk Fauth and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Dirk Fauth - initial API and implementation + * Vincent Lorenzo (vincent.lorenzo@cea.fr) - duplicate this class from nattable (change super class) + *******************************************************************************/ +package org.eclipse.papyrus.infra.nattable.celleditor; + +import org.eclipse.jface.layout.GridDataFactory; +import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes; +import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Text; + +/** + * A specialization of {@link TextCellEditor} that uses a multi line text editor as + * editor control. To support multi line editing correctly, the behaviour to commit + * on pressing the enter key is disabled. + *

+ * A multi line editor usually needs some space. Therefore it might be a good decision + * to set the configuration attribute {@link EditConfigAttributes#OPEN_IN_DIALOG} to + * true for this editor, so the editor always opens in a subdialog. + *

+ *

+ * As some table layouts may support enough space for an inline cell editor, this editor + * does not specify {@link ICellEditor#openInline(org.eclipse.nebula.widgets.nattable.config.IConfigRegistry, + * java.util.List)} to always return false. + *

+ * @author Dirk Fauth + * + */ +public class MultiLineTextCellEditor extends TextCellEditor { + + /** + * Flag to configure whether the text control should enable automatic line wrap behaviour + * or not. By default this editor will support automatic line wrapping. + */ + private boolean lineWrap = true; + + /** + * Create a new multi line text editor that ensures to not commit the editor + * value in case enter is typed. The text control will support automatic line wrapping. + */ + public MultiLineTextCellEditor() { + this(true); + } + + /** + * Create a new multi line text editor that ensures to not commit the editor + * value in case enter is typed. + * @param lineWrap Flag to configure whether the text control should enable automatic line + * wrap behaviour or not. + */ + public MultiLineTextCellEditor(boolean lineWrap) { + this.commitOnEnter = false; + this.lineWrap = lineWrap; + } + + @Override + public Text createEditorControl(Composite parent) { + int style = HorizontalAlignmentEnum.getSWTStyle(this.cellStyle) | SWT.MULTI | SWT.BORDER | SWT.V_SCROLL; + if (lineWrap) { + style = style | SWT.WRAP; + } else { + style = style | SWT.H_SCROLL; + } + final Text textControl = super.createEditorControl(parent, style); + + if (!openInline(this.configRegistry, this.labelStack.getLabels())) { + //add the layout data directly so it will not be layouted by the CellEditDialog + GridDataFactory.fillDefaults().grab(true, true).hint(100, 50).applyTo(textControl); + } + + return textControl; + } + + /** + * @param lineWrap true if the text control should enable automatic line + * wrap behaviour, false if not + */ + public void setLineWrap(boolean lineWrap) { + this.lineWrap = lineWrap; + } +} diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditorEx.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditorEx.java new file mode 100644 index 00000000000..e0f9f1be5ee --- /dev/null +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/MultiLineTextCellEditorEx.java @@ -0,0 +1,107 @@ +/***************************************************************************** + * Copyright (c) 2014 CEA LIST. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Vincent Lorenzo (CEA-LIST) - vincent.lorenzo@cea.fr + * + *****************************************************************************/ +package org.eclipse.papyrus.infra.nattable.celleditor; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.KeyEvent; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Text; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.keys.IBindingService; + +/** + * + * @author VL222926 + * This multi line cell editor has the same behavior than spreadsheet (ALT+ENTER (Excel)for new line and ENTER to commit). + * To get this behavior, we desactivate the filtering done by org.eclipse.e4.ui.bindings.keys.KeyBindingDispatcher. This class + * set event.doit==false if the keypressed are binding for eclipse command (ALT-ENTER is registered to show property view) + * + * //TODO : the next version of nattable seems support this behavior with ALT-ENTER, + */ +public class MultiLineTextCellEditorEx extends MultiLineTextCellEditor { + + /** + * boolean indicating if the eclipse filter was activated when the editor has been created + */ + private boolean initialValueForFilteringKeyPress; + + /** + * + * Constructor. + * + */ + public MultiLineTextCellEditorEx() { + super(); + this.commitOnEnter = true; + } + + /** + * + * Constructor. + * + * @param lineWrap + */ + public MultiLineTextCellEditorEx(boolean lineWrap) { + super(lineWrap); + this.commitOnEnter = true; + } + + /** + * + * @see org.eclipse.papyrus.infra.nattable.celleditor.MultiLineTextCellEditor#createEditorControl(org.eclipse.swt.widgets.Composite) + * + * @param parent + * @return + */ + @Override + public Text createEditorControl(Composite parent) { + IBindingService service = (IBindingService)PlatformUI.getWorkbench().getService(IBindingService.class); + this.initialValueForFilteringKeyPress = service.isKeyFilterEnabled(); + if(this.initialValueForFilteringKeyPress) { + service.setKeyFilterEnabled(false); + } + return super.createEditorControl(parent); + } + + /** + * + * @see org.eclipse.papyrus.infra.nattable.celleditor.TextCellEditor#close() + * + */ + @Override + public void close() { + if(this.initialValueForFilteringKeyPress) { + IBindingService service = (IBindingService)PlatformUI.getWorkbench().getService(IBindingService.class); + service.setKeyFilterEnabled(this.initialValueForFilteringKeyPress); + } + super.close(); + } + + /** + * + * @see org.eclipse.papyrus.infra.nattable.celleditor.TextCellEditor#keyPressed(org.eclipse.swt.widgets.Composite, org.eclipse.swt.widgets.Text, + * org.eclipse.swt.events.KeyEvent) + * + * @param parent + * @param text + * @param event + */ + @Override + protected void keyPressed(Composite parent, Text text, KeyEvent event) { + if(event.stateMask == SWT.ALT && (event.keyCode == SWT.CR || event.keyCode == SWT.KEYPAD_CR)) { + text.insert(text.getLineDelimiter()); + } else { + super.keyPressed(parent, text, event); + } + } +} diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/TextCellEditor.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/TextCellEditor.java new file mode 100644 index 00000000000..e9a9152b352 --- /dev/null +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/celleditor/TextCellEditor.java @@ -0,0 +1,457 @@ +/******************************************************************************* + * Copyright (c) 2012 Original authors and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Vincent Lorenzo (CEA-LIST) - duplicated and adapted code from nattable project. + * + ******************************************************************************/ +package org.eclipse.papyrus.infra.nattable.celleditor; + +import org.eclipse.jface.fieldassist.ControlDecoration; +import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes; +import org.eclipse.nebula.widgets.nattable.edit.config.RenderErrorHandling; +import org.eclipse.nebula.widgets.nattable.edit.editor.AbstractCellEditor; +import org.eclipse.nebula.widgets.nattable.edit.editor.ControlDecorationProvider; +import org.eclipse.nebula.widgets.nattable.edit.editor.EditorSelectionEnum; +import org.eclipse.nebula.widgets.nattable.edit.editor.ICellEditor; +import org.eclipse.nebula.widgets.nattable.edit.editor.IEditErrorHandler; +import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer.MoveDirectionEnum; +import org.eclipse.nebula.widgets.nattable.style.CellStyleAttributes; +import org.eclipse.nebula.widgets.nattable.style.DisplayMode; +import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum; +import org.eclipse.nebula.widgets.nattable.style.IStyle; +import org.eclipse.nebula.widgets.nattable.widget.EditModeEnum; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.KeyAdapter; +import org.eclipse.swt.events.KeyEvent; +import org.eclipse.swt.graphics.Cursor; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Text; + +/** + * {@link ICellEditor} implementation that wraps a SWT {@link Text} control to support + * text editing. This is also the default editor in NatTable if you didn't configure + * something else. + * + * duplicated and adapted code from nattable project. Add the method {@link #keyPressed(Composite, KeyEvent)} to allow to ovveride it + */ +public class TextCellEditor extends AbstractCellEditor { + + /** + * The Text control which is the editor wrapped by this TextCellEditor. + */ + private Text text = null; + + /** + * Flag to configure if the wrapped text editor control is editable or not. + */ + private boolean editable = true; + + /** + * Flag to configure whether the editor should commit and move the selection + * in the corresponding way if the up or down key is pressed. + */ + private final boolean commitOnUpDown; + + /** + * Flag to configure whether the selection should move after a value was + * committed after pressing enter. + */ + private final boolean moveSelectionOnEnter; + + /** + * The selection mode that should be used on activating the wrapped text control. + * By default the behaviour is to set the selection at the end of the containing text + * if the text editor control is activated with an initial value. If it is activated + * only specifying the original canonical value, the default behaviour is to select + * the whole text contained in the text editor control. + * + *

+ * You can override this default behaviour by setting an {@link EditorSelectionEnum} explicitly. With this you are able e.g. to set the selection + * at the beginning of the contained text, so writing in the text control will result in prefixing. + * + *

+ * Note that on overriding the behaviour, you override both activation cases. + */ + private EditorSelectionEnum selectionMode; + + /** + * The {@link ControlDecorationProvider} responsible for adding a {@link ControlDecoration} to the wrapped editor control. Can be configured via + * convenience methods of this TextCellEditor. + */ + protected final ControlDecorationProvider decorationProvider = new ControlDecorationProvider(); + + /** + * The {@link IEditErrorHandler} that is used for showing conversion errors on typing into + * this editor. By default this is the {@link RenderErrorHandling} which will render the + * content in the editor red to indicate a conversion error. + */ + private IEditErrorHandler inputConversionErrorHandler = new RenderErrorHandling(decorationProvider); + + /** + * The {@link IEditErrorHandler} that is used for showing validation errors on typing into + * this editor. By default this is the {@link RenderErrorHandling} which will render the + * content in the editor red to indicate a validation error. + */ + private IEditErrorHandler inputValidationErrorHandler = new RenderErrorHandling(decorationProvider); + + /** + * Flag to determine whether this editor should try to commit and close on pressing the enter key. + * The default is of course true, but for a multi line text editor, the enter key + * should be treated as inserting a new line instead of committing. + */ + protected boolean commitOnEnter = true; + + /** + * Creates the default TextCellEditor that does not commit on pressing the up/down arrow keys + * and will not move the selection on committing a value by pressing enter. + */ + public TextCellEditor() { + this(false); + } + + /** + * Creates a TextCellEditor that will not move the selection on committing a value by pressing enter. + * + * @param commitOnUpDown + * Flag to configure whether the editor should commit + * and move the selection in the corresponding way if the up or down key is pressed. + */ + public TextCellEditor(boolean commitOnUpDown) { + this(commitOnUpDown, false); + } + + /** + * Creates a TextCellEditor. + * + * @param commitOnUpDown + * Flag to configure whether the editor should commit + * and move the selection in the corresponding way if the up or down key is pressed. + * @param moveSelectionOnEnter + * Flag to configure whether the selection should move after a value was + * committed after pressing enter. + */ + public TextCellEditor(boolean commitOnUpDown, boolean moveSelectionOnEnter) { + this.commitOnUpDown = commitOnUpDown; + this.moveSelectionOnEnter = moveSelectionOnEnter; + } + + @Override + protected Control activateCell(final Composite parent, Object originalCanonicalValue) { + this.text = createEditorControl(parent); + + // If the originalCanonicalValue is a Character it is possible the editor is activated by keypress + if(originalCanonicalValue instanceof Character) { + this.text.setText(originalCanonicalValue.toString()); + selectText(this.selectionMode != null ? this.selectionMode : EditorSelectionEnum.END); + } + //if there is no initial value, handle the original canonical value to transfer it to the text control + else { + setCanonicalValue(originalCanonicalValue); + selectText(this.selectionMode != null ? this.selectionMode : EditorSelectionEnum.ALL); + } + + if(!isEditable()) { + this.text.setEditable(false); + } + + //show an error decoration if this is enabled + this.decorationProvider.createErrorDecorationIfRequired(this.text); + + //if the input error handlers are of type RenderErrorHandler (default) than + //we also check for a possible configured error styling in the configuration + //Note: this is currently only implemented in here, as the TextCellEditor is + // the only editor that supports just in time conversion/validation + if(this.inputConversionErrorHandler instanceof RenderErrorHandling) { + IStyle conversionErrorStyle = this.configRegistry.getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, DisplayMode.EDIT, this.labelStack.getLabels()); + + ((RenderErrorHandling)this.inputConversionErrorHandler).setErrorStyle(conversionErrorStyle); + } + + if(this.inputValidationErrorHandler instanceof RenderErrorHandling) { + IStyle validationErrorStyle = this.configRegistry.getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, DisplayMode.EDIT, this.labelStack.getLabels()); + + ((RenderErrorHandling)this.inputValidationErrorHandler).setErrorStyle(validationErrorStyle); + } + + this.text.forceFocus(); + + return this.text; + } + + @Override + public String getEditorValue() { + return this.text.getText(); + } + + @Override + public void setEditorValue(Object value) { + this.text.setText(value != null && value.toString().length() > 0 ? value.toString() : ""); //$NON-NLS-1$ + } + + @Override + public Text getEditorControl() { + return this.text; + } + + @Override + public Text createEditorControl(Composite parent) { + int style = HorizontalAlignmentEnum.getSWTStyle(this.cellStyle); + if(this.editMode == EditModeEnum.DIALOG) { + style = style | SWT.BORDER; + } + return createEditorControl(parent, style); + } + + /** + * Creates the editor control that is wrapped by this ICellEditor. + * Will use the style configurations in ConfigRegistry for styling the control. + * + * @param parent + * The Composite that will be the parent of the new editor control. + * Can not be null + * @param style + * The SWT style of the text control to create. + * @return The created editor control that is wrapped by this ICellEditor. + */ + protected Text createEditorControl(final Composite parent, int style) { + //create the Text control based on the specified style + final Text textControl = new Text(parent, style); + + //set style information configured in the associated cell style + textControl.setBackground(this.cellStyle.getAttributeValue(CellStyleAttributes.BACKGROUND_COLOR)); + textControl.setForeground(this.cellStyle.getAttributeValue(CellStyleAttributes.FOREGROUND_COLOR)); + textControl.setFont(this.cellStyle.getAttributeValue(CellStyleAttributes.FONT)); + + textControl.setCursor(new Cursor(Display.getDefault(), SWT.CURSOR_IBEAM)); + + //add a key listener that will commit or close the editor for special key strokes + //and executes conversion/validation on input to the editor + textControl.addKeyListener(new KeyAdapter() { + + @Override + public void keyPressed(KeyEvent event) { + TextCellEditor.this.keyPressed(parent, textControl, event); + } + + @Override + public void keyReleased(KeyEvent e) { + try { + //always do the conversion + Object canonicalValue = getCanonicalValue(inputConversionErrorHandler); + //and always do the validation + //even if for commiting the validation should be skipped, on editing + //a validation failure should be made visible + //otherwise there would be no need for validation! + validateCanonicalValue(canonicalValue, inputValidationErrorHandler); + } catch (Exception ex) { + //do nothing as exceptions caused by conversion or validation are handled already + //we just need this catch block for stopping the process if conversion failed with + //an exception + } + } + }); + + return textControl; + } + + protected void keyPressed(Composite parent, Text text, KeyEvent event) { + if(commitOnEnter && (event.keyCode == SWT.CR || event.keyCode == SWT.KEYPAD_CR)) { + + MoveDirectionEnum move = MoveDirectionEnum.NONE; + if(moveSelectionOnEnter && editMode == EditModeEnum.INLINE) { + if(event.stateMask == 0) { + move = MoveDirectionEnum.DOWN; + } else if(event.stateMask == SWT.SHIFT) { + move = MoveDirectionEnum.UP; + } + } + + commit(move); + + if(editMode == EditModeEnum.DIALOG) { + parent.forceFocus(); + } + } else if(event.keyCode == SWT.ESC && event.stateMask == 0) { + close(); + } else if(commitOnUpDown && editMode == EditModeEnum.INLINE) { + if(event.keyCode == SWT.ARROW_UP) { + commit(MoveDirectionEnum.UP); + } else if(event.keyCode == SWT.ARROW_DOWN) { + commit(MoveDirectionEnum.DOWN); + } + } + } + + @Override + public void close() { + super.close(); + + this.decorationProvider.dispose(); + } + + /** + * @return true if the wrapped Text control is editable, false if not. + */ + public boolean isEditable() { + return editable; + } + + /** + * + * @param editable + * true if the wrapped Text control should be editable, false if not. + */ + public void setEditable(boolean editable) { + this.editable = editable; + } + + /** + * Returns the current configured selection mode that is used on activating the wrapped + * text editor control. By default this is null which causes the following + * default behaviour. If the text editor control is activated with an initial value then + * the selection is set at the end of the containing text. If it is activated + * only specifying the original canonical value, the default behaviour is to select + * the whole text contained in the text editor control. + * + * @return The current configured selection mode, null for default behaviour. + */ + public final EditorSelectionEnum getSelectionMode() { + return selectionMode; + } + + /** + * Set the selection mode that should be used on the content of the wrapped text editor control + * when it gets activated. By setting a value explicitly you configure the selection mode for + * both cases, activating the wrapped text editor control with and without an initial value. + * Setting this value to null will reactivate the default behaviour like described + * here {@link TextCellEditor#getSelectionMode()}. + * + * @param selectionMode + * The selection mode that should be used on the content of the + * wrapped text editor control when it gets activated. + */ + public final void setSelectionMode(EditorSelectionEnum selectionMode) { + this.selectionMode = selectionMode; + } + + /** + * Will set the selection to the wrapped text control regarding the configured {@link EditorSelectionEnum}. + * + *

+ * This method is called + * + * @see Text#setSelection(int, int) + */ + private void selectText(EditorSelectionEnum selectionMode) { + int textLength = this.text.getText().length(); + if(textLength > 0) { + if(selectionMode == EditorSelectionEnum.ALL) { + this.text.setSelection(0, textLength); + } else if(selectionMode == EditorSelectionEnum.END) { + this.text.setSelection(textLength, textLength); + } else if(selectionMode == EditorSelectionEnum.START) { + this.text.setSelection(0); + } + } + } + + /** + * @return The {@link ControlDecorationProvider} responsible for adding a {@link ControlDecoration} to the wrapped editor control. + */ + public ControlDecorationProvider getDecorationProvider() { + return this.decorationProvider; + } + + /** + * Enables/disables the error decoration for the wrapped text control. + * + * @param enabled + * true if an error decoration should be added to + * the wrapped text control, false if not. + */ + public void setErrorDecorationEnabled(boolean enabled) { + this.decorationProvider.setErrorDecorationEnabled(enabled); + } + + /** + * Set the error description text that will be shown in the decoration hover. + * + * @param errorText + * The text to be shown as a description for the decoration, or null if there should be no description. + * + * @see ControlDecoration#setDescriptionText(String) + */ + public void setErrorDecorationText(String errorText) { + this.decorationProvider.setErrorDecorationText(errorText); + } + + /** + * Force the error decoration hover to show immediately. + * + * @param customErrorText + * The text to show in the hover popup. + * + * @see ControlDecoration#show() + * @see ControlDecoration#showHoverText(String) + */ + public void showErrorDecorationHover(String customErrorText) { + this.decorationProvider.showErrorDecorationHover(customErrorText); + } + + /** + * Set the position of the control decoration relative to the control. + * It should include style bits describing both the vertical and horizontal orientation. + * + * @param decorationPositionOverride + * bit-wise or of position constants (SWT.TOP, SWT.BOTTOM, SWT.LEFT, SWT.RIGHT, and + * SWT.CENTER). + * + * @see ControlDecoration#ControlDecoration(Control, int) + */ + public void setDecorationPositionOverride(int decorationPositionOverride) { + this.decorationProvider.setDecorationPositionOverride(decorationPositionOverride); + } + + /** + * @return The {@link IEditErrorHandler} that is used for showing conversion errors on typing into + * this editor. By default this is the {@link RenderErrorHandling} which will render the + * content in the editor red to indicate a conversion error. + */ + public IEditErrorHandler getInputConversionErrorHandler() { + return this.inputConversionErrorHandler; + } + + /** + * @param inputConversionErrorHandler + * The {@link IEditErrorHandler} that is should be used for showing + * conversion errors on typing into this editor. + */ + public void setInputConversionErrorHandler(IEditErrorHandler inputConversionErrorHandler) { + this.inputConversionErrorHandler = inputConversionErrorHandler; + } + + /** + * @return The {@link IEditErrorHandler} that is used for showing validation errors on typing into + * this editor. By default this is the {@link RenderErrorHandling} which will render the + * content in the editor red to indicate a validation error. + */ + public IEditErrorHandler getInputValidationErrorHandler() { + return this.inputValidationErrorHandler; + } + + /** + * @param inputValidationErrorHandler + * The {@link IEditErrorHandler} that is should used for showing + * validation errors on typing into this editor. + */ + public void setInputValidationErrorHandler(IEditErrorHandler inputValidationErrorHandler) { + this.inputValidationErrorHandler = inputValidationErrorHandler; + } +} diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/listener/NatTableDropListener.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/listener/NatTableDropListener.java index ee8754c0734..1ea0f87088c 100644 --- a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/listener/NatTableDropListener.java +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/listener/NatTableDropListener.java @@ -73,12 +73,13 @@ public class NatTableDropListener implements DropTargetListener { public void dragEnter(final DropTargetEvent event) { //nothing to do } -/** - * - * @see org.eclipse.swt.dnd.DropTargetListener#dragLeave(org.eclipse.swt.dnd.DropTargetEvent) - * - * @param event - */ + + /** + * + * @see org.eclipse.swt.dnd.DropTargetListener#dragLeave(org.eclipse.swt.dnd.DropTargetEvent) + * + * @param event + */ public void dragLeave(final DropTargetEvent event) { //nothing to do } @@ -86,7 +87,7 @@ public class NatTableDropListener implements DropTargetListener { /** * * @see org.eclipse.swt.dnd.DropTargetListener#dragOperationChanged(org.eclipse.swt.dnd.DropTargetEvent) - * + * * @param event */ public void dragOperationChanged(final DropTargetEvent event) { @@ -96,7 +97,7 @@ public class NatTableDropListener implements DropTargetListener { /** * * @see org.eclipse.swt.dnd.DropTargetListener#dragOver(org.eclipse.swt.dnd.DropTargetEvent) - * + * * @param event */ public void dragOver(final DropTargetEvent event) { @@ -107,6 +108,9 @@ public class NatTableDropListener implements DropTargetListener { if(data instanceof IStructuredSelection) { structuredSelection = (IStructuredSelection)data; } + if(structuredSelection == null) { + return; + } final List droppedElements = new ArrayList((Collection)structuredSelection.toList()); this.dropKindValue = this.manager.getLocationInTheTable(new Point(event.x, event.y)); int drop = DND.DROP_NONE; @@ -189,7 +193,7 @@ public class NatTableDropListener implements DropTargetListener { /** * * @see org.eclipse.swt.dnd.DropTargetListener#drop(org.eclipse.swt.dnd.DropTargetEvent) - * + * * @param event */ public void drop(final DropTargetEvent event) { @@ -198,7 +202,7 @@ public class NatTableDropListener implements DropTargetListener { Object data = localTransfer.nativeToJava(event.currentDataType); if(data instanceof StructuredSelection) { final IStructuredSelection selection = (IStructuredSelection)data; - final List< Object> droppedElements = new ArrayList((Collection)selection.toList()); + final List droppedElements = new ArrayList((Collection)selection.toList()); if(this.dropKindValue != null) { switch(this.dropKindValue.getKind()) { case AFTER_COLUMN_HEADER: diff --git a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/manager/table/NattableModelManager.java b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/manager/table/NattableModelManager.java index b3166a86baa..98d45525bbe 100644 --- a/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/manager/table/NattableModelManager.java +++ b/plugins/infra/nattable/org.eclipse.papyrus.infra.nattable/src/org/eclipse/papyrus/infra/nattable/manager/table/NattableModelManager.java @@ -396,7 +396,7 @@ public class NattableModelManager extends AbstractNattableWidgetManager implemen updateToggleCommandState(command, getTable().isInvertAxis()); } else { - throw new RuntimeException(String.format("The Eclipse service {0} has not been found", ICommandService.class)); //$NON-NLS-1$ + throw new RuntimeException(String.format("The Eclipse service %s has not been found", ICommandService.class)); //$NON-NLS-1$ } } -- cgit v1.2.3