| /* |
| * 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.sample.expenses.client; |
| |
| import com.google.gwt.animation.client.Animation; |
| import com.google.gwt.dom.client.Element; |
| import com.google.gwt.user.cellview.client.CellList; |
| import com.google.gwt.user.cellview.client.CellTable; |
| import com.google.gwt.view.client.ProvidesKey; |
| |
| import java.util.List; |
| |
| /** |
| * An animation used to phase in a value in a {@link CellTable}. |
| * |
| * @param <T> the data type of items |
| */ |
| public abstract class PhaseAnimation<T> extends Animation { |
| |
| /** |
| * The duration of the animation used to phase in new rows. |
| */ |
| private static final int DEFAULT_DURATION = 4000; |
| |
| /** |
| * A {@link PhaseAnimation} for {@link CellList}. |
| * |
| * @param <T> the data type of items |
| */ |
| public static class CellListPhaseAnimation<T> extends PhaseAnimation<T> { |
| |
| private final CellList<T> cellList; |
| |
| /** |
| * Construct a new {@link PhaseAnimation}. |
| * |
| * @param cellList the {@link CellList} to animate |
| * @param value the value to phase in |
| * @param keyProvider the {@link ProvidesKey} |
| */ |
| public CellListPhaseAnimation(CellList<T> cellList, T value, |
| ProvidesKey<T> keyProvider) { |
| super(value, keyProvider); |
| this.cellList = cellList; |
| } |
| |
| @Override |
| protected T getDisplayedItem(int index) { |
| return cellList.getVisibleItem(index); |
| } |
| |
| @Override |
| protected List<T> getDisplayedItems() { |
| return cellList.getVisibleItems(); |
| } |
| |
| @Override |
| protected Element getRowElement(int index) { |
| return cellList.getRowElement(index); |
| } |
| } |
| |
| /** |
| * A {@link PhaseAnimation} for {@link CellTable}. |
| * |
| * @param <T> the data type of items |
| */ |
| public static class CellTablePhaseAnimation<T> extends PhaseAnimation<T> { |
| |
| private final CellTable<T> cellTable; |
| |
| /** |
| * Construct a new {@link PhaseAnimation}. |
| * |
| * @param cellTable the {@link CellTable} to animate |
| * @param value the value to phase in |
| * @param keyProvider the {@link ProvidesKey} |
| */ |
| public CellTablePhaseAnimation(CellTable<T> cellTable, T value, |
| ProvidesKey<T> keyProvider) { |
| super(value, keyProvider); |
| this.cellTable = cellTable; |
| } |
| |
| @Override |
| protected T getDisplayedItem(int index) { |
| return cellTable.getVisibleItem(index); |
| } |
| |
| @Override |
| protected List<T> getDisplayedItems() { |
| return cellTable.getVisibleItems(); |
| } |
| |
| @Override |
| protected Element getRowElement(int index) { |
| return cellTable.getRowElement(index); |
| } |
| } |
| |
| private final Object key; |
| private final ProvidesKey<T> keyProvider; |
| private int lastRowIndex = -1; |
| |
| /** |
| * Construct a new {@link CellTablePhaseAnimation}. |
| * |
| * @param value the value to phase in |
| * @param keyProvider the {@link ProvidesKey} |
| */ |
| public PhaseAnimation(T value, ProvidesKey<T> keyProvider) { |
| this.key = keyProvider.getKey(value); |
| this.keyProvider = keyProvider; |
| } |
| |
| /** |
| * Run the animation using the default duration. |
| */ |
| public void run() { |
| run(DEFAULT_DURATION); |
| } |
| |
| /** |
| * Get the item at the specified index. |
| * |
| * @param index the index |
| * @return the item |
| */ |
| protected abstract T getDisplayedItem(int index); |
| |
| /** |
| * Get a list of all displayed items. |
| * |
| * @return the list of items |
| */ |
| protected abstract List<T> getDisplayedItems(); |
| |
| /** |
| * Get the row element at the specified index. |
| * |
| * @param index the row index |
| * @return the element |
| */ |
| protected abstract Element getRowElement(int index); |
| |
| @Override |
| protected void onComplete() { |
| Element elem = getItemElement(); |
| if (elem != null) { |
| elem.getStyle().clearBackgroundColor(); |
| } |
| } |
| |
| @Override |
| protected void onUpdate(double progress) { |
| Element elem = getItemElement(); |
| if (elem != null) { |
| int r = 255; |
| int g = 200 + (int) (55.0 * progress); |
| int b = 0 + (int) (255.0 * progress); |
| elem.getStyle().setBackgroundColor("rgb(" + r + "," + g + "," + b + ")"); |
| } |
| } |
| |
| /** |
| * Get the {@link Element} of the value within the table. |
| * |
| * @return the element, or null if not found |
| */ |
| private Element getItemElement() { |
| // Check if the cached row index is still valid. |
| if (lastRowIndex >= 0) { |
| T value = getDisplayedItem(lastRowIndex); |
| if (value == null || !key.equals(keyProvider.getKey(value))) { |
| lastRowIndex = -1; |
| } |
| } |
| |
| // Find the index of the row element. |
| if (lastRowIndex < 0) { |
| List<T> items = getDisplayedItems(); |
| for (int i = 0; i < items.size(); i++) { |
| T item = items.get(i); |
| if (item != null && key.equals(keyProvider.getKey(item))) { |
| lastRowIndex = i; |
| break; |
| } |
| } |
| } |
| |
| // Return the row element. |
| return lastRowIndex < 0 ? null : getRowElement(lastRowIndex); |
| } |
| } |