Examples with TreeExpansionEvent javax.swing.event.TreeExpansionEvent used on opensource projects

Example 11 with TreeExpansionEvent

use of javax.swing.event.TreeExpansionEvent in project cayenne by apache.

the class DbImportTree method createTreeExpandListener.

private void createTreeExpandListener() {
    TreeExpansionListener treeExpansionListener = new TreeExpansionListener() {

        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            TreePath path = event.getPath();
            Object lastPathComponent = path.getLastPathComponent();
            if (!(lastPathComponent instanceof TransferableNode)) {
                return;
            }
            DbImportTreeNode node = (DbImportTreeNode) lastPathComponent;
            if ((node.isIncludeTable() || node.isSchema() || node.isCatalog()) && !node.isLoaded()) {
                // reload tables and columns action.
                LoadDbSchemaAction action = Application.getInstance().getActionManager().getAction(LoadDbSchemaAction.class);
                action.performAction(null, path);
            }
        }

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
        }
    };
    this.addTreeExpansionListener(treeExpansionListener);
}

Example 12 with TreeExpansionEvent

use of javax.swing.event.TreeExpansionEvent in project omegat by omegat-org.

the class PreferencesWindowController method show.

@SuppressWarnings("serial")
public void show(Window parent, Class<? extends IPreferencesController> initialSelection) {
    dialog = new JDialog();
    dialog.setTitle(OStrings.getString("PREFERENCES_TITLE_NO_SELECTION"));
    dialog.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    dialog.setModal(true);
    StaticUIUtils.setWindowIcon(dialog);
    outerPanel = new PreferencePanel();
    innerPanel = new PreferenceViewSelectorPanel();
    outerPanel.prefsViewPanel.add(innerPanel, BorderLayout.CENTER);
    dialog.getContentPane().add(outerPanel);
    overlay = new HighlightablePanel(dialog.getRootPane(), innerPanel.selectedPrefsScrollPane);
    // Prevent ugly white viewport background with GTK LAF
    innerPanel.selectedPrefsScrollPane.getViewport().setOpaque(false);
    innerPanel.selectedPrefsScrollPane.setBackground(innerPanel.getBackground());
    innerPanel.searchTextField.getDocument().addDocumentListener(new DocumentListener() {

        @Override
        public void removeUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(PreferencesWindowController.this::searchAndFilterTree);
        }

        @Override
        public void insertUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(PreferencesWindowController.this::searchAndFilterTree);
        }

        @Override
        public void changedUpdate(DocumentEvent e) {
            SwingUtilities.invokeLater(PreferencesWindowController.this::searchAndFilterTree);
        }
    });
    innerPanel.searchTextField.addKeyListener(new KeyAdapter() {

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_UP) {
                innerPanel.availablePrefsTree.getActionForKeyStroke(KeyStroke.getKeyStrokeForEvent(e)).actionPerformed(new ActionEvent(innerPanel.availablePrefsTree, 0, null));
                innerPanel.availablePrefsTree.requestFocusInWindow();
                e.consume();
            }
        }
    });
    innerPanel.searchTextField.addFocusListener(new FocusAdapter() {

        @Override
        public void focusGained(FocusEvent e) {
            innerPanel.searchTextField.selectAll();
            searchCurrentView();
            preloadGuis();
        }
    });
    innerPanel.clearButton.addActionListener(e -> {
        innerPanel.searchTextField.clear();
    });
    innerPanel.availablePrefsTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    DefaultMutableTreeNode root = createNodeTree();
    walkTree(root, node -> {
        IPreferencesController view = (IPreferencesController) node.getUserObject();
        if (view != null) {
            view.addFurtherActionListener(this);
        }
    });
    innerPanel.availablePrefsTree.setModel(new DefaultTreeModel(root));
    innerPanel.availablePrefsTree.addTreeSelectionListener(e -> {
        handleViewSelection(e);
        updateTitle();
    });
    innerPanel.availablePrefsTree.addTreeExpansionListener(new TreeExpansionListener() {

        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            SwingUtilities.invokeLater(PreferencesWindowController.this::adjustTreeSize);
        }

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
        }
    });
    innerPanel.selectedPrefsScrollPane.getViewport().setBackground(innerPanel.getBackground());
    DefaultTreeCellRenderer renderer = (DefaultTreeCellRenderer) innerPanel.availablePrefsTree.getCellRenderer();
    renderer.setIcon(null);
    renderer.setLeafIcon(null);
    renderer.setOpenIcon(null);
    renderer.setClosedIcon(null);
    renderer.setDisabledIcon(null);
    outerPanel.okButton.addActionListener(e -> {
        if (currentView == null || currentView.validate()) {
            new SwingWorker<Void, Void>() {

                @Override
                protected Void doInBackground() throws Exception {
                    doSave();
                    return null;
                }

                @Override
                protected void done() {
                    if (getIsReloadRequired()) {
                        SwingUtilities.invokeLater(ProjectUICommands::promptReload);
                    }
                }
            }.execute();
            StaticUIUtils.closeWindowByEvent(dialog);
        }
    });
    outerPanel.cancelButton.addActionListener(e -> StaticUIUtils.closeWindowByEvent(dialog));
    // Hide undo, reset buttons on outer panel
    outerPanel.undoButton.setVisible(false);
    outerPanel.resetButton.setVisible(false);
    // Use ones on inner panel to indicate that actions are view-specific
    innerPanel.undoButton.addActionListener(e -> currentView.undoChanges());
    innerPanel.resetButton.addActionListener(e -> currentView.restoreDefaults());
    dialog.addWindowListener(new WindowAdapter() {

        @Override
        public void windowOpened(WindowEvent e) {
            walkTree(root, node -> {
                // Start with tree fully expanded
                if (node.getChildCount() > 0) {
                    innerPanel.availablePrefsTree.expandPath(new TreePath(node.getPath()));
                }
            });
            SwingUtilities.invokeLater(() -> {
                if (initialSelection != null) {
                    selectView(initialSelection);
                }
            });
        }
    });
    innerPanel.availablePrefsScrollPane.addComponentListener(new ComponentAdapter() {

        @Override
        public void componentResized(ComponentEvent e) {
            SwingUtilities.invokeLater(PreferencesWindowController.this::adjustTreeSize);
        }
    });
    ActionMap actionMap = innerPanel.getActionMap();
    InputMap inputMap = innerPanel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
    actionMap.put(ACTION_KEY_NEW_SEARCH, new AbstractAction() {

        @Override
        public void actionPerformed(ActionEvent e) {
            innerPanel.searchTextField.requestFocusInWindow();
            innerPanel.searchTextField.selectAll();
        }
    });
    KeyStroke searchKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_F, Java8Compat.getMenuShortcutKeyMaskEx());
    inputMap.put(searchKeyStroke, ACTION_KEY_NEW_SEARCH);
    actionMap.put(ACTION_KEY_CLEAR_OR_CLOSE, new AbstractAction() {

        @Override
        public void actionPerformed(ActionEvent e) {
            if (!innerPanel.searchTextField.isEmpty()) {
                // Move focus away from search field
                innerPanel.availablePrefsTree.requestFocusInWindow();
                innerPanel.clearButton.doClick();
            } else {
                StaticUIUtils.closeWindowByEvent(dialog);
            }
        }
    });
    inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), ACTION_KEY_CLEAR_OR_CLOSE);
    // Don't let Enter close the dialog
    innerPanel.searchTextField.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), ACTION_KEY_DO_SEARCH);
    innerPanel.searchTextField.getActionMap().put(ACTION_KEY_DO_SEARCH, new AbstractAction() {

        @Override
        public void actionPerformed(ActionEvent e) {
            searchCurrentView();
        }
    });
    String searchKeyText = StaticUIUtils.getKeyStrokeText(searchKeyStroke);
    innerPanel.searchTextField.setHintText(OStrings.getString("PREFERENCES_SEARCH_HINT", searchKeyText));
    // Set initial state
    searchAndFilterTree();
    adjustTreeSize();
    dialog.getRootPane().setDefaultButton(outerPanel.okButton);
    dialog.setPreferredSize(new Dimension(800, 500));
    dialog.pack();
    // Prevent search field from getting initial focus
    innerPanel.availablePrefsTree.requestFocusInWindow();
    dialog.setLocationRelativeTo(parent);
    dialog.setVisible(true);
}

Example 13 with TreeExpansionEvent

use of javax.swing.event.TreeExpansionEvent in project android by JetBrains.

the class MemoryInstanceView method ensureTreeInitialized.

private void ensureTreeInitialized(@NotNull JPanel parentPanel) {
    if (myTree != null) {
        assert myTreeModel != null && myTreeRoot != null;
        return;
    }
    myTreeRoot = new MemoryObjectTreeNode<>(new InstanceObject() {

        @NotNull
        @Override
        public String getName() {
            return "";
        }
    });
    myTreeModel = new DefaultTreeModel(myTreeRoot);
    JTree tree = new Tree(myTreeModel);
    tree.setRootVisible(false);
    tree.setShowsRootHandles(true);
    tree.addTreeSelectionListener(e -> {
        TreePath path = e.getPath();
        if (!e.isAddedPath()) {
            return;
        }
        assert path.getLastPathComponent() instanceof MemoryObjectTreeNode;
        MemoryObjectTreeNode instanceObject = (MemoryObjectTreeNode) path.getLastPathComponent();
        assert instanceObject.getAdapter() instanceof InstanceObject;
        InstanceObject selectedInstanceObject = (InstanceObject) instanceObject.getAdapter();
        myStage.selectInstance(selectedInstanceObject);
    });
    // Not all nodes have been populated during buildTree. Here we capture the TreeExpansionEvent to check whether any children
    // under the expanded node need to be populated.
    tree.addTreeExpansionListener(new TreeExpansionListener() {

        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            TreePath path = event.getPath();
            assert path.getLastPathComponent() instanceof MemoryObjectTreeNode;
            MemoryObjectTreeNode treeNode = (MemoryObjectTreeNode) path.getLastPathComponent();
            for (int i = 0; i < treeNode.getChildCount(); i++) {
                assert treeNode.getChildAt(i) instanceof MemoryObjectTreeNode;
                MemoryObjectTreeNode childNode = (MemoryObjectTreeNode) treeNode.getChildAt(i);
                // Anything below the top level should be FieldObjects
                assert childNode.getAdapter() instanceof FieldObject;
                FieldObject childObject = (FieldObject) childNode.getAdapter();
                if (childObject.getValueType() == ValueType.OBJECT && childNode.getChildCount() == 0) {
                    populateFields(childNode);
                    myTreeModel.nodeStructureChanged(childNode);
                }
            }
        }

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
        // No-op. TODO remove unseen children?
        }
    });
    assert myClassObject != null;
    List<InstanceAttribute> attributes = myClassObject.getInstanceAttributes();
    ColumnTreeBuilder builder = new ColumnTreeBuilder(tree);
    for (InstanceAttribute attribute : attributes) {
        builder.addColumn(myAttributeColumns.get(attribute).getBuilder());
    }
    builder.setTreeSorter((Comparator<MemoryObjectTreeNode<InstanceObject>> comparator, SortOrder sortOrder) -> {
        myTreeRoot.sort(comparator);
        myTreeModel.nodeStructureChanged(myTreeRoot);
    });
    builder.setBackground(ProfilerColors.MONITOR_BACKGROUND);
    myTree = builder.build();
    parentPanel.add(myTree, BorderLayout.CENTER);
}

Example 14 with TreeExpansionEvent

use of javax.swing.event.TreeExpansionEvent in project intellij-community by JetBrains.

the class ModulesDependenciesPanel method installLeftTreeListeners.

private void installLeftTreeListeners() {
    myLeftTree.addTreeExpansionListener(new TreeExpansionListener() {

        @Override
        public void treeCollapsed(TreeExpansionEvent event) {
        }

        @Override
        public void treeExpanded(TreeExpansionEvent event) {
            DefaultMutableTreeNode expandedNode = (DefaultMutableTreeNode) event.getPath().getLastPathComponent();
            for (int i = 0; i < expandedNode.getChildCount(); i++) {
                DefaultMutableTreeNode child = (DefaultMutableTreeNode) expandedNode.getChildAt(i);
                if (child.getChildCount() == 0 && !isLooped(event.getPath(), child)) {
                    Module module = ((MyUserObject) child.getUserObject()).myModule;
                    for (Module dependency : getModuleDependencies(module)) {
                        child.add(new DefaultMutableTreeNode(new MyUserObject(isInCycle(dependency), dependency)));
                    }
                    TreeUtil.sortRecursively(child, NODE_COMPARATOR);
                }
            }
        }

        private boolean isLooped(TreePath path, DefaultMutableTreeNode child) {
            for (Object o : path.getPath()) {
                DefaultMutableTreeNode node = (DefaultMutableTreeNode) o;
                if (node != child && Comparing.equal(node.getUserObject(), child.getUserObject())) {
                    return true;
                }
            }
            return false;
        }
    });
    myLeftTree.addTreeSelectionListener(new TreeSelectionListener() {

        @Override
        public void valueChanged(TreeSelectionEvent e) {
            TreePath selectionPath = myLeftTree.getSelectionPath();
            if (selectionPath != null) {
                myPathField.setText(StringUtil.join(selectionPath.getPath(), o -> {
                    Object userObject = ((DefaultMutableTreeNode) o).getUserObject();
                    return userObject instanceof MyUserObject ? ((MyUserObject) userObject).myModule.getName() : "";
                }, " : "));
                DefaultMutableTreeNode selection = (DefaultMutableTreeNode) selectionPath.getLastPathComponent();
                if (selection != null) {
                    updateRightTree(((MyUserObject) selection.getUserObject()).myModule);
                }
            }
        }
    });
}

Example 15 with TreeExpansionEvent

use of javax.swing.event.TreeExpansionEvent in project intellij-community by JetBrains.

the class SlicePanel method createTree.

@NotNull
private JTree createTree() {
    DefaultMutableTreeNode root = new DefaultMutableTreeNode();
    final Tree tree = new Tree(new DefaultTreeModel(root));
    tree.setOpaque(false);
    tree.setToggleClickCount(-1);
    SliceUsageCellRendererBase renderer = myProvider.getRenderer();
    renderer.setOpaque(false);
    tree.setCellRenderer(renderer);
    UIUtil.setLineStyleAngled(tree);
    tree.setRootVisible(false);
    tree.setShowsRootHandles(true);
    tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    tree.setSelectionPath(new TreePath(root.getPath()));
    //ActionGroup group = (ActionGroup)ActionManager.getInstance().getAction(IdeActions.GROUP_METHOD_HIERARCHY_POPUP);
    //PopupHandler.installPopupHandler(tree, group, ActionPlaces.METHOD_HIERARCHY_VIEW_POPUP, ActionManager.getInstance());
    EditSourceOnDoubleClickHandler.install(tree);
    new TreeSpeedSearch(tree);
    TreeUtil.installActions(tree);
    ToolTipManager.sharedInstance().registerComponent(tree);
    myAutoScrollToSourceHandler.install(tree);
    tree.getSelectionModel().addTreeSelectionListener(e -> treeSelectionChanged());
    tree.addKeyListener(new KeyAdapter() {

        @Override
        public void keyPressed(KeyEvent e) {
            if (KeyEvent.VK_ENTER == e.getKeyCode()) {
                List<Navigatable> navigatables = getNavigatables();
                if (navigatables.isEmpty())
                    return;
                for (Navigatable navigatable : navigatables) {
                    if (navigatable instanceof AbstractTreeNode && ((AbstractTreeNode) navigatable).getValue() instanceof Usage) {
                        navigatable = (Usage) ((AbstractTreeNode) navigatable).getValue();
                    }
                    if (navigatable.canNavigateToSource()) {
                        navigatable.navigate(false);
                        if (navigatable instanceof Usage) {
                            ((Usage) navigatable).highlightInEditor();
                        }
                    }
                }
                e.consume();
            }
        }
    });
    tree.addTreeWillExpandListener(new TreeWillExpandListener() {

        @Override
        public void treeWillCollapse(TreeExpansionEvent event) {
        }

        @Override
        public void treeWillExpand(TreeExpansionEvent event) {
            TreePath path = event.getPath();
            SliceNode node = fromPath(path);
            node.calculateDupNode();
        }
    });
    return tree;
}