ref: 53e30e39a6156b3182cff49af4e9375216e9df77
dir: /style/stylesheets.go/
package style import ( "9fans.net/go/draw" "bytes" "fmt" "github.com/andybalholm/cascadia" "github.com/chris-ramon/douceur/css" "github.com/chris-ramon/douceur/parser" "github.com/mjl-/duit" "github.com/psilva261/opossum/logger" "golang.org/x/image/colornames" "golang.org/x/net/html" "math" "os/exec" "regexp" "runtime" "strconv" "strings" ) var fontCache = make(map[string]*draw.Font) var dui *duit.DUI var availableFontNames []string var rMinWidth = regexp.MustCompile(`min-width: (\d+)(px|em|rem)`) var rMaxWidth = regexp.MustCompile(`max-width: (\d+)(px|em|rem)`) const FontBaseSize = 11.0 var WindowWidth = 1280 var WindowHeight = 1080 const AddOnCSS = ` /* https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elements */ a, abbr, acronym, audio, b, bdi, bdo, big, br, button, canvas, cite, code, data, datalist, del, dfn, em, embed, i, iframe, img, input, ins, kbd, label, map, mark, meter, noscript, object, output, picture, progress, q, ruby, s, samp, script, select, slot, small, span, strong, sub, sup, svg, template, textarea, time, u, tt, var, video, wbr { display: inline; } /* non-HTML5 elements: https://www.w3schools.com/tags/ref_byfunc.asp */ font, strike, tt { display: inline; } button, textarea, input, select { display: inline-block; } /* https://developer.mozilla.org/en-US/docs/Web/HTML/Block-level_elements */ address, article, aside, blockquote, details, dialog, dd, div, dl, dt, fieldset, figcaption, figure, footer, form, h1, h2, h3, h4, h5, h6, header, hgroup, hr, li, main, nav, ol, p, pre, section, table, ul { display: block; } a[href] { color: blue; margin-right: 2px; } ` func Init(d *duit.DUI) { dui = d initFontserver() } func Hrefs(doc *html.Node) (hrefs []string) { hrefs = make([]string, 0, 3) var f func(n *html.Node) f = func(n *html.Node) { if n.Type == html.ElementNode && n.Data == "link" { isStylesheet := false isPrint := false href := "" for _, a := range n.Attr { switch strings.ToLower(a.Key) { case "rel": if a.Val == "stylesheet" { isStylesheet = true } case "href": href = a.Val case "media": isPrint = a.Val == "print" } } if isStylesheet && !isPrint { hrefs = append(hrefs, href) } } for c := n.FirstChild; c != nil; c = c.NextSibling { f(c) } } f(doc) return } func MergeNodeMaps(m, addOn map[*html.Node]Map) { for n, mp := range addOn { // "zero" valued Map if it doesn't exist yet initial := m[n] m[n] = initial.ApplyChildStyle(mp, true) } } func FetchNodeMap(doc *html.Node, cssText string, windowWidth int) (m map[*html.Node]Map, err error) { mr, rv, err := FetchNodeRules(doc, cssText, windowWidth) if err != nil { return nil, fmt.Errorf("fetch rules: %w", err) } m = make(map[*html.Node]Map) for n, rs := range mr { ds := make(map[string]css.Declaration) for _, r := range rs { for _, d := range r.Declarations { if exist, ok := ds[d.Property]; ok && smaller(*d, exist) { continue } if strings.HasPrefix(d.Value, "var(") { v := strings.TrimPrefix(d.Value, "var(") v = strings.TrimSuffix(v, ")") if vv, ok := rv[v]; ok { d.Value = vv } } ds[d.Property] = *d } } m[n] = Map{Declarations: ds} } return } func smaller(d, dd css.Declaration) bool { return dd.Important } func compile(v string) (cs cascadia.Selector, err error) { l := strings.Split(v, " ") for _, s := range l { s = strings.TrimSpace(s) if strings.HasSuffix(s, ":") { // TODO: selectors like .selector: would crash otherwise err = fmt.Errorf("unsupported selector: %v", s) return } } return cascadia.Compile(v) } func FetchNodeRules(doc *html.Node, cssText string, windowWidth int) (m map[*html.Node][]*css.Rule, rVars map[string]string, err error) { m = make(map[*html.Node][]*css.Rule) rVars = make(map[string]string) s, err := parser.Parse(cssText) if err != nil { return nil, nil, fmt.Errorf("douceur parse: %w", err) } processRule := func(m map[*html.Node][]*css.Rule, r *css.Rule) (err error) { for _, sel := range r.Selectors { if sel.Value == ":root" { for _, d := range r.Declarations { rVars[d.Property] = d.Value } } cs, err := compile(sel.Value) if err != nil { log.Printf("cssSel compile %v: %v", sel.Value, err) continue } for _, el := range cascadia.QueryAll(doc, cs) { existing, ok := m[el] if !ok { existing = make([]*css.Rule, 0, 3) } existing = append(existing, r) m[el] = existing } } return } for _, r := range s.Rules { if err := processRule(m, r); err != nil { return nil, nil, fmt.Errorf("process rule: %w", err) } // for media queries if strings.Contains(r.Prelude, "print") && !strings.Contains(r.Prelude, "screen") { continue } if rMaxWidth.MatchString(r.Prelude) { m := rMaxWidth.FindStringSubmatch(r.Prelude) l := m[1] + m[2] maxWidth, _, err := length(nil, l) if err != nil { return nil, nil, fmt.Errorf("atoi: %w", err) } if float64(windowWidth) > maxWidth { continue } } if rMinWidth.MatchString(r.Prelude) { m := rMinWidth.FindStringSubmatch(r.Prelude) l := m[1] + m[2] minWidth, _, err := length(nil, l) if err != nil { return nil, nil, fmt.Errorf("atoi: %w", err) } if float64(windowWidth) < minWidth { continue } } for _, rr := range r.Rules { if err := processRule(m, rr); err != nil { return nil, nil, fmt.Errorf("process embedded rule: %w", err) } } } return } type DomTree interface { Parent() (p DomTree, ok bool) Style() Map } type Map struct { Declarations map[string]css.Declaration DomTree `json:"-"` } func NewMap(n *html.Node) Map { s := Map{ Declarations: make(map[string]css.Declaration), } for _, a := range n.Attr { if a.Key == "style" { v := strings.TrimSpace(a.Val) if !strings.HasSuffix(v, ";") { v += ";" } decls, err := parser.ParseDeclarations(v) if err != nil { log.Printf("could not parse '%v'", a.Val) break } for _, d := range decls { s.Declarations[d.Property] = *d } } else if a.Key == "height" || a.Key == "width" { v := a.Val if !strings.HasSuffix(v, "%") && !strings.HasSuffix(v, "px") { v += "px" } s.Declarations[a.Key] = css.Declaration{ Property: a.Key, Value: v, } } else if a.Key == "bgcolor" { s.Declarations["background-color"] = css.Declaration{ Property: "background-color", Value: a.Val, } } } return s } func (cs Map) ApplyChildStyle(ccs Map, copyAll bool) (res Map) { res.Declarations = make(map[string]css.Declaration) for k, v := range cs.Declarations { switch k { // https://www.w3.org/TR/CSS21/propidx.html case "azimuth", "border-collapse", "border-spacing", "caption-side", "color", "cursor", "direction", "elevation", "empty-cells", "font-family", "font-size", "font-style", "font-variant", "font-weight", "font", "letter-spacing", "line-height", "list-style-image", "list-style-position", "list-style-type", "list-style", "orphans", "pitch-range", "pitch", "quotes", "richness", "speak-header", "speak-numeral", "speak-punctuation", "speak", "speech-rate", "stress", "text-align", "text-indent", "text-transform", "visibility", "voice-family", "volume", "white-space", "widows", "word-spacing": default: if !copyAll { continue } } res.Declarations[k] = v } // overwrite with higher prio child props for k, v := range ccs.Declarations { if v.Value == "inherit" { continue } res.Declarations[k] = v } return } func (cs Map) Font() *draw.Font { fn, ok := cs.FontFilename() if !ok || dui == nil { return nil } if runtime.GOOS == "plan9" && dui.Display.HiDPI() { // TODO: proper hidpi handling return dui.Font(nil) } font, ok := fontCache[fn] if ok { return font } log.Infof("call dui.Display.OpenFont(%v)", fn) font, err := dui.Display.OpenFont(fn) if err != nil { log.Printf("%v is not avail", fn) return nil } fontCache[fn] = font return font } func (cs Map) preferedFontName(preferences []string) string { avails := availableFontNames if len(avails) == 0 { return preferences[0] } for len(preferences) > 0 { var pref string pref, preferences = preferences[0], preferences[1:] for _, avail := range avails { if pref == strings.TrimSuffix(avail, "/") { return avail } } } return avails[0] } func matchClosestFontSize(desired float64, available []int) (closest int) { for _, a := range available { if closest == 0 || math.Abs(float64(a)-desired) < math.Abs(float64(closest)-desired) { closest = a } } return } func (cs Map) FontSize() float64 { fs, ok := cs.Declarations["font-size"] if !ok || fs.Value == "" { return FontBaseSize } if len(fs.Value) <= 2 { log.Printf("error parsing font size %v", fs.Value) return FontBaseSize } numStr := fs.Value[0 : len(fs.Value)-2] f, err := strconv.ParseFloat(numStr, 64) if err != nil { log.Printf("error parsing font size %v", fs.Value) return FontBaseSize } if strings.HasSuffix(fs.Value, "em") { f *= FontBaseSize } return f } // FontHeight in lowDPI pixels. func (cs Map) FontHeight() float64 { return float64(cs.Font().Height) / float64(dui.Scale(1)) } func (cs Map) Color() draw.Color { if d, ok := cs.Declarations["color"]; ok { if h, ok := colorHex(d.Value); ok { c := draw.Color(h) return c } } return draw.Black } func colorHex(propVal string) (c draw.Color, ok bool) { var r, g, b uint32 var x uint32 if strings.HasPrefix(propVal, "rgb") { val := propVal[3:] val = strings.TrimPrefix(val, "a") val = strings.TrimPrefix(val, "(") val = strings.TrimSuffix(val, ")") vals := strings.Split(val, ",") if len(vals) < 3 { log.Errorf("vals=%+v", vals) return } rr, err := strconv.ParseInt(vals[0], 10, 32) if err != nil { goto default_value } gg, err := strconv.ParseInt(vals[1], 10, 32) if err != nil { goto default_value } bb, err := strconv.ParseInt(vals[2], 10, 32) if err != nil { goto default_value } r = uint32(rr) * 256 g = uint32(gg) * 256 b = uint32(bb) * 256 } else if strings.HasPrefix(propVal, "#") { hexColor := propVal[1:] if len(hexColor) == 3 { rr, err := strconv.ParseInt(hexColor[0:1], 16, 32) if err != nil { goto default_value } gg, err := strconv.ParseInt(hexColor[1:2], 16, 32) if err != nil { goto default_value } bb, err := strconv.ParseInt(hexColor[2:3], 16, 32) if err != nil { goto default_value } r = uint32(rr) * 256 * 0x11 g = uint32(gg) * 256 * 0x11 b = uint32(bb) * 256 * 0x11 } else if len(hexColor) == 6 { rr, err := strconv.ParseInt(hexColor[0:2], 16, 32) if err != nil { goto default_value } gg, err := strconv.ParseInt(hexColor[2:4], 16, 32) if err != nil { goto default_value } bb, err := strconv.ParseInt(hexColor[4:6], 16, 32) if err != nil { goto default_value } r = uint32(rr) * 256 g = uint32(gg) * 256 b = uint32(bb) * 256 } else { goto default_value } } else if propVal == "inherit" { // TODO: handle properly goto default_value } else { colorRGBA, ok := colornames.Map[propVal] if !ok { goto default_value } r, g, b, _ = colorRGBA.RGBA() } x = (r / 256) << 24 x = x | ((g / 256) << 16) x = x | ((b / 256) << 8) x = x | 0x000000ff return draw.Color(uint32(x)), true default_value: log.Printf("could not interpret %v", propVal) return 0, false } func (cs Map) IsInline() bool { propVal, ok := cs.Declarations["float"] if ok && propVal.Value == "left" { return true } propVal, ok = cs.Declarations["display"] if ok { return propVal.Value == "inline" || propVal.Value == "inline-block" } return false } func (cs Map) IsDisplayNone() bool { propVal, ok := cs.Declarations["display"] if ok && propVal.Value == "none" { return true } /*propVal, ok = cs.Declarations["position"] if ok && propVal.Value == "fixed" { return true }*/ propVal, ok = cs.Declarations["clip"] if ok && strings.ReplaceAll(propVal.Value, " ", "") == "rect(1px,1px,1px,1px)" { return true } propVal, ok = cs.Declarations["width"] if ok && propVal.Value == "1px" { propVal, ok = cs.Declarations["height"] if ok && propVal.Value == "1px" { return true } } return false } func (cs Map) IsFlex() bool { propVal, ok := cs.Declarations["display"] if ok { return propVal.Value == "flex" } return false } func (cs Map) IsFlexDirectionRow() bool { propVal, ok := cs.Declarations["flex-direction"] if ok { switch propVal.Value { case "row": return true case "column": return false } } return true // TODO: be more specific } // tlbr parses 4-tuple of top-right-bottom-left like in margin, // margin-top, ...-right, ...-bottom, ...-left. func (cs *Map) Tlbr(key string) (s duit.Space, err error) { if all, ok := cs.Declarations[key]; ok { parts := strings.Split(all.Value, " ") nums := make([]int, len(parts)) for i, p := range parts { if f, _, err := length(cs, p); err == nil { nums[i] = int(f) } else { return s, fmt.Errorf("length: %w", err) } } s.Top = nums[0] s.Right = s.Top s.Bottom = s.Top s.Left = s.Top if len(nums) >= 2 { s.Right = nums[1] s.Left = s.Right } if len(nums) >= 3 { s.Bottom = nums[2] } if len(nums) == 4 { s.Left = nums[3] } } if t, err := cs.CssPx(key + "-top"); err == nil { s.Top = t } if r, err := cs.CssPx(key + "-right"); err == nil { s.Right = r } if b, err := cs.CssPx(key + "-bottom"); err == nil { s.Bottom = b } if l, err := cs.CssPx(key + "-left"); err == nil { s.Left = l } return } var reBcInput = regexp.MustCompile(`^[0-9\+\*\-\/\(\)\\.\s]+$`) func calc(cs *Map, l string) (f float64, unit string, err error) { if !strings.HasPrefix(l, "calc(") && !strings.HasSuffix(l, ")") { return 0, "", fmt.Errorf("wrong format") } l = strings.TrimPrefix(l, "calc(") l = strings.TrimSuffix(l, ")") if len(l) > 50 { return 0, "", fmt.Errorf("parse expression: %v", l) } l = strings.ReplaceAll(l, "px", "") for _, u := range []string{"rem", "em", "%", "vw", "vh"} { if !strings.Contains(l, u) { continue } r, _, err := length(cs, "1"+u) if err != nil { return 0, "", fmt.Errorf("u %v: %v", u, err) } l = strings.ReplaceAll(l, u, fmt.Sprintf("*%v", r)) } if !reBcInput.MatchString(l) { return 0, "", fmt.Errorf("parse expression: %v", l) } cmd := exec.Command("bc") cmd.Stdin = strings.NewReader(l + "\n") var out bytes.Buffer var er bytes.Buffer cmd.Stdout = &out cmd.Stderr = &er if e := er.String(); e != "" { log.Errorf("bc: %v", e) } if err = cmd.Run(); err != nil { return } f, err = strconv.ParseFloat(strings.TrimSpace(out.String()), 64) return } func length(cs *Map, l string) (f float64, unit string, err error) { var s string if l == "auto" || l == "inherit" || l == "initial" || l == "0" { return 0, "px", nil } if strings.Contains(l, "calc") { return calc(cs, l) } for _, suffix := range []string{"px", "%", "rem", "em", "ex", "vw", "vh", "mm"} { if strings.HasSuffix(l, suffix) { if s = strings.TrimSuffix(l, suffix); s != "" { f, err = strconv.ParseFloat(s, 64) if err != nil { return 0, "", fmt.Errorf("error parsing '%v': %w", l, err) } } unit = suffix break } } switch unit { case "px": case "rem": // TODO: use font size from root element f *= FontBaseSize case "em", "ex": // TODO: distinguish between em and ex if cs == nil { f *= FontBaseSize } else { f *= cs.FontHeight() } case "vw": f *= float64(WindowWidth) / 100.0 case "vh": f *= float64(WindowHeight) / 100.0 case "%": if cs == nil { return 0.0, "%", nil } var wp int if p, ok := cs.DomTree.Parent(); ok { wp = p.Style().baseWidth() } else { log.Printf("%% unit used in root element") } f *= 0.01 * float64(wp) case "mm": dpi := 100 if dui != nil && dui.Display != nil && dui.Display.DPI != 0 { dpi = dui.Display.DPI } f *= float64(dpi) / 25.4 default: return f, unit, fmt.Errorf("unknown suffix: %v", l) } return } func (cs *Map) Height() int { d, ok := cs.Declarations["height"] if ok { f, _, err := length(cs, d.Value) if err != nil { log.Errorf("cannot parse height: %v", err) } return int(f) } return 0 } func (cs Map) Width() int { w := cs.width() if w > 0 { if d, ok := cs.Declarations["max-width"]; ok { f, _, err := length(&cs, d.Value) if err != nil { log.Errorf("cannot parse width: %v", err) } if mw := int(f); 0 < mw && mw < w { return int(mw) } } } return w } func (cs Map) width() int { d, ok := cs.Declarations["width"] if ok { f, _, err := length(&cs, d.Value) if err != nil { log.Errorf("cannot parse width: %v", err) } if f > 0 { return int(f) } } if _, ok := cs.DomTree.Parent(); !ok { return WindowWidth } return 0 } // baseWidth to calculate relative widths func (cs Map) baseWidth() int { if w := cs.Width(); w != 0 { return w } if p, ok := cs.DomTree.Parent(); !ok { return WindowWidth } else { return p.Style().baseWidth() } return 0 } func (cs Map) Css(propName string) string { d, ok := cs.Declarations[propName] if !ok { return "" } return d.Value } func (cs *Map) CssPx(propName string) (l int, err error) { d, ok := cs.Declarations[propName] if !ok { return 0, fmt.Errorf("property doesn't exist") } f, _, err := length(cs, d.Value) if err != nil { return 0, err } l = int(f) return } func (cs Map) SetCss(k, v string) { cs.Declarations[k] = css.Declaration{ Property: k, Value: v, } }