javafx.beans.property.Property Java Examples

public GroupAndDatasetStructure(
		final String groupPromptText,
		final String datasetPromptText,
		final Property<String> group,
		final Property<String> dataset,
		final ObservableList<String> datasetChoices,
		final ObservableValue<Boolean> isDropDownReady,
		final BiFunction<String, Scene, String> onBrowseClicked)
{
	super();
	this.groupPromptText = groupPromptText;
	this.datasetPromptText = datasetPromptText;
	this.group = group;
	this.dataset = dataset;
	this.datasetChoices = datasetChoices;
	this.isDropDownReady = isDropDownReady;
	this.onBrowseClicked = onBrowseClicked;
}
 

public GenericRootAndDatasetStructure(
		final String datasetPromptText,
		final Property<T> group,
		final Property<String> dataset,
		final ObservableList<String> datasetChoices,
		final ObservableValue<Boolean> isDropDownReady,
		final Consumer<Scene> onBrowseClicked,
		final Supplier<Node> groupNode)
{
	super();
	this.datasetPromptText = datasetPromptText;
	this.dataset = dataset;
	this.datasetChoices = datasetChoices;
	this.isDropDownReady = isDropDownReady;
	this.onBrowseClicked = onBrowseClicked;
	this.rootNode = groupNode;
	this.node = createNode();
}
 

@Test
public void simpleAvgBinding() {
  Property<Double> a = new SimpleObjectProperty<>();
  Property<Double> b = new SimpleObjectProperty<>();
  Property<Double>[] properties = new Property[] {a, b};
  Property<Double> avg = new SimpleObjectProperty<>();

  ObjectBinding<Double> avgBinding = Bindings.createObjectBinding(() -> {
    double sum = 0;
    int n = 0;
    for (Property<Double> p : properties) {
      if (p.getValue() != null) {
        sum += p.getValue().doubleValue();
        n++;
      }
    }
    return n == 0 ? 0 : sum / n;
  }, properties);
  avg.bind(avgBinding);
  logger.info("avg=" + avg.getValue().doubleValue() + "   " + avg.getValue());
  a.setValue(10d);
  logger.info("avg=" + avg.getValue().doubleValue() + "   " + avg.getValue());
  b.setValue(5d);
  logger.info("avg=" + avg.getValue().doubleValue() + "   " + avg.getValue());
}
 

@SuppressWarnings("unchecked")
public static <T> StringConverter<T> get(Property<T> p)
{
	if(p instanceof BooleanProperty)
	{
		return (StringConverter<T>)BOOLEAN();
	}
	else if(p instanceof IntegerProperty)
	{
		return (StringConverter<T>)INT();
	}
	else if(p instanceof DoubleProperty)
	{
		return (StringConverter<T>)NUMBER_DOUBLE();
	}
	else if(p instanceof StringProperty)
	{
		return (StringConverter<T>)STRING();
	}
	else
	{
		throw new Error("?" + p);
	}
}
 

private void addDeclaredProperties() {
	Object bean = getBean();
	if (bean == null) return;

	for (Method method : bean.getClass().getDeclaredMethods()) {
		if (method.getName().endsWith("Property") && Property.class.isAssignableFrom(method.getReturnType())
			&& !DirtyState.class.isAssignableFrom(method.getReturnType())) {
			try {
				Property property = (Property) method.invoke(bean);
				if (property != null)
					properties.add(property);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
	}
}
 

@SuppressWarnings("SuspiciousMethodCalls")
public void changed(ObservableValue property, Object oldValue, Object newValue) {
 if (dirtyProperties.contains(property)) {
  // Remove dirty state if newValue equals inititalValue
  if (Objects.equals(initialValues.get(property), newValue))
   dirtyProperties.remove(property);

  // If no other properties dirty, remove dirty state
  if (dirtyProperties.isEmpty() && isDirty())
   setValue(false);
 } else {
  // Configure initital value and add to dirty property list
  initialValues.put((Property) property, oldValue);
  dirtyProperties.add((Property) property);

  // Only trigger dirty state change if previously clean
  if (!isDirty())
   setValue(true);
 }

}
 

@Override
public void changed(ObservableValue observable, Object oldValue, Object newValue) {
	if(observable instanceof Property) {
		Property prop = (Property) observable;
		if(prop.getBean() instanceof Node) {
			Node node = (Node) prop.getBean();
			switch (node.getId()) {
				case ps_case:
					opt.SetPageSearchCaseSensitive((boolean) newValue);
				break;
				case ps_separate:
					opt.SetPageSearchSeparateWord((boolean) newValue);
				break;
				case regex_head:
					opt.SetRegexSearchEngineAutoAddHead((boolean) newValue);
				break;
				case regex_case:
					opt.SetRegexSearchEngineCaseSensitive((boolean) newValue);
				break;
				case page_regex_case:
					opt.SetPageSearchCaseSensitive((boolean) newValue);
				break;
				case pagewutsp:
					opt.SetPageWithoutSpace((boolean)newValue);
				break;
			}
		}
	}
}
 

static <T> SuspendableVar<T> suspendable(Property<T> p) {
    if(p instanceof SuspendableVar) {
        return (SuspendableVar<T>) p;
    } else {
        Var<T> var = p instanceof Var
                ? (Var<T>) p
                : new VarWrapper<>(p);
        return new SuspendableVarWrapper<>(var);
    }
}
 

/**
 * session scope bindings
 * 
 * @return
 */
public ObservableMap<String, Property<?>> getBindings() {
  if (bindings == null) {
    bindings = FXCollections.observableHashMap();
  }
  return bindings;
}
 

@Override
public void changed(ObservableValue<? extends Boolean> cond,
        Boolean wasTrue, Boolean isTrue) {
    Property<T> tgt = this.target.get();
    if(tgt == null) {
        condition.removeListener((ChangeListener<Boolean>) this);
    } else if(isTrue) {
        tgt.bind(source);
    } else {
        tgt.unbind();
    }
}
 

public Optional<DoubleProperty> getDoubleBinding(String key) {
  Optional<Property<?>> b = getBinding(key);
  if (!b.isPresent() || !DoubleProperty.class.isInstance(b.get())) {
    return Optional.empty();
  }
  return Optional.of((DoubleProperty) b.get());
}
 

@Override
public void setValue(U value) {
    Property<U> target = getTargetObservable();
    if(target != null) {
        target.setValue(value);
    }
}
 

@Override
public void execute(final SetPropertyValue command) {
    @SuppressWarnings("unchecked")
    final Property<Object> property = (Property<Object>) objectRegistry.getByIdOrFail(command.getPropertyId());

    changeExecutor.execute(property, new Runnable() {
        @Override
        public void run() {
            property.setValue(valueMapper.map(command.getValue()));
        }
    });
}
 

public Optional<StringProperty> getStringBinding(String key) {
  Optional<Property<?>> b = getBinding(key);
  if (!b.isPresent() || !StringProperty.class.isInstance(b.get())) {
    return Optional.empty();
  }
  return Optional.of((StringProperty) b.get());
}
 

@Override
public void unbind() {
    Property<U> target = getTargetObservable();
    if(target != null) {
        target.unbind();
    }
    boundTo = null;
}
 

private void monitorChanges() {
    properties.addListener((ListChangeListener<Property>) change -> {
        while (change.next()) {
            if (change.wasAdded()) change.getAddedSubList().forEach(p -> p.addListener(dirtyListener));
            if (change.wasRemoved()) change.getRemoved().forEach(p -> p.removeListener(dirtyListener));
        }
    });
}
 

@Override
public ObjectBinding<?> createBinding(BindingsType bind, ModularFeatureListRow row) {
  // get all properties of all features
  @SuppressWarnings("unchecked")
  Property<Range<Float>>[] prop =
      row.streamFeatures().map(f -> f.get(this)).toArray(Property[]::new);
  switch (bind) {
    case RANGE:
      return Bindings.createObjectBinding(() -> {
        Range<Float> result = null;
        for (Property<Range<Float>> p : prop) {
          if (p.getValue() != null) {
            if (result == null)
              result = p.getValue();
            else
              result = result.span(p.getValue());
          }
        }
        return result;
      }, prop);
    case AVERAGE:
    case MIN:
    case MAX:
    case SUM:
    case COUNT:
    default:
      throw new UndefinedRowBindingException(this, bind);
  }
}
 

@Override
@Nonnull
public String getFormattedString(@Nonnull Property<Integer> value) {
  if (value.getValue() == null)
    return "";
  return getFormatter().format(value.getValue().intValue());
}
 

public SimpleSerializer(final Property property) {
    this.property = property;
    if (property instanceof BooleanProperty) {
        editionType = EditionType.COMBO;
    } else if (property instanceof ObjectProperty && property.getValue() instanceof Color) {
        editionType = EditionType.COLOR_PICKER;
    } else {
        editionType = EditionType.TEXT_FIELD;
    }
}
 

public void setupFor(Property<Number> resultHolder) {
    resultHolder.bind(fib[N-2].add(fib[N-1]));

    // count the invalidations of the result
    resultHolder.addListener(o -> {
        invalidationCount += 1;
        resultHolder.getValue(); // force recomputation
    });
}
 

public AreaShareChart(@Nonnull ModularFeatureListRow row, AtomicDouble progress) {
  Float sum = row.streamFeatures().map(ModularFeature::getArea).filter(p -> p.getValue() != null)
      .map(Property<Float>::getValue).reduce(0f, Float::sum);

  List<Rectangle> all = new ArrayList<>();
  int i = 0;
  int size = row.getFeatures().size();
  for (Entry<RawDataFile, ModularFeature> entry : row.getFeatures().entrySet()) {
    Property<Float> areaProperty = entry.getValue().get(AreaType.class);
    if (areaProperty.getValue() != null) {
      // color from sample
      Color color = entry.getValue().get(RawColorType.class).getValue();
      if (color == null)
        color = Color.DARKORANGE;

      float ratio = areaProperty.getValue() / sum;
      Rectangle rect = new Rectangle();
      rect.setFill(color);
      // bind width
      rect.widthProperty().bind(this.widthProperty().multiply(ratio));
      rect.setHeight(i % 2 == 0 ? 20 : 25);
      all.add(rect);
      i++;
      if (progress != null)
        progress.addAndGet(1.0 / size);
    }
  }
  HBox box = new HBox(0, all.toArray(Rectangle[]::new));
  box.setPrefWidth(100);
  box.setAlignment(Pos.CENTER_LEFT);

  this.getChildren().add(box);
}
 

@Override
public ObjectBinding<?> createBinding(BindingsType bind, ModularFeatureListRow row) {
  // get all properties of all features
  @SuppressWarnings("unchecked")
  Property<Range<Double>>[] prop =
      row.streamFeatures().map(f -> f.get(this)).toArray(Property[]::new);
  switch (bind) {
    case RANGE:
      return Bindings.createObjectBinding(() -> {
        Range<Double> result = null;
        for (Property<Range<Double>> p : prop) {
          if (p.getValue() != null) {
            if (result == null)
              result = p.getValue();
            else
              result = result.span(p.getValue());
          }
        }
        return result;
      }, prop);
    case AVERAGE:
    case MIN:
    case MAX:
    case SUM:
    case COUNT:
    default:
      throw new UndefinedRowBindingException(this, bind);
  }
}
 

@Override
@Nonnull
public String getFormattedString(@Nonnull Property<Double> value) {
  if (value.getValue() == null)
    return "";
  return getFormatter().format(value.getValue().doubleValue());
}
 

/**
 * add session scope binding (Property.getName() required)
 * 
 * @param value
 */
public void addBinding(Property<?> value) {
  if (value.getName() == null || value.getName().isEmpty()) {
    throw new IllegalArgumentException("property name must not be empty");
  }
  getBindings().put(value.getName(), value);
}
 

public Optional<FloatProperty> getFloatBinding(String key) {
  Optional<Property<?>> b = getBinding(key);
  if (!b.isPresent() || !FloatProperty.class.isInstance(b.get())) {
    return Optional.empty();
  }
  return Optional.of((FloatProperty) b.get());
}
 

Property<Number> percentDoneProperty()
{
	return percentDone;
}
 

public SliderOption(Node graphic, String caption, String description, String category, IntegerProperty value, 
        boolean isEditable, int min, int max) {
    super(graphic, caption, description, category, (Property<Number>) value, isEditable);
    this.min = min;
    this.max = max;
}
 

public Property<String> searchValueProperty() {
    return searchValueProperty;
}
 

public Property<LoggerSearchRequest> loggerSearchRequestProperty() {
    return loggerSearchRequest;
}
 

public Property< InterpolationScheme > interpolationSchemeProperty() {
    return this.interpolationScheme;
}