001 /*
002 * Copyright 2008-2017 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package griffon.javafx.beans.binding;
017
018 import javafx.beans.InvalidationListener;
019 import javafx.beans.binding.BooleanBinding;
020 import javafx.beans.binding.ObjectBinding;
021 import javafx.beans.binding.StringBinding;
022 import javafx.beans.property.ListProperty;
023 import javafx.beans.property.Property;
024 import javafx.beans.property.ReadOnlyBooleanProperty;
025 import javafx.beans.property.ReadOnlyIntegerProperty;
026 import javafx.beans.value.ChangeListener;
027 import javafx.beans.value.ObservableIntegerValue;
028 import javafx.beans.value.ObservableValue;
029 import javafx.collections.ListChangeListener;
030 import javafx.collections.ObservableList;
031
032 import javax.annotation.Nonnull;
033 import java.util.Collection;
034 import java.util.Iterator;
035 import java.util.List;
036 import java.util.ListIterator;
037
038 import static java.util.Objects.requireNonNull;
039
040 /**
041 * @author Andres Almiray
042 * @since 2.11.0
043 */
044 public class ListPropertyDecorator<E> extends ListProperty<E> {
045 private final ListProperty<E> delegate;
046
047 public ListPropertyDecorator(@Nonnull ListProperty<E> delegate) {
048 this.delegate = requireNonNull(delegate, "Argument 'delegate' must not be null");
049 }
050
051 @Nonnull
052 protected final ListProperty<E> getDelegate() {
053 return delegate;
054 }
055
056 @Override
057 public void setValue(ObservableList<E> v) {
058 delegate.setValue(v);
059 }
060
061 @Override
062 public void bindBidirectional(Property<ObservableList<E>> other) {
063 delegate.bindBidirectional(other);
064 }
065
066 @Override
067 public void unbindBidirectional(Property<ObservableList<E>> other) {
068 delegate.unbindBidirectional(other);
069 }
070
071 @Override
072 public boolean equals(Object o) {
073 return this == o || delegate.equals(o);
074 }
075
076 @Override
077 public int hashCode() {
078 return delegate.hashCode();
079 }
080
081 @Override
082 public String toString() {
083 return getClass().getName() + ":" + delegate.toString();
084 }
085
086 @Override
087 public void bindContentBidirectional(ObservableList<E> list) {
088 delegate.bindContentBidirectional(list);
089 }
090
091 @Override
092 public void unbindContentBidirectional(Object object) {
093 delegate.unbindContentBidirectional(object);
094 }
095
096 @Override
097 public void bindContent(ObservableList<E> list) {
098 delegate.bindContent(list);
099 }
100
101 @Override
102 public void unbindContent(Object object) {
103 delegate.unbindContent(object);
104 }
105
106 @Override
107 public ObservableList<E> getValue() {
108 return delegate.getValue();
109 }
110
111 @Override
112 public int getSize() {
113 return delegate.getSize();
114 }
115
116 @Override
117 public ReadOnlyIntegerProperty sizeProperty() {
118 return delegate.sizeProperty();
119 }
120
121 @Override
122 public ReadOnlyBooleanProperty emptyProperty() {
123 return delegate.emptyProperty();
124 }
125
126 @Override
127 public ObjectBinding<E> valueAt(int index) {
128 return delegate.valueAt(index);
129 }
130
131 @Override
132 public ObjectBinding<E> valueAt(ObservableIntegerValue index) {
133 return delegate.valueAt(index);
134 }
135
136 @Override
137 public BooleanBinding isEqualTo(ObservableList<?> other) {
138 return delegate.isEqualTo(other);
139 }
140
141 @Override
142 public BooleanBinding isNotEqualTo(ObservableList<?> other) {
143 return delegate.isNotEqualTo(other);
144 }
145
146 @Override
147 public BooleanBinding isNull() {
148 return delegate.isNull();
149 }
150
151 @Override
152 public BooleanBinding isNotNull() {
153 return delegate.isNotNull();
154 }
155
156 @Override
157 public StringBinding asString() {
158 return delegate.asString();
159 }
160
161 @Override
162 public int size() {
163 return delegate.size();
164 }
165
166 @Override
167 public boolean isEmpty() {
168 return delegate.isEmpty();
169 }
170
171 @Override
172 public boolean contains(Object obj) {
173 return delegate.contains(obj);
174 }
175
176 @Override
177 public Iterator<E> iterator() {
178 return delegate.iterator();
179 }
180
181 @Override
182 public Object[] toArray() {
183 return delegate.toArray();
184 }
185
186 @Override
187 public <T> T[] toArray(T[] array) {
188 return delegate.toArray(array);
189 }
190
191 @Override
192 public boolean add(E element) {
193 return delegate.add(element);
194 }
195
196 @Override
197 public boolean remove(Object obj) {
198 return delegate.remove(obj);
199 }
200
201 @Override
202 public boolean containsAll(Collection<?> objects) {
203 return delegate.containsAll(objects);
204 }
205
206 @Override
207 public boolean addAll(Collection<? extends E> elements) {
208 return delegate.addAll(elements);
209 }
210
211 @Override
212 public boolean addAll(int i, Collection<? extends E> elements) {
213 return delegate.addAll(i, elements);
214 }
215
216 @Override
217 public boolean removeAll(Collection<?> objects) {
218 return delegate.removeAll(objects);
219 }
220
221 @Override
222 public boolean retainAll(Collection<?> objects) {
223 return delegate.retainAll(objects);
224 }
225
226 @Override
227 public void clear() {
228 delegate.clear();
229 }
230
231 @Override
232 public E get(int i) {
233 return delegate.get(i);
234 }
235
236 @Override
237 public E set(int i, E element) {
238 return delegate.set(i, element);
239 }
240
241 @Override
242 public void add(int i, E element) {
243 delegate.add(i, element);
244 }
245
246 @Override
247 public E remove(int i) {
248 return delegate.remove(i);
249 }
250
251 @Override
252 public int indexOf(Object obj) {
253 return delegate.indexOf(obj);
254 }
255
256 @Override
257 public int lastIndexOf(Object obj) {
258 return delegate.lastIndexOf(obj);
259 }
260
261 @Override
262 public ListIterator<E> listIterator() {
263 return delegate.listIterator();
264 }
265
266 @Override
267 public ListIterator<E> listIterator(int i) {
268 return delegate.listIterator(i);
269 }
270
271 @Override
272 public List<E> subList(int from, int to) {
273 return delegate.subList(from, to);
274 }
275
276 @Override
277 public boolean addAll(E[] elements) {
278 return delegate.addAll(elements);
279 }
280
281 @Override
282 public boolean setAll(E[] elements) {
283 return delegate.setAll(elements);
284 }
285
286 @Override
287 public boolean setAll(Collection<? extends E> elements) {
288 return delegate.setAll(elements);
289 }
290
291 @Override
292 public boolean removeAll(E[] elements) {
293 return delegate.removeAll(elements);
294 }
295
296 @Override
297 public boolean retainAll(E[] elements) {
298 return delegate.retainAll(elements);
299 }
300
301 @Override
302 public void remove(int from, int to) {
303 delegate.remove(from, to);
304 }
305
306 @Override
307 public ObservableList<E> get() {
308 return delegate.get();
309 }
310
311 @Override
312 public void addListener(ChangeListener<? super ObservableList<E>> listener) {
313 delegate.addListener(listener);
314 }
315
316 @Override
317 public void removeListener(ChangeListener<? super ObservableList<E>> listener) {
318 delegate.removeListener(listener);
319 }
320
321 @Override
322 public void addListener(InvalidationListener listener) {
323 delegate.addListener(listener);
324 }
325
326 @Override
327 public void removeListener(InvalidationListener listener) {
328 delegate.removeListener(listener);
329 }
330
331 @Override
332 public void addListener(ListChangeListener<? super E> listener) {
333 delegate.addListener(listener);
334 }
335
336 @Override
337 public void removeListener(ListChangeListener<? super E> listener) {
338 delegate.removeListener(listener);
339 }
340
341 @Override
342 public Object getBean() {
343 return delegate.getBean();
344 }
345
346 @Override
347 public String getName() {
348 return delegate.getName();
349 }
350
351 @Override
352 public void bind(ObservableValue<? extends ObservableList<E>> observable) {
353 delegate.bind(observable);
354 }
355
356 @Override
357 public void unbind() {
358 delegate.unbind();
359 }
360
361 @Override
362 public boolean isBound() {
363 return delegate.isBound();
364 }
365
366 @Override
367 public void set(ObservableList<E> value) {
368 delegate.set(value);
369 }
370 }
|