application.go

@@ -65,15 +65,6 @@ type ApplicationDescription struct {
 	Role ApplicationRole
 }
 
-// GlobalApplicationDescription returns the global application description which
-// points to cache, data, config, etc. used by Nasin itself.
-func GlobalApplicationDescription () ApplicationDescription {
-	return ApplicationDescription {
-		Name: "Nasin",
-		ID:   "xyz.holanet.Nasin",
-	}
-}
-
 // String satisfies the fmt.Stringer interface.
 func (application ApplicationDescription) String () string {
 	if application.Name == "" {
@@ -142,9 +133,8 @@ func RunApplication (application Application) {
 	if err != nil { log.Fatalln("nasin: could not register backend:", err) }
 	err = tomo.Run(func () {
 		err := registrar.SetTheme()
+		err := registrar.SetIconSet()
 		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
-		err = registrar.SetIconSet()
-		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
 		err = application.Init()
 		if err != nil { log.Fatalln("nasin: could not run application:", err) }
 

go.mod

@@ -8,12 +8,9 @@ require (
 	git.tebibyte.media/tomo/objects v0.20.1
 	git.tebibyte.media/tomo/tomo v0.41.1
 	git.tebibyte.media/tomo/xdg v0.1.0
-	github.com/flopp/go-findfont v0.1.0
 	golang.org/x/image v0.11.0
 )
 
-replace git.tebibyte.media/tomo/tomo => /home/sashakoshka/Repos/tebibyte/tomo/tomo
-
 require (
 	git.tebibyte.media/tomo/typeset v0.7.1 // indirect
 	git.tebibyte.media/tomo/xgbkb v1.0.1 // indirect
@@ -21,5 +18,4 @@ require (
 	github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
 	github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111 // indirect
-	golang.org/x/text v0.12.0 // indirect
 )

go.sum

@@ -5,6 +5,8 @@ git.tebibyte.media/tomo/backend v0.5.1 h1:u3DLVcNWNdQsIxAEGcZ+kGG7zuew8tpPbyEFBx
 git.tebibyte.media/tomo/backend v0.5.1/go.mod h1:urnfu+D56Q9AOCZ/qp5YqkmlRRTIB5p9RbzBN7yIibQ=
 git.tebibyte.media/tomo/objects v0.20.1 h1:dCMMzaHmj7w016XtTb8QWvKMHVK2Fru/2a70NqApzHQ=
 git.tebibyte.media/tomo/objects v0.20.1/go.mod h1:hbBlQem9cNOt/G2rBvH/C94FT1oWgbtEftwg6ield9U=
+git.tebibyte.media/tomo/tomo v0.41.1 h1:XdbyF3VjsLj1Zppr70gUaufuh49hU32JQo2ENnw4PcA=
+git.tebibyte.media/tomo/tomo v0.41.1/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
 git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
 git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xdg v0.1.0 h1:6G2WYPPiM2IXleCpKKHuJA34BxumwNWuLsUoX3yu5zA=
@@ -15,8 +17,6 @@ github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJ
 github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298/go.mod h1:D+QujdIlUNfa0igpNMk6UIvlb6C252URs4yupRUV4lQ=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966 h1:lTG4HQym5oPKjL7nGs+csTgiDna685ZXjxijkne828g=
 github.com/BurntSushi/graphics-go v0.0.0-20160129215708-b43f31a4a966/go.mod h1:Mid70uvE93zn9wgF92A/r5ixgnvX8Lh68fxp9KQBaI0=
-github.com/flopp/go-findfont v0.1.0 h1:lPn0BymDUtJo+ZkV01VS3661HL6F4qFlkhcJN55u6mU=
-github.com/flopp/go-findfont v0.1.0/go.mod h1:wKKxRDjD024Rh7VMwoU90i6ikQRCr+JTHB5n4Ejkqvw=
 github.com/jezek/xgb v1.1.0/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
@@ -50,7 +50,6 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
 golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

internal/registrar/registrar_unix.go

@@ -5,7 +5,6 @@ import "os"
 import "log"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/backend/x"
-import "git.tebibyte.media/sashakoshka/goparse"
 import "git.tebibyte.media/tomo/nasin/internal/icons/xdg"
 import "git.tebibyte.media/tomo/nasin/internal/style/tss"
 import "git.tebibyte.media/tomo/nasin/internal/icons/fallback"
@@ -24,11 +23,8 @@ func SetTheme () error {
 		styl, _, err := tss.LoadFile(styleSheetName)
 		if err == nil {
 			tomo.SetStyle(styl)
-			return nil
 		} else {
-			log.Printf (
+			log.Printf("nasin: could not load style sheet '%s': %v", styleSheetName, err)
-				"nasin: could not load style sheet '%s'\n%v",
-				styleSheetName, parse.Format(err))
 		}
 	}
 	

internal/style/aluminum.tss

@@ -1,211 +0,0 @@
-// Colors
-$ColorDot                   = #7391c0;
-$ColorAccent                = #5f8bc4;
-$ColorHighlight             = #5f8bc4;
-$ColorBackground            = #d4d4d4;
-$ColorForeground            = #000;
-$ColorOutline               = $ColorForeground;
-$ColorGutter                = #bfc6d1;
-$ColorGutterHovered         = #c5cbd6;
-$ColorRaised                = #e9eaea;
-$ColorRaisedPressed         = #ccd4dd;
-$ColorRaisedFocused         = #cfd6dd;
-$ColorRaisedHovered         = #f1f3f5;
-$ColorSunken                = #e9eaea;
-$ColorSunkenFocused         = #e0e6ee;
-$ColorSunkenPressed         = #e0e6ee;
-$ColorCalendarWeekdayHeader = #d3cac2;
-$ColorCalendarWeekend       = #c2d3c4;
-$ColorCalendarDay           = #d6dae2;
-
-// Borders
-$BorderOutline        = $ColorOutline                   / 1;
-$BorderEngraved       = #c3c3c5 #e3e3e3 #e9e9e9 #c2c2c2 / 1;
-$BorderGap            = #697c7c #566767 #566767 #697c7c / 1;
-$BorderLifted         = #f9fafc #c2c8d3 #a4afc0 #f5f6f8 / 1;
-$BorderLiftedFocused  = #f0f4f9 #b1baca #9aa6b7 #e4e9ee / 1;
-$BorderFocused        = #5f8bc4 #5f8bc4 #5f8bc4 #5f8bc4 / 1;
-$BorderTear           = $BorderEngraved;
-$BorderTearFocused    = #7f94b5 #ced7e4 #ced7e4 #7f94b5 / 1;
-$BorderTearPad        = #0000                           / 3;
-$BorderTearPadFocused = #7391c080                       / 3;
-$BorderInnerShadow    = #a4afc0                         / 1 0 0 1;
-$BorderOuterShadow    = #a4afc0                         / 0 1 1 0;
-
-*.* {
-	TextColor: $ColorForeground;
-	DotColor:  $ColorDot;
-	Gap:       8;
-	Face:      "DMMono-Regular.ttf" 11;
-}
-
-*.Button {
-	Border:  $BorderEngraved, $BorderGap, $BorderLifted;
-	Padding: 4 8;
-	Color:   $ColorRaised;
-}
-
-*.Button[focused] {
-	Border:  $BorderEngraved, $BorderGap, $BorderLiftedFocused;
-	Padding: 4 8;
-	Color:   $ColorRaisedFocused;
-}
-
-*.Button[hovered] {
-	Color: $ColorRaisedHovered;
-}
-
-*.Button[pressed] {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Padding: 5 8 4 9;
-	Color:   $ColorRaisedPressed;
-}
-
-*.TextInput {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Padding: 5 4 4 5;
-	Color:   $ColorSunken;
-}
-
-*.TextInput[focused] {
-	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
-}
-
-*.TextView {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Padding: 5 4 4 5;
-	Color:   $ColorSunken;
-}
-
-*.NumberInput {
-	Gap: 0;
-}
-
-*.Container[sunken] {
-	Border:  $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Padding: 5 4 4 5;
-	Color:   $ColorSunken;
-}
-
-*.Container[outer] {
-	Color:   $ColorBackground;
-	Padding: 8;
-}
-
-*.Container[menu] {
-	Border: $BorderGap, $BorderLifted;
-	Color:  $ColorBackground;
-	Gap:    0;
-}
-
-*.Heading {
-	Align: middle middle;
-}
-
-*.Separator {
-	Border: $BorderEngraved;
-}
-
-*.Slider {
-	Border: $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Color:  $ColorGutter;
-}
-
-*.Slider[focused] {
-	Border: $BorderEngraved, $BorderFocused, $BorderInnerShadow;
-}
-
-*.Slider[hovered] {
-	Color: $ColorGutterHovered;
-}
-
-*.Slider[horizontal] {
-	MinimumSize: 48 0;
-}
-
-*.Slider[vertical] {
-	MinimumSize: 0 48;
-}
-
-*.SliderHandle {
-	Border:      $BorderOuterShadow, $BorderGap, $BorderLifted;
-	Color:       $ColorRaised;
-	MinimumSize: 12;
-}
-
-*.ScrollContainer {
-	Gap: 0;
-}
-
-*.Checkbox {
-	Border:      $BorderEngraved, $BorderGap, $BorderInnerShadow;
-	Color:       $ColorSunken;
-	Padding:     0 1 1 0;
-	MinimumSize: 19;
-}
-
-*.Checkbox[focused] {
-	Border:  $BorderEngraved, $BorderFocused, $BorderInnerShadow;
-	Color:   $ColorSunkenFocused;
-	Padding: 0;
-}
-
-*.MenuItem {
-	Padding: 4;
-	Gap:     4;
-	Color:   #0000;
-}
-
-*.MenuItem[hovered] {
-	Color: $ColorDot;
-}
-
-*.MenuItem[focused] {
-	Color: $ColorDot;
-}
-
-*.File {
-	Color: #0000;
-}
-
-*.File[focused] {
-	Color: $ColorDot;
-}
-
-*.TearLine {
-	Border: $BorderTearPad, $BorderTear;
-}
-
-*.TearLine[hovered] {
-	Border: $BorderTearPadFocused, $BorderTearFocused;
-}
-
-*.TearLine[focused] {
-	Border: $BorderTearPadFocused, $BorderTearFocused;
-}
-
-*.Calendar {
-	Border:  $BorderOuterShadow, $BorderGap;
-	Color:   $ColorRaised;
-	Padding: 2;
-	Gap:     2;
-}
-
-*.CalendarGrid {
-	Gap: 2 2;
-}
-
-*.CalendarWeekdayHeader {
-	Color:   $ColorCalendarWeekdayHeader;
-	Padding: 2;
-}
-
-*.CalendarDay {
-	Color:       $ColorCalendarDay;
-	Padding:     2;
-	MinimumSize: 32;
-}
-
-*.CalendarDay[weekend] {
-	Color: $ColorCalendarWeekend;
-}

internal/style/styleminimal.tss

@@ -1,14 +0,0 @@
-$ColorBackground = #FFF;
-$ColorForeground = #000;
-$ColorRaised     = #AAA;
-$ColorSunken     = #888;
-$ColorAccent     = #0FF;
-
-*.* {
-	Color:     $ColorBackground;
-	Border:    $ColorForeground / 1;
-	TextColor: $ColorForeground;
-	DotColor:  $ColorAccent;
-	Padding:   2;
-}
-

internal/style/tss/build.go

@@ -1,408 +0,0 @@
-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
-	}
-}
-

internal/style/tss/color_test.go

@@ -1,17 +0,0 @@
-package tss
-
-import "testing"
-
-func TestValueColor (test *testing.T) {
-	testValueColorRGBA(test, 0xFB380CFF, 0xFBFB, 0x3838, 0x0C0C, 0xFFFF)
-	testValueColorRGBA(test, 0xFB380C00, 0x0000, 0x0000, 0x0000, 0x0000)
-}
-
-func testValueColorRGBA (test *testing.T, col ValueColor, r, g, b, a uint32) {
-	gr, gg, gb, ga := col.RGBA()
-	test.Logf("testing RGBA for color #%08X", col)
-	if gr != r { test.Errorf("r component inequal (%04X != %04X)", gr, r) }
-	if gg != g { test.Errorf("g component inequal (%04X != %04X)", gg, g) }
-	if gb != b { test.Errorf("b component inequal (%04X != %04X)", gb, b) }
-	if ga != a { test.Errorf("a component inequal (%04X != %04X)", ga, a) }
-}

internal/style/tss/flatten.go

@@ -1,53 +0,0 @@
-package tss
-
-import "fmt"
-import "errors"
-
-// Flatten evaluates all variables recursively, thereby eliminating all
-// instances of ValueVariable.
-func (this *Sheet) Flatten () error {
-	if this.flat { return nil }
-	this.flat = true
-	
-	for name, variable := range this.Variables {
-		variable, err := this.eval(variable)
-		if err != nil { return err }
-		this.Variables[name] = variable
-	}
-	
-	for index, rule := range this.Rules {
-		for name, attr := range rule.Attrs {
-			for index, list := range attr {
-				list, err := this.eval(list)
-				if err != nil { return err }
-				attr[index] = list
-			}
-			rule.Attrs[name] = attr
-		}
-		this.Rules[index] = rule
-	}
-	
-	return nil
-}
-
-func (this *Sheet) eval (source ValueList) (ValueList, error) {
-	destination := make(ValueList, 0, len(source))
-	for _, value := range source {
-		if name, ok := value.(ValueVariable); ok {
-			variable, ok := this.Variables[string(name)]
-			if !ok {
-				return nil, errors.New(fmt.Sprintf(
-					"variable $%s does not exist",
-					value))
-			}
-			variable, err := this.eval(variable)
-			if err != nil { return nil, err }
-			destination = append(destination, variable...)
-			continue
-		} else {
-			destination = append(destination, value)
-		}
-	}
-	
-	return destination, nil
-}

internal/style/tss/lex.go

@@ -19,7 +19,6 @@ const (
 	Star
 	Dot
 	Dollar
-	Slash
 	Color
 	Ident
 	Number
@@ -40,7 +39,6 @@ var tokenNames = map[parse.TokenKind] string {
 	Star: "Star",
 	Dot: "Dot",
 	Dollar: "Dollar",
-	Slash: "Slash",
 	Color: "Color",
 	Ident: "Ident",
 	Number: "Number",
@@ -117,8 +115,6 @@ func (this *lexer) next () (token parse.Token, err error) {
 				skipRune()
 				if err != nil { return }
 			}
-		} else {
-			token.Kind = Slash
 		}
 		if this.eof { err = nil; return }
 

internal/style/tss/parse.go

@@ -4,6 +4,43 @@ import "io"
 import "strconv"
 import "git.tebibyte.media/sashakoshka/goparse"
 
+type Sheet struct {
+	Variables map[string] ValueList
+	Rules     []Rule
+}
+
+type Rule struct {
+	Selector Selector
+	Attrs    map[string] []ValueList
+}
+
+type Selector struct {
+	Package string
+	Object  string
+	Tags    []string
+}
+
+type ValueList []Value
+
+type Value interface {
+	value ()
+}
+
+func (ValueNumber) value () { }
+type ValueNumber int
+
+func (ValueColor) value () { }
+type ValueColor uint32
+
+func (ValueString) value () { }
+type ValueString string
+
+func (ValueKeyword) value () { }
+type ValueKeyword string
+
+func (ValueVariable) value () { }
+type ValueVariable string
+
 type parser struct {
 	parse.Parser
 	sheet Sheet
@@ -68,9 +105,9 @@ func (this *parser) parseVariable () (string, ValueList, error) {
 	if err != nil { return "", nil, err }
 	err = this.ExpectNext(Ident)
 	if err != nil { return "", nil, err }
-	name := this.Value()
 	err = this.ExpectNext(Equals)
 	if err != nil { return "", nil, err }
+	name := this.Value()
 	this.Next()
 	values, err := this.parseValueList()
 	if err != nil { return "", nil, err }
@@ -87,18 +124,15 @@ func (this *parser) parseRule () (Rule, error) {
 	selector, err := this.parseSelector()
 	if err != nil { return Rule { }, err }
 	rule.Selector = selector
-	err = this.Expect(LBrace)
+	err = this.Expect(LBracket)
 	if err != nil { return Rule { }, err }
 	
 	for {
-		this.Next()
-		if this.Is(RBrace) { break }
 		pos := this.Pos()
 		name, attr, err := this.parseAttr()
-		if err != nil { return Rule { }, err }
+		if err != nil { break }
-		err = this.Expect(Semicolon)
+		_, exists := rule.Attrs[name]
-		if err != nil { return Rule { }, err }
+		if !exists {
-		if _, exists := rule.Attrs[name]; exists {
 			return Rule { }, parse.Errorf (
 				pos,
 				"attribute %s already declared in this rule",
@@ -107,6 +141,8 @@ func (this *parser) parseRule () (Rule, error) {
 		rule.Attrs[name] = attr
 	}
 	
+	err = this.Expect(LBracket)
+	if err != nil { return Rule { }, err }
 	return rule, this.Next()
 }
 
@@ -131,22 +167,20 @@ func (this *parser) parseSelector () (Selector, error) {
 	}
 
 	// tags
-	err = this.ExpectNext(LBracket)
+	err = this.ExpectNext(LBrace)
 	if err == nil {
 		this.Next()
 		for {
-			err := this.Expect(Ident, String, RBracket)
+			err := this.Expect(Ident, String, RBrace)
 			if err != nil { return Selector { }, err }
-			if this.Is(RBracket) { break       }
+			if this.Is(RBrace) { break }
-			if this.Is(Comma)    { this.Next() }
 			selector.Tags = append(selector.Tags, this.Value())
-			err = this.ExpectNext(Comma, RBracket)
+			err = this.ExpectNext(Comma, RBrace)
 			if err != nil { return Selector { }, err }
 		}
-		this.Next()
 	}
 	
-	return selector, nil
+	return selector, this.Next()
 }
 
 func (this *parser) parseAttr () (string, []ValueList, error) {
@@ -161,20 +195,18 @@ func (this *parser) parseAttr () (string, []ValueList, error) {
 	this.Next()
 	for {
 		err := this.ExpectDesc (
-			"value, Comma, or Semicolon",
+			"value, comma, or semicolon",
-			Number, Color, String, Ident, Dollar, Slash,
+			Number, Color, String, Ident, Dollar, Comma, Semicolon)
-			Comma, Semicolon)
 		if err != nil { return "", nil, err }
-		if this.Is(Semicolon) { break       }
+		if this.Is(Semicolon) { break }
-		if this.Is(Comma)     { this.Next() }
 		valueList, err := this.parseValueList()
 		if err != nil { return "", nil, err }
 		attr = append(attr, valueList)
-		err = this.Expect(Comma, Semicolon)
+		err = this.ExpectNext(Comma, Semicolon)
 		if err != nil { return "", nil, err }
 	}
 	
-	return name, attr, nil
+	return name, attr, this.Next()
 }
 
 func (this *parser) parseValueList () (ValueList, error) {
@@ -182,7 +214,7 @@ func (this *parser) parseValueList () (ValueList, error) {
 	for {
 		err := this.ExpectDesc (
 			"value",
-			Number, Color, String, Ident, Dollar, Slash)
+			Number, Color, String, Ident, Dollar)
 		if err != nil { break }
 		switch this.Kind() {
 		case Number:
@@ -205,12 +237,9 @@ func (this *parser) parseValueList () (ValueList, error) {
 			err := this.ExpectNext(Ident)
 			if err != nil { return nil, err }
 			list = append(list, ValueVariable(this.Value()))
-		case Slash:
-			list = append(list, ValueCut { })
 		}
-		this.Next()
 	}
-	return list, nil
+	return list, this.Next()
 }
 
 func parseColor (runes []rune) (uint32, bool) {

internal/style/tss/tss.go

@@ -1,79 +1,21 @@
 package tss
 
+import "io"
 import "os"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/event"
 
-type Sheet struct {
+func BuildStyle (sheet Sheet) (*tomo.Style, event.Cookie, error) {
-	Variables map[string] ValueList
+	// TODO
-	Rules     []Rule
+	return nil, nil, nil
-	flat      bool
 }
 
-type Rule struct {
-	Selector Selector
-	Attrs    map[string] []ValueList
-}
-
-type Selector struct {
-	Package string
-	Object  string
-	Tags    []string
-}
-
-type ValueList []Value
-
-type Value interface {
-	value ()
-}
-
-type ValueNumber int
-func (ValueNumber) value () { }
-
-type ValueColor uint32
-func (ValueColor) value () { }
-func (value ValueColor) RGBA () (r, g, b, a uint32) {
-	// extract components
-	bits := uint32(value)
-	r = (bits & 0xFF000000) >> 24
-	g = (bits & 0x00FF0000) >> 16
-	b = (bits & 0x0000FF00) >> 8
-	a = (bits & 0x000000FF)
-	// extend to 16 bits per channel
-	r = r << 8 | r
-	g = g << 8 | g
-	b = b << 8 | b
-	a = a << 8 | a
-	// alpha premultiply
-	r = (r * a) / 0xFFFF
-	g = (g * a) / 0xFFFF
-	b = (b * a) / 0xFFFF
-	return
-}
-
-type ValueString string
-func (ValueString) value () { }
-
-type ValueKeyword string
-func (ValueKeyword) value () { }
-
-type ValueVariable string
-func (ValueVariable) value () { }
-
-type ValueCut struct { }
-func (ValueCut) value () { }
-
-// LoadFile loads the stylesheet from the specified file. This may return a
-// parse.Error, so use parse.Format to print it.
 func LoadFile (name string) (*tomo.Style, event.Cookie, error) {
 	// TODO check cache for gobbed sheet. if the cache is nonexistent or
 	// invalid, then open/load/cache.
-	
+
 	file, err := os.Open(name)
 	if err != nil { return nil, nil, err }
 	defer file.Close()
-
+	return Load(file)
-	sheet, err := Parse(Lex(name, file))
-	if err != nil { return nil, nil, err }
-	return BuildStyle(sheet)
 }