use of com.sldeditor.ui.detail.config.base.GroupConfigInterface in project sldeditor by robward-scisys.
the class FieldConfigTTF method setValue.
/**
* Sets the value.
*
* @param symbolizerType the symbolizer type
* @param fieldConfigManager the field config manager
* @param multiOptionPanel the multi option panel
* @param graphic the graphic
* @param symbol the symbol
*/
@Override
public void setValue(Class<?> symbolizerType, GraphicPanelFieldManager fieldConfigManager, FieldConfigSymbolType multiOptionPanel, Graphic graphic, GraphicalSymbol symbol) {
if (symbol == null) {
return;
}
if (fieldConfigManager == null) {
return;
}
MarkImpl markerSymbol = (MarkImpl) symbol;
FillImpl fill = markerSymbol.getFill();
Expression expFillColour = null;
Expression expFillOpacity = null;
if (fill != null) {
expFillColour = fill.getColor();
if (!isOverallOpacity(symbolizerType)) {
expFillOpacity = fill.getOpacity();
}
}
FieldConfigBase field = fieldConfigManager.get(fillFieldConfig.getColour());
if (field != null) {
field.populate(expFillColour);
}
// Opacity
if (isOverallOpacity(symbolizerType)) {
FieldConfigBase opacity = fieldConfigManager.get(FieldIdEnum.OVERALL_OPACITY);
if (opacity != null) {
opacity.populate(graphic.getOpacity());
}
}
field = fieldConfigManager.get(fillFieldConfig.getOpacity());
if (field != null) {
field.populate(expFillOpacity);
}
Class<?> panelId = getCommonData().getPanelId();
GroupConfigInterface fillGroup = fieldConfigManager.getGroup(panelId, fillFieldConfig.getGroup());
if (fillGroup != null) {
fillGroup.enable(expFillColour != null);
}
if (ttfPanel != null) {
Expression wellKnownNameExpression = markerSymbol.getWellKnownName();
String wellKnownName = null;
if (wellKnownNameExpression != null) {
wellKnownName = wellKnownNameExpression.toString();
}
ttfPanel.populateExpression(wellKnownName);
}
if (multiOptionPanel != null) {
multiOptionPanel.setSelectedItem(TTF_SYMBOL_KEY);
}
}
use of com.sldeditor.ui.detail.config.base.GroupConfigInterface in project sldeditor by robward-scisys.
the class VOGeoServerContrastEnhancementNormalize method updateSymbol.
/*
* (non-Javadoc)
*
* @see
* com.sldeditor.ui.detail.vendor.geoserver.VendorOptionInterface#updateSymbol(org.geotools.
* styling.RasterSymbolizer)
*/
@Override
public void updateSymbol(RasterSymbolizer rasterSymbolizer) {
if (parentPanel != null) {
GroupConfigInterface group = parentPanel.getGroup(GroupIdEnum.RASTER_CHANNELSELECTION);
if (group != null) {
if (group.isPanelEnabled()) {
MultiOptionGroup contrastEnhancementGroup = (MultiOptionGroup) group;
ChannelSelection channelSelection = rasterSymbolizer.getChannelSelection();
OptionGroup selectedOption = contrastEnhancementGroup.getSelectedOptionGroup();
ContrastEnhancement contrastEnhancement = getContrastEnhancement(selectedOption.getId(), channelSelection);
if (contrastEnhancement != null) {
extractNormalizeVendorOption(contrastEnhancement);
}
}
}
}
}
use of com.sldeditor.ui.detail.config.base.GroupConfigInterface in project sldeditor by robward-scisys.
the class FilterManager method convertParameters.
/**
* Convert function parameters to ui components.
*
* @param panelId the panel id
* @param functionName the function name
* @return the list of ui components to display
*/
@Override
public List<GroupConfigInterface> convertParameters(Class<?> panelId, FunctionName functionName) {
List<GroupConfigInterface> groupConfigList = new ArrayList<GroupConfigInterface>();
if (functionName != null) {
GroupConfig groupConfig = new GroupConfig();
StringBuilder funcPrototypeStringBuilder = new StringBuilder();
funcPrototypeStringBuilder.append(functionName.getName());
funcPrototypeStringBuilder.append("(");
int argCount = functionName.getArgumentCount();
if (functionName.getArgumentCount() < 0) {
argCount *= -1;
}
for (int index = 0; index < argCount; index++) {
int argIndex = index;
if (argIndex >= functionName.getArguments().size()) {
argIndex = functionName.getArguments().size() - 1;
}
String label = functionName.getArgumentNames().get(argIndex);
Parameter<?> parameterType = functionName.getArguments().get(argIndex);
boolean valueOnly = false;
FieldIdEnum id = FieldIdEnum.UNKNOWN;
if (index > 0) {
funcPrototypeStringBuilder.append(", ");
}
Class<?> type = parameterType.getType();
funcPrototypeStringBuilder.append(type.getSimpleName());
FieldConfigBase fieldConfig = null;
FieldConfigCommonData commonData = new FieldConfigCommonData(panelId, id, label, valueOnly);
if (type == java.lang.Number.class) {
fieldConfig = new FieldConfigDouble(commonData);
} else if (type == Double.class) {
fieldConfig = new FieldConfigDouble(commonData);
} else if (type == Float.class) {
fieldConfig = new FieldConfigDouble(commonData);
} else if (type == Integer.class) {
fieldConfig = new FieldConfigInteger(commonData);
} else if (type == Long.class) {
fieldConfig = new FieldConfigInteger(commonData);
} else if (type == String.class) {
fieldConfig = new FieldConfigString(commonData, null);
} else if (type == Object.class) {
fieldConfig = new FieldConfigString(commonData, null);
} else if (type == Boolean.class) {
fieldConfig = new FieldConfigBoolean(commonData);
} else if (type == Geometry.class) {
fieldConfig = new FieldConfigGeometry(commonData, null);
} else if (type == org.opengis.geometry.Geometry.class) {
fieldConfig = new FieldConfigGeometry(commonData, null);
} else if (type == LineString.class) {
fieldConfig = new FieldConfigGeometry(commonData, null);
} else if (type == Date.class) {
fieldConfig = new FieldConfigDate(commonData);
} else if (type == Class.class) {
fieldConfig = new FieldConfigString(commonData, null);
} else if (type == Classifier.class) {
fieldConfig = new FieldConfigString(commonData, null);
} else if (type == Unit.class) {
fieldConfig = new FieldConfigMapUnits(commonData);
} else if (type == Comparable.class) {
fieldConfig = new FieldConfigString(commonData, null);
} else if (type == Color.class) {
fieldConfig = new FieldConfigColour(commonData);
} else {
ConsoleManager.getInstance().error(this, Localisation.getField(ExpressionPanelv2.class, "FilterManager.error1") + type.getName());
}
groupConfig.addField(fieldConfig);
}
funcPrototypeStringBuilder.append(")");
groupConfig.setLabel(funcPrototypeStringBuilder.toString());
groupConfigList.add(groupConfig);
}
return groupConfigList;
}
use of com.sldeditor.ui.detail.config.base.GroupConfigInterface in project sldeditor by robward-scisys.
the class SLDTestRunner method runTest.
/**
* Run the test.
*
* @param folder the folder
* @param testConfig the test config
*/
public void runTest(String folder, String testConfig) {
// read JSON file data as String
String fullPath = "/" + folder + "/test/" + testConfig;
SldEditorTest testSuite = (SldEditorTest) ParseXML.parseFile("", fullPath, SCHEMA_RESOURCE, SldEditorTest.class);
Assert.assertNotNull("Failed to read test config file : " + fullPath, testSuite);
String testsldfile = testSuite.getTestsldfile();
if (!testsldfile.startsWith("/")) {
testsldfile = "/" + testsldfile;
}
System.out.println("Opening : " + testsldfile);
List<XMLVendorOption> xmlVendorOptionList = testSuite.getVendorOption();
List<VersionData> versionDataList = new ArrayList<VersionData>();
if ((xmlVendorOptionList != null) && !xmlVendorOptionList.isEmpty()) {
for (XMLVendorOption vo : xmlVendorOptionList) {
VersionData versionData = ReadPanelConfig.decodeVersionData(vo);
versionDataList.add(versionData);
}
}
// If in doubt revert to strict SLD
if (versionDataList.isEmpty()) {
versionDataList.add(VendorOptionManager.getInstance().getDefaultVendorOptionVersionData());
}
sldEditor.setVendorOptions(versionDataList);
InputStream inputStream = SLDTestRunner.class.getResourceAsStream(testsldfile);
if (inputStream == null) {
Assert.assertNotNull("Failed to find sld test file : " + testsldfile, inputStream);
} else {
File f = null;
try {
f = stream2file(inputStream);
int noOfRetries = 3;
int attempt = 0;
while (attempt < noOfRetries) {
try {
sldEditor.openFile(f.toURI().toURL());
break;
} catch (NullPointerException nullException) {
nullException.printStackTrace();
StackTraceElement[] stackTraceElements = nullException.getStackTrace();
System.out.println(stackTraceElements[0].getMethodName());
System.out.println("Attempt : " + attempt + 1);
attempt++;
}
}
f.delete();
} catch (IOException e1) {
e1.printStackTrace();
}
GraphicPanelFieldManager mgr = sldEditor.getFieldDataManager();
for (XMLPanelTest test : testSuite.getPanelTests()) {
XMLSetup selectedItem = test.getSetup();
TreeSelectionData selectionData = new TreeSelectionData();
selectionData.setLayerIndex(getXMLValue(selectedItem.getLayer()));
selectionData.setStyleIndex(getXMLValue(selectedItem.getStyle()));
selectionData.setFeatureTypeStyleIndex(getXMLValue(selectedItem.getFeatureTypeStyle()));
selectionData.setRuleIndex(getXMLValue(selectedItem.getRule()));
selectionData.setSymbolizerIndex(getXMLValue(selectedItem.getSymbolizer()));
selectionData.setSymbolizerDetailIndex(getXMLValue(selectedItem.getSymbolizerDetail()));
try {
selectionData.setSelectedPanel(Class.forName(selectedItem.getExpectedPanel()));
} catch (ClassNotFoundException e1) {
Assert.fail("Unknown class : " + selectedItem.getExpectedPanel());
}
boolean result = sldEditor.selectTreeItem(selectionData);
Assert.assertTrue("Failed to select tree item", result);
PopulateDetailsInterface panel = sldEditor.getSymbolPanel();
String panelClassName = panel.getClass().getName();
Assert.assertEquals(panelClassName, selectedItem.getExpectedPanel());
Assert.assertEquals("Check panel data present", panel.isDataPresent(), selectedItem.getEnabled());
Class<?> panelId = null;
try {
panelId = Class.forName(selectedItem.getExpectedPanel());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if (test.getFieldTests() != null) {
for (XMLFieldTest testItem : test.getFieldTests()) {
if (testItem != null) {
if (testItem.getDisabledOrLiteralStringOrLiteralInt() != null) {
for (Object xmlTestValueObj : testItem.getDisabledOrLiteralStringOrLiteralInt()) {
if (xmlTestValueObj instanceof XMLSetMultiOptionGroup) {
XMLSetMultiOptionGroup testValue = (XMLSetMultiOptionGroup) xmlTestValueObj;
GroupIdEnum groupId = testValue.getMultiOptionGroupId();
String outputText = "Checking multioption group : " + groupId;
System.out.println(outputText);
Assert.assertNotNull(outputText, groupId);
MultiOptionGroup multiOptionGroup = mgr.getMultiOptionGroup(panelId, groupId);
Assert.assertNotNull(panelId.getName() + "/" + groupId + " multi option group should exist", multiOptionGroup);
multiOptionGroup.setOption(testValue.getOption());
OptionGroup optionGroupSelected = multiOptionGroup.getSelectedOptionGroup();
Assert.assertTrue(groupId + " should be set", optionGroupSelected.getId() == testValue.getOption());
} else if (xmlTestValueObj instanceof XMLSetGroup) {
XMLSetGroup testValue = (XMLSetGroup) xmlTestValueObj;
GroupIdEnum groupId = testValue.getGroupId();
String outputText = "Checking group : " + groupId;
System.out.println(outputText);
Assert.assertNotNull(outputText, groupId);
GroupConfigInterface groupConfig = mgr.getGroup(panelId, groupId);
Assert.assertNotNull(panelId.getName() + "/" + groupId + " group should exist", groupConfig);
groupConfig.enable(testValue.getEnable());
Assert.assertTrue(groupId + " should be set", groupConfig.isPanelEnabled() == testValue.getEnable());
} else {
XMLFieldBase testValue = (XMLFieldBase) xmlTestValueObj;
FieldIdEnum fieldId = testValue.getField();
String outputText = "Checking : " + fieldId;
System.out.println(outputText);
Assert.assertNotNull(outputText, fieldId);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
FieldConfigBase fieldConfig = mgr.getData(panelId, fieldId);
Assert.assertNotNull(String.format("Failed to field panel %s field %s", selectedItem.getExpectedPanel(), fieldId), fieldConfig);
if (testValue instanceof XMLSetFieldLiteralBase) {
XMLSetFieldLiteralInterface testInterface = (XMLSetFieldLiteralInterface) testValue;
testInterface.accept(fieldConfig, fieldId);
if (!((XMLSetFieldLiteralBase) testValue).getIgnoreCheck()) {
String sldContentString = sldEditor.getSLDString();
boolean actualResult = testOutput.testValue(sldContentString, selectionData, testValue.getField(), testValue);
Assert.assertTrue(fieldId + " should be set", actualResult);
}
} else if (testValue instanceof XMLSetFieldAttribute) {
XMLSetFieldLiteralInterface testInterface = (XMLSetFieldLiteralInterface) testValue;
testInterface.accept(fieldConfig, fieldId);
String sldContentString = sldEditor.getSLDString();
boolean actualResult = testOutput.testAttribute(sldContentString, selectionData, testValue.getField(), (XMLSetFieldAttribute) testValue);
Assert.assertTrue(fieldId + " should be set", actualResult);
} else if (testValue instanceof XMLFieldDisabled) {
Assert.assertFalse(fieldId + " should be disabled", fieldConfig.isEnabled());
} else {
Assert.assertTrue(fieldId + " should be enabled", fieldConfig.isEnabled());
Expression expression = null;
if (fieldConfig.isValueOnly()) {
String expectedValue = "";
if (testValue instanceof XMLFieldLiteralBase) {
Object literalValue = getLiteralValue((XMLFieldLiteralBase) testValue);
expectedValue = String.valueOf(literalValue);
if (fieldId == FieldIdEnum.TTF_SYMBOL) {
expectedValue = processTTFField(expectedValue).toString();
}
} else if (testValue instanceof XMLFieldAttribute) {
expectedValue = ((XMLFieldAttribute) testValue).getAttribute();
// CHECKSTYLE:OFF
} else if (testValue instanceof XMLFieldExpression) {
expectedValue = ((XMLFieldExpression) testValue).getExpression();
} else if (testValue instanceof XMLColourMapEntries) {
expectedValue = EncodeColourMap.encode(((XMLColourMapEntries) testValue).getEntry());
// CHECKSTYLE:ON
} else {
Assert.fail(fieldId + " has unsupported type " + testValue.getClass().getName());
}
String actualValue = fieldConfig.getStringValue();
String msg = String.format("%s Expected : '%s' Actual : '%s'", outputText, expectedValue, actualValue);
boolean condition;
if (comparingFilename(fieldId)) {
File actualFile = new File(actualValue);
File expectedFile = new File(expectedValue);
String actualFileString = actualFile.getAbsolutePath();
String expectedFileString = expectedFile.getAbsolutePath();
expectedFileString = expectedFileString.substring(expectedFileString.length() - expectedValue.length());
condition = actualFileString.endsWith(expectedFileString);
} else {
condition = (expectedValue.compareTo(actualValue) == 0);
}
Assert.assertTrue(msg, condition);
} else {
if (colourFieldsList.contains(fieldId)) {
FieldConfigColour fieldColour = (FieldConfigColour) fieldConfig;
expression = fieldColour.getColourExpression();
} else {
expression = fieldConfig.getExpression();
if (fieldId == FieldIdEnum.SYMBOL_TYPE) {
String string = expression.toString();
expression = ff.literal(string.replace(File.separatorChar, '/'));
} else if (fieldId == FieldIdEnum.FONT_FAMILY) {
// Handle the case where a font is not
// available on all operating systems
String string = expression.toString();
if (string.compareToIgnoreCase(DEFAULT_FONT) != 0) {
expression = ff.literal(getFontForOS());
// CHECKSTYLE:OFF
System.out.println("Updated font family to test for : " + expression.toString());
// CHECKSTYLE:ON
}
} else if (fieldId == FieldIdEnum.TTF_SYMBOL) {
expression = processTTFField(expression.toString());
}
}
if (expression != null) {
if (testValue instanceof XMLFieldLiteralBase) {
Object literalValue = getLiteralValue((XMLFieldLiteralBase) testValue);
if (literalValue.getClass() == Double.class) {
checkLiteralValue(outputText, expression, (Double) literalValue);
} else if (literalValue.getClass() == Integer.class) {
checkLiteralValue(outputText, expression, (Integer) literalValue);
} else if (literalValue.getClass() == String.class) {
// CHECKSTYLE:OFF
if (fieldId == FieldIdEnum.FONT_FAMILY) {
// Handle the case where a font is not
// available on all operating systems
// CHECKSTYLE:ON
checkLiteralValue(outputText, expression, getFontForOS());
} else {
checkLiteralValue(outputText, expression, (String) literalValue);
}
}
}
} else {
String actualValue;
String expectedValue = fieldConfig.getStringValue();
Object literalValue = getLiteralValue((XMLFieldLiteralBase) testValue);
if (literalValue.getClass() == Double.class) {
actualValue = String.valueOf((Double) literalValue);
} else if (literalValue.getClass() == Integer.class) {
actualValue = String.valueOf((Integer) literalValue);
} else if (literalValue.getClass() == String.class) {
actualValue = (String) literalValue;
} else {
actualValue = "";
}
String msg = String.format("%s Expected : '%s' Actual : '%s'", outputText, expectedValue, actualValue);
boolean condition = (expectedValue.compareTo(actualValue) == 0);
Assert.assertTrue(msg, condition);
}
}
}
}
}
}
}
}
}
}
}
JFrame frame = sldEditor.getApplicationFrame();
frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));
}
use of com.sldeditor.ui.detail.config.base.GroupConfigInterface in project sldeditor by robward-scisys.
the class StrokeDetails method populateStroke.
/**
* Populate stroke.
*
* @param symbolizerType the symbolizer type
* @param stroke the stroke
*/
private void populateStroke(Class<?> symbolizerType, Stroke stroke) {
Expression expColour = null;
Expression expStrokeColour = null;
Expression expOpacity = null;
Expression expStrokeWidth = null;
Expression expStrokeOffset = null;
Expression expStrokeLineCap = null;
Expression expStrokeLineJoin = null;
Expression expStrokeDashArray = null;
Expression expAnchorPointX = null;
Expression expAnchorPointY = null;
Expression expDisplacementX = null;
Expression expDisplacementY = null;
Expression expGap = null;
Expression expInitialGap = null;
Expression expSymbolSize = null;
Expression expSymbolRotation = null;
if (stroke == null) {
expColour = getFilterFactory().literal("#000000");
expOpacity = getFilterFactory().literal(1.0);
symbolTypeFactory.setSolidFill(fieldConfigManager, expColour, expOpacity);
expStrokeWidth = getFilterFactory().literal(1.0);
expStrokeOffset = getFilterFactory().literal(0.0);
expStrokeLineCap = getFilterFactory().literal("round");
expStrokeLineJoin = getFilterFactory().literal("round");
expStrokeDashArray = getFilterFactory().literal("");
} else {
Graphic graphicFill = stroke.getGraphicFill();
Graphic graphicStroke = stroke.getGraphicStroke();
if ((graphicFill == null) && (graphicStroke == null)) {
expOpacity = stroke.getOpacity();
symbolTypeFactory.setSolidFill(fieldConfigManager, stroke.getColor(), stroke.getOpacity());
}
expOpacity = stroke.getOpacity();
expStrokeWidth = stroke.getWidth();
expStrokeOffset = stroke.getDashOffset();
expStrokeLineCap = stroke.getLineCap();
expStrokeLineJoin = stroke.getLineJoin();
expColour = stroke.getColor();
List<Float> dashesArray = getStrokeDashArray(stroke);
expStrokeDashArray = getFilterFactory().literal(createDashArrayString(dashesArray));
if (graphicStroke != null) {
// Anchor points
AnchorPoint anchorPoint = graphicStroke.getAnchorPoint();
if (anchorPoint != null) {
expAnchorPointX = anchorPoint.getAnchorPointX();
expAnchorPointY = anchorPoint.getAnchorPointY();
} else {
expAnchorPointX = defaultAnchorPoint.getAnchorPointX();
expAnchorPointY = defaultAnchorPoint.getAnchorPointY();
}
// Displacement
Displacement displacement = graphicStroke.getDisplacement();
if (displacement != null) {
expDisplacementX = displacement.getDisplacementX();
expDisplacementY = displacement.getDisplacementY();
} else {
expDisplacementX = defaultDisplacement.getDisplacementX();
expDisplacementY = defaultDisplacement.getDisplacementY();
}
expGap = graphicStroke.getGap();
expInitialGap = graphicStroke.getInitialGap();
expSymbolSize = graphicStroke.getSize();
expSymbolRotation = graphicStroke.getRotation();
List<GraphicalSymbol> graphicSymbolList = graphicStroke.graphicalSymbols();
for (GraphicalSymbol graphicSymbol : graphicSymbolList) {
if (graphicSymbol instanceof MarkImpl) {
MarkImpl mark = (MarkImpl) graphicSymbol;
Mark defaultMark = getStyleFactory().getDefaultMark();
Fill markFill = mark.getFill();
if (markFill != null) {
expColour = markFill.getColor();
}
expStrokeColour = defaultMark.getStroke().getColor();
Stroke markStroke = mark.getStroke();
if (markStroke != null) {
expStrokeColour = markStroke.getColor();
}
} else if (graphicSymbol instanceof ExternalGraphicImpl) {
@SuppressWarnings("unused") ExternalGraphicImpl externalGraphic = (ExternalGraphicImpl) graphicSymbol;
}
symbolTypeFactory.setValue(symbolizerType, this.fieldConfigManager, graphicStroke, graphicSymbol);
}
}
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_WIDTH, expStrokeWidth);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_OFFSET, expStrokeOffset);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_LINE_CAP, expStrokeLineCap);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_LINE_JOIN, expStrokeLineJoin);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_DASH_ARRAY, expStrokeDashArray);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_GAP, expGap);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_INITIAL_GAP, expInitialGap);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_SIZE, expSymbolSize);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_ANGLE, expSymbolRotation);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_ANCHOR_POINT_H, expAnchorPointX);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_ANCHOR_POINT_V, expAnchorPointY);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_DISPLACEMENT_X, expDisplacementX);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_SYMBOL_DISPLACEMENT_Y, expDisplacementY);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_FILL_COLOUR, expColour);
fieldConfigVisitor.populateField(FieldIdEnum.STROKE_STROKE_COLOUR, expStrokeColour);
if ((graphicFill == null) && (graphicStroke == null)) {
GroupConfigInterface fillColourGroup = getGroup(GroupIdEnum.FILLCOLOUR);
if (fillColourGroup != null) {
fillColourGroup.enable(true);
}
}
//
// GroupConfigInterface strokeColourGroup = getGroup(GroupIdEnum.STROKECOLOUR);
// if (strokeColourGroup != null) {
// strokeColourGroup.enable(strokeColourEnabled);
// }
}
}
Aggregations