Mercurial > projects > dwt2

comparison org.eclipse.jface/src/org/eclipse/jface/viewers/deferred/DeferredContentProvider.d @ 12:bc29606a740c

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