package rui import ( "fmt" "strings" ) const ( // NoneLine constant specifies that there is no border NoneLine = 0 // SolidLine constant specifies the border/line as a solid line SolidLine = 1 // DashedLine constant specifies the border/line as a dashed line DashedLine = 2 // DottedLine constant specifies the border/line as a dotted line DottedLine = 3 // DoubleLine constant specifies the border/line as a double solid line DoubleLine = 4 // DoubleLine constant specifies the border/line as a double solid line WavyLine = 5 // LeftStyle is the constant for "left-style" property tag. LeftStyle = "left-style" // RightStyle is the constant for "-right-style" property tag. RightStyle = "right-style" // TopStyle is the constant for "top-style" property tag. TopStyle = "top-style" // BottomStyle is the constant for "bottom-style" property tag. BottomStyle = "bottom-style" // LeftWidth is the constant for "left-width" property tag. LeftWidth = "left-width" // RightWidth is the constant for "-right-width" property tag. RightWidth = "right-width" // TopWidth is the constant for "top-width" property tag. TopWidth = "top-width" // BottomWidth is the constant for "bottom-width" property tag. BottomWidth = "bottom-width" // LeftColor is the constant for "left-color" property tag. LeftColor = "left-color" // RightColor is the constant for "-right-color" property tag. RightColor = "right-color" // TopColor is the constant for "top-color" property tag. TopColor = "top-color" // BottomColor is the constant for "bottom-color" property tag. BottomColor = "bottom-color" ) // BorderProperty is the interface of a view border data type BorderProperty interface { Properties fmt.Stringer stringWriter ViewBorders(session Session) ViewBorders delete(tag string) cssStyle(builder cssBuilder, session Session) cssWidth(builder cssBuilder, session Session) cssColor(builder cssBuilder, session Session) cssStyleValue(session Session) string cssWidthValue(session Session) string cssColorValue(session Session) string } type borderProperty struct { propertyList } func newBorderProperty(value interface{}) BorderProperty { border := new(borderProperty) border.properties = map[string]interface{}{} if value != nil { switch value := value.(type) { case BorderProperty: return value case DataNode: if value.Type() == ObjectNode { _ = border.setBorderObject(value.Object()) } else { return nil } case DataObject: _ = border.setBorderObject(value) case ViewBorder: border.properties[Style] = value.Style border.properties[Width] = value.Width border.properties[ColorTag] = value.Color case ViewBorders: if value.Left.Style == value.Right.Style && value.Left.Style == value.Top.Style && value.Left.Style == value.Bottom.Style { border.properties[Style] = value.Left.Style } else { border.properties[LeftStyle] = value.Left.Style border.properties[RightStyle] = value.Right.Style border.properties[TopStyle] = value.Top.Style border.properties[BottomStyle] = value.Bottom.Style } if value.Left.Width.Equal(value.Right.Width) && value.Left.Width.Equal(value.Top.Width) && value.Left.Width.Equal(value.Bottom.Width) { border.properties[Width] = value.Left.Width } else { border.properties[LeftWidth] = value.Left.Width border.properties[RightWidth] = value.Right.Width border.properties[TopWidth] = value.Top.Width border.properties[BottomWidth] = value.Bottom.Width } if value.Left.Color == value.Right.Color && value.Left.Color == value.Top.Color && value.Left.Color == value.Bottom.Color { border.properties[ColorTag] = value.Left.Color } else { border.properties[LeftColor] = value.Left.Color border.properties[RightColor] = value.Right.Color border.properties[TopColor] = value.Top.Color border.properties[BottomColor] = value.Bottom.Color } default: invalidPropertyValue(Border, value) return nil } } return border } // NewBorder creates the new BorderProperty func NewBorder(params Params) BorderProperty { border := new(borderProperty) border.properties = map[string]interface{}{} if params != nil { for _, tag := range []string{Style, Width, ColorTag, Left, Right, Top, Bottom, LeftStyle, RightStyle, TopStyle, BottomStyle, LeftWidth, RightWidth, TopWidth, BottomWidth, LeftColor, RightColor, TopColor, BottomColor} { if value, ok := params[tag]; ok && value != nil { border.Set(tag, value) } } } return border } func (border *borderProperty) normalizeTag(tag string) string { tag = strings.ToLower(tag) switch tag { case BorderLeft, CellBorderLeft: return Left case BorderRight, CellBorderRight: return Right case BorderTop, CellBorderTop: return Top case BorderBottom, CellBorderBottom: return Bottom case BorderStyle, CellBorderStyle: return Style case BorderLeftStyle, CellBorderLeftStyle, "style-left": return LeftStyle case BorderRightStyle, CellBorderRightStyle, "style-right": return RightStyle case BorderTopStyle, CellBorderTopStyle, "style-top": return TopStyle case BorderBottomStyle, CellBorderBottomStyle, "style-bottom": return BottomStyle case BorderWidth, CellBorderWidth: return Width case BorderLeftWidth, CellBorderLeftWidth, "width-left": return LeftWidth case BorderRightWidth, CellBorderRightWidth, "width-right": return RightWidth case BorderTopWidth, CellBorderTopWidth, "width-top": return TopWidth case BorderBottomWidth, CellBorderBottomWidth, "width-bottom": return BottomWidth case BorderColor, CellBorderColor: return ColorTag case BorderLeftColor, CellBorderLeftColor, "color-left": return LeftColor case BorderRightColor, CellBorderRightColor, "color-right": return RightColor case BorderTopColor, CellBorderTopColor, "color-top": return TopColor case BorderBottomColor, CellBorderBottomColor, "color-bottom": return BottomColor } return tag } func (border *borderProperty) writeString(buffer *strings.Builder, indent string) { buffer.WriteString("_{ ") comma := false write := func(tag string, value interface{}) { if comma { buffer.WriteString(", ") } buffer.WriteString(tag) buffer.WriteString(" = ") writePropertyValue(buffer, BorderStyle, value, indent) comma = true } for _, tag := range []string{Style, Width, ColorTag} { if value, ok := border.properties[tag]; ok { write(tag, value) } } for _, side := range []string{Top, Right, Bottom, Left} { style, okStyle := border.properties[side+"-"+Style] width, okWidth := border.properties[side+"-"+Width] color, okColor := border.properties[side+"-"+ColorTag] if okStyle || okWidth || okColor { if comma { buffer.WriteString(", ") comma = false } buffer.WriteString(side) buffer.WriteString(" = _{ ") if okStyle { write(Style, style) } if okWidth { write(Width, width) } if okColor { write(ColorTag, color) } buffer.WriteString(" }") comma = true } } buffer.WriteString(" }") } func (border *borderProperty) String() string { return runStringWriter(border) } func (border *borderProperty) setSingleBorderObject(prefix string, obj DataObject) bool { result := true if text, ok := obj.PropertyValue(Style); ok { if !border.setEnumProperty(prefix+"-style", text, enumProperties[BorderStyle].values) { result = false } } if text, ok := obj.PropertyValue(ColorTag); ok { if !border.setColorProperty(prefix+"-color", text) { result = false } } if text, ok := obj.PropertyValue("width"); ok { if !border.setSizeProperty(prefix+"-width", text) { result = false } } return result } func (border *borderProperty) setBorderObject(obj DataObject) bool { result := true for _, side := range []string{Top, Right, Bottom, Left} { if node := obj.PropertyWithTag(side); node != nil { if node.Type() == ObjectNode { if !border.setSingleBorderObject(side, node.Object()) { result = false } } else { notCompatibleType(side, node) result = false } } } if text, ok := obj.PropertyValue(Style); ok { values := split4Values(text) styles := enumProperties[BorderStyle].values switch len(values) { case 1: if !border.setEnumProperty(Style, values[0], styles) { result = false } case 4: for n, tag := range [4]string{TopStyle, RightStyle, BottomStyle, LeftStyle} { if !border.setEnumProperty(tag, values[n], styles) { result = false } } default: notCompatibleType(Style, text) result = false } } if text, ok := obj.PropertyValue(ColorTag); ok { values := split4Values(text) switch len(values) { case 1: if !border.setColorProperty(ColorTag, values[0]) { return false } case 4: for n, tag := range [4]string{TopColor, RightColor, BottomColor, LeftColor} { if !border.setColorProperty(tag, values[n]) { return false } } default: notCompatibleType(ColorTag, text) result = false } } if text, ok := obj.PropertyValue(Width); ok { values := split4Values(text) switch len(values) { case 1: if !border.setSizeProperty(Width, values[0]) { result = false } case 4: for n, tag := range [4]string{TopWidth, RightWidth, BottomWidth, LeftWidth} { if !border.setSizeProperty(tag, values[n]) { result = false } } default: notCompatibleType(Width, text) result = false } } return result } func (border *borderProperty) Remove(tag string) { tag = border.normalizeTag(tag) switch tag { case Style: for _, t := range []string{tag, TopStyle, RightStyle, BottomStyle, LeftStyle} { delete(border.properties, t) } case Width: for _, t := range []string{tag, TopWidth, RightWidth, BottomWidth, LeftWidth} { delete(border.properties, t) } case ColorTag: for _, t := range []string{tag, TopColor, RightColor, BottomColor, LeftColor} { delete(border.properties, t) } case Left, Right, Top, Bottom: border.Remove(tag + "-style") border.Remove(tag + "-width") border.Remove(tag + "-color") case LeftStyle, RightStyle, TopStyle, BottomStyle: delete(border.properties, tag) if style, ok := border.properties[Style]; ok && style != nil { for _, t := range []string{TopStyle, RightStyle, BottomStyle, LeftStyle} { if t != tag { if _, ok := border.properties[t]; !ok { border.properties[t] = style } } } } case LeftWidth, RightWidth, TopWidth, BottomWidth: delete(border.properties, tag) if width, ok := border.properties[Width]; ok && width != nil { for _, t := range []string{TopWidth, RightWidth, BottomWidth, LeftWidth} { if t != tag { if _, ok := border.properties[t]; !ok { border.properties[t] = width } } } } case LeftColor, RightColor, TopColor, BottomColor: delete(border.properties, tag) if color, ok := border.properties[ColorTag]; ok && color != nil { for _, t := range []string{TopColor, RightColor, BottomColor, LeftColor} { if t != tag { if _, ok := border.properties[t]; !ok { border.properties[t] = color } } } } default: ErrorLogF(`"%s" property is not compatible with the BorderProperty`, tag) } } func (border *borderProperty) Set(tag string, value interface{}) bool { if value == nil { border.Remove(tag) return true } tag = border.normalizeTag(tag) switch tag { case Style: if border.setEnumProperty(Style, value, enumProperties[BorderStyle].values) { for _, side := range []string{TopStyle, RightStyle, BottomStyle, LeftStyle} { delete(border.properties, side) } return true } case Width: if border.setSizeProperty(Width, value) { for _, side := range []string{TopWidth, RightWidth, BottomWidth, LeftWidth} { delete(border.properties, side) } return true } case ColorTag: if border.setColorProperty(ColorTag, value) { for _, side := range []string{TopColor, RightColor, BottomColor, LeftColor} { delete(border.properties, side) } return true } case LeftStyle, RightStyle, TopStyle, BottomStyle: return border.setEnumProperty(tag, value, enumProperties[BorderStyle].values) case LeftWidth, RightWidth, TopWidth, BottomWidth: return border.setSizeProperty(tag, value) case LeftColor, RightColor, TopColor, BottomColor: return border.setColorProperty(tag, value) case Left, Right, Top, Bottom: switch value := value.(type) { case string: if obj := ParseDataText(value); obj != nil { return border.setSingleBorderObject(tag, obj) } case DataObject: return border.setSingleBorderObject(tag, value) case BorderProperty: styleTag := tag + "-" + Style if style := value.Get(styleTag); value != nil { border.properties[styleTag] = style } colorTag := tag + "-" + ColorTag if color := value.Get(colorTag); value != nil { border.properties[colorTag] = color } widthTag := tag + "-" + Width if width := value.Get(widthTag); value != nil { border.properties[widthTag] = width } return true case ViewBorder: border.properties[tag+"-"+Style] = value.Style border.properties[tag+"-"+Width] = value.Width border.properties[tag+"-"+ColorTag] = value.Color return true } fallthrough default: ErrorLogF(`"%s" property is not compatible with the BorderProperty`, tag) } return false } func (border *borderProperty) Get(tag string) interface{} { tag = border.normalizeTag(tag) if result, ok := border.properties[tag]; ok { return result } switch tag { case Left, Right, Top, Bottom: result := newBorderProperty(nil) if style, ok := border.properties[tag+"-"+Style]; ok { result.Set(Style, style) } else if style, ok := border.properties[Style]; ok { result.Set(Style, style) } if width, ok := border.properties[tag+"-"+Width]; ok { result.Set(Width, width) } else if width, ok := border.properties[Width]; ok { result.Set(Width, width) } if color, ok := border.properties[tag+"-"+ColorTag]; ok { result.Set(ColorTag, color) } else if color, ok := border.properties[ColorTag]; ok { result.Set(ColorTag, color) } return result case LeftStyle, RightStyle, TopStyle, BottomStyle: if style, ok := border.properties[tag]; ok { return style } return border.properties[Style] case LeftWidth, RightWidth, TopWidth, BottomWidth: if width, ok := border.properties[tag]; ok { return width } return border.properties[Width] case LeftColor, RightColor, TopColor, BottomColor: if color, ok := border.properties[tag]; ok { return color } return border.properties[ColorTag] } return nil } func (border *borderProperty) delete(tag string) { tag = border.normalizeTag(tag) remove := []string{} switch tag { case Style: remove = []string{Style, LeftStyle, RightStyle, TopStyle, BottomStyle} case Width: remove = []string{Width, LeftWidth, RightWidth, TopWidth, BottomWidth} case ColorTag: remove = []string{ColorTag, LeftColor, RightColor, TopColor, BottomColor} case Left, Right, Top, Bottom: if border.Get(Style) != nil { border.properties[tag+"-"+Style] = 0 remove = []string{tag + "-" + ColorTag, tag + "-" + Width} } else { remove = []string{tag + "-" + Style, tag + "-" + ColorTag, tag + "-" + Width} } case LeftStyle, RightStyle, TopStyle, BottomStyle: if border.Get(Style) != nil { border.properties[tag] = 0 } else { remove = []string{tag} } case LeftWidth, RightWidth, TopWidth, BottomWidth: if border.Get(Width) != nil { border.properties[tag] = AutoSize() } else { remove = []string{tag} } case LeftColor, RightColor, TopColor, BottomColor: if border.Get(ColorTag) != nil { border.properties[tag] = 0 } else { remove = []string{tag} } } for _, tag := range remove { delete(border.properties, tag) } } func (border *borderProperty) ViewBorders(session Session) ViewBorders { defStyle, _ := valueToEnum(border.getRaw(Style), BorderStyle, session, NoneLine) defWidth, _ := sizeProperty(border, Width, session) defColor, _ := colorProperty(border, ColorTag, session) getBorder := func(prefix string) ViewBorder { var result ViewBorder var ok bool if result.Style, ok = valueToEnum(border.getRaw(prefix+Style), BorderStyle, session, NoneLine); !ok { result.Style = defStyle } if result.Width, ok = sizeProperty(border, prefix+Width, session); !ok { result.Width = defWidth } if result.Color, ok = colorProperty(border, prefix+ColorTag, session); !ok { result.Color = defColor } return result } return ViewBorders{ Top: getBorder("top-"), Left: getBorder("left-"), Right: getBorder("right-"), Bottom: getBorder("bottom-"), } } func (border *borderProperty) cssStyle(builder cssBuilder, session Session) { borders := border.ViewBorders(session) values := enumProperties[BorderStyle].cssValues if borders.Top.Style == borders.Right.Style && borders.Top.Style == borders.Left.Style && borders.Top.Style == borders.Bottom.Style { builder.add(BorderStyle, values[borders.Top.Style]) } else { builder.addValues(BorderStyle, " ", values[borders.Top.Style], values[borders.Right.Style], values[borders.Bottom.Style], values[borders.Left.Style]) } } func (border *borderProperty) cssWidth(builder cssBuilder, session Session) { borders := border.ViewBorders(session) if borders.Top.Width == borders.Right.Width && borders.Top.Width == borders.Left.Width && borders.Top.Width == borders.Bottom.Width { if borders.Top.Width.Type != Auto { builder.add("border-width", borders.Top.Width.cssString("0")) } } else { builder.addValues("border-width", " ", borders.Top.Width.cssString("0"), borders.Right.Width.cssString("0"), borders.Bottom.Width.cssString("0"), borders.Left.Width.cssString("0")) } } func (border *borderProperty) cssColor(builder cssBuilder, session Session) { borders := border.ViewBorders(session) if borders.Top.Color == borders.Right.Color && borders.Top.Color == borders.Left.Color && borders.Top.Color == borders.Bottom.Color { if borders.Top.Color != 0 { builder.add("border-color", borders.Top.Color.cssString()) } } else { builder.addValues("border-color", " ", borders.Top.Color.cssString(), borders.Right.Color.cssString(), borders.Bottom.Color.cssString(), borders.Left.Color.cssString()) } } func (border *borderProperty) cssStyleValue(session Session) string { var builder cssValueBuilder border.cssStyle(&builder, session) return builder.finish() } func (border *borderProperty) cssWidthValue(session Session) string { var builder cssValueBuilder border.cssWidth(&builder, session) return builder.finish() } func (border *borderProperty) cssColorValue(session Session) string { var builder cssValueBuilder border.cssColor(&builder, session) return builder.finish() } // ViewBorder describes parameters of a view border type ViewBorder struct { Style int Color Color Width SizeUnit } // ViewBorders describes the top, right, bottom, and left border of a view type ViewBorders struct { Top, Right, Bottom, Left ViewBorder } // AllTheSame returns true if all borders are the same func (border *ViewBorders) AllTheSame() bool { return border.Top.Style == border.Right.Style && border.Top.Style == border.Left.Style && border.Top.Style == border.Bottom.Style && border.Top.Color == border.Right.Color && border.Top.Color == border.Left.Color && border.Top.Color == border.Bottom.Color && border.Top.Width.Equal(border.Right.Width) && border.Top.Width.Equal(border.Left.Width) && border.Top.Width.Equal(border.Bottom.Width) } func getBorder(style Properties, tag string) BorderProperty { if value := style.Get(tag); value != nil { if border, ok := value.(BorderProperty); ok { return border } } return nil }