| /* | |
| * 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.core.client.Scheduler; | |
| import com.google.gwt.core.client.Scheduler.ScheduledCommand; | |
| import com.google.gwt.event.shared.GwtEvent; | |
| import com.google.gwt.event.shared.HandlerManager; | |
| import com.google.gwt.event.shared.HandlerRegistration; | |
| import com.google.gwt.view.client.SelectionChangeEvent.HasSelectionChangedHandlers; | |
| /** | |
| * A model for selection within a list. | |
| * | |
| * @param <T> the data type of records in the list | |
| */ | |
| public interface SelectionModel<T> extends HasSelectionChangedHandlers, ProvidesKey<T> { | |
| /** | |
| * A default implementation of {@link SelectionModel} that provides listener | |
| * addition and removal. | |
| * | |
| * @param <T> the data type of records in the list | |
| */ | |
| public abstract class AbstractSelectionModel<T> implements SelectionModel<T> { | |
| private final HandlerManager handlerManager = new HandlerManager(this); | |
| /** | |
| * Set to true if the next scheduled event should be canceled. | |
| */ | |
| private boolean isEventCancelled; | |
| /** | |
| * Set to true if an event is scheduled to be fired. | |
| */ | |
| private boolean isEventScheduled; | |
| private final ProvidesKey<T> keyProvider; | |
| /** | |
| * Construct an AbstractSelectionModel with a given key provider. | |
| * | |
| * @param keyProvider an instance of ProvidesKey<T>, or null if the record | |
| * object should act as its own key | |
| */ | |
| protected AbstractSelectionModel(ProvidesKey<T> keyProvider) { | |
| this.keyProvider = keyProvider; | |
| } | |
| @Override | |
| public HandlerRegistration addSelectionChangeHandler( | |
| SelectionChangeEvent.Handler handler) { | |
| return handlerManager.addHandler(SelectionChangeEvent.getType(), handler); | |
| } | |
| @Override | |
| public void fireEvent(GwtEvent<?> event) { | |
| handlerManager.fireEvent(event); | |
| } | |
| @Override | |
| public Object getKey(T item) { | |
| return (keyProvider == null || item == null) ? item | |
| : keyProvider.getKey(item); | |
| } | |
| /** | |
| * Returns a {@link ProvidesKey} instance that simply returns the input data | |
| * item. | |
| * | |
| * @return the key provider, which may be null | |
| */ | |
| public ProvidesKey<T> getKeyProvider() { | |
| return keyProvider; | |
| } | |
| /** | |
| * Fire a {@link SelectionChangeEvent}. Multiple firings may be coalesced. | |
| */ | |
| protected void fireSelectionChangeEvent() { | |
| if (isEventScheduled()) { | |
| setEventCancelled(true); | |
| } | |
| SelectionChangeEvent.fire(AbstractSelectionModel.this); | |
| } | |
| /** | |
| * Return true if the next scheduled event should be canceled. | |
| * | |
| * @return true if the event is canceled | |
| */ | |
| protected boolean isEventCancelled() { | |
| return isEventCancelled; | |
| } | |
| /** | |
| * Return true if an event is scheduled to be fired. | |
| * | |
| * @return true if the event is scheduled | |
| */ | |
| protected boolean isEventScheduled() { | |
| return isEventScheduled; | |
| } | |
| /** | |
| * Schedules a {@link SelectionChangeEvent} to fire at the | |
| * end of the current event loop. | |
| */ | |
| protected void scheduleSelectionChangeEvent() { | |
| setEventCancelled(false); | |
| if (!isEventScheduled()) { | |
| setEventScheduled(true); | |
| Scheduler.get().scheduleFinally(new ScheduledCommand() { | |
| public void execute() { | |
| setEventScheduled(false); | |
| if (isEventCancelled()) { | |
| setEventCancelled(false); | |
| return; | |
| } | |
| fireSelectionChangeEvent(); | |
| } | |
| }); | |
| } | |
| } | |
| /** | |
| * Set whether the next scheduled event should be canceled. | |
| * | |
| * @param isEventCancelled if true, cancel the event | |
| */ | |
| protected void setEventCancelled(boolean isEventCancelled) { | |
| this.isEventCancelled = isEventCancelled; | |
| } | |
| /** | |
| * Set whether an event is scheduled to be fired. | |
| * | |
| * @param isEventScheduled if true, schedule the event | |
| */ | |
| protected void setEventScheduled(boolean isEventScheduled) { | |
| this.isEventScheduled = isEventScheduled; | |
| } | |
| } | |
| /** | |
| * Adds a {@link SelectionChangeEvent} handler. | |
| * | |
| * @param handler the handler | |
| * @return the registration for the event | |
| */ | |
| @Override | |
| HandlerRegistration addSelectionChangeHandler(SelectionChangeEvent.Handler handler); | |
| /** | |
| * Check if an object is selected. | |
| * | |
| * @param object the object | |
| * @return true if selected, false if not | |
| */ | |
| boolean isSelected(T object); | |
| /** | |
| * Set the selected state of an object and fire a | |
| * {@link SelectionChangeEvent} if the selection has | |
| * changed. Subclasses should not fire an event in the case where | |
| * selected is true and the object was already selected, or selected | |
| * is false and the object was not previously selected. | |
| * | |
| * @param object the object to select or deselect | |
| * @param selected true to select, false to deselect | |
| */ | |
| void setSelected(T object, boolean selected); | |
| } |