@Override public BaseElement setTextPadding(float left, float right, float top, float bottom) { PropertyDeclaration declLeft = new PropertyDeclaration(CSSName.PADDING_LEFT, new PropertyValue(CSSPrimitiveValue.CSS_PX, left, String.format("%fpx", left)), false, StylesheetInfo.USER); PropertyDeclaration declRight = new PropertyDeclaration(CSSName.PADDING_RIGHT, new PropertyValue(CSSPrimitiveValue.CSS_PX, right, String.format("%fpx", right)), false, StylesheetInfo.USER); PropertyDeclaration declBottom = new PropertyDeclaration(CSSName.PADDING_BOTTOM, new PropertyValue(CSSPrimitiveValue.CSS_PX, bottom, String.format("%fpx", bottom)), false, StylesheetInfo.USER); PropertyDeclaration declTop = new PropertyDeclaration(CSSName.PADDING_TOP, new PropertyValue(CSSPrimitiveValue.CSS_PX, top, String.format("%fpx", top)), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(declLeft); applyCssPadding(declLeft); cssState.addAllCssDeclaration(declRight); applyCssPadding(declRight); cssState.addAllCssDeclaration(declTop); applyCssPadding(declTop); cssState.addAllCssDeclaration(declBottom); applyCssPadding(declBottom); layoutChildren(); return this; }
protected void setCssSize(CSSName size, Size dim) { PropertyDeclaration decl = dim == null ? CssExtensions.createValues(size, StylesheetInfo.USER, false, new PropertyValue(IdentValue.AUTO), new PropertyValue(IdentValue.AUTO)) : CssExtensions.createValues(size, StylesheetInfo.USER, false, dim.xUnit == Unit.AUTO ? new PropertyValue(IdentValue.AUTO) : new PropertyValue( dim.xUnit == Unit.PX ? CSSPrimitiveValue.CSS_PX : CSSPrimitiveValue.CSS_PERCENTAGE, dim.x, String.format("%f%s", dim.x, dim.xUnit == Unit.PX ? "px" : "%")), dim.yUnit == Unit.AUTO ? new PropertyValue(IdentValue.AUTO) : new PropertyValue( dim.yUnit == Unit.PX ? CSSPrimitiveValue.CSS_PX : CSSPrimitiveValue.CSS_PERCENTAGE, dim.y, String.format("%f%s", dim.y, dim.yUnit == Unit.PX ? "px" : "%"))); cssState.addAllCssDeclaration(decl); applyCss(decl); layoutChildren(); }
@Override public BaseElement setHandlePosition(Vector4f borderHandles) { PropertyDeclaration declLeft = new PropertyDeclaration(CssExtensions.HANDLE_POSITION_LEFT, new PropertyValue(CSSPrimitiveValue.CSS_PX, borderHandles.w, String.format("%fpx", borderHandles.w)), false, StylesheetInfo.USER); PropertyDeclaration declRight = new PropertyDeclaration(CssExtensions.HANDLE_POSITION_RIGHT, new PropertyValue(CSSPrimitiveValue.CSS_PX, borderHandles.y, String.format("%fpx", borderHandles.y)), false, StylesheetInfo.USER); PropertyDeclaration declBottom = new PropertyDeclaration(CssExtensions.HANDLE_POSITION_BOTTOM, new PropertyValue(CSSPrimitiveValue.CSS_PX, borderHandles.z, String.format("%fpx", borderHandles.z)), false, StylesheetInfo.USER); PropertyDeclaration declTop = new PropertyDeclaration(CssExtensions.HANDLE_POSITION_TOP, new PropertyValue(CSSPrimitiveValue.CSS_PX, borderHandles.x, String.format("%fpx", borderHandles.x)), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(declLeft); applyCss(declLeft); cssState.addAllCssDeclaration(declRight); applyCss(declRight); cssState.addAllCssDeclaration(declTop); applyCss(declTop); cssState.addAllCssDeclaration(declBottom); applyCss(declBottom); layoutChildren(); return this; }
/** * Implements {@link * ValueManager#createStringValue(short,String,CSSEngine)}. */ public Value createStringValue(short type, String value, CSSEngine engine) throws DOMException { switch (type) { case CSSPrimitiveValue.CSS_IDENT: if (value.equalsIgnoreCase(CSSConstants.CSS_NONE_VALUE)) { return ValueConstants.NONE_VALUE; } break; case CSSPrimitiveValue.CSS_URI: return new URIValue(value, resolveURI(engine.getCSSBaseURI(), value)); } throw createInvalidStringTypeDOMException(type); }
/** * Implements {@link ValueManager#createValue(LexicalUnit,CSSEngine)}. */ public Value createValue(LexicalUnit lu, CSSEngine engine) throws DOMException { switch (lu.getLexicalUnitType()) { case LexicalUnit.SAC_INHERIT: return SVGValueConstants.INHERIT_VALUE; case LexicalUnit.SAC_INTEGER: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getIntegerValue()); case LexicalUnit.SAC_REAL: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getFloatValue()); default: throw createInvalidLexicalUnitDOMException (lu.getLexicalUnitType()); } }
protected void applyCssBgMap(PropertyDeclaration decl) { CSSPrimitiveValue v = decl.getValue(); CSSName cssName = decl.getCSSName(); if (cssName == CssExtensions.BGMAP_COLOR) { super.setBgMapColor(CssUtil.toColor(v.getCssText())); } else if (cssName == CssExtensions.BGMAP_IMAGE) { if (decl.getValue().getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { IdentValue ident = decl.asIdentValue(); if (ident == IdentValue.NONE || ident == IdentValue.AUTO) { super.setBgMap(null); } else throw new UnsupportedOperationException(String.format("Invalid animation image type %s.", ident)); } else if (decl.getValue().getPrimitiveType() == CSSPrimitiveValue.CSS_URI) { super.setBgMap(v.getStringValue()); } else throw new UnsupportedOperationException( String.format("Invalid animation image type %d", decl.getValue().getPrimitiveType())); } }
/** * Implements {@link * ValueManager#createStringValue(short,String,CSSEngine)}. */ public Value createStringValue(short type, String value, CSSEngine engine) throws DOMException { switch (type) { case CSSPrimitiveValue.CSS_IDENT: String s = value.toLowerCase(); if (s.equals(CSSConstants.CSS_AUTO_VALUE)) { return SVGValueConstants.AUTO_VALUE; } if (s.equals(CSSConstants.CSS_SRGB_VALUE)) { return SVGValueConstants.SRGB_VALUE; } return new StringValue(CSSPrimitiveValue.CSS_IDENT, s); case CSSPrimitiveValue.CSS_URI: return new URIValue(value, resolveURI(engine.getCSSBaseURI(), value)); } throw createInvalidStringTypeDOMException(type); }
/** * Implements {@link ValueManager#createValue(LexicalUnit,CSSEngine)}. */ public Value createValue(LexicalUnit lu, CSSEngine engine) throws DOMException { switch (lu.getLexicalUnitType()) { case LexicalUnit.SAC_INHERIT: return SVGValueConstants.INHERIT_VALUE; case LexicalUnit.SAC_INTEGER: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getIntegerValue()); case LexicalUnit.SAC_REAL: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getFloatValue()); } throw createInvalidLexicalUnitDOMException(lu.getLexicalUnitType()); }
@Override public BaseElement setAtlas(Vector4f atlas) { PropertyDeclaration declX = new PropertyDeclaration(CssExtensions.ATLAS_X, new PropertyValue(CSSPrimitiveValue.CSS_PX, atlas.x, String.format("%fpx", atlas.x)), false, StylesheetInfo.USER); PropertyDeclaration declY = new PropertyDeclaration(CssExtensions.ATLAS_Y, new PropertyValue(CSSPrimitiveValue.CSS_PX, atlas.y, String.format("%fpx", atlas.y)), false, StylesheetInfo.USER); PropertyDeclaration declW = new PropertyDeclaration(CssExtensions.ATLAS_WIDTH, new PropertyValue(CSSPrimitiveValue.CSS_PX, atlas.z, String.format("%fpx", atlas.z)), false, StylesheetInfo.USER); PropertyDeclaration declH = new PropertyDeclaration(CssExtensions.ATLAS_HEIGHT, new PropertyValue(CSSPrimitiveValue.CSS_PX, atlas.w, String.format("%fpx", atlas.w)), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(declX); applyCss(declX); cssState.addAllCssDeclaration(declY); applyCss(declY); cssState.addAllCssDeclaration(declH); applyCss(declH); cssState.addAllCssDeclaration(declW); applyCss(declW); layoutChildren(); return this; }
@Override public BaseElement setMargin(float left, float right, float top, float bottom) { PropertyDeclaration declLeft = new PropertyDeclaration(CSSName.MARGIN_LEFT, new PropertyValue(CSSPrimitiveValue.CSS_PX, left, String.format("%fpx", left)), false, StylesheetInfo.USER); PropertyDeclaration declRight = new PropertyDeclaration(CSSName.MARGIN_RIGHT, new PropertyValue(CSSPrimitiveValue.CSS_PX, right, String.format("%fpx", right)), false, StylesheetInfo.USER); PropertyDeclaration declBottom = new PropertyDeclaration(CSSName.MARGIN_BOTTOM, new PropertyValue(CSSPrimitiveValue.CSS_PX, bottom, String.format("%fpx", bottom)), false, StylesheetInfo.USER); PropertyDeclaration declTop = new PropertyDeclaration(CSSName.MARGIN_TOP, new PropertyValue(CSSPrimitiveValue.CSS_PX, top, String.format("%fpx", top)), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(declLeft); applyCssMargin(declLeft); cssState.addAllCssDeclaration(declRight); applyCssMargin(declRight); cssState.addAllCssDeclaration(declTop); applyCssMargin(declTop); cssState.addAllCssDeclaration(declBottom); applyCssMargin(declBottom); layoutChildren(); return this; }
/** * Creates a color component from a lexical unit. */ protected Value createColorComponent(LexicalUnit lu) throws DOMException { switch (lu.getLexicalUnitType()) { case LexicalUnit.SAC_INTEGER: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getIntegerValue()); case LexicalUnit.SAC_REAL: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getFloatValue()); case LexicalUnit.SAC_PERCENTAGE: return new FloatValue(CSSPrimitiveValue.CSS_PERCENTAGE, lu.getFloatValue()); } throw createInvalidRGBComponentUnitDOMException (lu.getLexicalUnitType()); }
/** * Implements {@link * ValueManager#computeValue(CSSStylableElement,String,CSSEngine,int,StyleMap,Value)}. */ public Value computeValue(CSSStylableElement elt, String pseudo, CSSEngine engine, int idx, StyleMap sm, Value value) { if ((value.getCssValueType() == CSSValue.CSS_PRIMITIVE_VALUE) && (value.getPrimitiveType() == CSSPrimitiveValue.CSS_URI)) { // Reveal the absolute value as the cssText now. return new URIValue(value.getStringValue(), value.getStringValue()); } return value; }
/** * Implements {@link * ValueManager#computeValue(CSSStylableElement,String,CSSEngine,int,StyleMap,Value)}. */ public Value computeValue(CSSStylableElement elt, String pseudo, CSSEngine engine, int idx, StyleMap sm, Value value) { if (value.getCssValueType() == CSSValue.CSS_VALUE_LIST) { ListValue lv = (ListValue)value; int len = lv.getLength(); ListValue result = new ListValue(' '); for (int i=0; i<len; i++) { Value v = lv.item(0); if (v.getPrimitiveType() == CSSPrimitiveValue.CSS_URI) { // Reveal the absolute value as the cssText now. result.append(new URIValue(v.getStringValue(), v.getStringValue())); } else { result.append(v); } } return result; } return super.computeValue(elt, pseudo, engine, idx, sm, value); }
/** * Implements {@link ValueManager#createValue(LexicalUnit,CSSEngine)}. */ public Value createValue(LexicalUnit lu, CSSEngine engine) throws DOMException { switch (lu.getLexicalUnitType()) { case LexicalUnit.SAC_INHERIT: return ValueConstants.INHERIT_VALUE; case LexicalUnit.SAC_INTEGER: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getIntegerValue()); case LexicalUnit.SAC_REAL: return new FloatValue(CSSPrimitiveValue.CSS_NUMBER, lu.getFloatValue()); case LexicalUnit.SAC_IDENT: if (lu.getStringValue().equalsIgnoreCase (CSSConstants.CSS_NONE_VALUE)) { return ValueConstants.NONE_VALUE; } throw createInvalidIdentifierDOMException(lu.getStringValue()); } throw createInvalidLexicalUnitDOMException(lu.getLexicalUnitType()); }
/** * Converts the current value into inches. */ protected static float toInches(Value value) { switch (value.getPrimitiveType()) { case CSSPrimitiveValue.CSS_CM: return (value.getFloatValue() / 2.54f); case CSSPrimitiveValue.CSS_MM: return (value.getFloatValue() / 25.4f); case CSSPrimitiveValue.CSS_IN: return value.getFloatValue(); case CSSPrimitiveValue.CSS_PT: return (value.getFloatValue() / 72); case CSSPrimitiveValue.CSS_PC: return (value.getFloatValue() / 6); default: throw new DOMException(DOMException.INVALID_ACCESS_ERR, ""); } }
/** * Converts the current value into millimeters. */ protected static float toMillimeters(Value value) { switch (value.getPrimitiveType()) { case CSSPrimitiveValue.CSS_CM: return (value.getFloatValue() * 10); case CSSPrimitiveValue.CSS_MM: return value.getFloatValue(); case CSSPrimitiveValue.CSS_IN: return (value.getFloatValue() * 25.4f); case CSSPrimitiveValue.CSS_PT: return (value.getFloatValue() * 25.4f / 72); case CSSPrimitiveValue.CSS_PC: return (value.getFloatValue() * 25.4f / 6); default: throw new DOMException(DOMException.INVALID_ACCESS_ERR, ""); } }
/** * Converts the current value into points. */ protected static float toPoints(Value value) { switch (value.getPrimitiveType()) { case CSSPrimitiveValue.CSS_CM: return (value.getFloatValue() * 72 / 2.54f); case CSSPrimitiveValue.CSS_MM: return (value.getFloatValue() * 72 / 25.4f); case CSSPrimitiveValue.CSS_IN: return (value.getFloatValue() * 72); case CSSPrimitiveValue.CSS_PT: return value.getFloatValue(); case CSSPrimitiveValue.CSS_PC: return (value.getFloatValue() * 12); default: throw new DOMException(DOMException.INVALID_ACCESS_ERR, ""); } }
/** * Converts the current value into picas. */ protected static float toPicas(Value value) { switch (value.getPrimitiveType()) { case CSSPrimitiveValue.CSS_CM: return (value.getFloatValue() * 6 / 2.54f); case CSSPrimitiveValue.CSS_MM: return (value.getFloatValue() * 6 / 25.4f); case CSSPrimitiveValue.CSS_IN: return (value.getFloatValue() * 6); case CSSPrimitiveValue.CSS_PT: return (value.getFloatValue() / 12); case CSSPrimitiveValue.CSS_PC: return value.getFloatValue(); default: throw new DOMException(DOMException.INVALID_ACCESS_ERR, ""); } }
protected void setCssPosition(CSSName size, Measurement dim) { PropertyDeclaration decl = dim == null ? CssExtensions.createValues(size, StylesheetInfo.USER, false, new PropertyValue(IdentValue.AUTO), new PropertyValue(IdentValue.AUTO)) : CssExtensions.createValues(size, StylesheetInfo.USER, false, dim.xUnit == Unit.AUTO ? new PropertyValue(IdentValue.AUTO) : new PropertyValue( dim.yUnit == Unit.PX ? CSSPrimitiveValue.CSS_PX : CSSPrimitiveValue.CSS_PERCENTAGE, dim.x, String.format("%fpx", dim.x)), dim.yUnit == Unit.AUTO ? new PropertyValue(IdentValue.AUTO) : new PropertyValue( dim.yUnit == Unit.PX ? CSSPrimitiveValue.CSS_PX : CSSPrimitiveValue.CSS_PERCENTAGE, dim.y, String.format("%fpx", dim.y))); cssState.addAllCssDeclaration(decl); applyCss(decl); layoutChildren(); }
@Override public List buildDeclarations(CSSName cssName, List values, int origin, boolean important, boolean inheritAllowed) { checkValueCount(cssName, 1, values.size()); CSSPrimitiveValue value = (CSSPrimitiveValue) values.get(0); checkInheritAllowed(value, inheritAllowed); if (value.getCssValueType() != CSSValue.CSS_INHERIT) { checkIdentOrColorType(cssName, value); if (value.getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { FSRGBColor color = Conversions.getColor(value.getStringValue()); if (color != null) { return Collections.singletonList( new PropertyDeclaration(cssName, new PropertyValue(color), important, origin)); } IdentValue ident = checkIdent(cssName, value); checkValidity(cssName, ALLOWED, ident); } } return Collections.singletonList(new PropertyDeclaration(cssName, value, important, origin)); }
/** * Set the north, west, east and south borders in number of pixels * * @param nBorder * float * @param wBorder * float * @param eBorder * float * @param sBorder * float */ @Override public BaseElement setResizeBorders(float nBorder, float wBorder, float eBorder, float sBorder) { PropertyDeclaration declW = new PropertyDeclaration(CSSName.BORDER_LEFT_WIDTH, new PropertyValue(CSSPrimitiveValue.CSS_PX, eBorder, String.format("%fpx", eBorder)), false, StylesheetInfo.USER); PropertyDeclaration declE = new PropertyDeclaration(CSSName.BORDER_RIGHT_WIDTH, new PropertyValue(CSSPrimitiveValue.CSS_PX, wBorder, String.format("%fpx", wBorder)), false, StylesheetInfo.USER); PropertyDeclaration declN = new PropertyDeclaration(CSSName.BORDER_TOP_WIDTH, new PropertyValue(CSSPrimitiveValue.CSS_PX, nBorder, String.format("%fpx", nBorder)), false, StylesheetInfo.USER); PropertyDeclaration declS = new PropertyDeclaration(CSSName.BORDER_BOTTOM_WIDTH, new PropertyValue(CSSPrimitiveValue.CSS_PX, sBorder, String.format("%fpx", sBorder)), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(declW); cssState.addAllCssDeclaration(declE); cssState.addAllCssDeclaration(declN); cssState.addAllCssDeclaration(declS); applyCss(declW); applyCss(declE); applyCss(declN); applyCss(declS); layoutChildren(); return this; }
/** * <b>DOM</b>: Implements {@link * org.w3c.dom.svg.SVGColor#getColorType()}. */ public short getColorType() { Value value = valueProvider.getValue(); int cssValueType = value.getCssValueType(); switch ( cssValueType ) { case CSSValue.CSS_PRIMITIVE_VALUE: int primitiveType = value.getPrimitiveType(); switch ( primitiveType ) { case CSSPrimitiveValue.CSS_IDENT: { if (value.getStringValue().equalsIgnoreCase (CSSConstants.CSS_CURRENTCOLOR_VALUE)) return SVG_COLORTYPE_CURRENTCOLOR; return SVG_COLORTYPE_RGBCOLOR; } case CSSPrimitiveValue.CSS_RGBCOLOR: return SVG_COLORTYPE_RGBCOLOR; } // there was no case for this primitiveType, prevent throwing the other exception throw new IllegalStateException("Found unexpected PrimitiveType:" + primitiveType ); case CSSValue.CSS_VALUE_LIST: return SVG_COLORTYPE_RGBCOLOR_ICCCOLOR; } // should not happen throw new IllegalStateException("Found unexpected CssValueType:" + cssValueType ); }
protected AnimatableValue createAnimatableValue(AnimationTarget target, String pn, Value v) { FloatValue fv = (FloatValue) v; short unit; switch (fv.getPrimitiveType()) { case CSSPrimitiveValue.CSS_NUMBER: case CSSPrimitiveValue.CSS_DEG: unit = SVGAngle.SVG_ANGLETYPE_DEG; break; case CSSPrimitiveValue.CSS_RAD: unit = SVGAngle.SVG_ANGLETYPE_RAD; break; case CSSPrimitiveValue.CSS_GRAD: unit = SVGAngle.SVG_ANGLETYPE_GRAD; break; default: // XXX Do something better than returning null. return null; } return new AnimatableAngleValue(target, fv.getFloatValue(), unit); }
protected AnimatableValue createAnimatableValue(AnimationTarget target, String pn, Value v) { if (v instanceof StringValue) { return new AnimatableAngleOrIdentValue(target, v.getStringValue()); } FloatValue fv = (FloatValue) v; short unit; switch (fv.getPrimitiveType()) { case CSSPrimitiveValue.CSS_NUMBER: case CSSPrimitiveValue.CSS_DEG: unit = SVGAngle.SVG_ANGLETYPE_DEG; break; case CSSPrimitiveValue.CSS_RAD: unit = SVGAngle.SVG_ANGLETYPE_RAD; break; case CSSPrimitiveValue.CSS_GRAD: unit = SVGAngle.SVG_ANGLETYPE_GRAD; break; default: // XXX Do something better than returning null. return null; } return new AnimatableAngleOrIdentValue(target, fv.getFloatValue(), unit); }
/** * Returns an array of floating offsets representing the 'clip' * property or null if 'auto'. The offsets are specified in the * order top, right, bottom, left. * * @param e the element with the 'clip' property */ public static float[] convertClip(Element e) { Value v = getComputedStyle(e, SVGCSSEngine.CLIP_INDEX); int primitiveType = v.getPrimitiveType(); switch ( primitiveType ) { case CSSPrimitiveValue.CSS_RECT: float [] off = new float[4]; off[0] = v.getTop().getFloatValue(); off[1] = v.getRight().getFloatValue(); off[2] = v.getBottom().getFloatValue(); off[3] = v.getLeft().getFloatValue(); return off; case CSSPrimitiveValue.CSS_IDENT: return null; // 'auto' means no offsets default: // can't be reached throw new IllegalStateException("Unexpected primitiveType:" + primitiveType ); } }
/** * Sets the text of the element. * * @param text * String The text to display. */ @Override public BaseElement setText(String text) { if (!Objects.equals(text, getText())) { if (text == null) { cssState.removeAllCssDeclaration(CSSName.CONTENT.toString()); } else { PropertyDeclaration decl = new PropertyDeclaration(CSSName.CONTENT, new PropertyValue(CSSPrimitiveValue.CSS_STRING, text, text), false, StylesheetInfo.USER); cssState.addAllCssDeclaration(decl); try { applyCss(decl); } catch (IndexOutOfBoundsException iiobe) { System.err.println("**BUG** Text for " + toString() + " is '" + text + "'"); iiobe.printStackTrace(); } } layoutChildren(); } return this; }
/** * Returns the value of one color component (0 <= result <= 255). * @param v the value that defines the color component */ public static int resolveColorComponent(Value v) { float f; switch(v.getPrimitiveType()) { case CSSPrimitiveValue.CSS_PERCENTAGE: f = v.getFloatValue(); f = (f > 100f) ? 100f : (f < 0f) ? 0f : f; return Math.round(255f * f / 100f); case CSSPrimitiveValue.CSS_NUMBER: f = v.getFloatValue(); f = (f > 255f) ? 255f : (f < 0f) ? 0f : f; return Math.round(f); default: throw new IllegalArgumentException ("Color component argument is not an appropriate CSS value"); } }
protected void applyCssBorder(PropertyDeclaration decl) { CSSName cssName = decl.getCSSName(); CSSPrimitiveValue v = decl.getValue(); if (cssName == CSSName.BORDER_LEFT_WIDTH) { borders.x = v.getFloatValue(CSSPrimitiveValue.CSS_PX); dirtyLayout(false, LayoutType.boundsChange()); } else if (cssName == CSSName.BORDER_RIGHT_WIDTH) { borders.y = v.getFloatValue(CSSPrimitiveValue.CSS_PX); dirtyLayout(false, LayoutType.boundsChange()); } else if (cssName == CSSName.BORDER_TOP_WIDTH) { borders.z = v.getFloatValue(CSSPrimitiveValue.CSS_PX); dirtyLayout(false, LayoutType.boundsChange()); } else if (cssName == CSSName.BORDER_BOTTOM_WIDTH) { borders.w = v.getFloatValue(CSSPrimitiveValue.CSS_PX); dirtyLayout(false, LayoutType.boundsChange()); } }
@Override public List buildDeclarations(CSSName cssName, List values, int origin, boolean important, boolean inheritAllowed) { checkValueCount(cssName, 1, values.size()); CSSPrimitiveValue value = (CSSPrimitiveValue) values.get(0); checkInheritAllowed(value, inheritAllowed); if (value.getCssValueType() != CSSValue.CSS_INHERIT) { checkIdentOrURIType(cssName, value); if (value.getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { IdentValue ident = checkIdent(cssName, value); checkValidity(cssName, ALLOWED, ident); } } return Collections.singletonList(new PropertyDeclaration(cssName, value, important, origin)); }
@Override public List buildDeclarations(CSSName cssName, List values, int origin, boolean important, boolean inheritAllowed) { checkValueCount(cssName, 1, values.size()); PropertyValue value = (PropertyValue) values.get(0); checkInheritAllowed(value, inheritAllowed); if (value.getCssValueType() != CSSValue.CSS_INHERIT) { checkIdentNumberType(cssName, value); if (value.getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { IdentValue ident = checkIdent(cssName, value); checkValidity(cssName, allowed, ident); } else if (value.getFloatValue() < 0.0f) { throw new CSSParseException(cssName + " may not be negative", -1); } } return Collections.singletonList(new PropertyDeclaration(cssName, value, important, origin)); }
@Override public List buildDeclarations(CSSName cssName, List values, int origin, boolean important, boolean inheritAllowed) { checkValueCount(cssName, 1, values.size()); CSSPrimitiveValue value = (CSSPrimitiveValue) values.get(0); checkInheritAllowed(value, inheritAllowed); if (value.getCssValueType() != CSSValue.CSS_INHERIT) { checkIdentType(cssName, value); IdentValue ident = checkIdent(cssName, value); checkValidity(cssName, getAllowed(), ident); } return Collections.singletonList(new PropertyDeclaration(cssName, value, important, origin)); }
@Override public List buildDeclarations(CSSName cssName, List values, int origin, boolean important, boolean inheritAllowed) { checkValueCount(cssName, 1, values.size()); PropertyValue value = (PropertyValue) values.get(0); checkInheritAllowed(value, inheritAllowed); if (value.getCssValueType() != CSSValue.CSS_INHERIT) { checkIdentNumberOrPercentType(cssName, value); if (value.getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { IdentValue ident = checkIdent(cssName, value); checkValidity(cssName, allowed, ident); } else if (value.getFloatValue() < 0.0f) { throw new CSSParseException(cssName + " may not be negative", -1); } } return Collections.singletonList(new PropertyDeclaration(cssName, value, important, origin)); }
/** * Converts a value to a color * * @param value * @return Color */ public static Color color(CSSValue value) { RGBColor rgbColorValue = ((CSSPrimitiveValue)value).getRGBColorValue(); int r = (int)rgbColorValue.getRed().getFloatValue(CSSPrimitiveValue.CSS_NUMBER); int g = (int)rgbColorValue.getGreen().getFloatValue(CSSPrimitiveValue.CSS_NUMBER); int b = (int)rgbColorValue.getBlue().getFloatValue(CSSPrimitiveValue.CSS_NUMBER); return new Color(r, g, b); }
private RGB createRGB(LexicalUnit value) { RGBColor rgbColor = new RGBColorImpl(value); int green = ((int) rgbColor.getGreen().getFloatValue(CSSPrimitiveValue.CSS_NUMBER)); int red = ((int) rgbColor.getRed().getFloatValue(CSSPrimitiveValue.CSS_NUMBER)); int blue = ((int) rgbColor.getBlue().getFloatValue(CSSPrimitiveValue.CSS_NUMBER)); return new RGB(red, green, blue); }
protected void setCssBounds(CSSName size, Vector4f dim) { PropertyDeclaration decl = dim == null ? CssExtensions.createValues(size, StylesheetInfo.USER, false, new PropertyValue(IdentValue.AUTO), new PropertyValue(IdentValue.AUTO)) : CssExtensions.createValues(size, StylesheetInfo.USER, false, new PropertyValue(CSSPrimitiveValue.CSS_PX, dim.x, String.format("%fpx", dim.x)), new PropertyValue(CSSPrimitiveValue.CSS_PX, dim.y, String.format("%fpx", dim.y)), new PropertyValue(CSSPrimitiveValue.CSS_PX, dim.z, String.format("%fpx", dim.z)), new PropertyValue(CSSPrimitiveValue.CSS_PX, dim.w, String.format("%fpx", dim.w))); cssState.addAllCssDeclaration(decl); applyCss(decl); layoutChildren(); }
public BaseElement setHoverVolume(float volume) { PropertyDeclaration decl = new PropertyDeclaration(CssExtensions.VOLUME, new PropertyValue(CSSPrimitiveValue.CSS_PERCENTAGE, (int) (volume * 100f), String.valueOf((int) (volume * 100))), false, StylesheetInfo.USER); getCssState().addCssDeclaration(decl, PseudoStyle.hover); applyCss(decl); return this; }
public static ColorRGBA toFontColor(PropertyDeclaration pd, StyledNode<?, ?> element) { if (pd.getValue().getPrimitiveType() == CSSPrimitiveValue.CSS_IDENT) { IdentValue iv = pd.asIdentValue(); if (iv == IdentValue.INHERIT) return null; } else if (pd != null && pd.getValue() instanceof PropertyValue) { PropertyValue pv = (PropertyValue) pd.getValue(); return CssUtil.toColor(pv.getFSColor()); } else if (pd != null) return CssUtil.toColor(pd.getValue().getCssText()); return null; }
/** * Implements {@link * ValueManager#computeValue(CSSStylableElement,String,CSSEngine,int,StyleMap,Value)}. */ public Value computeValue(CSSStylableElement elt, String pseudo, CSSEngine engine, int idx, StyleMap sm, Value value) { if (value.getCssValueType() != CSSValue.CSS_PRIMITIVE_VALUE) { return value; } if (value.getPrimitiveType() != CSSPrimitiveValue.CSS_RECT) { return value; } RectValue rect = (RectValue)value; orientation = VERTICAL_ORIENTATION; Value top = super.computeValue(elt, pseudo, engine, idx, sm, rect.getTop()); Value bottom = super.computeValue(elt, pseudo, engine, idx, sm, rect.getBottom()); orientation = HORIZONTAL_ORIENTATION; Value left = super.computeValue(elt, pseudo, engine, idx, sm, rect.getLeft()); Value right = super.computeValue(elt, pseudo, engine, idx, sm, rect.getRight()); if (top != rect.getTop() || right != rect.getRight() || bottom != rect.getBottom() || left != rect.getLeft()) { return new RectValue(top, right, bottom, left); } else { return value; } }
/** * Implements {@link * ValueManager#createStringValue(short,String,CSSEngine)}. */ public Value createStringValue(short type, String value, CSSEngine engine) { if (type != CSSPrimitiveValue.CSS_IDENT) { throw createInvalidStringTypeDOMException(type); } if (!value.equalsIgnoreCase(CSSConstants.CSS_ACCUMULATE_VALUE)) { throw createInvalidIdentifierDOMException(value); } return SVGValueConstants.ACCUMULATE_VALUE; }