public boolean restoreSelection(TreeSelection treeSelection) {
if (treeSelection.isEmpty()) return false;
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
TreeNode node = root.getChildAt(i);
if (node instanceof MessageNode) {
MessageNode messageNode = (MessageNode) node;
String[] text = messageNode.getText();
if (text.length == 0) continue;
if (Comparing.equal(treeSelection.mySelectedTarget, text[0])) {
TreePath pathToSelect = new TreePath(messageNode.getPath());
for (Enumeration enumeration = messageNode.children(); enumeration.hasMoreElements(); ) {
Object o = enumeration.nextElement();
if (o instanceof MessageNode) {
messageNode = (MessageNode) o;
if (Comparing.equal(treeSelection.mySelectedTask, text[0])) {
pathToSelect = new TreePath(messageNode.getPath());
break;
}
}
}
TreeUtil.selectPath(myTree, pathToSelect);
myTree.expandPath(pathToSelect);
return true;
}
}
}
return false;
}
public void updateModel(
List<? extends ChangeList> changeLists,
Trinity<List<VirtualFile>, Integer, Integer> unversionedFiles,
final List<LocallyDeletedChange> locallyDeletedFiles,
List<VirtualFile> modifiedWithoutEditing,
MultiMap<String, VirtualFile> switchedFiles,
@Nullable Map<VirtualFile, String> switchedRoots,
@Nullable List<VirtualFile> ignoredFiles,
final List<VirtualFile> lockedFolders,
@Nullable final Map<VirtualFile, LogicalLock> logicallyLockedFiles) {
TreeModelBuilder builder = new TreeModelBuilder(myProject, isShowFlatten());
final DefaultTreeModel model =
builder.buildModel(
changeLists,
unversionedFiles,
locallyDeletedFiles,
modifiedWithoutEditing,
switchedFiles,
switchedRoots,
ignoredFiles,
lockedFolders,
logicallyLockedFiles);
storeState();
DefaultTreeModel oldModel = getModel();
setModel(model);
setCellRenderer(new ChangesBrowserNodeRenderer(myProject, isShowFlatten(), true));
ChangesBrowserNode root = (ChangesBrowserNode) model.getRoot();
expandPath(new TreePath(root.getPath()));
restoreState();
expandDefaultChangeList(oldModel, root);
}
private void collapseTargets() {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i);
myTree.collapsePath(new TreePath(node.getPath()));
}
}
void onEdit() {
DefaultTreeModel model = (DefaultTreeModel) m_tree.getModel();
TreePath path = m_tree.getSelectionPath();
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
Organization org = (Organization) node.getUserObject();
OrganizationEditorDlg dlg = null;
if (parent == model.getRoot())
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, null, org);
else
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(),
m_conn,
m_sessionid,
(DefaultMutableTreeNode) node.getParent(),
org);
dlg.setVisible(true);
if (dlg.getResponse() == JOptionPane.OK_OPTION) {
node.setUserObject(dlg.getOrganization());
model.nodeChanged(node);
}
}
public void selectOptionByName(@NotNull final String optionName) {
selectPath(
findOption(
myTreeModel.getRoot(),
new DescriptorMatcher() {
@Override
public boolean matches(@NotNull Object data) {
return !optionName.isEmpty()
&& StringUtil.containsIgnoreCase(data.toString(), optionName);
}
}));
}
public void selectOptionByType(@NotNull final String attributeType) {
selectPath(
findOption(
myTreeModel.getRoot(),
new DescriptorMatcher() {
@Override
public boolean matches(@NotNull Object data) {
if (data instanceof EditorSchemeAttributeDescriptor) {
return attributeType.equals(((EditorSchemeAttributeDescriptor) data).getType());
}
return false;
}
}));
}
/** Removes the current selected group. */
final void removeSelectedGroup() {
TreePath[] selectionPaths = this.tree.getSelectionPaths();
if (selectionPaths == null) {
return;
}
DefaultTreeModel model = (DefaultTreeModel) this.tree.getModel();
ElementTreeNode rootNode = (ElementTreeNode) model.getRoot();
for (TreePath selectionPath : selectionPaths) {
ElementTreeNode treeNode = (ElementTreeNode) selectionPath.getLastPathComponent();
if (treeNode.getUserObject() instanceof ElementGroup) {
ElementGroup elementGroup = (ElementGroup) treeNode.getUserObject();
this.model.removeGroup(elementGroup);
model.nodesWereRemoved(
rootNode, new int[] {rootNode.getIndex(treeNode)}, new Object[] {treeNode});
}
}
}
private void expandDefaultChangeList(DefaultTreeModel oldModel, ChangesBrowserNode root) {
if (((ChangesBrowserNode) oldModel.getRoot()).getCount() == 0
&& TreeUtil.collectExpandedPaths(this).size() == 1) {
TreeNode toExpand = null;
for (int i = 0; i < root.getChildCount(); i++) {
TreeNode node = root.getChildAt(i);
if (node instanceof ChangesBrowserChangeListNode && node.getChildCount() > 0) {
ChangeList object = ((ChangesBrowserChangeListNode) node).getUserObject();
if (object instanceof LocalChangeList) {
if (((LocalChangeList) object).isDefault()) {
toExpand = node;
break;
}
}
}
}
if (toExpand != null) {
expandPath(new TreePath(new Object[] {root, toExpand}));
}
}
}
public void mouseReleased(MouseEvent e) {
if (e.isPopupTrigger()) {
DefaultTreeModel model = (DefaultTreeModel) m_tree.getModel();
TreePath path = m_tree.getSelectionPath();
if (path != null) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
if (node == model.getRoot()) {
mi_add.setEnabled(true);
mi_edit.setEnabled(false);
mi_delete.setEnabled(false);
} else {
mi_add.setEnabled(true);
mi_edit.setEnabled(true);
mi_delete.setEnabled(true);
}
Rectangle rectangle = m_tree.getPathBounds(path);
if (rectangle.contains(e.getPoint())) m_popupMenu.show(m_tree, e.getX(), e.getY());
}
}
}
void onAdd() {
DefaultTreeModel model = (DefaultTreeModel) m_tree.getModel();
TreePath path = m_tree.getSelectionPath();
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
OrganizationEditorDlg dlg = null;
if (node == model.getRoot())
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, null);
else
dlg =
new OrganizationEditorDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, node);
dlg.setVisible(true);
if (dlg.getResponse() == JOptionPane.OK_OPTION) {
Organization org = new Organization(dlg.getOrganization(), dlg.getOrganization().getCode());
DefaultMutableTreeNode child = new DefaultMutableTreeNode(org);
model.insertNodeInto(child, node, node.getChildCount());
m_tree.scrollPathToVisible(new TreePath(model.getPathToRoot(child)));
}
}
/** Adds a new group to our tree and element model. */
final void addNewGroup() {
DefaultTreeModel model = (DefaultTreeModel) this.tree.getModel();
boolean groupSummaryVisibleByDefault = UIManager.getBoolean(GROUP_SUMMARY_VISIBLE_DEFAULT);
boolean scopeVisibleByDefault = UIManager.getBoolean(ANALOG_SCOPE_VISIBLE_DEFAULT);
int groupCount = this.model.getGroups().size();
String name = String.format("Group %d", Integer.valueOf(groupCount + 1));
// Create model structure...
ElementGroup newGroup = this.model.addGroup(name);
newGroup.setVisible(true);
SignalElement groupSummaryElement = SignalElement.createGroupSummaryElement(newGroup);
groupSummaryElement.setEnabled(groupSummaryVisibleByDefault);
newGroup.addElement(groupSummaryElement);
SignalElement analogScopeElement = SignalElement.createAnalogScopeElement(newGroup);
analogScopeElement.setEnabled(scopeVisibleByDefault);
newGroup.addElement(analogScopeElement);
// Create tree structure...
ElementTreeNode rootNode = (ElementTreeNode) model.getRoot();
ElementTreeNode groupNode = new ElementTreeNode(newGroup);
rootNode.add(groupNode);
groupNode.add(new ElementTreeNode(groupSummaryElement));
groupNode.add(new ElementTreeNode(analogScopeElement));
int index = rootNode.getIndex(groupNode);
model.nodesWereInserted(rootNode, new int[] {index});
model.nodeStructureChanged(groupNode);
this.tree.expandRow(index);
}
protected DefaultMutableTreeNode getRootNode() {
return (DefaultMutableTreeNode) myTreeModel.getRoot();
}
public void scrollToFirstError() {
TreePath path = getFirstErrorPath(new TreePath(myTreeModel.getRoot()));
if (path != null) {
TreeUtil.selectPath(myTree, path);
}
}
public void finishBuild(String messageText) {
collapseTargets();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
myStatusNode = new DefaultMutableTreeNode(messageText);
myTreeModel.insertNodeInto(myStatusNode, root, root.getChildCount());
}
public static void sort(final DefaultTreeModel model, final Comparator comparator) {
sort((DefaultMutableTreeNode) model.getRoot(), comparator);
}