Examples with IStyle org.eclipse.nebula.widgets.nattable.style.IStyle used on opensource projects

Example 51 with IStyle

use of org.eclipse.nebula.widgets.nattable.style.IStyle in project nebula.widgets.nattable by eclipse.

the class GroupByHeaderPainter method paintCell.

@Override
public void paintCell(ILayerCell cell, GC gc, Rectangle bounds, IConfigRegistry configRegistry) {
    Color originalBackground = gc.getBackground();
    Color originalForeground = gc.getForeground();
    Font originalFont = gc.getFont();
    // get color for header background
    Color headerBgColor = configRegistry.getConfigAttribute(GroupByConfigAttributes.GROUP_BY_HEADER_BACKGROUND_COLOR, DisplayMode.NORMAL);
    if (headerBgColor != null) {
        gc.setBackground(headerBgColor);
    }
    // Draw background
    gc.fillRectangle(bounds);
    this.groupByCellBounds.clear();
    IStyle cellStyle = CellStyleUtil.getCellStyle(cell, configRegistry);
    gc.setBackground(cellStyle.getAttributeValue(CellStyleAttributes.BACKGROUND_COLOR));
    gc.setForeground(cellStyle.getAttributeValue(CellStyleAttributes.FOREGROUND_COLOR));
    gc.setFont(cellStyle.getAttributeValue(CellStyleAttributes.FONT));
    gc.setAntialias(GUIHelper.DEFAULT_ANTIALIAS);
    gc.setTextAntialias(GUIHelper.DEFAULT_TEXT_ANTIALIAS);
    List<Integer> groupByColumnIndexes = this.groupByModel.getGroupByColumnIndexes();
    if (groupByColumnIndexes.size() > 0) {
        // $NON-NLS-1$
        int textHeight = gc.textExtent("X").y;
        int x0 = bounds.x + LEFT_INDENT;
        int y0 = bounds.y + bounds.height / 2 - textHeight / 2 - Y_PADDING;
        int y_height = Y_PADDING + textHeight + Y_PADDING;
        // Draw leftmost edge
        gc.drawLine(x0, y0, x0, y0 + y_height);
        x0++;
        // Draw group by columns
        int lastColumnIndex = groupByColumnIndexes.size() - 1;
        for (int i = 0; i <= lastColumnIndex; i++) {
            int columnIndex = groupByColumnIndexes.get(i);
            String columnName = null;
            if (this.columnHeaderLayer != null && this.columnHeaderLayer.isColumnRenamed(columnIndex)) {
                columnName = this.columnHeaderLayer.getRenamedColumnLabelByIndex(columnIndex);
            } else {
                columnName = (String) this.columnHeaderDataProvider.getDataValue(columnIndex, 0);
            }
            int textWidth = gc.textExtent(columnName).x;
            this.groupByCellBounds.add(new Rectangle(x0, y0, X_PADDING + textWidth + X_PADDING, y_height));
            gc.fillRectangle(x0, y0, X_PADDING + textWidth + X_PADDING, y_height);
            gc.drawLine(x0, y0, x0 + X_PADDING + textWidth + X_PADDING, y0);
            gc.drawLine(x0, y0 + y_height, x0 + X_PADDING + textWidth + X_PADDING, y0 + y_height);
            gc.drawText(columnName, x0 + X_PADDING, y0 + Y_PADDING);
            x0 += X_PADDING + textWidth + X_PADDING;
            // Draw end cap
            if (i < lastColumnIndex) {
                gc.fillRectangle(x0, y0, ENDCAP_WIDTH, y_height);
                gc.drawLine(x0, y0, x0 + ENDCAP_WIDTH, y0);
                gc.drawLine(x0, y0 + y_height, x0 + ENDCAP_WIDTH, y0 + y_height);
            } else {
                gc.fillPolygon(new int[] { x0, y0, x0 + ENDCAP_WIDTH, y0 + y_height / 2, x0, y0 + y_height });
            }
            gc.drawLine(x0, y0, x0 + ENDCAP_WIDTH - 1, y0 + y_height / 2);
            gc.drawLine(x0, y0 + y_height, x0 + ENDCAP_WIDTH - 1, y0 + y_height / 2);
            x0 += ENDCAP_WIDTH;
        }
    } else {
        // if no grouping is applied and a hint is specified via
        // configuration, the hint is rendered
        String hint = configRegistry.getConfigAttribute(GroupByConfigAttributes.GROUP_BY_HINT, DisplayMode.NORMAL);
        if (hint != null) {
            // check if there is a separate styling configured for the hint
            IStyle hintStyle = configRegistry.getConfigAttribute(GroupByConfigAttributes.GROUP_BY_HINT_STYLE, DisplayMode.NORMAL);
            if (hintStyle != null) {
                Color hintBackground = hintStyle.getAttributeValue(CellStyleAttributes.BACKGROUND_COLOR);
                gc.setBackground(hintBackground != null ? hintBackground : originalBackground);
                Color hintForeground = hintStyle.getAttributeValue(CellStyleAttributes.FOREGROUND_COLOR);
                if (hintForeground != null) {
                    gc.setForeground(hintForeground);
                }
                Font hintFont = hintStyle.getAttributeValue(CellStyleAttributes.FONT);
                if (hintFont != null) {
                    gc.setFont(hintFont);
                }
            } else {
                // ensure the background is the same as the background of
                // the groupby header region
                gc.setBackground(originalBackground);
            }
            // $NON-NLS-1$
            int textHeight = gc.textExtent("X").y;
            int x0 = bounds.x + LEFT_INDENT;
            int y0 = bounds.y + bounds.height / 2 - textHeight / 2 - Y_PADDING;
            gc.drawText(hint, x0 + X_PADDING, y0);
        }
    }
    gc.setBackground(originalBackground);
    gc.setForeground(originalForeground);
    gc.setFont(originalFont);
}

Example 52 with IStyle

use of org.eclipse.nebula.widgets.nattable.style.IStyle in project tdq-studio-se by Talend.

the class DataSampleTable method setNatTableFont.

/**
 * set the NatTable Font with a fixed size.
 */
public void setNatTableFont(NatTable natTable) {
    // TDQ-9725: we use the fixed font size to make it show well even the user changed the default font size
    IStyle rowHeaderNormalStyle = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_STYLE, DisplayMode.NORMAL, GridRegion.ROW_HEADER);
    if (rowHeaderNormalStyle != null) {
        rowHeaderNormalStyle.setAttributeValue(CellStyleAttributes.FONT, font);
    }
    IStyle columnHeaderNormalStyle = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_STYLE, DisplayMode.NORMAL, GridRegion.COLUMN_HEADER);
    if (columnHeaderNormalStyle != null) {
        columnHeaderNormalStyle.setAttributeValue(CellStyleAttributes.FONT, font);
    }
    IStyle dataNormalStyle = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_STYLE, DisplayMode.NORMAL, GridRegion.DATAGRID);
    if (dataNormalStyle != null) {
        dataNormalStyle.setAttributeValue(CellStyleAttributes.FONT, font);
    }
    IStyle selectionStyle = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_STYLE, DisplayMode.SELECT, GridRegion.ROW_HEADER);
    if (selectionStyle != null) {
        selectionStyle.setAttributeValue(CellStyleAttributes.FONT, font);
    }
}

Example 53 with IStyle

use of org.eclipse.nebula.widgets.nattable.style.IStyle in project nebula.widgets.nattable by eclipse.

the class CrossValidationDialogErrorHandling method configureRegistry.

@Override
public void configureRegistry(IConfigRegistry configRegistry) {
    configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE);
    configRegistry.registerConfigAttribute(CellConfigAttributes.DISPLAY_CONVERTER, new DefaultDateDisplayConverter(), DisplayMode.NORMAL, CrossValidationGridExample.DATE_LABEL);
    configRegistry.registerConfigAttribute(CellConfigAttributes.DISPLAY_CONVERTER, new DefaultDateDisplayConverter(), DisplayMode.EDIT, CrossValidationGridExample.DATE_LABEL);
    // configure the validation error style
    IStyle validationErrorStyle = new Style();
    validationErrorStyle.setAttributeValue(CellStyleAttributes.BACKGROUND_COLOR, GUIHelper.COLOR_RED);
    validationErrorStyle.setAttributeValue(CellStyleAttributes.FOREGROUND_COLOR, GUIHelper.COLOR_WHITE);
    configRegistry.registerConfigAttribute(CellConfigAttributes.CELL_STYLE, validationErrorStyle, DisplayMode.NORMAL, CrossValidationGridExample.INVALID_LABEL);
    configRegistry.registerConfigAttribute(EditConfigAttributes.DATA_VALIDATOR, new EventDataValidator(this.bodyDataProvider), DisplayMode.EDIT, CrossValidationGridExample.DATE_LABEL);
    configRegistry.registerConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_HANDLER, new DialogErrorHandling(true), DisplayMode.EDIT, CrossValidationGridExample.DATE_LABEL);
}

Example 54 with IStyle

use of org.eclipse.nebula.widgets.nattable.style.IStyle in project nebula.widgets.nattable by eclipse.

the class NatTableCSSHandler method retrieveCSSProperty.

@Override
public String retrieveCSSProperty(Object control, String property, String pseudo, CSSEngine engine) throws Exception {
    NatTable natTable = null;
    String label = null;
    String displayMode = NatTableCSSHelper.getDisplayMode(pseudo);
    if (control instanceof NatTable) {
        natTable = (NatTable) control;
    } else if (control instanceof NatTableWrapper) {
        natTable = ((NatTableWrapper) control).getNatTable();
        label = ((NatTableWrapper) control).getLabel();
    }
    if (natTable != null) {
        // check property
        if (NatTableCSSConstants.BACKGROUND_COLOR.equalsIgnoreCase(property)) {
            return CSSPropertyBackgroundSWTHandler.INSTANCE.retrieveCSSPropertyBackgroundColor(control, pseudo, engine);
        } else if (NatTableCSSConstants.BACKGROUND_IMAGE.equalsIgnoreCase(property)) {
            return CSSPropertyBackgroundSWTHandler.INSTANCE.retrieveCSSPropertyBackgroundImage(control, pseudo, engine);
        } else if (NatTableCSSConstants.CELL_BACKGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BACKGROUND_COLOR, displayMode, label), engine, null);
        } else if (NatTableCSSConstants.CELL_BACKGROUND_IMAGE.equalsIgnoreCase(property)) {
            // TODO : manage path of Image.
            return "none";
        } else if (NatTableCSSConstants.FOREGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FOREGROUND_COLOR, displayMode, label), engine, null);
        } else if (NatTableCSSConstants.HORIZONTAL_ALIGNMENT.equalsIgnoreCase(property)) {
            HorizontalAlignmentEnum align = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.HORIZONTAL_ALIGNMENT, displayMode, label);
            switch(align) {
                case CENTER:
                    return "center";
                case LEFT:
                    return "left";
                case RIGHT:
                    return "right";
            }
        } else if (NatTableCSSConstants.VERTICAL_ALIGNMENT.equalsIgnoreCase(property)) {
            VerticalAlignmentEnum align = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.VERTICAL_ALIGNMENT, displayMode, label);
            switch(align) {
                case TOP:
                    return "top";
                case MIDDLE:
                    return "middle";
                case BOTTOM:
                    return "bottom";
            }
        } else if (NatTableCSSConstants.FONT.equalsIgnoreCase(property)) {
            Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);
            return CSSSWTFontHelper.getFontComposite(font);
        } else if (NatTableCSSConstants.FONT_FAMILY.equalsIgnoreCase(property)) {
            Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);
            return CSSSWTFontHelper.getFontFamily(font);
        } else if (NatTableCSSConstants.FONT_SIZE.equalsIgnoreCase(property)) {
            Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);
            return CSSSWTFontHelper.getFontSize(font);
        } else if (NatTableCSSConstants.FONT_STYLE.equalsIgnoreCase(property)) {
            Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);
            return CSSSWTFontHelper.getFontStyle(font);
        } else if (NatTableCSSConstants.FONT_WEIGHT.equalsIgnoreCase(property)) {
            Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);
            return CSSSWTFontHelper.getFontWeight(font);
        } else if (NatTableCSSConstants.IMAGE.equalsIgnoreCase(property)) {
            // TODO : manage path of Image.
            return "none";
        } else if (NatTableCSSConstants.BORDER.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BORDER_STYLE, displayMode, label);
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return border.getThickness() + " " + border.getLineStyle().toString().toLowerCase() + " " + border.getBorderMode().toString().toLowerCase() + " " + cssValueConverter.convert(border.getColor(), engine, null);
        } else if (NatTableCSSConstants.BORDER_COLOR.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BORDER_STYLE, displayMode, label);
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(border.getColor(), engine, null);
        } else if (NatTableCSSConstants.BORDER_STYLE.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BORDER_STYLE, displayMode, label);
            return border.getLineStyle().toString().toLowerCase();
        } else if (NatTableCSSConstants.BORDER_WIDTH.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BORDER_STYLE, displayMode, label);
            return "" + border.getThickness();
        } else if (NatTableCSSConstants.BORDER_MODE.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.BORDER_STYLE, displayMode, label);
            return "" + border.getBorderMode();
        } else if (NatTableCSSConstants.PASSWORD_ECHO_CHAR.equalsIgnoreCase(property)) {
            return "" + NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.PASSWORD_ECHO_CHAR, displayMode, label);
        } else if (NatTableCSSConstants.TEXT_DECORATION.equalsIgnoreCase(property)) {
            TextDecorationEnum decoration = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.TEXT_DECORATION, displayMode, label);
            switch(decoration) {
                case NONE:
                    return "none";
                case STRIKETHROUGH:
                    return "line-through";
                case UNDERLINE:
                    return "underline";
                case UNDERLINE_STRIKETHROUGH:
                    return "underline line-through";
            }
        } else if (NatTableCSSConstants.FREEZE_SEPARATOR_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(natTable.getConfigRegistry().getConfigAttribute(IFreezeConfigAttributes.SEPARATOR_COLOR, displayMode, label), engine, null);
        } else if (NatTableCSSConstants.GRID_LINE_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.GRID_LINE_COLOR, displayMode, label), engine, null);
        } else if (NatTableCSSConstants.GRID_LINE_WIDTH.equalsIgnoreCase(property)) {
            Integer width = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.GRID_LINE_WIDTH, displayMode, label);
            if (width == null) {
                return "0";
            } else {
                return width.toString();
            }
        } else if (NatTableCSSConstants.RENDER_GRID_LINES.equalsIgnoreCase(property)) {
            Boolean render = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.RENDER_GRID_LINES, displayMode, label);
            if (render == null) {
                return Boolean.TRUE.toString();
            } else {
                return render.toString();
            }
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontComposite(font);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_FAMILY.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontFamily(font);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_SIZE.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontSize(font);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_STYLE.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontStyle(font);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_WEIGHT.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontWeight(font);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_BACKGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            return cssValueConverter.convert(style.getAttributeValue(CellStyleAttributes.BACKGROUND_COLOR), engine, null);
        } else if (NatTableCSSConstants.CONVERSION_ERROR_FOREGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.CONVERSION_ERROR_STYLE, displayMode, label);
            return cssValueConverter.convert(style.getAttributeValue(CellStyleAttributes.FOREGROUND_COLOR), engine, null);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontComposite(font);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_FAMILY.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontFamily(font);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_SIZE.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontSize(font);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_STYLE.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontStyle(font);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_WEIGHT.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            Font font = style.getAttributeValue(CellStyleAttributes.FONT);
            return CSSSWTFontHelper.getFontWeight(font);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_BACKGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            return cssValueConverter.convert(style.getAttributeValue(CellStyleAttributes.BACKGROUND_COLOR), engine, null);
        } else if (NatTableCSSConstants.VALIDATION_ERROR_FOREGROUND_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(EditConfigAttributes.VALIDATION_ERROR_STYLE, displayMode, label);
            return cssValueConverter.convert(style.getAttributeValue(CellStyleAttributes.FOREGROUND_COLOR), engine, null);
        } else if (NatTableCSSConstants.WORD_WRAP.equalsIgnoreCase(property)) {
            Boolean wrap = Boolean.FALSE;
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                }
            }
            if (painter instanceof AbstractTextPainter) {
                wrap = ((AbstractTextPainter) painter).isWordWrapping();
            }
            return wrap.toString();
        } else if (NatTableCSSConstants.TEXT_WRAP.equalsIgnoreCase(property)) {
            Boolean wrap = Boolean.FALSE;
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                }
            }
            if (painter instanceof AbstractTextPainter) {
                wrap = ((AbstractTextPainter) painter).isWrapText();
            }
            return wrap.toString();
        } else if (NatTableCSSConstants.TEXT_TRIM.equalsIgnoreCase(property)) {
            Boolean trim = Boolean.FALSE;
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                }
            }
            if (painter instanceof AbstractTextPainter) {
                trim = ((AbstractTextPainter) painter).isTrimText();
            }
            return trim.toString();
        } else if (NatTableCSSConstants.LINE_SPACING.equalsIgnoreCase(property)) {
            int spacing = 0;
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                }
            }
            if (painter instanceof AbstractTextPainter) {
                spacing = ((AbstractTextPainter) painter).getLineSpacing();
            }
            return "" + spacing;
        } else if (NatTableCSSConstants.TEXT_DIRECTION.equalsIgnoreCase(property)) {
            String direction = "horizontal";
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                }
            }
            if (painter instanceof VerticalTextPainter) {
                direction = "vertical";
            }
            return direction;
        } else if (NatTableCSSConstants.COLUMN_WIDTH.equalsIgnoreCase(property)) {
            // inherit is not supported here
            return "default";
        } else if (NatTableCSSConstants.ROW_HEIGHT.equalsIgnoreCase(property)) {
            // inherit is not supported here
            return "default";
        } else if (NatTableCSSConstants.PADDING.equalsIgnoreCase(property)) {
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                    if (painter instanceof PaddingDecorator) {
                        PaddingDecorator decorator = (PaddingDecorator) painter;
                        return new StringBuilder().append(decorator.getTopPadding()).append(" ").append(decorator.getRightPadding()).append(" ").append(decorator.getBottomPadding()).append(" ").append(decorator.getLeftPadding()).toString();
                    }
                }
            }
        } else if (NatTableCSSConstants.PADDING_TOP.equalsIgnoreCase(property)) {
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                    if (painter instanceof PaddingDecorator) {
                        return "" + ((PaddingDecorator) painter).getTopPadding();
                    }
                }
            }
            return "0";
        } else if (NatTableCSSConstants.PADDING_RIGHT.equalsIgnoreCase(property)) {
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                    if (painter instanceof PaddingDecorator) {
                        return "" + ((PaddingDecorator) painter).getRightPadding();
                    }
                }
            }
            return "0";
        } else if (NatTableCSSConstants.PADDING_BOTTOM.equalsIgnoreCase(property)) {
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                    if (painter instanceof PaddingDecorator) {
                        return "" + ((PaddingDecorator) painter).getBottomPadding();
                    }
                }
            }
            return "0";
        } else if (NatTableCSSConstants.PADDING_LEFT.equalsIgnoreCase(property)) {
            ICellPainter painter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_PAINTER, displayMode, label);
            if (painter != null) {
                while (painter instanceof CellPainterWrapper) {
                    painter = ((CellPainterWrapper) painter).getWrappedPainter();
                    if (painter instanceof PaddingDecorator) {
                        return "" + ((PaddingDecorator) painter).getLeftPadding();
                    }
                }
            }
            return "0";
        } else if (NatTableCSSConstants.TABLE_BORDER_COLOR.equalsIgnoreCase(property)) {
            for (Iterator<IOverlayPainter> it = natTable.getOverlayPainters().iterator(); it.hasNext(); ) {
                IOverlayPainter painter = it.next();
                if (painter instanceof NatTableBorderOverlayPainter) {
                    return engine.getCSSValueConverter(String.class).convert(((NatTableBorderOverlayPainter) painter).getBorderColor(), engine, null);
                }
            }
        } else if (NatTableCSSConstants.FILL_HANDLE_BORDER.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, FillHandleConfigAttributes.FILL_HANDLE_BORDER_STYLE, displayMode, label);
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return border.getThickness() + " " + border.getLineStyle().toString().toLowerCase() + " " + border.getBorderMode().toString().toLowerCase() + " " + cssValueConverter.convert(border.getColor(), engine, null);
        } else if (NatTableCSSConstants.FILL_HANDLE_COLOR.equalsIgnoreCase(property)) {
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(natTable.getConfigRegistry().getConfigAttribute(FillHandleConfigAttributes.FILL_HANDLE_COLOR, displayMode, label), engine, null);
        } else if (NatTableCSSConstants.FILL_REGION_BORDER.equalsIgnoreCase(property)) {
            BorderStyle border = NatTableCSSHelper.getNatTableStyle(natTable, FillHandleConfigAttributes.FILL_HANDLE_REGION_BORDER_STYLE, displayMode, label);
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return border.getThickness() + " " + border.getLineStyle().toString().toLowerCase() + " " + border.getBorderMode().toString().toLowerCase() + " " + cssValueConverter.convert(border.getColor(), engine, null);
        } else if (NatTableCSSConstants.INVERT_ICONS.equalsIgnoreCase(property)) {
            // not able to determine it easily here
            return Boolean.FALSE.toString();
        } else if (NatTableCSSConstants.DECORATION.equalsIgnoreCase(property)) {
            // TODO : manage path of Image.
            return "none";
        } else if (NatTableCSSConstants.PERCENTAGE_DECORATOR_COLORS.equalsIgnoreCase(property)) {
            IStyle style = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.CELL_STYLE, displayMode, label);
            Color c1 = style.getAttributeValue(PercentageBarDecorator.PERCENTAGE_BAR_COMPLETE_REGION_START_COLOR);
            Color c2 = style.getAttributeValue(PercentageBarDecorator.PERCENTAGE_BAR_COMPLETE_REGION_END_COLOR);
            Color c3 = style.getAttributeValue(PercentageBarDecorator.PERCENTAGE_BAR_INCOMPLETE_REGION_COLOR);
            ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
            return cssValueConverter.convert(c1, engine, null) + " " + cssValueConverter.convert(c2, engine, null) + " " + cssValueConverter.convert(c3, engine, null);
        } else if (NatTableCSSConstants.CONVERTER.equalsIgnoreCase(property)) {
            IDisplayConverter converter = natTable.getConfigRegistry().getConfigAttribute(CellConfigAttributes.DISPLAY_CONVERTER, displayMode, label);
            return NatTableCSSHelper.getDisplayConverterString(converter);
        }
    }
    return null;
}

Example 55 with IStyle

use of org.eclipse.nebula.widgets.nattable.style.IStyle in project nebula.widgets.nattable by eclipse.

the class NatTableCSSHelper method applyNatTableStyle.

/**
 * Apply a style attribute value for the {@link IStyle} registered for the
 * given styleAttribute.
 *
 * @param natTable
 *            The NatTable to apply the style configuration to.
 * @param styleAttribute
 *            The {@link ConfigAttribute} that points to the {@link IStyle}
 *            that should be configured.
 * @param styleConfig
 *            The style {@link ConfigAttribute} that should be applied.
 * @param value
 *            The value to apply.
 * @param displayMode
 *            The {@link DisplayMode} for which the configuration should be
 *            applied.
 * @param configLabel
 *            The label for which the configuration should be applied.
 */
public static <T> void applyNatTableStyle(NatTable natTable, ConfigAttribute<IStyle> styleAttribute, ConfigAttribute<T> styleConfig, T value, String displayMode, String configLabel) {
    IConfigRegistry configRegistry = natTable.getConfigRegistry();
    // retrieve the style object for the given selector
    IStyle style = configRegistry.getSpecificConfigAttribute(styleAttribute, displayMode, configLabel);
    if (style == null) {
        style = new Style();
        if (configLabel != null) {
            configRegistry.registerConfigAttribute(styleAttribute, style, displayMode, configLabel);
        } else {
            configRegistry.registerConfigAttribute(styleAttribute, style, displayMode);
        }
    }
    // set the value to the style object
    style.setAttributeValue(styleConfig, value);
}