diff options
Diffstat (limited to 'tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java')
| -rw-r--r-- | tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java | 418 |
1 files changed, 395 insertions, 23 deletions
diff --git a/tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java b/tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java index a15589d5a..75157aa43 100644 --- a/tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java +++ b/tests/org.eclipse.emf.eef.tests.nonreg.edit/src-gen/org/eclipse/emf/eef/eefnr/filters/parts/forms/ConcreteReferenceOwnerSamplePropertiesEditionPartForm.java @@ -16,68 +16,57 @@ import java.util.Iterator; import java.util.List; import org.eclipse.emf.ecore.EObject; - +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider; import org.eclipse.emf.eef.eefnr.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart; import org.eclipse.emf.eef.eefnr.filters.parts.FiltersViewsRepository; - import org.eclipse.emf.eef.eefnr.filters.providers.FiltersMessages; - import org.eclipse.emf.eef.runtime.api.component.IPropertiesEditionComponent; - import org.eclipse.emf.eef.runtime.api.notify.IPropertiesEditionEvent; - import org.eclipse.emf.eef.runtime.api.parts.IFormPropertiesEditionPart; - import org.eclipse.emf.eef.runtime.context.impl.EObjectPropertiesEditionContext; - import org.eclipse.emf.eef.runtime.impl.notify.PropertiesEditionEvent; - import org.eclipse.emf.eef.runtime.part.impl.SectionPropertiesEditingPart; - import org.eclipse.emf.eef.runtime.policies.PropertiesEditingPolicy; - import org.eclipse.emf.eef.runtime.providers.PropertiesEditingProvider; - import org.eclipse.emf.eef.runtime.ui.parts.PartComposer; - import org.eclipse.emf.eef.runtime.ui.parts.sequence.BindingCompositionSequence; import org.eclipse.emf.eef.runtime.ui.parts.sequence.CompositionSequence; import org.eclipse.emf.eef.runtime.ui.parts.sequence.CompositionStep; - import org.eclipse.emf.eef.runtime.ui.utils.EditingUtils; - import org.eclipse.emf.eef.runtime.ui.widgets.FormUtils; import org.eclipse.emf.eef.runtime.ui.widgets.ReferencesTable; - import org.eclipse.emf.eef.runtime.ui.widgets.ReferencesTable.ReferencesTableListener; - import org.eclipse.emf.eef.runtime.ui.widgets.TabElementTreeSelectionDialog; - import org.eclipse.emf.eef.runtime.ui.widgets.referencestable.ReferencesTableContentProvider; import org.eclipse.emf.eef.runtime.ui.widgets.referencestable.ReferencesTableSettings; - +import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.ILabelProviderListener; import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.TableViewer; import org.eclipse.jface.viewers.ViewerFilter; - import org.eclipse.swt.SWT; - import org.eclipse.swt.events.FocusAdapter; import org.eclipse.swt.events.FocusEvent; import org.eclipse.swt.events.KeyAdapter; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; - +import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; - +import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.TableColumn; import org.eclipse.swt.widgets.Text; - import org.eclipse.ui.forms.widgets.Form; import org.eclipse.ui.forms.widgets.FormToolkit; import org.eclipse.ui.forms.widgets.ScrolledForm; import org.eclipse.ui.forms.widgets.Section; +import org.eclipse.ui.views.properties.tabbed.ISection; // End of user code @@ -94,6 +83,15 @@ public class ConcreteReferenceOwnerSamplePropertiesEditionPartForm extends Secti protected ReferencesTable strictTyping; protected List<ViewerFilter> strictTypingBusinessFilters = new ArrayList<ViewerFilter>(); protected List<ViewerFilter> strictTypingFilters = new ArrayList<ViewerFilter>(); + protected TableViewer strictTypingMultipleOnTableComposition; + protected List<ViewerFilter> strictTypingMultipleOnTableCompositionBusinessFilters = new ArrayList<ViewerFilter>(); + protected List<ViewerFilter> strictTypingMultipleOnTableCompositionFilters = new ArrayList<ViewerFilter>(); + protected Button addStrictTypingMultipleOnTableComposition; + protected Button removeStrictTypingMultipleOnTableComposition; + protected Button editStrictTypingMultipleOnTableComposition; + protected ReferencesTable strictTypingMultipleOnAdvancedTableComposition; + protected List<ViewerFilter> strictTypingMultipleOnAdvancedTableCompositionBusinessFilters = new ArrayList<ViewerFilter>(); + protected List<ViewerFilter> strictTypingMultipleOnAdvancedTableCompositionFilters = new ArrayList<ViewerFilter>(); @@ -142,6 +140,8 @@ public class ConcreteReferenceOwnerSamplePropertiesEditionPartForm extends Secti propertiesStep.addStep(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.name); propertiesStep.addStep(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.abstractTarget); propertiesStep.addStep(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTyping); + propertiesStep.addStep(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + propertiesStep.addStep(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition); composer = new PartComposer(concreteReferenceOwnerSampleStep) { @@ -160,6 +160,12 @@ public class ConcreteReferenceOwnerSamplePropertiesEditionPartForm extends Secti if (key == FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTyping) { return createStrictTypingTableComposition(widgetFactory, parent); } + if (key == FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition) { + return createStrictTypingMultipleOnTableCompositionTableComposition(widgetFactory, parent); + } + if (key == FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition) { + return createStrictTypingMultipleOnAdvancedTableCompositionTableComposition(widgetFactory, parent); + } return parent; } }; @@ -385,6 +391,231 @@ public class ConcreteReferenceOwnerSamplePropertiesEditionPartForm extends Secti return parent; } + /** + * @param container + * + */ + protected Composite createStrictTypingMultipleOnTableCompositionTableComposition(FormToolkit widgetFactory, Composite container) { + Composite tableContainer = widgetFactory.createComposite(container, SWT.NONE); + GridLayout tableContainerLayout = new GridLayout(); + GridData tableContainerData = new GridData(GridData.FILL_BOTH); + tableContainerData.horizontalSpan = 3; + tableContainer.setLayoutData(tableContainerData); + tableContainerLayout.numColumns = 2; + tableContainer.setLayout(tableContainerLayout); + org.eclipse.swt.widgets.Table tableStrictTypingMultipleOnTableComposition = widgetFactory.createTable(tableContainer, SWT.FULL_SELECTION | SWT.BORDER); + tableStrictTypingMultipleOnTableComposition.setHeaderVisible(true); + GridData gdStrictTypingMultipleOnTableComposition = new GridData(); + gdStrictTypingMultipleOnTableComposition.grabExcessHorizontalSpace = true; + gdStrictTypingMultipleOnTableComposition.horizontalAlignment = GridData.FILL; + gdStrictTypingMultipleOnTableComposition.grabExcessVerticalSpace = true; + gdStrictTypingMultipleOnTableComposition.verticalAlignment = GridData.FILL; + tableStrictTypingMultipleOnTableComposition.setLayoutData(gdStrictTypingMultipleOnTableComposition); + tableStrictTypingMultipleOnTableComposition.setLinesVisible(true); + + // Start of user code for columns definition for StrictTypingMultipleOnTableComposition + TableColumn name = new TableColumn(tableStrictTypingMultipleOnTableComposition, SWT.NONE); + name.setWidth(80); + name.setText("Label"); //$NON-NLS-1$ + // End of user code + + strictTypingMultipleOnTableComposition = new TableViewer(tableStrictTypingMultipleOnTableComposition); + strictTypingMultipleOnTableComposition.setContentProvider(new ArrayContentProvider()); + strictTypingMultipleOnTableComposition.setLabelProvider(new ITableLabelProvider() { + //Start of user code for label provider definition for StrictTypingMultipleOnTableComposition + public String getColumnText(Object object, int columnIndex) { + AdapterFactoryLabelProvider labelProvider = new AdapterFactoryLabelProvider(adapterFactory); + if (object instanceof EObject) { + switch (columnIndex) { + case 0: + return labelProvider.getText(object); + } + } + return ""; //$NON-NLS-1$ + } + + public Image getColumnImage(Object element, int columnIndex) { + return null; + } + + //End of user code + + public void addListener(ILabelProviderListener listener) { + } + + public void dispose() { + } + + public boolean isLabelProperty(Object element, String property) { + return false; + } + + public void removeListener(ILabelProviderListener listener) { + } + + }); + strictTypingMultipleOnTableComposition.getTable().addListener(SWT.MouseDoubleClick, new Listener(){ + + public void handleEvent(Event event) { + if (strictTypingMultipleOnTableComposition.getSelection() instanceof IStructuredSelection) { + IStructuredSelection selection = (IStructuredSelection) strictTypingMultipleOnTableComposition.getSelection(); + if (selection.getFirstElement() instanceof EObject) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.EDIT, null, selection.getFirstElement())); + strictTypingMultipleOnTableComposition.refresh(); + } + } + } + + }); + GridData strictTypingMultipleOnTableCompositionData = new GridData(GridData.FILL_HORIZONTAL); + strictTypingMultipleOnTableCompositionData.minimumHeight = 120; + strictTypingMultipleOnTableCompositionData.heightHint = 120; + strictTypingMultipleOnTableComposition.getTable().setLayoutData(strictTypingMultipleOnTableCompositionData); + for (ViewerFilter filter : this.strictTypingMultipleOnTableCompositionFilters) { + strictTypingMultipleOnTableComposition.addFilter(filter); + } + EditingUtils.setID(strictTypingMultipleOnTableComposition.getTable(), FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + EditingUtils.setEEFtype(strictTypingMultipleOnTableComposition.getTable(), "eef::TableComposition::field"); //$NON-NLS-1$ + createStrictTypingMultipleOnTableCompositionPanel(widgetFactory, tableContainer); + // Start of user code for createStrictTypingMultipleOnTableCompositionTableComposition + + // End of user code + return container; + } + + /** + * @param container + * + */ + protected Composite createStrictTypingMultipleOnTableCompositionPanel(FormToolkit widgetFactory, Composite container) { + Composite strictTypingMultipleOnTableCompositionPanel = widgetFactory.createComposite(container, SWT.NONE); + GridLayout strictTypingMultipleOnTableCompositionPanelLayout = new GridLayout(); + strictTypingMultipleOnTableCompositionPanelLayout.numColumns = 1; + strictTypingMultipleOnTableCompositionPanel.setLayout(strictTypingMultipleOnTableCompositionPanelLayout); + addStrictTypingMultipleOnTableComposition = widgetFactory.createButton(strictTypingMultipleOnTableCompositionPanel, FiltersMessages.PropertiesEditionPart_AddTableViewerLabel, SWT.NONE); + GridData addStrictTypingMultipleOnTableCompositionData = new GridData(GridData.FILL_HORIZONTAL); + addStrictTypingMultipleOnTableComposition.setLayoutData(addStrictTypingMultipleOnTableCompositionData); + addStrictTypingMultipleOnTableComposition.addSelectionListener(new SelectionAdapter() { + + /** + * {@inheritDoc} + * + * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent) + * + */ + public void widgetSelected(SelectionEvent e) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.ADD, null, null)); + strictTypingMultipleOnTableComposition.refresh(); + } + }); + EditingUtils.setID(addStrictTypingMultipleOnTableComposition, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + EditingUtils.setEEFtype(addStrictTypingMultipleOnTableComposition, "eef::TableComposition::addbutton"); //$NON-NLS-1$ + removeStrictTypingMultipleOnTableComposition = widgetFactory.createButton(strictTypingMultipleOnTableCompositionPanel, FiltersMessages.PropertiesEditionPart_RemoveTableViewerLabel, SWT.NONE); + GridData removeStrictTypingMultipleOnTableCompositionData = new GridData(GridData.FILL_HORIZONTAL); + removeStrictTypingMultipleOnTableComposition.setLayoutData(removeStrictTypingMultipleOnTableCompositionData); + removeStrictTypingMultipleOnTableComposition.addSelectionListener(new SelectionAdapter() { + + /** + * {@inheritDoc} + * + * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent) + * + */ + public void widgetSelected(SelectionEvent e) { + if (strictTypingMultipleOnTableComposition.getSelection() instanceof IStructuredSelection) { + IStructuredSelection selection = (IStructuredSelection) strictTypingMultipleOnTableComposition.getSelection(); + if (selection.getFirstElement() instanceof EObject) { + EObject selectedElement = (EObject) selection.getFirstElement(); + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition, PropertiesEditionEvent.CHANGE, PropertiesEditionEvent.REMOVE, null, selectedElement)); + strictTypingMultipleOnTableComposition.refresh(); + } + } + } + + }); + EditingUtils.setID(removeStrictTypingMultipleOnTableComposition, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + EditingUtils.setEEFtype(removeStrictTypingMultipleOnTableComposition, "eef::TableComposition::removebutton"); //$NON-NLS-1$ + editStrictTypingMultipleOnTableComposition = widgetFactory.createButton(strictTypingMultipleOnTableCompositionPanel, FiltersMessages.PropertiesEditionPart_EditTableViewerLabel, SWT.NONE); + GridData editStrictTypingMultipleOnTableCompositionData = new GridData(GridData.FILL_HORIZONTAL); + editStrictTypingMultipleOnTableComposition.setLayoutData(editStrictTypingMultipleOnTableCompositionData); + editStrictTypingMultipleOnTableComposition.addSelectionListener(new SelectionAdapter() { + + /** + * {@inheritDoc} + * + * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent) + * + */ + public void widgetSelected(SelectionEvent e) { + if (strictTypingMultipleOnTableComposition.getSelection() instanceof IStructuredSelection) { + IStructuredSelection selection = (IStructuredSelection) strictTypingMultipleOnTableComposition.getSelection(); + if (selection.getFirstElement() instanceof EObject) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.EDIT, null, selection.getFirstElement())); + strictTypingMultipleOnTableComposition.refresh(); + } + } + } + + }); + EditingUtils.setID(editStrictTypingMultipleOnTableComposition, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + EditingUtils.setEEFtype(editStrictTypingMultipleOnTableComposition, "eef::TableComposition::editbutton"); //$NON-NLS-1$ + // Start of user code for createStrictTypingMultipleOnTableCompositionPanel + + // End of user code + return strictTypingMultipleOnTableCompositionPanel; + } + + /** + * @param container + * + */ + protected Composite createStrictTypingMultipleOnAdvancedTableCompositionTableComposition(FormToolkit widgetFactory, Composite parent) { + this.strictTypingMultipleOnAdvancedTableComposition = new ReferencesTable(getDescription(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, FiltersMessages.ConcreteReferenceOwnerSamplePropertiesEditionPart_StrictTypingMultipleOnAdvancedTableCompositionLabel), new ReferencesTableListener() { + public void handleAdd() { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.ADD, null, null)); + strictTypingMultipleOnAdvancedTableComposition.refresh(); + } + public void handleEdit(EObject element) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.EDIT, null, element)); + strictTypingMultipleOnAdvancedTableComposition.refresh(); + } + public void handleMove(EObject element, int oldIndex, int newIndex) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.MOVE, element, newIndex)); + strictTypingMultipleOnAdvancedTableComposition.refresh(); + } + public void handleRemove(EObject element) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, PropertiesEditionEvent.COMMIT, PropertiesEditionEvent.REMOVE, null, element)); + strictTypingMultipleOnAdvancedTableComposition.refresh(); + } + public void navigateTo(EObject element) { } + }); + for (ViewerFilter filter : this.strictTypingMultipleOnAdvancedTableCompositionFilters) { + this.strictTypingMultipleOnAdvancedTableComposition.addFilter(filter); + } + this.strictTypingMultipleOnAdvancedTableComposition.setHelpText(propertiesEditionComponent.getHelpContent(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, FiltersViewsRepository.FORM_KIND)); + this.strictTypingMultipleOnAdvancedTableComposition.createControls(parent, widgetFactory); + this.strictTypingMultipleOnAdvancedTableComposition.addSelectionListener(new SelectionAdapter() { + + public void widgetSelected(SelectionEvent e) { + if (e.item != null && e.item.getData() instanceof EObject) { + propertiesEditionComponent.firePropertiesChanged(new PropertiesEditionEvent(ConcreteReferenceOwnerSamplePropertiesEditionPartForm.this, FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition, PropertiesEditionEvent.CHANGE, PropertiesEditionEvent.SELECTION_CHANGED, null, e.item.getData())); + } + } + + }); + GridData strictTypingMultipleOnAdvancedTableCompositionData = new GridData(GridData.FILL_HORIZONTAL); + strictTypingMultipleOnAdvancedTableCompositionData.horizontalSpan = 3; + this.strictTypingMultipleOnAdvancedTableComposition.setLayoutData(strictTypingMultipleOnAdvancedTableCompositionData); + this.strictTypingMultipleOnAdvancedTableComposition.setLowerBound(0); + this.strictTypingMultipleOnAdvancedTableComposition.setUpperBound(-1); + strictTypingMultipleOnAdvancedTableComposition.setID(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition); + strictTypingMultipleOnAdvancedTableComposition.setEEFType("eef::AdvancedTableComposition"); //$NON-NLS-1$ + // Start of user code for createStrictTypingMultipleOnAdvancedTableCompositionTableComposition + + // End of user code + return parent; + } + /** * {@inheritDoc} @@ -561,6 +792,147 @@ public class ConcreteReferenceOwnerSamplePropertiesEditionPartForm extends Secti + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#initStrictTypingMultipleOnTableComposition(EObject current, EReference containingFeature, EReference feature) + */ + public void initStrictTypingMultipleOnTableComposition(ReferencesTableSettings settings) { + if (current.eResource() != null && current.eResource().getResourceSet() != null) + this.resourceSet = current.eResource().getResourceSet(); + ReferencesTableContentProvider contentProvider = new ReferencesTableContentProvider(); + strictTypingMultipleOnTableComposition.setContentProvider(contentProvider); + strictTypingMultipleOnTableComposition.setInput(settings); + boolean eefElementEditorReadOnlyState = isReadOnly(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnTableComposition); + if (eefElementEditorReadOnlyState && strictTypingMultipleOnTableComposition.getTable().isEnabled()) { + strictTypingMultipleOnTableComposition.getTable().setEnabled(false); + strictTypingMultipleOnTableComposition.getTable().setToolTipText(FiltersMessages.ConcreteReferenceOwnerSample_ReadOnly); + addStrictTypingMultipleOnTableComposition.setEnabled(false); + addStrictTypingMultipleOnTableComposition.setToolTipText(FiltersMessages.ConcreteReferenceOwnerSample_ReadOnly); + removeStrictTypingMultipleOnTableComposition.setEnabled(false); + removeStrictTypingMultipleOnTableComposition.setToolTipText(FiltersMessages.ConcreteReferenceOwnerSample_ReadOnly); + editStrictTypingMultipleOnTableComposition.setEnabled(false); + editStrictTypingMultipleOnTableComposition.setToolTipText(FiltersMessages.ConcreteReferenceOwnerSample_ReadOnly); + } else if (!eefElementEditorReadOnlyState && !strictTypingMultipleOnTableComposition.getTable().isEnabled()) { + strictTypingMultipleOnTableComposition.getTable().setEnabled(true); + addStrictTypingMultipleOnTableComposition.setEnabled(true); + removeStrictTypingMultipleOnTableComposition.setEnabled(true); + editStrictTypingMultipleOnTableComposition.setEnabled(true); + } + + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#updateStrictTypingMultipleOnTableComposition() + * + */ + public void updateStrictTypingMultipleOnTableComposition() { + strictTypingMultipleOnTableComposition.refresh(); +} + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#addFilterStrictTypingMultipleOnTableComposition(ViewerFilter filter) + * + */ + public void addFilterToStrictTypingMultipleOnTableComposition(ViewerFilter filter) { + strictTypingMultipleOnTableCompositionFilters.add(filter); + if (this.strictTypingMultipleOnTableComposition != null) { + this.strictTypingMultipleOnTableComposition.addFilter(filter); + } + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#addBusinessFilterStrictTypingMultipleOnTableComposition(ViewerFilter filter) + * + */ + public void addBusinessFilterToStrictTypingMultipleOnTableComposition(ViewerFilter filter) { + strictTypingMultipleOnTableCompositionBusinessFilters.add(filter); + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#isContainedInStrictTypingMultipleOnTableCompositionTable(EObject element) + * + */ + public boolean isContainedInStrictTypingMultipleOnTableCompositionTable(EObject element) { + return ((ReferencesTableSettings)strictTypingMultipleOnTableComposition.getInput()).contains(element); + } + + + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#initStrictTypingMultipleOnAdvancedTableComposition(EObject current, EReference containingFeature, EReference feature) + */ + public void initStrictTypingMultipleOnAdvancedTableComposition(ReferencesTableSettings settings) { + if (current.eResource() != null && current.eResource().getResourceSet() != null) + this.resourceSet = current.eResource().getResourceSet(); + ReferencesTableContentProvider contentProvider = new ReferencesTableContentProvider(); + strictTypingMultipleOnAdvancedTableComposition.setContentProvider(contentProvider); + strictTypingMultipleOnAdvancedTableComposition.setInput(settings); + boolean eefElementEditorReadOnlyState = isReadOnly(FiltersViewsRepository.ConcreteReferenceOwnerSample.Properties.strictTypingMultipleOnAdvancedTableComposition); + if (eefElementEditorReadOnlyState && strictTypingMultipleOnAdvancedTableComposition.isEnabled()) { + strictTypingMultipleOnAdvancedTableComposition.setEnabled(false); + strictTypingMultipleOnAdvancedTableComposition.setToolTipText(FiltersMessages.ConcreteReferenceOwnerSample_ReadOnly); + } else if (!eefElementEditorReadOnlyState && !strictTypingMultipleOnAdvancedTableComposition.isEnabled()) { + strictTypingMultipleOnAdvancedTableComposition.setEnabled(true); + } + + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#updateStrictTypingMultipleOnAdvancedTableComposition() + * + */ + public void updateStrictTypingMultipleOnAdvancedTableComposition() { + strictTypingMultipleOnAdvancedTableComposition.refresh(); +} + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#addFilterStrictTypingMultipleOnAdvancedTableComposition(ViewerFilter filter) + * + */ + public void addFilterToStrictTypingMultipleOnAdvancedTableComposition(ViewerFilter filter) { + strictTypingMultipleOnAdvancedTableCompositionFilters.add(filter); + if (this.strictTypingMultipleOnAdvancedTableComposition != null) { + this.strictTypingMultipleOnAdvancedTableComposition.addFilter(filter); + } + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#addBusinessFilterStrictTypingMultipleOnAdvancedTableComposition(ViewerFilter filter) + * + */ + public void addBusinessFilterToStrictTypingMultipleOnAdvancedTableComposition(ViewerFilter filter) { + strictTypingMultipleOnAdvancedTableCompositionBusinessFilters.add(filter); + } + + /** + * {@inheritDoc} + * + * @see org.eclipse.emf.eef.filters.parts.ConcreteReferenceOwnerSamplePropertiesEditionPart#isContainedInStrictTypingMultipleOnAdvancedTableCompositionTable(EObject element) + * + */ + public boolean isContainedInStrictTypingMultipleOnAdvancedTableCompositionTable(EObject element) { + return ((ReferencesTableSettings)strictTypingMultipleOnAdvancedTableComposition.getInput()).contains(element); + } + + + |