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); }