rui_orig/backgroundGradient.go

672 lines
17 KiB
Go
Raw Normal View History

2022-04-30 12:13:16 +03:00
package rui
import "strings"
const (
// ToTopGradient is value of the Direction property of a linear gradient. The value is equivalent to the 0deg angle
ToTopGradient = 0
// ToRightTopGradient is value of the Direction property of a linear gradient.
ToRightTopGradient = 1
// ToRightGradient is value of the Direction property of a linear gradient. The value is equivalent to the 90deg angle
ToRightGradient = 2
// ToRightBottomGradient is value of the Direction property of a linear gradient.
ToRightBottomGradient = 3
// ToBottomGradient is value of the Direction property of a linear gradient. The value is equivalent to the 180deg angle
ToBottomGradient = 4
// ToLeftBottomGradient is value of the Direction property of a linear gradient.
ToLeftBottomGradient = 5
// ToLeftGradient is value of the Direction property of a linear gradient. The value is equivalent to the 270deg angle
ToLeftGradient = 6
// ToLeftTopGradient is value of the Direction property of a linear gradient.
ToLeftTopGradient = 7
// EllipseGradient is value of the Shape property of a radial gradient background:
// the shape is an axis-aligned ellipse
EllipseGradient = 0
// CircleGradient is value of the Shape property of a radial gradient background:
// the gradient's shape is a circle with constant radius
CircleGradient = 1
// ClosestSideGradient is value of the Radius property of a radial gradient background:
// The gradient's ending shape meets the side of the box closest to its center (for circles)
// or meets both the vertical and horizontal sides closest to the center (for ellipses).
ClosestSideGradient = 0
// ClosestCornerGradient is value of the Radius property of a radial gradient background:
// The gradient's ending shape is sized so that it exactly meets the closest corner
// of the box from its center.
ClosestCornerGradient = 1
// FarthestSideGradient is value of the Radius property of a radial gradient background:
// Similar to closest-side, except the ending shape is sized to meet the side of the box
// farthest from its center (or vertical and horizontal sides).
FarthestSideGradient = 2
// FarthestCornerGradient is value of the Radius property of a radial gradient background:
// The default value, the gradient's ending shape is sized so that it exactly meets
// the farthest corner of the box from its center.
FarthestCornerGradient = 3
)
// BackgroundGradientPoint define point on gradient straight line
type BackgroundGradientPoint struct {
2022-04-30 18:02:01 +03:00
// Color - the color of the point. Must not be nil.
// Can take a value of Color type or string (color constant or textual description of the color)
2022-07-26 18:36:00 +03:00
Color any
2022-04-30 18:02:01 +03:00
// Pos - the distance from the start of the gradient straight line. Optional (may be nil).
// Can take a value of SizeUnit type or string (angle constant or textual description of the SizeUnit)
2022-07-26 18:36:00 +03:00
Pos any
2022-04-30 12:13:16 +03:00
}
type backgroundGradient struct {
backgroundElement
}
type backgroundLinearGradient struct {
backgroundGradient
}
type backgroundRadialGradient struct {
backgroundGradient
}
// NewBackgroundLinearGradient creates the new background linear gradient
func NewBackgroundLinearGradient(params Params) BackgroundElement {
result := new(backgroundLinearGradient)
2022-07-26 18:36:00 +03:00
result.properties = map[string]any{}
2022-04-30 12:13:16 +03:00
for tag, value := range params {
result.Set(tag, value)
}
return result
}
// NewBackgroundRadialGradient creates the new background radial gradient
func NewBackgroundRadialGradient(params Params) BackgroundElement {
result := new(backgroundRadialGradient)
2022-07-26 18:36:00 +03:00
result.properties = map[string]any{}
2022-04-30 12:13:16 +03:00
for tag, value := range params {
result.Set(tag, value)
}
return result
}
2022-04-30 18:02:01 +03:00
func (gradient *backgroundGradient) parseGradientText(value string) []BackgroundGradientPoint {
elements := strings.Split(value, ",")
count := len(elements)
if count < 2 {
ErrorLog("The gradient must contain at least 2 points")
return nil
}
points := make([]BackgroundGradientPoint, count)
for i, element := range elements {
if !points[i].setValue(element) {
2022-11-23 15:10:29 +03:00
ErrorLogF(`Invalid %d element of the conic gradient: "%s"`, i, element)
2022-04-30 18:02:01 +03:00
return nil
}
}
return points
}
2022-07-26 18:36:00 +03:00
func (gradient *backgroundGradient) Set(tag string, value any) bool {
2022-04-30 12:13:16 +03:00
switch tag = strings.ToLower(tag); tag {
case Repeating:
return gradient.setBoolProperty(tag, value)
case Gradient:
switch value := value.(type) {
case string:
if value != "" {
2022-04-30 18:02:01 +03:00
if strings.Contains(value, " ") || strings.Contains(value, ",") {
if points := gradient.parseGradientText(value); len(points) >= 2 {
gradient.properties[Gradient] = points
return true
2022-04-30 12:13:16 +03:00
}
2022-04-30 18:02:01 +03:00
} else if value[0] == '@' {
gradient.properties[Gradient] = value
2022-04-30 12:13:16 +03:00
return true
}
}
case []BackgroundGradientPoint:
if len(value) >= 2 {
gradient.properties[Gradient] = value
return true
}
case []Color:
count := len(value)
if count >= 2 {
points := make([]BackgroundGradientPoint, count)
for i, color := range value {
points[i].Color = color
}
gradient.properties[Gradient] = points
return true
}
case []GradientPoint:
count := len(value)
if count >= 2 {
points := make([]BackgroundGradientPoint, count)
for i, point := range value {
points[i].Color = point.Color
points[i].Pos = Percent(point.Offset * 100)
}
gradient.properties[Gradient] = points
return true
}
2022-04-30 18:02:01 +03:00
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
ErrorLogF("Invalid gradient %v", value)
return false
}
2022-05-01 13:27:04 +03:00
ErrorLogF("Property %s is not supported by a background gradient", tag)
return false
2022-04-30 18:02:01 +03:00
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
func (point *BackgroundGradientPoint) setValue(text string) bool {
text = strings.Trim(text, " ")
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
colorText := text
pointText := ""
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
if index := strings.Index(text, " "); index > 0 {
colorText = text[:index]
pointText = strings.Trim(text[index+1:], " ")
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
if colorText == "" {
return false
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
if colorText[0] == '@' {
point.Color = colorText
} else if color, ok := StringToColor(colorText); ok {
point.Color = color
} else {
return false
2022-04-30 12:13:16 +03:00
}
2022-04-30 18:02:01 +03:00
if pointText == "" {
point.Pos = nil
} else if pointText[0] == '@' {
point.Pos = pointText
} else if pos, ok := StringToSizeUnit(pointText); ok {
point.Pos = pos
} else {
return false
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
return true
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
func (point *BackgroundGradientPoint) color(session Session) (Color, bool) {
if point.Color != nil {
switch color := point.Color.(type) {
case string:
if color != "" {
if color[0] == '@' {
if clr, ok := session.Color(color[1:]); ok {
return clr, true
}
} else {
if clr, ok := StringToColor(color); ok {
return clr, true
}
}
}
2022-04-30 12:13:16 +03:00
2022-04-30 18:02:01 +03:00
case Color:
return color, true
2022-04-30 12:13:16 +03:00
}
}
2022-04-30 18:02:01 +03:00
return 0, false
2022-04-30 12:13:16 +03:00
}
2024-04-22 19:14:58 +03:00
func (point *BackgroundGradientPoint) String() string {
result := "black"
if point.Color != nil {
switch color := point.Color.(type) {
case string:
result = color
case Color:
result = color.String()
}
}
if point.Pos != nil {
switch value := point.Pos.(type) {
case string:
result += " " + value
case SizeUnit:
if value.Type != Auto {
result += " " + value.String()
}
}
}
return result
}
2022-04-30 12:13:16 +03:00
func (gradient *backgroundGradient) writeGradient(session Session, buffer *strings.Builder) bool {
value, ok := gradient.properties[Gradient]
if !ok {
return false
}
2022-04-30 18:02:01 +03:00
var points []BackgroundGradientPoint = nil
2022-04-30 12:13:16 +03:00
switch value := value.(type) {
case string:
2022-04-30 18:02:01 +03:00
if value != "" && value[0] == '@' {
if text, ok := session.Constant(value[1:]); ok {
points = gradient.parseGradientText(text)
2022-04-30 12:13:16 +03:00
}
}
case []BackgroundGradientPoint:
points = value
}
if len(points) > 0 {
for i, point := range points {
if i > 0 {
buffer.WriteString(`, `)
}
2022-04-30 18:02:01 +03:00
if color, ok := point.color(session); ok {
buffer.WriteString(color.cssString())
} else {
return false
}
if point.Pos != nil {
switch value := point.Pos.(type) {
case string:
if value != "" {
if value, ok := session.resolveConstants(value); ok {
if pos, ok := StringToSizeUnit(value); ok && pos.Type != Auto {
buffer.WriteRune(' ')
buffer.WriteString(pos.cssString("", session))
}
2022-04-30 18:02:01 +03:00
}
}
case SizeUnit:
if value.Type != Auto {
buffer.WriteRune(' ')
buffer.WriteString(value.cssString("", session))
2022-04-30 18:02:01 +03:00
}
}
2022-04-30 12:13:16 +03:00
}
}
return true
}
return false
}
func (gradient *backgroundLinearGradient) Tag() string {
return "linear-gradient"
}
func (image *backgroundLinearGradient) Clone() BackgroundElement {
result := NewBackgroundLinearGradient(nil)
for tag, value := range image.properties {
result.setRaw(tag, value)
}
return result
}
2022-07-26 18:36:00 +03:00
func (gradient *backgroundLinearGradient) Set(tag string, value any) bool {
2022-04-30 12:13:16 +03:00
if strings.ToLower(tag) == Direction {
switch value := value.(type) {
case AngleUnit:
gradient.properties[Direction] = value
return true
case string:
2022-05-01 13:27:04 +03:00
if gradient.setSimpleProperty(tag, value) {
return true
}
if angle, ok := StringToAngleUnit(value); ok {
2022-04-30 12:13:16 +03:00
gradient.properties[Direction] = angle
return true
}
}
return gradient.setEnumProperty(tag, value, enumProperties[Direction].values)
}
return gradient.backgroundGradient.Set(tag, value)
}
func (gradient *backgroundLinearGradient) cssStyle(session Session) string {
buffer := allocStringBuilder()
defer freeStringBuilder(buffer)
if repeating, _ := boolProperty(gradient, Repeating, session); repeating {
buffer.WriteString(`repeating-linear-gradient(`)
} else {
buffer.WriteString(`linear-gradient(`)
}
if value, ok := gradient.properties[Direction]; ok {
switch value := value.(type) {
case string:
if text, ok := session.resolveConstants(value); ok {
direction := enumProperties[Direction]
if n, ok := enumStringToInt(text, direction.values, false); ok {
buffer.WriteString(direction.cssValues[n])
buffer.WriteString(", ")
} else {
if angle, ok := StringToAngleUnit(text); ok {
buffer.WriteString(angle.cssString())
buffer.WriteString(", ")
} else {
ErrorLog(`Invalid linear gradient direction: ` + text)
}
}
} else {
ErrorLog(`Invalid linear gradient direction: ` + value)
}
case int:
values := enumProperties[Direction].cssValues
if value >= 0 && value < len(values) {
buffer.WriteString(values[value])
buffer.WriteString(", ")
} else {
ErrorLogF(`Invalid linear gradient direction: %d`, value)
}
case AngleUnit:
buffer.WriteString(value.cssString())
buffer.WriteString(", ")
}
}
if !gradient.writeGradient(session, buffer) {
return ""
}
buffer.WriteString(") ")
return buffer.String()
}
2024-04-22 19:14:58 +03:00
func (gradient *backgroundLinearGradient) writeString(buffer *strings.Builder, indent string) {
gradient.writeToBuffer(buffer, indent, gradient.Tag(), []string{
Gradient,
Repeating,
Direction,
})
}
func (gradient *backgroundLinearGradient) String() string {
buffer := allocStringBuilder()
defer freeStringBuilder(buffer)
gradient.writeString(buffer, "")
return buffer.String()
}
2022-04-30 12:13:16 +03:00
func (gradient *backgroundRadialGradient) Tag() string {
return "radial-gradient"
}
func (image *backgroundRadialGradient) Clone() BackgroundElement {
result := NewBackgroundRadialGradient(nil)
for tag, value := range image.properties {
result.setRaw(tag, value)
}
return result
}
func (gradient *backgroundRadialGradient) normalizeTag(tag string) string {
tag = strings.ToLower(tag)
switch tag {
case Radius:
tag = RadialGradientRadius
case Shape:
tag = RadialGradientShape
case "x-center":
tag = CenterX
case "y-center":
tag = CenterY
}
return tag
}
2022-07-26 18:36:00 +03:00
func (gradient *backgroundRadialGradient) Set(tag string, value any) bool {
2022-04-30 12:13:16 +03:00
tag = gradient.normalizeTag(tag)
switch tag {
case RadialGradientRadius:
switch value := value.(type) {
2022-05-01 13:27:04 +03:00
case []SizeUnit:
switch len(value) {
case 0:
delete(gradient.properties, RadialGradientRadius)
return true
case 1:
if value[0].Type == Auto {
delete(gradient.properties, RadialGradientRadius)
} else {
gradient.properties[RadialGradientRadius] = value[0]
}
return true
default:
gradient.properties[RadialGradientRadius] = value
return true
}
2022-07-26 18:36:00 +03:00
case []any:
2022-05-01 13:27:04 +03:00
switch len(value) {
case 0:
delete(gradient.properties, RadialGradientRadius)
return true
case 1:
return gradient.Set(RadialGradientRadius, value[0])
default:
gradient.properties[RadialGradientRadius] = value
return true
}
case string:
if gradient.setSimpleProperty(RadialGradientRadius, value) {
return true
}
if size, err := stringToSizeUnit(value); err == nil {
if size.Type == Auto {
delete(gradient.properties, RadialGradientRadius)
} else {
gradient.properties[RadialGradientRadius] = size
}
return true
}
return gradient.setEnumProperty(RadialGradientRadius, value, enumProperties[RadialGradientRadius].values)
case SizeUnit:
if value.Type == Auto {
delete(gradient.properties, RadialGradientRadius)
} else {
gradient.properties[RadialGradientRadius] = value
}
return true
2022-04-30 12:13:16 +03:00
case int:
n := value
if n >= 0 && n < len(enumProperties[RadialGradientRadius].values) {
return gradient.propertyList.Set(RadialGradientRadius, value)
}
}
ErrorLogF(`Invalid value of "%s" property: %v`, tag, value)
2022-05-01 13:27:04 +03:00
case RadialGradientShape, CenterX, CenterY:
2022-04-30 12:13:16 +03:00
return gradient.propertyList.Set(tag, value)
}
return gradient.backgroundGradient.Set(tag, value)
}
2022-07-26 18:36:00 +03:00
func (gradient *backgroundRadialGradient) Get(tag string) any {
2022-04-30 12:13:16 +03:00
return gradient.backgroundGradient.Get(gradient.normalizeTag(tag))
}
func (gradient *backgroundRadialGradient) cssStyle(session Session) string {
buffer := allocStringBuilder()
defer freeStringBuilder(buffer)
if repeating, _ := boolProperty(gradient, Repeating, session); repeating {
buffer.WriteString(`repeating-radial-gradient(`)
} else {
buffer.WriteString(`radial-gradient(`)
}
2022-05-01 13:27:04 +03:00
var shapeText string
2022-04-30 12:13:16 +03:00
if shape, ok := enumProperty(gradient, RadialGradientShape, session, EllipseGradient); ok && shape == CircleGradient {
2022-05-01 13:27:04 +03:00
shapeText = `circle `
2022-04-30 12:13:16 +03:00
} else {
2022-05-01 13:27:04 +03:00
shapeText = `ellipse `
2022-04-30 12:13:16 +03:00
}
if value, ok := gradient.properties[RadialGradientRadius]; ok {
switch value := value.(type) {
case string:
if text, ok := session.resolveConstants(value); ok {
values := enumProperties[RadialGradientRadius]
if n, ok := enumStringToInt(text, values.values, false); ok {
2022-05-01 13:27:04 +03:00
buffer.WriteString(shapeText)
shapeText = ""
2022-04-30 12:13:16 +03:00
buffer.WriteString(values.cssValues[n])
buffer.WriteString(" ")
} else {
if r, ok := StringToSizeUnit(text); ok && r.Type != Auto {
2022-05-01 13:27:04 +03:00
buffer.WriteString("ellipse ")
shapeText = ""
buffer.WriteString(r.cssString("", session))
2022-05-01 13:27:04 +03:00
buffer.WriteString(" ")
buffer.WriteString(r.cssString("", session))
2022-04-30 12:13:16 +03:00
buffer.WriteString(" ")
} else {
ErrorLog(`Invalid radial gradient radius: ` + text)
}
}
} else {
ErrorLog(`Invalid radial gradient radius: ` + value)
}
case int:
values := enumProperties[RadialGradientRadius].cssValues
if value >= 0 && value < len(values) {
2022-05-01 13:27:04 +03:00
buffer.WriteString(shapeText)
shapeText = ""
2022-04-30 12:13:16 +03:00
buffer.WriteString(values[value])
buffer.WriteString(" ")
} else {
ErrorLogF(`Invalid radial gradient radius: %d`, value)
}
case SizeUnit:
if value.Type != Auto {
2022-05-01 13:27:04 +03:00
buffer.WriteString("ellipse ")
shapeText = ""
buffer.WriteString(value.cssString("", session))
2022-04-30 12:13:16 +03:00
buffer.WriteString(" ")
buffer.WriteString(value.cssString("", session))
2022-05-01 13:27:04 +03:00
buffer.WriteString(" ")
}
case []SizeUnit:
count := len(value)
if count > 2 {
count = 2
}
buffer.WriteString("ellipse ")
shapeText = ""
for i := 0; i < count; i++ {
buffer.WriteString(value[i].cssString("50%", session))
2022-05-01 13:27:04 +03:00
buffer.WriteString(" ")
}
2022-07-26 18:36:00 +03:00
case []any:
2022-05-01 13:27:04 +03:00
count := len(value)
if count > 2 {
count = 2
}
buffer.WriteString("ellipse ")
shapeText = ""
for i := 0; i < count; i++ {
if value[i] != nil {
switch value := value[i].(type) {
case SizeUnit:
buffer.WriteString(value.cssString("50%", session))
2022-05-01 13:27:04 +03:00
buffer.WriteString(" ")
case string:
if text, ok := session.resolveConstants(value); ok {
if size, err := stringToSizeUnit(text); err == nil {
buffer.WriteString(size.cssString("50%", session))
2022-05-01 13:27:04 +03:00
buffer.WriteString(" ")
} else {
buffer.WriteString("50% ")
}
} else {
buffer.WriteString("50% ")
}
}
} else {
buffer.WriteString("50% ")
}
2022-04-30 12:13:16 +03:00
}
}
}
x, _ := sizeProperty(gradient, CenterX, session)
y, _ := sizeProperty(gradient, CenterX, session)
if x.Type != Auto || y.Type != Auto {
2022-05-01 13:27:04 +03:00
if shapeText != "" {
buffer.WriteString(shapeText)
}
2022-04-30 12:13:16 +03:00
buffer.WriteString("at ")
buffer.WriteString(x.cssString("50%", session))
2022-04-30 12:13:16 +03:00
buffer.WriteString(" ")
buffer.WriteString(y.cssString("50%", session))
2022-04-30 12:13:16 +03:00
}
buffer.WriteString(", ")
if !gradient.writeGradient(session, buffer) {
return ""
}
buffer.WriteString(") ")
return buffer.String()
}
2024-04-22 19:14:58 +03:00
func (gradient *backgroundRadialGradient) writeString(buffer *strings.Builder, indent string) {
gradient.writeToBuffer(buffer, indent, gradient.Tag(), []string{
Gradient,
CenterX,
CenterY,
Repeating,
RadialGradientShape,
RadialGradientRadius,
})
}
func (gradient *backgroundRadialGradient) String() string {
buffer := allocStringBuilder()
defer freeStringBuilder(buffer)
gradient.writeString(buffer, "")
return buffer.String()
}