* Portlet for displaying class trees. It can be configured to show only a

* subtree of an ontology, by setting the portlet property <code>topClass</code>

* to the name of the top class to show. <br>

* Also supports creating and editing classes.

* @author Tania Tudorache <tudorache@stanford.edu>

*/

    private static final String SUFFIX_ID_LOCAL_ANNOTATION_COUNT = "_locAnnCnt";

    private static final String SUFFIX_ID_LOCAL_ANNOTATION_IMG = "_locAnnImg";

    protected static final String WATCH_ICON_STYLE_STRING = "style=\"position:relative; top:3px; left:2px;\"";

    private static final String PLACE_HOLDER_PANEL = "placeHolderPanel";

    private final String linkPattern = "{0}?ontology={1}&tab={2}&id={3}";

    private TreePanel treePanel;

    protected ToolbarButton createButton;

    protected ToolbarButton deleteButton;

    protected CycleButton watchButton;

    private CheckItem lastSelectedWatchType;

    private CheckItem watchBranchItem;

    private CheckItem unwatchBranchItem;

    private boolean expandDisabled = false;

    private boolean showToolbar = true;

    private boolean showTitle = true;

    private boolean showTools = true;

    private boolean allowsMultiSelection = true;

    private String hierarchyProperty = null;

    private String topClass = null;

    private Collection<EntityData> initialSelection = null;

    private TreeNodeListenerAdapter nodeListener;

    private boolean registeredEventHandlers = false;

    /*

    * Configuration constants and defaults

    */

    private static Set<EntityData> nodesWithNotesOpen = new HashSet<EntityData>();

    public ClassTreePortlet(final Project project) {

        this(project, true, true, true, true, null);

    }

    public ClassTreePortlet(final Project project, final boolean showToolbar, final boolean showTitle, final boolean showTools, final boolean allowsMultiSelection, final String topClass) {

        super(project, false);

        this.showToolbar = showToolbar;

        this.showTitle = showTitle;

        this.showTools = showTools;

        this.allowsMultiSelection = allowsMultiSelection;

        this.topClass = topClass;

        registerEventHandlers();

        initialize();

    }

    private void registerEventHandlers() {

        if(registeredEventHandlers) {

            return;

        }

        GWT.log("Registering event handlers for ClassTreePortlet " + this);

        registeredEventHandlers = true;

        ///////////////////////////////////////////////////////////////////////////

        //

        // Registration of event handlers that we are interested in

        //

        ///////////////////////////////////////////////////////////////////////////

        addProjectEventHandler(BrowserTextChangedEvent.TYPE, new BrowserTextChangedHandler() {

            @Override

            public void browserTextChanged(BrowserTextChangedEvent event) {

                    onEntityBrowserTextChanged(event);

            }

        });

        addProjectEventHandler(EntityNotesChangedEvent.TYPE, new EntityNotesChangedHandler() {

            @Override

            public void entityNotesChanged(EntityNotesChangedEvent event) {

                if (isEventForThisProject(event)) {

                    onNotesChanged(event);

                }

            }

        });

        addProjectEventHandler(WatchAddedEvent.TYPE, new WatchAddedHandler() {

            @Override

            public void handleWatchAdded(WatchAddedEvent event) {

                if (isEventForThisProject(event)) {

                    onWatchAdded(event);

                }

            }

        });

        addProjectEventHandler(WatchRemovedEvent.TYPE, new WatchRemovedHandler() {

            @Override

            public void handleWatchRemoved(WatchRemovedEvent event) {

                if (isEventForThisProject(event)) {

                    onWatchRemoved(event);

                }

            }

        });

        addProjectEventHandler(EntityDeprecatedChangedEvent.TYPE, new EntityDeprecatedChangedHandler() {

            @Override

            public void handleEntityDeprecatedChangedEvent(EntityDeprecatedChangedEvent evt) {

                if (isEventForThisProject(evt)) {

                    onEntityDeprecatedChanged(evt.getEntity(), evt.isDeprecated());

                }

            }

        });

        addProjectEventHandler(ClassHierarchyParentAddedEvent.TYPE, new ClassHierarchyParentAddedHandler() {

            @Override

            public void handleClassHierarchyParentAdded(final ClassHierarchyParentAddedEvent event) {

                if (isEventForThisProject(event)) {

                    handleParentAddedEvent(event);

                }

            }

        });

        addProjectEventHandler(ClassHierarchyParentRemovedEvent.TYPE, new ClassHierarchyParentRemovedHandler() {

            @Override

            public void handleClassHierarchyParentRemoved(ClassHierarchyParentRemovedEvent event) {

                if (isEventForThisProject(event)) {

                    handleParentRemovedEvent(event);

                }

            }

        });

    }

    private void handleParentAddedEvent(final ClassHierarchyParentAddedEvent event) {

        final TreeNode tn = findTreeNode(event.getParent());

        if(tn != null) {

            RenderingServiceManager.getManager().execute(new GetRendering(getProjectId(), event), new AsyncCallback<GetRenderingResponse>() {

                @Override

                public void onFailure(Throwable caught) {

                    GWT.log("Problem getting classes", caught);

                }

                @Override

                public void onSuccess(GetRenderingResponse result) {

                    SubclassEntityData subClassData = new SubclassEntityData(event.getChild().toStringID(), result.getRendering(event.getChild().getIRI()).get().getBrowserText(), Collections.<EntityData>emptyList(), 0);

                    subClassData.setValueType(ValueType.Cls);

                    onSubclassAdded((EntityData) tn.getUserObject(), Arrays.<EntityData>asList(subClassData), false);

                }

            });

        }

    }

    private void handleParentRemovedEvent(ClassHierarchyParentRemovedEvent event) {

        TreeNode parentTn = findTreeNode(event.getParent());

        if (parentTn != null) {

            // We should check

            TreeNode childTn = findTreeNode(event.getChild());

            if(childTn != null) {

                for(Node existingChild : parentTn.getChildNodes()) {

                    String childId = childTn.getId();

                    String existingChildId = existingChild.getId();

                    if(childId != null && existingChildId != null && childId.equals(existingChildId)) {

                        childTn.remove();

                        return;

                    }

                }

            }

        }

    }

    protected String getCreateClsDescription() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.CREATE_ACTION_DESC_PROP, ClassTreePortletConstants.CREATE_ACTION_DESC_DEFAULT);

    }

    protected String getDeleteClsDescription() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.DELETE_ACTION_DESC_PROP, ClassTreePortletConstants.DELETE_ACTION_DESC_DEFAULT);

    }

    protected String getRenameClsDescription() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.RENAME_ACTION_DESC_PROP, ClassTreePortletConstants.RENAME_ACTION_DESC_DEFAULT);

    }

    protected String getMoveClsDescription() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.MOVE_ACTION_DESC_PROP, ClassTreePortletConstants.MOVE_ACTION_DESC_DEFAULT);

    }

    protected String getCreateClsLabel() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.CREATE_LABEL_PROP, ClassTreePortletConstants.CREATE_LABEL_DEFAULT);

    }

    protected String getDeleteClsLabel() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.DELETE_LABEL_PROP, ClassTreePortletConstants.DELETE_LABEL_DEFAULT);

    }

    protected boolean getDeleteEnabled() {

        return UIUtil.getBooleanConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.DELETE_ENABLED_PROP, ClassTreePortletConstants.DELETE_ENABLED_DEFAULT);

    }

    protected String getWatchClsLabel() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.WATCH_LABEL_PROP, ClassTreePortletConstants.WATCH_LABEL_DEFAULT);

    }

    protected String getWatchBranchClsLabel() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.WATCH_BRANCH_LABEL_PROP, ClassTreePortletConstants.WATCH_BRANCH_LABEL_DEFAULT);

    }

    protected String getUnwatchClsLabel() {

        return UIUtil.getStringConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.UNWATCH_LABEL_PROP, ClassTreePortletConstants.UNWATCH_LABEL_DEFAULT);

    }

    protected boolean getInheritMetaClasses() {

        return UIUtil.getBooleanConfigurationProperty(getPortletConfiguration(), ClassTreePortletConstants.INHERIT_METACLASSES_PROP, ClassTreePortletConstants.INHERIT_METACLASSES_DEFAULT);

    }

    @Override

    public void initialize() {

        setLayout(new FitLayout());

        setTools(getTools());

        if (showTitle) {

            setTitle("Classes");

        }

        if (showToolbar) {

            addToolbarButtons();

        }

        final Panel bogusPanel = new Panel();

        bogusPanel.setId(PLACE_HOLDER_PANEL);

        bogusPanel.setHeight(560);

        add(bogusPanel);

        updateButtonStates();

        if (nodeListener == null) {

            //listener for click on the comment icon to display notes

            nodeListener = new TreeNodeListenerAdapter() {

                //TODO: this functionality is similar to that found in AbstractFieldWidget and

                @Override

                public boolean doBeforeClick(final Node node, final EventObject e) {

                    if (!nodesWithNotesOpen.contains(node.getUserObject())) { //not the second click in a double click

                        onCellClickOrDblClick(node, e);

                    }

                    return true;

                }

                private void onCellClickOrDblClick(Node node, EventObject e) {

                    final Element target = e.getTarget();

                    if (target != null) {

                        final String targetId = target.getId();

                        if (targetId.endsWith(SUFFIX_ID_LOCAL_ANNOTATION_IMG) || targetId.endsWith(SUFFIX_ID_LOCAL_ANNOTATION_COUNT)) {

                            showClassNotes(node);

                        }

                    }

                }

                @Override

                public void onContextMenu(final Node node, EventObject e) {

                    treePanel.getSelectionModel().select((TreeNode) node);

                    Menu contextMenu = new Menu();

                    contextMenu.setWidth("140px");

                    MenuItem menuShowInternalID = new MenuItem();

                    menuShowInternalID.setText("Show internal ID");

                    menuShowInternalID.addListener(new BaseItemListenerAdapter() {

                        @Override

                        public void onClick(BaseItem item, EventObject event) {

                            super.onClick(item, event);

                            showInternalID((EntityData) node.getUserObject());

                        }

                    });

                    contextMenu.addItem(menuShowInternalID);

                    MenuItem menuShowDirectLink = new MenuItem();

                    menuShowDirectLink.setText("Show direct link");

                    menuShowDirectLink.setIcon("images/link.png");

                    menuShowDirectLink.addListener(new BaseItemListenerAdapter() {

                        @Override

                        public void onClick(BaseItem item, EventObject event) {

                            super.onClick(item, event);

                            showDirectLink((EntityData) node.getUserObject());

                        }

                    });

                    contextMenu.addItem(menuShowDirectLink);

                    contextMenu.showAt(e.getXY()[0] + 5, e.getXY()[1] + 5);

                }

            };

        }

    }

    private void onNotesChanged(EntityNotesChangedEvent event) {

        String name = event.getEntity().getIRI().toString();

        TreeNode node = findTreeNode(name);

        if(node != null) {

            final Object userObject = node.getUserObject();

            if (userObject instanceof EntityData) {

                EntityData subclassEntityData = (EntityData) userObject;

                subclassEntityData.setLocalAnnotationsCount(event.getTotalNotesCount());

                String nodeText = createNodeRenderText(node);

                node.setText(nodeText);

            }

        }

    }

    private void onWatchAdded(WatchAddedEvent event) {

        if(!event.getUserId().equals(getUserId())) {

            return;

        }

        Watch<?> watch = event.getWatch();

        if(watch instanceof EntityBasedWatch) {

            TreeNode tn = findTreeNode(((EntityBasedWatch) watch).getEntity().getIRI().toString());

            if(tn != null) {

                SubclassEntityData data = (SubclassEntityData) tn.getUserObject();

                data.addWatch(watch);

                updateTreeNodeRendering(tn);

            }

        }

    }

    private void updateTreeNodeRendering(TreeNode tn) {

        tn.setText(createNodeRenderText(tn));

        updateTreeNodeIcon(tn);

    }

    private void onWatchRemoved(WatchRemovedEvent event) {

        if(!event.getUserId().equals(getUserId())) {

            return;

        }

        Watch<?> watch = event.getWatch();

        if(watch instanceof EntityBasedWatch) {

            OWLEntity entity = ((EntityBasedWatch) watch).getEntity();

            TreeNode tn = findTreeNode(entity.getIRI().toString());

            if(tn != null) {

                SubclassEntityData data = (SubclassEntityData) tn.getUserObject();

                data.clearWatches();

                updateTreeNodeRendering(tn);

            }

        }

    }

    private void showInternalID(EntityData entity) {

        String className = entity.getName();

        MessageBox.showMessage(entity.getBrowserText() + " Internal Id", className);

    }

    private void showDirectLink(EntityData entity) {

        String url = "";

        try {

            String applicationURL = Window.Location.getHref();

            if (applicationURL.contains("?")) {

                applicationURL = applicationURL.substring(0, applicationURL.indexOf("?"));

            }

            if (applicationURL.contains("#")) {

                applicationURL = applicationURL.substring(0, applicationURL.indexOf("#"));

            }

            String tabName = getTab().getTabConfiguration().getName();

            if (tabName.contains(".")) {

                tabName = tabName.substring(tabName.lastIndexOf(".") + 1);

            }

            String className = entity.getName();

            url = linkPattern.replace("{0}", applicationURL).

                    replace("{1}", URL.encodeQueryString(getProjectId().getId())).

                    replace("{2}", tabName).

                    replace("{3}", className == null ? "" : URL.encodeQueryString(className));

        }

        catch (Exception e) {

            e.printStackTrace();

        }

        MessageBox.showMessage("Direct link to " + entity.getBrowserText(), url);

    }

    public TreePanel createTreePanel() {

        treePanel = new TreePanel();

        treePanel.setHeight(560);

        treePanel.setAutoWidth(true);

        treePanel.setAnimate(true);

        treePanel.setAutoScroll(true);

        treePanel.setEnableDD(true);

        if (allowsMultiSelection) {

            treePanel.setSelectionModel(new MultiSelectionModel());

        }

        treePanel.addListener(new TreePanelListenerAdapter() {

            @Override

            public void onExpandNode(final TreeNode node) {

                // if (!expandDisabled && !treePanel.getRootNode().equals(node)) {

                if (!expandDisabled) {

                    GWT.log("Expand node " + node.getUserObject(), null);

                    getSubclasses(((EntityData) node.getUserObject()).getName(), node);

                }

            }

        });

        addDragAndDropSupport();

        return treePanel;

    }

    protected void createSelectionListener() {

        final TreeSelectionModel selModel = treePanel.getSelectionModel();

        if (selModel instanceof DefaultSelectionModel) {

            ((DefaultSelectionModel) selModel).addSelectionModelListener(new DefaultSelectionModelListenerAdapter() {

                @Override

                public void onSelectionChange(final DefaultSelectionModel sm, final TreeNode node) {

                    notifySelectionListeners(new SelectionEvent(ClassTreePortlet.this));

                }

            });

        }

        else if (selModel instanceof MultiSelectionModel) {

            ((MultiSelectionModel) selModel).addSelectionModelListener(new MultiSelectionModelListener() {

                public void onSelectionChange(final MultiSelectionModel sm, final TreeNode[] nodes) {

                    notifySelectionListeners(new SelectionEvent(ClassTreePortlet.this));

                }

            });

        }

        else {

            GWT.log("Unknown tree selection model for class tree: " + selModel, null);

        }

    }

    @Override

    protected Tool[] getTools() {

        return showTools ? super.getTools() : new Tool[]{};

    }

    protected void addToolbarButtons() {

        setTopToolbar(new Toolbar());

        final Toolbar toolbar = getTopToolbar();

        createButton = createCreateButton();

        if (createButton != null) {

            toolbar.addButton(createButton);

        }

        deleteButton = createDeleteButton();

        if (deleteButton != null) {

            toolbar.addButton(deleteButton);

        }

        watchButton = createWatchButton();

        if (watchButton != null) {

            toolbar.addElement(watchButton.getElement());

        }

        final Component searchField = createSearchField();

        if (searchField != null) {

            toolbar.addSpacer();

            toolbar.addSeparator();

            toolbar.addText("&nbsp<i>Search</i>:&nbsp&nbsp");

            toolbar.addElement(searchField.getElement());

        }

    }

    protected ToolbarButton createCreateButton() {

        createButton = new ToolbarButton(getCreateClsLabel());

        createButton.setCls("toolbar-button");

        createButton.addListener(new ButtonListenerAdapter() {

            @Override

            public void onClick(final Button button, final EventObject e) {

                onCreateCls(e.isShiftKey() ? CreateClassesMode.IMPORT_CSV : CreateClassesMode.CREATE_SUBCLASSES);

            }

        });

        createButton.setDisabled(!hasWritePermission());

        return createButton;

    }

    protected ToolbarButton createDeleteButton() {

        deleteButton = new ToolbarButton(getDeleteClsLabel());

        deleteButton.setCls("toolbar-button");

        deleteButton.addListener(new ButtonListenerAdapter() {

            @Override

            public void onClick(final Button button, final EventObject e) {

                onDeleteCls();

            }

        });

        deleteButton.setDisabled(!getProject().hasWritePermission(Application.get().getUserId()));

        deleteButton.setDisabled(!getDeleteEnabled());

        return deleteButton;

    }

    protected CycleButton createWatchButton() {

        watchButton = new CycleButton();

        watchButton.setShowText(true);

        watchButton.setCls("toolbar-button");

        final CheckItem watchItem = new CheckItem();

        watchItem.setText(getWatchClsLabel());

        watchItem.setCls("toolbar-button");

        watchButton.addItem(watchItem);

        watchBranchItem = new CheckItem();

        watchBranchItem.setText(getWatchBranchClsLabel());

        watchBranchItem.setCls("toolbar-button");

        watchBranchItem.setChecked(true);

        watchButton.addItem(watchBranchItem);

        unwatchBranchItem = new CheckItem();

        unwatchBranchItem.setText(getUnwatchClsLabel());

        unwatchBranchItem.setCls("toolbar-button");

        watchButton.addItem(unwatchBranchItem);

        //the listener is needed to override behavior of cycle button

        CheckItemListener checkItemListener = new CheckItemListenerAdapter() {

            @Override

            public boolean doBeforeCheckChange(CheckItem item, boolean checked) {

                return false;

            }

        };

        BaseItemListener baseItemListener = new BaseItemListenerAdapter() {

            @Override

            public void onClick(BaseItem item, EventObject e) {

                CheckItem activeItem = (CheckItem) item;

                watchButton.setActiveItem(activeItem);

                if (activeItem != unwatchBranchItem) {

                    lastSelectedWatchType = activeItem;

                }

                //this is optional, and can be removed if it is confusing to the user:

                //if a user clicks in the watch menu on an item, we perform the operation right away to avoid one more click.

                if (activeItem.equals(watchItem)) {

                    onWatchCls();

                }

                else if (activeItem.equals(watchBranchItem)) {

                    onWatchBranchCls();

                }

                else if (activeItem.equals(unwatchBranchItem)) {

                    onUnwatchCls();

                }

            }

        };

        watchItem.addListener(baseItemListener);

        watchBranchItem.addListener(baseItemListener);

        unwatchBranchItem.addListener(baseItemListener);

        watchItem.addListener(checkItemListener);

        watchBranchItem.addListener(checkItemListener);

        unwatchBranchItem.addListener(checkItemListener);

        //listener for performing the specific watch action

        watchButton.addListener(new ButtonListenerAdapter() {

            @Override

            public void onClick(Button button, EventObject e) {

                CheckItem activeItem = watchButton.getActiveItem();

                if (activeItem.equals(watchItem)) {

                    onWatchCls();

                }

                else if (activeItem.equals(watchBranchItem)) {

                    onWatchBranchCls();

                }

                else if (activeItem.equals(unwatchBranchItem)) {

                    onUnwatchCls();

                }

            }

        });

        //listener for adjusting the watch button to the selection in tree

        addSelectionListener(new SelectionListener() {

            public void selectionChanged(SelectionEvent event) {

                updateWatchedMenuState(event.getSelectable().getSelection());

            }

        });

        return watchButton;

    }

    protected void updateWatchedMenuState(Collection<EntityData> entities) {

        if (entities == null || entities.size() == 0) {

            return;

        }

        EntityData entityData = entities.iterator().next();

        Set<Watch<?>> watches = entityData.getWatches();

        if (!watches.isEmpty()) {

            watchButton.setActiveItem(unwatchBranchItem);

        }

        else {

            watchButton.setActiveItem(lastSelectedWatchType == null ? watchBranchItem : lastSelectedWatchType);

        }

    }

    protected Component createSearchField() {

        final TextField searchField = new TextField("Search: ", "search");

        searchField.setSelectOnFocus(true);

        searchField.setAutoWidth(true);

        searchField.setEmptyText("Type search string");

        searchField.addListener(new TextFieldListenerAdapter() {

            @Override

            public void onSpecialKey(final Field field, final EventObject e) {

                if (e.getKey() == EventObject.ENTER) {

                    SearchUtil searchUtil = new SearchUtil(getProjectId(), ClassTreePortlet.this, getSearchAsyncCallback());

                    searchUtil.setBusyComponent(searchField);

                    searchUtil.setSearchedValueType(ValueType.Cls);

                    searchUtil.search(searchField.getText());

                }

            }

        });

        return searchField;

    }

    protected AsyncCallback<Boolean> getSearchAsyncCallback() {

        return new AsyncCallback<Boolean>() {

            public void onFailure(Throwable caught) {

                MessageBox.showAlert("Search error", "An error occurred during the search. Please try again.");

            }

            public void onSuccess(Boolean result) {

            }

        };

    }

    protected void addDragAndDropSupport() {

        treePanel.addListener(new TreePanelListenerAdapter() {

            @Override

            public boolean doBeforeNodeDrop(final TreePanel treePanel, final TreeNode target, final DragData dragData, final String point, final DragDrop source, final TreeNode dropNode, final DropNodeCallback dropNodeCallback) {

                if (hasWritePermission()) {

                    final boolean success = Window.confirm("Are you sure you want to move " + getNodeBrowserText(dropNode) + " from parent " + getNodeBrowserText(dropNode.getParentNode()) + " to parent " + getNodeBrowserText(target) + " ?");

                    if (success) {

                        moveClass((EntityData) dropNode.getUserObject(), (EntityData) dropNode.getParentNode().getUserObject(), (EntityData) target.getUserObject());

                        return true;

                    }

                    else {

                        return false;

                    }

                }

                else {

                    return false;

                }

            }

        });

    }

    protected void onSubclassAdded(final EntityData parent, final Collection<EntityData> subclasses, final boolean selectNewNode) {

        if (subclasses == null || subclasses.size() == 0) {

            return;

        }

        final EntityData subclassEntity = ((List<EntityData>) subclasses).get(0); //there is always just one

        final TreeNode parentNode = findTreeNode(parent.getName());

        if (parentNode == null) {

            return; // nothing to be done

        }

        TreeNode subclassNode = findTreeNode(subclassEntity.getName());

        if (subclassNode == null) {

            subclassNode = createTreeNode(subclassEntity);

            parentNode.appendChild(subclassNode);

            getSubclasses(parent.getName(), parentNode);

        }

        else { // tricky if it already exists

            if (!hasChild(parentNode, subclassEntity.getName())) { //multiple parents

                subclassNode = createTreeNode(subclassEntity);

                if (subclassEntity instanceof SubclassEntityData) {

                    final int childrenCount = ((SubclassEntityData) subclassEntity).getSubclassCount();

                    if (childrenCount > 0) {

                        subclassNode.setExpandable(true);

                    }

                }

                parentNode.appendChild(subclassNode);

            }

        }

    }

    protected TreeNode findTreeNode(OWLClass cls) {

        return findTreeNode(cls.getIRI().toString());

    }

    protected TreeNode findTreeNode(final String id) {

        if(treePanel == null) {

            return null;

        }

        final TreeNode root = treePanel.getRootNode();

        final TreeNode node = findTreeNode(root, id, new ArrayList<TreeNode>());

        return node;

    }

    protected TreeNode findTreeNode(final TreeNode node, final String id, final ArrayList<TreeNode> visited) {

        if (getNodeClsName(node).equals(id)) {

            return node;

        }

        else {

            visited.add(node);

            final Node[] children = node.getChildNodes();

            for (final Node element2 : children) {

                final TreeNode n = findTreeNode((TreeNode) element2, id, visited);

                if (n != null) {

                    return n;

                }

            }

            return null;

        }

    }

//        if (subclasses == null || subclasses.size() == 0) {

//            return;

//        }

//

//        final EntityData subclass = ((List<EntityData>) subclasses).get(0);

//        final TreeNode parentNode = findTreeNode(entity.getName());

//

//        if (parentNode == null) {

//            return;

//        }

//

//        // final TreeNode subclassNode = findTreeNode(parentNode, subclass.getName(), new ArrayList<TreeNode>());

//        final TreeNode subclassNode = getDirectChild(parentNode, subclass.getName());

//        if (subclassNode == null) {

//            return;

//        }

//

//        //if (subclassNode.getParentNode().equals(parentNode)) {

//        parentNode.removeChild(subclassNode);

//        if (parentNode.getChildNodes().length < 1) {

//            parentNode.setExpandable(false);

//        }

//        //}

//    }

    /**

     * Called to update the browser text in the tree

     * @param event The event that describes the browser text change that happened.

     */

    protected void onEntityBrowserTextChanged(BrowserTextChangedEvent event) {

        OWLEntity entity = event.getEntity();

        TreeNode tn = findTreeNode(entity.getIRI().toString());

        if(tn == null) {

            return;

        }

        EntityData ed = (EntityData) tn.getUserObject();

        ed.setBrowserText(event.getNewBrowserText());

        updateTreeNodeRendering(tn);

    }

    protected void onEntityDeprecatedChanged(OWLEntity entity, boolean deprecated) {

        TreeNode tn = findTreeNode(entity.getIRI().toString());

        if(tn == null) {

            return;

        }

        if (tn.getUserObject() instanceof SubclassEntityData) {

            SubclassEntityData entityData = (SubclassEntityData) tn.getUserObject();

            entityData.setDeprecated(deprecated);

            updateTreeNodeRendering(tn);

        }

    }

    protected void onClassCreated(final OWLClass freshClass, final List<OWLClass> superClasses) {

    }

    protected void insertNodeInTree(final TreeNode parentNode, final EntityData child) {

        if (!hasChild(parentNode, child.getName())) {

            parentNode.appendChild(createTreeNode(child));

        }

    }

    private enum CreateClassesMode {

        CREATE_SUBCLASSES,

        IMPORT_CSV

    }

    protected void onCreateCls(CreateClassesMode mode) {

        if (mode == CreateClassesMode.CREATE_SUBCLASSES) {

            createSubClasses();

        }

        else {

            createSubClassesByImportingCSVDocument();

        }

    }

    private void createSubClasses() {

        WebProtegeDialog.showDialog(new CreateEntityDialogController(EntityType.CLASS, new CreateEntityDialogController.CreateEntityHandler() {

            @Override

            public void handleCreateEntity(CreateEntityInfo createEntityInfo) {

                final OWLClass superCls = getSelectedClass();

                final Set<String> browserTexts = new HashSet<String>(createEntityInfo.getBrowserTexts());

                if (browserTexts.size() > 1) {

                    DispatchServiceManager.get().execute(new CreateClassesAction(getProjectId(), superCls, browserTexts), getCreateClassesActionAsyncHandler());

                }

                else {

                    DispatchServiceManager.get().execute(new CreateClassAction(getProjectId(), browserTexts.iterator().next(), superCls), getCreateClassAsyncHandler());

                }

            }

        }));

    }

    private void createSubClassesByImportingCSVDocument() {

        UploadFileDialogController controller = new UploadFileDialogController("Upload CSV", new UploadFileResultHandler() {

            @Override

            public void handleFileUploaded(final DocumentId fileDocumentId) {

                WebProtegeDialog<CSVImportDescriptor> csvImportDialog = new WebProtegeDialog<CSVImportDescriptor>(new CSVImportDialogController(getProjectId(), fileDocumentId, getSelectedClass()));

                csvImportDialog.setVisible(true);

            }

            @Override

            public void handleFileUploadFailed(String errorMessage) {

                UIUtil.hideLoadProgessBar();

                MessageBox.showAlert("Error uploading CSV file", errorMessage);

            }

        });

        WebProtegeDialog.showDialog(controller);

    }

    private AsyncCallback<CreateClassesResult> getCreateClassesActionAsyncHandler() {

        return new AsyncCallback<CreateClassesResult>() {

            @Override

            public void onFailure(Throwable caught) {

                GWT.log("There was a problem creating the classes.  Please try again.");

            }

            @Override

            public void onSuccess(CreateClassesResult result) {

                Set<OWLClass> createdClasses = result.getCreatedClasses();

                for(TreeNode node : getSelectedTreeNodes()) {

                    Set<OWLClass> existingClasses = new HashSet<OWLClass>();

                    for(Node childNode : node.getChildNodes()) {

                        OWLClass childCls = DataFactory.getOWLClass(getNodeClsName(childNode));

                        existingClasses.add(childCls);

                    }

                    for(OWLClass createdCls : createdClasses) {

                        if(!existingClasses.contains(createdCls)) {

                            final SubclassEntityData entityData = new SubclassEntityData(createdCls.getIRI().toString(), result.getBrowserText(createdCls).or(""), Collections.<EntityData>emptySet(), 0);

                            entityData.setValueType(ValueType.Cls);

                            Node n = createTreeNode(entityData);

                            node.appendChild(n);

                        }

                    }

                }

            }

        };

    }

    protected boolean isValidClassName(String value) {

        return value != null && value.length() > 0 && UIUtil.getIdentifierStart(value, value.length()) == 0;

    }

    /**

     * Gets the selected class.

     * @return The selected class, or {@code null} if there is not selection.

     */

    protected OWLClass getSelectedClass() {

        final EntityData currentSelection = getSingleSelection();

        if(currentSelection == null) {

            return null;

        }

        return DataFactory.getOWLClass(currentSelection.getName());

    }

    protected void createCls(final String className) {

        OWLClass superCls = getSelectedClass();

        if(superCls == null) {

            superCls = DataFactory.getOWLThing();

        }

        DispatchServiceManager.get().execute(new CreateClassAction(getProjectId(), className, superCls), getCreateClassAsyncHandler());

    }

    protected AbstractAsyncHandler<CreateClassResult> getCreateClassAsyncHandler() {

        return new CreateClassHandler();

    }

    protected void onDeleteCls() {

        final EntityData currentSelection = getSingleSelection();

        if (currentSelection == null) {

            MessageBox.showAlert("No class selected", "Please select a class to delete.");

            return;

        }

        final String displayName = currentSelection.getBrowserText();

        final String clsName = currentSelection.getName();

        MessageBox.showYesNoConfirmBox("Delete class?", "Are you sure you want to delete class \"" + displayName + "\"?", new YesNoHandler() {

            @Override

            public void handleYes() {

                deleteCls(clsName);

            }

            @Override

            public void handleNo() {

            }

        });

    }

    protected void deleteCls(final String className) {

        GWT.log("Should delete class with name: " + className, null);

        if (className == null) {

            return;

        }

        OWLClass entity = DataFactory.getOWLClass(className);

        DispatchServiceManager.get().execute(new DeleteEntityAction(entity, getProjectId()), new DeleteClassHandler());

        refreshFromServer(500);

    }

    protected void onWatchCls() {

        final OWLClass sel = getSelectedClass();

        if(sel == null) {

            return;

        }

        EntityFrameWatch entityWatch = new EntityFrameWatch(sel);

        DispatchServiceManager.get().execute(new AddWatchAction(entityWatch, getProjectId(), getUserId()), new AsyncCallback<AddWatchResult>() {

            @Override

            public void onFailure(Throwable caught) {

                GWT.log("Problem adding watch");

            }

            @Override

            public void onSuccess(AddWatchResult result) {

            }

        });

    }

    protected void onWatchBranchCls() {

        final OWLClass sel = getSelectedClass();

        if(sel == null) {

            return;

        }

        Watch<?> watch = new HierarchyBranchWatch(sel);

        DispatchServiceManager.get().execute(new AddWatchAction(watch, getProjectId(), getUserId()), new AsyncCallback<AddWatchResult>() {

            @Override

            public void onFailure(Throwable caught) {