Dear users, Please note that, from Monday, August 16, 2019, RSA keys shorter than 2048bit will no longer be accepted for security reasons. Please update your keys as needed before this date. If you need assistance with regard to this process, please contact sia@list.lu

Thank you for your understanding.

Commit 95ff0624 authored by Nico Mack's avatar Nico Mack

Implementation of Coxcomb Graphs

NumericalVariables round to specified number of decimals
parent 17d399cf
ABOVE_ELEMENT=above
BELOW_ELEMENT=below
BLINK_ON_OUT_OF_RANGE_NODE=blinkOnOutOfRange
CAPPED_DISPLAY_NODE=cappedDisplay
ITEMS_VARIABLE_NODE=itemsVariable
LABEL_NODE=label
LOWER_BOUND_RADIUS_NODE=lowerBoundRadius
LOWER_BOUND_VARIABLE_NODE=lowerBoundVariable
LOWER_STOP_ANGLE_NODE=lowerStopAngle
MAXIMUM_VALUE_NODE=maximumValue
MINIMUM_VALUE_NODE=minimumValue
MODIFY_VALUE_ON_ROTATION_NODE=modifyValueOnRotation
RADIAL_LAYOUT_NODE=radialLayout
REFERENCE_NODE=reference
RELATIVE_NODE=relative
SELECTED_ITEMS_VARIABLE_NODE=selectedItemsVariable
SELECTED_RADIUS_NODE=selectedRadius
STEP_SIZE_NODE=stepSize
UPPER_BOUND_RADIUS_NODE=upperBoundRadius
UPPER_BOUND_VARIABLE_NODE=upperBoundVariable
UPPER_STOP_ANGLE_NODE=upperStopAngle
VARIABLE_NODE=variable
......
/**
* Copyright Luxembourg Institute of Science and Technology, 2017. All rights reserved. If you wish
* to use this code for any purpose, please contact the author(s).
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package lu.list.itis.dkd.tui.bootstrapping;
import lu.list.itis.dkd.tui.cps.InputChangeListener;
import lu.list.itis.dkd.tui.cps.system.VariableBased;
import lu.list.itis.dkd.tui.cps.variable.Variable;
import lu.list.itis.dkd.tui.cps.variable.VectorVariable;
import lu.list.itis.dkd.tui.exception.BuildException;
import lu.list.itis.dkd.tui.utility.ColorFactory;
import lu.list.itis.dkd.tui.utility.Templating;
import lu.list.itis.dkd.tui.widget.BaseWidget;
import org.jdom2.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.Color;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author Nico Mack [nico.mack@list.lu]
* @since 1.5
* @version 1.5.0
*/
// ***************************************************************************
// * Class Definition and Members *
// ***************************************************************************
public class VectorBasedBootstrapper implements BootstrapCallback {
private List<VectorVariable<?>> variables;
private List<Color> indexColours;
private Integer index;
private Integer size;
// ***************************************************************************
// * Constants *
// ***************************************************************************
private static final Logger LOGGER = LoggerFactory.getLogger(VectorBasedBootstrapper.class.getName());
// ---------------------------------------------------------------------------
// ***************************************************************************
// * Constructor(s) *
// ***************************************************************************
// ---------------------------------------------------------------------------
public VectorBasedBootstrapper(List<VectorVariable<?>> variables) {
size = -1;
this.variables = variables;
for (VectorVariable<?> variable : variables) {
if (size < 0)
size = variable.size();
if (variable.size() != size) {
LOGGER.error("Size of vector {} is {} and differs from size of other vectors which is {}!", variable.getName(), variable.size(), size); //$NON-NLS-1$
}
}
this.indexColours = ColorFactory.makeRainbowColours(size);
}
// ---------------------------------------------------------------------------
// ***************************************************************************
// * Class Body *
// ***************************************************************************
// ---------------------------------------------------------------------------
public List<BaseWidget> buildWidgetsFromVariables(Element template, Integer widgetId, BootstrapContext context, BootstrapCallback callback) throws BuildException {
List<BaseWidget> widgets = null;
Map<String, Variable<?>> systemVariables = new HashMap<>();
index = 0;
context.setProperty(Templating.HANDLE_ID_PROPERTY, widgetId);
context.setProperty(Templating.SIZE_OF_VECTORS_PROPERTY, size);
for (Variable<?> systemVariable : variables) {
systemVariables.put(systemVariable.getName(), systemVariable);
}
if (size > 0) {
widgets = TangibleObjectBootstrapper.buildWidgetFromTemplate(template, context, this);
for (BaseWidget widget : widgets) {
List<Variable<?>> connected;
if (widget.getClass().isAssignableFrom(VariableBased.class)) {
VariableBased display = (VariableBased) widget;
connected = display.connectWithSystemVariables(systemVariables);
if (widget.getClass().isAssignableFrom(InputChangeListener.class)) {
InputChangeListener listener = (InputChangeListener) widget;
for (Variable<?> connectedVariable : connected)
connectedVariable.addListener(listener);
}
}
}
} else {
LOGGER.warn("Encountered a Widget without any variables. Won't build Widget! ID of offending Widget is {}", widgetId); //$NON-NLS-1$
}
return widgets;
}
// ---------------------------------------------------------------------------
/** {@inheritDoc} */
@Override
public BootstrapContext preInstantiation(Element node, BootstrapContext context) {
for (VectorVariable<?> variable : variables) {
context.setProperty(variable.getName(), variable.get(index));
}
Color colour = indexColours.get(index);
context.setProperty(Templating.INDEX_COLOUR_PROPERTY, colour.getRGB());
return context;
}
// ---------------------------------------------------------------------------
/** {@inheritDoc} */
@Override
public BootstrapContext postInstantiation(Element node, BootstrapContext context) {
return context;
}
// ---------------------------------------------------------------------------
/** {@inheritDoc} */
@Override
public BootstrapContext next(BootstrapContext context) {
if (index < size) {
this.index++;
}
return context;
}
// ---------------------------------------------------------------------------
/** {@inheritDoc} */
@Override
public BootstrapContext reset(BootstrapContext context) {
this.index = 0;
return context;
}
// ---------------------------------------------------------------------------
}
......@@ -56,6 +56,8 @@ public class NumericalVariable extends Variable<Double> {
protected double epsilon;
private DecimalFormat format;
private double roundingFactor;
// ***************************************************************************
// * Constants *
......@@ -97,6 +99,7 @@ public class NumericalVariable extends Variable<Double> {
valueRange = getValueRange(minValue, maxValue);
epsilon = DEFAULT_EPSILON;
scale = 1;
roundingFactor = 1;
}
// ---------------------------------------------------------------------------
......@@ -111,11 +114,11 @@ public class NumericalVariable extends Variable<Double> {
* specifies the lower value bound.
* @param upperValue
* specifies the upper value bound.
* @return the value range determined as the difference between the true upper bound and the
* true lower bound. This means that in case maxValue would be inferior to minValue,
* minValue and maxValue will be swapped. In case one of the specified values is still
* set to ± Double.MAX_VALUE the returned value will be Double.MAX_VALUE since the range
* can't be determined.
* @return the value range determined as the difference between the true upper bound and the true
* lower bound. This means that in case maxValue would be inferior to minValue, minValue and
* maxValue will be swapped. In case one of the specified values is still set to ±
* Double.MAX_VALUE the returned value will be Double.MAX_VALUE since the range can't be
* determined.
*/
// ---------------------------------------------------------------------------
......@@ -137,7 +140,7 @@ public class NumericalVariable extends Variable<Double> {
// ---------------------------------------------------------------------------
private double normalizeValue(double newValue) {
double noramlized = 0;
double normalized = 0;
if (this.valueRange == Double.MAX_VALUE) {
this.valueRange = this.getValueRange(this.minValue, this.maxValue);
......@@ -151,9 +154,9 @@ public class NumericalVariable extends Variable<Double> {
else if (val > this.maxValue)
val = this.maxValue;
noramlized = (val - this.minValue) / this.valueRange;
normalized = (val - this.minValue) / this.valueRange;
}
return noramlized;
return normalized;
}
// ---------------------------------------------------------------------------
......@@ -167,6 +170,12 @@ public class NumericalVariable extends Variable<Double> {
return builder.toString();
}
// ---------------------------------------------------------------------------
private double roundToPrecision(double rawValue) {
return Math.round(rawValue * this.roundingFactor) / this.roundingFactor;
}
// ---------------------------------------------------------------------------
// ***************************************************************************
// * Class Body *
......@@ -194,8 +203,8 @@ public class NumericalVariable extends Variable<Double> {
* specifies whether or not to display the capped value, i.e. the constrained value being
* minValue <= x <= maxValue, or the raw Value. Specify <code>true</code> to display the
* capped value or <code>false</code> for the raw value
* @return a string showing the name of the variable, its value (either capped or not) and its
* unit if defined.
* @return a string showing the name of the variable, its value (either capped or not) and its unit
* if defined.
*/
// ---------------------------------------------------------------------------
......@@ -257,7 +266,7 @@ public class NumericalVariable extends Variable<Double> {
@Override
public void setValue(Double newValue) {
double val = (newValue != null) ? newValue + 0.0d : 0d; // Avoid -0.0 values
double val = (newValue != null) ? roundToPrecision(newValue) + 0.0d : 0d; // Avoid -0.0 values
this.normalizedValue = this.normalizeValue(val);
this.modified = ((newValue != null) && (!isEqual(newValue, this.value, this.epsilon)));
......@@ -415,6 +424,7 @@ public class NumericalVariable extends Variable<Double> {
public void setNumberOfDecimals(int decimals) {
this.format.setMaximumFractionDigits(decimals);
this.roundingFactor = Math.pow(10, decimals);
}
// ---------------------------------------------------------------------------
......
......@@ -20,6 +20,7 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
import java.util.regex.Pattern;
......@@ -33,12 +34,11 @@ import java.util.regex.Pattern;
// * Class Definition and Members *
// ***************************************************************************
public class VectorVariable<B> extends Variable<List<B>> implements Collection<B> {
public class VectorVariable<B> extends Variable<List<B>> implements List<B> {
private static final Pattern VECTOR_PATTERN = Pattern.compile("\\[\\s*(.*?)\\s*\\]", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$
private static final Pattern VECTOR_SPLITTER_PATTERN = Pattern.compile("([+-]?[a-z0-9\\._]+)(\\s*,[+-]?[a-z0-9\\._]+)*", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$
// ---------------------------------------------------------------------------
// ***************************************************************************
// * Constructor(s) *
......@@ -172,6 +172,66 @@ public class VectorVariable<B> extends Variable<List<B>> implements Collection<B
return value.retainAll(c);
}
/** {@inheritDoc} */
@Override
public boolean addAll(int index, Collection<? extends B> c) {
return value.addAll(index, c);
}
/** {@inheritDoc} */
@Override
public B get(int index) {
return value.get(index);
}
/** {@inheritDoc} */
@Override
public B set(int index, B element) {
return value.set(index, element);
}
/** {@inheritDoc} */
@Override
public void add(int index, B element) {
value.add(index, element);
}
/** {@inheritDoc} */
@Override
public B remove(int index) {
return value.remove(index);
}
/** {@inheritDoc} */
@Override
public int indexOf(Object o) {
return value.indexOf(o);
}
/** {@inheritDoc} */
@Override
public int lastIndexOf(Object o) {
return value.lastIndexOf(o);
}
/** {@inheritDoc} */
@Override
public ListIterator<B> listIterator() {
return value.listIterator();
}
/** {@inheritDoc} */
@Override
public ListIterator<B> listIterator(int index) {
return value.listIterator(index);
}
/** {@inheritDoc} */
@Override
public List<B> subList(int fromIndex, int toIndex) {
return value.subList(fromIndex, toIndex);
}
/** {@inheritDoc} */
@Override
public void clear() {
......@@ -213,4 +273,6 @@ public class VectorVariable<B> extends Variable<List<B>> implements Collection<B
// TODO Auto-generated method stub
return null;
}
}
......@@ -28,11 +28,15 @@ public class CpsNamespace extends NLS {
public static String ABOVE_ELEMENT;
public static String BELOW_ELEMENT;
public static String BLINK_ON_OUT_OF_RANGE_NODE;
public static String CAPPED_DISPLAY_NODE;
public static String ITEMS_VARIABLE_NODE;
public static String LABEL_NODE;
public static String LOWER_BOUND_RADIUS_NODE;
public static String LOWER_BOUND_VARIABLE_NODE;
public static String LOWER_STOP_ANGLE_NODE;
......@@ -40,6 +44,7 @@ public class CpsNamespace extends NLS {
public static String MINIMUM_VALUE_NODE;
public static String MODIFY_VALUE_ON_ROTATION_NODE;
public static String RADIAL_LAYOUT_NODE;
public static String REFERENCE_NODE;
public static String RELATIVE_NODE;
......@@ -47,6 +52,7 @@ public class CpsNamespace extends NLS {
public static String SELECTED_RADIUS_NODE;
public static String STEP_SIZE_NODE;
public static String UPPER_BOUND_RADIUS_NODE;
public static String UPPER_BOUND_VARIABLE_NODE;
public static String UPPER_STOP_ANGLE_NODE;
......
......@@ -4,7 +4,7 @@ import lu.list.itis.dkd.tui.content.InformationReceiver;
import lu.list.itis.dkd.tui.cps.system.VariableBased;
import lu.list.itis.dkd.tui.cps.variable.NumericalVariable;
import lu.list.itis.dkd.tui.cps.variable.Variable;
import lu.list.itis.dkd.tui.widget.corona.builder.ValueCoronaBuilder;
import lu.list.itis.dkd.tui.widget.corona.builder.BaseValueCoronaBuilder;
import org.python.google.common.base.Preconditions;
......@@ -35,7 +35,7 @@ public class ValueCorona extends SelectableCorona implements InformationReceiver
// ***************************************************************************
// ---------------------------------------------------------------------------
public ValueCorona(ValueCoronaBuilder<?> builder) {
public ValueCorona(BaseValueCoronaBuilder<?> builder) {
super(builder);
this.variable = builder.variable;
}
......
......@@ -17,14 +17,12 @@ import lu.list.itis.dkd.dbc.annotation.Nullable;
import lu.list.itis.dkd.tui.bootstrapping.BootstrapCallback;
import lu.list.itis.dkd.tui.bootstrapping.BootstrapContext;
import lu.list.itis.dkd.tui.bootstrapping.BootstrappingUtils;
import lu.list.itis.dkd.tui.bootstrapping.VariableBootstrapper;
import lu.list.itis.dkd.tui.cps.variable.VectorVariable;
import lu.list.itis.dkd.tui.exception.BuildException;
import lu.list.itis.dkd.tui.utility.ColorPair;
import lu.list.itis.dkd.tui.utility.CpsNamespace;
import lu.list.itis.dkd.tui.utility.Externalization;
import lu.list.itis.dkd.tui.utility.Point;
import lu.list.itis.dkd.tui.widget.corona.ItemFan;
import lu.list.itis.dkd.tui.widget.corona.CoxcombSlice;
import org.jdom2.Element;
......@@ -40,24 +38,30 @@ import java.awt.Font;
// * Class Definition and Members *
// ***************************************************************************
public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extends BaseSelectableCoronaBuilder<B> {
public abstract class BaseCoxcombSliceBuilder<B extends BaseCoxcombSliceBuilder<B>> extends BaseValueCoronaBuilder<B> {
public VectorVariable<?> itemsVariable;
public VectorVariable<?> selectedItemsVariable;
public String label;
public boolean radialLayout;
public boolean blinkOnOutOfRange;
public double innerRadius;
public double outerRadius;
public double selectedRadius;
public double lowerBoundRadius;
public double upperBoundRadius;
public double startAngle;
public double arcSpan;
public ColorPair fillColour;
public ColorPair strokeColour;
public ColorPair textColour;
public ColorPair faceColour;
public ColorPair bezelColour;
public Font textFont;
public int strokeWidth;
public boolean cappedDisplay;
public int rampingTime;
// ---------------------------------------------------------------------------
// ***************************************************************************
// * Constructor(s) *
......@@ -68,7 +72,7 @@ public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extend
*/
// ---------------------------------------------------------------------------
protected BaseItemFanBuilder(Point centre) {
protected BaseCoxcombSliceBuilder(Point centre) {
super(centre);
}
......@@ -79,7 +83,7 @@ public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extend
*/
// ---------------------------------------------------------------------------
public BaseItemFanBuilder(Element rootElement) throws BuildException {
public BaseCoxcombSliceBuilder(Element rootElement) throws BuildException {
super(rootElement);
this.buildFromBootstrap(rootElement, null, null);
}
......@@ -93,7 +97,7 @@ public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extend
*/
// ---------------------------------------------------------------------------
public BaseItemFanBuilder(Element rootElement, BootstrapContext context, BootstrapCallback callback) throws BuildException {
public BaseCoxcombSliceBuilder(Element rootElement, BootstrapContext context, BootstrapCallback callback) throws BuildException {
super(rootElement, context, callback);
this.buildFromBootstrap(rootElement, context, callback);
}
......@@ -106,26 +110,31 @@ public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extend
protected void buildFromBootstrap(@Nullable Element rootElement, BootstrapContext context, BootstrapCallback callback) throws BuildException {
Element variablesElement = rootElement.getChild(CpsNamespace.VARIABLES_NODE);
if (variablesElement != null) {
itemsVariable = (VectorVariable<?>) VariableBootstrapper.buildVariableFromElement(variablesElement.getChild(CpsNamespace.ITEMS_VARIABLE_NODE), context, callback);
selectedItemsVariable = (VectorVariable<?>) VariableBootstrapper.buildVariableFromElement(variablesElement.getChild(CpsNamespace.SELECTED_ITEMS_VARIABLE_NODE), context, callback);
}
startAngle = BootstrappingUtils.getContentAsInteger(rootElement, Externalization.START_ANGLE_NODE, BootstrappingUtils.MANDATORY, null, context);
arcSpan = BootstrappingUtils.getContentAsInteger(rootElement, Externalization.ARC_SPAN_NODE, BootstrappingUtils.MANDATORY, null, context);
innerRadius = BootstrappingUtils.getContentAsDouble(rootElement, Externalization.INNER_RADIUS_NODE, BootstrappingUtils.MANDATORY, null, context);
outerRadius = BootstrappingUtils.getContentAsDouble(rootElement, Externalization.OUTER_RADIUS_NODE, BootstrappingUtils.MANDATORY, null, context);
selectedRadius = BootstrappingUtils.getContentAsDouble(rootElement, CpsNamespace.SELECTED_RADIUS_NODE, BootstrappingUtils.OPTIONAL, outerRadius, context);
upperBoundRadius = BootstrappingUtils.getContentAsDouble(rootElement, CpsNamespace.UPPER_BOUND_RADIUS_NODE, BootstrappingUtils.MANDATORY, null, context);
lowerBoundRadius = BootstrappingUtils.getContentAsDouble(rootElement, CpsNamespace.LOWER_BOUND_RADIUS_NODE, BootstrappingUtils.MANDATORY, null, context);
fillColour = buildColorPair(rootElement.getChild(Externalization.FILL_COLOUR_ELEMENT), BootstrappingUtils.MANDATORY, context);
strokeColour = buildColorPair(rootElement.getChild(Externalization.STROKE_COLOUR_ELEMENT), BootstrappingUtils.MANDATORY, context);
/** Optional fields */
label = BootstrappingUtils.getContentAsString(rootElement, CpsNamespace.LABEL_NODE, BootstrappingUtils.OPTIONAL, Externalization.EMPTY_STRING, context);
radialLayout = BootstrappingUtils.getContentAsBoolean(rootElement, CpsNamespace.RADIAL_LAYOUT_NODE, BootstrappingUtils.OPTIONAL, Boolean.FALSE, context);
cappedDisplay = BootstrappingUtils.getContentAsBoolean(rootElement, CpsNamespace.CAPPED_DISPLAY_NODE, BootstrappingUtils.OPTIONAL, Boolean.FALSE, context);
blinkOnOutOfRange = BootstrappingUtils.getContentAsBoolean(rootElement, CpsNamespace.BLINK_ON_OUT_OF_RANGE_NODE, BootstrappingUtils.OPTIONAL, Boolean.FALSE, context);
strokeWidth = BootstrappingUtils.getContentAsInteger(rootElement, Externalization.STROKE_WIDTH_NODE, BootstrappingUtils.OPTIONAL, 1, context);
rampingTime = BootstrappingUtils.getContentAsInteger(rootElement, Externalization.RAMPING_TIME_NODE, BootstrappingUtils.OPTIONAL, 500, context);
fillColour = buildColorPair(rootElement.getChild(Externalization.FILL_COLOUR_ELEMENT), BootstrappingUtils.MANDATORY, context);
textColour = buildColorPair(rootElement.getChild(Externalization.TEXT_COLOUR_ELEMENT), BootstrappingUtils.OPTIONAL, context);
strokeColour = buildColorPair(rootElement.getChild(Externalization.STROKE_COLOUR_ELEMENT), BootstrappingUtils.MANDATORY, context);
faceColour = buildColorPair(rootElement.getChild(Externalization.FACE_COLOUR_ELEMENT), BootstrappingUtils.OPTIONAL, context);
bezelColour = buildColorPair(rootElement.getChild(Externalization.BEZEL_COLOUR_ELEMENT), BootstrappingUtils.OPTIONAL, context);
String fontName = BootstrappingUtils.getContentAsString(rootElement, Externalization.FONT_NODE, BootstrappingUtils.OPTIONAL, "Monospaced"); //$NON-NLS-1$
Integer fontSize = BootstrappingUtils.getContentAsInteger(rootElement, Externalization.FONT_SIZE_NODE, BootstrappingUtils.OPTIONAL, 14);
......@@ -156,7 +165,7 @@ public abstract class BaseItemFanBuilder<B extends BaseItemFanBuilder<B>> extend
// ---------------------------------------------------------------------------
@Override
public abstract ItemFan build();
public abstract CoxcombSlice build();
// ---------------------------------------------------------------------------
......
......@@ -4,7 +4,7 @@ import lu.list.itis.dkd.tui.bootstrapping.BootstrapCallback;
import lu.list.itis.dkd.tui.bootstrapping.BootstrapContext;
import lu.list.itis.dkd.tui.exception.BuildException;
import lu.list.itis.dkd.tui.utility.Point;
import lu.list.itis.dkd.tui.widget.corona.ItemFan;
import lu.list.itis.dkd.tui.widget.corona.CoxcombSlice;
import org.jdom2.Element;
......@@ -18,7 +18,7 @@ import org.jdom2.Element;
// * Class Definition and Members *
// ***************************************************************************
public class ItemFanBuilder<B extends ItemFanBuilder<B>> extends BaseItemFanBuilder<B> {
public class CoxcombSliceBuilder<B extends CoxcombSliceBuilder<B>> extends BaseCoxcombSliceBuilder<B> {
// ***************************************************************************
// * Constants *
......@@ -30,15 +30,15 @@ public class ItemFanBuilder<B extends ItemFanBuilder<B>> extends BaseItemFanBuil
// ***************************************************************************
// ---------------------------------------------------------------------------
public ItemFanBuilder(Point centre) {
public CoxcombSliceBuilder(Point centre) {
super(centre);
}
public ItemFanBuilder(Element rootElement) throws BuildException {
public CoxcombSliceBuilder(Element rootElement) throws BuildException {
super(rootElement);
}
public ItemFanBuilder(Element rootElement, BootstrapContext context, BootstrapCallback callback) throws BuildException {
public CoxcombSliceBuilder(Element rootElement, BootstrapContext context, BootstrapCallback callback) throws BuildException {
super(rootElement, context, callback);
}
......@@ -55,8 +55,8 @@ public class ItemFanBuilder<B extends ItemFanBuilder<B>> extends BaseItemFanBuil
// ---------------------------------------------------------------------------
@Override
public ItemFan build() {
return new ItemFan(this);
public CoxcombSlice build() {
return new CoxcombSlice(this);
}
// ---------------------------------------------------------------------------
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment