409 lines
11 KiB
Go
409 lines
11 KiB
Go
package tss
|
|
|
|
import "os"
|
|
import "fmt"
|
|
import "image"
|
|
import "errors"
|
|
import "image/color"
|
|
import "golang.org/x/image/font"
|
|
import "github.com/flopp/go-findfont"
|
|
import "git.tebibyte.media/tomo/tomo"
|
|
import "golang.org/x/image/font/opentype"
|
|
import "git.tebibyte.media/tomo/tomo/event"
|
|
|
|
type styleBuilder struct {
|
|
sheet Sheet
|
|
fonts map[string] *opentype.Font
|
|
faces map[faceKey] font.Face
|
|
}
|
|
|
|
type faceKey struct {
|
|
name string
|
|
size int
|
|
}
|
|
|
|
// BuildStyle builds a Tomo style from the specified sheet. Resources associated
|
|
// with it (such as textures) can be freed by closing the returned cookie.
|
|
func BuildStyle (sheet Sheet) (*tomo.Style, event.Cookie, error) {
|
|
builder := &styleBuilder {
|
|
sheet: sheet,
|
|
fonts: make(map[string] *opentype.Font),
|
|
faces: make(map[faceKey] font.Face),
|
|
}
|
|
return builder.build()
|
|
}
|
|
|
|
func (this *styleBuilder) build () (*tomo.Style, event.Cookie, error) {
|
|
err := this.sheet.Flatten()
|
|
if err != nil { return nil, nil, err }
|
|
|
|
getColor := func (name string) color.Color {
|
|
if list, ok := this.sheet.Variables[name]; ok {
|
|
if len(list) > 0 {
|
|
if col, ok := list[0].(ValueColor); ok {
|
|
return col
|
|
}
|
|
}
|
|
}
|
|
return color.RGBA { R: 255, B: 255, A: 255 }
|
|
}
|
|
|
|
cookies := []event.Cookie { }
|
|
style := &tomo.Style {
|
|
Rules: make([]tomo.Rule, len(this.sheet.Rules)),
|
|
Colors: map[tomo.Color] color.Color {
|
|
tomo.ColorBackground: getColor("ColorBackground"),
|
|
tomo.ColorForeground: getColor("ColorForeground"),
|
|
tomo.ColorRaised: getColor("ColorRaised"),
|
|
tomo.ColorSunken: getColor("ColorSunken"),
|
|
tomo.ColorAccent: getColor("ColorAccent"),
|
|
},
|
|
}
|
|
|
|
for index, rule := range this.sheet.Rules {
|
|
styleRule := tomo.Rule {
|
|
Role: tomo.Role {
|
|
Package: rule.Selector.Package,
|
|
Object: rule.Selector.Object,
|
|
},
|
|
Tags: rule.Selector.Tags,
|
|
Set: make(tomo.AttrSet),
|
|
}
|
|
for name, attr := range rule.Attrs {
|
|
styleAttr, cookie, err := this.buildAttr(name, attr)
|
|
if err != nil { return nil, nil, err }
|
|
styleRule.Set.Add(styleAttr)
|
|
if cookie != nil {
|
|
cookies = append(cookies, cookie)
|
|
}
|
|
}
|
|
style.Rules[index] = styleRule
|
|
}
|
|
|
|
// TODO include all the faces in this.faces (ONCE EACH) in the
|
|
// multicookie
|
|
|
|
return style, event.MultiCookie(cookies...), nil
|
|
}
|
|
|
|
func (this *styleBuilder) buildAttr (name string, attr []ValueList) (tomo.Attr, event.Cookie, error) {
|
|
errWrongType := func () error {
|
|
return errors.New(fmt.Sprintf("wrong type for %s attribute", name))
|
|
}
|
|
expectSingle := func () error {
|
|
if len(attr) != 1 {
|
|
return errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly one value list",
|
|
name))
|
|
}
|
|
return nil
|
|
}
|
|
expectSingleSingle := func () error {
|
|
err := expectSingle()
|
|
if err != nil { return err }
|
|
if len(attr[0]) != 1 {
|
|
return errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly one value",
|
|
name))
|
|
}
|
|
return nil
|
|
}
|
|
expectNumbers := func (list ValueList) error {
|
|
for _, value := range list {
|
|
if _, ok := value.(ValueNumber); ok { continue }
|
|
return errWrongType()
|
|
}
|
|
return nil
|
|
}
|
|
numbers := func (list ValueList) ([]int, error) {
|
|
nums := make([]int, len(list))
|
|
for index, value := range list {
|
|
if value, ok := value.(ValueNumber); ok {
|
|
nums[index] = int(value)
|
|
continue
|
|
}
|
|
return nil, errWrongType()
|
|
}
|
|
return nums, nil
|
|
}
|
|
bools := func (list ValueList) ([]bool, error) {
|
|
bools := make([]bool, len(list))
|
|
for index, value := range list {
|
|
if value, ok := value.(ValueKeyword); ok {
|
|
switch value {
|
|
case "true":
|
|
bools[index] = true
|
|
continue
|
|
case "false":
|
|
bools[index] = false
|
|
continue
|
|
}
|
|
}
|
|
return nil, errWrongType()
|
|
}
|
|
return bools, nil
|
|
}
|
|
point := func (list ValueList) (image.Point, error) {
|
|
err := expectNumbers(list)
|
|
if err != nil { return image.Point { }, err }
|
|
|
|
vector := image.Point { }
|
|
switch len(attr[0]) {
|
|
case 1:
|
|
vector.X = int(list[0].(ValueNumber))
|
|
vector.Y = int(list[0].(ValueNumber))
|
|
case 2:
|
|
vector.X = int(list[0].(ValueNumber))
|
|
vector.Y = int(list[1].(ValueNumber))
|
|
default:
|
|
return image.Point { }, errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly one or two values",
|
|
name))
|
|
}
|
|
return vector, nil
|
|
}
|
|
|
|
switch name {
|
|
case "Color":
|
|
err := expectSingleSingle()
|
|
if err != nil { return nil, nil, err }
|
|
if col, ok := attr[0][0].(ValueColor); ok {
|
|
return tomo.AColor(col), nil, nil
|
|
}
|
|
return nil, nil, errWrongType()
|
|
|
|
case "Texture":
|
|
// TODO load image from file
|
|
|
|
case "TextureMode":
|
|
err := expectSingleSingle()
|
|
if err != nil { return nil, nil, err }
|
|
if keyword, ok := attr[0][0].(ValueKeyword); ok {
|
|
switch keyword {
|
|
case "tile": return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
|
|
case "center": return tomo.ATextureMode(tomo.TextureModeCenter), nil, nil
|
|
}
|
|
return nil, nil, errors.New(fmt.Sprintf (
|
|
"unknown texture mode: %s",
|
|
keyword))
|
|
}
|
|
return nil, nil, errWrongType()
|
|
|
|
case "Border":
|
|
attrBorder, err := buildAttrBorder(attr)
|
|
if err != nil { return nil, nil, err }
|
|
return attrBorder, nil, nil
|
|
|
|
case "MinimumSize":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
vector, err := point(attr[0])
|
|
if err != nil { return nil, nil, err }
|
|
return tomo.AttrMinimumSize(vector), nil, nil
|
|
|
|
case "Padding":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
numbers, err := numbers(attr[0])
|
|
if err != nil { return nil, nil, err }
|
|
inset := tomo.Inset { }
|
|
if !copyBorderValue(inset[:], numbers) {
|
|
return nil, nil, errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly one, two, or four values",
|
|
name))
|
|
}
|
|
return tomo.AttrPadding(inset), nil, nil
|
|
|
|
case "Gap":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
vector, err := point(attr[0])
|
|
if err != nil { return nil, nil, err }
|
|
return tomo.AttrGap(vector), nil, nil
|
|
|
|
case "TextColor":
|
|
err := expectSingleSingle()
|
|
if err != nil { return nil, nil, err }
|
|
if col, ok := attr[0][0].(ValueColor); ok {
|
|
return tomo.ATextColor(col), nil, nil
|
|
}
|
|
return nil, nil, errWrongType()
|
|
|
|
case "DotColor":
|
|
err := expectSingleSingle()
|
|
if err != nil { return nil, nil, err }
|
|
if col, ok := attr[0][0].(ValueColor); ok {
|
|
return tomo.ADotColor(col), nil, nil
|
|
}
|
|
return nil, nil, errWrongType()
|
|
|
|
case "Face":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
list := attr[0]
|
|
if len(list) != 2 {
|
|
return nil, nil, errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly two values",
|
|
name))
|
|
}
|
|
name, ok := list[0].(ValueString)
|
|
if !ok { return nil, nil, errWrongType() }
|
|
size, ok := list[1].(ValueNumber)
|
|
if !ok { return nil, nil, errWrongType() }
|
|
face, err := this.face(string(name), int(size))
|
|
if err != nil { return nil, nil, err }
|
|
return tomo.AFace(face), nil, nil
|
|
|
|
case "Wrap":
|
|
err := expectSingleSingle()
|
|
if err != nil { return nil, nil, err }
|
|
if value, ok := attr[0][0].(ValueKeyword); ok {
|
|
switch value {
|
|
case "true": return tomo.AWrap(true), nil, nil
|
|
case "false": return tomo.AWrap(false), nil, nil
|
|
}
|
|
}
|
|
return nil, nil, errWrongType()
|
|
|
|
case "Align":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
list := attr[0]
|
|
if len(list) != 2 {
|
|
return nil, nil, errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly two values",
|
|
name))
|
|
}
|
|
aligns := [2]tomo.Align { }
|
|
for index, value := range list {
|
|
if keyword, ok := value.(ValueKeyword); ok {
|
|
switch keyword {
|
|
case "start": aligns[index] = tomo.AlignStart; continue
|
|
case "middle": aligns[index] = tomo.AlignMiddle; continue
|
|
case "end": aligns[index] = tomo.AlignEnd; continue
|
|
case "even": aligns[index] = tomo.AlignEven; continue
|
|
default: return nil, nil, errors.New(fmt.Sprintf (
|
|
"unknown texture mode: %s",
|
|
keyword))
|
|
}
|
|
}
|
|
return nil, nil, errWrongType()
|
|
}
|
|
return tomo.AAlign(aligns[0], aligns[1]), nil, nil
|
|
|
|
case "Overflow":
|
|
err := expectSingle()
|
|
if err != nil { return nil, nil, err }
|
|
bools, err := bools(attr[0])
|
|
if err != nil { return nil, nil, err }
|
|
if len(bools) != 2 {
|
|
return nil, nil, errors.New(fmt.Sprintf (
|
|
"%s attribute requires exactly two values",
|
|
name))
|
|
}
|
|
return tomo.AOverflow(bools[0], bools[1]), nil, nil
|
|
|
|
case "Layout":
|
|
// TODO allow use of some layouts in the objects package
|
|
|
|
default: return nil, nil, errors.New(fmt.Sprintf("unknown attribute name %s", name))
|
|
}
|
|
return nil, nil, errors.New(fmt.Sprintf("unimplemented attribute name %s", name))
|
|
}
|
|
|
|
func (this *styleBuilder) face (name string, size int) (font.Face, error) {
|
|
key := faceKey { name: name, size: size }
|
|
face, ok := this.faces[key]
|
|
if ok { return face, nil }
|
|
|
|
font, ok := this.fonts[name]
|
|
if !ok {
|
|
path, err := findfont.Find(name)
|
|
if err != nil { return nil, err }
|
|
file, err := os.Open(path)
|
|
if err != nil { return nil, err }
|
|
defer file.Close()
|
|
fnt, err := opentype.ParseReaderAt(file)
|
|
if err != nil {
|
|
return nil, errors.New(fmt.Sprintf (
|
|
"could not load font %s: %v", path, err))
|
|
}
|
|
font = fnt
|
|
this.fonts[name] = font
|
|
}
|
|
|
|
face, err := opentype.NewFace(font, &opentype.FaceOptions {
|
|
Size: float64(size),
|
|
DPI: 96, // TODO: replace this with the actual DPI
|
|
})
|
|
if err != nil { return nil, err }
|
|
this.faces[key] = face
|
|
return face, nil
|
|
}
|
|
|
|
func buildAttrBorder (attr []ValueList) (tomo.Attr, error) {
|
|
borders := make([]tomo.Border, len(attr))
|
|
for index, list := range attr {
|
|
colors := make([]color.Color, 0, len(list))
|
|
sizes := make([]int, 0, len(list))
|
|
|
|
capturingSize := false
|
|
for _, value := range list {
|
|
if capturingSize {
|
|
if value, ok := value.(ValueNumber); ok {
|
|
sizes = append(sizes, int(value))
|
|
continue
|
|
}
|
|
} else {
|
|
if _, ok := value.(ValueCut); ok {
|
|
capturingSize = true
|
|
continue
|
|
}
|
|
if value, ok := value.(ValueColor); ok {
|
|
colors = append(colors, value)
|
|
continue
|
|
}
|
|
}
|
|
return nil, errors.New("malformed Border attribute value list")
|
|
}
|
|
|
|
border := tomo.Border { }
|
|
if !copyBorderValue(border.Width[:], sizes) {
|
|
return nil, errors.New("malformed Border attribute width list")
|
|
}
|
|
if !copyBorderValue(border.Color[:], colors) {
|
|
return nil, errors.New("malformed Border attribute color list")
|
|
}
|
|
borders[index] = border
|
|
}
|
|
|
|
return tomo.ABorder(borders...), nil
|
|
}
|
|
|
|
func copyBorderValue[T any, U ~[]T] (destination, source U) bool {
|
|
if len(source) > len(destination) { return false }
|
|
switch len(source) {
|
|
case 1:
|
|
destination[0] = source[0]
|
|
destination[1] = source[0]
|
|
destination[2] = source[0]
|
|
destination[3] = source[0]
|
|
return true
|
|
case 2:
|
|
destination[0] = source[0]
|
|
destination[1] = source[1]
|
|
destination[2] = source[0]
|
|
destination[3] = source[1]
|
|
return true
|
|
case 4:
|
|
destination[0] = source[0]
|
|
destination[1] = source[1]
|
|
destination[2] = source[2]
|
|
destination[3] = source[3]
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|