private static void expandFirstLevel(Tree tree) {
PackageDependenciesNode root = (PackageDependenciesNode) tree.getModel().getRoot();
int count = root.getChildCount();
if (count < 10) {
for (int i = 0; i < count; i++) {
PackageDependenciesNode child = (PackageDependenciesNode) root.getChildAt(i);
expandNodeIfNotTooWide(tree, child);
}
}
}
public void refreshData(User user, ProjectsData data) {
assert data != null;
assert user != null;
myUser = user;
myProjectsData = data;
((DefaultTreeModel) myTree.getModel()).setRoot(new MyRootNode());
TreeUtils.expandAll(myTree);
}
@Override
public void actionPerformed(AnActionEvent e) {
final List<Descriptor> descriptors = new ArrayList<Descriptor>();
final InspectionConfigTreeNode[] selectedNodes =
myTree.getSelectedNodes(InspectionConfigTreeNode.class, null);
LOG.assertTrue(selectedNodes != null);
final List<InspectionConfigTreeNode> nodes =
new ArrayList<InspectionConfigTreeNode>(Arrays.asList(selectedNodes));
for (InspectionConfigTreeNode node : selectedNodes) {
collect(descriptors, nodes, node);
}
final Project project = PlatformDataKeys.PROJECT.getData(e.getDataContext());
final List<String> availableScopes = getAvailableScopes(project, descriptors);
final int idx =
Messages.showChooseDialog(
myTree,
"Scope:",
"Choose Scope",
ArrayUtil.toStringArray(availableScopes),
availableScopes.get(0),
Messages.getQuestionIcon());
if (idx == -1) return;
final NamedScope chosenScope = NamedScopesHolder.getScope(project, availableScopes.get(idx));
for (InspectionConfigTreeNode node : nodes) {
final Descriptor descriptor = node.getDesriptor();
if (node.getScopeName() != null || descriptor == null) continue;
final InspectionProfileEntry tool = descriptor.getTool(); // copy
final ScopeToolState scopeToolState =
getSelectedProfile()
.addScope(
tool,
chosenScope,
getSelectedProfile().getErrorLevel(descriptor.getKey(), chosenScope),
getSelectedProfile().isToolEnabled(descriptor.getKey()));
final Descriptor addedDescriptor = new Descriptor(scopeToolState, getSelectedProfile());
if (node.getChildCount() == 0) {
node.add(
new InspectionConfigTreeNode(
descriptor,
getSelectedProfile().getToolDefaultState(descriptor.getKey().toString()),
true,
true,
false));
}
node.insert(new InspectionConfigTreeNode(addedDescriptor, scopeToolState, false, false), 0);
node.setInspectionNode(false);
node.dropCache();
((DefaultTreeModel) myTree.getModel()).reload(node);
myTree.expandPath(new TreePath(node.getPath()));
}
myTree.revalidate();
}
protected void initTree() {
((DefaultTreeModel) myTree.getModel()).setRoot(myRoot);
myTree.setRootVisible(false);
myTree.setShowsRootHandles(true);
UIUtil.setLineStyleAngled(myTree);
TreeUtil.installActions(myTree);
myTree.setCellRenderer(
new ColoredTreeCellRenderer() {
public void customizeCellRenderer(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
if (value instanceof MyNode) {
final MyNode node = ((MyNode) value);
setIcon(node.getIcon(expanded));
final Font font = UIUtil.getTreeFont();
if (node.isDisplayInBold()) {
setFont(font.deriveFont(Font.BOLD));
} else {
setFont(font.deriveFont(Font.PLAIN));
}
append(
node.getDisplayName(),
node.isDisplayInBold()
? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES
: SimpleTextAttributes.REGULAR_ATTRIBUTES);
}
}
});
initToolbar();
ArrayList<AnAction> actions = createActions(true);
if (actions != null) {
final DefaultActionGroup group = new DefaultActionGroup();
for (AnAction action : actions) {
group.add(action);
}
actions = getAdditionalActions();
if (actions != null) {
group.addSeparator();
for (AnAction action : actions) {
group.add(action);
}
}
PopupHandler.installPopupHandler(
myTree,
group,
ActionPlaces.UNKNOWN,
ActionManager.getInstance()); // popup should follow the selection
}
}
public void update() {
if (myFileSystemTree != null) {
myFileSystemTree.updateTree();
final DefaultTreeModel model = (DefaultTreeModel) myTree.getModel();
final int visibleRowCount = myTree.getVisibleRowCount();
for (int row = 0; row < visibleRowCount; row++) {
final TreePath pathForRow = myTree.getPathForRow(row);
if (pathForRow != null) {
final TreeNode node = (TreeNode) pathForRow.getLastPathComponent();
if (node != null) {
model.nodeChanged(node);
}
}
}
}
}
protected void removePaths(final TreePath... paths) {
MyNode parentNode = null;
int idx = -1;
for (TreePath path : paths) {
final MyNode node = (MyNode) path.getLastPathComponent();
final NamedConfigurable namedConfigurable = node.getConfigurable();
final Object editableObject = namedConfigurable.getEditableObject();
parentNode = (MyNode) node.getParent();
idx = parentNode.getIndex(node);
((DefaultTreeModel) myTree.getModel()).removeNodeFromParent(node);
myHasDeletedItems |= wasObjectStored(editableObject);
fireItemsChangeListener(editableObject);
onItemDeleted(editableObject);
namedConfigurable.disposeUIResources();
}
if (paths.length > 0) {
if (parentNode != null && idx != -1) {
DefaultMutableTreeNode toSelect = null;
if (idx < parentNode.getChildCount()) {
toSelect = (DefaultMutableTreeNode) parentNode.getChildAt(idx);
} else {
if (idx > 0 && parentNode.getChildCount() > 0) {
if (idx - 1 < parentNode.getChildCount()) {
toSelect = (DefaultMutableTreeNode) parentNode.getChildAt(idx - 1);
} else {
toSelect = (DefaultMutableTreeNode) parentNode.getFirstChild();
}
} else {
if (parentNode.isRoot() && myTree.isRootVisible()) {
toSelect = parentNode;
} else if (parentNode.getChildCount() > 0) {
toSelect = (DefaultMutableTreeNode) parentNode.getFirstChild();
}
}
}
if (toSelect != null) {
TreeUtil.selectInTree(toSelect, true, myTree);
}
} else {
TreeUtil.selectFirstNode(myTree);
}
}
}
public void reset() {
loadComponentState();
myHasDeletedItems = false;
((DefaultTreeModel) myTree.getModel()).reload();
// myTree.requestFocus();
myState.getProportions().restoreSplitterProportions(myWholePanel);
final Enumeration enumeration = myRoot.breadthFirstEnumeration();
boolean selected = false;
while (enumeration.hasMoreElements()) {
final MyNode node = (MyNode) enumeration.nextElement();
if (node instanceof MyRootNode) continue;
final String path = getNodePathString(node);
if (!selected && Comparing.strEqual(path, myState.getLastEditedConfigurable())) {
TreeUtil.selectInTree(node, false, myTree);
selected = true;
}
}
if (!selected) {
TreeUtil.selectFirstNode(myTree);
}
updateSelectionFromTree();
}
protected void sortDescendants(MyNode root) {
TreeUtil.sort(root, getNodeComparator());
((DefaultTreeModel) myTree.getModel()).reload(root);
}
protected void addNode(MyNode nodeToAdd, MyNode parent) {
int i = TreeUtil.indexedBinarySearch(parent, nodeToAdd, getNodeComparator());
int insertionPoint = i >= 0 ? i : -i - 1;
((DefaultTreeModel) myTree.getModel()).insertNodeInto(nodeToAdd, parent, insertionPoint);
}
public StructureViewComponent(
final FileEditor editor,
final StructureViewModel structureViewModel,
final Project project,
final boolean showRootNode) {
super(true, true);
myProject = project;
myFileEditor = editor;
myTreeModel = structureViewModel;
myTreeModelWrapper = new TreeModelWrapper(myTreeModel, this);
SmartTreeStructure treeStructure =
new SmartTreeStructure(project, myTreeModelWrapper) {
public void rebuildTree() {
if (!isDisposed()) {
super.rebuildTree();
}
}
public boolean isToBuildChildrenInBackground(final Object element) {
return getRootElement() == element;
}
protected TreeElementWrapper createTree() {
return new StructureViewTreeElementWrapper(myProject, myModel.getRoot(), myModel);
}
@Override
public String toString() {
return "structure view tree structure(model=" + myTreeModel + ")";
}
};
final DefaultTreeModel model =
new DefaultTreeModel(new DefaultMutableTreeNode(treeStructure.getRootElement()));
myTree = new Tree(model);
myTree.setRootVisible(showRootNode);
myTree.setShowsRootHandles(true);
myAbstractTreeBuilder =
new StructureTreeBuilder(
project,
myTree,
(DefaultTreeModel) myTree.getModel(),
treeStructure,
myTreeModelWrapper) {
@Override
protected boolean validateNode(Object child) {
return isValid(child);
}
};
Disposer.register(this, myAbstractTreeBuilder);
Disposer.register(
myAbstractTreeBuilder,
new Disposable() {
public void dispose() {
storeState();
}
});
setContent(ScrollPaneFactory.createScrollPane(myAbstractTreeBuilder.getTree()));
myAbstractTreeBuilder.getTree().setCellRenderer(new NodeRenderer());
myAutoScrollToSourceHandler = new MyAutoScrollToSourceHandler();
myAutoScrollFromSourceHandler = new MyAutoScrollFromSourceHandler(myProject, this);
JComponent toolbarComponent =
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.STRUCTURE_VIEW_TOOLBAR, createActionGroup(), true)
.getComponent();
setToolbar(toolbarComponent);
installTree();
myCopyPasteDelegator =
new CopyPasteDelegator(myProject, getTree()) {
@NotNull
protected PsiElement[] getSelectedElements() {
return getSelectedPsiElements();
}
};
}
@Override
protected JComponent createCenterPanel() {
final FileChooserDescriptor descriptor =
FileChooserDescriptorFactory.createAllButJarContentsDescriptor();
calculateRoots();
final ArrayList<VirtualFile> list = new ArrayList<VirtualFile>(myRoots);
final Comparator<VirtualFile> comparator =
new Comparator<VirtualFile>() {
@Override
public int compare(VirtualFile o1, VirtualFile o2) {
final boolean isDir1 = o1.isDirectory();
final boolean isDir2 = o2.isDirectory();
if (isDir1 != isDir2) return isDir1 ? -1 : 1;
final String module1 = myModulesSet.get(o1);
final String path1 = module1 != null ? module1 : o1.getPath();
final String module2 = myModulesSet.get(o2);
final String path2 = module2 != null ? module2 : o2.getPath();
return path1.compareToIgnoreCase(path2);
}
};
descriptor.setRoots(list);
myTree = new Tree();
myTree.setMinimumSize(new Dimension(200, 200));
myTree.setBorder(BORDER);
myTree.setShowsRootHandles(true);
myTree.setRootVisible(true);
myTree.getExpandableItemsHandler().setEnabled(false);
final MyCheckboxTreeCellRenderer cellRenderer =
new MyCheckboxTreeCellRenderer(
mySelectionManager, myModulesSet, myProject, myTree, myRoots);
final FileSystemTreeImpl fileSystemTree =
new FileSystemTreeImpl(
myProject,
descriptor,
myTree,
cellRenderer,
null,
new Convertor<TreePath, String>() {
@Override
public String convert(TreePath o) {
final DefaultMutableTreeNode lastPathComponent =
((DefaultMutableTreeNode) o.getLastPathComponent());
final Object uo = lastPathComponent.getUserObject();
if (uo instanceof FileNodeDescriptor) {
final VirtualFile file = ((FileNodeDescriptor) uo).getElement().getFile();
final String module = myModulesSet.get(file);
if (module != null) return module;
return file == null ? "" : file.getName();
}
return o.toString();
}
});
final AbstractTreeUi ui = fileSystemTree.getTreeBuilder().getUi();
ui.setNodeDescriptorComparator(
new Comparator<NodeDescriptor>() {
@Override
public int compare(NodeDescriptor o1, NodeDescriptor o2) {
if (o1 instanceof FileNodeDescriptor && o2 instanceof FileNodeDescriptor) {
final VirtualFile f1 = ((FileNodeDescriptor) o1).getElement().getFile();
final VirtualFile f2 = ((FileNodeDescriptor) o2).getElement().getFile();
return comparator.compare(f1, f2);
}
return o1.getIndex() - o2.getIndex();
}
});
myRoot = (DefaultMutableTreeNode) myTree.getModel().getRoot();
new ClickListener() {
@Override
public boolean onClick(@NotNull MouseEvent e, int clickCount) {
int row = myTree.getRowForLocation(e.getX(), e.getY());
if (row < 0) return false;
final Object o = myTree.getPathForRow(row).getLastPathComponent();
if (myRoot == o || getFile(o) == null) return false;
Rectangle rowBounds = myTree.getRowBounds(row);
cellRenderer.setBounds(rowBounds);
Rectangle checkBounds = cellRenderer.myCheckbox.getBounds();
checkBounds.setLocation(rowBounds.getLocation());
if (checkBounds.height == 0) checkBounds.height = rowBounds.height;
if (checkBounds.contains(e.getPoint())) {
mySelectionManager.toggleSelection((DefaultMutableTreeNode) o);
myTree.revalidate();
myTree.repaint();
}
return true;
}
}.installOn(myTree);
myTree.addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_SPACE) {
TreePath[] paths = myTree.getSelectionPaths();
if (paths == null) return;
for (TreePath path : paths) {
if (path == null) continue;
final Object o = path.getLastPathComponent();
if (myRoot == o || getFile(o) == null) return;
mySelectionManager.toggleSelection((DefaultMutableTreeNode) o);
}
myTree.revalidate();
myTree.repaint();
e.consume();
}
}
});
JBPanel panel = new JBPanel(new BorderLayout());
panel.add(new JBScrollPane(fileSystemTree.getTree()), BorderLayout.CENTER);
mySelectedLabel = new JLabel("");
mySelectedLabel.setBorder(BorderFactory.createEmptyBorder(2, 0, 2, 0));
panel.add(mySelectedLabel, BorderLayout.SOUTH);
mySelectionManager.setSelectionChangeListener(
new PlusMinus<VirtualFile>() {
@Override
public void plus(VirtualFile virtualFile) {
mySelectedFiles.add(virtualFile);
recalculateErrorText();
}
private void recalculateErrorText() {
checkEmpty();
if (mySelectionManager.canAddSelection()) {
mySelectedLabel.setText("");
} else {
mySelectedLabel.setText(CAN_NOT_ADD_TEXT);
}
mySelectedLabel.revalidate();
}
@Override
public void minus(VirtualFile virtualFile) {
mySelectedFiles.remove(virtualFile);
recalculateErrorText();
}
});
return panel;
}
/** @param contentEntryEditor : null means to clear the editor */
public void setContentEntryEditor(final ContentEntryEditor contentEntryEditor) {
if (myContentEntryEditor != null && myContentEntryEditor.equals(contentEntryEditor)) {
return;
}
if (myFileSystemTree != null) {
Disposer.dispose(myFileSystemTree);
myFileSystemTree = null;
}
if (myContentEntryEditor != null) {
myContentEntryEditor.removeContentEntryEditorListener(myContentEntryEditorListener);
myContentEntryEditor = null;
}
if (contentEntryEditor == null) {
((DefaultTreeModel) myTree.getModel()).setRoot(EMPTY_TREE_ROOT);
myTreePanel.setVisible(false);
if (myFileSystemTree != null) {
Disposer.dispose(myFileSystemTree);
}
return;
}
myTreePanel.setVisible(true);
myContentEntryEditor = contentEntryEditor;
myContentEntryEditor.addContentEntryEditorListener(myContentEntryEditorListener);
final ContentEntry entry = contentEntryEditor.getContentEntry();
assert entry != null : contentEntryEditor;
final VirtualFile file = entry.getFile();
myDescriptor.setRoots(file);
if (file == null) {
final String path = VfsUtilCore.urlToPath(entry.getUrl());
myDescriptor.setTitle(FileUtil.toSystemDependentName(path));
}
final Runnable init =
new Runnable() {
@Override
public void run() {
//noinspection ConstantConditions
myFileSystemTree.updateTree();
myFileSystemTree.select(file, null);
}
};
myFileSystemTree =
new FileSystemTreeImpl(
myProject, myDescriptor, myTree, getContentEntryCellRenderer(), init, null) {
@Override
protected AbstractTreeBuilder createTreeBuilder(
JTree tree,
DefaultTreeModel treeModel,
AbstractTreeStructure treeStructure,
Comparator<NodeDescriptor> comparator,
FileChooserDescriptor descriptor,
final Runnable onInitialized) {
return new MyFileTreeBuilder(
tree, treeModel, treeStructure, comparator, descriptor, onInitialized);
}
};
myFileSystemTree.showHiddens(true);
Disposer.register(myProject, myFileSystemTree);
final NewFolderAction newFolderAction = new MyNewFolderAction();
final DefaultActionGroup mousePopupGroup = new DefaultActionGroup();
mousePopupGroup.add(myEditingActionsGroup);
mousePopupGroup.addSeparator();
mousePopupGroup.add(newFolderAction);
myFileSystemTree.registerMouseListener(mousePopupGroup);
}
public ResourcePanel(AndroidFacet facet, ResourceType[] types, boolean system) {
myTree = new Tree();
myTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode()));
myTree.setScrollsOnExpand(true);
myTree.setRootVisible(false);
myTree.setShowsRootHandles(true);
new DoubleClickListener() {
@Override
protected boolean onDoubleClick(MouseEvent e) {
if (!myTreeBuilder.getSelectedElements(ResourceItem.class).isEmpty()) {
close(OK_EXIT_CODE);
return true;
}
return false;
}
}.installOn(myTree);
ToolTipManager.sharedInstance().registerComponent(myTree);
TreeUtil.installActions(myTree);
myManager = facet.getResourceManager(system ? AndroidUtils.SYSTEM_RESOURCE_PACKAGE : null);
myGroups = new ResourceGroup[types.length];
for (int i = 0; i < types.length; i++) {
myGroups[i] = new ResourceGroup(types[i], myManager);
}
myTreeBuilder =
new AbstractTreeBuilder(
myTree,
(DefaultTreeModel) myTree.getModel(),
new TreeContentProvider(myGroups),
null);
myTreeBuilder.initRootNode();
TreeSelectionModel selectionModel = myTree.getSelectionModel();
selectionModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
selectionModel.addTreeSelectionListener(ChooseResourceDialog.this);
myTree.setCellRenderer(new NodeRenderer());
new TreeSpeedSearch(myTree, TreeSpeedSearch.NODE_DESCRIPTOR_TOSTRING, true);
myComponent = new JBSplitter(true, 0.8f);
myComponent.setSplitterProportionKey("android.resource_dialog_splitter");
myComponent.setFirstComponent(ScrollPaneFactory.createScrollPane(myTree));
myPreviewPanel = new JPanel(new CardLayout());
myComponent.setSecondComponent(myPreviewPanel);
myTextArea = new JTextArea(5, 20);
myTextArea.setEditable(false);
myPreviewPanel.add(ScrollPaneFactory.createScrollPane(myTextArea), TEXT);
myComboTextArea = new JTextArea(5, 20);
myComboTextArea.setEditable(false);
myComboBox = new JComboBox();
myComboBox.setMaximumRowCount(15);
myComboBox.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
java.util.List<ResourceElement> resources =
(java.util.List<ResourceElement>) myComboBox.getClientProperty(COMBO);
myComboTextArea.setText(
getResourceElementValue(resources.get(myComboBox.getSelectedIndex())));
}
});
JPanel comboPanel =
new JPanel(
new BorderLayout(0, 1) {
@Override
public void layoutContainer(Container target) {
super.layoutContainer(target);
Rectangle bounds = myComboBox.getBounds();
Dimension size = myComboBox.getPreferredSize();
size.width += 20;
myComboBox.setBounds(
(int) bounds.getMaxX() - size.width, bounds.y, size.width, size.height);
}
});
comboPanel.add(ScrollPaneFactory.createScrollPane(myComboTextArea), BorderLayout.CENTER);
comboPanel.add(myComboBox, BorderLayout.SOUTH);
myPreviewPanel.add(comboPanel, COMBO);
myImageComponent = new JLabel();
myImageComponent.setHorizontalAlignment(SwingConstants.CENTER);
myImageComponent.setVerticalAlignment(SwingConstants.CENTER);
myPreviewPanel.add(myImageComponent, IMAGE);
myNoPreviewComponent = new JLabel("No Preview");
myNoPreviewComponent.setHorizontalAlignment(SwingConstants.CENTER);
myNoPreviewComponent.setVerticalAlignment(SwingConstants.CENTER);
myPreviewPanel.add(myNoPreviewComponent, NONE);
}
