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

@Override
public void setFocus(){
    super.setFocus();
    if (viewer == null) {
        Konsultation selectedKons =
            (Konsultation) ElexisEventDispatcher.getSelected(Konsultation.class);

        viewer = commonViewer.getViewerWidget();
        IContentProvider contentProvider = viewer.getContentProvider();
        if (contentProvider instanceof TarmedCodeSelectorContentProvider) {
            if (selectedKons != null) {
                updateLawFilter(selectedKons);
            }
            viewer.addFilter(lawFilter);
        }
        if (selectedKons != null) {
            updateValidFilter(selectedKons);
        }
        viewer.addFilter(validDateFilter);
        ElexisEventDispatcher.getInstance().addListeners(konsFilter);
    }
    refreshViewer();
}

/**
 * Creates a tableviewer from the given provider.
 * 
 * @param parent
 *            Composite that holds the table.
 * @param dataset
 * @param labelProvider
 * @param contentProvider
 * @return Table
 */
public TableViewer createTableFromData(final Composite parent, final DataSet dataset,
        final ILabelProvider labelProvider, final IContentProvider contentProvider) {
    Table table = this.createTable(parent, dataset);

    // Create table viewer and set providers.
    TableViewer tableViewer = new TableViewer(table);

    // Set providers.
    tableViewer.setLabelProvider(labelProvider);
    tableViewer.setContentProvider(contentProvider);

    // Invoke the inputChanged method after a content provider is set.
    tableViewer.setInput(table);

    // add column sorters.
    this.addColumnSort(tableViewer);

    return tableViewer;
}

private boolean hasUnfilteredChild(TreeViewer viewer, TreePath parentPath, Object element) {
    TreePath elementPath = parentPath.createChildPath(element);
    IContentProvider contentProvider = viewer.getContentProvider();
    Object[] children = contentProvider instanceof ITreePathContentProvider
            ? ((ITreePathContentProvider) contentProvider).getChildren(elementPath)
            : ((ITreeContentProvider) contentProvider).getChildren(element);

    /* avoid NPE + guard close */
    if (children == null || children.length == 0) {
        return false;
    }
    for (int i = 0; i < children.length; i++) {
        if (selectTreePath(viewer, elementPath, children[i])) {
            return true;
        }
    }
    return false;
}

private static void initViewer(StructuredViewer viewer, ElementTypes elementTypes, Object input,
        IElementBinding elementBinding, IViewerType viewerType, Class<?> contentProviderInterfaceType) {

    PluggableContentProvider pluggableContentProvider = new PluggableContentProvider(viewerType, elementTypes,
            elementBinding);

    ElementTypesLabelProvider labelProvider = new ElementTypesLabelProvider(elementTypes);

    DelegatingInvocationHandler invocationHandler = new DelegatingInvocationHandler(pluggableContentProvider);

    IContentProvider contentProvider = (IContentProvider) Proxy.newProxyInstance(contentProviderInterfaceType
            .getClassLoader(), new Class[] { contentProviderInterfaceType }, invocationHandler);

    viewer.setContentProvider(contentProvider);
    viewer.setLabelProvider(labelProvider);
    viewer.setUseHashlookup(true);
    viewer.setInput(input);
}

private IContentProvider createContentProvider() {
    return new IStructuredContentProvider() {
        @Override
        public void dispose() {
        }

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

        }

        @Override
        public Object[] getElements(Object inputElement) {

            Object model = null;
            if (inputElement instanceof IPointGenerator) {
                IPointGenerator<IScanPathModel> op = (IPointGenerator<IScanPathModel>)inputElement;
                model = op.getModel();
            } else {
                model = inputElement;
            }
            try {
                final Collection<FieldValue>  col = FieldUtils.getModelFields(model);
                return col.toArray(new FieldValue[col.size()]);
            } catch (Exception ne) {
                return new FieldValue[]{};
            }
        }
    };
}

private IContentProvider createContentProvider() {
    return new IStructuredContentProvider() {


        private Set<Entry<Object, Object>> entries;

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            @SuppressWarnings("unchecked")
            Map<Object,Object> tmp = (Map<Object,Object>)newInput;
            if (tmp==null) return;
            this.entries = tmp.entrySet();
        }

        @Override
        public void dispose() {

        }

        @Override
        public Object[] getElements(Object inputElement) {
            return entries.toArray(new Entry[entries.size()]);
        }
    };
}

private IContentProvider createContentProvider() {
    return new IStructuredContentProvider() {

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }

        @Override
        public void dispose() {
            if (consumers!=null) consumers.clear();
        }

        @Override
        public Object[] getElements(Object inputElement) {
            if (consumers==null) return new HeartbeatBean[]{HeartbeatBean.EMPTY};
            final List<HeartbeatBean> beats = new ArrayList<>(consumers.values());
            Collections.sort(beats, new Comparator<HeartbeatBean>() {
                @Override
                public int compare(HeartbeatBean o1, HeartbeatBean o2) {
                    return (int)(o2.getConceptionTime()-o1.getConceptionTime());
                }
            });
            return beats.toArray(new HeartbeatBean[consumers.size()]);
        }
    };
}

@SuppressWarnings("squid:S3776")
private IContentProvider createContentProvider() {
    return new IStructuredContentProvider() {
        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            queue = (Map<String, StatusBean>)newInput;
        }

        @Override
        public void dispose() {
            if (queue!=null) queue.clear();
        }

        @Override
        public Object[] getElements(Object inputElement) {
            if (queue==null) return new StatusBean[]{StatusBean.EMPTY};
            final List<StatusBean> retained = new ArrayList<>(queue.values());

            // This preference is not secure people could hack DAWN to do this.
            if (!Boolean.getBoolean("org.dawnsci.commandserver.ui.view.showWholeQueue")) {
                // Old fashioned loop. In Java8 we will use a predicate...
                final String userName = getUserName();
                for (Iterator it = retained.iterator(); it.hasNext();) {
                    StatusBean statusBean = (StatusBean) it.next();
                    if (statusBean.getUserName()==null) continue;
                    if (hideOtherUsersResults && !userName.equals(statusBean.getUserName())) it.remove();
                }
                // This form of filtering is not at all secure because we
                // give the full list of the queue to the clients.
            }
            return retained.toArray(new StatusBean[retained.size()]);
        }
    };
}

private boolean hasUnfilteredChild(TreeViewer viewer, TreePath parentPath, Object element) {
    TreePath elementPath = parentPath.createChildPath(element);
    IContentProvider contentProvider = viewer.getContentProvider();
    Object[] children = contentProvider instanceof ITreePathContentProvider
            ? ((ITreePathContentProvider) contentProvider).getChildren(elementPath)
            : ((ITreeContentProvider) contentProvider).getChildren(element);

    /* avoid NPE + guard close */
    if (children == null || children.length == 0) {
        return false;
    }
    for (int i = 0; i < children.length; i++) {
        if (selectTreePath(viewer, elementPath, children[i])) {
            return true;
        }
    }
    return false;
}

protected IContentProvider getContentProvider(final boolean undo) {
    return new IStructuredContentProvider() {

        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            //
        }

        @Override
        public void dispose() {
            //
        }

        @Override
        public Object[] getElements(Object inputElement) {
            ICommandExecutor cmdExecutor = (ICommandExecutor) inputElement;
            if (undo) {
                return cmdExecutor.getUndoableCommandStack().toArray();
            } else {
                return cmdExecutor.getRedoableCommandStack().toArray();
            }
        }

    };
}

private boolean hasUnfilteredChild(TreeViewer viewer, TreePath parentPath, Object element) {
    TreePath elementPath = parentPath.createChildPath(element);
    IContentProvider contentProvider = viewer.getContentProvider();
    Object[] children = contentProvider instanceof ITreePathContentProvider
            ? ((ITreePathContentProvider) contentProvider).getChildren(elementPath)
            : ((ITreeContentProvider) contentProvider).getChildren(element);

    /* avoid NPE + guard close */
    if (children == null || children.length == 0) {
        return false;
    }

    for (int i = 0; i < children.length; i++) {
        if (selectTreePath(viewer, elementPath, children[i])) {
            return true;
        }
    }
    return false;
}

private void setupBranchViewers() {
    final IContentProvider contentProvider = new ContentProviderAdapter() {
        @Override
        public Object[] getElements(final Object input) {
            @SuppressWarnings("unchecked")
            final List<GitBranch> branches = ((List<GitBranch>) input);

            return branches.toArray(new GitBranch[branches.size()]);
        }
    };
    branchViewer.setContentProvider(contentProvider);
    branchComboViewer.setContentProvider(contentProvider);

    final LabelProvider labelProvider = new LabelProvider() {
        @Override
        public String getText(final Object element) {
            return ((GitBranch) element).getRemoteName();
        }
    };
    branchViewer.setLabelProvider(labelProvider);
    branchComboViewer.setLabelProvider(labelProvider);

    final ViewerComparator viewerComparator = new ViewerComparator() {
        @Override
        public int compare(final Viewer viewer, final Object e1, final Object e2) {
            return ((GitBranch) e1).compareTo(((GitBranch) e2));
        }
    };
    branchViewer.setComparator(viewerComparator);
    branchComboViewer.setComparator(viewerComparator);
}

public ChangePathsTableProvider(Composite parent, IContentProvider contentProvider) {
  super(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI | SWT.FULL_SELECTION);

  TableLayout layout = new TableLayout();
  GridData data = new GridData(GridData.FILL_BOTH);

  Table table = (Table) getControl();
  table.setHeaderVisible(true);
  table.setLinesVisible(true);
  table.setLayoutData(data);    
  table.setLayout(layout);
  table.addDisposeListener(new DisposeListener() {
    public void widgetDisposed(DisposeEvent e) {
      if(currentPathFont != null) {
        currentPathFont.dispose();
      }
    }
  });

  createColumns(table, layout);

  setLabelProvider(new ChangePathLabelProvider());
  setContentProvider(contentProvider);

  ChangePathsSorter sorter = new ChangePathsSorter(COL_PATH);
  setSorter(sorter);
  table.setSortDirection(SWT.UP);
}

public ChangePathsTreeViewer(Composite parent, IContentProvider contentProvider) {
    super(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI /*| SWT.FULL_SELECTION*/);
    GridData data = new GridData(GridData.FILL_BOTH);
    getControl().setLayoutData(data);
    getControl().addDisposeListener(new DisposeListener() {
        public void widgetDisposed(DisposeEvent e) {
            if(currentPathFont != null) {
                currentPathFont.dispose();
            }
        }
    });

    setLabelProvider(new ChangePathLabelProvider());
    setContentProvider(contentProvider);
}

protected IContentProvider createContentProvider(AbstractTraceEditor<?> editor, TableViewer logViewerTable, boolean supportsVariableRowHeight){
 ILogMessage root =   ((StaticTraceEditorInput)editor.getEditorInput()).getRoot();
 if (supportsVariableRowHeight)
     return new DetailedLinuxTableContentProvider(this, root);
 else
     return new DetailedWindowsTableContentProvider(this, root);
}

private void setContentProvider(ViewerComparator viewerComparator, IContentProvider contentProvider,
        boolean supportsFilters, boolean supportsPlugins) {
    viewer.setComparator(viewerComparator);
    viewer.setContentProvider(contentProvider);

    setViewerFilterActionsEnabled(supportsFilters);
    showPluginsAction.setEnabled(supportsPlugins);

    if (supportsFilters) {
        resetViewerFilters();
    } else {
        viewer.setFilters(new ViewerFilter[] { patternFilter });
    }
}

public ChangePathsTableProvider(Composite parent, IContentProvider contentProvider) {
  super(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI | SWT.FULL_SELECTION);

  TableLayout layout = new TableLayout();
  GridData data = new GridData(GridData.FILL_BOTH);

  Table table = (Table) getControl();
  table.setHeaderVisible(true);
  table.setLinesVisible(true);
  table.setLayoutData(data);    
  table.setLayout(layout);
  table.addDisposeListener(new DisposeListener() {
    public void widgetDisposed(DisposeEvent e) {
      if(currentPathFont != null) {
        currentPathFont.dispose();
      }
    }
  });

  createColumns(table, layout);

  setLabelProvider(new ChangePathLabelProvider());
  setContentProvider(contentProvider);

  ChangePathsSorter sorter = new ChangePathsSorter(COL_PATH);
  setSorter(sorter);
  table.setSortDirection(SWT.UP);
}

public ChangePathsTreeViewer(Composite parent, IContentProvider contentProvider) {
    super(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI /*| SWT.FULL_SELECTION*/);
    GridData data = new GridData(GridData.FILL_BOTH);
    getControl().setLayoutData(data);
    getControl().addDisposeListener(new DisposeListener() {
        public void widgetDisposed(DisposeEvent e) {
            if(currentPathFont != null) {
                currentPathFont.dispose();
            }
        }
    });

    setLabelProvider(new ChangePathLabelProvider());
    setContentProvider(contentProvider);
}

private TableViewer createTableViewer(Composite container, IContentProvider provider, Object[] input) {
    GridData gd = new GridData(GridData.FILL_BOTH);
    gd.heightHint = 200;
    gd.widthHint = 225;

    Table table = new Table(container, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
    table.setLayoutData(gd);

    TableViewer viewer = new TableViewer(table);
    viewer.setLabelProvider(fLabelProvider);
    viewer.setContentProvider(provider);
    viewer.setInput(input);
    viewer.setComparator(new ViewerComparator());
    return viewer;
}

/**
 * The remove command to return may be a simple straight-forward remove command
 * or it may be a complicated remove command where we are trying to remove an item from a
 * table open a multi-valued attribute.
 * 
 * @return an appropriate remove command.
 */
private Command getRemoveCommand(
        final EditingDomain editingDomain,
        final TreeTableViewer<EObject, EAttribute> treeTableViewer,
        List list) {
    Command command = RemoveCommand.create(editingDomain, list);
    if(command instanceof UnexecutableCommand) {
        IContentProvider contentProvider = treeTableViewer.getContentProvider();
        if(contentProvider instanceof EMFTreeTableContentProvider) {
            EMFTreeTableContentProvider emfContentProvider = (EMFTreeTableContentProvider)contentProvider;
            EStructuralFeature structuralFeature = emfContentProvider.getStructuralFeature();
            EObject owner = null;
            if(structuralFeature instanceof EAttribute && structuralFeature.isMany()) {
                List itemsToRemove = new ArrayList();
                for(Object object : list) {
                    if(object instanceof EObjectIndexPair) {
                        EObjectIndexPair pair = (EObjectIndexPair) object;
                        if(owner == null) {
                            owner = pair.getObject();
                        } else if(owner.equals(pair.getObject())) {
                            LogUtil.warn("object index pairs in the same list have different owners.");
                            continue;
                        }
                        int index = pair.getIndex();
                        List values = (List) owner.eGet(structuralFeature);
                        Object selectedValue = values.get(index);
                        itemsToRemove.add(selectedValue);                                       
                    }
                }
                command = RemoveCommand.create(editingDomain, owner, structuralFeature, itemsToRemove);
            }
        }
    }
    return command;
}

@Override
protected void searchInputChanged(String key, String searchString) {
    IContentProvider cp = treeViewer.getContentProvider();
    if (cp instanceof TemplatePlanViewContentProvider) {                        
        ((TemplatePlanViewContentProvider) cp).searchInputChanged(key, searchString);           
    }
}

/**
 * Removes filters for the given parent and element
 *
 * @param parent the parent of the element
 * @param element the element
 * @param contentProvider the content provider of the viewer from which
 *  the filters will be removed
 *
 * @return the array of new filter ids
 */
public String[] removeFiltersFor(Object parent, Object element, IContentProvider contentProvider) {
    ArrayList<String> newFilters= new ArrayList<String>();
    for (Iterator<FilterItem> iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
        FilterItem item= iterator.next();
        if (item.enabled) {
            ViewerFilter filter= item.getFilterInstance();
            if (filter != null && isSelected(parent, element, contentProvider, filter))
                newFilters.add(item.id);
        }
    }
    if (fUserDefinedPatternsEnabled && isSelected(parent, element, contentProvider, fPatternFilter))
        newFilters.add(fPatternFilter.getClass().getName());

    return newFilters.toArray(new String[newFilters.size()]);
}

private boolean isSelected(Object parent, Object element, IContentProvider contentProvider, ViewerFilter filter) {
    if (filter instanceof EmptyLibraryContainerFilter) // workaround for https://bugs.eclipse.org/341109
        return true;
    if (contentProvider instanceof ITreeContentProvider) {
        // the element and all its parents have to be selected
        ITreeContentProvider provider = (ITreeContentProvider) contentProvider;
        while (element != null && !(element instanceof IJavaModel)) {
            if (!filter.select(fViewer, parent, element))
                return false;
            element= provider.getParent( element);
        }
        return true;
    }
    return filter.select(fViewer, parent, element);
}

@Override
public void setSelection(ISelection selection, boolean reveal) {
    if (selection instanceof IStructuredSelection) {
        IStructuredSelection sel= (IStructuredSelection) selection;

        //try and give the two a common super class
        IContentProvider provider= getContentProvider();
        if (provider instanceof LogicalPackagesProvider) {
            LogicalPackagesProvider fprovider= (LogicalPackagesProvider) provider;

            Object object= sel.getFirstElement();
            if (object instanceof IPackageFragment) {
                IPackageFragment pkgFragment= (IPackageFragment)object;
                LogicalPackage logicalPkg= fprovider.findLogicalPackage(pkgFragment);
                if (logicalPkg != null)
                    object= logicalPkg;
                else
                    object= pkgFragment;
            }
            if (object != null)
                fViewer.setSelection(new StructuredSelection(object), reveal);
            else
                fViewer.setSelection(StructuredSelection.EMPTY, reveal);
        }
    } else
        fViewer.setSelection(selection, reveal);
}

/**
 * Overrides the createContentProvider from JavaBrowsingPart
 * Creates the content provider of this part.
 */
@Override
protected IContentProvider createContentProvider() {
    if(isInListState())
        return new PackagesViewFlatContentProvider(fWrappedViewer.getViewer());
    else return new PackagesViewHierarchicalContentProvider(fWrappedViewer.getViewer());
}

public void setViewData(IContentProvider contentProvider, ILabelProvider labelProvider, Object inputElement, IAnalyserResult analysis) {
    this.contentProvider = contentProvider;
    this.labelProvider   = labelProvider;
    this.inputElement    = inputElement;
    this.analysis = analysis;

    // First time the view is used
    if ( graph.getContentProvider() == null ) {
        graph.setContentProvider(contentProvider);          
    }
    graph.setInput(inputElement);
    graph.setContentProvider(contentProvider);
    graph.setLabelProvider(labelProvider);
    graph.refresh();
}

public static IContentProvider getContentProviderForMetamodelViewer(Resource metamodelResource) {       
    // From EcoreEditor
    ComposedAdapterFactory adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

    adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
    adapterFactory.addAdapterFactory(new EcoreItemProviderAdapterFactory());
    adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

    return new AdapterFactoryContentProvider(adapterFactory);

}

public void setTransformationMapping(ITransformationMapping tm) {
    this.tm = tm;
    this.mappingViewSupport.setTransformationMapping(tm);

    IContentProvider srcContent = UiUtils.getContentProviderForMetamodelViewer(tm.getInputMetamodel());
    IContentProvider tgtContent = UiUtils.getContentProviderForMetamodelViewer(tm.getInputMetamodel());

    ILabelProvider srcLabel = UiUtils.getLabelProviderForMetamodelViewer(tm.getInputMetamodel());
    ILabelProvider tgtLabel = UiUtils.getLabelProviderForMetamodelViewer(tm.getInputMetamodel());

    mapper.setContentProviders((ITreeContentProvider) srcContent, (ITreeContentProvider) tgtContent);
    mapper.setLabelProviders(srcLabel, tgtLabel);
    mapper.setInput(tm.getInputMetamodel(), tm.getOutputMetamodel(), tm.getMappings());

    IMappingFilter<MetamodelElementMapping> filter = tm.getMappingFilter();
    mapper.setMappingFilter(filter == null ? null : filter);

    mapper.refresh();
}

/** {@inheritDoc} */
@Override
protected ContentOutlinePage createOutlinePage() {
    return new XmlModelEditorOutlinePage(
            (ScalableFreeformRootEditPart) getGraphicalViewer()
                    .getRootEditPart(), rootModel) {
        @Override
        protected IContentProvider createTreeContentProvider() {
            return new CqTreeContentProvider();
        }

        @Override
        protected ILabelProvider createTreeLabelProvider() {
            return new CQLabelProvider();
        }
    };
}

/**
 * Get all root packages which have to be shown in the tree.
 * @param contentProvider content provider for packages
 * @param javaPackages the java packages to find their root packages
 * @return Array with all root packages.
 */
public static List<IPackageFragment> getRootpackages(IContentProvider contentProvider, 
        SortedSet<IPackageFragment> javaPackages) {

    List<IPackageFragment> rootPackages = new ArrayList<IPackageFragment>();
    if (!(contentProvider instanceof PackagesTreeContentProvider)) {
        return rootPackages;
    }
    PackagesTreeContentProvider packagesTreeContentProvider = (PackagesTreeContentProvider) contentProvider;
    for (IPackageFragment javaPackage : javaPackages) {
        if (packagesTreeContentProvider.getParentPackage(javaPackage) == null) {
            rootPackages.add(javaPackage);
        }
    }

    return rootPackages;
}