![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: EnumCellEditor$TargetToModelStrategy
EnumCellEditor$TargetToModelStrategy
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| EnumCellEditor.TargetToModelStrategy(EnumCellEditor) |
|
|
|
|
|
||||||||||||||||||||
| convert(Object) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2017 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Edgar Mueller - initial API and implementation
13: *******************************************************************************/
14: package org.eclipse.emf.ecp.view.spi.table.swt;
15:
16: import org.eclipse.core.databinding.DataBindingContext;
17: import org.eclipse.core.databinding.UpdateValueStrategy;
18: import org.eclipse.core.databinding.observable.Diffs;
19: import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
20: import org.eclipse.core.databinding.observable.value.IObservableValue;
21: import org.eclipse.core.databinding.property.INativePropertyListener;
22: import org.eclipse.core.databinding.property.ISimplePropertyListener;
23: import org.eclipse.core.databinding.property.value.IValueProperty;
24: import org.eclipse.core.databinding.property.value.SimpleValueProperty;
25: import org.eclipse.emf.common.util.Enumerator;
26: import org.eclipse.emf.databinding.EMFUpdateValueStrategy;
27: import org.eclipse.emf.ecore.EAttribute;
28: import org.eclipse.emf.ecore.EEnum;
29: import org.eclipse.emf.ecore.EEnumLiteral;
30: import org.eclipse.emf.ecore.EStructuralFeature;
31: import org.eclipse.emf.ecp.edit.spi.swt.table.ECPEnumCellEditor;
32: import org.eclipse.emf.ecp.view.internal.core.swt.ComboUtil;
33: import org.eclipse.emf.ecp.view.internal.core.swt.MatchItemComboViewer;
34: import org.eclipse.emf.ecp.view.internal.table.swt.FigureUtilities;
35: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
36: import org.eclipse.emfforms.common.Optional;
37: import org.eclipse.jface.layout.GridDataFactory;
38: import org.eclipse.jface.viewers.ArrayContentProvider;
39: import org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent;
40: import org.eclipse.jface.viewers.ISelectionChangedListener;
41: import org.eclipse.jface.viewers.IStructuredSelection;
42: import org.eclipse.jface.viewers.LabelProvider;
43: import org.eclipse.jface.viewers.SelectionChangedEvent;
44: import org.eclipse.jface.viewers.StructuredSelection;
45: import org.eclipse.swt.SWT;
46: import org.eclipse.swt.custom.CCombo;
47: import org.eclipse.swt.graphics.Image;
48: import org.eclipse.swt.graphics.Point;
49: import org.eclipse.swt.widgets.Composite;
50: import org.eclipse.swt.widgets.Control;
51:
52: /**
53: * Generic {@link org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor ECPCellEditor} which is
54: * applicable for all {@link EAttribute EAttributes} with a Single {@link EEnum} data type.
55: *
56: * @since 1.13
57: * @deprecated Use {@link ItemProviderEnumCellEditor} instead
58: */
59: @Deprecated
60: public class EnumCellEditor extends ECPEnumCellEditor {
61:
62: private static final String EMPTY = ""; //$NON-NLS-1$
63: private EEnum eEnum;
64: private MatchItemComboViewer viewer;
65: private int minWidth;
66: private String text;
67: private EnumCellEditorLabelProvider labelProvider;
68:
69: /**
70: * Default constructor.
71: *
72: * @param parent the parent
73: */
74: public EnumCellEditor(Composite parent) {
75: super(parent);
76: }
77:
78: /**
79: * Constructor allowing to specify a SWT style.
80: *
81: * @param parent the parent
82: * @param style the SWT style
83: */
84: public EnumCellEditor(Composite parent, int style) {
85: super(parent, style);
86: }
87:
88: /**
89: *
90: * {@inheritDoc}
91: *
92: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getValueProperty()
93: */
94: @Override
95: public IValueProperty getValueProperty() {
96: return new ComboValueProperty();
97: }
98:
99: /**
100: *
101: * {@inheritDoc}
102: *
103: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#instantiate(org.eclipse.emf.ecore.EStructuralFeature,
104: * org.eclipse.emf.ecp.view.spi.context.ViewModelContext)
105: */
106: @Override
107: public void instantiate(EStructuralFeature feature, ViewModelContext viewModelContext) {
108:
109: final EAttribute attribute = EAttribute.class.cast(feature);
110: eEnum = EEnum.class.cast(attribute.getEAttributeType());
111: final int literalsSize = getELiterals().size();
112: viewer.getCCombo().setVisibleItemCount(literalsSize <= 25 ? literalsSize : 25);
113: final Point emptyViewerSize = viewer.getCCombo().computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
114: minWidth = 50;
115: for (final EEnumLiteral literal : getELiterals()) {
116: final String string = literal.getInstance().getLiteral();
117: final int newWidth = FigureUtilities.getTextWidth(string, viewer.getCCombo().getFont());
118: if (newWidth > minWidth) {
119: minWidth = newWidth;
120: }
121: }
122: minWidth += emptyViewerSize.x;
123: }
124:
125: /**
126: *
127: * {@inheritDoc}
128: *
129: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getFormatedString(java.lang.Object)
130: */
131: @Override
132: public String getFormatedString(Object value) {
133: if (value != null) {
134: final Enumerator enumerator = (Enumerator) value;
135: return enumerator.getLiteral();
136: }
137: return EMPTY;
138: }
139:
140: /**
141: *
142: * {@inheritDoc}
143: *
144: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getColumnWidthWeight()
145: */
146: @Override
147: public int getColumnWidthWeight() {
148: return 100;
149: }
150:
151: /**
152: * {@inheritDoc}
153: *
154: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getMinWidth()
155: */
156: @Override
157: public int getMinWidth() {
158: return minWidth;
159: }
160:
161: /**
162: * {@inheritDoc}
163: *
164: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getImage(java.lang.Object)
165: */
166: @Override
167: public Image getImage(Object value) {
168: return null;
169: }
170:
171: /**
172: *
173: * {@inheritDoc}
174: *
175: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getTargetToModelStrategy(org.eclipse.core.databinding.DataBindingContext)
176: */
177: @Override
178: public UpdateValueStrategy getTargetToModelStrategy(DataBindingContext databindingContext) {
179: return new TargetToModelStrategy();
180: }
181:
182: /**
183: *
184: * {@inheritDoc}
185: *
186: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#getModelToTargetStrategy(org.eclipse.core.databinding.DataBindingContext)
187: */
188: @Override
189: public UpdateValueStrategy getModelToTargetStrategy(DataBindingContext databindingContext) {
190: return new ModelToTargetStrategy();
191: }
192:
193: /**
194: *
195: * {@inheritDoc}
196: *
197: * @see org.eclipse.jface.viewers.CellEditor#getLayoutData()
198: */
199: @Override
200: public LayoutData getLayoutData() {
201: final LayoutData data = new LayoutData();
202: data.minimumWidth = 0;
203: return data;
204: }
205:
206: /**
207: *
208: * {@inheritDoc}
209: *
210: * @see org.eclipse.emf.ecp.edit.spi.swt.table.ECPCellEditor#setEditable(boolean)
211: */
212: @Override
213: public void setEditable(boolean editable) {
214: viewer.getCCombo().setEnabled(editable);
215: }
216:
217: /**
218: * {@inheritDoc}
219: *
220: * @see org.eclipse.jface.viewers.CellEditor#createControl(org.eclipse.swt.widgets.Composite)
221: */
222: @Override
223: protected Control createControl(Composite parent) {
224: viewer = new MatchItemComboViewer(new CCombo(parent, SWT.NONE)) {
225: @Override
226: public void onEnter() {
227: final int selectedIndex = ComboUtil.getClosestMatchIndex(getCCombo().getItems(),
228: getBuffer().asString());
229: if (!getBuffer().isEmpty() && selectedIndex > -1) {
230: final String closestMatch = getCCombo().getItems()[selectedIndex];
231: final Optional<SelectedEnumeratorMapping> selectedMappping = SelectedEnumeratorMapping
232: .findLiteral((SelectedEnumeratorMapping[]) getInput(), closestMatch);
233: if (selectedMappping.isPresent()) {
234: setSelection(new StructuredSelection(selectedMappping.get()));
235: }
236:
237: } else {
238: setClosestMatch(getCCombo().getText());
239: }
240:
241: focusLost();
242: }
243:
244: /**
245: * {@inheritDoc}
246: *
247: * @see org.eclipse.emf.ecp.view.internal.core.swt.MatchItemComboViewer#onEscape()
248: */
249: @Override
250: protected void onEscape() {
251: EnumCellEditor.this.fireCancelEditor();
252: }
253: };
254:
255: final CCombo combo = viewer.getCCombo();
256:
257: GridDataFactory.fillDefaults().grab(true, false).applyTo(combo);
258: labelProvider = new EnumCellEditorLabelProvider();
259: viewer.setContentProvider(ArrayContentProvider.getInstance());
260: viewer.setLabelProvider(labelProvider);
261: return combo;
262: }
263:
264: /**
265: * {@inheritDoc}
266: *
267: * @see org.eclipse.jface.viewers.CellEditor#doGetValue()
268: */
269: @Override
270: protected Object doGetValue() {
271: return viewer.getInput();
272: }
273:
274: /**
275: * {@inheritDoc}
276: *
277: * @see org.eclipse.jface.viewers.CellEditor#doSetFocus()
278: */
279: @Override
280: protected void doSetFocus() {
281: final CCombo combo = viewer.getCCombo();
282: if (combo == null || combo.isDisposed()) {
283: return;
284: }
285: combo.setFocus();
286: // Remove text selection and move the cursor to the end.
287: final String text = combo.getText();
288: if (text != null) {
289: combo.setSelection(new Point(text.length(), text.length()));
290: }
291: }
292:
293: /**
294: *
295: * {@inheritDoc}
296: *
297: * @see org.eclipse.jface.viewers.CellEditor#activate(org.eclipse.jface.viewers.ColumnViewerEditorActivationEvent)
298: */
299: @Override
300: public void activate(ColumnViewerEditorActivationEvent actEvent) {
301: super.activate(actEvent);
302: if (actEvent.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED) {
303: final CCombo control = (CCombo) getControl();
304: if (control != null && Character.isLetterOrDigit(actEvent.character)) {
305: viewer.getBuffer().reset();
306: // key pressed is not fired during activation
307: viewer.getBuffer().addLast(actEvent.character);
308: }
309: }
310: }
311:
312: /**
313: * {@inheritDoc}
314: *
315: * @see org.eclipse.jface.viewers.CellEditor#deactivate()
316: */
317: @Override
318: public void deactivate() {
319: final CCombo control = (CCombo) getControl();
320:
321: if (control != null && !control.isDisposed()) {
322: text = control.getText();
323: text = text == null ? EMPTY : text;
324: }
325:
326: final SelectedEnumeratorMapping[] selectedMapping = (SelectedEnumeratorMapping[]) viewer.getInput();
327: if (selectedMapping != null) {
328: final Optional<SelectedEnumeratorMapping> sel = SelectedEnumeratorMapping.findLiteral(selectedMapping,
329: text);
330: if (sel.isPresent()) {
331: sel.get().setSelected(true);
332: viewer.setSelection(new StructuredSelection(sel.get()));
333: }
334: }
335:
336: text = EMPTY;
337: viewer.getBuffer().reset();
338:
339: // As the same cell editor is used for all the rows.
340: // We need to reset the value to avoid the values are cached.
341: if (control != null && !control.isDisposed()) {
342: control.setText(""); //$NON-NLS-1$
343: }
344: super.deactivate();
345: }
346:
347: /**
348: * {@inheritDoc}
349: *
350: * @see org.eclipse.jface.viewers.CellEditor#doSetValue(java.lang.Object)
351: */
352: @Override
353: protected void doSetValue(Object value) {
354: viewer.setInput(value);
355: }
356:
357: private String getComboText(SelectedEnumeratorMapping[] input) {
358: final Optional<Enumerator> selected = SelectedEnumeratorMapping.findSelected(input);
359: if (selected.isPresent()) {
360: return selected.get().getLiteral();
361: }
362: return EMPTY;
363: }
364:
365: /**
366: * Returns the {@link EEnum} is cell editor responsible for.
367: *
368: * @return the enum
369: */
370: @Override
371: public EEnum getEEnum() {
372: return eEnum;
373: }
374:
375: /**
376: * Label provider for the drop down.
377: *
378: *
379: */
380: private class EnumCellEditorLabelProvider extends LabelProvider {
381:
382: /**
383: * {@inheritDoc}
384: *
385: * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
386: */
387: @Override
388: public String getText(Object element) {
389: final SelectedEnumeratorMapping mapping = (SelectedEnumeratorMapping) element;
390: return mapping.getEnumerator().getLiteral();
391: }
392: }
393:
394: /**
395: * Target to model update strategy.
396: *
397: *
398: */
399: private class TargetToModelStrategy extends EMFUpdateValueStrategy {
400: /*
401: * (non-Javadoc)
402: * @see org.eclipse.core.databinding.UpdateValueStrategy#convert(java.lang.Object)
403: */
404: @Override
405: public Object convert(Object value) {
406: final SelectedEnumeratorMapping[] mapping = (SelectedEnumeratorMapping[]) value;
407: final Optional<Enumerator> selected = SelectedEnumeratorMapping.findSelected(mapping);
408: return selected.orNull();
409: }
410: }
411:
412: /**
413: * Model to target update strategy.
414: *
415: *
416: */
417: private class ModelToTargetStrategy extends EMFUpdateValueStrategy {
418:
419: @Override
420: public Object convert(Object value) {
421: final Enumerator enumerator = (Enumerator) value;
422: final SelectedEnumeratorMapping[] mapping = SelectedEnumeratorMapping.createFromList(getELiterals());
423: SelectedEnumeratorMapping.select(mapping, enumerator);
424: return mapping;
425: }
426: }
427:
428: /**
429: * Value property working on the combo.
430: *
431: */
432: private class ComboValueProperty extends SimpleValueProperty {
433:
434: @Override
435: public Object getValueType() {
436: return CCombo.class;
437: }
438:
439: @Override
440: protected Object doGetValue(Object source) {
441: return EnumCellEditor.this.getValue();
442: }
443:
444: @Override
445: protected void doSetValue(Object source, Object value) {
446:
447: EnumCellEditor.this.doSetValue(value);
448: }
449:
450: @Override
451: public IObservableValue observe(Object source) {
452: return new ComboObservableValue();
453: }
454:
455: @Override
456: public INativePropertyListener adaptListener(ISimplePropertyListener listener) {
457: return null;
458: }
459: }
460:
461: /**
462: * Observable value for the combo.
463: *
464: */
465: private class ComboObservableValue extends AbstractObservableValue {
466:
467: private final EnumSelectionAdapter selectionAdapter;
468:
469: /**
470: * Default Constructor.
471: */
472: ComboObservableValue() {
473: selectionAdapter = new EnumSelectionAdapter();
474: viewer.addSelectionChangedListener(selectionAdapter);
475: }
476:
477: /**
478: * {@inheritDoc}
479: *
480: * @see org.eclipse.core.databinding.observable.value.IObservableValue#getValueType()
481: */
482: @Override
483: public Object getValueType() {
484: return null;
485: }
486:
487: /**
488: * {@inheritDoc}
489: *
490: * @see org.eclipse.core.databinding.observable.value.AbstractObservableValue#doGetValue()
491: */
492: @Override
493: protected Object doGetValue() {
494: return viewer.getInput();
495: }
496:
497: /**
498: * {@inheritDoc}
499: *
500: * @see org.eclipse.core.databinding.observable.value.AbstractObservableValue#doSetValue(java.lang.Object)
501: */
502: @Override
503: protected void doSetValue(Object value) {
504: viewer.setInput(value);
505: viewer.getCCombo().setText(getComboText((SelectedEnumeratorMapping[]) value));
506: }
507:
508: /**
509: * {@inheritDoc}
510: *
511: * @see org.eclipse.core.databinding.observable.AbstractObservable#dispose()
512: */
513: @Override
514: public synchronized void dispose() {
515: viewer.removeSelectionChangedListener(selectionAdapter);
516: super.dispose();
517: }
518:
519: /**
520: * Selection adapter for the combo.
521: *
522: *
523: */
524: private class EnumSelectionAdapter implements ISelectionChangedListener {
525:
526: @Override
527: public void selectionChanged(SelectionChangedEvent event) {
528: final SelectedEnumeratorMapping mapping = (SelectedEnumeratorMapping) ((IStructuredSelection) event
529: .getSelection())
530: .getFirstElement();
531: if (mapping == null) {
532: return;
533: }
534: final SelectedEnumeratorMapping[] allMapping = (SelectedEnumeratorMapping[]) viewer.getInput();
535: SelectedEnumeratorMapping.deselectAll(allMapping);
536: mapping.setSelected(!mapping.isSelected());
537: viewer.getCCombo().setText(getComboText((SelectedEnumeratorMapping[]) viewer.getInput()));
538: viewer.update(mapping, null);
539: fireValueChange(Diffs.createValueDiff(!mapping.isSelected(), mapping.isSelected()));
540: }
541: }
542: }
543: }