protected void increaseValue(int step) {
if (step == 0) return;
String value = getText();
Number newValue = numberType.increaseValue(value, step);
if (newValue == null || maxConstrained && newValue.intValue() > max) {
return;
}
setValue(numberType.formatValue(newValue));
}
public boolean equal(WeaCValue a, WeaCValue b) {
if (a.getValue() instanceof Boolean && b.getValue() instanceof Boolean)
return a.getValue() == b.getValue();
if (a.type == this && b.type == this) {
return a.getValue() == b.getValue();
} else if (a.type == this) {
return ((int) NumberType.convert(b.getValue(), WeaCType.intType) != 0)
== (boolean) a.getValue();
} else if (b.type == this) {
return ((int) NumberType.convert(a.getValue(), WeaCType.intType) != 0)
== (boolean) b.getValue();
}
return false;
}
private boolean addValueMapEntry(
@Nullable Number lower, @Nullable Number upper, String newValue) {
if (!numberType.addValueMapEntry(derivationHelper, lower, upper, newValue)) {
fireEvent(NotificationEvent.newBuilder().error(translations.rangeOverlap()).build());
return false;
}
return true;
}
private static ValueType newValueType(
Map<Type, ValueType> typeMap, Type type, Class declaringClass, Class compositeType) {
ValueType valueType = null;
if (CollectionType.isCollection(type)) {
if (type instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) type;
Type collectionType = pt.getActualTypeArguments()[0];
if (collectionType instanceof TypeVariable) {
TypeVariable collectionTypeVariable = (TypeVariable) collectionType;
collectionType =
Classes.resolveTypeVariable(collectionTypeVariable, declaringClass, compositeType);
}
ValueType collectedType =
newValueType(typeMap, collectionType, declaringClass, compositeType);
valueType = new CollectionType(nameOf(type), collectedType);
} else {
valueType =
new CollectionType(
nameOf(type), newValueType(typeMap, Object.class, declaringClass, compositeType));
}
} else if (ValueCompositeType.isValueComposite(type)) {
if (typeMap != null) {
valueType = typeMap.get(type);
}
if (valueType == null) {
Class valueTypeClass = Classes.getRawClass(type);
List<PropertyType> types = new ArrayList<PropertyType>();
valueType = new ValueCompositeType(nameOf(valueTypeClass), types);
if (typeMap == null) {
typeMap = new HashMap<Type, ValueType>();
}
typeMap.put(type, valueType);
addProperties(typeMap, valueTypeClass, compositeType, types);
Collections.sort(types); // Sort by property name
}
} else if (EnumType.isEnum(type)) {
valueType = new EnumType(nameOf(type));
} else if (StringType.isString(type)) {
valueType = new StringType();
} else if (NumberType.isNumber(type)) {
valueType = new NumberType(nameOf(type));
} else if (BooleanType.isBoolean(type)) {
valueType = new BooleanType();
} else if (DateType.isDate(type)) {
valueType = new DateType();
} else if (EntityReferenceType.isEntityReference(type)) {
valueType = new EntityReferenceType(nameOf(type));
} else {
// TODO: shouldn't we check that the type is a Serializable?
valueType = new SerializableType(nameOf(type));
}
return valueType;
}
/**
* Creates a new RangeSeekBar.
*
* @param absoluteMinValue The minimum value of the selectable range.
* @param absoluteMaxValue The maximum value of the selectable range.
* @param context
* @throws IllegalArgumentException Will be thrown if min/max value type is not one of Long,
* Double, Integer, Float, Short, Byte or BigDecimal.
*/
public RangeSeekBar(T absoluteMinValue, T absoluteMaxValue, Context context)
throws IllegalArgumentException {
super(context);
this.absoluteMinValue = absoluteMinValue;
this.absoluteMaxValue = absoluteMaxValue;
absoluteMinValuePrim = absoluteMinValue.doubleValue();
absoluteMaxValuePrim = absoluteMaxValue.doubleValue();
numberType = NumberType.fromNumber(absoluteMinValue);
}
@SuppressWarnings("MethodOnlyUsedFromInnerClass")
private boolean addValueMapEntry(@Nullable String value, String newValue) {
if (derivationHelper.hasValueMapEntryWithValue(value)) {
fireEvent(NotificationEvent.newBuilder().error(translations.valueMapAlreadyAdded()).build());
return false;
}
numberType.addValueMapEntry(derivationHelper, value, newValue);
return true;
}
@Override
public void setValue(String value, boolean fireEvents) {
try {
Number newValue = numberType.parseValue(value);
if (newValue == null
|| maxConstrained && newValue.intValue() > max
|| minConstrained && newValue.intValue() < min) {
return;
}
String prevText = getValue();
setText(numberType.formatValue(newValue));
if (fireEvents) {
ValueChangeEvent.fireIfNotEqual(this, getValue(), prevText);
}
} catch (Exception ex) {
// Do Nothing
}
}
protected void invokeObject(Object obj, Object value)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
if (_type.isEnum()) {
if (value instanceof Enum) _setter.invoke(obj, new Object[] {value});
else
_setter.invoke(
obj, new Object[] {Enum.valueOf((Class<? extends Enum>) _type, value.toString())});
} else if (_numberType != null && value instanceof Number) {
_setter.invoke(obj, new Object[] {_numberType.getActualValue((Number) value)});
} else if (Character.TYPE.equals(_type) || Character.class.equals(_type)) {
_setter.invoke(obj, new Object[] {String.valueOf(value).charAt(0)});
} else if (_componentType != null && value.getClass().isArray()) {
if (_numberType == null) {
int len = Array.getLength(value);
Object array = Array.newInstance(_componentType, len);
try {
System.arraycopy(value, 0, array, 0, len);
} catch (Exception e) {
// unusual array with multiple types
LOG.ignore(e);
_setter.invoke(obj, new Object[] {value});
return;
}
_setter.invoke(obj, new Object[] {array});
} else {
Object[] old = (Object[]) value;
Object array = Array.newInstance(_componentType, old.length);
try {
for (int i = 0; i < old.length; i++)
Array.set(array, i, _numberType.getActualValue((Number) old[i]));
} catch (Exception e) {
// unusual array with multiple types
LOG.ignore(e);
_setter.invoke(obj, new Object[] {value});
return;
}
_setter.invoke(obj, new Object[] {array});
}
} else _setter.invoke(obj, new Object[] {value});
}
/**
* Creates a new RangeSeekBar.
*
* @param absoluteMinValue The minimum value of the selectable range.
* @param absoluteMaxValue The maximum value of the selectable range.
* @param context
* @throws IllegalArgumentException Will be thrown if min/max value type is not one of Long,
* Double, Integer, Float, Short, Byte or BigDecimal.
*/
public RangeSeekBar(T absoluteMinValue, T absoluteMaxValue, Context context)
throws IllegalArgumentException {
super(context);
this.absoluteMinValue = absoluteMinValue;
this.absoluteMaxValue = absoluteMaxValue;
absoluteMinValuePrim = absoluteMinValue.doubleValue();
absoluteMaxValuePrim = absoluteMaxValue.doubleValue();
numberType = NumberType.fromNumber(absoluteMinValue);
// make RangeSeekBar focusable. This solves focus handling issues in case EditText widgets are
// being used along with the RangeSeekBar within ScollViews.
setFocusable(true);
setFocusableInTouchMode(true);
init();
}
public enum NumberType {
UNKNOWN(0),
TEL(1),
SIP(2),
IP(2),
RING(3);
private final int type;
NumberType(int t) {
type = t;
}
private static final NumberType[] VALS = NumberType.values();
public static NumberType fromInteger(int _id) {
for (NumberType v : VALS) if (v.type == _id) return v;
return UNKNOWN;
}
}
private void newDerivationHelper() {
numberType = NumberType.valueOf(getOriginalVariable().getValueType().toUpperCase());
derivationHelper =
numberType.newDerivationHelper(getOriginalVariable(), getDerivedVariable());
}
public void setNumberType(String type) {
numberType = NumberType.valueOf(type.toUpperCase());
}
@Nullable
@SuppressWarnings("unchecked")
public <T extends Number> T getNumberValue() {
if (getText().isEmpty()) return null;
return (T) numberType.parseValue(getValue());
}
public void setType(int type) {
this.ntype = NumberType.fromInteger(type);
}
private void readFromParcel(Parcel in) {
ntype = NumberType.fromInteger(in.readInt());
number = in.readParcelable(SipUri.class.getClassLoader());
category = in.readInt();
}
@Override
public boolean isValidInstance(QuantityUnit value) {
return quantityType.isValidInstance(value.quantity) && unitType.isValidInstance(value.unit);
}
/**
* Converts a normalized value to a Number object in the value space between absolute minimum and
* maximum.
*
* @param normalized
* @return
*/
@SuppressWarnings("unchecked")
private T normalizedToValue(double normalized) {
return (T)
numberType.toNumber(
absoluteMinValuePrim + normalized * (absoluteMaxValuePrim - absoluteMinValuePrim));
}
/**
* Converts a normalized value to a Number object in the value space between absolute minimum and
* maximum.
*/
@SuppressWarnings("unchecked")
private T normalizedToValue(double normalized) {
double v = absoluteMinValuePrim + normalized * (absoluteMaxValuePrim - absoluteMinValuePrim);
// TODO parameterize this rounding to allow variable decimal points
return (T) numberType.toNumber(Math.round(v * 100) / 100d);
}
private void setValuePrimAndNumberType() {
absoluteMinValuePrim = absoluteMinValue.doubleValue();
absoluteMaxValuePrim = absoluteMaxValue.doubleValue();
numberType = NumberType.fromNumber(absoluteMinValue);
}
