| /* | |
| * 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.cell.client.Cell.Context; | |
| import com.google.gwt.dom.client.NativeEvent; | |
| import com.google.gwt.event.shared.EventHandler; | |
| import com.google.gwt.event.shared.GwtEvent; | |
| /** | |
| * Allows the previewing of events before they are fired to Cells. | |
| * | |
| * @param <T> the data type of the {@link HasData} source | |
| */ | |
| public class CellPreviewEvent<T> extends GwtEvent<CellPreviewEvent.Handler<T>> { | |
| /** | |
| * Handler for {@link CellPreviewEvent}. | |
| * | |
| * @param <T> the data type of the {@link HasData} | |
| */ | |
| public static interface Handler<T> extends EventHandler { | |
| /** | |
| * Called when {@link CellPreviewEvent} is fired. | |
| * | |
| * @param event the {@link CellPreviewEvent} that was fired | |
| */ | |
| void onCellPreview(CellPreviewEvent<T> event); | |
| } | |
| /** | |
| * Handler type. | |
| */ | |
| private static Type<Handler<?>> TYPE; | |
| /** | |
| * Fires a cell preview event on all registered handlers in the handler | |
| * manager. If no such handlers exist, this implementation will do nothing. | |
| * This implementation sets the column to 0. | |
| * | |
| * @param <T> the old value type | |
| * @param source the source of the handlers | |
| * @param nativeEvent the event to preview | |
| * @param display the {@link HasData} source of the event | |
| * @param context the Cell {@link Context} | |
| * @param value the value where the event occurred | |
| * @param isCellEditing indicates whether or not the cell is being edited | |
| * @param isSelectionHandled indicates whether or not selection is handled | |
| * @return the {@link CellPreviewEvent} that was fired | |
| */ | |
| public static <T> CellPreviewEvent<T> fire(HasCellPreviewHandlers<T> source, | |
| NativeEvent nativeEvent, HasData<T> display, Context context, T value, | |
| boolean isCellEditing, boolean isSelectionHandled) { | |
| CellPreviewEvent<T> event = new CellPreviewEvent<T>(nativeEvent, display, | |
| context, value, isCellEditing, isSelectionHandled); | |
| if (TYPE != null) { | |
| source.fireEvent(event); | |
| } | |
| return event; | |
| } | |
| /** | |
| * Gets the type associated with this event. | |
| * | |
| * @return returns the handler type | |
| */ | |
| public static Type<Handler<?>> getType() { | |
| if (TYPE == null) { | |
| TYPE = new Type<Handler<?>>(); | |
| } | |
| return TYPE; | |
| } | |
| private final Context context; | |
| private final HasData<T> display; | |
| private boolean isCanceled = false; | |
| private final boolean isCellEditing; | |
| private final boolean isSelectionHandled; | |
| private final NativeEvent nativeEvent; | |
| private final T value; | |
| /** | |
| * Construct a new {@link CellPreviewEvent}. | |
| * | |
| * @param nativeEvent the event to preview | |
| * @param display the {@link HasData} source of the event | |
| * @param context the Cell {@link Context} | |
| * @param value the value where the event occurred | |
| * @param isCellEditing indicates whether or not the cell is being edited | |
| * @param isSelectionHandled indicates whether or not selection is handled | |
| */ | |
| protected CellPreviewEvent(NativeEvent nativeEvent, HasData<T> display, | |
| Context context, T value, boolean isCellEditing, | |
| boolean isSelectionHandled) { | |
| this.nativeEvent = nativeEvent; | |
| this.display = display; | |
| this.context = context; | |
| this.value = value; | |
| this.isCellEditing = isCellEditing; | |
| this.isSelectionHandled = isSelectionHandled; | |
| } | |
| // The instance knows its Handler is of type T, but the TYPE | |
| // field itself does not, so we have to do an unsafe cast here. | |
| @SuppressWarnings({"unchecked", "rawtypes"}) | |
| @Override | |
| public Type<Handler<T>> getAssociatedType() { | |
| return (Type) TYPE; | |
| } | |
| /** | |
| * Get the column index of the Cell where the event occurred if the source is | |
| * a table. If the source is not a table, the column is always 0. | |
| * | |
| * @return the column index, or 0 if there is only one column | |
| */ | |
| public int getColumn() { | |
| return context.getColumn(); | |
| } | |
| /** | |
| * Get the cell {@link Context}. | |
| * | |
| * @return the cell {@link Context} | |
| */ | |
| public Context getContext() { | |
| return context; | |
| } | |
| /** | |
| * Get the {@link HasData} source of the event. | |
| */ | |
| public HasData<T> getDisplay() { | |
| return display; | |
| } | |
| /** | |
| * Get the index of the value where the event occurred. | |
| */ | |
| public int getIndex() { | |
| return context.getIndex(); | |
| } | |
| /** | |
| * Get the {@link NativeEvent} to preview. | |
| */ | |
| public NativeEvent getNativeEvent() { | |
| return nativeEvent; | |
| } | |
| /** | |
| * Get the value where the event occurred. | |
| */ | |
| public T getValue() { | |
| return value; | |
| } | |
| /** | |
| * Check if the event has been canceled. | |
| * | |
| * @return true if the event has been canceled | |
| * @see #setCanceled(boolean) | |
| */ | |
| public boolean isCanceled() { | |
| return isCanceled; | |
| } | |
| /** | |
| * Check whether or not the cell where the event occurred is being edited. | |
| * | |
| * @return true if the cell is being edited, false if not | |
| */ | |
| public boolean isCellEditing() { | |
| return isCellEditing; | |
| } | |
| /** | |
| * Check whether or not selection is being handled by the widget or one of its | |
| * Cells. | |
| * | |
| * @return true if selection is handled by the widget | |
| */ | |
| public boolean isSelectionHandled() { | |
| return isSelectionHandled; | |
| } | |
| /** | |
| * Cancel the event and prevent it from firing to the Cell. | |
| * | |
| * @param cancel true to cancel the event, false to allow it | |
| */ | |
| public void setCanceled(boolean cancel) { | |
| this.isCanceled = cancel; | |
| } | |
| @Override | |
| protected void dispatch(Handler<T> handler) { | |
| handler.onCellPreview(this); | |
| } | |
| } |