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

@Override
public void createPartControl ( final Composite parent )
{
    this.container = parent;
    createEditingDomain ();

    parent.setLayout ( new FillLayout () );
    this.viewer = new TreeViewer ( parent );
    this.viewer.setAutoExpandLevel ( 2 );

    this.viewer.setContentProvider ( new AdapterFactoryContentProvider ( this.factory ) );
    this.viewer.setLabelProvider ( new AdapterFactoryLabelProvider ( this.factory ) );

    createContextMenuFor ( this.viewer );

    new AdapterFactoryTreeEditor ( this.viewer.getTree (), this.factory );
    getViewSite ().setSelectionProvider ( this.viewer );

    attachSelectionService ();

    getViewSite ().getActionBars ().getMenuManager ().add ( new Separator ( "additions" ) );

    this.actionBarContributor.init ( getViewSite ().getActionBars () );
    this.actionBarContributor.setViewPart ( this );
}

/**
 * Create the composite.
 */
public CustomElementSelectionForm(Composite parent, int style) {
    super(parent, style);
    setLayout(new GridLayout(2, false));

    treeViewer = new TreeViewer(this, SWT.BORDER);
    Tree tree = getTreeViewer().getTree();

    // Set a minimum height to prevent weird dialog dimensions
    tree.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).span(2, 1).minSize(0, 200).create());

    elementLabel = new Label(this, SWT.NONE);
    elementLabel.setLayoutData(GridDataFactory.swtDefaults().create());
    elementLabel.setText("New Label");

    elementInput = new SuffixText(this, SWT.BORDER);// new Text(this, SWT.BORDER);
    elementInput.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
}

@Override
protected TreeViewer createViewer(final Composite parent, final AbstractColumnLayout columnLayout,
        final int style) {
    final TreeViewer viewer = new TreeViewer(parent, virual ? (style | VIRTUAL) : style);
    final Tree tree = viewer.getTree();
    tree.setLinesVisible(linesVisible);
    tree.setHeaderVisible(headerVisible);

    int columnIndex = 0;
    for (final String columnLabel : columnLabels) {

        final TreeViewerColumn viewerColumn = new TreeViewerColumn(viewer, NONE);
        final TreeColumn column = viewerColumn.getColumn();
        columnLayout.setColumnData(column, createColumnLayoutData(columnIndex));
        column.setText(columnLabel);
        column.setMoveable(moveable);

        columnIndex++;
    }

    return viewer;
}

/**
 * Create contents of the editor part.
 * @param parent
 */
@Override
@PostConstruct
public void createPartControl(Composite parent) {

    this.sashForm = new SashForm(parent, SWT.NONE);

    this.treeViewer = new TreeViewer(this.sashForm, SWT.BORDER);
    this.tree = this.treeViewer.getTree();

    this.tabFolder = new CTabFolder(this.sashForm, SWT.BORDER);
    this.tabFolder.setTabPosition(SWT.BOTTOM);
    this.tabFolder.setSelectionBackground(Display.getCurrent().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT));

    this.tabItem = new CTabItem(this.tabFolder, SWT.NONE);
    this.tabItem.setText("New Item");

    this.tabItem_1 = new CTabItem(this.tabFolder, SWT.NONE);
    this.tabItem_1.setText("New Item");

    this.sashForm.setWeights(new int[] { 3, 10 });

}

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);
}

protected void performAdded ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        ( (TreeViewer)this.viewer ).add ( this.data, entries );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}

public void performRemoved ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        ( (TreeViewer)this.viewer ).remove ( entries );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}

public void performUpdated ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        for ( final ListEntry entry : entries )
        {
            ( (TreeViewer)this.viewer ).refresh ( entry );
        }
        ( (TreeViewer)this.viewer ).update ( entries, null );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}

public ServersViewer ( final Composite parent )
{
    parent.setLayout ( new FillLayout () );
    this.viewer = new TreeViewer ( parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL );

    this.contentProvider = new ObservableSetTreeContentProvider ( new ObservableFactoryImpl (), null );
    this.viewer.setContentProvider ( this.contentProvider );
    this.labelProvider = new ServerLabelProvider ( this.contentProvider.getKnownElements () );
    this.viewer.setLabelProvider ( this.labelProvider );

    this.viewer.setInput ( HivesPlugin.getDefault ().getServerManager () );
    this.viewer.getControl ().addDisposeListener ( new DisposeListener () {

        @Override
        public void widgetDisposed ( final DisposeEvent e )
        {
            handleDispose ();
        }
    } );

    ColumnViewerToolTipSupport.enableFor ( this.viewer );
}

protected synchronized void hasBeenModified() {
    if (isInherited()) return;

    XMLVector<XMLVector<Object>> xmlv = new XMLVector<XMLVector<Object>>();
    for(PropertyTableRowTreeObject rowTreeObject : getChildren()){
        XMLVector<Object> row = new XMLVector<Object>(rowTreeObject.getObject());
        xmlv.add(row);
    }
    data = xmlv;

    try {
        DatabaseObject databaseObject = databaseObjectTreeObject.getObject();
        java.beans.PropertyDescriptor databaseObjectPropertyDescriptor = databaseObjectTreeObject.getPropertyDescriptor(getObject());
        Method setter = databaseObjectPropertyDescriptor.getWriteMethod();
        Object args[] = { data };
        setter.invoke(databaseObject, args);
        databaseObject.hasChanged = true;
        databaseObjectTreeObject.hasBeenModified(true);
    }
    catch (Exception e) {}

       TreeViewer viewer = (TreeViewer) getAdapter(TreeViewer.class);
    viewer.update(databaseObjectTreeObject, null);

}

@Override
public boolean rename(String newName, Boolean bDialog) {
    if (getName().equals(newName))
        return true;

    IDesignTreeObject dto = getParentDesignTreeObject();
    if (((DesignDocumentTreeObject)dto).hasUpdate(newName)) {
        ConvertigoPlugin.logException(new ConvertigoException("The function named \"" + newName + "\" already exists."), "Unable to change the object name.", bDialog);
        return false;
    }

    getObject().setName(newName);
    hasBeenModified();

       TreeViewer viewer = (TreeViewer) getAdapter(TreeViewer.class);
    viewer.update(this, null);

    return true;
}

public boolean rename(String newName, Boolean bDialog) {
    if (getName().equals(newName))
        return true;
    if (getParentDesignTreeObject().hasView(newName)) {
        ConvertigoPlugin.logException(new ConvertigoException("The view named \"" + newName + "\" already exists."), "Unable to change the object name.", bDialog);
        return false;
    }

    getObject().setName(newName);
    hasBeenModified();

       TreeViewer viewer = (TreeViewer) getAdapter(TreeViewer.class);
    viewer.update(this, null);

    return true;
}

@Override
public boolean rename(String newName, Boolean bDialog) {
    if (getName().equals(newName))
        return true;

    IDesignTreeObject dto = getParentDesignTreeObject();
    if (((DesignDocumentTreeObject)dto).hasFilter(newName)) {
        ConvertigoPlugin.logException(new ConvertigoException("The function named \"" + newName + "\" already exists."), "Unable to change the object name.", bDialog);
        return false;
    }

    getObject().setName(newName);
    hasBeenModified();

       TreeViewer viewer = (TreeViewer) getAdapter(TreeViewer.class);
    viewer.update(this, null);

    return true;
}

private void updateLoadedProjects() {
    TreeParent invisibleRoot = ((ViewContentProvider)((TreeViewer)viewer).getContentProvider()).getTreeRoot();
    Sequence sequence = getObject();

    Set<String> loadedProject = sequence.getLoadedProjectNames();

    for (TreeObject treeObject : invisibleRoot.getChildren()) {
        if (treeObject instanceof ProjectTreeObject) {
            Project project = ((ProjectTreeObject)treeObject).getObject();
            sequence.setLoadedProject(project);
        }
        else if (treeObject instanceof UnloadedProjectTreeObject) {
            sequence.removeLoaded(((UnloadedProjectTreeObject)treeObject).getName());
        }

        if (loadedProject.contains(treeObject.getName())) {
            loadedProject.remove(treeObject.getName());
        }
    }

    for (String projectName: loadedProject) {
        sequence.removeLoaded(projectName);
    }
}

private void createColumns(TreeViewer viewer) {

        viewer.setColumnProperties(new String[] { "Name", "Value"});
        ColumnViewerToolTipSupport.enableFor(viewer);

        TreeViewerColumn nameColumn = new TreeViewerColumn(viewer, SWT.LEFT, 0);
        nameColumn.getColumn().setText("Name");
        nameColumn.getColumn().setWidth(200);
        nameColumn.setLabelProvider(new ColumnLabelProvider() {
            @Override
            public String getText(Object element) {
                INamedNode node = (INamedNode)element;
                return node.getDisplayName();
            }
        });
        nameColumn.setEditingSupport(new NameEditingSupport(this));

        TreeViewerColumn valueColumn = new TreeViewerColumn(viewer, SWT.LEFT, 1);
        valueColumn.getColumn().setText("Value");
        valueColumn.getColumn().setWidth(300);
        valueColumn.setLabelProvider(new DelegatingStyledCellLabelProvider(new ControlValueLabelProvider(cservice, this)));
        valueColumn.setEditingSupport(new ControlEditingSupport(viewer, cservice, controlViewerMode));
    }

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);
}

/**
 * @wbp.parser.entryPoint
 */
@Override
public void createControl(Composite parent) {
    fRootControl = new Composite(parent, SWT.NULL);
    fRootControl.setLayout(new FillLayout(SWT.HORIZONTAL));


    viewer = new TreeViewer(fRootControl, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
    viewer.setContentProvider(new ViewContentProvider());
    viewer.setLabelProvider(new DelegatingStyledCellLabelProvider(new ViewLabelProvider(createImageDescriptor())));
    viewer.addDoubleClickListener(new IDoubleClickListener () {

        @Override
        public void doubleClick(DoubleClickEvent evt) {
            TreeSelection sel = (TreeSelection) evt.getSelection();
            IFile file = (IFile) sel.getFirstElement();
            if (isModelFile(file)) {
                JDTManager.openEditor(file, "org.gw4e.eclipse.studio.editor.GW4EEditor", null); 
                return;
            }
            JDTManager.openEditor(file, null); 
        }

    });
    files = new ArrayList<IFile>();
}

private void initContextualView(IEditorPart editor) {
  if (editor == null) {
    return;
  }
  IFile file = editor.getEditorInput().getAdapter(IFile.class);
  TreeViewer treeViewer = ContextualView.getTreeViewer();
  if (treeViewer != null) {
    // Finding all markers in given file.
    ArrayList<IMarker> allMarkers;
    allMarkers = MarkerFactory.findMarkersAsArrayList(file);
    if (allMarkers == null) {
      return;
    }
    Iterator<IMarker> iter = allMarkers.iterator();
    while (iter.hasNext()) {
      IMarker marker = iter.next();
      if (MarkUtilities.getLeaderId(marker) == null && MarkUtilities.getGroupId(marker) != null) {
        iter.remove();
      }
    }
    if (!treeViewer.getTree().isDisposed()) {
      treeViewer.setInput(allMarkers.toArray());
    }
    treeViewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);
  }
}

@Override
public void createControl(Composite parent) {
  Composite container = new Composite(parent, SWT.NONE);
  setControl(container);
  container.setLayout(new FillLayout(SWT.HORIZONTAL));

  treeViewer = new TreeViewer(container, SWT.BORDER);
  treeViewer.setUseHashlookup(true);
  treeViewer.setLabelProvider(new SigTypeLabelProvider());
  treeViewer.setContentProvider(new SigTypeContentProvider());
  treeViewer.setInput(ResourcesPlugin.getWorkspace().getRoot().getProjects());

  treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {

    @Override
    public void selectionChanged(SelectionChangedEvent event) {
      if (((TreeSelection) event.getSelection()).getFirstElement() instanceof IMarker) {
        selection = event.getSelection();
        ContainerSelectionPage.this.setPageComplete(true);
      } else {
        ContainerSelectionPage.this.setPageComplete(false);
      }
    }
  });
}

@Override
public void createControl(Composite parent) {
  Composite container = new Composite(parent, SWT.NONE);
  this.setControl(container);
  container.setLayout(new FillLayout(SWT.HORIZONTAL));

  TreeViewer treeViewer = new TreeViewer(container, SWT.BORDER);
  treeViewer.setUseHashlookup(true);
  treeViewer.setLabelProvider(new CreatingAtomWizardLabelProvider());
  treeViewer.setContentProvider(new CreatingAtomWizardContentProvider());
  treeViewer.setInput(ResourcesPlugin.getWorkspace().getRoot().getProjects());
  treeViewer.setFilters(new ViewerFilter[] {new CreatingAtomWizardFilter()});

  treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {

    @Override
    public void selectionChanged(SelectionChangedEvent event) {
      if (((TreeSelection) event.getSelection()).getFirstElement() instanceof IMarker) {
        UntypedMarkerPage.this.selection = event.getSelection();
        UntypedMarkerPage.this.setPageComplete(true);
      } else {
        UntypedMarkerPage.this.setPageComplete(false);
      }
    }
  });
}

private void addPackage(TreeViewer treeViewer) {
    IJavaProject jProject = ProjectHelper.getCurrentJavaProject();
    if (jProject == null) {
        alertAndClose();
        return;
    }
    PackageSelectionDialog dialog = createPackageSelectionDialog(jProject);
    if (dialog.open() == IDialogConstants.OK_ID) {
        String packageName = getPackageName(dialog);
        if (nodeListManager.addNodesFromPackage(jProject, packageName,
                getFile(jProject, packageName).list())) {
            setTreeViewer(treeViewer);
            setPageComplete(false);
        }
    }
}

private void removeSelectedPackage(SelectionEvent e, TreeViewer treeViewer) {
    Tree tree = getTree(e);
    if (tree == null) {
        return;
    }
    TreeItem[] selection = tree.getSelection();
    if (selection != null && selection.length > 0) {
        for (TreeItem item : selection) {
            TreeItem parent = item.getParentItem();
            if (parent == null) {
                removePackage(item);
                updatePageComplete(tree);
            } else {
                alert("请选择要删除的包!");
            }
        }
    } else {
        alert("请选择要删除的包!");
    }
}

public static void expandAll(final TreeViewer treeViewer, final String context) {
    AvroSchemaLogger.logMsg(context + " BEGIN", false);
    BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {              
    @Override
    public void run() {
        long time1 = System.currentTimeMillis();                
        try {       
            treeViewer.getTree().setRedraw(false);
            treeViewer.expandAll();
        } finally {
            treeViewer.getTree().setRedraw(true);
            long time2 = System.currentTimeMillis();
            long delay = time2 - time1;
            AvroSchemaLogger.logMsg(context + " END : " + delay + " ms", false);
        }
    }
});
  }

public static void run(final TreeViewer treeViewer, final Runnable runnable, final String context) {
    AvroSchemaLogger.logMsg(context + " BEGIN", false);
    BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {              
    @Override
    public void run() {
        long time1 = System.currentTimeMillis();                
        try {                   
            treeViewer.getTree().setRedraw(false);
            runnable.run();
        } finally {
            treeViewer.getTree().setRedraw(true);
            long time2 = System.currentTimeMillis();
            long delay = time2 - time1;
            AvroSchemaLogger.logMsg(context + " END : " + delay + " ms", false);
        }
    }
});
  }

protected void computeAndDisplayStats(AvroSchemaEditor editor) {

    SchemaViewer masterViewer = editor.getContentPart().getSchemaViewer(AvroContext.Kind.MASTER);
    TreeViewer treeViewer = masterViewer.getTreeViewer();
    AvroNode inputNode = (AvroNode) treeViewer.getInput();
    NodeType inputType = inputNode.getType();
    String name = AttributeUtil.getNameFromAttribute(inputNode);

    NodeStats stats = new NodeStats("Compute stats of " + inputType.toString().toLowerCase() 
            + " " + name + " from editor " + editor.getName());
    stats.start();

    Tree tree = treeViewer.getTree();

    TreeItem[] items = tree.getItems();
    for (TreeItem item : items) {
        visitTreeItem(item, stats);
    }

    stats.finish();
    AvroSchemaLogger.logStats(stats, false);

}

protected void configureDragAndDrop(DragAndDropConfiguration dragAndDropConfiguration, TreeViewer treeViewer) {

      // drop
      Transfer[] transferTypes = new Transfer[] { LocalSelectionTransfer.getTransfer() };
      int operations = dragAndDropConfiguration.getSupportedDropOperations(this);

      DropTarget target = new DropTarget(treeViewer.getControl(), operations);
      target.setTransfer(transferTypes);

      // Drop listeners pour le drop des elements sur l'arbre
      SchemaViewerDropPolicy dropPolicy = dragAndDropConfiguration.getDropPolicy(this);
      DnDTargetListener targetListener = new DnDTargetListener(this, nodeConverter, dropPolicy);
      target.addDropListener(targetListener);

      // Drag listener pour le drag des elements de l'arbre
      DragSourceListener sourceListener = new DnDSourceListener(this);
      operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_DEFAULT;
      transferTypes = new Transfer[] { LocalSelectionTransfer.getTransfer() };
      treeViewer.addDragSupport(operations, transferTypes, sourceListener);

  }

protected void assertExpanded(TreeViewer aTreeViewer, IOutlineNode... expectedExpansion) {
    Object[] expandedElements = aTreeViewer.getExpandedElements();
    assertEquals(expectedExpansion.length, expandedElements.length);
    OUTER: for (Object expandedObject : expandedElements) {
        assertTrue(expandedObject instanceof IOutlineNode);
        for (IOutlineNode expectedExpanded : expectedExpansion) {
            if (nodeComparer.equals((IOutlineNode) expandedObject, expectedExpanded))
                continue OUTER;
        }
        fail("Unexpected expansion" + expandedObject.toString());
    }
}

protected void assertSelected(TreeViewer aTreeViewer, IOutlineNode... expectedSelection) {
    ISelection selection = aTreeViewer.getSelection();
    assertTrue(selection instanceof IStructuredSelection);
    assertEquals(expectedSelection.length, ((IStructuredSelection) selection).size());
    OUTER: for (Iterator<?> i = ((IStructuredSelection) selection).iterator(); i.hasNext();) {
        Object selectedObject = i.next();
        assertTrue(selectedObject instanceof IOutlineNode);
        for (IOutlineNode expectedSelected : expectedSelection) {
            if (nodeComparer.equals((IOutlineNode) selectedObject, expectedSelected))
                continue OUTER;
        }
        fail("Unexpected selection " + selectedObject.toString());
    }
}

@Override
protected Control createDialogArea(Composite parent) {
    CustomElementSelectionForm form = new CustomElementSelectionForm(parent, SWT.FILL);
    form.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());

    TreeViewer v = form.getTreeViewer();
    for (ViewerFilter filter : filters) {
        v.addFilter(filter);
    }
    this.treeViewer = v;

    WorkbenchContentProvider contentProvider = new WorkbenchContentProvider();
    ILabelProvider labelProvider = new WorkbenchLabelProvider();

    this.treeViewer.setContentProvider(contentProvider);
    this.treeViewer.setLabelProvider(labelProvider);

    this.treeViewer.setComparator(new ViewerComparator());

    this.treeViewer.setAutoExpandLevel(this.getAutoExpandLevel());

    form.setElementLabel(this.elementLabel);

    this.elementNameInput = form.getElementInput();

    form.getElementInput().addPropertyChangeListener(new PropertyChangeListener() {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getPropertyName().equals(SuffixText.TEXT_PROPERTY) ||
                    evt.getPropertyName().equals(SuffixText.SUFFIX_PROPERTY)) {
                validateElementInput();
                elementInputChanged();
            }

        }
    });
    return form;
}

private static void updateInput(final TreeViewer viewer, final Object input) {
    UIUtils.getDisplay().asyncExec(() -> {
        final Object[] expandedElements = viewer.getExpandedElements();
        final TreePath[] expandedTreePaths = viewer.getExpandedTreePaths();
        viewer.setInput(input);
        viewer.getControl().notifyListeners(Selection, null);
        if (!Arrays2.isEmpty(expandedElements)) {
            viewer.setExpandedElements(expandedElements);
        }
        if (!Arrays2.isEmpty(expandedTreePaths)) {
            viewer.setExpandedTreePaths(expandedTreePaths);
        }
    });
}