java类org.eclipse.jface.viewers.TreePath的实例源码

private boolean selectTreePath(Viewer viewer, TreePath parentPath, Object element) {
    // Cut off children of elements that are shown repeatedly.
    for (int i = 0; i < parentPath.getSegmentCount() - 1; i++) {
        if (element.equals(parentPath.getSegment(i))) {
            return false;
        }
    }

    if (!(viewer instanceof TreeViewer)) {
        return true;
    }
    if (matcher == null) {
        return true;
    }
    TreeViewer treeViewer = (TreeViewer) viewer;
    Boolean matchingResult = isMatchingOrNull(element);
    if (matchingResult != null) {
        return matchingResult;
    }
    return hasUnfilteredChild(treeViewer, parentPath, element);
}

private boolean selectTreePath(Viewer viewer, TreePath parentPath, Object element) {
    // Cut off children of elements that are shown repeatedly.
    for (int i = 0; i < parentPath.getSegmentCount() - 1; i++) {
        if (element.equals(parentPath.getSegment(i))) {
            return false;
        }
    }

    if (!(viewer instanceof TreeViewer)) {
        return true;
    }
    if (matcher == null) {
        return true;
    }
    TreeViewer treeViewer = (TreeViewer) viewer;
    Boolean matchingResult = isMatchingOrNull(element);
    if (matchingResult != null) {
        return matchingResult;
    }
    return hasUnfilteredChild(treeViewer, parentPath, element);
}

public static IJavaProject[] getJavaProjects(final ITreeSelection treeSelection) {
  if (treeSelection == null) {
    return new IJavaProject[0];
  }
  final List<IJavaProject> projects = new ArrayList<>();
  final TreePath[] paths = treeSelection.getPaths();
  for (final TreePath treePath : paths) {
    if (treePath.equals(TreePath.EMPTY)) {
      continue;
    }
    for (int i = 0; i < treePath.getSegmentCount(); i++) {
      final Object segment = treePath.getSegment(i);
      if ((segment instanceof IJavaProject)) {
        projects.add((IJavaProject) segment);
        break;
      }
    }
  }
  return projects.toArray(new IJavaProject[projects.size()]);
}

public static IJavaElement[] getJavaElements(final ITreeSelection selection) {
  if (selection == null) {
    return new IJavaProject[0];
  }
  final List<IJavaElement> projects = new ArrayList<>();
  for (final TreePath treePath : selection.getPaths()) {
    if (treePath.equals(TreePath.EMPTY)) {
      continue;
    }
    final Object lastSegment = treePath.getLastSegment();
    if (!(lastSegment instanceof IJavaElement)) {
      continue;
    }
    projects.add((IJavaElement) lastSegment);
  }
  return projects.toArray(new IJavaElement[projects.size()]);
}

private boolean selectTreePath(Viewer viewer, TreePath parentPath, Object element) {
    // Cut off children of elements that are shown repeatedly.
    for (int i = 0; i < parentPath.getSegmentCount() - 1; i++) {
        if (element.equals(parentPath.getSegment(i))) {
            return false;
        }
    }

    if (!(viewer instanceof TreeViewer)) {
        return true;
    }
    if (matcher == null) {
        return true;
    }
    TreeViewer treeViewer = (TreeViewer) viewer;
    Boolean matchingResult = isMatchingOrNull(element);
    if (matchingResult != null) {
        return matchingResult;
    }
    return hasUnfilteredChild(treeViewer, parentPath, element);
}

@Override
protected boolean computeEnablement(final IStructuredSelection selection) {
    if (selection.size() != 1) {
        return false;
    }

    // For VS 2010 the content provider is a TreeContentProvider. Only
    // enable this action for history items at the root level. For
    // versions prior to 2010 the condition for enablement conditions
    // are unchanged.
    boolean isRootItemSelected = true;
    if (selection instanceof ITreeSelection) {
        final ITreeSelection treeSelection = (ITreeSelection) selection;
        final TreePath[] treePaths = treeSelection.getPaths();
        if (treePaths.length == 1) {
            isRootItemSelected = treePaths[0].getSegmentCount() == 1;
        }
    }

    final String item = historyInput.getHistoryItem();
    return !ServerPath.isServerPath(item) && isRootItemSelected;
}

public void setInput(PageRoot inputElement) {
    input = inputElement;
    if (viewer != null) {
        Object[] expandedElements = viewer.getExpandedElements();
        TreePath[] expandedTreePaths = viewer.getExpandedTreePaths();

        viewer.setInput(input);

        viewer.setExpandedElements(expandedElements);
        viewer.setExpandedTreePaths(expandedTreePaths);

        actions.get(ACTION_COPY).setEnabled(true);
        actions.get(ACTION_CUT).setEnabled(true);
        actions.get(ACTION_PASTE).setEnabled(true);
        actions.get(ACTION_DELETE).setEnabled(true);
    }
}

/**
 * getExpandTreePaths
 *  
 * @param tree
 * @param selectedItem
 * @return TreePath[]
 */
public static TreePath[] getExpandTreePaths(Tree tree, TreeItem selectedItem) {
    ArrayList<Object> items = new ArrayList<Object>();
    internalCollectTreeItems(items, tree);
    ArrayList<Object> result = new ArrayList<Object>();

    for (Iterator<Object> it = items.iterator(); it.hasNext();) {
        Item item = (Item) it.next();
        // if (item == selectedItem) {
        TreePath treePath = getTreePathFromItem(item);
        if (treePath != null) {
            result.add(treePath);
        }
        // }
    }

    return (TreePath[]) result.toArray(new TreePath[items.size()]);
}

/**
 * hierarchyCheck
 *  
 * @return boolean
 */
protected boolean hierarchyCheck() {
    CommonViewer commonViewer = ViewerRegistry.getViewer();
    TreeSelection sel = (TreeSelection) commonViewer.getSelection();

    List<TreePath> pathList = Arrays.asList(sel.getPaths());

    for (TreePath path : pathList) {
        if (isContains(pathList, path.getParentPath())) {
            MessageDialog.openError(ProjectExplorerPlugin.getShell(),
                UMLMessage.LABEL_FILE_FRAGMENTATION,
                UMLMessage.MESSAGE_FRAGMENT_DEFRAGMENT_ERROR_MESSAGE/*"패키지 간 상하 관계가 포함된 경우 일괄 단편화/병합을 실행할 수 없습니다."*/);
            return false;
        }
    }

    return true;
}

protected void doRunSimulationExperiment() {
    TreePath[] paths = suiteViewer.getStructuredSelection().getPaths();
    if ((paths != null)&&(paths.length>0)) {
        TreePath selected = paths[0];           
        if (selected.getSegmentCount()>=2) {
            SimulationSuiteElement simulationSuiteElement = (SimulationSuiteElement) selected.getSegment(1);
            RunSimulationExperimentJob experiment = new RunSimulationExperimentJob(this, simulationSuiteElement);

            //update the Lab View
            //updateView();

            experiment.setUser(true);
            experiment.schedule();
        }
    }

}

private void refreshTreeViewer(final BTSCorpusObject btsCorpusObject) {
        sync.asyncExec(new Runnable() {
            public void run() {
                if (!mainTreeViewer.getTree().isDisposed())
                {

//                  mainTreeViewer
//                          .removeSelectionChangedListener(selectionListener);
                    for (TreePath path : mainTreeViewer.getExpandedTreePaths())
                        System.out.println(path.getLastSegment());
                    mainTreeViewer.refresh();
//                  mainTreeViewer.addSelectionChangedListener(selectionListener);
                }
            }
        });

    }

private void refreshTreeViewer(final BTSCorpusObject btsCorpusObject) {
        sync.asyncExec(new Runnable() {
            public void run() {
                if (!mainTreeViewer.getTree().isDisposed())
                {

//                  mainTreeViewer
//                          .removeSelectionChangedListener(selectionListener);
                    for (TreePath path : mainTreeViewer.getExpandedTreePaths())
                        System.out.println(path.getLastSegment());
                    mainTreeViewer.refresh();
//                  mainTreeViewer.addSelectionChangedListener(selectionListener);
                }
            }
        });

    }

private void refreshTreeViewer(final BTSCorpusObject btsCorpusObject) {
        sync.asyncExec(new Runnable() {
            public void run() {
                if (!mainTreeViewer.getTree().isDisposed())
                {

//                  mainTreeViewer
//                          .removeSelectionChangedListener(selectionListener);
                    for (TreePath path : mainTreeViewer.getExpandedTreePaths())
                        System.out.println(path.getLastSegment());
                    mainTreeViewer.refresh();
//                  mainTreeViewer.addSelectionChangedListener(selectionListener);
                }
            }
        });

    }

private void refreshTreeViewer(final BTSCorpusObject btsCorpusObject) {
        sync.asyncExec(new Runnable() {
            public void run() {
                if (!mainTreeViewer.getTree().isDisposed())
                {

//                  mainTreeViewer
//                          .removeSelectionChangedListener(selectionListener);
                    for (TreePath path : mainTreeViewer.getExpandedTreePaths())
                        System.out.println(path.getLastSegment());
                    mainTreeViewer.refresh();
//                  mainTreeViewer.addSelectionChangedListener(selectionListener);
                }
            }
        });

    }

@Override
public void handleEvent(final Event event) {
    // FIXME hack, should be solved be resetting the selection in viewer
    // instead
    btnToEdit.setEnabled(false);
    btnUngroup.setEnabled(false);
    final TreePath[] paths = xViewer.getSelection().getPaths();
    if (paths.length > 0) {
        final Copy copy = (Copy) paths[0].getLastSegment();
        setInput(copy);
        copies.remove(copy);
        bindingContext.updateTargets();
        checkGroups();
        updateToListButton();
        updateSaveButton();
        xViewer.setInput(copies);
    }
}

@Override
public void doubleClick(final DoubleClickEvent event) {
    // safety check first
    if (event == null || event.getSelection() == null || !(event.getSelection() instanceof TreeSelection)) {
        return;
    }
    final TreeSelection selection = (TreeSelection) event.getSelection();
    final TreePath[] paths = selection.getPaths();
    final TreePath treePath = paths[paths.length - 1];
    final Object segment = treePath.getLastSegment();

    final TreeItem[] items = viewer.getTree().getItems();
    final TreeItem item = getItem(items, segment);
    if (item != null) {
        item.setExpanded(!item.getExpanded());
        viewer.refresh();
    }
}

private void copyTreeSelectionToClipboard() {
  ITreeSelection selection = (ITreeSelection) treeViewer.getSelection();
  TreePath[] paths = selection.getPaths();

  StringBuffer buf = new StringBuffer();

  for (TreePath path : paths) {
    LogEntry<?> entry = (LogEntry<?>) path.getLastSegment();
    buf.append(createTabString(path.getSegmentCount() - 1));
    buf.append(entry.toString());
    buf.append("\n");
  }

  if (buf.length() > 0) {
    buf.deleteCharAt(buf.length() - 1); // take off last \n
  }

  copyToClipboard(buf.toString());
}

/**
 * We will accept the selection in the workbench to see if we can initialize
 * from it.
 * 
 * @see IWorkbenchWizard#init(IWorkbench, IStructuredSelection)
 */
public void init(IWorkbench workbench, IStructuredSelection selection) {
    if (selection instanceof StructuredSelection) {
        if (selection.getFirstElement() instanceof IProject || selection.getFirstElement() instanceof IFile || selection.getFirstElement() instanceof IFolder) {
            this.selection = selection;
            return;
        }
        for (Object obj : selection.toList()) {
            if (obj instanceof EditPart) {
                IEditorInput ein = SelectionHelper.getActiveJRXMLEditor().getEditorInput();
                if (ein instanceof FileEditorInput) {
                    this.selection = new TreeSelection(new TreePath(new Object[] { ((FileEditorInput) ein).getFile() }));
                    return;
                }
            }
        }
    }
    this.selection = selection;
}

@Override
public void init(IWorkbench workbench, IStructuredSelection selection) {
    if (selection instanceof StructuredSelection) {
        if (selection.getFirstElement() instanceof IProject || selection.getFirstElement() instanceof IFile || selection.getFirstElement() instanceof IFolder) {
            this.selection = selection;
            return;
        }
        for (Object obj : selection.toList()) {
            if (obj instanceof EditPart) {
                IEditorInput ein = SelectionHelper.getActiveJRXMLEditor().getEditorInput();
                if (ein instanceof FileEditorInput) {
                    this.selection = new TreeSelection(new TreePath(new Object[] { ((FileEditorInput) ein).getFile() }));
                    return;
                }
            }
        }
    }
    this.selection = selection;
}

@Override
public void run() {
    TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();
    for (int i = 0; i < p.length;) {
        final Object obj = p[i].getLastSegment();
        if (obj instanceof ANode) {
            ANode parent = (ANode) obj;
            AddResourceWizard wizard = new AddResourceWizard(parent);
            WizardDialog dialog = new WizardDialog(UIUtils.getShell(), wizard);
            dialog.create();
            dialog.open();
        }
        break;
    }

}

@Override
public void run() {
    final TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();
    for (int i = 0; i < p.length; i++) {
        final Object obj = p[i].getLastSegment();
        if (obj instanceof MResource) {
            PermissionWizard wizard = new PermissionWizard((MResource) obj);
            PermissionDialog dialog = new PermissionDialog(UIUtils.getShell(), wizard);
            dialog.addApplyListener(wizard);
            dialog.open();
        } else if (obj instanceof MServerProfile) {
            EditServerAction.fillServerProfile((MServerProfile) obj, treeViewer);
        }
    }
}

@Override
public void run() {
    final TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();
    for (int i = 0; i < p.length; i++) {
        Object obj = p[i].getLastSegment();
        if (obj instanceof MResource) {
            INode node = ((MResource) obj).getReportUnit();
            if (node != null) {
                final String key = ServerManager.getKey((MReportUnit) node);
                if (key != null)
                    Display.getDefault().asyncExec(new Runnable() {

                        public void run() {
                            SelectionHelper.openEditor(key, ReportUnitEditor.ID);
                        }
                    });
            }
            break;
        }
    }
}

@Override
public void run() {
    TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();
    List<MResource> rlist = new ArrayList<MResource>();
    for (int i = 0; i < p.length; i++) {
        final Object obj = p[i].getLastSegment();
        if (obj instanceof MResource) {
            System.out.println(((MResource) obj).getToolTip());
            ((MResource) obj).setCut(true);
            rlist.add((MResource) obj);
        }
    }
    if (!rlist.isEmpty())
        Clipboard.getDefault().setContents(rlist);
}

public void editElement(Object element, int column) {
    if (element instanceof TreePath) {
        setSelection(new TreeSelection((TreePath) element));
        GalleryItem[] items = gallery.getSelection();

        if (items.length == 1) {
            ViewerRow row = getViewerRowFromItem(items[0]);

            if (row != null) {
                ViewerCell cell = row.getCell(column);
                if (cell != null) {
                    getControl().setRedraw(false);
                    triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(cell));
                    getControl().setRedraw(true);
                }
            }
        }
    } else {
        super.editElement(element, column);
    }
}

@Override
public void run() {
    TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();

    for (int i = 0; i < p.length; i++) {
        Object obj = p[i].getLastSegment();
        if (obj instanceof MDataAdapter) {
            SaveAsDialog saveAsDialog = new SaveAsDialog(Display.getDefault().getActiveShell());
            saveAsDialog.setOriginalName(((MDataAdapter) obj).getValue().getName().replace(" ", "") + ".xml"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            saveAsDialog.open();
            IPath path = saveAsDialog.getResult();
            if (path != null)
                saveFile(obj, path);
        }
    }
}

@Override
public void run() {
    TreeSelection s = (TreeSelection) treeViewer.getSelection();
    TreePath[] p = s.getPaths();

    if (!UIUtils.showDeleteConfirmation())
        return;
    ADataAdapterStorage storage = null;
    for (int i = 0; i < p.length; i++) {
        Object obj = p[i].getLastSegment();
        if (obj instanceof MDataAdapter) {
            MDataAdapter mDataAdapter = (MDataAdapter) obj;
            DataAdapterDescriptor m = mDataAdapter.getValue();
            if (storage == null)
                storage = ((MDataAdapters) mDataAdapter.getParent()).getValue();
            if (storage != null)
                storage.removeDataAdapter(m);
            treeViewer.refresh(true);
        }
    }
}

public void setActivePart(IAction action, IWorkbenchPart targetPart) {
    ISelection s = targetPart.getSite().getSelectionProvider().getSelection();
    if (s instanceof TreeSelection) {
        TreePath[] tp = ((TreeSelection) s).getPaths();
        for (int i = 0; i < tp.length; i++) {
            Object obj = tp[i].getFirstSegment();
            if (obj instanceof IProject) {
                try {
                    if (((IProject) obj).hasNature(JasperReportsNature.NATURE_ID))
                        action.setChecked(true);
                    else {
                        action.setChecked(false);
                        break;
                    }
                } catch (CoreException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * @param allVisibleItems
 * @param allExpandedItems
 * @return Returns {@link TreePath}'s which are expanded and open (not hidden).
 */
public static TreePath[] getExpandedOpenedItems(final Object[] allVisibleItems, final TreePath[] allExpandedItems) {

    final ArrayList<TreePath> expandedOpened = new ArrayList<TreePath>();

    for (final TreePath expandedPath : allExpandedItems) {

        /*
         * The last expanded segment must be in the visible list otherwise it is hidden.
         */
        final Object lastExpandedItem = expandedPath.getLastSegment();

        for (final Object visibleItem : allVisibleItems) {

            if (lastExpandedItem == visibleItem) {

                expandedOpened.add(expandedPath);
                break;
            }
        }
    }

    return expandedOpened.toArray(new TreePath[expandedOpened.size()]);
}

private List<TreePath> getTreePaths(List<Object> modelParents, int index) {
    List<TreePath> result= new ArrayList<TreePath>();
    Object input= getViewerInput();
    Object element= modelParents.get(index);
    Object[] parents= fWorkingSetModel.getAllParents(element);
    for (int i= 0; i < parents.length; i++) {
        List<Object> chain= new ArrayList<Object>();
        if (!parents[i].equals(input))
            chain.add(parents[i]);
        for (int m= index; m < modelParents.size(); m++) {
            chain.add(modelParents.get(m));
        }
        result.add(new TreePath(chain.toArray()));
    }
    return result;
}

public void updateLabel(ViewerLabel label, TreePath elementPath) {
    Object firstSegment = elementPath.getFirstSegment();
    if (firstSegment instanceof IProject && elementPath.getSegmentCount() == 2) {
        IProject project = (IProject) firstSegment;
        Object lastSegment = elementPath.getLastSegment();
        if (lastSegment instanceof IFolder) {
            IFolder folder = (IFolder) lastSegment;
            if (!folder.getParent().equals(project)) {
                // This means that a folder that is not a direct child of the project
                // is a child in the tree. Therefore, the resource content provider
                // must be active and in compress folder mode so we will leave
                // it to the resource provider to provide the proper label.
                // We need to do this because of bug 153912
                return;
            }
        }
    }
    label.setImage(getImage(elementPath.getLastSegment()));
    label.setText(getText(elementPath.getLastSegment()));
    Font f = getFont(elementPath.getLastSegment());
    if (f != null)
        label.setFont(f);
}