Set the LineRoundLimit property
<p>
Used to automatically convert round joins to miter joins for shallow angles.
</p>

@param value property wrapper value around Float
1506
public void setLineRoundLimit( Float value) {
    PropertyValue propertyValue = lineRoundLimit(value);
    constantPropertyUsageMap.put(PROPERTY_LINE_ROUND_LIMIT, propertyValue);
    layer.setProperties(propertyValue);
  }
208532
public void setUsed(long value){
		used.setValueAsLong(value);
		minUsed.setValueIfLesserThanCurrentAsLong(value);
		maxUsed.setValueIfGreaterThanCurrentAsLong(value);
	}
601181
private void setBar(final double VALUE) {
        barCtx.clearRect(0, 0, size, size);
        barCtx.setLineCap(StrokeLineCap.BUTT);
        barCtx.setStroke(barColor);
        barCtx.setLineWidth(barWidth);

        if (sectionsVisible) {
            int listSize = sections.size();
            for (int i = 0 ; i < listSize ;i++) {
                Section section = sections.get(i);
                if (section.contains(VALUE)) {
                    barCtx.setStroke(section.getColor());
                    break;
                }
            }
        }

        if (thresholdVisible && VALUE > gauge.getThreshold()) {
            barCtx.setStroke(thresholdColor);
        }

        double v             = (VALUE - minValue) * angleStep;
        int    minValueAngle = (int) (-minValue * angleStep);
        if (!isStartFromZero) {
            for (int i = 0; i < 280; i++) {
                if (i % 10 == 0 && i < v) {
                    barCtx.strokeArc(barWidth * 0.5 + barWidth * 0.1, barWidth * 0.5 + barWidth * 0.1, size - barWidth - barWidth * 0.2, size - barWidth - barWidth * 0.2, (-i - 139), 9.2, ArcType.OPEN);
                }
            }
        } else {
            if (Double.compare(VALUE, 0) != 0) {
                if (VALUE < 0) {
                    for (int i = Math.min(minValueAngle, 280) - 1; i >= 0; i--) {
                        if (i % 10 == 0 && i > v - 10) {
                            barCtx.strokeArc(barWidth * 0.5 + barWidth * 0.1, barWidth * 0.5 + barWidth * 0.1, size - barWidth - barWidth * 0.2, size - barWidth - barWidth * 0.2, (-i - 139), 9.2, ArcType.OPEN);
                        }
                    }
                } else {
                    for (int i = Math.max(minValueAngle, 0) - 5; i < 280; i++) {
                        if (i % 10 == 0 && i < v) {
                            barCtx.strokeArc(barWidth * 0.5 + barWidth * 0.1, barWidth * 0.5 + barWidth * 0.1, size - barWidth - barWidth * 0.2, size - barWidth - barWidth * 0.2, (-i - 139), 9.2, ArcType.OPEN);
                        }
                    }
                }
            }
        }
        valueText.setText(formatNumber(gauge.getLocale(), gauge.getFormatString(), gauge.getDecimals(), VALUE));
        valueText.setLayoutX(valueBkgText.getLayoutBounds().getMaxX() - valueText.getLayoutBounds().getWidth());
    }
188737
public void setMax(int value) {
		updateDisable = true;
		maxSpinner.setValue(new Integer(value));
		updateDisable = false;
	}
806395
public void setTextTranslate( Float[] value) {
    PropertyValue propertyValue = textTranslate(value);
    constantPropertyUsageMap.put(PROPERTY_TEXT_TRANSLATE, propertyValue);
    layer.setProperties(propertyValue);
  }
769063
public final void setGuaranteedValueRequestedOnly(boolean value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setGuaranteedValueRequestedOnly", Boolean.valueOf(value));
        getHdr2().setBooleanField(JsHdr2Access.GUARANTEEDVALUE_SET_REQUESTEDONLY, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setGuaranteedValueRequestedOnly");
    }
25253
@Override
  public void setStrength(int value) {
    if (value < Collator.PRIMARY || value > Collator.IDENTICAL) {
      throw new IllegalArgumentException();
    }
    strength = value;
  }
602760
public void setLineTranslateAnchor(@Property.LINE_TRANSLATE_ANCHOR String value) {
    PropertyValue propertyValue = lineTranslateAnchor(value);
    constantPropertyUsageMap.put(PROPERTY_LINE_TRANSLATE_ANCHOR, propertyValue);
    layer.setProperties(propertyValue);
  }
1207234
public void setValueR(int x, int y, double value) {
		int idx=y*width+x;
		setValueR_atIndex(idx, value);
	}
1294908
public void setMaxValue(final double VALUE) {
        if (Status.RUNNING == timeline.getStatus()) { timeline.jumpTo(Duration.ONE); }
        if (null == maxValue) {
            if (VALUE < getMinValue()) { setMinValue(VALUE); }
            _maxValue = clamp(getMinValue(), Double.MAX_VALUE, VALUE);
            setRange(_maxValue - getMinValue());
            if (Helper.equals(originalMaxValue, Double.MAX_VALUE)) originalMaxValue = _maxValue;
            if (Helper.biggerThan(originalThreshold, getThreshold())) { setThreshold(clamp(getMinValue(), _maxValue, originalThreshold)); }
            fireTileEvent(RECALC_EVENT);
            if (!valueProperty().isBound()) Tile.this.setValue(clamp(getMinValue(), getMaxValue(), Tile.this.getValue()));
        } else {
            maxValue.set(VALUE);
        }
    }
374776
public void setFormValue(Object value) {

        if (value == null) {
            value = "";
        }
        if (value instanceof String) {
            String strValue = (String)value;
            m_selectionInput.m_textbox.setText(strValue);
            setTitle(strValue);
        }

    }
66027
public void setMaxValue(final double VALUE) {
        if (Status.RUNNING == timeline.getStatus()) { timeline.jumpTo(Duration.ONE); }
        if (null == maxValue) {
            if (VALUE < getMinValue()) { setMinValue(VALUE); }
            _maxValue = Helper.clamp(getMinValue(), Double.MAX_VALUE, VALUE);
            setRange(_maxValue - getMinValue());
            if (Double.compare(originalMaxValue, Double.MAX_VALUE) == 0) originalMaxValue = _maxValue;
            if (Double.compare(originalThreshold, getThreshold()) > 0) { setThreshold(Helper.clamp(getMinValue(), _maxValue, originalThreshold)); }

            if (!valueProperty().isBound()) Gauge.this.setValue(Helper.clamp(getMinValue(), getMaxValue(), Gauge.this.getValue()));
            updateFormatString();
            fireUpdateEvent(RECALC_EVENT);
        } else {
            maxValue.set(VALUE);
        }
    }
349776
public void setStringValue(String property, String value) {
		try {
			if (jsMBean != null) {
				setProperty(jsMBean, property, value);
			}
			if (cssMBean != null) {
				setProperty(cssMBean, property, value);
			}
			if (binaryMBean != null) {
				setProperty(binaryMBean, property, value);
			}
		} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			throw new JmxConfigException("Exception while setting the string value", e);
		}
	}
613245
public void setIconAllowOverlap( Boolean value) {
    PropertyValue propertyValue = iconAllowOverlap(value);
    constantPropertyUsageMap.put(PROPERTY_ICON_ALLOW_OVERLAP, propertyValue);
    layer.setProperties(propertyValue);
  }
308288
public void setValue(String value) {
		try {			
			ContactHeader contactHeader = (ContactHeader) SipFactoryImpl.headerFactory.createHeader(
					ContactHeader.NAME, value);
			this.address = SipFactoryImpl.addressFactory.createAddress(value);
			this.parameters = getParameters(((Parameters) contactHeader));
		} catch (Exception ex) {
			throw new IllegalArgumentException("Illegal argument", ex);
		}
	}
624259
public void setBounds(org.kie.dmn.model.api.dmndi.Bounds value) {
        this.bounds = value;
    }
1185020
public void setLineCap(@Property.LINE_CAP String value) {
    PropertyValue propertyValue = lineCap(value);
    constantPropertyUsageMap.put(PROPERTY_LINE_CAP, propertyValue);
    layer.setProperties(propertyValue);
  }