Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
283,700 | void (JTree tree) { } | setTree |
283,701 | Component (JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) { int modelRow = table.convertRowIndexToModel(row); final boolean lineHasFocus = table.hasFocus(); if (myTreeCellRenderer != null) myTree.setCellRenderer(myTreeCellRenderer); if (isSelected){ myTree.setBackground(lineHasFocus ? RenderingUtil.getSelectionBackground(table) : UIUtil.getTreeUnfocusedSelectionBackground()); myTree.setForeground(RenderingUtil.getSelectionForeground(table)); } else { myTree.setBackground(RenderingUtil.getBackground(table)); myTree.setForeground(RenderingUtil.getForeground(table)); } myCellRendererComponent.setBackground(isSelected ? RenderingUtil.getSelectionBackground(table) : RenderingUtil.getBackground(table)); myCellRendererComponent.setForeground(isSelected ? RenderingUtil.getSelectionForeground(table) : RenderingUtil.getForeground(table)); //TableModel model = myTreeTable.getModel(); //myTree.setTreeTableTreeBorder(hasFocus && model.getColumnClass(column).equals(TreeTableModel.class) ? myDefaultBorder : null); myTree.setVisibleRow(modelRow); final Object treeObject = myTree.getPathForRow(modelRow).getLastPathComponent(); boolean leaf = myTree.getModel().isLeaf(treeObject); final boolean expanded = myTree.isExpanded(modelRow); Component component = myTree.getCellRenderer().getTreeCellRendererComponent(myTree, treeObject, isSelected, expanded, leaf, modelRow, lineHasFocus); if (component instanceof JComponent) { table.setToolTipText(((JComponent)component).getToolTipText()); } //myTree.setCellFocused(false); myCellRendererComponent.setComponent(component, expanded, leaf); return myCellRendererComponent; } | getTableCellRendererComponent |
283,702 | void (TreeCellRenderer treeCellRenderer) { myTreeCellRenderer = treeCellRenderer; } | setCellRenderer |
283,703 | void (Border border) { myDefaultBorder = border; } | setDefaultBorder |
283,704 | void (String key, Object value) { myTree.putClientProperty(key, value); } | putClientProperty |
283,705 | void (String s, String s1) { putClientProperty(s, (Object)s1); } | putClientProperty |
283,706 | void (boolean b) { myTree.setRootVisible(b); } | setRootVisible |
283,707 | void (boolean b) { myTree.setShowsRootHandles(b); } | setShowsRootHandles |
283,708 | void (Component component, boolean expanded, boolean leaf) { myComponent = component; myExpanded = expanded; myLeaf = leaf; // Since we wrap a new component, we need to reset our accessible context accessibleContext = null; // By adding the tree as our only child, we ensure the row corresponding // to the cell will be painted inside our bounds. if (getComponentCount() == 0) { add(myTree, BorderLayout.CENTER); } } | setComponent |
283,709 | AccessibleContext () { // Return the accessible context of the component we wrap (if it is accessible) if (accessibleContext == null) { if ((myComponent instanceof Accessible) && (myComponent.getAccessibleContext() != null)) { accessibleContext = new AccessibleTableCellRendererComponent(myComponent.getAccessibleContext()); } else { // If myComponent is not accessible -- which should be rare for a fully accessible application, // returning the default JPanel accessibility context is a reasonable default. accessibleContext = super.getAccessibleContext(); } } return accessibleContext; } | getAccessibleContext |
283,710 | Container () { return myComponent.getParent(); } | getDelegateParent |
283,711 | AccessibleStateSet () { AccessibleStateSet set = super.getAccessibleStateSet(); if (!myLeaf) { // Add expandable+expanded/collapsed states so that screen readers announce // that this is an item that can be expanded (or collapsed). set.add(AccessibleState.EXPANDABLE); set.add(myExpanded ? AccessibleState.EXPANDED : AccessibleState.COLLAPSED); } return set; } | getAccessibleStateSet |
283,712 | void (TreeExpansionEvent event) { fireTableDataChanged(); } | treeExpanded |
283,713 | void (TreeExpansionEvent event) { fireTableDataChanged(); } | treeCollapsed |
283,714 | void (TreeModelEvent e) { delayedFireTableDataChanged(); } | treeNodesChanged |
283,715 | void (TreeModelEvent e) { delayedFireTableDataChanged(); } | treeNodesInserted |
283,716 | void (TreeModelEvent e) { delayedFireTableDataChanged(); } | treeNodesRemoved |
283,717 | void (TreeModelEvent e) { delayedFireTableDataChanged(); } | treeStructureChanged |
283,718 | int () { return treeTableModel.getColumnCount(); } | getColumnCount |
283,719 | String (int column) { return treeTableModel.getColumnName(column); } | getColumnName |
283,720 | Class (int column) { return treeTableModel.getColumnClass(column); } | getColumnClass |
283,721 | int () { return tree.getRowCount(); } | getRowCount |
283,722 | Object (int row) { TreePath treePath = tree.getPathForRow(row); return treePath == null ? null : treePath.getLastPathComponent(); } | nodeForRow |
283,723 | Object (int row, int column) { final Object o = nodeForRow(row); return o == null? null : treeTableModel.getValueAt(o, column); } | getValueAt |
283,724 | boolean (int row, int column) { final Object o = nodeForRow(row); return o != null && treeTableModel.isCellEditable(o, column); } | isCellEditable |
283,725 | void (Object value, int row, int column) { final Object o = nodeForRow(row); if (o != null) treeTableModel.setValueAt(value, o, column); } | setValueAt |
283,726 | void () { long stamp = modificationStamp.incrementAndGet(); ApplicationManager.getApplication().invokeLater(() -> { if (stamp != modificationStamp.get()) return; fireTableDataChanged(); }, ModalityState.any()); } | delayedFireTableDataChanged |
283,727 | void () { // have to restore table selection since AbstractDataModel.fireTableDataChanged() clears all selection final TreePath[] treePaths = tree.getSelectionPaths(); super.fireTableDataChanged(); if (treePaths != null) { for (TreePath treePath : treePaths) { final int row = tree.getRowForPath(treePath); table.getSelectionModel().addSelectionInterval(row, row); } } } | fireTableDataChanged |
283,728 | void (JTree tree) { myTree = tree; } | setTree |
283,729 | int () { return myColumns.length; } | getColumnCount |
283,730 | String (int column) { return myColumns[column].getName(); } | getColumnName |
283,731 | Object (Object value, int column) { return myColumns[column].valueOf(value); } | getValueAt |
283,732 | Object (Object parent, int index) { return ((TreeNode) parent).getChildAt(index); } | getChild |
283,733 | Object (final int row) { final TreePath path = myTree.getPathForRow(row); if (path != null) { return path.getLastPathComponent(); } return null; } | getRowValue |
283,734 | int (Object parent) { return ((TreeNode) parent).getChildCount(); } | getChildCount |
283,735 | Class (int column) { return myColumns[column].getColumnClass(); } | getColumnClass |
283,736 | ColumnInfo[] () { return myColumns; } | getColumns |
283,737 | boolean (Object node, int column) { return myColumns[column].isCellEditable(node); } | isCellEditable |
283,738 | void (Object aValue, Object node, int column) { myColumns[column].setValue(node, aValue); } | setValueAt |
283,739 | boolean (ColumnInfo[] columns) { if (myColumns != null && Arrays.equals(myColumns, columns)) { return false; } myColumns = columns; return true; } | setColumns |
283,740 | ColumnInfo[] () { return myColumns; } | getColumnInfos |
283,741 | List () { ArrayList result = new ArrayList(); TreeNode root = (TreeNode) getRoot(); for (int i = 0; i < root.getChildCount(); i++) { addElementsToCollection(root.getChildAt(i), result); } return result; } | getItems |
283,742 | void (TreeNode parent, Collection collection) { collection.add(parent); Enumeration children = parent.children(); if (children == null) return; while(children.hasMoreElements()){ TreeNode child = (TreeNode) children.nextElement(); addElementsToCollection(child, collection); } } | addElementsToCollection |
283,743 | void (boolean aBoolean) { } | setSortable |
283,744 | boolean () { return false; } | isSortable |
283,745 | JTree () { JTree tree = !myProcessCursorKeys ? null : getTree(); if (tree == null || 1 != getSelectedRowCount()) return null; if (!getColumnModel().getColumnSelectionAllowed()) return tree; int column = getColumnModel().getSelectionModel().getAnchorSelectionIndex(); return 0 <= column && column < getColumnCount() && !isTreeColumn(column) ? null : tree; } | getTreeToPerformAction |
283,746 | void (ActionEvent event) { JTree tree = getTreeToPerformAction(); Action action = tree == null ? null : tree.getActionMap().get(actionId); if (action == null) { this.action.actionPerformed(event); } else { action.actionPerformed(new ActionEvent(tree, ActionEvent.ACTION_PERFORMED, actionId)); int row = tree.getLeadSelectionRow(); getSelectionModel().setSelectionInterval(row, row); TableUtil.scrollSelectionToVisible(TreeTable.this); } } | actionPerformed |
283,747 | void (TreeTableModel treeTableModel) {// Create the tree. It will be used as a renderer and editor. if (myTree != null) { myTree.removePropertyChangeListener(JTree.ROW_HEIGHT_PROPERTY, myTreeRowHeightPropertyListener); } myTree = new TreeTableTree(treeTableModel, this); setRowHeight(myTree.getRowHeight()); myTreeRowHeightPropertyListener = new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { int treeRowHeight = myTree.getRowHeight(); if (treeRowHeight == getRowHeight()) return; setRowHeight(treeRowHeight); } }; myTree.addPropertyChangeListener(JTree.ROW_HEIGHT_PROPERTY, myTreeRowHeightPropertyListener); // Install a tableModel representing the visible rows in the tree. setTableModel(treeTableModel); // Force the JTable and JTree to share their row selection models. ListToTreeSelectionModelWrapper selectionWrapper = new ListToTreeSelectionModelWrapper(); myTree.setSelectionModel(selectionWrapper); setSelectionModel(selectionWrapper.getListSelectionModel()); // Install the tree editor renderer and editor. TreeTableCellRenderer treeTableCellRenderer = createTableRenderer(treeTableModel); setDefaultRenderer(TreeTableModel.class, treeTableCellRenderer); setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor(treeTableCellRenderer)); // No grid. setShowGrid(false); // No intercell spacing setIntercellSpacing(new Dimension(0, 0)); // And update the height of the trees row to match that of the table. if (myTree.getRowHeight() < 1) { setRowHeight(JBUIScale.scale(18)); // Metal looks better like this. } else { setRowHeight(getRowHeight()); } } | setModel |
283,748 | void (PropertyChangeEvent evt) { int treeRowHeight = myTree.getRowHeight(); if (treeRowHeight == getRowHeight()) return; setRowHeight(treeRowHeight); } | propertyChange |
283,749 | TreeTableModel () { return myTableModel; } | getTableModel |
283,750 | void (TreeTableModel treeTableModel) { myTableModel = treeTableModel; super.setModel(adapt(treeTableModel)); } | setTableModel |
283,751 | TreeTableModelAdapter (TreeTableModel treeTableModel) { return new TreeTableModelAdapter(treeTableModel, myTree, this); } | adapt |
283,752 | void (boolean visible) { myTree.setRootVisible(visible); } | setRootVisible |
283,753 | void (Object key, Object value) { myTree.putClientProperty(key, value); } | putTreeClientProperty |
283,754 | void (TreeCellRenderer renderer) { myTree.setCellRenderer(renderer); } | setTreeCellRenderer |
283,755 | void () { super.updateUI(); if (myTree!= null) { myTree.updateUI(); } // Use the tree's default foreground and background colors in the // table. LookAndFeel.installColorsAndFont(this, "Tree.background", "Tree.foreground", "Tree.font"); } | updateUI |
283,756 | int () { return editingColumn == -1 || isTreeColumn(editingColumn) ? -1 : editingRow; } | getEditingRow |
283,757 | void (int rowHeight) { super.setRowHeight(rowHeight); if (myTree != null && myTree.getRowHeight() < rowHeight) { myTree.setRowHeight(getRowHeight()); } } | setRowHeight |
283,758 | TreeTableTree () { return myTree; } | getTree |
283,759 | void (boolean processCursorKeys) { myProcessCursorKeys = processCursorKeys; } | setProcessCursorKeys |
283,760 | void () { if (!updatingListSelectionModel) { updatingListSelectionModel = true; try { Set<Integer> selectedRows = new HashSet<>(); int min = listSelectionModel.getMinSelectionIndex(); int max = listSelectionModel.getMaxSelectionIndex(); if (min != -1 && max != -1) { for (int counter = min; counter <= max; counter++) { if (listSelectionModel.isSelectedIndex(counter)) { selectedRows.add(Integer.valueOf(counter)); } } } super.resetRowSelection(); listSelectionModel.clearSelection(); for (final Integer row : selectedRows) { listSelectionModel.addSelectionInterval(row.intValue(), row.intValue()); } } finally { updatingListSelectionModel = false; } } // Notice how we don't message super if // updatingListSelectionModel is true. If // updatingListSelectionModel is true, it implies the // ListSelectionModel has already been updated and the // paths are the only thing that needs to be updated. } | resetRowSelection |
283,761 | ListSelectionListener () { return new ListSelectionHandler(); } | createListSelectionListener |
283,762 | void () { if (!updatingListSelectionModel) { updatingListSelectionModel = true; try { // This is way expensive, ListSelectionModel needs an // enumerator for iterating. int min = listSelectionModel.getMinSelectionIndex(); int max = listSelectionModel.getMaxSelectionIndex(); clearSelection(); if (min != -1 && max != -1) { List<TreePath> selectionPaths = new ArrayList<>(); for (int counter = min; counter <= max; counter++) { if (listSelectionModel.isSelectedIndex(counter)) { TreePath selPath = myTree.getPathForRow(counter); if (selPath != null) { selectionPaths.add(selPath); } } } if (!selectionPaths.isEmpty()) { addSelectionPaths(selectionPaths.toArray(TreeUtil.EMPTY_TREE_PATH)); } } } finally { updatingListSelectionModel = false; } } } | updateSelectedPathsFromSelectedRows |
283,763 | void (ListSelectionEvent e) { updateSelectedPathsFromSelectedRows(); } | valueChanged |
283,764 | boolean (int row, int column, EventObject e) { boolean editResult = super.editCellAt(row, column, e); if (e instanceof MouseEvent me && isTreeColumn(column)){ int y = me.getY(); if (getRowHeight() != myTree.getRowHeight()) { // fix y if row heights are not equal // [todo]: review setRowHeight to synchronize heights correctly! final Rectangle tableCellRect = getCellRect(row, column, true); y = Math.min(y - tableCellRect.y, myTree.getRowHeight() - 1) + row * myTree.getRowHeight(); } MouseEvent newEvent = new MouseEvent(myTree, me.getID(), me.getWhen(), me.getModifiers(), me.getX() - getCellRect(0, column, true).x, y, me.getClickCount(), me.isPopupTrigger() ); myTree.dispatchEvent(newEvent); // Some LAFs, for example, Aqua under MAC OS X // expand tree node by MOUSE_RELEASED event. Unfortunately, // it's not possible to find easy way to wedge in table's // event sequence. Therefore we send "synthetic" release event. if (newEvent.getID()==MouseEvent.MOUSE_PRESSED) { MouseEvent newME2 = new MouseEvent( myTree, MouseEvent.MOUSE_RELEASED, me.getWhen(), me.getModifiers(), me.getX() - getCellRect(0, column, true).x, y - getCellRect(0, column, true).y, me.getClickCount(), me.isPopupTrigger() ); myTree.dispatchEvent(newME2); } } return editResult; } | editCellAt |
283,765 | boolean (int column) { return TreeTableModel.class.isAssignableFrom(getColumnClass(column)); } | isTreeColumn |
283,766 | void (TreePath path) { int row = getTree().getRowForPath(path); getTree().addSelectionPath(path); getSelectionModel().addSelectionInterval(row, row); } | addSelectedPath |
283,767 | void (TreePath path) { int row = getTree().getRowForPath(path); getTree().removeSelectionPath(path); getSelectionModel().removeSelectionInterval(row, row); } | removeSelectedPath |
283,768 | TreeTableCellRenderer (TreeTableModel treeTableModel) { return new TreeTableCellRenderer(this, myTree); } | createTableRenderer |
283,769 | void (int i) { setRowHeight(Math.max(getRowHeight(), i)); } | setMinRowHeight |
283,770 | Class () { return TreeTableModel.class; } | getColumnClass |
283,771 | Object (final Object object) { return object; } | valueOf |
283,772 | void (@NotNull AnActionEvent e) { int row = getTree().getRowCount() - 1; while (row >= collapseToLevel) { getTree().collapseRow(row); row--; } } | actionPerformed |
283,773 | JTree () { return myTree; } | getTree |
283,774 | void (@NotNull AnActionEvent e) { for (int i = 0; i < getTree().getRowCount(); i++) { getTree().expandRow(i); } } | actionPerformed |
283,775 | JTree () { return myTree; } | getTree |
283,776 | void () { myLeaves.clear(); myNodesCache.clear(); myDescriptors2Nodes.clear(); addToCache(myRoot, false); } | rebuild |
283,777 | void (FilteringNode node, boolean duplicate) { Object delegate = node.getDelegate(); Object[] delegates = myBaseStructure.getChildElements(delegate); if (delegates.length == 0 || duplicate) { myLeaves.add(node); } else { ArrayList<FilteringNode> nodes = new ArrayList<>(delegates.length); for (Object d : delegates) { boolean isDuplicate = myDescriptors2Nodes.containsKey(d); if (!isDuplicate) { FilteringNode n = new FilteringNode(node, d); myDescriptors2Nodes.put(d, n); nodes.add(n); } } myNodesCache.put(node, nodes); for (FilteringNode n : nodes) { addToCache(n, false); } if (nodes.isEmpty()) { myLeaves.add(node); } } } | addToCache |
283,778 | void () { setUnknown(myRoot); for (FilteringNode node : myLeaves) { State state = getState(node); while (node != null && node.state != State.VISIBLE) { if (node.state != state) { node.state = state; node = node.getParentNode(); if (node != null && state == State.HIDDEN) { state = getState(node); } } else { break; } } } } | refilter |
283,779 | List<FilteringNode> () { return ContainerUtil.filter(myLeaves, node -> node.state == State.VISIBLE); } | getVisibleLeaves |
283,780 | State (@NotNull FilteringNode node) { return myFilter.shouldBeShowing(node.getDelegate()) ? State.VISIBLE : State.HIDDEN; } | getState |
283,781 | void (FilteringNode node) { if (node.state == State.UNKNOWN) return; node.state = State.UNKNOWN; List<FilteringNode> nodes = myNodesCache.get(node); if (nodes != null) { for (FilteringNode n : nodes) { setUnknown(n); } } } | setUnknown |
283,782 | FilteringNode (Object nodeObject) { return myDescriptors2Nodes.get(nodeObject); } | getVisibleNodeFor |
283,783 | FilteringNode () { return myRoot; } | getRootElement |
283,784 | Object (@NotNull Object element) { return ((FilteringNode) element).getParent(); } | getParentElement |
283,785 | boolean (@NotNull Object element) { return element instanceof FilteringNode && ((FilteringNode)element).isAlwaysLeaf(); } | isAlwaysLeaf |
283,786 | boolean (@NotNull Object element) { return myBaseStructure.isToBuildChildrenInBackground(element); } | isToBuildChildrenInBackground |
283,787 | NodeDescriptor (@NotNull Object element, NodeDescriptor parentDescriptor) { return element instanceof FilteringNode ? (FilteringNode)element : new FilteringNode((SimpleNode)parentDescriptor, element); } | createDescriptor |
283,788 | void () { myBaseStructure.commit(); } | commit |
283,789 | boolean () { return myBaseStructure.hasSomethingToCommit(); } | hasSomethingToCommit |
283,790 | ActionCallback () { return myBaseStructure.asyncCommit(); } | asyncCommit |
283,791 | FilteringNode (Object delegate) { return new FilteringNode(null, delegate); } | createFilteringNode |
283,792 | void (Object delegate) { myDelegate = delegate; } | setDelegate |
283,793 | FilteringNode () { return (FilteringNode)getParent(); } | getParentNode |
283,794 | Object () { return myDelegate; } | getDelegate |
283,795 | List<FilteringNode> () { List<FilteringNode> nodes = myNodesCache.get(this); return nodes == null ? Collections.emptyList() : nodes; } | children |
283,796 | String () { return String.valueOf(getDelegate()); } | toString |
283,797 | boolean () { return myDelegate instanceof SimpleNode && ((SimpleNode)myDelegate).isContentHighlighted(); } | isContentHighlighted |
283,798 | boolean (final @NotNull PresentableNodeDescriptor kid) { return myDelegate instanceof PresentableNodeDescriptor && ((PresentableNodeDescriptor<?>)myDelegate).isHighlightableContentNode(kid); } | isHighlightableContentNode |
283,799 | void (@NotNull PresentationData presentation) { presentation.clearText(); if (myDelegate instanceof PresentableNodeDescriptor<?> node) { node.update(); presentation.applyFrom(node.getPresentation()); } else if (myDelegate != null) { NodeDescriptor<?> descriptor = myBaseStructure.createDescriptor(myDelegate, getParentDescriptor()); descriptor.update(); presentation.setIcon(descriptor.getIcon()); presentation.setPresentableText(myDelegate.toString()); } } | doUpdate |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.