Skip to main content
aboutsummaryrefslogtreecommitdiffstats
blob: 372bad0d32638cda0940461799bfcfe3985c0a89 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/*****************************************************************************
 * Copyright (c) 2010 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:
 *  Remi Schnekenburger (CEA LIST) remi.schnekenburger@cea.fr - Initial API and implementation
 *****************************************************************************/
package org.eclipse.papyrus.properties.runtime.controller;

import java.util.List;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.papyrus.properties.runtime.Activator;
import org.eclipse.papyrus.properties.runtime.controller.descriptor.IPropertyEditorControllerDescriptor;
import org.eclipse.papyrus.properties.runtime.propertyeditor.AbstractPropertyEditor;
import org.eclipse.papyrus.properties.runtime.propertyeditor.PropertyEditorService;
import org.eclipse.papyrus.properties.runtime.propertyeditor.descriptor.IPropertyEditorDescriptor;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.services.IDisposable;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetWidgetFactory;


/**
 * Controller for property editors
 */
public abstract class PropertyEditorController implements IDisposable, IPropertyEditorController {

	/** objects to edit */
	protected List<? extends Object> objectToEdit;

	/** parent composite for the viewer */
	protected Composite composite;

	/** property editor */
	protected AbstractPropertyEditor propertyEditor;

	/**
	 * Creates a new {@link PropertyEditorController}
	 */
	public PropertyEditorController() {
	}

	/**
	 * {@inheritDoc}
	 */
	public void setObjectsToEdit(List<? extends Object> objectToEdit) {
		assert (objectToEdit != null && !objectToEdit.isEmpty()) : "List of object to edit should be neither null nor empty";
		this.objectToEdit = objectToEdit;
		addListenersToModel();
	}

	/**
	 * {@inheritDoc}
	 */
	public void changeObjectsToEdit(List<? extends Object> objectToEdit) {
		removeListenersFromModel();
		setObjectsToEdit(objectToEdit);
	}

	/**
	 * {@inheritDoc}
	 */
	public void setParent(Composite composite) {
		this.composite = composite;
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean acceptMultiSelection() {
		return true;
	}

	/**
	 * Returns the property editor associated to this controller
	 * 
	 * @return the propertyEditor controlled by this controller
	 */
	public AbstractPropertyEditor getPropertyEditor() {
		return propertyEditor;
	}

	/**
	 * Sets the property editor associated to this controller
	 * 
	 * @param propertyEditor
	 *        the property editor to set
	 */
	protected void setPropertyEditor(AbstractPropertyEditor propertyEditor) {
		this.propertyEditor = propertyEditor;
	}

	/**
	 * Returns the object to edit.
	 * <P>
	 * In case of a property editor that edits the name of a named element, the object to edit is the named element.
	 * </P>
	 * 
	 * @return the object to edit
	 */
	public List<? extends Object> getObjectsToEdit() {
		return objectToEdit;
	}

	/**
	 * Returns the parent composite of controls created by the property editor
	 * 
	 * @return the composite parent of controls of the property editor
	 */
	protected Composite getComposite() {
		return composite;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @param widgetFactory
	 */
	public void createPropertyEditor(IPropertyEditorDescriptor descriptor, TabbedPropertySheetWidgetFactory widgetFactory) {
		setPropertyEditor(PropertyEditorService.getInstance().createPropertyEditor(this, descriptor.getEditorId(), widgetFactory));
		IStatus status = initPropertyEditor(descriptor);
		if(IStatus.ERROR != status.getSeverity()) {
			getPropertyEditor().createContent(getComposite());
		} else {
			Activator.log.error("Could not create the property editor because of initialisation issues.", null);
		}
		refreshDisplay();
	}

	/**
	 * Returns the default label for the property editor
	 * 
	 * @return the default label for the property editor
	 */
	protected abstract String getDefaultLabel();

	/**
	 * Initializes the content of the property editor, in case the property editor contains enumeration or references for example
	 * 
	 * @param descriptor
	 *        the descriptor of the editor
	 * @return the status of the initialization
	 */
	protected abstract IStatus initPropertyEditor(IPropertyEditorDescriptor descriptor);

	/**
	 * {@inheritDoc}
	 */
	public abstract IStatus initController(Composite parent, List<Object> objectsToEdit, IPropertyEditorControllerDescriptor descriptor);

	/**
	 * Sets the value of the property in the model
	 * 
	 * @param value
	 *        the value to set
	 */
	protected abstract void setValueInModel(Object value);

	/**
	 * Returns the value currently in the property editor
	 * 
	 * @return the current value in the property editor
	 */
	protected Object getEditorValue() {
		if(isValid(getPropertyEditor())) {
			return getPropertyEditor().getValue();
		}
		return null;
	}

	/**
	 * Check if the proeprty editor is valid
	 * 
	 * @param propertyEditor
	 *        the editor to check
	 * @return <code>true</code> if the editor is not <code>null</code> and not disposed
	 */
	protected boolean isValid(AbstractPropertyEditor propertyEditor) {
		return getPropertyEditor() != null && !getPropertyEditor().isDisposed();
	}

	/**
	 * {@inheritDoc}
	 */
	public void refreshDisplay() {
		if(isValid(getPropertyEditor())) {
			getPropertyEditor().setValue(getValueToEdit());
		}
	}

	/**
	 * Returns the value of the property to edit, found in the model
	 * 
	 * @return the value of the property to edit
	 */
	protected abstract Object getValueToEdit();

	/**
	 * Adds listener in the model to have notification when the model changes and that the editor should be updated
	 */
	protected abstract void addListenersToModel();

	/**
	 * Removes listener in the model to have notification when the model changes. It should be the mirror of {@link #addListenersToModel()}
	 */
	protected abstract void removeListenersFromModel();

	/**
	 * Performs the action of updating the model.
	 */
	public abstract void updateModel();

	/**
	 * {@inheritDoc}
	 */
	public void dispose() {
		// remove added listeners
		removeListenersFromModel();

		// dispose the composite created by the property editor
		if(getPropertyEditor() != null) {
			getPropertyEditor().dispose();
		}
		setPropertyEditor(null);
	}
}

Back to the top