| /* | |
| * Copyright 2010 Google Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not | |
| * use this file except in compliance with the License. You may obtain a copy of | |
| * the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |
| * License for the specific language governing permissions and limitations under | |
| * the License. | |
| */ | |
| package com.google.gwt.view.client; | |
| import com.google.gwt.event.shared.HandlerRegistration; | |
| import java.util.Collections; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| /** | |
| * A base implementation of a data source for {@link HasData} implementations. | |
| * | |
| * @param <T> the data type of records in the list | |
| */ | |
| public abstract class AbstractDataProvider<T> implements ProvidesKey<T> { | |
| private Set<HasData<T>> displays = new HashSet<HasData<T>>(); | |
| /** | |
| * The provider of keys for list items. | |
| */ | |
| private final ProvidesKey<T> keyProvider; | |
| /** | |
| * The last row count. | |
| */ | |
| private int lastRowCount = -1; | |
| /** | |
| * Indicates whether or not the last row count is exact. | |
| */ | |
| private boolean lastRowCountExact; | |
| /** | |
| * A mapping of {@link HasData}s to their handlers. | |
| */ | |
| private Map<HasData<T>, HandlerRegistration> rangeChangeHandlers = | |
| new HashMap<HasData<T>, HandlerRegistration>(); | |
| /** | |
| * Construct an AbstractDataProvider without a key provider. | |
| */ | |
| protected AbstractDataProvider() { | |
| this.keyProvider = null; | |
| } | |
| /** | |
| * Construct an AbstractDataProvider with a given key provider. | |
| * | |
| * @param keyProvider a {@link ProvidesKey} object | |
| */ | |
| protected AbstractDataProvider(ProvidesKey<T> keyProvider) { | |
| this.keyProvider = keyProvider; | |
| } | |
| /** | |
| * Adds a data display to this adapter. The current range of interest of the | |
| * display will be populated with data. | |
| * | |
| * @param display a {@link HasData}. | |
| */ | |
| public void addDataDisplay(final HasData<T> display) { | |
| if (display == null) { | |
| throw new IllegalArgumentException("display cannot be null"); | |
| } else if (displays.contains(display)) { | |
| throw new IllegalStateException( | |
| "The specified display has already been added to this adapter."); | |
| } | |
| // Add the display to the set. | |
| displays.add(display); | |
| // Add a handler to the display. | |
| HandlerRegistration handler = display.addRangeChangeHandler( | |
| new RangeChangeEvent.Handler() { | |
| public void onRangeChange(RangeChangeEvent event) { | |
| AbstractDataProvider.this.onRangeChanged(display); | |
| } | |
| }); | |
| rangeChangeHandlers.put(display, handler); | |
| // Update the data size in the display. | |
| if (lastRowCount >= 0) { | |
| display.setRowCount(lastRowCount, lastRowCountExact); | |
| } | |
| // Initialize the display with the current range. | |
| onRangeChanged(display); | |
| } | |
| /** | |
| * Get the set of displays currently assigned to this adapter. | |
| * | |
| * @return the set of {@link HasData} | |
| */ | |
| public Set<HasData<T>> getDataDisplays() { | |
| return Collections.unmodifiableSet(displays); | |
| } | |
| /** | |
| * Get the key for a list item. The default implementation returns the item | |
| * itself. | |
| * | |
| * @param item the list item | |
| * @return the key that represents the item | |
| */ | |
| public Object getKey(T item) { | |
| return keyProvider == null ? item : keyProvider.getKey(item); | |
| } | |
| /** | |
| * Get the {@link ProvidesKey} that provides keys for list items. | |
| * | |
| * @return the {@link ProvidesKey} | |
| */ | |
| public ProvidesKey<T> getKeyProvider() { | |
| return keyProvider; | |
| } | |
| /** | |
| * Get the current ranges of all displays. | |
| * | |
| * @return the ranges | |
| */ | |
| public Range[] getRanges() { | |
| Range[] ranges = new Range[displays.size()]; | |
| int i = 0; | |
| for (HasData<T> display : displays) { | |
| ranges[i++] = display.getVisibleRange(); | |
| } | |
| return ranges; | |
| } | |
| /** | |
| * Remove the given data display. | |
| * | |
| * @param display a {@link HasData} instance | |
| * | |
| * @throws IllegalStateException if the display is not present | |
| */ | |
| public void removeDataDisplay(HasData<T> display) { | |
| if (!displays.contains(display)) { | |
| throw new IllegalStateException("HasData not present"); | |
| } | |
| displays.remove(display); | |
| // Remove the handler. | |
| HandlerRegistration handler = rangeChangeHandlers.remove(display); | |
| handler.removeHandler(); | |
| } | |
| /** | |
| * Called when a display changes its range of interest. | |
| * | |
| * @param display the display whose range has changed | |
| */ | |
| protected abstract void onRangeChanged(HasData<T> display); | |
| /** | |
| * Inform the displays of the total number of items that are available. | |
| * | |
| * @param count the new total row count | |
| * @param exact true if the count is exact, false if it is an estimate | |
| */ | |
| protected void updateRowCount(int count, boolean exact) { | |
| lastRowCount = count; | |
| lastRowCountExact = exact; | |
| for (HasData<T> display : displays) { | |
| display.setRowCount(count, exact); | |
| } | |
| } | |
| /** | |
| * Inform the displays of the new data. | |
| * | |
| * @param start the start index | |
| * @param values the data values | |
| */ | |
| protected void updateRowData(int start, List<T> values) { | |
| for (HasData<T> display : displays) { | |
| updateRowData(display, start, values); | |
| } | |
| } | |
| /** | |
| * Informs a single display of new data. | |
| * | |
| * @param display the display to be updated | |
| * @param start the start index | |
| * @param values the data values | |
| */ | |
| protected void updateRowData(HasData<T> display, int start, List<T> values) { | |
| int end = start + values.size(); | |
| Range range = display.getVisibleRange(); | |
| int curStart = range.getStart(); | |
| int curLength = range.getLength(); | |
| int curEnd = curStart + curLength; | |
| if (start == curStart || (curStart < end && curEnd > start)) { | |
| // Fire the handler with the data that is in the range. | |
| // Allow an empty list that starts on the page start. | |
| int realStart = curStart < start ? start : curStart; | |
| int realEnd = curEnd > end ? end : curEnd; | |
| int realLength = realEnd - realStart; | |
| List<T> realValues = values.subList( | |
| realStart - start, realStart - start + realLength); | |
| display.setRowData(realStart, realValues); | |
| } | |
| } | |
| } |