public void addHijos(DefaultMutableTreeNode nodo) {
    if (nodo.getChildCount() != 0) {
      nodo.removeAllChildren();
    }
    Vector<String> ListaDir = new Vector<String>();
    Vector<String> ListaArch = new Vector<String>();
    DefaultMutableTreeNode upNode =
        (nodo.isRoot()) ? nodo : (DefaultMutableTreeNode) nodo.getParent();
    String Ruta = nodo.getUserObject().toString();
    while (!upNode.isRoot()) {
      Ruta = upNode.getUserObject().toString() + "\\" + Ruta;
      upNode = (DefaultMutableTreeNode) upNode.getParent();
    }

    try {
      Process sysCall;
      BufferedReader br;
      String s = "";
      String strCmd = "cmd /c cd " + localDir + "\\" + Ruta + " & dir";
      System.out.println(strCmd);
      sysCall = Runtime.getRuntime().exec(strCmd);
      br = new BufferedReader(new InputStreamReader(sysCall.getInputStream()));
      while ((s = br.readLine()) != null) {
        System.out.println(s);
        int indexArch = "                                         ".length();
        if (s.contains("<DIR>")) {
          int indexDir = s.indexOf("<DIR>") + "<DIR>".length() + 1;
          String nomDir = s.substring(indexDir);
          ListaDir.add(nomDir.trim());
        } else {
          String nomArch = (s.length() > indexArch) ? s.substring(indexArch) : s;
          ListaArch.add(nomArch);
        }
      }
      ListaDir = new Vector<String>(ListaDir.subList(2, ListaDir.size()));
      ListaArch = new Vector<String>(ListaArch.subList(5, ListaArch.size() - 2));
      int i;
      for (i = 0; i < ListaDir.size(); i++) {
        DefaultMutableTreeNode hijo = new DefaultMutableTreeNode(ListaDir.get(i).toString());
        nodo.add(hijo);
      }
      for (i = 0; i < ListaArch.size(); i++) {
        DefaultMutableTreeNode hijo = new DefaultMutableTreeNode(ListaArch.get(i).toString());
        nodo.add(hijo);
      }
      ListaArchSup.addAll(ListaArch);
      ListaDirSup.addAll(ListaDir);
    } catch (Exception e) {
    }
  }
Exemple #2
0
 public synchronized void updateCategory(ViewerType type, HashSet<String> names) {
   final DefaultMutableTreeNode node;
   Enumeration<TreePath> userPath = getExpandedDescendants();
   switch (type) {
     case STAFF:
       staff.removeAllChildren();
       node = staff;
       break;
     case ADMIN:
       admins.removeAllChildren();
       node = admins;
       break;
     case MOD:
       mods.removeAllChildren();
       node = mods;
       break;
     case VIEWER:
       viewers.removeAllChildren();
       node = viewers;
       break;
     case GLOBAL_MOD:
       global_mods.removeAllChildren();
       node = global_mods;
       break;
     default:
       node = null;
       break;
   }
   if (node != null) {
     if (!names.isEmpty()) {
       names.stream().sorted().forEach(s -> node.add(new DefaultMutableTreeNode(s)));
     }
     updateRoot(userPath);
   }
 }
Exemple #3
0
    @Override
    public void actionPerformed(ActionEvent evt) {
      JCheckBoxMenuItem menuItem = (JCheckBoxMenuItem) evt.getSource();
      boolean curState = menuItem.isSelected();

      TreePath path = resultTree.getSelectionPath();
      DefaultMutableTreeNode operNode = (DefaultMutableTreeNode) path.getLastPathComponent();

      HyperSearchOperationNode operNodeObj = (HyperSearchOperationNode) operNode.getUserObject();
      if (curState) operNodeObj.cacheResultNodes(operNode);
      operNode.removeAllChildren();
      if (curState) {
        Exception excp = null;
        try {
          operNodeObj.insertTreeNodes(resultTree, operNode);
        } catch (Exception ex) {
          operNodeObj.restoreFlatNodes(resultTree, operNode);
          menuItem.setSelected(false);
          excp = ex;
        } finally {
          ((DefaultTreeModel) resultTree.getModel()).nodeStructureChanged(operNode);
          expandAllNodes(operNode);
          resultTree.scrollPathToVisible(new TreePath(operNode.getPath()));
        }
        if (excp != null) throw new RuntimeException(excp);
      } else operNodeObj.restoreFlatNodes(resultTree, operNode);

      operNodeObj.setTreeViewDisplayed(menuItem.isSelected());
    }
  public synchronized void resetRoot() {
    if (tableModelListener != null) {
      int nodeFoundSetsSize = nodeFoundSets.size();
      for (int i = 0; i < nodeFoundSetsSize; i++) {
        if (nodeFoundSets.get(i) instanceof ISwingFoundSet) {
          ((ISwingFoundSet) nodeFoundSets.get(i)).removeTableModelListener(tableModelListener);
        }
      }
    }

    nodeFoundSets.clear();

    DefaultMutableTreeNode root = (DefaultMutableTreeNode) getRoot();
    removeModificationListenerRecursiv(root); // remove all nodes modification listeners
    root.removeAllChildren();

    DefaultMutableTreeNode child;

    ArrayList rootFoundSets = bindingInfo.getRootFoundSets();
    IFoundSet rootFs;
    for (int j = 0; j < rootFoundSets.size(); j++) {
      rootFs = (IFoundSet) rootFoundSets.get(j);
      for (int i = 0; i < rootFs.getSize(); i++) {
        rootFs.getRecord(i);
        child = createChildNode(root, rootFs, i);
      }
      // check child item to detect dir/leaf status (need this for icon display)
      Enumeration<DefaultMutableTreeNode> childEnum = root.children();
      while (childEnum.hasMoreElements()) childEnum.nextElement().isLeaf();
      addListenerToFoundSet(rootFs);
    }
  }
Exemple #5
0
  public void update() {
    try {
      _mpd.getMPDAdmin().updateDatabase();
    } catch (Exception e) {
    }

    DefaultMutableTreeNode parent = (DefaultMutableTreeNode) getRoot();
    Iterator<Path> pathIter = null;
    Path subPath = null;
    MPDSong song = null;

    try {
      Iterator<MPDSong> list = _mpd.getMPDDatabase().listAllSongs().iterator();

      parent.removeAllChildren();

      while (list.hasNext()) {
        song = list.next();
        pathIter = Paths.get(song.getFile()).iterator();
        parent = (DefaultMutableTreeNode) getRoot();

        while (pathIter.hasNext()) {
          subPath = pathIter.next();
          if (pathIter.hasNext()) {
            parent = appendNode(parent, new DefaultMutableTreeNode(subPath));
          } else {
            appendNode(parent, new DefaultMutableTreeNode(new SongContainer(song)));
          }
        }
      }
      super.reload();
    } catch (Exception e) {
    }
  }
  public void treeWillExpand(TreeExpansionEvent e) {

    // get the tree path which will be expanded
    TreePath path = e.getPath();
    if (path == null) {
      return;
    }

    // get the directory at the node
    DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
    File selDir = (File) node.getUserObject();

    // remove old entries
    if (node.getChildCount() > 0) {
      node.removeAllChildren();
    }

    // get all the subdirectories
    File childDirs[] = selDir.listFiles(this);
    if (childDirs == null) {
      return;
    }

    // add the subdirectories
    Arrays.sort(childDirs);
    for (int i = 0; i < childDirs.length; i++) {
      if (childDirs[i].isHidden()) {
        if (showHidden) {
          node.add(new DefaultMutableTreeNode(childDirs[i]));
        }
      } else {
        node.add(new DefaultMutableTreeNode(childDirs[i]));
      }
    }
  }
  /** Empty the interface. */
  public void resetInterface() {
    // Empty tree objects
    this.treeNodeModels.clear();
    this.consoles.clear();

    /*
     * TODO : clear properly paused processes remaining when another new
     * injection is run.
     */
    // GUIMediator.model().suspendables.clear();

    MediatorGUI.bottomPanel().listHTTPHeader.clear();

    // Tree model for refreshing the tree
    DefaultTreeModel treeModel = (DefaultTreeModel) MediatorGUI.databaseTree().getModel();
    // The tree root
    DefaultMutableTreeNode root = (DefaultMutableTreeNode) treeModel.getRoot();

    // Delete tabs
    MediatorGUI.right().removeAll();
    // Remove tree nodes
    root.removeAllChildren();
    // Refresh the root
    treeModel.nodeChanged(root);
    // Refresh the tree
    treeModel.reload();
    MediatorGUI.databaseTree().setRootVisible(true);

    // Empty infos tabs
    MediatorGUI.bottomPanel().chunkTab.setText("");
    MediatorGUI.bottomPanel().binaryTab.setText("");
    ((DefaultTableModel) MediatorGUI.bottomPanel().networkTable.getModel()).setRowCount(0);
    MediatorGUI.bottomPanel().javaTab.getProxy().setText("");

    MediatorGUI.bottomPanel().networkTabHeader.setText("");
    MediatorGUI.bottomPanel().networkTabParam.setText("");
    MediatorGUI.bottomPanel().networkTabResponse.setText("");
    MediatorGUI.bottomPanel().networkTabTiming.setText("");
    MediatorGUI.bottomPanel().networkTabSource.setText("");
    MediatorGUI.bottomPanel().networkTabPreview.setText("");

    for (int i = 0; i < MediatorGUI.bottom().getTabCount(); i++) {
      Component tabComponent = MediatorGUI.bottom().getTabComponentAt(i);
      if (tabComponent != null) {
        tabComponent.setFont(tabComponent.getFont().deriveFont(Font.PLAIN));
      }
    }

    MediatorGUI.left().fileManager.setButtonEnable(false);
    MediatorGUI.left().shellManager.setButtonEnable(false);
    MediatorGUI.left().sqlShellManager.setButtonEnable(false);

    // Default status info
    MediatorGUI.status().reset();

    MediatorGUI.left().fileManager.changePrivilegeIcon(HelperGUI.SQUARE_GREY);
    MediatorGUI.left().shellManager.changePrivilegeIcon(HelperGUI.SQUARE_GREY);
    MediatorGUI.left().sqlShellManager.changePrivilegeIcon(HelperGUI.SQUARE_GREY);
    MediatorGUI.left().uploadManager.changePrivilegeIcon(HelperGUI.SQUARE_GREY);
  }
 private static void replaceChildren(
     final DefaultMutableTreeNode node, final Collection<? extends ElementNode> arrayList) {
   node.removeAllChildren();
   for (ElementNode child : arrayList) {
     node.add(child);
   }
 }
  // reorder the nodes
  private void reorder(Vector nodes) {

    debug("reorder nodes");

    // remove all the children of topNode (they'll be added back later)
    topNode.removeAllChildren();

    // Create an array of the elements for sorting & copy the elements
    // into the array.
    DefaultMutableTreeNode[] array = new DefaultMutableTreeNode[nodes.size()];
    nodes.copyInto(array);

    // Sort the array (Quick Sort)
    quickSort(array, 0, array.length - 1);

    // Reload the topNode. Everthing is in order now.
    for (int i = 0; i < array.length; i++) {
      topNode.add((DefaultMutableTreeNode) array[i]);
    }

    // Tell the tree to repaint itself
    ((DefaultTreeModel) tree.getModel()).reload();
    tree.invalidate();
    tree.repaint();
  }
  /**
   * Reloads data from new model, creates new search engine to search in new model if model contains
   * view with the same name
   */
  private void reloadData(HelpModel model) {
    debug("reloadData using new model");
    helpsearch = null;
    SearchView view = null;

    newHelpSet = model.getHelpSet();
    SearchView oldView = (SearchView) searchnav.getNavigatorView();
    String oldName = oldView.getName();
    NavigatorView[] navViews = newHelpSet.getNavigatorViews();
    for (int i = 0; i < navViews.length; i++) {
      if ((navViews[i].getName()).equals(oldName)) {
        NavigatorView tempView = navViews[i];
        if (tempView instanceof SearchView) {
          view = (SearchView) tempView;
          break;
        }
      }
    }

    if (view == null) return;

    topNode.removeAllChildren();
    searchnav.setSearchEngine(new MergingSearchEngine(view));

    setCellRenderer(view, tree);
    // add all subhelpsets
    addSubHelpSets(newHelpSet);
  }
  private void populateNetworkTree() {

    DefaultTreeModel tree = (DefaultTreeModel) networkJTree.getModel();
    DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getRoot();
    root.removeAllChildren();
    DefaultMutableTreeNode networkNode;
    DefaultMutableTreeNode stateNode;
    DefaultMutableTreeNode cityNode;
    ArrayList<Network> networkList = system.getNetworkList();
    for (int i = 0; i < networkList.size(); i++) {
      Network country = networkList.get(i);
      networkNode = new DefaultMutableTreeNode(country.getNetworkname());
      root.insert(networkNode, i);
      ArrayList<Network> stateList = country.getSubnetworklist();
      DefaultMutableTreeNode enterpriseNode;
      for (int j = 0; j < stateList.size(); j++) {
        Network state = stateList.get(j);
        stateNode = new DefaultMutableTreeNode(state.getNetworkname());
        networkNode.insert(stateNode, j);
        ArrayList<Network> cityList = state.getSubnetworklist();
        for (int k = 0; k < cityList.size(); k++) {
          Network city = cityList.get(k);
          cityNode = new DefaultMutableTreeNode(city.getNetworkname());
          stateNode.insert(cityNode, k);
        }
      }
    }
    tree.reload();
  }
  public void exploreBean(DefaultMutableTreeNode root, String classname, String parentPath) {
    try {

      root.removeAllChildren();
      if (parentPath.length() > 0) parentPath += ".";

      MainFrame.reportClassLoader.rescanLibDirectory();
      Class clazz = Class.forName(classname, true, MainFrame.reportClassLoader);

      java.beans.PropertyDescriptor[] pd =
          org.apache.commons.beanutils.PropertyUtils.getPropertyDescriptors(clazz);
      for (int nd = 0; nd < pd.length; ++nd) {
        String fieldName = pd[nd].getName();
        if (pd[nd].getPropertyType() != null && pd[nd].getReadMethod() != null) {
          String returnType = pd[nd].getPropertyType().getName();
          it.businesslogic.ireport.JRField field =
              new it.businesslogic.ireport.JRField(Misc.getJRFieldType(fieldName), returnType);
          if (isPathOnDescription()) {
            field.setDescription(parentPath + fieldName);
          } else {
            field.setName(parentPath + fieldName);
          }

          TreeJRField jtf = new TreeJRField();

          jtf.setField(field);
          jtf.setObj(pd[nd].getPropertyType());

          boolean bChildrens = true;
          if (pd[nd].getPropertyType().isPrimitive()
              || pd[nd].getPropertyType().getName().startsWith("java.lang.")) {
            bChildrens = false;
          }
          root.add(new DefaultMutableTreeNode(jtf, bChildrens));
        }
      }

      jTree1.expandPath(new TreePath(root.getPath()));
      jTree1.updateUI();

    } catch (ClassNotFoundException cnf) {
      javax.swing.JOptionPane.showMessageDialog(
          this,
          I18n.getFormattedString(
              "messages.BeanInspectorPanel.classNotFoundError",
              "Class not found error!!\nCheck your classpath and retry!\n{0}",
              new Object[] {cnf.getMessage()}),
          I18n.getString("message.title.error", "Error"),
          javax.swing.JOptionPane.ERROR_MESSAGE);
      return;
    } catch (Exception ex) {
      javax.swing.JOptionPane.showMessageDialog(
          this,
          ex.getMessage(),
          I18n.getString("message.title.error", "Error"),
          javax.swing.JOptionPane.ERROR_MESSAGE);
      return;
    }
  }
 /** Must be used when the combobox is not visible... */
 public void setClassName(String className) {
   DefaultMutableTreeNode root = (DefaultMutableTreeNode) jTree1.getModel().getRoot();
   root.removeAllChildren();
   jTree1.updateUI();
   if (className != null && className.trim().length() > 0) {
     exploreBean(root, className, "");
   }
 }
Exemple #14
0
 public static void sort(final DefaultMutableTreeNode node, final Comparator comparator) {
   final List<TreeNode> children = childrenToArray(node);
   Collections.sort(children, comparator);
   node.removeAllChildren();
   addChildrenTo(node, children);
   for (int i = 0; i < node.getChildCount(); i++) {
     sort((DefaultMutableTreeNode) node.getChildAt(i), comparator);
   }
 }
 private void patchActionsTreeCorrespondingToSchema(DefaultMutableTreeNode root) {
   root.removeAllChildren();
   if (mySelectedSchema != null) {
     mySelectedSchema.fillActionGroups(root);
     for (final ActionUrl actionUrl : mySelectedSchema.getActions()) {
       ActionUrl.changePathInActionsTree(myActionsTree, actionUrl);
     }
   }
   ((DefaultTreeModel) myActionsTree.getModel()).reload();
 }
Exemple #16
0
 private void loadActions() {
   rootActionsNode.removeAllChildren();
   loadAction(rootActionsNode, Main.main.menu);
   for (Map.Entry<String, Action> a : regactions.entrySet()) {
     if (actions.get(a.getKey()) == null) {
       rootActionsNode.add(new DefaultMutableTreeNode(a.getValue()));
     }
   }
   rootActionsNode.add(new DefaultMutableTreeNode(null));
 }
Exemple #17
0
  public void buildTree() {
    top.removeAllChildren();
    DefaultTreeModel model = (DefaultTreeModel) this.getModel();
    top.setUserObject(new NodeData(jsonElement, "data"));
    model.setRoot(top);

    prepareElement(top, jsonElement);
    repaint();
    setSelectionRow(0);
  }
  private void updateCheckBoxTree() {
    DefaultMutableTreeNode root = (DefaultMutableTreeNode) this.checkboxTree.getModel().getRoot();
    this.checkboxTree.removeCheckingPaths(this.checkboxTree.getCheckingPaths());
    root.removeAllChildren();

    if (this.dateDisplay) {
      TreeMap<Integer, ArrayList<Game>> dateGames = new TreeMap<Integer, ArrayList<Game>>();
      for (Game g : this.games) {
        if (!g.getTitle()
            .equals("SIVOX")) { // TODO A Supprimer lorsque le nouvel installeur sera en place SEUL
          if (!dateGames.containsKey(g.getAnnee())) {
            dateGames.put(g.getAnnee(), new ArrayList<Game>());
          }
          dateGames.get(g.getAnnee()).add(g);
        }
      }

      for (Integer annee : dateGames.keySet()) {
        DefaultMutableTreeNode anneeNode = new DefaultMutableTreeNode(String.valueOf(annee));
        for (Game g : dateGames.get(annee)) {
          anneeNode.add(new DefaultMutableTreeNode(g));
        }
        root.add(anneeNode);
      }
    } else {
      TreeMap<GameCategory, ArrayList<Game>> catGames =
          new TreeMap<GameCategory, ArrayList<Game>>();

      for (Game g : this.games) {
        if (!g.getTitle()
            .equals("SIVOX")) { // TODO A Supprimer lorsque le nouvel installeur sera en place SEUL
          for (GameCategory gameCat : g.getGameCategories()) {
            if (!catGames.containsKey(gameCat)) {
              catGames.put(gameCat, new ArrayList<Game>());
            }
            catGames.get(gameCat).add(g);
          }
        }
      }

      for (GameCategory gameCat : catGames.keySet()) {
        DefaultMutableTreeNode gameCatNode = new DefaultMutableTreeNode(gameCat);
        for (Game g : catGames.get(gameCat)) {
          gameCatNode.add(new DefaultMutableTreeNode(g));
        }
        root.add(gameCatNode);
      }
    }

    ((DefaultTreeModel) this.checkboxTree.getModel()).nodeStructureChanged(root);

    this.checkboxTree.expandAll();
    this.validate();
  }
Exemple #19
0
 public void appendNodes(DefaultMutableTreeNode node1, Vector vct) {
   Vector newvct = new Vector();
   if (vct != null) {
     newvct = vct;
     node1.removeAllChildren();
   } else {
     node1.removeAllChildren();
     return;
   }
   for (int i = 0; i < vct.size(); i++) {
     File file = (File) newvct.get(i);
     FileTreeNode childnode = new FileTreeNode(file);
     if (file.listFiles() != null) {
       File[] f = file.listFiles();
       for (int j = 0; j < f.length; j++) {
         if (f[j].isDirectory()) childnode.add(new FileTreeNode(""));
       }
     }
     node1.add(childnode);
   }
 }
Exemple #20
0
  /**
   * Shut the repository down.
   *
   * @param wait true, if ORB should wait for still open connections to be closed by clients.
   */
  public void imrShutdown(boolean wait) {
    disableRefresh();

    try {
      m_admin.shutdown(wait);

      m_top_node.removeAllChildren();
      m_servers = null;
    } catch (Exception _e) {
      handleException(_e);
    }
  }
Exemple #21
0
 public synchronized void buildFilteredModel(String text) {
   filtered_root.removeAllChildren();
   ArrayList<DefaultMutableTreeNode> rows = new ArrayList<>();
   if (staff.getChildCount() > 0) {
     DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Staff");
     filterNode(staff, text, filtered);
     if (filtered.getChildCount() > 0) {
       filtered_root.add(filtered);
       rows.add(filtered);
     }
   }
   if (admins.getChildCount() > 0) {
     DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Admins");
     filterNode(admins, text, filtered);
     if (filtered.getChildCount() > 0) {
       filtered_root.add(filtered);
       rows.add(filtered);
     }
   }
   if (global_mods.getChildCount() > 0) {
     DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Global Moderators");
     filterNode(global_mods, text, filtered);
     if (filtered.getChildCount() > 0) {
       filtered_root.add(filtered);
       rows.add(filtered);
     }
   }
   if (mods.getChildCount() > 0) {
     DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Moderators");
     filterNode(mods, text, filtered);
     if (filtered.getChildCount() > 0) {
       filtered_root.add(filtered);
       rows.add(filtered);
     }
   }
   if (viewers.getChildCount() > 0) {
     DefaultMutableTreeNode filtered = new DefaultMutableTreeNode("Viewers");
     filterNode(viewers, text, filtered);
     if (filtered.getChildCount() > 0) {
       filtered_root.add(filtered);
       rows.add(filtered);
     }
   }
   setViewerTreeModel(new DefaultTreeModel(filtered_root));
   for (DefaultMutableTreeNode row : rows) {
     TreePath tp = new TreePath(row.getPath());
     viewerTree.expandPath(tp);
   }
 }
 /**
  * Set the list of SchemaClasses to be displayed in this EntityInstanceListPane.
  *
  * @param classes
  * @throws Exception
  */
 public void setSchemaClasses(List<GKSchemaClass> classes, XMLFileAdaptor fileAdaptor)
     throws Exception {
   DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
   DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
   root.removeAllChildren();
   for (GKSchemaClass cls : classes) {
     Collection instances = fileAdaptor.fetchInstancesByClass(cls.getName());
     // Don't add an empty class node to save space
     if (instances == null || instances.size() == 0) continue;
     DefaultMutableTreeNode clsNode = new DefaultMutableTreeNode(cls);
     root.add(clsNode);
     buildTree(instances, clsNode);
   }
   model.nodeStructureChanged(root);
 }
Exemple #23
0
 private synchronized void updateRoot(Enumeration<TreePath> userPath) {
   DefaultMutableTreeNode root = default_root;
   root.removeAllChildren();
   if (staff.getChildCount() > 0) root.add(staff);
   if (admins.getChildCount() > 0) root.add(admins);
   if (global_mods.getChildCount() > 0) root.add(global_mods);
   if (mods.getChildCount() > 0) root.add(mods);
   root.add(viewers);
   if (!isFiltering) defaultModel.reload(root);
   if (userPath != null) {
     while (userPath.hasMoreElements()) {
       viewerTree.expandPath(userPath.nextElement());
     }
   }
 }
  /**
   * Generic method to add a logical operator to rule.
   *
   * @param dialog
   * @param operator
   * @return node of logical operator
   */
  private DefaultMutableTreeNode addLogicalOperator(
      final CustomSearchDialog dialog, final ILogicalSearchOperator operator) {
    // Get selected node and parent
    DefaultTreeModel model = ((DefaultTreeModel) dialog.getComplexRulesTree().getModel());
    DefaultMutableTreeNode selectedNode =
        (DefaultMutableTreeNode)
            dialog.getComplexRulesTree().getSelectionPath().getLastPathComponent();
    DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) selectedNode.getParent();

    // Create node
    DefaultMutableTreeNode logicalNode = new DefaultMutableTreeNode(operator);

    // Node is root
    if (parentNode == null) {
      // add as root
      model.setRoot(logicalNode);
    } else {
      // add as child of parent

      // remove all nodes and add again to keep order
      List<MutableTreeNode> nodes = new ArrayList<MutableTreeNode>();
      for (int i = 0; i < parentNode.getChildCount(); i++) {
        nodes.add((MutableTreeNode) parentNode.getChildAt(i));
      }
      parentNode.removeAllChildren();
      for (MutableTreeNode node : nodes) {
        if (node.equals(selectedNode)) {
          parentNode.add(logicalNode);
        } else {
          parentNode.add(node);
        }
      }
    }
    // Add previous selected node as child of new logical operator node
    logicalNode.add(selectedNode);

    // Reload model
    model.reload();

    // Expand complex rules tree to display full rule
    GuiUtils.expandTree(dialog.getComplexRulesTree());

    // Select added node
    dialog.getComplexRulesTree().setSelectionPath(new TreePath(logicalNode.getPath()));

    return logicalNode;
  }
  public void populateTree() {

    DefaultTreeModel model = (DefaultTreeModel) JTree.getModel();

    ArrayList<Network> networkList = system.getNetworkList();
    ArrayList<Enterprise> enterpriseList;
    ArrayList<Organization> organizationList;

    Network network;
    Enterprise enterprise;
    Organization organization;

    DefaultMutableTreeNode networks = new DefaultMutableTreeNode("Networks");
    DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
    root.removeAllChildren();
    root.insert(networks, 0);

    DefaultMutableTreeNode networkNode;
    DefaultMutableTreeNode enterpriseNode;
    DefaultMutableTreeNode organizationNode;

    for (int i = 0; i < networkList.size(); i++) {
      network = networkList.get(i);
      networkNode = new DefaultMutableTreeNode(network.getName());
      networks.insert(networkNode, i);

      enterpriseList = network.getEnterpriseDirectory().getEnterpriseList();

      for (int j = 0; j < enterpriseList.size(); j++) {
        enterprise = enterpriseList.get(j);
        enterpriseNode = new DefaultMutableTreeNode(enterprise.getName());
        networkNode.insert(enterpriseNode, j);

        organizationList = enterprise.getOrganizationDirectory().getOrganizationList();
        for (int k = 0; k < organizationList.size(); k++) {
          organization = organizationList.get(k);
          organizationNode = new DefaultMutableTreeNode(organization.getName());
          enterpriseNode.insert(organizationNode, k);
        }
      }
    }

    model.reload();
  }
  private void reset(
      final Keymap keymap,
      final QuickList[] allQuickLists,
      String filter,
      @Nullable KeyboardShortcut shortcut) {
    myKeymap = keymap;

    final PathsKeeper pathsKeeper = new PathsKeeper();
    pathsKeeper.storePaths();

    myRoot.removeAllChildren();

    ActionManager actionManager = ActionManager.getInstance();
    Project project =
        CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myComponent));
    Group mainGroup =
        ActionsTreeUtil.createMainGroup(
            project,
            myKeymap,
            allQuickLists,
            filter,
            true,
            ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, true));
    if ((filter != null && filter.length() > 0 || shortcut != null)
        && mainGroup.initIds().isEmpty()) {
      mainGroup =
          ActionsTreeUtil.createMainGroup(
              project,
              myKeymap,
              allQuickLists,
              filter,
              false,
              ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, false));
    }
    myRoot = ActionsTreeUtil.createNode(mainGroup);
    myMainGroup = mainGroup;
    MyModel model = (MyModel) myTree.getModel();
    model.setRoot(myRoot);
    model.nodeStructureChanged(myRoot);

    pathsKeeper.restorePaths();
  }
Exemple #27
0
  private void updateTree() {

    // Create a tree that allows one selection at a time
    top.removeAllChildren();
    HashMap<String, DefaultMutableTreeNode> paletteNodes = new HashMap<>();
    for (ObjectType type : ObjectType.getAll()) {
      if (!type.isDragAndDrop()) continue;

      String pName = type.getPaletteName();
      DefaultMutableTreeNode palNode = paletteNodes.get(pName);
      if (palNode == null) {
        palNode = new DefaultMutableTreeNode(pName, true);
        paletteNodes.put(pName, palNode);
        top.add(palNode);
      }

      DefaultMutableTreeNode classNode = new DefaultMutableTreeNode(type, true);
      palNode.add(classNode);
    }
    treeModel.reload(top);
  }
Exemple #28
0
 /** remove all from the tree */
 protected void clearTree() {
   switch (getTreeMode()) {
     case DEPENDENCY:
       indNode.removeAllChildren();
       depNode.removeAllChildren();
       auxiliaryNode.removeAllChildren();
       break;
     case TYPE:
       rootType.removeAllChildren();
       typeNodesMap.clear();
       break;
     case LAYER:
       rootLayer.removeAllChildren();
       layerNodesMap.clear();
       break;
     case ORDER:
       rootOrder.removeAllChildren();
   }
 }
  /**
   * Repopulates the contents of the tree.
   *
   * @param tree the tree to be repopulated.
   */
  private void repopulateTree(JTree tree) {
    ignoreSelectionEvents = true;

    final Point currentPosition = treeScroll.getViewport().getViewPosition();
    DefaultMutableTreeNode root = getRoot(tree);

    TreePath path = tree.getSelectionPath();
    DefaultMutableTreeNode lastSelectedNode = null;
    if (path != null) {
      lastSelectedNode = (DefaultMutableTreeNode) path.getLastPathComponent();
    }
    TreePath newSelectionPath = null;

    BackendDescriptor backend = null;
    String backendName = (String) backends.getSelectedItem();
    if (backendName != null) {
      for (BackendDescriptor b : getInfo().getServerDescriptor().getBackends()) {
        if (b.getBackendID().equalsIgnoreCase(backendName)) {
          backend = b;
          break;
        }
      }
    }

    ArrayList<ArrayList<? extends AbstractIndexTreeNode>> nodes =
        new ArrayList<ArrayList<? extends AbstractIndexTreeNode>>();
    ArrayList<IndexTreeNode> standardIndexNodes = new ArrayList<IndexTreeNode>();
    ArrayList<VLVIndexTreeNode> vlvIndexNodes = new ArrayList<VLVIndexTreeNode>();
    nodes.add(standardIndexNodes);
    nodes.add(vlvIndexNodes);

    if (backend != null) {
      for (IndexDescriptor index : backend.getIndexes()) {
        standardIndexNodes.add(new IndexTreeNode(index.getName(), index));
      }
      for (VLVIndexDescriptor index : backend.getVLVIndexes()) {
        vlvIndexNodes.add(new VLVIndexTreeNode(index.getName(), index));
      }
    }

    DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
    int i = 0;
    int positionUnderRoot = 0;
    for (DefaultMutableTreeNode parent : categoryNodes) {
      if (nodes.get(i).size() == 0) {
        if (root.getIndex(parent) != -1) {
          model.removeNodeFromParent(parent);
          parent.removeAllChildren();
        }
      } else {
        boolean expand = true;
        if (root.getIndex(parent) == -1) {
          model.insertNodeInto(parent, root, positionUnderRoot);
        } else {
          expand = tree.isExpanded(new TreePath(parent)) || (parent.getChildCount() == 0);
          parent.removeAllChildren();
        }
        for (AbstractIndexTreeNode node : nodes.get(i)) {
          parent.add(node);
          if ((newSelectionPath == null)
              && ((lastSelectedNode != null) || (lastCreatedIndex != null))) {
            if (lastCreatedIndex != null) {
              if ((node instanceof IndexTreeNode)
                  && (lastCreatedIndex instanceof IndexDescriptor)) {
                if (node.getName().equals(lastCreatedIndex.getName())) {
                  newSelectionPath = new TreePath(node.getPath());
                  lastCreatedIndex = null;
                }
              } else if ((node instanceof VLVIndexTreeNode)
                  && (lastCreatedIndex instanceof VLVIndexDescriptor)) {
                if (node.getName().equals(lastCreatedIndex.getName())) {
                  newSelectionPath = new TreePath(node.getPath());
                  lastCreatedIndex = null;
                }
              }
            } else if (node.getName().equals(lastSelectedNode.getUserObject())) {
              newSelectionPath = new TreePath(node.getPath());
            }
          }
        }
        model.nodeStructureChanged(parent);
        if (expand) {
          tree.expandPath(new TreePath(parent.getPath()));
        }
        positionUnderRoot++;
      }
      i++;
    }

    if (newSelectionPath == null) {
      if (firstTreeRepopulate) {
        newSelectionPath = new TreePath(standardIndexes.getPath());
      }
    }
    if (newSelectionPath != null) {
      tree.setSelectionPath(newSelectionPath);
      tree.scrollPathToVisible(newSelectionPath);
    }

    updateEntryPane();

    SwingUtilities.invokeLater(
        new Runnable() {
          public void run() {
            if (firstTreeRepopulate) {
              treeScroll.getViewport().setViewPosition(new Point(0, 0));
            } else {
              treeScroll.getViewport().setViewPosition(currentPosition);
            }
          }
        });
    firstTreeRepopulate = false;
    ignoreSelectionEvents = false;
  }
 private void clearNode(DefaultMutableTreeNode node) {
   while (node.getChildCount() > 0) {
     node.removeAllChildren();
   }
 }