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