com.google.gwt.view.client.CellPreviewEvent.java Source code

Introduction

Here is the source code for com.google.gwt.view.client.CellPreviewEvent.java

Source

/*
 * 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);
    }
}