Application: gvSIG desktop » gvSIG projections

package org.gvsig.proj.swing.impl.tree;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.List;

import javax.swing.Icon;

import javax.swing.tree.TreeNode;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

public class LoadedGroup extends BranchNode {

        private boolean loaded = false;

        private boolean loading = false;

        private GroupLoader loader = null;

        final protected I18nManager i18nManager = ToolsLocator.getI18nManager(); 

        public LoadedGroup(TreeNode parent, TreeContainer container,  String message, Icon icon) {

                super(parent, container, message, icon);

        }

        public LoadedGroup(TreeNode parent, TreeContainer container, String message, Icon expandedIcon, Icon collapsedIcon) {

                super(parent, container, message, expandedIcon, collapsedIcon);

        }

        /**

         * Requests children to be loaded, if they have not been previously loaded

         * 

         * @return true if children were previously loaded (so load was not needed), false

         * otherwise.

         */

        public void loadChildren() {

                if (loaded == false && loading==false) {

                        reloadChildren();

                }

        }

        public void reloadChildren() {

                if (!loading) {

                        loading = true;

                        children.clear();

                        doLoad();

                        TreeNode node = loader.createLoadingNode();

                        if (node!=null) {

                                children.add(node);

                        }

                }

                else {

                        doLoad();

                }

        }

        public void doLoad() {

                if (loader!=null) {

                        loader.cancel();

                }

                loader = getLoader();

                loader.execute();

        }

        protected boolean isLoading() {

                return loading;

        }

        protected boolean isLoaded() {

                return loaded;

        }

        protected GroupLoader getLoader() {

                return this.loader;

        }

        public void setLoader(GroupLoader loader) {

                this.loader = loader;

        }

        /**

         * This method is called by the loader in the Event Dispatch Thread

         * when children loading has been cancelled

         */

        protected void cancelled(GroupLoader loader) {

                if (this.loader == loader) {

                        loading = false;

                        this.loader = null;

                        cancelled();

                }

        }

        /**

         * This method is called by the loader in the Event Dispatch Thread

         * when children loading is completed

         */

        public void loaded(ArrayList<TreeNode> loadedData, GroupLoader loader) {

                if (this.loader == loader) { // ignore if results are coming from an older loader

                        this.loader = null;

                        this.loading = false;

                        if (loader.isCancelled()) {

                                cancelled();

                        }

                        else {

                                loaded = true;

                                loaded(loadedData);

                        }

                }

        }

        public TreeContainer geTreeContainer() {

                return this.container;

        }

        /**

         * This method is called in the Event Dispatch Thread

         * when children loading is completed

         */

        public void loaded(List<TreeNode> loadedData) {

                this.children.clear();

                this.children.addAll(loadedData);

                this.container.getModel().reload(this);

        }

        /**

         * This method is called the Event Dispatch Thread

         * when children loading has been cancelled

         */

        protected void cancelled() {

                this.children.clear();

        }

        @Override

        public TreeNode getChildAt(int childIndex) {

                loadChildren();

                return super.getChildAt(childIndex);

        }

        @Override

        public int getChildCount() {

                loadChildren();

                return super.getChildCount();

        }

        @Override

        @SuppressWarnings("rawtypes")

        public Enumeration children() {

                loadChildren();

                return super.children();

        }

}