import java.util.Optional;
import org.simantics.db.Resource;
+import org.simantics.scl.runtime.function.Function1;
/**
* @author Tuukka Lehtonen
*/
public class DiagramSettings {
- public final Optional<Resource> vertexScalingProperty;
- public final double vertexScalingScale;
- public final Optional<Resource> edgeThicknessProperty;
- public final double edgeThicknessScale;
+ public final Optional<Function1<Resource, Double>> vertexScaleProperty;
+ public final double vertexScaleGain;
+ public final double vertexScaleBias;
+ public final Optional<Function1<Resource, Double>> edgeThicknessProperty;
+ public final double edgeThicknessGain;
+ public final double edgeThicknessBias;
+ public final Optional<Function1<Resource, Double>> elementColoringFunction;
+ public final float elementColoringGradientHue;
+ public final float elementColoringGradientSaturation;
+ public final transient ColorGradient coloringGradient;
- public DiagramSettings(Resource vertexScalingProperty, double vertexScalingScale, Resource edgeThicknessProperty, double edgeThicknessScale) {
- this.vertexScalingProperty = Optional.ofNullable(vertexScalingProperty);
- this.vertexScalingScale = vertexScalingScale;
+ public DiagramSettings(
+ Function1<Resource, Double> vertexScaleProperty, double vertexScaleGain, double vertexScaleBias,
+ Function1<Resource, Double> edgeThicknessProperty, double edgeThicknessGain, double edgeThicknessBias,
+ Function1<Resource, Double> elementColoringFunction,
+ float elementColoringGradientHue,
+ float elementColoringGradientSaturation
+ ) {
+ this.vertexScaleProperty = Optional.ofNullable(vertexScaleProperty);
+ this.vertexScaleGain = vertexScaleGain;
+ this.vertexScaleBias = vertexScaleBias;
this.edgeThicknessProperty = Optional.ofNullable(edgeThicknessProperty);
- this.edgeThicknessScale = edgeThicknessScale;
+ this.edgeThicknessGain = edgeThicknessGain;
+ this.edgeThicknessBias = edgeThicknessBias;
+ this.elementColoringFunction = Optional.ofNullable(elementColoringFunction);
+ this.elementColoringGradientHue = elementColoringGradientHue;
+ this.elementColoringGradientSaturation = elementColoringGradientSaturation;
+ this.coloringGradient = Colors.cached(
+ Colors.hsvGradient(
+ elementColoringGradientHue,
+ elementColoringGradientSaturation)
+ );
}
@Override
int result = 1;
result = prime * result + edgeThicknessProperty.hashCode();
long temp;
- temp = Double.doubleToLongBits(edgeThicknessScale);
+ temp = Double.doubleToLongBits(edgeThicknessGain);
result = prime * result + (int) (temp ^ (temp >>> 32));
-// result = prime * result + vertexScalingProperty.hashCode();
- temp = Double.doubleToLongBits(vertexScalingScale);
+ temp = Double.doubleToLongBits(edgeThicknessBias);
result = prime * result + (int) (temp ^ (temp >>> 32));
+ result = prime * result + vertexScaleProperty.hashCode();
+ temp = Double.doubleToLongBits(vertexScaleGain);
+ result = prime * result + (int) (temp ^ (temp >>> 32));
+ temp = Double.doubleToLongBits(vertexScaleBias);
+ result = prime * result + (int) (temp ^ (temp >>> 32));
+ result = prime * result + elementColoringFunction.hashCode();
+ result = prime * result + Float.floatToIntBits(elementColoringGradientHue);
+ result = prime * result + Float.floatToIntBits(elementColoringGradientSaturation);
return result;
}
DiagramSettings other = (DiagramSettings) obj;
if (!edgeThicknessProperty.equals(other.edgeThicknessProperty))
return false;
- if (Double.doubleToLongBits(edgeThicknessScale) != Double.doubleToLongBits(other.edgeThicknessScale))
+ if (Double.doubleToLongBits(edgeThicknessGain) != Double.doubleToLongBits(other.edgeThicknessGain))
+ return false;
+ if (Double.doubleToLongBits(edgeThicknessBias) != Double.doubleToLongBits(other.edgeThicknessBias))
+ return false;
+ if (!vertexScaleProperty.equals(other.vertexScaleProperty))
+ return false;
+ if (Double.doubleToLongBits(vertexScaleGain) != Double.doubleToLongBits(other.vertexScaleGain))
return false;
- if (!vertexScalingProperty.equals(other.vertexScalingProperty))
+ if (Double.doubleToLongBits(vertexScaleBias) != Double.doubleToLongBits(other.vertexScaleBias))
return false;
- if (Double.doubleToLongBits(vertexScalingScale) != Double.doubleToLongBits(other.vertexScalingScale))
+ if (!elementColoringFunction.equals(other.elementColoringFunction))
+ return false;
+ if (Float.floatToIntBits(elementColoringGradientHue) != Float.floatToIntBits(other.elementColoringGradientHue))
+ return false;
+ if (Float.floatToIntBits(elementColoringGradientSaturation) != Float.floatToIntBits(other.elementColoringGradientSaturation))
return false;
return true;
}
-
+ @Override
+ public String toString() {
+ return String.format("DiagramSettings[%s * %f + %f - %s * %f + %f - coloringFunction: %s, hue: %f, saturation: %f]",
+ vertexScaleProperty.toString(), vertexScaleGain, vertexScaleBias,
+ edgeThicknessProperty, edgeThicknessGain, edgeThicknessBias,
+ elementColoringFunction.toString(),
+ elementColoringGradientHue, elementColoringGradientSaturation
+ );
+ }
+
}