Java TreeSelectionModel.SINGLE_TREE_SELECTION属性代码示例

public ModuleChooser(Project project, 
                     boolean allowFileSelection,
                     boolean allowMultipleSelection,
                     boolean allowRootSelection,
                     String expertTitle,
                     String selectModulePageTitle) {
  super(expertTitle, project);
  mySelectCVSConfigurationStep = new SelectCVSConfigurationStep(project, this);
  mySelectCvsElementStep = new SelectCvsElementStep(selectModulePageTitle,
                                                    this,
                                                    project,
                                                    mySelectCVSConfigurationStep, allowRootSelection, allowMultipleSelection ?
                                                                        TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION :
                                                                        TreeSelectionModel.SINGLE_TREE_SELECTION, true,
                                                    allowFileSelection);

  addStep(mySelectCVSConfigurationStep);
  addStep(mySelectCvsElementStep);

  init();
}
 

public BrowserPanel(CvsRootConfiguration configuration, Project project, Consumer<VcsException> errorCallback) {
  super(new BorderLayout(2, 0));
  setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
  myProject = project;
  myCvsRootConfiguration = configuration;
  myTree = new CvsTree(project, false, TreeSelectionModel.SINGLE_TREE_SELECTION, true, true, errorCallback);
  add(myTree, BorderLayout.CENTER);
  myTree.init();
  myTree.setCvsRootConfiguration(configuration);
  myCheckoutHelper = new CheckoutHelper(configuration, this);

  TreeUIHelper uiHelper = TreeUIHelper.getInstance();

  uiHelper.installEditSourceOnDoubleClick(myTree.getTree());
  TreeUtil.installActions(myTree.getTree());

  ActionGroup group = getActionGroup();
  PopupHandler.installPopupHandler(myTree.getTree(), group, ActionPlaces.CHECKOUT_POPUP, ActionManager.getInstance());
}
 

/**
 * Get the state set of this object.
 *
 * @return the state set for this object
 */
public AccessibleStateSet getAccessibleStateSet()
{
  if (isVisible())
    states.add(AccessibleState.VISIBLE);
  if (tree.isCollapsed(tp))
    states.add(AccessibleState.COLLAPSED);
  if (tree.isEditable())
    states.add(AccessibleState.EDITABLE);
  if (mod != null &&
      !mod.isLeaf(tp.getLastPathComponent()))
    states.add(AccessibleState.EXPANDABLE);
  if (tree.isExpanded(tp))
    states.add(AccessibleState.EXPANDED);
  if (isFocusable())
    states.add(AccessibleState.FOCUSABLE);
  if (hasFocus())
    states.add(AccessibleState.FOCUSED);
  if (tree.getSelectionModel().getSelectionMode() !=
    TreeSelectionModel.SINGLE_TREE_SELECTION)
    states.add(AccessibleState.MULTISELECTABLE);
  if (tree.isOpaque())
    states.add(AccessibleState.OPAQUE);
  if (tree.isPathSelected(tp))
    states.add(AccessibleState.SELECTED);
  if (isShowing())
    states.add(AccessibleState.SHOWING);

  states.add(AccessibleState.SELECTABLE);
  return states;
}
 

/**
 * Causes every selected item in the object to be selected if the object
 * supports multiple selections.
 */
public void selectAllAccessibleSelection()
{
  if (getSelectionModel().getSelectionMode() !=
    TreeSelectionModel.SINGLE_TREE_SELECTION)
  addSelectionInterval(0, getVisibleRowCount());
}
 

public ImportWizard(Project project, VirtualFile selectedFile) {
  super(CvsBundle.message("dialog.title.import.into.cvs"), project);
  final ImportConfiguration importConfig = ImportConfiguration.getInstance();
  mySelectCVSConfigurationStep = new SelectCVSConfigurationStep(project, this);
  mySelectCvsElementStep = new SelectCvsElementStep(CvsBundle.message("dialog.title.select.directory.to.import.into"),
                                                    this,
                                                    project,
                                                    mySelectCVSConfigurationStep,
                                                    true,
                                                    TreeSelectionModel.SINGLE_TREE_SELECTION,
                                                    false,
                                                    false);

  mySelectImportLocationStep = new SelectImportLocationStep(
                                          CvsBundle.message("dialog.title.select.import.directory"),
                                          this,
                                          project,
                                          selectedFile);
  mySettingsStep = new ImportSettingsStep(project, this, mySelectImportLocationStep, importConfig);

  addStep(mySelectCVSConfigurationStep);
  addStep(mySelectCvsElementStep);
  addStep(mySelectImportLocationStep);
  addStep(mySettingsStep);

  init();
}
 

/**
 * Get the state set of this object.
 * 
 * @return the state set for this object
 */
public AccessibleStateSet getAccessibleStateSet()
{
  if (isVisible())
    states.add(AccessibleState.VISIBLE);
  if (tree.isCollapsed(tp))
    states.add(AccessibleState.COLLAPSED);
  if (tree.isEditable())
    states.add(AccessibleState.EDITABLE);
  if (mod != null && 
      !mod.isLeaf(tp.getLastPathComponent()))
    states.add(AccessibleState.EXPANDABLE);
  if (tree.isExpanded(tp))
    states.add(AccessibleState.EXPANDED);
  if (isFocusable())
    states.add(AccessibleState.FOCUSABLE);
  if (hasFocus())
    states.add(AccessibleState.FOCUSED);
  if (tree.getSelectionModel().getSelectionMode() != 
    TreeSelectionModel.SINGLE_TREE_SELECTION)
    states.add(AccessibleState.MULTISELECTABLE);
  if (tree.isOpaque())
    states.add(AccessibleState.OPAQUE);
  if (tree.isPathSelected(tp))
    states.add(AccessibleState.SELECTED);
  if (isShowing())
    states.add(AccessibleState.SHOWING);

  states.add(AccessibleState.SELECTABLE);
  return states;
}
 

/**
 * Causes every selected item in the object to be selected if the object
 * supports multiple selections.
 */
public void selectAllAccessibleSelection()
{
  if (getSelectionModel().getSelectionMode() != 
    TreeSelectionModel.SINGLE_TREE_SELECTION)
  addSelectionInterval(0, getVisibleRowCount());
}
 

/** Check if selection of the nodes could break the selection mode set in TreeSelectionModel.
 * @param nodes the nodes for selection
 * @return true if the selection mode is broken */
private boolean isSelectionModeBroken(Node[] nodes) {
    // if nodes are empty or single the everthing is ok
    // or if discontiguous selection then everthing ok
    if ((nodes.length <= 1) || (getSelectionMode() == TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)) {
        return false;
    }

    // if many nodes
    // brakes single selection mode
    if (getSelectionMode() == TreeSelectionModel.SINGLE_TREE_SELECTION) {
        return true;
    }

    // check the contiguous selection mode
    TreePath[] paths = new TreePath[nodes.length];
    RowMapper rowMapper = tree.getSelectionModel().getRowMapper();

    // if rowMapper is null then tree bahaves as discontiguous selection mode is set
    if (rowMapper == null) {
        return false;
    }

    ArrayList<Node> toBeExpaned = new ArrayList<Node>(3);

    for (int i = 0; i < nodes.length; i++) {
        toBeExpaned.clear();

        Node n = nodes[i];

        while (n.getParentNode() != null) {
            if (!isExpanded(n)) {
                toBeExpaned.add(n);
            }

            n = n.getParentNode();
        }

        for (int j = toBeExpaned.size() - 1; j >= 0; j--) {
            expandNode(toBeExpaned.get(j));
        }
        paths[i] = getTreePath(nodes[i]);
    }

    int[] rows = rowMapper.getRowsForPaths(paths);

    // check selection's rows
    Arrays.sort(rows);

    for (int i = 1; i < rows.length; i++) {
        if (rows[i] != (rows[i - 1] + 1)) {
            return true;
        }
    }

    // all is ok
    return false;
}
 

@Override
public void setSingleSelectionOnly(boolean b)
{
	int mode = b ? TreeSelectionModel.SINGLE_TREE_SELECTION : TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION;
	tree.getSelectionModel().setSelectionMode(mode);
}
 

@Override
public boolean isMultiSelect() {
    return impl.getSelectionModel().getSelectionMode() != TreeSelectionModel.SINGLE_TREE_SELECTION;
}
 

@Override
public void setMultiSelect(boolean multiselect) {
    int mode = multiselect ?
            TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION : TreeSelectionModel.SINGLE_TREE_SELECTION;
    impl.getSelectionModel().setSelectionMode(mode);
}
 

private void createDefaultTreeActions() {
  final EditableTreeModel model = (EditableTreeModel)myTree.getModel();
  myAddAction = new AnActionButtonRunnable() {
    @Override
    public void run(AnActionButton button) {
      final TreePath path = myTree.getSelectionPath();
      final DefaultMutableTreeNode selected =
        path == null ? (DefaultMutableTreeNode)myTree.getModel().getRoot() : (DefaultMutableTreeNode)path.getLastPathComponent();
      final Object selectedNode = selected.getUserObject();

      myTree.stopEditing();
      Object element;
      if (model instanceof DefaultTreeModel && myProducer != null) {
         element = myProducer.createElement();
        if (element == null) return;
      } else {
        element = null;
      }
      DefaultMutableTreeNode parent = selected;
      if ((selectedNode instanceof SimpleNode && ((SimpleNode)selectedNode).isAlwaysLeaf()) || !selected.getAllowsChildren()) {
        parent = (DefaultMutableTreeNode)selected.getParent();
      }
      if (parent != null) {
       parent.insert(new DefaultMutableTreeNode(element), parent.getChildCount());
      }
      final TreePath createdPath = model.addNode(new TreePath(parent.getPath()));
      if (path != null) {
        TreeUtil.selectPath(myTree, createdPath);
        myTree.requestFocus();
      }
    }
  };

  myRemoveAction = new AnActionButtonRunnable() {
    @Override
    public void run(AnActionButton button) {
      myTree.stopEditing();
      if (myTree.getSelectionModel().getSelectionMode() == TreeSelectionModel.SINGLE_TREE_SELECTION) {
        final TreePath path = myTree.getSelectionPath();
        if (path != null) {
          model.removeNode(path);
        }
      }
      else {
        final TreePath[] paths = myTree.getSelectionPaths();
        if (paths != null && paths.length > 0) {
          model.removeNodes(Arrays.asList(paths));
        }
      }
    }
  };
}
 

@JdkConstants.TreeSelectionMode
protected int getSelectionMode() {
  return TreeSelectionModel.SINGLE_TREE_SELECTION;
}
 

/**
 * Returning true signifies a mouse event on the node should toggle the
 * selection of only the row under the mouse. The BasisTreeUI treats the
 * event as "toggle selection event" if the CTRL button was pressed while
 * clicking. The event is not counted as toggle event if the associated
 * tree does not support the multiple selection.
 *
 * @param event is the MouseEvent performed on the row.
 * @return true signifies a mouse event on the node should toggle the
 *         selection of only the row under the mouse.
 */
protected boolean isToggleSelectionEvent(MouseEvent event)
{
  return
    (tree.getSelectionModel().getSelectionMode() !=
      TreeSelectionModel.SINGLE_TREE_SELECTION) &&
    ((event.getModifiersEx() & InputEvent.CTRL_DOWN_MASK) != 0);
}
 

/**
 * Returning true signifies a mouse event on the node should select from the
 * anchor point. The BasisTreeUI treats the event as "multiple selection
 * event" if the SHIFT button was pressed while clicking. The event is not
 * counted as multiple selection event if the associated tree does not support
 * the multiple selection.
 *
 * @param event is the MouseEvent performed on the node.
 * @return true signifies a mouse event on the node should select from the
 *         anchor point.
 */
protected boolean isMultiSelectEvent(MouseEvent event)
{
  return
    (tree.getSelectionModel().getSelectionMode() !=
      TreeSelectionModel.SINGLE_TREE_SELECTION) &&
    ((event.getModifiersEx() & InputEvent.SHIFT_DOWN_MASK) != 0);
}