org.eclipse.jface.viewers.ITableLabelProvider Java Examples

protected void doUpdateCell(int index, CContainerCell cell, Object element, String[] properties) {
	super.doUpdateCell(index, cell, element, properties);
	
	IBaseLabelProvider prov = (IBaseLabelProvider) getLabelProvider();
	if(prov != null) {
		CTableTreeCell cttc = (CTableTreeCell) cell;
		String text = null;
		if(prov instanceof ICContainerLabelProvider) {
			cttc.setImages(((ICContainerLabelProvider) prov).getColumnImages(element, index));
			text = ((ITableLabelProvider) prov).getColumnText(element, index);
		} else if(prov instanceof ITableLabelProvider) {
			cttc.setImage(((ITableLabelProvider) prov).getColumnImage(element, index));
			text = ((ITableLabelProvider) prov).getColumnText(element, index);
		} else if(prov instanceof ILabelProvider) {
			cttc.setImage(((ILabelProvider) prov).getImage(element));
			text = ((ILabelProvider) prov).getText(element);
		}
		if(text == null) text = ""; //$NON-NLS-1$
		cttc.setText(text);
	}
}
 

/**
 * Get the child entry of this entry with the given name
 *
 * @param name
 *            the name of the entry
 *
 * @return the child entry
 */
public SWTBotTimeGraphEntry getEntry(String name) {
    AtomicReference<ITimeGraphEntry> found = new AtomicReference<>();
    SWTBotUtils.waitUntil(timegraph -> {
        List<ITimeGraphEntry> entries = syncExec(new ListResult<ITimeGraphEntry>() {
            @Override
            public List<ITimeGraphEntry> run() {
                return Arrays.asList(timegraph.getExpandedElements());
            }
        });
        ITableLabelProvider labelProvider = timegraph.getLabelProvider();
        for (ITimeGraphEntry entry : entries) {
            if (fEntry.equals(entry.getParent())) {
                String label = labelProvider == null ? entry.getName() : labelProvider.getColumnText(entry, 0);
                if (name.equals(label)) {
                    found.set(entry);
                    return true;
                }
            }
        }
        return false;
    }, widget, () -> "Timed out waiting for time graph entry " + name);
    return new SWTBotTimeGraphEntry(widget, found.get());
}
 

private ViewerComparator buildColumnSorter(int colIndex) {
  if (INDEX_VISIBLE == colIndex) {
    return new BooleanVisibleSorter();
  }
  if (INDEX_XPOS == colIndex) {
    return new PositionSorter(true);
  }
  if (INDEX_YPOS == colIndex) {
    return new PositionSorter(false);
  }

  // By default, use an alphabetic sort over the column labels.
  ITableLabelProvider labelProvider =
      (ITableLabelProvider) propViewer.getLabelProvider();
  ViewerComparator result = new AlphabeticSorter(
      new LabelProviderToString(labelProvider, colIndex));
  return result;
}
 

@Override
protected boolean isLeafMatch(Viewer viewer, Object element) {
    Object node = element;
    StructuredViewer structuredViewer = (StructuredViewer) viewer;
    ITableLabelProvider labelProvider = (ITableLabelProvider) structuredViewer.getLabelProvider();
    ITreeContentProvider treeContentProvider = (ITreeContentProvider) structuredViewer.getContentProvider();

    // Ensure the tree element and its parent(s) match the filter text
    for (Predicate<String> p : fPredicates) {
        // Retrieve tree element text and make verification. Text is at column 0
        String labelText = labelProvider.getColumnText(node, 0);
        if (labelText == null || !p.test(labelText)) {
            return false;
        }

        // Retrieve parent element
        node = treeContentProvider.getParent(node);
    }
    return true;
}
 

private void setSortColumn(
    TableColumn column, int colIndex, int direction) {

  ITableLabelProvider labelProvider =
      (ITableLabelProvider) kindViewer.getLabelProvider();
  ViewerComparator sorter = new AlphabeticSorter(
      new LabelProviderToString(labelProvider, colIndex));
  if (SWT.UP == direction) {
    sorter = new InverseSorter(sorter);
  }

  Table tableControl = (Table) kindViewer.getControl();
  kindViewer.setComparator(sorter);
  tableControl.setSortColumn(column);
  tableControl.setSortDirection(direction);
}
 

private ViewerComparator buildColumnSorter(int columnIndex) {
  switch (columnIndex) {
  case INDEX_ROOT:
    return new RootSorter();
  case INDEX_RANK:
    return new RankSorter();
  case INDEX_PREDS:
    return new PredecessorCountSorter();
  case INDEX_SUCCS:
    return new SuccessorCountSorter();
  }

  // By default, use an alphabetic sort over the column labels.
  ITableLabelProvider labelProvider =
      (ITableLabelProvider) propViewer.getLabelProvider();
  ViewerComparator result = new AlphabeticSorter(
      new LabelProviderToString(labelProvider, columnIndex));
  return result;
}
 

@SuppressWarnings("unchecked")
private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	// if (columnNumber == CATEGORY_COLUMN) {
	// return sortUser(a, b);
	// }
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	// if (columnNumber == CATEGORY_COLUMN) {
	// return sortUser(a, b);
	// }
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

private ViewerComparator buildColumnSorter(int colIndex) {
  if (INDEX_VISIBLE == colIndex) {
    return new BooleanViewSorter();
  }

  // By default, use an alphabetic sort over the column labels.
  ITableLabelProvider labelProvider =
      (ITableLabelProvider) relSetViewer.getLabelProvider();
  ViewerComparator result = new AlphabeticSorter(
      new LabelProviderToString(labelProvider, colIndex));
  return result;
}
 

private ViewerComparator buildColumnSorter(int colIndex) {

    // By default, use an alphabetic sort over the column labels.
    ITableLabelProvider labelProvider =
        (ITableLabelProvider) propViewer.getLabelProvider();
    ViewerComparator result = new AlphabeticSorter(
        new LabelProviderToString(labelProvider, colIndex));
    return result;
  }
 

private ViewerComparator buildColumnSorter(int colIndex) {

    // By default, use an alphabetic sort over the column labels.
    ITableLabelProvider labelProvider =
        (ITableLabelProvider) propViewer.getLabelProvider();
    ViewerComparator result = new AlphabeticSorter(
        new LabelProviderToString(labelProvider, colIndex));
    return result;
  }
 

private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	// if (columnNumber == CATEGORY_COLUMN) {
	// return sortUser(a, b);
	// }
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

@SuppressWarnings("unchecked")
private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

/**
 * Overwrite this compare method if text comparison isn't what you need
 * @param TableViewer
 * @param e1
 * @param e2
 * @return
 */
protected int doCompare(Viewer TableViewer, Object e1, Object e2) {
	ITableLabelProvider lp = ((ITableLabelProvider) viewer
        .getLabelProvider());
        String t1 = lp.getColumnText(e1, index);
        String t2 = lp.getColumnText(e2, index);
        return t1.compareTo(t2);
}
 

public static <T> void sortByDouble(ColumnViewer viewer, ITableLabelProvider labelProvider, int... cols) {
	for (int col : cols) {
		LabelComparator<T> s = new LabelComparator<>(col, labelProvider);
		s.asNumbers = true;
		addComparator(viewer, s);
	}
}
 

public static <T> void sortByLabels(ColumnViewer viewer,
		ITableLabelProvider label) {
	if (viewer == null || label == null)
		return;
	Object[] props = viewer.getColumnProperties();
	if (props == null)
		return;
	for (int col = 0; col < props.length; col++) {
		LabelComparator<T> s = new LabelComparator<>(col, label);
		addComparator(viewer, s);
	}
}
 

/**
 * Sets the tree label provider used for the name space
 *
 * @param labelProvider the tree label provider
 * @since 2.3
 */
public void setTimeGraphLabelProvider(ITableLabelProvider labelProvider) {
    fLabelProvider = labelProvider;
    if (fTimeGraphCtrl != null) {
        fTimeGraphCtrl.setLabelProvider(labelProvider);
    }
}
 

public static <T> void sortByLabels(ColumnViewer viewer,
		ITableLabelProvider labelProvider, int... cols) {
	for (int col : cols) {
		LabelComparator<T> s = new LabelComparator<>(col, labelProvider);
		addComparator(viewer, s);
	}
}
 

/**
 * Get the time graph entry at the specified path relative to the root.
 *
 * @param names
 *            the path of names
 * @return the time graph entry
 * @throws WidgetNotFoundException
 *             if the entry was not found.
 */
public SWTBotTimeGraphEntry getEntry(String... names) throws WidgetNotFoundException {
    AtomicReference<ITimeGraphEntry> parent = new AtomicReference<>();
    AtomicReference<String> missing = new AtomicReference<>();
    SWTBotUtils.waitUntil(timegraph -> {
        List<ITimeGraphEntry> entries = syncExec(new ListResult<ITimeGraphEntry>() {
            @Override
            public List<ITimeGraphEntry> run() {
                return Arrays.asList(timegraph.getExpandedElements());
            }
        });
        ITableLabelProvider labelProvider = timegraph.getLabelProvider();
        parent.set(null);
        for (String name : names) {
            boolean found = false;
            for (ITimeGraphEntry entry : entries) {
                String label = labelProvider == null ? entry.getName() : labelProvider.getColumnText(entry, 0);
                if (Objects.equals(entry.getParent(), parent.get()) && name.equals(label)) {
                    parent.set(entry);
                    found = true;
                    break;
                }
            }
            if (!found) {
                missing.set(name);
                return false;
            }
        }
        return true;
    }, widget, () -> "Timed out waiting for time graph entry " + missing.get() + " of parent " + parent.get());
    return new SWTBotTimeGraphEntry(widget, parent.get());
}
 

@Override
public int compare(Viewer viewer, Object e1, Object e2) {

	if (viewer instanceof TableViewer) {
		IBaseLabelProvider baseLabel = ((TableViewer) viewer).getLabelProvider();

		String left = ((ITableLabelProvider) baseLabel).getColumnText(e1, fSortColumn);
		String right = ((ITableLabelProvider) baseLabel).getColumnText(e2, fSortColumn);
		int sortResult = getComparator().compare(left != null ? left : "", right != null ? right : ""); //$NON-NLS-1$ //$NON-NLS-2$
		return sortResult * fSortOrder;
	}

	return super.compare(viewer, e1, e2);
}
 

@Override
public int compare(Viewer viewer, Object e1, Object e2) {

	if (viewer instanceof TableViewer) {
		IBaseLabelProvider baseLabel = ((TableViewer) viewer).getLabelProvider();

		String left = ((ITableLabelProvider) baseLabel).getColumnText(e1, fSortColumn);
		String right = ((ITableLabelProvider) baseLabel).getColumnText(e2, fSortColumn);
		int sortResult = getComparator().compare(left != null ? left : "", right != null ? right : "");
		return sortResult * fSortOrder;
	}

	return super.compare(viewer, e1, e2);
}
 

public int compare( Viewer viewer, Object e1, Object e2 )
{
	String name1;
	String name2;

	if ( viewer == null || !( viewer instanceof ContentViewer ) )
	{
		if ( descent )
		{
			name1 = e2.toString( );
			name2 = e1.toString( );
		}
		else
		{
			name1 = e1.toString( );
			name2 = e2.toString( );
		}
	}
	else
	{
		IBaseLabelProvider prov = ( (ContentViewer) viewer ).getLabelProvider( );
		if ( prov instanceof ITableLabelProvider )
		{
			ITableLabelProvider lprov = (ITableLabelProvider) prov;
			if ( second )
			{
				if ( descent )
				{
					name1 = lprov.getColumnText( e2, 1 );
					name2 = lprov.getColumnText( e1, 1 );
				}
				else
				{
					name1 = lprov.getColumnText( e1, 1 );
					name2 = lprov.getColumnText( e2, 1 );
				}
			}
			else
			{
				if ( descent )
				{
					name1 = lprov.getColumnText( e2, 0 );
					name2 = lprov.getColumnText( e1, 0 );
				}
				else
				{
					name1 = lprov.getColumnText( e1, 0 );
					name2 = lprov.getColumnText( e2, 0 );
				}
			}
		}
		else
		{
			if ( descent )
			{
				name1 = e2.toString( );
				name2 = e1.toString( );
			}
			else
			{
				name1 = e1.toString( );
				name2 = e2.toString( );
			}
		}
	}
	if ( name1 == null )
	{
		name1 = ""; //$NON-NLS-1$
	}
	if ( name2 == null )
	{
		name2 = ""; //$NON-NLS-1$
	}

	return collator.compare( name1, name2 );
}
 

/**
 * @param provider
 * @param decorator
 */
public TableDecoratingLabelProvider(ILabelProvider provider, ILabelDecorator decorator){
	super(provider, decorator);
	this.provider = (ITableLabelProvider) provider;
	this.decorator = decorator;
}
 

LabelComparator(int column, ITableLabelProvider labelProvider) {
	super(column);
	this.provider = labelProvider;
}
 

private void createSeparateViewer(Composite composite) {
	fSeparateViewer= CheckboxTableViewer.newCheckList(composite, SWT.SINGLE | SWT.BORDER);
	Table table= fSeparateViewer.getTable();
	table.setHeaderVisible(false);
	table.setLinesVisible(false);
	table.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, true, false, 1, 1));

	TableColumn nameColumn= new TableColumn(table, SWT.NONE);
	nameColumn.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_category_column_title);
	nameColumn.setResizable(false);

	fSeparateViewer.setContentProvider(new ArrayContentProvider());

	ITableLabelProvider labelProvider= new SeparateTableLabelProvider();
	fSeparateViewer.setLabelProvider(labelProvider);
	fSeparateViewer.setInput(fModel.elements);

	final int ICON_AND_CHECKBOX_WITH= 50;
	final int HEADER_MARGIN= 20;
	int minNameWidth= computeWidth(table, nameColumn.getText()) + HEADER_MARGIN;
	for (int i= 0; i < fModel.elements.size(); i++) {
		minNameWidth= Math.max(minNameWidth, computeWidth(table, labelProvider.getColumnText(fModel.elements.get(i), 0)) + ICON_AND_CHECKBOX_WITH);
	}

	nameColumn.setWidth(minNameWidth);

	fSeparateViewer.addCheckStateListener(new ICheckStateListener() {
		public void checkStateChanged(CheckStateChangedEvent event) {
			boolean checked= event.getChecked();
			ModelElement element= (ModelElement) event.getElement();
			element.setSeparateCommand(checked);
		}
	});

	table.addSelectionListener(new SelectionAdapter() {
		@Override
		public void widgetSelected(SelectionEvent e) {
			handleTableSelection();
		}
	});

}
 

public TableDecoratingLabelProvider(ILabelProvider provider, ILabelDecorator decorator) {
	super(provider, decorator);
	this.provider = (ITableLabelProvider) provider;
    this.decorator = decorator;
}
 

public TableDecoratingLabelProvider(ILabelProvider provider, ILabelDecorator decorator) {
	super(provider, decorator);
	this.provider = (ITableLabelProvider) provider;
    this.decorator = decorator;
}
 

public TableDecoratingLabelProvider(ILabelProvider provider, ILabelDecorator decorator) {
	super(provider, decorator);
	this.provider = (ITableLabelProvider) provider;
    this.decorator = decorator;
}
 

public ITableLabelProvider getLabelProvider() {
  return (ITableLabelProvider) getTreeViewer().getLabelProvider();
}