internal static bool TryGetImageSourceFromValue(StylePropertyValue propertyValue, out ImageSource source) { source = new ImageSource(); switch (propertyValue.handle.valueType) { case StyleValueType.ResourcePath: { string path = propertyValue.sheet.ReadResourcePath(propertyValue.handle); if (!string.IsNullOrEmpty(path)) { source.texture = Panel.LoadResource(path, typeof(Texture2D)) as Texture2D; if (source.texture == null) { source.vectorImage = Panel.LoadResource(path, typeof(VectorImage)) as VectorImage; } } if (source.texture == null && source.vectorImage == null) { Debug.LogWarning(string.Format("Image not found for path: {0}", path)); return(false); } } break; case StyleValueType.AssetReference: { var o = propertyValue.sheet.ReadAssetReference(propertyValue.handle); source.texture = o as Texture2D; source.vectorImage = o as VectorImage; if (source.texture == null && source.vectorImage == null) { Debug.LogWarning("Invalid image specified"); return(false); } } break; default: Debug.LogWarning("Invalid value for image texture " + propertyValue.handle.valueType); return(false); } return(true); }
public StyleBackground ReadStyleBackground(int index) { ImageSource imageSource = default(ImageSource); StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; bool flag = stylePropertyValue.handle.valueType == StyleValueType.Keyword; if (flag) { bool flag2 = stylePropertyValue.handle.valueIndex != 6; if (flag2) { string arg_68_0 = "Invalid keyword for image source "; StyleValueKeyword valueIndex = (StyleValueKeyword)stylePropertyValue.handle.valueIndex; Debug.LogWarning(arg_68_0 + valueIndex.ToString()); } } else { bool flag3 = !StylePropertyReader.TryGetImageSourceFromValue(stylePropertyValue, this.dpiScaling, out imageSource); if (flag3) { imageSource.texture = (Panel.LoadResource("d_console.warnicon", typeof(Texture2D), this.dpiScaling) as Texture2D); } } bool flag4 = imageSource.texture != null; StyleBackground result; if (flag4) { result = new StyleBackground(imageSource.texture); } else { bool flag5 = imageSource.vectorImage != null; if (flag5) { result = new StyleBackground(imageSource.vectorImage); } else { result = default(StyleBackground); } } return(result); }
static int ReadEnum(StyleEnumType enumType, StylePropertyValue value) { string enumString = null; var handle = value.handle; if (handle.valueType == StyleValueType.Keyword) { var keyword = value.sheet.ReadKeyword(handle); enumString = keyword.ToUssString(); } else { enumString = value.sheet.ReadEnum(handle); } StylePropertyUtil.TryGetEnumIntValue(enumType, enumString, out var intValue); return(intValue); }
static public Angle ReadAngle(StylePropertyValue value) { if (value.handle.valueType == StyleValueType.Keyword) { var keyword = (StyleValueKeyword)value.handle.valueIndex; switch (keyword) { case StyleValueKeyword.None: return(Angle.None()); default: return(new Angle()); } } var dimension = value.sheet.ReadDimension(value.handle); return(dimension.ToAngle()); }
public StyleInt ReadStyleEnum(StyleEnumType enumType, int index) { StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; StyleValueHandle handle = stylePropertyValue.handle; bool flag = handle.valueType == StyleValueType.Keyword; string value; if (flag) { StyleValueKeyword svk = stylePropertyValue.sheet.ReadKeyword(handle); value = svk.ToUssString(); } else { value = stylePropertyValue.sheet.ReadEnum(handle); } int enumIntValue = StylePropertyUtil.GetEnumIntValue(enumType, value); return(new StyleInt(enumIntValue)); }
static public Scale ReadScale(int valCount, StylePropertyValue val1, StylePropertyValue val2, StylePropertyValue val3) { if (val1.handle.valueType == StyleValueType.Keyword && (StyleValueKeyword)val1.handle.valueIndex == StyleValueKeyword.None) { return(Scale.None()); } var scale = Vector3.one; switch (valCount) { case 1: // If only one argument, the translation is along both axes if (val1.handle.valueType == StyleValueType.Dimension || val1.handle.valueType == StyleValueType.Float) { scale.x = val1.sheet.ReadFloat(val1.handle); scale.y = scale.x; } break; case 2: //X Y value if (val1.handle.valueType == StyleValueType.Dimension || val1.handle.valueType == StyleValueType.Float) { scale.x = val1.sheet.ReadFloat(val1.handle); } if (val2.handle.valueType == StyleValueType.Dimension || val2.handle.valueType == StyleValueType.Float) { scale.y = val2.sheet.ReadFloat(val2.handle); } break; case 3: //X Y Z value if (val3.handle.valueType == StyleValueType.Dimension || val3.handle.valueType == StyleValueType.Float) { scale.z = val3.sheet.ReadFloat(val3.handle); } goto case 2; //Parse the first 2 parameters } return(new Scale(scale)); }
public StyleFont ReadStyleFont(int index) { Font font = null; StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; StyleValueType valueType = stylePropertyValue.handle.valueType; StyleValueType styleValueType = valueType; if (styleValueType != StyleValueType.ResourcePath) { if (styleValueType != StyleValueType.AssetReference) { Debug.LogWarning("Invalid value for font " + stylePropertyValue.handle.valueType.ToString()); } else { font = (stylePropertyValue.sheet.ReadAssetReference(stylePropertyValue.handle) as Font); bool flag = font == null; if (flag) { Debug.LogWarning("Invalid font reference"); } } } else { string text = stylePropertyValue.sheet.ReadResourcePath(stylePropertyValue.handle); bool flag2 = !string.IsNullOrEmpty(text); if (flag2) { font = (Panel.LoadResource(text, typeof(Font), this.dpiScaling) as Font); } bool flag3 = font == null; if (flag3) { Debug.LogWarning(string.Format("Font not found for path: {0}", text)); } } return(new StyleFont(font)); }
static public Rotate ReadRotate(int valCount, StylePropertyValue val1, StylePropertyValue val2, StylePropertyValue val3, StylePropertyValue val4) { if (val1.handle.valueType == StyleValueType.Keyword && (StyleValueKeyword)val1.handle.valueIndex == StyleValueKeyword.None) { return(Rotate.None()); } var rot = Rotate.Initial(); switch (valCount) { case 1: // If only one argument, the only argument is an angle and the rotation is in Z if (val1.handle.valueType == StyleValueType.Dimension) { rot.angle = ReadAngle(val1); //we leave axis to the default value; } break; //other rotations are not supported } return(rot); }
static private Length ReadTransformOriginEnum(StylePropertyValue value, out bool isVertical, out bool isHorizontal) { if (value.handle.valueType == StyleValueType.Enum) { var enumValue = (TransformOriginOffset)ReadEnum(StyleEnumType.TransformOriginOffset, value); switch (enumValue) { case TransformOriginOffset.Left: isVertical = false; isHorizontal = true; return(Length.Percent(0)); case TransformOriginOffset.Top: isVertical = true; isHorizontal = false; return(Length.Percent(0)); case TransformOriginOffset.Center: isVertical = true; isHorizontal = true; return(Length.Percent(50)); case TransformOriginOffset.Right: isVertical = false; isHorizontal = true; return(Length.Percent(100)); case TransformOriginOffset.Bottom: isVertical = true; isHorizontal = false; return(Length.Percent(100)); } } else if (value.handle.valueType == StyleValueType.Dimension || value.handle.valueType == StyleValueType.Float) { isVertical = true; isHorizontal = true; return(value.sheet.ReadDimension(value.handle).ToLength()); } isVertical = false; isHorizontal = false; // should not matter because there would be no ambiguity return(Length.Percent(50)); }
internal static bool TryGetImageSourceFromValue(StylePropertyValue propertyValue, float dpiScaling, out ImageSource source) { source = default(ImageSource); StyleValueType valueType = propertyValue.handle.valueType; StyleValueType styleValueType = valueType; bool result; if (styleValueType <= StyleValueType.AssetReference) { if (styleValueType != StyleValueType.ResourcePath) { if (styleValueType == StyleValueType.AssetReference) { UnityEngine.Object @object = propertyValue.sheet.ReadAssetReference(propertyValue.handle); source.texture = (@object as Texture2D); source.vectorImage = (@object as VectorImage); bool flag = source.texture == null && source.vectorImage == null; if (flag) { Debug.LogWarning("Invalid image specified"); result = false; return(result); } goto IL_24E; } } else { string text = propertyValue.sheet.ReadResourcePath(propertyValue.handle); bool flag2 = !string.IsNullOrEmpty(text); if (flag2) { source.texture = (Panel.LoadResource(text, typeof(Texture2D), dpiScaling) as Texture2D); bool flag3 = source.texture == null; if (flag3) { source.vectorImage = (Panel.LoadResource(text, typeof(VectorImage), dpiScaling) as VectorImage); } } bool flag4 = source.texture == null && source.vectorImage == null; if (flag4) { Debug.LogWarning(string.Format("Image not found for path: {0}", text)); result = false; return(result); } goto IL_24E; } } else if (styleValueType != StyleValueType.ScalableImage) { if (styleValueType == StyleValueType.MissingAssetReference) { result = false; return(result); } } else { ScalableImage scalableImage = propertyValue.sheet.ReadScalableImage(propertyValue.handle); bool flag5 = scalableImage.normalImage == null && scalableImage.highResolutionImage == null; if (flag5) { Debug.LogWarning("Invalid scalable image specified"); result = false; return(result); } bool flag6 = dpiScaling > 1f; if (flag6) { source.texture = scalableImage.highResolutionImage; source.texture.pixelsPerPoint = 2f; } else { source.texture = scalableImage.normalImage; } bool flag7 = !Mathf.Approximately(dpiScaling % 1f, 0f); if (flag7) { source.texture.filterMode = FilterMode.Bilinear; } goto IL_24E; } Debug.LogWarning("Invalid value for image texture " + propertyValue.handle.valueType.ToString()); result = false; return(result); IL_24E: result = true; return(result); }
public StyleCursor ReadStyleCursor(int index) { float x = 0f; float y = 0f; int defaultCursorId = 0; Texture2D texture = null; StyleValueType valueType = this.GetValueType(index); bool flag = valueType == StyleValueType.ResourcePath || valueType == StyleValueType.AssetReference || valueType == StyleValueType.ScalableImage; bool flag2 = flag; if (flag2) { bool flag3 = this.valueCount < 1; if (flag3) { Debug.LogWarning(string.Format("USS 'cursor' has invalid value at {0}.", index)); } else { ImageSource imageSource = default(ImageSource); StylePropertyValue value = this.GetValue(index); bool flag4 = StylePropertyReader.TryGetImageSourceFromValue(value, this.dpiScaling, out imageSource); if (flag4) { texture = imageSource.texture; bool flag5 = this.valueCount >= 3; if (flag5) { StylePropertyValue value2 = this.GetValue(index + 1); StylePropertyValue value3 = this.GetValue(index + 2); bool flag6 = value2.handle.valueType != StyleValueType.Float || value3.handle.valueType != StyleValueType.Float; if (flag6) { Debug.LogWarning("USS 'cursor' property requires two integers for the hot spot value."); } else { x = value2.sheet.ReadFloat(value2.handle); y = value3.sheet.ReadFloat(value3.handle); } } } } } else { bool flag7 = StylePropertyReader.getCursorIdFunc != null; if (flag7) { StylePropertyValue value4 = this.GetValue(index); defaultCursorId = StylePropertyReader.getCursorIdFunc(value4.sheet, value4.handle); } } UnityEngine.UIElements.Cursor v = new UnityEngine.UIElements.Cursor { texture = texture, hotspot = new Vector2(x, y), defaultCursorId = defaultCursorId }; return(new StyleCursor(v)); }
public StyleInt ReadStyleInt(int index) { StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; return(new StyleInt((int)stylePropertyValue.sheet.ReadFloat(stylePropertyValue.handle))); }
static public Translate ReadTranslate(int valCount, StylePropertyValue val1, StylePropertyValue val2, StylePropertyValue val3) { if (val1.handle.valueType == StyleValueType.Keyword && (StyleValueKeyword)val1.handle.valueIndex == StyleValueKeyword.None) { return(Translate.None()); } Length x = 0, y = 0; float z = 0; switch (valCount) { case 1: // If only one argument, the translation is along both axes if (val1.handle.valueType == StyleValueType.Dimension || val1.handle.valueType == StyleValueType.Float) { x = val1.sheet.ReadDimension(val1.handle).ToLength(); y = val1.sheet.ReadDimension(val1.handle).ToLength(); } break; case 2: //X Y value if (val1.handle.valueType == StyleValueType.Dimension || val1.handle.valueType == StyleValueType.Float) { x = val1.sheet.ReadDimension(val1.handle).ToLength(); } if (val2.handle.valueType == StyleValueType.Dimension || val2.handle.valueType == StyleValueType.Float) { y = val2.sheet.ReadDimension(val2.handle).ToLength(); } break; case 3: //X Y Z value if (val3.handle.valueType == StyleValueType.Dimension || val3.handle.valueType == StyleValueType.Float) { var dimension = val3.sheet.ReadDimension(val3.handle); if (dimension.unit != Dimension.Unit.Pixel && dimension.unit != Dimension.Unit.Unitless) { z = dimension.value; } } goto case 2; //Parse the first 2 parameters } return(new Translate(x, y, z)); }
static public TransformOrigin ReadTransformOrigin(int valCount, StylePropertyValue val1, StylePropertyValue val2, StylePropertyValue zVvalue) { Length x = Length.Percent(50), y = Length.Percent(50); float z = 0; switch (valCount) { case 1: //Single parameter, Could be x-offset(length or %) or offset-keyword (left, right, top, bottom, or center) { var val = ReadTransformOriginEnum(val1, out bool isVertical, out bool isHorizontal); if (isHorizontal) //We apply on X by default, except if we have top or bottom { x = val; } else { y = val; } break; } case 2: //two parameter ( x, y ) whether they are value or keyword. The order can be inverted if using keywords (ie top, left) { var len1 = ReadTransformOriginEnum(val1, out bool isVertical1, out bool isHorizontal1); var len2 = ReadTransformOriginEnum(val2, out bool isVertical2, out bool isHorizontal2); if (!isHorizontal1 || !isVertical2) //Argument probably are "swapped" if one of both cant be assigned "in order" to x, y { if (isHorizontal2 && isVertical1) { x = len2; y = len1; } } else { x = len1; y = len2; } break; } case 3: // xyz if (zVvalue.handle.valueType == StyleValueType.Dimension || zVvalue.handle.valueType == StyleValueType.Float) { var dimension = zVvalue.sheet.ReadDimension(zVvalue.handle); z = dimension.value; } goto case 2; //Go parse the first arguments } return(new TransformOrigin(x, y, z)); }
public bool IsKeyword(int index, StyleValueKeyword keyword) { StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; return(stylePropertyValue.handle.valueType == StyleValueType.Keyword && stylePropertyValue.handle.valueIndex == (int)keyword); }
internal static bool TryGetImageSourceFromValue(StylePropertyValue propertyValue, float dpiScaling, out ImageSource source) { source = new ImageSource(); switch (propertyValue.handle.valueType) { case StyleValueType.ResourcePath: { string path = propertyValue.sheet.ReadResourcePath(propertyValue.handle); if (!string.IsNullOrEmpty(path)) { //TODO: This will use GUIUtility.pixelsPerPoint as targetDpi, this may not be the best value for the current panel source.texture = Panel.LoadResource(path, typeof(Texture2D), dpiScaling) as Texture2D; if (source.texture == null) { source.vectorImage = Panel.LoadResource(path, typeof(VectorImage), dpiScaling) as VectorImage; } } if (source.texture == null && source.vectorImage == null) { Debug.LogWarning(string.Format("Image not found for path: {0}", path)); return(false); } } break; case StyleValueType.AssetReference: { var o = propertyValue.sheet.ReadAssetReference(propertyValue.handle); source.texture = o as Texture2D; source.vectorImage = o as VectorImage; if (source.texture == null && source.vectorImage == null) { Debug.LogWarning("Invalid image specified"); return(false); } } break; case StyleValueType.ScalableImage: { var img = propertyValue.sheet.ReadScalableImage(propertyValue.handle); if (img.normalImage == null && img.highResolutionImage == null) { Debug.LogWarning("Invalid scalable image specified"); return(false); } if (dpiScaling > 1.0f) { source.texture = img.highResolutionImage; source.texture.pixelsPerPoint = 2.0f; } else { source.texture = img.normalImage; } if (!Mathf.Approximately(dpiScaling % 1.0f, 0)) { source.texture.filterMode = FilterMode.Bilinear; } } break; default: Debug.LogWarning("Invalid value for image texture " + propertyValue.handle.valueType); return(false); } return(true); }
public string ReadAsString(int index) { StylePropertyValue stylePropertyValue = this.m_Values[this.m_CurrentValueIndex + index]; return(stylePropertyValue.sheet.ReadAsString(stylePropertyValue.handle)); }