10
|
1 /*******************************************************************************
|
|
2 * Copyright (c) 2004, 2006 IBM Corporation and others.
|
|
3 * All rights reserved. This program and the accompanying materials
|
|
4 * are made available under the terms of the Eclipse Public License v1.0
|
|
5 * which accompanies this distribution, and is available at
|
|
6 * http://www.eclipse.org/legal/epl-v10.html
|
|
7 *
|
|
8 * Contributors:
|
|
9 * IBM Corporation - initial API and implementation
|
|
10 * Port to the D programming language:
|
|
11 * Frank Benoit <benoit@tionex.de>
|
|
12 *******************************************************************************/
|
|
13 module dwtx.jface.viewers.deferred.DeferredContentProvider;
|
|
14
|
|
15 import dwtx.jface.viewers.ILazyContentProvider;
|
|
16 import dwtx.jface.viewers.deferred.AbstractVirtualTable;
|
|
17 import dwtx.jface.viewers.deferred.BackgroundContentProvider;
|
|
18 import dwtx.jface.viewers.deferred.IConcurrentModel;
|
|
19
|
|
20 import dwt.widgets.Control;
|
|
21 import dwt.widgets.Table;
|
|
22 import dwtx.core.runtime.Assert;
|
|
23 import dwtx.jface.viewers.AcceptAllFilter;
|
|
24 import dwtx.jface.viewers.IFilter;
|
|
25 import dwtx.jface.viewers.ILazyContentProvider;
|
|
26 import dwtx.jface.viewers.TableViewer;
|
|
27 import dwtx.jface.viewers.Viewer;
|
|
28
|
|
29 import dwt.dwthelper.utils;
|
|
30
|
|
31 /**
|
|
32 * Content provider that performs sorting and filtering in a background thread.
|
|
33 * Requires a <code>TableViewer</code> created with the <code>DWT.VIRTUAL</code>
|
|
34 * flag and an <code>IConcurrentModel</code> as input.
|
|
35 * <p>
|
|
36 * The sorter and filter must be set directly on the content provider.
|
|
37 * Any sorter or filter on the TableViewer will be ignored.
|
|
38 * </p>
|
|
39 *
|
|
40 * <p>
|
|
41 * The real implementation is in <code>BackgroundContentProvider</code>. This
|
|
42 * object is a lightweight wrapper that adapts the algorithm to work with
|
|
43 * <code>TableViewer</code>.
|
|
44 * </p>
|
|
45 *
|
|
46 * @since 3.1
|
|
47 */
|
|
48 public class DeferredContentProvider : ILazyContentProvider {
|
|
49
|
|
50 private int limit = -1;
|
|
51 private BackgroundContentProvider provider;
|
|
52 private Comparator sortOrder;
|
|
53 private IFilter filter;
|
|
54
|
|
55 private AbstractVirtualTable table;
|
|
56
|
|
57 private static final class TableViewerAdapter : AbstractVirtualTable {
|
|
58
|
|
59 private TableViewer viewer;
|
|
60
|
|
61 /**
|
|
62 * @param viewer
|
|
63 */
|
|
64 public this(TableViewer viewer) {
|
|
65 this.viewer = viewer;
|
|
66 }
|
|
67
|
|
68 /* (non-Javadoc)
|
|
69 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#flushCache(java.lang.Object)
|
|
70 */
|
|
71 public void clear(int index) {
|
|
72 viewer.clear(index);
|
|
73 }
|
|
74
|
|
75 /* (non-Javadoc)
|
|
76 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#replace(java.lang.Object, int)
|
|
77 */
|
|
78 public void replace(Object element, int itemIndex) {
|
|
79 viewer.replace(element, itemIndex);
|
|
80 }
|
|
81
|
|
82 /* (non-Javadoc)
|
|
83 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#setItemCount(int)
|
|
84 */
|
|
85 public void setItemCount(int total) {
|
|
86 viewer.setItemCount(total);
|
|
87 }
|
|
88
|
|
89 /* (non-Javadoc)
|
|
90 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#getItemCount()
|
|
91 */
|
|
92 public int getItemCount() {
|
|
93 return viewer.getTable().getItemCount();
|
|
94 }
|
|
95
|
|
96 /* (non-Javadoc)
|
|
97 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#getTopIndex()
|
|
98 */
|
|
99 public int getTopIndex() {
|
|
100 return Math.max(viewer.getTable().getTopIndex() - 1, 0);
|
|
101 }
|
|
102
|
|
103 /* (non-Javadoc)
|
|
104 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#getVisibleItemCount()
|
|
105 */
|
|
106 public int getVisibleItemCount() {
|
|
107 int start = getTopIndex();
|
|
108 int itemCount = getItemCount();
|
|
109 Table table = viewer.getTable();
|
|
110 return Math.min(table.getBounds().height / table.getItemHeight() + 2,
|
|
111 itemCount - start);
|
|
112 }
|
|
113
|
|
114 /* (non-Javadoc)
|
|
115 * @see dwtx.jface.viewers.deferred.AbstractVirtualTable#getControl()
|
|
116 */
|
|
117 public Control getControl() {
|
|
118 return viewer.getControl();
|
|
119 }
|
|
120
|
|
121 }
|
|
122
|
|
123 /**
|
|
124 * Create a DeferredContentProvider with the given sort order.
|
|
125 * @param sortOrder a comparator that sorts the content.
|
|
126 */
|
|
127 public this(Comparator sortOrder) {
|
|
128 this.filter = AcceptAllFilter.getInstance();
|
|
129 this.sortOrder = sortOrder;
|
|
130 }
|
|
131
|
|
132 /* (non-Javadoc)
|
|
133 * @see dwtx.jface.viewers.IContentProvider#dispose()
|
|
134 */
|
|
135 public void dispose() {
|
|
136 setProvider(null);
|
|
137 }
|
|
138
|
|
139 /* (non-Javadoc)
|
|
140 * @see dwtx.jface.viewers.IContentProvider#inputChanged(dwtx.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
|
|
141 */
|
|
142 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
|
|
143 if (newInput is null) {
|
|
144 setProvider(null);
|
|
145 return;
|
|
146 }
|
|
147
|
|
148 Assert.isTrue(null !is cast(IConcurrentModel)newInput );
|
|
149 Assert.isTrue(null !is cast(TableViewer)viewer );
|
|
150 IConcurrentModel model = cast(IConcurrentModel)newInput;
|
|
151
|
|
152 this.table = new TableViewerAdapter(cast(TableViewer)viewer);
|
|
153
|
|
154 BackgroundContentProvider newProvider = new BackgroundContentProvider(
|
|
155 table,
|
|
156 model, sortOrder);
|
|
157
|
|
158 setProvider(newProvider);
|
|
159
|
|
160 newProvider.setLimit(limit);
|
|
161 newProvider.setFilter(filter);
|
|
162 }
|
|
163
|
|
164 /**
|
|
165 * Sets the sort order for this content provider. This sort order takes priority
|
|
166 * over anything that was supplied to the <code>TableViewer</code>.
|
|
167 *
|
|
168 * @param sortOrder new sort order. The comparator must be able to support being
|
|
169 * used in a background thread.
|
|
170 */
|
|
171 public void setSortOrder(Comparator sortOrder) {
|
|
172 Assert.isNotNull(cast(Object)sortOrder);
|
|
173 this.sortOrder = sortOrder;
|
|
174 if (provider !is null) {
|
|
175 provider.setSortOrder(sortOrder);
|
|
176 }
|
|
177 }
|
|
178
|
|
179 /**
|
|
180 * Sets the filter for this content provider. This filter takes priority over
|
|
181 * anything that was supplied to the <code>TableViewer</code>. The filter
|
|
182 * must be capable of being used in a background thread.
|
|
183 *
|
|
184 * @param toSet filter to set
|
|
185 */
|
|
186 public void setFilter(IFilter toSet) {
|
|
187 this.filter = toSet;
|
|
188 if (provider !is null) {
|
|
189 provider.setFilter(toSet);
|
|
190 }
|
|
191 }
|
|
192
|
|
193 /**
|
|
194 * Sets the maximum number of rows in the table. If the model contains more
|
|
195 * than this number of elements, only the top elements will be shown based on
|
|
196 * the current sort order.
|
|
197 *
|
|
198 * @param limit maximum number of rows to show or -1 if unbounded
|
|
199 */
|
|
200 public void setLimit(int limit) {
|
|
201 this.limit = limit;
|
|
202 if (provider !is null) {
|
|
203 provider.setLimit(limit);
|
|
204 }
|
|
205 }
|
|
206
|
|
207 /**
|
|
208 * Returns the current maximum number of rows or -1 if unbounded
|
|
209 *
|
|
210 * @return the current maximum number of rows or -1 if unbounded
|
|
211 */
|
|
212 public int getLimit() {
|
|
213 return limit;
|
|
214 }
|
|
215
|
|
216 /* (non-Javadoc)
|
|
217 * @see dwtx.jface.viewers.ILazyContentProvider#updateElement(int)
|
|
218 */
|
|
219 public void updateElement(int element) {
|
|
220 if (provider !is null) {
|
|
221 provider.checkVisibleRange(element);
|
|
222 }
|
|
223 }
|
|
224
|
|
225 private void setProvider(BackgroundContentProvider newProvider) {
|
|
226 if (provider !is null) {
|
|
227 provider.dispose();
|
|
228 }
|
|
229
|
|
230 provider = newProvider;
|
|
231 }
|
|
232
|
|
233 }
|