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
231
232
233
234
235
236
237
238
239
240
241
|
/*******************************************************************************
* Copyright (c) 2006, 2008 IBM Corporation 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:
* IBM Corporation - initial API and implementation
* Matthew Hall - bugs 206839, 124684, 239302, 245647, 194734, 195222,
* 264286
*******************************************************************************/
package org.eclipse.jface.databinding.viewers;
import org.eclipse.core.databinding.observable.Observables;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.internal.databinding.viewers.ViewerObservableValueDecorator;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckable;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
/**
* Factory methods for creating observables for JFace viewers
*
* @since 1.1
*/
public class ViewersObservables {
private static void checkNull(Object obj) {
if (obj == null)
throw new IllegalArgumentException();
}
/**
* Returns an observable which delays notification of value change events
* from <code>observable</code> until <code>delay</code> milliseconds have
* passed since the last change event, or until a FocusOut event is received
* from the underlying viewer control (whichever happens earlier). This
* class helps to delay validation until the user stops changing the value
* (e.g. until a user stops changing a viewer selection). To notify about
* pending changes, the returned observable value will fire a stale event
* when the wrapped observable value fires a change event, but this change
* is being delayed.
*
* @param delay
* the delay in milliseconds
* @param observable
* the observable being delayed
* @return an observable which delays notification of value change events
* from <code>observable</code> until <code>delay</code>
* milliseconds have passed since the last change event.
*
* @since 1.3
*/
public static IViewerObservableValue observeDelayedValue(int delay,
IViewerObservableValue observable) {
return new ViewerObservableValueDecorator(Observables
.observeDelayedValue(delay, observable), observable.getViewer());
}
/**
* Returns an observable value that tracks the current selection of the
* given selection provider. If the selection provider provides selections
* of type {@link IStructuredSelection}, the observable value will be the
* first element of the structured selection as returned by
* {@link IStructuredSelection#getFirstElement()}.
*
* @param selectionProvider
* @return the observable value tracking the (single) selection of the given
* selection provider
*/
public static IObservableValue observeSingleSelection(
ISelectionProvider selectionProvider) {
checkNull(selectionProvider);
return ViewerProperties.singleSelection().observe(selectionProvider);
}
/**
* Returns an observable list that tracks the current selection of the given
* selection provider. Assumes that the selection provider provides
* selections of type {@link IStructuredSelection}. Note that the observable
* list will not honor the full contract of <code>java.util.List</code> in
* that it may delete or reorder elements based on what the selection
* provider returns from {@link ISelectionProvider#getSelection()} after
* having called
* {@link ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection)}
* based on the requested change to the observable list. The affected
* methods are <code>add</code>, <code>addAll</code>, and <code>set</code>.
*
* @param selectionProvider
* @return the observable value tracking the (multi) selection of the given
* selection provider
*
* @since 1.2
*/
public static IObservableList observeMultiSelection(
ISelectionProvider selectionProvider) {
checkNull(selectionProvider);
return ViewerProperties.multipleSelection().observe(selectionProvider);
}
/**
* Returns an observable value that tracks the current selection of the
* given viewer. If the viewer provides selections of type
* {@link IStructuredSelection}, the observable value will be the first
* element of the structured selection as returned by
* {@link IStructuredSelection#getFirstElement()}.
*
* @param viewer
* the viewer
* @return the observable value tracking the (single) selection of the given
* viewer
* @since 1.2
*/
public static IViewerObservableValue observeSingleSelection(Viewer viewer) {
checkNull(viewer);
return ViewerProperties.singleSelection().observe(viewer);
}
/**
* Returns an observable list that tracks the current selection of the given
* viewer. Assumes that the viewer provides selections of type
* {@link IStructuredSelection}. Note that the observable list will not
* honor the full contract of <code>java.util.List</code> in that it may
* delete or reorder elements based on what the viewer returns from
* {@link ISelectionProvider#getSelection()} after having called
* {@link ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection)}
* based on the requested change to the observable list. The affected
* methods are <code>add</code>, <code>addAll</code>, and <code>set</code>.
*
* @param viewer
* @return the observable value tracking the (multi) selection of the given
* selection provider
*
* @since 1.2
*/
public static IViewerObservableList observeMultiSelection(Viewer viewer) {
checkNull(viewer);
return ViewerProperties.multipleSelection().observe(viewer);
}
/**
* Returns an observable value that tracks the input of the given viewer.
* <p>
* The returned observer is blind to changes in the viewer's input unless
* its {@link IObservableValue#setValue(Object)} method is called directly.
*
* @param viewer
* the viewer to observe
* @return an observable value tracking the input of the given viewer
* @since 1.2
*/
public static IObservableValue observeInput(Viewer viewer) {
checkNull(viewer);
return ViewerProperties.input().observe(viewer);
}
/**
* Returns an observable set that tracks the checked elements of the given
* <code>ICheckable</code>.
*
* @param checkable
* {@link ICheckable} containing the checked elements to track
* @param elementType
* element type of the returned set
* @return an observable set tracking the checked elements of the given
* checkable.
* @since 1.2
*/
public static IObservableSet observeCheckedElements(ICheckable checkable,
Object elementType) {
checkNull(checkable);
return ViewerProperties.checkedElements(elementType).observe(checkable);
}
/**
* Returns an observable set that tracks the checked elements of the given
* viewer. Assumes that the viewer implements {@link ICheckable}.
*
* @param viewer
* {@link CheckboxTableViewer} containing the checked elements to
* track.
* @param elementType
* element type of the returned set
* @return an observable set that tracks the checked elements of the given
* viewer.
* @since 1.2
*/
public static IViewerObservableSet observeCheckedElements(
CheckboxTableViewer viewer, Object elementType) {
checkNull(viewer);
return ViewerProperties.checkedElements(elementType).observe(viewer);
}
/**
* Returns an observable set that tracks the checked elements of the given
* viewer. Assumes that the viewer implements {@link ICheckable}.
*
* @param viewer
* {@link CheckboxTreeViewer} containing the checked elements to
* track.
* @param elementType
* element type of the returned set
* @return an observable set that tracks the checked elements of the given
* viewer.
* @since 1.2
*/
public static IViewerObservableSet observeCheckedElements(
CheckboxTreeViewer viewer, Object elementType) {
checkNull(viewer);
return ViewerProperties.checkedElements(elementType).observe(viewer);
}
/**
* Returns an observable set that tracks the filters of the given viewer.
* Note that the returned set will not track changes that are made using
* direct API on StructuredViewer (by calling
* {@link StructuredViewer#addFilter(org.eclipse.jface.viewers.ViewerFilter)
* addFilter()},
* {@link StructuredViewer#removeFilter(org.eclipse.jface.viewers.ViewerFilter)
* removeFilter()}, or
* {@link StructuredViewer#setFilters(org.eclipse.jface.viewers.ViewerFilter[])
* setFilters()}) -- it is assumed that filters are only changed through the
* returned set.
*
* @param viewer
* viewer containing the filters to be tracked
* @return an observable set that tracks the filters of the given viewer.
* @since 1.3
*/
public static IViewerObservableSet observeFilters(StructuredViewer viewer) {
checkNull(viewer);
return ViewerProperties.filters().observe(viewer);
}
}
|
