/*****************************************************************************
 * Copyright (c) 2015, 2020 CEA LIST and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *		Dirk Fauth <dirk.fauth@googlemail.com> - Initial API and implementation
 *
 *****************************************************************************/
package org.eclipse.nebula.widgets.nattable.extension.e4.css;

import java.net.URI;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.e4.ui.css.core.css2.CSS2FontPropertiesHelpers;
import org.eclipse.e4.ui.css.core.dom.CSSStylableElement;
import org.eclipse.e4.ui.css.core.dom.properties.Gradient;
import org.eclipse.e4.ui.css.core.dom.properties.ICSSPropertyHandler;
import org.eclipse.e4.ui.css.core.dom.properties.ICSSPropertyHandler2;
import org.eclipse.e4.ui.css.core.dom.properties.converters.ICSSValueConverter;
import org.eclipse.e4.ui.css.core.dom.properties.css2.CSS2FontProperties;
import org.eclipse.e4.ui.css.core.engine.CSSElementContext;
import org.eclipse.e4.ui.css.core.engine.CSSEngine;
import org.eclipse.e4.ui.css.core.util.resources.IResourcesLocatorManager;
import org.eclipse.e4.ui.css.swt.helpers.CSSSWTFontHelper;
import org.eclipse.e4.ui.css.swt.properties.converters.CSSValueSWTGradientConverterImpl;
import org.eclipse.e4.ui.css.swt.properties.css2.CSSPropertyBackgroundSWTHandler;
import org.eclipse.nebula.widgets.nattable.NatTable;
import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
import org.eclipse.nebula.widgets.nattable.data.convert.IDisplayConverter;
import org.eclipse.nebula.widgets.nattable.edit.EditConfigAttributes;
import org.eclipse.nebula.widgets.nattable.extension.e4.painterfactory.CellPainterFactory;
import org.eclipse.nebula.widgets.nattable.fillhandle.config.FillHandleConfigAttributes;
import org.eclipse.nebula.widgets.nattable.freeze.FreezeConfigAttributes;
import org.eclipse.nebula.widgets.nattable.hideshow.indicator.HideIndicatorConfigAttributes;
import org.eclipse.nebula.widgets.nattable.painter.IOverlayPainter;
import org.eclipse.nebula.widgets.nattable.painter.NatTableBorderOverlayPainter;
import org.eclipse.nebula.widgets.nattable.painter.cell.AbstractTextPainter;
import org.eclipse.nebula.widgets.nattable.painter.cell.CellPainterWrapper;
import org.eclipse.nebula.widgets.nattable.painter.cell.ICellPainter;
import org.eclipse.nebula.widgets.nattable.painter.cell.VerticalTextPainter;
import org.eclipse.nebula.widgets.nattable.painter.cell.decorator.PaddingDecorator;
import org.eclipse.nebula.widgets.nattable.painter.cell.decorator.PercentageBarDecorator;
import org.eclipse.nebula.widgets.nattable.resize.command.ColumnSizeConfigurationCommand;
import org.eclipse.nebula.widgets.nattable.resize.command.RowSizeConfigurationCommand;
import org.eclipse.nebula.widgets.nattable.style.BorderStyle;
import org.eclipse.nebula.widgets.nattable.style.BorderStyle.BorderModeEnum;
import org.eclipse.nebula.widgets.nattable.style.BorderStyle.LineStyleEnum;
import org.eclipse.nebula.widgets.nattable.style.CellStyleAttributes;
import org.eclipse.nebula.widgets.nattable.style.ConfigAttribute;
import org.eclipse.nebula.widgets.nattable.style.HorizontalAlignmentEnum;
import org.eclipse.nebula.widgets.nattable.style.IStyle;
import org.eclipse.nebula.widgets.nattable.style.TextDecorationEnum;
import org.eclipse.nebula.widgets.nattable.style.VerticalAlignmentEnum;
import org.eclipse.nebula.widgets.nattable.tree.config.TreeConfigAttributes;
import org.eclipse.nebula.widgets.nattable.ui.util.CellEdgeEnum;
import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Image;
import org.w3c.dom.css.CSSPrimitiveValue;
import org.w3c.dom.css.CSSValue;
import org.w3c.dom.css.CSSValueList;

@SuppressWarnings("restriction")
public class NatTableCSSHandler implements ICSSPropertyHandler, ICSSPropertyHandler2 {

    @Override
    public boolean applyCSSProperty(Object element, String property, CSSValue value, String pseudo, CSSEngine engine)
            throws Exception {

        Object control = null;

        if (element instanceof CSSStylableElement) {
            CSSStylableElement elt = (CSSStylableElement) element;
            control = elt.getNativeWidget();
        }

        NatTable natTable = null;
        String label = null;
        String displayMode = NatTableCSSHelper.getDisplayMode(pseudo);

        CSSElementContext context = null;
        CSSElementContext natTableContext = null;

        if (control instanceof NatTable) {
            natTable = (NatTable) control;
        } else if (control instanceof NatTableWrapper) {
            natTable = ((NatTableWrapper) control).getNatTable();
            label = ((NatTableWrapper) control).getLabel();
            natTableContext = engine.getCSSElementContext(natTable);
        }

        if (natTable != null) {
            context = engine.getCSSElementContext(control);
            boolean resolvePainter = NatTableCSSHelper.resolvePainter(context, natTableContext, displayMode);

            // check property
            if (NatTableCSSConstants.PAINTER_RESOLUTION.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storeContextValue(
                        context,
                        displayMode,
                        NatTableCSSConstants.PAINTER_RESOLUTION,
                        NatTableCSSHelper.getBoolean(value, true));
            } else if (NatTableCSSConstants.PAINTER.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storeContextValue(
                        context,
                        displayMode,
                        NatTableCSSConstants.PAINTER,
                        NatTableCSSHelper.resolvePainterRepresentation(value));
            } else if (NatTableCSSConstants.BACKGROUND_COLOR.equalsIgnoreCase(property)) {
                CSSPropertyBackgroundSWTHandler.INSTANCE.applyCSSPropertyBackgroundColor(element, value, pseudo, engine);
            } else if (NatTableCSSConstants.BACKGROUND_IMAGE.equalsIgnoreCase(property)) {
                CSSPropertyBackgroundSWTHandler.INSTANCE.applyCSSPropertyBackgroundImage(element, value, pseudo, engine);
            } else if (NatTableCSSConstants.CELL_BACKGROUND_COLOR.equalsIgnoreCase(property)) {
                if (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                    Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                    NatTableCSSHelper.applyNatTableStyle(
                            natTable,
                            CellStyleAttributes.BACKGROUND_COLOR,
                            newColor,
                            displayMode,
                            label);

                    if (resolvePainter) {
                        NatTableCSSHelper.storeContextValue(
                                context,
                                displayMode,
                                NatTableCSSConstants.CV_BACKGROUND_PAINTER,
                                CellPainterFactory.BACKGROUND_PAINTER_KEY);
                    }
                } else if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) {
                    Gradient grad = (Gradient) CSSValueSWTGradientConverterImpl.INSTANCE.convert(value, engine, natTable.getDisplay());
                    if (grad != null) {
                        List<?> values = grad.getValues();
                        if (values.size() == 2) {
                            Color background = (Color) engine.convert(
                                    (CSSPrimitiveValue) values.get(0), Color.class, natTable.getDisplay());
                            NatTableCSSHelper.applyNatTableStyle(
                                    natTable,
                                    CellStyleAttributes.GRADIENT_BACKGROUND_COLOR,
                                    background,
                                    displayMode,
                                    label);
                            Color foreground = (Color) engine.convert(
                                    (CSSPrimitiveValue) values.get(1), Color.class, natTable.getDisplay());
                            NatTableCSSHelper.applyNatTableStyle(
                                    natTable,
                                    CellStyleAttributes.GRADIENT_FOREGROUND_COLOR,
                                    foreground,
                                    displayMode,
                                    label);

                            NatTableCSSHelper
                                    .getPainterProperties(context, displayMode)
                                    .put(NatTableCSSConstants.GRADIENT_BACKGROUND_VERTICAL, grad.getVerticalGradient());

                            if (resolvePainter) {
                                NatTableCSSHelper.storeContextValue(
                                        context,
                                        displayMode,
                                        NatTableCSSConstants.CV_BACKGROUND_PAINTER,
                                        CellPainterFactory.GRADIENT_BACKGROUND_PAINTER_KEY);
                            }
                        }
                    }
                }
            } else if (NatTableCSSConstants.CELL_BACKGROUND_IMAGE.equalsIgnoreCase(property)) {
                Image image = (Image) engine.convert(value, Image.class, natTable.getDisplay());
                if (image != null) {
                    NatTableCSSHelper
                            .getPainterProperties(context, displayMode)
                            .put(NatTableCSSConstants.CELL_BACKGROUND_IMAGE, image);

                    if (resolvePainter) {
                        NatTableCSSHelper.storeContextValue(
                                context,
                                displayMode,
                                NatTableCSSConstants.CV_BACKGROUND_PAINTER,
                                CellPainterFactory.BACKGROUND_IMAGE_PAINTER_KEY);
                    }
                }
            } else if (NatTableCSSConstants.FOREGROUND_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.FOREGROUND_COLOR,
                        newColor,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.HORIZONTAL_ALIGNMENT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                String stringValue = value.getCssText().toLowerCase();
                HorizontalAlignmentEnum align = HorizontalAlignmentEnum.CENTER;
                if ("left".equals(stringValue)
                        || "lead".equals(stringValue)) {
                    align = HorizontalAlignmentEnum.LEFT;
                } else if ("right".equals(stringValue)
                        || "trail".equals(stringValue)) {
                    align = HorizontalAlignmentEnum.RIGHT;
                } else if ("center".equals(stringValue)) {
                    align = HorizontalAlignmentEnum.CENTER;
                }
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.HORIZONTAL_ALIGNMENT,
                        align,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.VERTICAL_ALIGNMENT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                String stringValue = value.getCssText().toLowerCase();
                VerticalAlignmentEnum align = VerticalAlignmentEnum.MIDDLE;
                if ("top".equals(stringValue)
                        || "up".equals(stringValue)) {
                    align = VerticalAlignmentEnum.TOP;
                } else if ("bottom".equals(stringValue)
                        || "down".equals(stringValue)) {
                    align = VerticalAlignmentEnum.BOTTOM;
                } else if ("middle".equals(stringValue)) {
                    align = VerticalAlignmentEnum.MIDDLE;
                }
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.VERTICAL_ALIGNMENT,
                        align,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.FONT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                NatTableCSSHelper.setFontProperties(
                        (CSSValueList) value,
                        NatTableCSSHelper.getFontProperties(context, CSS2FontPropertiesHelpers.CSS2FONT_KEY, natTable, displayMode, label));
            } else if (NatTableCSSConstants.FONT_FAMILY.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font =
                        NatTableCSSHelper.getFontProperties(context, CSS2FontPropertiesHelpers.CSS2FONT_KEY, natTable, displayMode, label);
                font.setFamily((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.FONT_SIZE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font =
                        NatTableCSSHelper.getFontProperties(context, CSS2FontPropertiesHelpers.CSS2FONT_KEY, natTable, displayMode, label);
                font.setSize((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.FONT_STYLE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font =
                        NatTableCSSHelper.getFontProperties(context, CSS2FontPropertiesHelpers.CSS2FONT_KEY, natTable, displayMode, label);
                font.setStyle((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.FONT_WEIGHT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font =
                        NatTableCSSHelper.getFontProperties(context, CSS2FontPropertiesHelpers.CSS2FONT_KEY, natTable, displayMode, label);
                font.setWeight((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.IMAGE.equalsIgnoreCase(property)) {
                Image image = (Image) engine.convert(value, Image.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.IMAGE,
                        image,
                        displayMode,
                        label);

                if (resolvePainter) {
                    NatTableCSSHelper.storeContextValue(
                            context,
                            displayMode,
                            NatTableCSSConstants.CV_CONTENT_PAINTER,
                            CellPainterFactory.IMAGE_PAINTER_KEY);
                }
            } else if (NatTableCSSConstants.BORDER.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                CSSValueList valueList = (CSSValueList) value;
                BorderStyle borderStyle = NatTableCSSHelper.getBorderStyle(context, displayMode);
                NatTableCSSHelper.storeBorderStyle(valueList, borderStyle, engine, natTable.getDisplay());
            } else if (NatTableCSSConstants.BORDER_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                BorderStyle borderStyle = NatTableCSSHelper.getBorderStyle(context, displayMode);
                borderStyle.setColor((Color) engine.convert(value, Color.class, natTable.getDisplay()));
            } else if (NatTableCSSConstants.BORDER_STYLE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                BorderStyle borderStyle = NatTableCSSHelper.getBorderStyle(context, displayMode);
                CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value;
                borderStyle.setLineStyle(
                        LineStyleEnum.valueOf(primitiveValue.getStringValue().toUpperCase()));
            } else if (NatTableCSSConstants.BORDER_WIDTH.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                BorderStyle borderStyle = NatTableCSSHelper.getBorderStyle(context, displayMode);
                borderStyle.setThickness(
                        (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT));
            } else if (NatTableCSSConstants.BORDER_MODE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                BorderStyle borderStyle = NatTableCSSHelper.getBorderStyle(context, displayMode);
                CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value;
                borderStyle.setBorderMode(
                        BorderModeEnum.valueOf(primitiveValue.getStringValue().toUpperCase()));
            } else if (NatTableCSSConstants.PASSWORD_ECHO_CHAR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                String stringValue = value.getCssText();
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.PASSWORD_ECHO_CHAR,
                        stringValue.charAt(0),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.TEXT_DECORATION.equalsIgnoreCase(property)) {
                if (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                    String stringValue = value.getCssText();
                    if ("none".equals(stringValue)) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                null,
                                displayMode,
                                label);
                    } else if ("underline".equals(stringValue)) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                TextDecorationEnum.UNDERLINE,
                                displayMode,
                                label);
                    } else if ("line-through".equals(stringValue)) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                TextDecorationEnum.STRIKETHROUGH,
                                displayMode,
                                label);
                    }
                } else if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) {
                    CSSValueList valueList = (CSSValueList) value;
                    int length = valueList.getLength();
                    boolean strikethrough = false;
                    boolean underline = false;
                    for (int i = 0; i < length; i++) {
                        CSSValue value2 = valueList.item(i);
                        if (value2.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                            String stringValue = value2.getCssText();
                            if ("none".equals(stringValue)) {
                                strikethrough = false;
                                underline = false;
                                break;
                            } else if ("underline".equals(stringValue)) {
                                underline = true;
                            } else if ("line-through".equals(stringValue)) {
                                strikethrough = true;
                            }
                        }
                    }

                    if (!strikethrough && !underline) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                null,
                                displayMode,
                                label);
                    } else if (!strikethrough && underline) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                TextDecorationEnum.UNDERLINE,
                                displayMode,
                                label);
                    } else if (strikethrough && !underline) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                TextDecorationEnum.STRIKETHROUGH,
                                displayMode,
                                label);
                    } else if (strikethrough && underline) {
                        NatTableCSSHelper.applyNatTableStyle(
                                natTable,
                                CellStyleAttributes.TEXT_DECORATION,
                                TextDecorationEnum.UNDERLINE_STRIKETHROUGH,
                                displayMode,
                                label);
                    }
                }
            } else if (NatTableCSSConstants.FREEZE_SEPARATOR_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        FreezeConfigAttributes.SEPARATOR_COLOR,
                        (Color) engine.convert(value, Color.class, natTable.getDisplay()),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.FREEZE_SEPARATOR_WIDTH.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        FreezeConfigAttributes.SEPARATOR_WIDTH,
                        (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.GRID_LINE_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        CellConfigAttributes.GRID_LINE_COLOR,
                        (Color) engine.convert(value, Color.class, natTable.getDisplay()),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.GRID_LINE_WIDTH.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        CellConfigAttributes.GRID_LINE_WIDTH,
                        (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.RENDER_GRID_LINES.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        CellConfigAttributes.RENDER_GRID_LINES,
                        NatTableCSSHelper.getBoolean(value, true),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                NatTableCSSHelper.setFontProperties(
                        (CSSValueList) value,
                        NatTableCSSHelper.getFontProperties(
                                context,
                                NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES,
                                natTable,
                                displayMode,
                                label));
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_FAMILY.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setFamily((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_SIZE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setSize((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_STYLE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setStyle((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FONT_WEIGHT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setWeight((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_BACKGROUND_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.CONVERSION_ERROR_STYLE,
                        CellStyleAttributes.BACKGROUND_COLOR,
                        newColor,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.CONVERSION_ERROR_FOREGROUND_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.CONVERSION_ERROR_STYLE,
                        CellStyleAttributes.FOREGROUND_COLOR,
                        newColor,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                NatTableCSSHelper.setFontProperties(
                        (CSSValueList) value,
                        NatTableCSSHelper.getFontProperties(
                                context,
                                NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES,
                                natTable,
                                displayMode,
                                label));
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_FAMILY.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setFamily((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_SIZE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setSize((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_STYLE.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setStyle((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FONT_WEIGHT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSS2FontProperties font = NatTableCSSHelper.getFontProperties(
                        context,
                        NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES,
                        natTable,
                        displayMode,
                        label);
                font.setWeight((CSSPrimitiveValue) value);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_BACKGROUND_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.VALIDATION_ERROR_STYLE,
                        CellStyleAttributes.BACKGROUND_COLOR,
                        newColor,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.VALIDATION_ERROR_FOREGROUND_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.VALIDATION_ERROR_STYLE,
                        CellStyleAttributes.FOREGROUND_COLOR,
                        newColor,
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.WORD_WRAP.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.WORD_WRAP, NatTableCSSHelper.getBoolean(value, false));
            } else if (NatTableCSSConstants.TEXT_WRAP.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.TEXT_WRAP, NatTableCSSHelper.getBoolean(value, false));
            } else if (NatTableCSSConstants.TEXT_TRIM.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.TEXT_TRIM, NatTableCSSHelper.getBoolean(value, true));
            } else if (NatTableCSSConstants.TEXT_DIRECTION.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.TEXT_DIRECTION, value.getCssText());
            } else if (NatTableCSSConstants.LINE_SPACING.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.LINE_SPACING, (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT));
            } else if (NatTableCSSConstants.COLUMN_WIDTH.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value;
                short type = primitiveValue.getPrimitiveType();
                switch (type) {
                    case CSSPrimitiveValue.CSS_IDENT:
                        if ("auto".equalsIgnoreCase(value.getCssText())) {
                            NatTableCSSHelper
                                    .getPainterProperties(context, displayMode)
                                    .put(NatTableCSSConstants.CALCULATE_CELL_WIDTH, true);
                        } else if ("percentage".equalsIgnoreCase(value.getCssText())) {
                            // set column percentage sizing
                            natTable.doCommand(new ColumnSizeConfigurationCommand(label, null, true));
                        }
                        break;
                    case CSSPrimitiveValue.CSS_PERCENTAGE:
                        // set column percentage sizing
                        int percentage = (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PERCENTAGE);
                        natTable.doCommand(new ColumnSizeConfigurationCommand(label, percentage, true));
                        break;
                    case CSSPrimitiveValue.CSS_PT:
                    case CSSPrimitiveValue.CSS_NUMBER:
                    case CSSPrimitiveValue.CSS_PX:
                        // set column width by label
                        int width = (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT);
                        natTable.doCommand(new ColumnSizeConfigurationCommand(label, width, false));
                        break;
                }
            } else if (NatTableCSSConstants.ROW_HEIGHT.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value;
                short type = primitiveValue.getPrimitiveType();
                switch (type) {
                    case CSSPrimitiveValue.CSS_IDENT:
                        if ("auto".equalsIgnoreCase(value.getCssText())) {
                            NatTableCSSHelper
                                    .getPainterProperties(context, displayMode)
                                    .put(NatTableCSSConstants.CALCULATE_CELL_HEIGHT, true);
                        } else if ("percentage".equalsIgnoreCase(value.getCssText())) {
                            // set column percentage sizing
                            natTable.doCommand(new RowSizeConfigurationCommand(label, null, true));
                        }
                        break;
                    case CSSPrimitiveValue.CSS_PERCENTAGE:
                        // set column percentage sizing
                        int percentage = (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PERCENTAGE);
                        natTable.doCommand(new RowSizeConfigurationCommand(label, percentage, true));
                        break;
                    case CSSPrimitiveValue.CSS_PT:
                    case CSSPrimitiveValue.CSS_NUMBER:
                    case CSSPrimitiveValue.CSS_PX:
                        // set column width by label
                        int width = (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT);
                        natTable.doCommand(new RowSizeConfigurationCommand(label, width, false));
                        break;
                }
            } else if (NatTableCSSConstants.CONVERTER.equalsIgnoreCase(property)) {
                if (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                    if (NatTableCSSHelper.isConverterString(value.getCssText())) {
                        natTable.getConfigRegistry().registerConfigAttribute(
                                CellConfigAttributes.DISPLAY_CONVERTER,
                                NatTableCSSHelper.getDisplayConverter(
                                        value.getCssText(),
                                        true,
                                        null,
                                        null,
                                        null),
                                displayMode,
                                label);
                    }
                } else if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) {
                    String converterKey = null;
                    boolean format = true;
                    Integer minFractionDigits = null;
                    Integer maxFractionDigits = null;
                    String pattern = null;

                    CSSValueList valueList = (CSSValueList) value;
                    int length = valueList.getLength();
                    for (int i = 0; i < length; i++) {
                        CSSValue value2 = valueList.item(i);
                        if (value2.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                            CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value2;
                            short type = primitiveValue.getPrimitiveType();
                            switch (type) {
                                case CSSPrimitiveValue.CSS_IDENT:
                                    if (NatTableCSSHelper.isConverterString(primitiveValue.getCssText())) {
                                        converterKey = primitiveValue.getCssText();
                                    } else if ("true".equals(primitiveValue.getCssText())
                                            || "false".equals(primitiveValue.getCssText())) {
                                        format = NatTableCSSHelper.getBoolean(primitiveValue, true);
                                    }
                                    break;
                                case CSSPrimitiveValue.CSS_STRING:
                                    pattern = primitiveValue.getCssText();
                                    break;
                                case CSSPrimitiveValue.CSS_PT:
                                case CSSPrimitiveValue.CSS_NUMBER:
                                case CSSPrimitiveValue.CSS_PX:
                                    if (minFractionDigits == null) {
                                        minFractionDigits = (int) primitiveValue.getFloatValue(CSSPrimitiveValue.CSS_PT);
                                    } else {
                                        maxFractionDigits = (int) primitiveValue.getFloatValue(CSSPrimitiveValue.CSS_PT);
                                    }
                                    break;
                            }
                        }
                    }

                    if (converterKey != null) {
                        natTable.getConfigRegistry().registerConfigAttribute(
                                CellConfigAttributes.DISPLAY_CONVERTER,
                                NatTableCSSHelper.getDisplayConverter(
                                        converterKey,
                                        format,
                                        minFractionDigits,
                                        maxFractionDigits,
                                        pattern),
                                displayMode,
                                label);
                    }
                }
            } else if (NatTableCSSConstants.PADDING.equalsIgnoreCase(property)) {
                if (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                    NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_TOP, value, context, displayMode);
                    NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_RIGHT, value, context, displayMode);
                    NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_BOTTOM, value, context, displayMode);
                    NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_LEFT, value, context, displayMode);
                } else if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) {
                    CSSValueList valueList = (CSSValueList) value;
                    int length = valueList.getLength();
                    if (length == 4) {
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_TOP, valueList.item(0), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_RIGHT, valueList.item(1), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_BOTTOM, valueList.item(2), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_LEFT, valueList.item(3), context, displayMode);
                    } else if (length == 3) {
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_TOP, valueList.item(0), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_RIGHT, valueList.item(1), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_BOTTOM, valueList.item(2), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_LEFT, valueList.item(1), context, displayMode);
                    } else if (length == 2) {
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_TOP, valueList.item(0), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_RIGHT, valueList.item(1), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_BOTTOM, valueList.item(0), context, displayMode);
                        NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_LEFT, valueList.item(1), context, displayMode);
                    }
                }
            } else if (NatTableCSSConstants.PADDING_TOP.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_TOP, value, context, displayMode);
            } else if (NatTableCSSConstants.PADDING_RIGHT.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_RIGHT, value, context, displayMode);
            } else if (NatTableCSSConstants.PADDING_BOTTOM.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_BOTTOM, value, context, displayMode);
            } else if (NatTableCSSConstants.PADDING_LEFT.equalsIgnoreCase(property)) {
                NatTableCSSHelper.storePadding(NatTableCSSConstants.PADDING_LEFT, value, context, displayMode);
            } else if (NatTableCSSConstants.TABLE_BORDER_COLOR.equals(property)
                    && value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {

                // remove any prior configured NatTableBorderOverlayPainter
                for (Iterator<IOverlayPainter> it = natTable.getOverlayPainters().iterator(); it.hasNext();) {
                    IOverlayPainter painter = it.next();
                    if (painter instanceof NatTableBorderOverlayPainter) {
                        it.remove();
                    }
                }

                // add the new NatTableBorderOverlayPainter
                if ("auto".equalsIgnoreCase(value.getCssText())) {
                    natTable.addOverlayPainter(new NatTableBorderOverlayPainter(true, natTable.getConfigRegistry()));
                } else {
                    Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                    natTable.addOverlayPainter(new NatTableBorderOverlayPainter(newColor, true));
                }
            } else if (NatTableCSSConstants.FILL_HANDLE_BORDER.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                CSSValueList valueList = (CSSValueList) value;
                BorderStyle borderStyle = new BorderStyle();
                NatTableCSSHelper.storeBorderStyle(valueList, borderStyle, engine, natTable.getDisplay());
                natTable.getConfigRegistry().registerConfigAttribute(
                        FillHandleConfigAttributes.FILL_HANDLE_BORDER_STYLE,
                        borderStyle);
            } else if (NatTableCSSConstants.FILL_HANDLE_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        FillHandleConfigAttributes.FILL_HANDLE_COLOR,
                        (Color) engine.convert(value, Color.class, natTable.getDisplay()));
            } else if (NatTableCSSConstants.FILL_REGION_BORDER.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                CSSValueList valueList = (CSSValueList) value;
                BorderStyle borderStyle = new BorderStyle();
                NatTableCSSHelper.storeBorderStyle(valueList, borderStyle, engine, natTable.getDisplay());
                natTable.getConfigRegistry().registerConfigAttribute(
                        FillHandleConfigAttributes.FILL_HANDLE_REGION_BORDER_STYLE,
                        borderStyle);
            } else if (NatTableCSSConstants.DECORATION.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_VALUE_LIST)) {
                CSSValueList valueList = (CSSValueList) value;
                int length = valueList.getLength();
                for (int i = 0; i < length; i++) {
                    CSSValue value2 = valueList.item(i);
                    if (value2.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                        CSSPrimitiveValue primitiveValue = (CSSPrimitiveValue) value2;
                        short type = primitiveValue.getPrimitiveType();
                        switch (type) {
                            case CSSPrimitiveValue.CSS_IDENT:
                                if ("true".equalsIgnoreCase(value2.getCssText())
                                        || "false".equalsIgnoreCase(value2.getCssText())) {
                                    NatTableCSSHelper
                                            .getPainterProperties(context, displayMode)
                                            .put(NatTableCSSConstants.PAINT_DECORATION_DEPENDENT,
                                                    NatTableCSSHelper.getBoolean(value2, true));
                                } else {
                                    CellEdgeEnum edge = NatTableCSSHelper.getCellEdgeEnum(value2.getCssText());
                                    NatTableCSSHelper
                                            .getPainterProperties(context, displayMode)
                                            .put(NatTableCSSConstants.DECORATOR_EDGE, edge);
                                }

                                break;
                            case CSSPrimitiveValue.CSS_URI:
                                // first try to resolve the image using NatTable
                                // GUIHelper to support scaling
                                Image image = null;
                                try {
                                    IResourcesLocatorManager manager = engine.getResourcesLocatorManager();
                                    String resolved = manager.resolve(primitiveValue.getStringValue());
                                    image = GUIHelper.getImageByURL(new URI(resolved).toURL());
                                } catch (Exception e) {
                                    // something went wrong with loading the
                                    // image by URL try to use the CSSEngine
                                    image = (Image) engine.convert(value2, Image.class, natTable.getDisplay());
                                }

                                if (image != null) {
                                    NatTableCSSHelper
                                            .getPainterProperties(context, displayMode)
                                            .put(NatTableCSSConstants.DECORATOR_IMAGE, image);
                                }
                                break;
                            case CSSPrimitiveValue.CSS_PT:
                            case CSSPrimitiveValue.CSS_NUMBER:
                            case CSSPrimitiveValue.CSS_PX:
                                int spacing = (int) ((CSSPrimitiveValue) value2).getFloatValue(CSSPrimitiveValue.CSS_PT);
                                NatTableCSSHelper
                                        .getPainterProperties(context, displayMode)
                                        .put(NatTableCSSConstants.DECORATOR_SPACING, spacing);
                                break;
                        }
                    }
                }

                List<String> decoratorKeys = NatTableCSSHelper.getDecoratorPainter(context, displayMode);
                if (!decoratorKeys.contains(CellPainterFactory.DECORATOR_KEY)) {
                    decoratorKeys.add(CellPainterFactory.DECORATOR_KEY);
                }
            } else if (NatTableCSSConstants.INVERT_ICONS.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                NatTableCSSHelper
                        .getPainterProperties(context, displayMode)
                        .put(NatTableCSSConstants.INVERT_ICONS, NatTableCSSHelper.getBoolean(value, false));
            } else if (NatTableCSSConstants.PERCENTAGE_DECORATOR_COLORS.equalsIgnoreCase(property)) {
                if (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                    Color newColor = (Color) engine.convert(value, Color.class, natTable.getDisplay());
                    NatTableCSSHelper.applyNatTableStyle(
                            natTable,
                            PercentageBarDecorator.PERCENTAGE_BAR_COMPLETE_REGION_START_COLOR,
                            newColor,
                            displayMode,
                            label);
                } else if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) {
                    CSSValueList valueList = (CSSValueList) value;
                    int length = valueList.getLength();
                    for (int i = 0; i < length; i++) {
                        CSSValue value2 = valueList.item(i);
                        if (value2.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) {
                            Color newColor = (Color) engine.convert(value2, Color.class, natTable.getDisplay());
                            ConfigAttribute<Color> percentageConfig = null;
                            switch (i) {
                                case 0:
                                    percentageConfig = PercentageBarDecorator.PERCENTAGE_BAR_COMPLETE_REGION_START_COLOR;
                                    break;
                                case 1:
                                    percentageConfig = PercentageBarDecorator.PERCENTAGE_BAR_COMPLETE_REGION_END_COLOR;
                                    break;
                                case 2:
                                    percentageConfig = PercentageBarDecorator.PERCENTAGE_BAR_INCOMPLETE_REGION_COLOR;
                                    break;
                            }

                            if (percentageConfig != null) {
                                NatTableCSSHelper.applyNatTableStyle(
                                        natTable,
                                        percentageConfig,
                                        newColor,
                                        displayMode,
                                        label);
                            }
                        }
                    }
                }
            } else if (NatTableCSSConstants.TREE_STRUCTURE_PAINTER.equalsIgnoreCase(property)) {
                List<String> painterValues = NatTableCSSHelper.resolvePainterRepresentation(value);
                Map<String, Object> painterProperties =
                        NatTableCSSHelper.getPainterPropertiesInherited(context, natTableContext, displayMode);

                // ensure that the last value in the element is not a content
                // painter
                if (CellPainterFactory.getInstance().isContentPainterKey(painterValues.get(painterValues.size() - 1))) {
                    painterValues.remove(painterValues.size() - 1);
                }

                // add none to the end to ensure that the content painter is
                // resolved dynamically by the TreeLayer
                painterValues.add(CellPainterFactory.NONE);

                ICellPainter painter = CellPainterFactory.getInstance().getCellPainter(painterValues, painterProperties);

                if (painter != null) {
                    natTable.getConfigRegistry().registerConfigAttribute(
                            TreeConfigAttributes.TREE_STRUCTURE_PAINTER,
                            painter,
                            displayMode);
                }
            } else if (NatTableCSSConstants.HIDE_INDICATOR_COLOR.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        HideIndicatorConfigAttributes.HIDE_INDICATOR_COLOR,
                        (Color) engine.convert(value, Color.class, natTable.getDisplay()),
                        displayMode,
                        label);
            } else if (NatTableCSSConstants.HIDE_INDICATOR_WIDTH.equalsIgnoreCase(property)
                    && (value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE)) {
                natTable.getConfigRegistry().registerConfigAttribute(
                        HideIndicatorConfigAttributes.HIDE_INDICATOR_LINE_WIDTH,
                        (int) ((CSSPrimitiveValue) value).getFloatValue(CSSPrimitiveValue.CSS_PT),
                        displayMode,
                        label);
            }

            return true;
        }

        return false;
    }

    @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(
                                FreezeConfigAttributes.SEPARATOR_COLOR,
                                displayMode,
                                label),
                        engine,
                        null);
            } else if (NatTableCSSConstants.FREEZE_SEPARATOR_WIDTH.equalsIgnoreCase(property)) {
                Integer width = natTable.getConfigRegistry().getConfigAttribute(
                        FreezeConfigAttributes.SEPARATOR_WIDTH,
                        displayMode,
                        label);
                if (width == null) {
                    return "0";
                } else {
                    return width.toString();
                }
            } 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)) {
                // return a value that would not trigger any action for resizing
                // inherit is not supported here
                return "default";
            } else if (NatTableCSSConstants.ROW_HEIGHT.equalsIgnoreCase(property)) {
                // return a value that would not trigger any action for resizing
                // 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)) {
                // that information is hidden in specific painters and we are
                // 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);
            } else if (NatTableCSSConstants.HIDE_INDICATOR_COLOR.equalsIgnoreCase(property)) {
                ICSSValueConverter cssValueConverter = engine.getCSSValueConverter(String.class);
                return cssValueConverter.convert(
                        natTable.getConfigRegistry().getConfigAttribute(
                                HideIndicatorConfigAttributes.HIDE_INDICATOR_COLOR,
                                displayMode,
                                label),
                        engine,
                        null);
            } else if (NatTableCSSConstants.HIDE_INDICATOR_WIDTH.equalsIgnoreCase(property)) {
                Integer width = natTable.getConfigRegistry().getConfigAttribute(
                        HideIndicatorConfigAttributes.HIDE_INDICATOR_LINE_WIDTH,
                        displayMode,
                        label);
                if (width == null) {
                    return "0";
                } else {
                    return width.toString();
                }
            }
        }
        return null;
    }

    @Override
    public void onAllCSSPropertiesApplyed(Object element, CSSEngine engine, String pseudo) throws Exception {
        Object control = null;

        if (element instanceof CSSStylableElement) {
            CSSStylableElement elt = (CSSStylableElement) element;
            control = elt.getNativeWidget();
        }

        NatTable natTable = null;
        String label = null;

        CSSElementContext context = null;
        CSSElementContext natTableContext = null;

        if (control instanceof NatTable) {
            natTable = (NatTable) control;
        } else if (control instanceof NatTableWrapper) {
            natTable = ((NatTableWrapper) control).getNatTable();
            label = ((NatTableWrapper) control).getLabel();
            natTableContext = engine.getCSSElementContext(natTable);
        }

        if (natTable != null) {
            context = engine.getCSSElementContext(control);
            String displayMode = NatTableCSSHelper.getDisplayMode(pseudo);

            CSS2FontProperties fontProperties =
                    (CSS2FontProperties) NatTableCSSHelper.getContextValue(
                            context,
                            displayMode,
                            CSS2FontPropertiesHelpers.CSS2FONT_KEY);
            if (fontProperties != null) {
                // if there are font properties, register the font
                // check if there is a font registered in the hierarchy
                Font font = NatTableCSSHelper.getNatTableStyle(natTable, CellStyleAttributes.FONT, displayMode, label);

                if (font == null) {
                    // if there are no font properties already and no font, use
                    // the default font
                    font = GUIHelper.DEFAULT_FONT;
                }

                FontData fontData = CSSSWTFontHelper.getFontData(
                        fontProperties,
                        CSSSWTFontHelper.getFirstFontData(font));
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.FONT,
                        GUIHelper.getFont(fontData),
                        displayMode,
                        label);
            }

            BorderStyle borderStyle =
                    (BorderStyle) NatTableCSSHelper.getContextValue(
                            context,
                            displayMode,
                            NatTableCSSConstants.CV_BORDER_CONFIGURATION);
            if (borderStyle != null) {
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        CellStyleAttributes.BORDER_STYLE,
                        borderStyle,
                        displayMode,
                        label);
            }

            CSS2FontProperties conversionErrorFontProperties =
                    (CSS2FontProperties) NatTableCSSHelper.getContextValue(
                            context,
                            displayMode,
                            NatTableCSSConstants.CV_CONVERSION_ERROR_FONT_PROPERTIES);
            if (conversionErrorFontProperties != null) {
                // if there are font properties, register the font
                FontData fontData = CSSSWTFontHelper.getFontData(
                        conversionErrorFontProperties,
                        CSSSWTFontHelper.getFirstFontData(GUIHelper.DEFAULT_FONT));
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.CONVERSION_ERROR_STYLE,
                        CellStyleAttributes.FONT,
                        GUIHelper.getFont(fontData),
                        displayMode,
                        label);
            }

            CSS2FontProperties validationErrorFontProperties =
                    (CSS2FontProperties) NatTableCSSHelper.getContextValue(
                            context,
                            displayMode,
                            NatTableCSSConstants.CV_VALIDATION_ERROR_FONT_PROPERTIES);
            if (validationErrorFontProperties != null) {
                // if there are font properties, register the font
                FontData fontData = CSSSWTFontHelper.getFontData(
                        validationErrorFontProperties,
                        CSSSWTFontHelper.getFirstFontData(GUIHelper.DEFAULT_FONT));
                NatTableCSSHelper.applyNatTableStyle(
                        natTable,
                        EditConfigAttributes.VALIDATION_ERROR_STYLE,
                        CellStyleAttributes.FONT,
                        GUIHelper.getFont(fontData),
                        displayMode,
                        label);
            }

            Object pv = NatTableCSSHelper.getContextValue(context, displayMode, NatTableCSSConstants.PAINTER);
            if (pv instanceof List<?>) {
                @SuppressWarnings("unchecked")
                List<String> painterValues = (List<String>) pv;

                Map<String, Object> painterProperties =
                        NatTableCSSHelper.getPainterPropertiesInherited(context, natTableContext, displayMode);

                ICellPainter painter = CellPainterFactory.getInstance().getCellPainter(painterValues, painterProperties);

                if (painter != null) {
                    natTable.getConfigRegistry().registerConfigAttribute(
                            CellConfigAttributes.CELL_PAINTER,
                            painter,
                            displayMode,
                            label);
                }
            } else if (NatTableCSSHelper.resolvePainter(context, natTableContext, displayMode)) {
                String backgroundKey = (String) NatTableCSSHelper.getContextValueInherited(
                        context,
                        natTableContext,
                        displayMode,
                        NatTableCSSConstants.CV_BACKGROUND_PAINTER);
                List<String> decoratorKeys = NatTableCSSHelper.getDecoratorPainter(context, displayMode);
                String contentKey = (String) NatTableCSSHelper.getContextValue(
                        context,
                        displayMode,
                        NatTableCSSConstants.CV_CONTENT_PAINTER);
                Map<String, Object> painterProperties =
                        NatTableCSSHelper.getPainterPropertiesInherited(context, natTableContext, displayMode);

                if ((painterProperties.containsKey(NatTableCSSConstants.PADDING_TOP)
                        || painterProperties.containsKey(NatTableCSSConstants.PADDING_LEFT)
                        || painterProperties.containsKey(NatTableCSSConstants.PADDING_BOTTOM)
                        || painterProperties.containsKey(NatTableCSSConstants.PADDING_RIGHT))
                        && !decoratorKeys.contains(CellPainterFactory.PADDING_DECORATOR_KEY)) {
                    decoratorKeys.add(0, CellPainterFactory.PADDING_DECORATOR_KEY);
                }

                if (borderStyle != null && !decoratorKeys.contains(CellPainterFactory.LINE_BORDER_DECORATOR_KEY)) {
                    decoratorKeys.add(0, CellPainterFactory.LINE_BORDER_DECORATOR_KEY);
                }

                ICellPainter painter = CellPainterFactory.getInstance().getCellPainter(
                        backgroundKey,
                        decoratorKeys,
                        contentKey,
                        painterProperties);

                if (painter != null) {
                    natTable.getConfigRegistry().registerConfigAttribute(
                            CellConfigAttributes.CELL_PAINTER,
                            painter,
                            displayMode,
                            label);
                }
            }
        }
    }
}