Mercurial > projects > dwt-addons

comparison dwtx/jface/viewers/deferred/DeferredContentProvider.d @ 10:b6c35faf97c8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Viewers
author Frank Benoit <benoit@tionex.de>
date Mon, 31 Mar 2008 00:47:19 +0200
parents
children ea8ff534f622
comparison
equal deleted inserted replaced
9:6c14e54dfc11 10:b6c35faf97c8
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 }