Java Code Examples for org.eclipse.swt.SWT#UP

public void testSetSortDirection() {
Header header = new Header(shell, SWT.NONE);

assertEquals(SWT.NONE, header.getSortDirection());

int[] values = { SWT.UP, SWT.DOWN, SWT.NONE };
for (int value : values) {
    header.setSortDirection(value);

    assertEquals(value, header.getSortDirection());
}

try {
    header.setSortDirection(-1);
    fail();
} catch (RuntimeException rex) {
    // expected
}
   }
 

@SuppressWarnings({
	"rawtypes", "unchecked"
})
private int compareElements(Object e1, Object e2){
	IColumnContentProvider columnValueProvider =
		(IColumnContentProvider) tableViewer.getContentProvider();
	
	Table table = tableViewer.getTable();
	
	int index = Arrays.asList(table.getColumns()).indexOf(table.getSortColumn());
	int result = 0;
	if (index != -1) {
		Comparable c1 = columnValueProvider.getValue(e1, index);
		Comparable c2 = columnValueProvider.getValue(e2, index);
		if (c1 instanceof String && c2 instanceof String) {
			String _c1 = (String) c1;
			String _c2 = (String) c2;
			result = _c1.compareToIgnoreCase(_c2);
		} else {
			result = c1.compareTo(c2);
		}
	}
	
	return table.getSortDirection() == SWT.UP ? result : -result;
}
 

private boolean canContinue() {
	if (shell == null || shell.isDisposed())
		return false;

	if (shellBounds == null)
		return true;

	//System.out.println((slideIn ? "In" : "Out") + ";" + direction + ";S:" + shellBounds + ";" + endBounds);
	if (slideIn) {
		if (direction == SWT.UP) {
			return shellBounds.y > endBounds.y;
		}
		// TODO: Other directions
	} else {
		if (direction == SWT.RIGHT) {
			// stop early, because some OSes have trim, and won't allow the window
			// to go smaller than it.
			return shellBounds.width > 10;
		}
	}
	return false;
}
 

private int compareElements(Viewer viewer, Object e1, Object e2) {
	TreeViewer treeViewer = (TreeViewer) viewer;
	if (e1 instanceof IAbapGitObject && e2 instanceof IAbapGitObject) {
		IAbapGitObject object1 = (IAbapGitObject) e1;
		IAbapGitObject object2 = (IAbapGitObject) e2;
		//set "non-code and meta files" as the first node
		if (object1.getType() == null) {
			return treeViewer.getTree().getSortDirection() == SWT.UP ? -1 : 1;
		}
		if (object2.getType() == null) {
			return treeViewer.getTree().getSortDirection() == SWT.UP ? 1 : -1;
		}
		int result = object1.getName().compareToIgnoreCase(object2.getName());
		return treeViewer.getTree().getSortDirection() == SWT.UP ? result : -result;
	}
	return 0;
}
 

@Override
public void widgetSelected(SelectionEvent e) {
	Widget parent = getParent(e);
	// 4) Compute the (inverse) sort direction
	sortDirection = sortDirection == SWT.DOWN ? SWT.UP : SWT.DOWN;
	// 5) Modify the sort of the page controller
	super.getController(parent).setSort(sortPropertyName, sortDirection);
	// 6) Modify the SWT Table sort
	sort(e);
}
 

@SuppressWarnings("unchecked")
private int compare(Comparable c1, Comparable c2) {
	if (sortDirection == SWT.UP) {
		return c2.compareTo(c1);
	}
	return c1.compareTo(c2);
}
 

/**
 * Javadoc out of date // TODO: update javadoc
 * @param panel
 * @param style
 */
public VControl(VPanel panel, int style) {
	setParent(panel);

	this.style = style;
	bounds = new Rectangle(0, 0, 0, 0);

	if((style & SWT.OK) != 0) {
		setPolygon(Points_OK);
		setForeground(Display.getDefault().getSystemColor(SWT.COLOR_DARK_GREEN));
	} else if((style & SWT.CANCEL) != 0) {
		setPolygon(Points_Cancel);
		setForeground(Display.getDefault().getSystemColor(SWT.COLOR_DARK_RED));
	} else if((style & SWT.ARROW) != 0) {
		if((style & SWT.DOWN) != 0) {
			setPolygon(Points_Down);
		} else if((style & SWT.LEFT) != 0) {
			setPolygon(Points_Left);
		} else if((style & SWT.RIGHT) != 0) {
			setPolygon(Points_Right);
		} else if((style & SWT.UP) != 0) {
			setPolygon(Points_Up);
		}
	} else if((style & SWT.UP) != 0) {
		setPolygon(Points_Add);
	} else if((style & SWT.DOWN) != 0) {
		setPolygon(Points_Subtract);
	}

	if(foreground == null) {
		setForeground(Display.getDefault().getSystemColor(SWT.COLOR_WIDGET_FOREGROUND));
	}
	if(fill == null) {
		setFill(getForeground());
	}
}
 

public void drawArrowHead(final int x, final int y, final int face, final GC gc) {
    switch (face) {
        case SWT.UP:
            gc.drawLine(x, y + 3, x, y + 3);
            gc.drawLine(x - 1, y + 4, x + 1, y + 4);
            gc.drawLine(x - 2, y + 5, x + 2, y + 5);
            gc.drawLine(x - 3, y + 6, x + 3, y + 6);
            gc.drawLine(x - 4, y + 7, x + 4, y + 7);
            break;
        case SWT.DOWN:
            gc.drawLine(x, y + 7, x, y + 7);
            gc.drawLine(x - 1, y + 6, x + 1, y + 6);
            gc.drawLine(x - 2, y + 5, x + 2, y + 5);
            gc.drawLine(x - 3, y + 4, x + 3, y + 4);
            gc.drawLine(x - 4, y + 3, x + 4, y + 3);
            break;
        case SWT.RIGHT:
            // don't need 1 as a line will be on it
            gc.drawLine(x + 3, y - 4, x + 3, y + 4);
            gc.drawLine(x + 4, y - 3, x + 4, y + 3);
            gc.drawLine(x + 5, y - 2, x + 5, y + 2);
            gc.drawLine(x + 6, y - 1, x + 6, y + 1);
            break;
        case SWT.LEFT:
            // don't need 1 as a line will be on it
            gc.drawLine(x - 3, y - 4, x - 3, y + 4);
            gc.drawLine(x - 4, y - 3, x - 4, y + 3);
            gc.drawLine(x - 5, y - 2, x - 5, y + 2);
            gc.drawLine(x - 6, y - 1, x - 6, y + 1);
            break;
        default:
            break;
    }
}
 

@Override
public void widgetSelected(SelectionEvent e){
	TableColumn sortColumn = tableViewerInvoiceList.getTable().getSortColumn();
	TableColumn selectedColumn = (TableColumn) e.widget;
	int sortDirection = tableViewerInvoiceList.getTable().getSortDirection();
	if (sortColumn == selectedColumn) {
		sortDirection = sortDirection == SWT.UP ? SWT.DOWN : SWT.UP;
	} else {
		tableViewerInvoiceList.getTable().setSortColumn(selectedColumn);
		sortDirection = SWT.UP;
	}
	
	setSortOrder(selectedColumn, sortDirection);
}
 

/**
    * Set the sort direction.
    * 
    * @param direct one of SWT.UP, SWT.DOWN, SWT.NONE 
    * @throws RuntimeException if direction has an invalid value
    * @see #setSortColumn(int);
    */
public void setSortDirection(int direction) {
	if (!(direction == SWT.NONE || direction == SWT.UP || direction == SWT.DOWN)) {
		throw new IllegalArgumentException("direction= " + direction);
	}
	headerTable.setSortDirection(direction);
	sortDirection = direction;
}
 

private int getSortDirection(TableColumn column) {
  Table tableControl = (Table) kindViewer.getControl();
  if (column != tableControl.getSortColumn()) {
    return SWT.DOWN;
  }
  // If it is unsorted (SWT.NONE), assume down sort
  return (SWT.DOWN == tableControl.getSortDirection())
      ? SWT.UP : SWT.DOWN;
}
 

@Override
public int compare(final Viewer viewer, final Object e1, final Object e2) {
	final ActionInformationItem a1 = (ActionInformationItem) e1;
	final ActionInformationItem a2 = (ActionInformationItem) e2;

	final Table table = (Table) viewer.getControl();
	final TableColumn sortColumn = table.getSortColumn();
	if (sortColumn == null) {
		// a) Compare by distinct states first (we want actions with zero distinct states
		// to appear at the top).
		if (Long.compare(a1.getUnseen(), a2.getUnseen()) == 0L) {
			// b) Compare by location
			return a1.getModuleLocation().compareTo(a2.getModuleLocation());
		} else {
			return Long.compare(a1.getUnseen(), a2.getUnseen());
		}
	} else {
		// User requested to sort a specific column up or down.
		@SuppressWarnings("unchecked")
		final Comparator<ActionInformationItem> comp = (Comparator<ActionInformationItem>) sortColumn
				.getData(CoverageLabelProvider.COVERAGE_COMPARATOR);
		if (table.getSortDirection() == SWT.UP) {
			return comp.compare(a2, a1);
		} else {
			return comp.compare(a1, a2);
		}
	}
}
 

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

  ViewerComparator sorter = buildColumnSorter(colIndex);
  if (SWT.UP == direction) {
    sorter = new InverseSorter(sorter);
  }

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

public int compare( Object o1, Object o2 )
{
	ComputedColumnHandle binding1 = (ComputedColumnHandle) o1;
	ComputedColumnHandle binding2 = (ComputedColumnHandle) o2;
	String columnText1 = labelProvider.getColumnText( binding1,
			sortingColumnIndex );
	String columnText2 = labelProvider.getColumnText( binding2,
			sortingColumnIndex );
	int result = ( columnText1 == null ? "" : columnText1 ).compareTo( ( columnText2 == null ? ""
			: columnText2 ) );
	if ( sortDirection == SWT.UP )
		return result;
	else
		return 0 - result;
}
 

public int compare( Viewer viewer, Object e1, Object e2 )
{
	if ( sortDir == SWT.UP )
	{
		if ( e1 instanceof NullValue )
		{
			return -1;
		}
		if ( e2 instanceof NullValue )
		{
			return 1;
		}
		if ( e1 instanceof Integer )
		{
			return ( (Integer) e1 ).compareTo( (Integer) e2 );
		}
		else if ( e1 instanceof Double )
		{
			return ( (Double) e1 ).compareTo( (Double) e2 );
		}
		else if ( e1 instanceof BigDecimal )
		{
			return ( (BigDecimal) e1 ).compareTo( (BigDecimal) e2 );
		}
		else
		{
			return getDataText( e1 ).compareTo( getDataText( e2 ) );
		}
	}
	else if ( sortDir == SWT.DOWN )
	{
		if ( e1 instanceof NullValue )
		{
			return 1;
		}
		if ( e2 instanceof NullValue )
		{
			return -1;
		}
		if ( e2 instanceof Double )
		{
			return ( (Double) e2 ).compareTo( (Double) e1 );
		}
		else if ( e2 instanceof BigDecimal )
		{
			return ( (BigDecimal) e2 ).compareTo( (BigDecimal) e1 );
		}
		else
		{
			return getDataText( e2 ).compareTo( getDataText( e1 ) );
		}
	}
	return 0;
}
 

public int getDirection(){
	return direction == 1 ? SWT.DOWN : SWT.UP;
}
 

public int getDirection() {
  return direction == 1 ? SWT.DOWN : SWT.UP;
}
 

public int getDirection() {
  return direction == 1 ? SWT.DOWN : SWT.UP;
}
 

/**
 * for sort direction
 * 
 * @return SWT.DOWN or SWT.UP
 */
public int getDirection(){
	return direction ? SWT.DOWN : SWT.UP;
}
 

/**
 * for sort direction
 * 
 * @return SWT.DOWN or SWT.UP
 */
public int getDirection(){
	return direction ? SWT.DOWN : SWT.UP;
}