com.intellij.packageDependencies.ui.PackageDependenciesNode.java Source code

Introduction

Here is the source code for com.intellij.packageDependencies.ui.PackageDependenciesNode.java

Source

/*
 * Copyright 2000-2009 JetBrains s.r.o.
 *
 * 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.intellij.packageDependencies.ui;

import com.intellij.analysis.AnalysisScopeBundle;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.fileEditor.OpenFileDescriptor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.pom.Navigatable;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiManager;
import com.intellij.ui.Gray;
import com.intellij.util.IconUtil;
import com.intellij.util.ui.EmptyIcon;
import com.intellij.util.ui.tree.TreeUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import java.awt.*;
import java.util.*;
import java.util.List;

public class PackageDependenciesNode extends DefaultMutableTreeNode implements Navigatable {
    private static final EmptyIcon EMPTY_ICON = new EmptyIcon(0, IconUtil.getEmptyIcon(false).getIconHeight());

    private Set<VirtualFile> myRegisteredFiles = null;
    private boolean myHasUnmarked = false;
    private boolean myHasMarked = false;
    private boolean myEquals;
    protected Color myColor = null;
    protected static final Color NOT_CHANGED = Gray._0;
    protected Project myProject;
    private boolean mySorted;

    public PackageDependenciesNode(@NotNull Project project) {
        myProject = project;
    }

    public void setEquals(final boolean equals) {
        myEquals = equals;
    }

    public boolean isEquals() {
        return myEquals;
    }

    public void fillFiles(Set<PsiFile> set, boolean recursively) {
        final PsiManager psiManager = PsiManager.getInstance(myProject);
        for (VirtualFile vFile : getRegisteredFiles()) {
            final PsiFile psiFile = psiManager.findFile(vFile);
            if (psiFile != null && psiFile.isValid()) {
                set.add(psiFile);
            }
        }
    }

    public void addFile(VirtualFile file, boolean isMarked) {
        getRegisteredFiles().add(file);
        updateMarked(!isMarked, isMarked);
    }

    public Icon getIcon() {
        return EMPTY_ICON;
    }

    public int getWeight() {
        return 0;
    }

    public boolean hasUnmarked() {
        return myHasUnmarked;
    }

    public boolean hasMarked() {
        return myHasMarked;
    }

    @Nullable
    public PsiElement getPsiElement() {
        return null;
    }

    @Nullable
    public Color getColor() {
        return myColor;
    }

    public void updateColor() {
        myColor = null;
    }

    public int getContainingFiles() {
        int result = 0;
        for (int i = 0; i < getChildCount(); i++) {
            result += ((PackageDependenciesNode) getChildAt(i)).getContainingFiles();
        }
        return result;
    }

    public String getPresentableFilesCount() {
        final int filesCount = getContainingFiles();
        return filesCount > 0
                ? " (" + AnalysisScopeBundle.message("package.dependencies.node.items.count", filesCount) + ")"
                : "";
    }

    @Override
    public void add(MutableTreeNode newChild) {
        super.add(newChild);
        boolean hasUnmarked = ((PackageDependenciesNode) newChild).hasUnmarked();
        boolean hasMarked = ((PackageDependenciesNode) newChild).hasMarked();
        updateMarked(hasUnmarked, hasMarked);
    }

    private void updateMarked(boolean hasUnmarked, boolean hasMarked) {
        if (hasUnmarked && !myHasUnmarked || hasMarked && !myHasMarked) {
            myHasUnmarked |= hasUnmarked;
            myHasMarked |= hasMarked;
            PackageDependenciesNode parent = (PackageDependenciesNode) getParent();
            if (parent != null) {
                parent.updateMarked(myHasUnmarked, myHasMarked);
            }
        }
    }

    @Override
    public void navigate(boolean focus) {
        if (canNavigate()) {
            openTextEditor(focus);
        }
    }

    @Nullable
    private Editor openTextEditor(boolean focus) {
        final OpenFileDescriptor descriptor = getDescriptor();
        if (descriptor != null) {
            return FileEditorManager.getInstance(getProject()).openTextEditor(descriptor, focus);
        }
        return null;
    }

    @Override
    public boolean canNavigate() {
        if (getProject() == null)
            return false;
        final PsiElement psiElement = getPsiElement();
        if (psiElement == null)
            return false;
        final VirtualFile virtualFile = psiElement.getContainingFile().getVirtualFile();
        return virtualFile != null && virtualFile.isValid();
    }

    @Override
    public boolean canNavigateToSource() {
        return canNavigate();
    }

    @Nullable
    private Project getProject() {
        final PsiElement psiElement = getPsiElement();
        if (psiElement == null || psiElement.getContainingFile() == null) {
            return null;
        }
        return psiElement.getContainingFile().getProject();
    }

    @Nullable
    private OpenFileDescriptor getDescriptor() {
        if (getProject() == null)
            return null;
        final PsiElement psiElement = getPsiElement();
        if (psiElement == null)
            return null;
        final VirtualFile virtualFile = psiElement.getContainingFile().getVirtualFile();
        if (virtualFile == null || !virtualFile.isValid())
            return null;
        return new OpenFileDescriptor(getProject(), virtualFile, psiElement.getTextOffset());
    }

    @Override
    public Object getUserObject() {
        return toString();
    }

    public boolean isValid() {
        return true;
    }

    public Set<VirtualFile> getRegisteredFiles() {
        if (myRegisteredFiles == null) {
            myRegisteredFiles = new HashSet<VirtualFile>();
        }
        return myRegisteredFiles;
    }

    @Nullable
    public String getComment() {
        return null;
    }

    public boolean canSelectInLeftTree(Map<PsiFile, Set<PsiFile>> deps) {
        return false;
    }

    public boolean isSorted() {
        return mySorted;
    }

    public void setSorted(boolean sorted) {
        mySorted = sorted;
    }

    public void sortChildren() {
        if (isSorted())
            return;
        final List children = TreeUtil.childrenToArray(this);
        Collections.sort(children, new DependencyNodeComparator());
        removeAllChildren();
        TreeUtil.addChildrenTo(this, children);
        setSorted(true);
    }
}