1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 package ohos.devtools.views.layout.chartview.memory.nativehook; 17 18 import com.intellij.ui.treeStructure.treetable.TreeTableModel; 19 import com.intellij.util.ui.ColumnInfo; 20 import com.intellij.util.ui.SortableColumnModel; 21 import org.apache.logging.log4j.LogManager; 22 import org.apache.logging.log4j.Logger; 23 24 import javax.swing.JTree; 25 import javax.swing.RowSorter; 26 import javax.swing.tree.DefaultMutableTreeNode; 27 import javax.swing.tree.DefaultTreeModel; 28 import javax.swing.tree.TreeNode; 29 import javax.swing.tree.TreePath; 30 import java.util.Enumeration; 31 32 /** 33 * NativeHookTreeTableModel 34 * 35 * @since 2021/10/25 36 */ 37 public class NativeHookTreeTableModel extends DefaultTreeModel implements TreeTableModel, SortableColumnModel { 38 private static final Logger LOGGER = LogManager.getLogger(NativeHookTreeTableModel.class); 39 40 private NativeHookDataFilter filter = new NativeHookDataFilter(); 41 private ColumnInfo[] myColumns; 42 private JTree myTree; 43 44 /** 45 * FilterTreeTableModel 46 * 47 * @param root root 48 * @param columns columns 49 */ NativeHookTreeTableModel(DefaultMutableTreeNode root, ColumnInfo[] columns)50 public NativeHookTreeTableModel(DefaultMutableTreeNode root, ColumnInfo[] columns) { 51 super(root); 52 this.myColumns = columns; 53 } 54 55 /** 56 * fireTreeStructureChanged 57 * 58 * @param source source 59 * @param path path 60 * @param childIndices childIndices 61 * @param children children 62 */ 63 @Override fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children)64 protected void fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children) { 65 super.fireTreeStructureChanged(source, path, childIndices, children); 66 } 67 68 @Override getColumnInfos()69 public ColumnInfo[] getColumnInfos() { 70 return this.myColumns; 71 } 72 73 @Override setSortable(boolean sortable)74 public void setSortable(boolean sortable) { 75 } 76 77 @Override isSortable()78 public boolean isSortable() { 79 return false; 80 } 81 82 @Override getRowValue(int row)83 public Object getRowValue(int row) { 84 TreePath path = this.myTree.getPathForRow(row); 85 return path != null ? path.getLastPathComponent() : null; 86 } 87 88 @Override getDefaultSortKey()89 public RowSorter.SortKey getDefaultSortKey() { 90 return null; 91 } 92 93 @Override getColumnCount()94 public int getColumnCount() { 95 return this.myColumns.length; 96 } 97 98 @Override getColumnName(int columnIndex)99 public String getColumnName(int columnIndex) { 100 return this.myColumns[columnIndex].getName(); 101 } 102 103 @Override getColumnClass(int columnIndex)104 public Class getColumnClass(int columnIndex) { 105 return this.myColumns[columnIndex].getColumnClass(); 106 } 107 108 @Override getValueAt(Object value, int column)109 public Object getValueAt(Object value, int column) { 110 if (value instanceof DefaultMutableTreeNode && column != 0) { 111 DefaultMutableTreeNode nodeValue = (DefaultMutableTreeNode) value; 112 if (nodeValue.isLeaf()) { 113 return this.myColumns[column].valueOf(value); 114 } 115 long parentNodeData = 0L; 116 Enumeration<TreeNode> children = nodeValue.children(); 117 while (children.hasMoreElements()) { 118 DefaultMutableTreeNode treeNode = null; 119 Object nextElementObject = children.nextElement(); 120 if (nextElementObject instanceof DefaultMutableTreeNode) { 121 treeNode = (DefaultMutableTreeNode) nextElementObject; 122 if (filter.passTreeNode(treeNode)) { 123 Object valueAt = this.getValueAt(treeNode, column); 124 try { 125 parentNodeData = Long.parseLong(valueAt.toString()) + parentNodeData; 126 } catch (NumberFormatException numberFormatException) { 127 Object valueOf = this.myColumns[column].valueOf(value); 128 return String.valueOf(valueOf); 129 } 130 } 131 } 132 } 133 return String.valueOf(parentNodeData); 134 } else { 135 return this.myColumns[column].valueOf(value); 136 } 137 } 138 139 @Override isCellEditable(Object obj, int index)140 public boolean isCellEditable(Object obj, int index) { 141 return false; 142 } 143 144 @Override setValueAt(Object obj, Object objOne, int columnIndex)145 public void setValueAt(Object obj, Object objOne, int columnIndex) { 146 this.myColumns[columnIndex].setValue(objOne, obj); 147 } 148 149 @Override setTree(JTree jTree)150 public void setTree(JTree jTree) { 151 this.myTree = jTree; 152 } 153 154 /** 155 * getChildCount 156 * 157 * @param parent parent 158 * @return int 159 */ 160 @Override getChildCount(Object parent)161 public int getChildCount(Object parent) { 162 int realCount = super.getChildCount(parent); 163 if (filter.aBoolean) { 164 return realCount; 165 } 166 int filterCount = 0; 167 for (int index = 0; index < realCount; index++) { 168 TreeNode child = null; 169 Object childObject = super.getChild(parent, index); 170 if (childObject instanceof TreeNode) { 171 child = (TreeNode) childObject; 172 if (filter.passTreeNode(child)) { 173 filterCount++; 174 } 175 } 176 } 177 return filterCount; 178 } 179 180 /** 181 * setFiltered 182 * 183 * @param pass pass 184 */ setFiltered(boolean pass)185 public void setFiltered(boolean pass) { 186 filter.setFilter(pass); 187 } 188 189 /** 190 * getChild 191 * 192 * @param parent parent 193 * @param index index 194 * @return return 195 */ 196 @Override getChild(Object parent, int index)197 public Object getChild(Object parent, int index) { 198 if (filter.aBoolean) { 199 return ((TreeNode) parent).getChildAt(index); 200 } 201 int childrenIndex = -1; 202 for (int count = 0; count < super.getChildCount(parent); count++) { 203 TreeNode child = null; 204 Object childObject = super.getChild(parent, count); 205 if (childObject instanceof TreeNode) { 206 child = (TreeNode) childObject; 207 if (filter.passTreeNode(child)) { 208 childrenIndex++; 209 } 210 if (childrenIndex == index) { 211 return child; 212 } 213 } 214 } 215 return null; 216 } 217 }