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

/**
 * Constructor.
 * 
 * @param labelProvider
 *            the {@link ILabelProvider} to decorate
 * @param labelDecorator
 *            the {@link ILabelDecorator} adding decoration
 */
public DecoratingColumLabelProvider(ILabelProvider labelProvider, ILabelDecorator labelDecorator) {
    this.labelProvider = labelProvider;
    if (labelProvider instanceof IFontProvider) {
        this.fontProvider = (IFontProvider)labelProvider;
    } else {
        this.fontProvider = null;
    }
    if (labelProvider instanceof IColorProvider) {
        this.colorProvider = (IColorProvider)labelProvider;
    } else {
        this.colorProvider = null;
    }

    this.labelDecorator = labelDecorator;
    if (labelDecorator instanceof CellLabelProvider) {
        this.cellLabelProvider = (CellLabelProvider)labelDecorator;
    } else {
        this.cellLabelProvider = null;
    }
}

public SelectAnyEObjectDialog(Shell parent, ResourceSet resourceSet, ILabelProvider renderer) {
    super(parent, renderer);
    _searchedResourceSet = resourceSet;
    ArrayList<EObject> all = new ArrayList<EObject>();
    EcoreUtil.resolveAll(resourceSet);
    for (Resource r : _searchedResourceSet.getResources())
    {
        for (TreeIterator<EObject> iterator = r.getAllContents(); iterator.hasNext();) {
            EObject o =  iterator.next();
            if(select(o)) all.add(o);
        }
    }

    Object[] elements = all.toArray();
    this.setElements(elements);
}

public static IJavaProject chooseGW4EProject(IJavaProject javaProject) {
    Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
    IJavaProject[] projects = getGW4EProjects();
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
    ElementListSelectionDialog dialog = new ElementListSelectionDialog(shell, labelProvider);
    dialog.setTitle(MessageUtil.getString("projectdialog_title"));
    dialog.setMessage(MessageUtil.getString("projectdialog_message"));
    dialog.setElements(projects);

    if (javaProject != null) {
        dialog.setInitialSelections(new Object[] { javaProject });
    }
    if (dialog.open() == Window.OK) {
        return (IJavaProject) dialog.getFirstResult();
    }
    return null;
}

/**
 * Creates a label provider for the detail section below the list<br>
 * The label provider prints out the name of operation definition and the module the operation is defined in 
 */
private ILabelProvider getDetailLabelProvider()
{
    return new LabelProvider() {
        public String getText(Object element)
        {
            if (element instanceof OpDefNode)
            {
                OpDefNode node = (OpDefNode) element;

                return node.getSource().getName().toString()
                        + ((node.getSource().getOriginallyDefinedInModuleNode() != null) ? " : "
                                + node.getSource().getOriginallyDefinedInModuleNode().getName().toString() : "");
            }
            return super.getText(element);
        }
    };
}

/**
 * Creates label provider for the elements in the list
 */
private ILabelProvider getListLabelProvider()
{
    return new LabelProvider() {
        public String getText(Object element)
        {
            if (element instanceof OpDefNode)
            {
                OpDefNode node = (OpDefNode) element;
                if (node.getSource() == node)
                {
                    return node.getName().toString();
                } else
                {
                    return node.getSource().getName().toString() + " ["
                            + node.getSource().getOriginallyDefinedInModuleNode().getName().toString() + "]";
                }
            }
            return super.getText(element);
        }
    };
}

@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
    // Element passes the filter if the string matcher is undefined or
    // the
    // viewer is not a tree viewer
    if ((stringMatcher == null) || !(viewer instanceof TreeViewer)) {
        return true;
    }
    TreeViewer aTreeViewer = (TreeViewer) viewer;
    // Match the pattern against the label of the given element
    String matchName = ((ILabelProvider) aTreeViewer.getLabelProvider()).getText(element);
    // Element passes the filter if it matches the pattern
    if ((matchName != null) && stringMatcher.match(matchName)) {
        return true;
    }
    // Determine whether the element has children that pass the filter
    return hasUnfilteredChild(aTreeViewer, element);
}

public XtextEObjectSearchDialog(Shell parent, IXtextEObjectSearch searchEngine, ILabelProvider labelProvider) {
    super(parent);
    this.searchEngine = searchEngine;
    this.labelProvider = labelProvider;
    setTitle(Messages.XtextEObjectSearchDialog_TableLabelDialogTitle);
    setMessage(Messages.XtextEObjectSearchDialog_TableLabelSearchControlLabel);
    setAddCancelButton(true);
    // super class needs an IStructuredContentProvider so we register this dummy and 
    // register the lazy one later
    setContentProvider(new IStructuredContentProvider() {
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }

        public void dispose() {
        }

        public Object[] getElements(Object inputElement) {
            return null;
        }
    });
    setLabelProvider(labelProvider);
}

public ProjectSelectionDialog(Shell parentShell, Object input,
        IStructuredContentProvider contentProvider,
        ILabelProvider labelProvider, String message, String unifiedDiff) {
    super(parentShell);
    this.unifiedDiff = unifiedDiff;
    featureController.getFeatures(VariantSyncPlugin.getDefault()
            .getSupportProjectList());
    setTitle(WorkbenchMessages.ListSelection_title);
    inputElement = input;
    projectSelectionDiaglog = this;
    this.projectContentProvider = contentProvider;
    this.featureContentProvider = new FeatureListViewerContentProvider();
    this.projectLabelProvider = labelProvider;
    this.featureLabelProvider = new LabelProvider();
    if (message != null) {
        setMessage(message);
    } else {
        setMessage(WorkbenchMessages.ListSelection_message);
    }
}

public Image getImage(Object element)
{
    List<ILabelProvider> providers = this.getProcessors();
    Image result = null;

    for (ILabelProvider provider : providers)
    {
        result = provider.getImage(element);

        if (result != null)
        {
            break;
        }
    }

    return result;
}

private void setUpBrowseProjectDialog() {
  ILabelProvider projectLabelProvider = new BrowseProjectLabelProvider();

  IJavaProject[] javaProjects = javaProjectHelper.getJavaProjects();

  ElementListSelectionDialog dialog =
      new ElementListSelectionDialog(getControl().getShell(), projectLabelProvider);
  dialog.setMessage("Choose a project to run testability on:");

  if (javaProjects != null) {
    dialog.setElements(javaProjects);
  }

  if (dialog.open() == Window.OK) {
    IJavaProject project = (IJavaProject) dialog.getFirstResult();
    projectText.setText(project.getElementName());
    setTabDirty();
  }
}

@Override
public int compare(Viewer viewer, Object e1, Object e2) {
    ILabelProvider lprov = (ILabelProvider) ((ContentViewer) viewer).getLabelProvider();
    String name1 = lprov.getText(e1);
    String name2 = lprov.getText(e2);
    if (name1 == null) {
        name1 = "";
    }
    if (name2 == null) {
        name2 = "";
    }
    if (name1.length() > 0 && name2.length() > 0) {
        char char1 = name1.charAt(name1.length() - 1);
        char char2 = name2.charAt(name2.length() - 1);
        if (char1 == '*' && char1 != char2) {
            return -1;
        }
        if (char2 == '*' && char2 != char1) {
            return 1;
        }
    }
    return name1.compareTo(name2);
}

/**
 * @param adapter Can be <code>null</code>.
 */
public TreeListDialogField(ITreeListAdapter adapter, String[] buttonLabels,
        ILabelProvider lprovider) {
    super();
    fTreeAdapter = adapter;

    fLabelProvider = lprovider;
    fTreeViewerAdapter = new TreeViewerAdapter();

    fElements = new ArrayList(10);

    fButtonLabels = buttonLabels;
    if (fButtonLabels != null) {
        int nButtons = fButtonLabels.length;
        fButtonsEnabled = new boolean[nButtons];
        for (int i = 0; i < nButtons; i++) {
            fButtonsEnabled[i] = true;
        }
    }

    fRemoveButtonIndex = -1;
    fUpButtonIndex = -1;
    fDownButtonIndex = -1;
}

public boolean select(Viewer viewer, Object parentElement,
        Object element) {

    if (pattern == null || !(viewer instanceof TableViewer)) {
        return true;
    }
    TableViewer tableViewer = (TableViewer) viewer;

    String matchName = ((ILabelProvider) tableViewer.getLabelProvider())
            .getText(element);

    if(matchName == null) {
        return false;
    }
    // A dirty editor's label will start with dirty prefix, this prefix
    // should not be taken in consideration when matching with a pattern
    String prefix = PartTab.DIRTY_PREFIX;
    if (matchName.startsWith(prefix)) {
        matchName = matchName.substring(prefix.length());
    }
    return matchName != null && matches(pattern, matchName);
}

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

/**
 * Create a selection dialog displaying all available methods with @main
 * from elements in 'aspects' weaving 'modelElem'.
 * If 'modelElem' is null, selection dialog displays all @main.
 */
public SelectMainMethodDialog(Set<Class<?>> aspects, EObject modelElem, ILabelProvider renderer) {
    super(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), renderer);
    _aspects = aspects;

    if(aspects != null)
        update(modelElem);
}

@Override
public ILabelProvider getLabelProvider() {
       if (isLabelProviderSet()) {
        return super.getLabelProvider();
    }

       return new LabelProvider() {
        @Override
        public String getText(Object element) {
            return getInfo();
        }

       };
}

public ModelCellEditor(Composite      parent,
                       FieldValue     value,
                       ILabelProvider labelProv) {
    super();
    this.fvalue     = value;
    this.labelProv = labelProv;
    create(parent);
}

private void createTestContainerSelectionGroup (Composite parent) {
    Label fTestLabel = new Label(parent, SWT.NONE);
    GridData gd = new GridData( );
    gd.horizontalAlignment = SWT.RIGHT;
    gd.horizontalIndent = 25;
    gd.verticalAlignment=SWT.TOP;
    fTestLabel.setLayoutData(gd);
    fTestLabel.setText(MessageUtil.getString("mainTestExecutionContext"));

    fMainTestExecutionComboViewer = new ComboViewer(parent,SWT.DROP_DOWN);
    Combo combo = fMainTestExecutionComboViewer.getCombo();
    combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    fMainTestExecutionComboViewer.setContentProvider(new   IStructuredContentProvider(){
        @Override
        public Object[] getElements(Object inputElement) {
            String projectName= (String) inputElement;
            loadMainExecutionContextTests(projectName);
            return mainExecutionContexts;
        }
    });
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_QUALIFIED);
    fMainTestExecutionComboViewer.setLabelProvider(labelProvider);
    fMainTestExecutionComboViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
                fAdditionalTestViewer.setInput(null);
                IStructuredSelection selection = (IStructuredSelection) event.getSelection();
                if (selection.size() > 0){
                      resetDoHint();
                      IType type =  (IType) selection.getFirstElement();
                      fAdditionalTestViewer.setInput(type);
                      validatePage();
                }
        }
    });
    combo.setData(GW4E_LAUNCH_CONFIGURATION_CONTROL_ID,GW4E_LAUNCH_TEST_CONFIGURATION_MAIN_TEST);
}

/**
 * Initializes decorator for given EcoreEditor.
 */
private void initDecoratingLabelProvider(EcoreEditor eEditor) {
  TreeViewer treeViewer = (TreeViewer) eEditor.getViewer();
  ILabelProvider labelProvider = (ILabelProvider) treeViewer.getLabelProvider();

  if (labelProvider instanceof DecoratingLabelProvider) {
    return;
  } else {
    ILabelDecorator decorator =
        window.getWorkbench().getDecoratorManager().getLabelDecorator();
    treeViewer.setLabelProvider(new DecoratingLabelProvider(labelProvider, decorator));
  }
}

protected String getLabel(Object element) {
    if (hasConfiguration(AttributeControlConfigurations.LABEL_PROVIDER)) {
        ILabelProvider labelProvider = getConfiguration(AttributeControlConfigurations.LABEL_PROVIDER, ILabelProvider.class);
        if (labelProvider != null) {
            return labelProvider.getText(element);
        }
    }
    return element.toString();
}

protected String[] getValuesAsString(T[] values) {  

    ILabelProvider labelProvider = getConfiguration(AttributeControlConfigurations.LABEL_PROVIDER, ILabelProvider.class);
    String[] valuesAsString = new String[values.length];
    for (int i = 0; i < valuesAsString.length; i++) {
        T val = values[i];
        valuesAsString[i] = labelProvider.getText(val);
    }

    return valuesAsString;
}

protected ILabelProvider getBaseAttributeLabelProvider() {
    return new LabelProvider() {
        @Override
        public String getText(Object element) {
            return ((AvroAttribute<?>)element).getName();
        } 
    };
}

protected ILabelProvider getStringListAttributeLabelProvider(final String actionLabel) {
    return new LabelProvider() {
        @Override
        public String getText(Object element) {
            if (ACTION_LABEL.equals(element)) {
                return actionLabel;
            }
            return ((AvroAttribute<?>)element).getName();
        } 
    };
}

@Override
protected String getNewInputObject() {
    final String[] currentItems = this.list.getItems();
    final IProject[] allProjects = ResourcesPlugin.getWorkspace().getRoot().getProjects();

    final ILabelProvider labelProvider = new LabelProvider() {
        @Override
        public String getText(final Object element) {
            return (String) element;
        }
    };
    final SimpleListContentProvider contentsProvider = new SimpleListContentProvider();
    contentsProvider.setElements(this.sortedDifference(allProjects, currentItems));

    final ListSelectionDialog dialog = new ListSelectionDialog(this.getShell(), this, contentsProvider, labelProvider, PROJECT_SELECTION_LABEL);
    if (dialog.open() != 0) {
        return null;
    }
    final Object[] result = dialog.getResult();

    final int currentItemsLength = currentItems.length;
    final int resultLength = result.length;
    final String[] newItems = new String[currentItemsLength + resultLength];

    System.arraycopy(currentItems, 0, newItems, 0, currentItemsLength);
    System.arraycopy(result, 0, newItems, currentItemsLength, result.length);

    this.list.setItems(newItems);
    return null;
}

public void dispose() {
    super.dispose();

    ILabelDecorator labelDecorator = getLabelDecorator();
    if (labelDecorator != null) {
        labelDecorator.dispose();
    }

    ILabelProvider labelProvider = getLabelProvider();
    if (labelProvider != null) {
        labelProvider.dispose();
    }
}

public void dispose() {
    super.dispose();

    ILabelDecorator labelDecorator = getLabelDecorator();
    if (labelDecorator != null) {
        labelDecorator.dispose();
    }

    ILabelProvider labelProvider = getLabelProvider();
    if (labelProvider != null) {
        labelProvider.dispose();
    }
}

public void dispose() {
    super.dispose();

    ILabelDecorator labelDecorator = getLabelDecorator();
    if (labelDecorator != null) {
        labelDecorator.dispose();
    }

    ILabelProvider labelProvider = getLabelProvider();
    if (labelProvider != null) {
        labelProvider.dispose();
    }
}

/**
 * Get the label from the given eObject's {@link IResourceServiceProvider}.
 *
 * @param eObject
 *          the target object
 * @return the label for the given eObject
 */
private String getForeignObjectLabel(final EObject eObject) {
  IResourceServiceProvider serviceProvider = ((XtextResource) eObject.eResource()).getResourceServiceProvider();
  ILabelProvider labelProvider = serviceProvider.get(ILabelProvider.class);
  if (labelProvider != null) {
    return labelProvider.getText(eObject);
  }
  return null;
}

/**
 * Creates a new instance of the class.
 *
 * @param provider
 *            the label provider for all items, not <code>null</code>
 * @param selectionDecorator
 *            the decorator for selected items, can be <code>null</code>
 */
public ItemsListLabelProvider(ILabelProvider provider,
        ILabelDecorator selectionDecorator) {
    Assert.isNotNull(provider);
    this.provider = provider;
    this.selectionDecorator = selectionDecorator;

    setOwnerDrawEnabled(showColoredLabels() && provider instanceof IStyledLabelProvider);

    provider.addListener(this);

    if (selectionDecorator != null) {
        selectionDecorator.addListener(this);
    }
}

/**
 * Sets new label provider.
 *
 * @param newProvider
 *            new label provider for items in the list, not
 *            <code>null</code>
 */
public void setProvider(ILabelProvider newProvider) {
    Assert.isNotNull(newProvider);
    provider.removeListener(this);
    provider.dispose();

    provider = newProvider;

    if (provider != null) {
        provider.addListener(this);
    }

    setOwnerDrawEnabled(showColoredLabels() && provider instanceof IStyledLabelProvider);
}