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

Introduction

Here is the source code for com.google.gwt.view.client.TreeViewModel.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;
import com.google.gwt.cell.client.ValueUpdater;
import com.google.gwt.event.shared.HandlerRegistration;

/**
 * A model of a tree.
 */
public interface TreeViewModel {

    /**
     * Default implementation of {@link NodeInfo}.
     */
    class DefaultNodeInfo<T> implements NodeInfo<T> {

        private final Cell<T> cell;
        private final AbstractDataProvider<T> dataProvider;
        private final CellPreviewEvent.Handler<T> selectionEventManager;
        private HandlerRegistration selectionEventManagerReg;
        private final SelectionModel<? super T> selectionModel;
        private final ValueUpdater<T> valueUpdater;
        private HasData<T> display;

        /**
         * Construct a new {@link DefaultNodeInfo}.
         * 
         * @param dataProvider the {@link AbstractDataProvider} that provides the
         *          child values
         * @param cell the {@link Cell} used to render the child values
         */
        public DefaultNodeInfo(AbstractDataProvider<T> dataProvider, Cell<T> cell) {
            this(dataProvider, cell, null, null);
        }

        /**
         * Construct a new {@link DefaultNodeInfo}.
         * 
         * @param dataProvider the {@link AbstractDataProvider} that provides the
         *          child values
         * @param cell the {@link Cell} used to render the child values update when
         *          the selection changes
         * @param selectionModel the {@link SelectionModel} used for selection
         * @param valueUpdater the {@link ValueUpdater}
         */
        public DefaultNodeInfo(AbstractDataProvider<T> dataProvider, final Cell<T> cell,
                SelectionModel<? super T> selectionModel, final ValueUpdater<T> valueUpdater) {
            this(dataProvider, cell, selectionModel, DefaultSelectionEventManager.<T>createDefaultManager(),
                    valueUpdater);
        }

        /**
         * Construct a new {@link DefaultNodeInfo}.
         * 
         * @param dataProvider the {@link AbstractDataProvider} that provides the
         *          child values
         * @param cell the {@link Cell} used to render the child values update when
         *          the selection changes
         * @param selectionModel the {@link SelectionModel} used for selection
         * @param selectionEventManager the {@link CellPreviewEvent.Handler} that
         *          handles user selection interaction
         * @param valueUpdater the {@link ValueUpdater}
         */
        public DefaultNodeInfo(AbstractDataProvider<T> dataProvider, final Cell<T> cell,
                SelectionModel<? super T> selectionModel, CellPreviewEvent.Handler<T> selectionEventManager,
                final ValueUpdater<T> valueUpdater) {
            this.dataProvider = dataProvider;
            this.cell = cell;
            this.selectionModel = selectionModel;
            this.valueUpdater = valueUpdater;
            this.selectionEventManager = selectionEventManager;
        }

        public Cell<T> getCell() {
            return cell;
        }

        public ProvidesKey<T> getProvidesKey() {
            return dataProvider;
        }

        public SelectionModel<? super T> getSelectionModel() {
            return selectionModel;
        }

        public ValueUpdater<T> getValueUpdater() {
            return valueUpdater;
        }

        public void setDataDisplay(HasData<T> display) {
            this.display = display;
            if (selectionEventManager != null) {
                selectionEventManagerReg = display.addCellPreviewHandler(selectionEventManager);
            }
            dataProvider.addDataDisplay(display);
        }

        public void unsetDataDisplay() {
            if (display != null) {
                dataProvider.removeDataDisplay(display);
                if (selectionEventManagerReg != null) {
                    selectionEventManagerReg.removeHandler();
                    selectionEventManagerReg = null;
                }
                display = null;
            }
        }
    }

    /**
     * The info needed to create the children of a tree node.
     */
    interface NodeInfo<T> {

        /**
         * Get the {@link Cell} used to render the children of this node.
         * 
         * @return the {@link Cell}
         */
        Cell<T> getCell();

        /**
         * Return the key provider for children of this node.
         * 
         * @return the {@link ProvidesKey}
         */
        ProvidesKey<T> getProvidesKey();

        /**
         * Get the {@link SelectionModel} used for the children of this node. To
         * unify selection across all items of the same type, or across the entire
         * tree, return the same instance of {@link SelectionModel} from all
         * {@link NodeInfo}.
         * 
         * @return the {@link SelectionModel}
         */
        SelectionModel<? super T> getSelectionModel();

        /**
         * Get the value updater associated with the cell.
         * 
         * @return the value updater
         */
        ValueUpdater<T> getValueUpdater();

        /**
         * Set the display that is listening to this {@link NodeInfo}. The
         * implementation should attach the display to the source of data.
         * 
         * @param display the {@link HasData}
         */
        void setDataDisplay(HasData<T> display);

        /**
         * Unset the display from the {@link NodeInfo}. The implementation should
         * detach the display from the source of data.
         */
        void unsetDataDisplay();
    }

    /**
     * Get the {@link NodeInfo} that will provide the {@link ProvidesKey},
     * {@link Cell}, and {@link HasData} instances to retrieve and display the
     * children of the specified value.
     * 
     * @param value the value in the parent node
     * @return the {@link NodeInfo}
     */
    <T> NodeInfo<?> getNodeInfo(T value);

    /**
     * Check if the value is known to be a leaf node.
     * 
     * @param value the value at the node
     * 
     * @return true if the node is known to be a leaf node, false otherwise
     */
    boolean isLeaf(Object value);
}