aboutsummaryrefslogtreecommitdiffstats
path: root/src/css
diff options
context:
space:
mode:
authorbptato <nincsnevem662@gmail.com>2024-11-19 20:07:18 +0100
committerbptato <nincsnevem662@gmail.com>2024-11-19 20:58:24 +0100
commitd24647869c540f1c51d5f047b3953fe54152c61e (patch)
treec07a28166a8d89d9f6cd057c1dde05bc85eff67b /src/css
parent411760ee6584cc58b07e118e12947667c569b670 (diff)
downloadchawan-d24647869c540f1c51d5f047b3953fe54152c61e.tar.gz
match, stylednode: remove generics, refactor
Turns out the generics weren't really needed in the first place. Also, StyledNode is now 16 bytes smaller.
Diffstat (limited to 'src/css')
-rw-r--r--src/css/cascade.nim7
-rw-r--r--src/css/match.nim162
-rw-r--r--src/css/stylednode.nim59
3 files changed, 91 insertions, 137 deletions
diff --git a/src/css/cascade.nim b/src/css/cascade.nim
index 04f9c0dd..d1927721 100644
--- a/src/css/cascade.nim
+++ b/src/css/cascade.nim
@@ -79,9 +79,10 @@ func applies*(mqlist: MediaQueryList; window: Window): bool =
type
ToSorts = array[PseudoElem, seq[(int, CSSRuleDef)]]
-proc calcRule(tosorts: var ToSorts; styledNode: StyledNode; rule: CSSRuleDef) =
+proc calcRule(tosorts: var ToSorts; element: Element;
+ depends: var DependencyInfo; rule: CSSRuleDef) =
for sel in rule.sels:
- if styledNode.selectorsMatch(sel):
+ if element.selectorsMatch(sel, depends):
let spec = getSpecificity(sel)
tosorts[sel.pseudo].add((spec, rule))
@@ -108,7 +109,7 @@ func calcRules(styledNode: StyledNode; sheet: CSSStylesheet): RuleList =
rules.add(rule)
rules.sort(ruleDefCmp, order = Ascending)
for rule in rules:
- tosorts.calcRule(styledNode, rule)
+ tosorts.calcRule(element, styledNode.depends, rule)
for i in PseudoElem:
tosorts[i].sort((proc(x, y: (int, CSSRuleDef)): int =
cmp(x[0], y[0])
diff --git a/src/css/match.nim b/src/css/match.nim
index 05c9f742..51dd9a6e 100644
--- a/src/css/match.nim
+++ b/src/css/match.nim
@@ -1,6 +1,4 @@
-import std/options
import std/strutils
-import std/tables
import chame/tags
import css/cssparser
@@ -11,16 +9,16 @@ import html/dom
import utils/twtstr
#TODO rfNone should match insensitively for certain properties
-func attrSelectorMatches(elem: Element; sel: Selector): bool =
+func attrSelectorMatches(element: Element; sel: Selector): bool =
case sel.rel.t
- of rtExists: return elem.attrb(sel.attr)
+ of rtExists: return element.attrb(sel.attr)
of rtEquals:
case sel.rel.flag
- of rfNone: return elem.attr(sel.attr) == sel.value
- of rfI: return elem.attr(sel.attr).equalsIgnoreCase(sel.value)
- of rfS: return elem.attr(sel.attr) == sel.value
+ of rfNone: return element.attr(sel.attr) == sel.value
+ of rfI: return element.attr(sel.attr).equalsIgnoreCase(sel.value)
+ of rfS: return element.attr(sel.attr) == sel.value
of rtToken:
- let val = elem.attr(sel.attr)
+ let val = element.attr(sel.attr)
case sel.rel.flag
of rfNone: return sel.value in val.split(AsciiWhitespace)
of rfI:
@@ -29,7 +27,7 @@ func attrSelectorMatches(elem: Element; sel: Selector): bool =
return selval in val.split(AsciiWhitespace)
of rfS: return sel.value in val.split(AsciiWhitespace)
of rtBeginDash:
- let val = elem.attr(sel.attr)
+ let val = element.attr(sel.attr)
case sel.rel.flag
of rfNone:
return val == sel.value or sel.value.startsWith(val & '-')
@@ -39,19 +37,19 @@ func attrSelectorMatches(elem: Element; sel: Selector): bool =
of rfS:
return val == sel.value or sel.value.startsWith(val & '-')
of rtStartsWith:
- let val = elem.attr(sel.attr)
+ let val = element.attr(sel.attr)
case sel.rel.flag
of rfNone: return val.startsWith(sel.value)
of rfI: return val.startsWithIgnoreCase(sel.value)
of rfS: return val.startsWith(sel.value)
of rtEndsWith:
- let val = elem.attr(sel.attr)
+ let val = element.attr(sel.attr)
case sel.rel.flag
of rfNone: return val.endsWith(sel.value)
of rfI: return val.endsWithIgnoreCase(sel.value)
of rfS: return val.endsWith(sel.value)
of rtContains:
- let val = elem.attr(sel.attr)
+ let val = element.attr(sel.attr)
case sel.rel.flag
of rfNone: return val.contains(sel.value)
of rfI:
@@ -60,129 +58,118 @@ func attrSelectorMatches(elem: Element; sel: Selector): bool =
return val.contains(selval)
of rfS: return val.contains(sel.value)
-func selectorsMatch*[T: Element|StyledNode](elem: T; cxsel: ComplexSelector;
- felem: T = nil): bool
+func selectorsMatch*(element: Element; cxsel: ComplexSelector;
+ depends: var DependencyInfo): bool
-func selectorsMatch[T: Element|StyledNode](elem: T; slist: SelectorList;
- felem: T = nil): bool =
+func selectorsMatch(element: Element; slist: SelectorList;
+ depends: var DependencyInfo): bool =
for cxsel in slist:
- if elem.selectorsMatch(cxsel, felem):
+ if element.selectorsMatch(cxsel, depends):
return true
return false
-func pseudoSelectorMatches[T: Element|StyledNode](elem: T; sel: Selector;
- felem: T): bool =
- let selem = elem
- when elem is StyledNode:
- let elem = Element(elem.node)
+func pseudoSelectorMatches(element: Element; sel: Selector;
+ depends: var DependencyInfo): bool =
case sel.pseudo.t
- of pcFirstChild: return elem.parentNode.firstElementChild == elem
- of pcLastChild: return elem.parentNode.lastElementChild == elem
+ of pcFirstChild: return element.parentNode.firstElementChild == element
+ of pcLastChild: return element.parentNode.lastElementChild == element
of pcOnlyChild:
- return elem.parentNode.firstElementChild == elem and
- elem.parentNode.lastElementChild == elem
+ return element.parentNode.firstElementChild == element and
+ element.parentNode.lastElementChild == element
of pcHover:
- when selem is StyledNode: felem.addDependency(elem, dtHover)
- return elem.hover
- of pcRoot: return elem == elem.document.documentElement
+ depends.add(element, dtHover)
+ return element.hover
+ of pcRoot: return element == element.document.documentElement
of pcNthChild:
if sel.pseudo.ofsels.len != 0 and
- not selem.selectorsMatch(sel.pseudo.ofsels, felem):
+ not element.selectorsMatch(sel.pseudo.ofsels, depends):
return false
let A = sel.pseudo.anb.A # step
let B = sel.pseudo.anb.B # start
var i = 1
- let parent = when selem is StyledNode: selem.parent
- else: selem.parentNode
+ let parent = element.parentNode
if parent == nil: return false
for child in parent.elementList:
- when selem is StyledNode:
- if not child.isDomElement: continue
- if child == selem:
+ if child == element:
if A == 0:
return i == B
if A < 0:
return (i - B) <= 0 and (i - B) mod A == 0
return (i - B) >= 0 and (i - B) mod A == 0
if sel.pseudo.ofsels.len == 0 or
- child.selectorsMatch(sel.pseudo.ofsels, felem):
+ child.selectorsMatch(sel.pseudo.ofsels, depends):
inc i
return false
of pcNthLastChild:
if sel.pseudo.ofsels.len == 0 and
- not selem.selectorsMatch(sel.pseudo.ofsels, felem):
+ not element.selectorsMatch(sel.pseudo.ofsels, depends):
return false
let A = sel.pseudo.anb.A # step
let B = sel.pseudo.anb.B # start
var i = 1
- let parent = when selem is StyledNode: selem.parent
- else: selem.parentNode
- if parent == nil: return false
+ let parent = element.parentNode
+ if parent == nil:
+ return false
for child in parent.elementList_rev:
- when selem is StyledNode:
- if not child.isDomElement: continue
- if child == selem:
+ if child == element:
if A == 0:
return i == B
if A < 0:
return (i - B) <= 0 and (i - B) mod A == 0
return (i - B) >= 0 and (i - B) mod A == 0
if sel.pseudo.ofsels.len != 0 or
- child.selectorsMatch(sel.pseudo.ofsels, felem):
+ child.selectorsMatch(sel.pseudo.ofsels, depends):
inc i
return false
of pcChecked:
- when selem is StyledNode: felem.addDependency(elem, dtChecked)
- if elem.tagType == TAG_INPUT:
- return HTMLInputElement(elem).checked
- elif elem.tagType == TAG_OPTION:
- return HTMLOptionElement(elem).selected
+ depends.add(element, dtChecked)
+ if element.tagType == TAG_INPUT:
+ return HTMLInputElement(element).checked
+ elif element.tagType == TAG_OPTION:
+ return HTMLOptionElement(element).selected
return false
of pcFocus:
- when selem is StyledNode: felem.addDependency(elem, dtFocus)
- return elem.document.focus == elem
+ depends.add(element, dtFocus)
+ return element.document.focus == element
of pcNot:
- return not selem.selectorsMatch(sel.pseudo.fsels, felem)
+ return not element.selectorsMatch(sel.pseudo.fsels, depends)
of pcIs, pcWhere:
- return selem.selectorsMatch(sel.pseudo.fsels, felem)
+ return element.selectorsMatch(sel.pseudo.fsels, depends)
of pcLang:
return sel.pseudo.s == "en" #TODO languages?
of pcLink:
- return elem.tagType in {TAG_A, TAG_AREA} and elem.attrb(satHref)
+ return element.tagType in {TAG_A, TAG_AREA} and element.attrb(satHref)
of pcVisited:
return false
-func selectorMatches[T: Element|StyledNode](elem: T; sel: Selector;
- felem: T = nil): bool =
- let selem = elem
- when elem is StyledNode:
- let elem = Element(selem.node)
+func selectorMatches(element: Element; sel: Selector;
+ depends: var DependencyInfo): bool =
case sel.t
of stType:
- return elem.localName == sel.tag
+ return element.localName == sel.tag
of stClass:
- return sel.class in elem.classList
+ return sel.class in element.classList
of stId:
- return sel.id == elem.id
+ return sel.id == element.id
of stAttr:
- return elem.attrSelectorMatches(sel)
+ return element.attrSelectorMatches(sel)
of stPseudoClass:
- return pseudoSelectorMatches(selem, sel, felem)
+ return pseudoSelectorMatches(element, sel, depends)
of stPseudoElement:
return true
of stUniversal:
return true
-func selectorsMatch[T: Element|StyledNode](elem: T; sels: CompoundSelector;
- felem: T): bool =
+func selectorsMatch(element: Element; sels: CompoundSelector;
+ depends: var DependencyInfo): bool =
for sel in sels:
- if not selectorMatches(elem, sel, felem):
+ if not selectorMatches(element, sel, depends):
return false
return true
-func complexSelectorMatches[T: Element|StyledNode](elem: T;
- cxsel: ComplexSelector; felem: T = nil): bool =
- var e = elem
+func complexSelectorMatches(element: Element; cxsel: ComplexSelector;
+ depends: var DependencyInfo): bool =
+ var e = element
for i in countdown(cxsel.high, 0):
let sels = cxsel[i]
if e == nil:
@@ -190,42 +177,38 @@ func complexSelectorMatches[T: Element|StyledNode](elem: T;
var match = false
case sels.ct
of ctNone:
- match = e.selectorsMatch(sels, felem)
+ match = e.selectorsMatch(sels, depends)
of ctDescendant:
e = e.parentElement
while e != nil:
- if e.selectorsMatch(sels, felem):
+ if e.selectorsMatch(sels, depends):
match = true
break
e = e.parentElement
of ctChild:
e = e.parentElement
if e != nil:
- match = e.selectorsMatch(sels, felem)
+ match = e.selectorsMatch(sels, depends)
of ctNextSibling:
if e.parentElement == nil: return false
var found = false
for child in e.parentElement.elementList_rev:
- when elem is StyledNode:
- if not child.isDomElement: continue
if e == child:
found = true
continue
if found:
e = child
- match = e.selectorsMatch(sels, felem)
+ match = e.selectorsMatch(sels, depends)
break
of ctSubsequentSibling:
var found = false
if e.parentElement == nil: return false
for child in e.parentElement.elementList_rev:
- when elem is StyledNode:
- if not child.isDomElement: continue
- if child == elem:
+ if child == element:
found = true
continue
if not found: continue
- if child.selectorsMatch(sels, felem):
+ if child.selectorsMatch(sels, depends):
e = child
match = true
break
@@ -233,27 +216,24 @@ func complexSelectorMatches[T: Element|StyledNode](elem: T;
return false
return true
-# WARNING for StyledNode, this has the side effect of modifying depends.
-#TODO make that an explicit flag or something, also get rid of the Element case
-func selectorsMatch*[T: Element|StyledNode](elem: T; cxsel: ComplexSelector;
- felem: T = nil): bool =
- let felem = if felem != nil:
- felem
- else:
- elem
- return elem.complexSelectorMatches(cxsel, felem)
+# Note: this modifies "depends".
+func selectorsMatch*(element: Element; cxsel: ComplexSelector;
+ depends: var DependencyInfo): bool =
+ return element.complexSelectorMatches(cxsel, depends)
# Forward declaration hack
querySelectorAllImpl = proc(node: Node; q: string): seq[Element] =
result = @[]
let selectors = parseSelectors(q, node.document.factory)
for element in node.elements:
- if element.selectorsMatch(selectors):
+ var dummy: DependencyInfo
+ if element.selectorsMatch(selectors, dummy):
result.add(element)
querySelectorImpl = proc(node: Node; q: string): Element =
let selectors = parseSelectors(q, node.document.factory)
for element in node.elements:
- if element.selectorsMatch(selectors):
+ var dummy: DependencyInfo
+ if element.selectorsMatch(selectors, dummy):
return element
return nil
diff --git a/src/css/stylednode.nim b/src/css/stylednode.nim
index cf9a8a59..0402826e 100644
--- a/src/css/stylednode.nim
+++ b/src/css/stylednode.nim
@@ -37,7 +37,12 @@ type
StyledType* = enum
stElement, stText, stReplacement
- DependencyInfo = array[DependencyType, seq[Element]]
+ DependencyInfoItem = object
+ t: DependencyType
+ element: Element
+
+ DependencyInfo* = object
+ items: seq[DependencyInfoItem]
StyledNode* = ref object
parent*: StyledNode
@@ -49,7 +54,7 @@ type
of stElement:
computed*: CSSComputedValues
children*: seq[StyledNode]
- # All elements we depend on, for each dependency type d.
+ # All elements our style depends on, for each dependency type d.
depends*: DependencyInfo
of stReplacement:
# replaced elements: quotes, or (TODO) markers, images
@@ -72,40 +77,6 @@ when defined(debug):
of stReplacement:
return "#replacement"
-iterator branch*(node: StyledNode): StyledNode {.inline.} =
- var node = node
- while node != nil:
- yield node
- node = node.parent
-
-iterator elementList*(node: StyledNode): StyledNode {.inline.} =
- for child in node.children:
- yield child
-
-iterator elementList_rev*(node: StyledNode): StyledNode {.inline.} =
- for i in countdown(node.children.high, 0):
- yield node.children[i]
-
-func findElement*(root: StyledNode; element: Element): StyledNode =
- var stack: seq[StyledNode] = @[]
- for child in root.elementList_rev:
- if child.t == stElement and child.pseudo == peNone:
- stack.add(child)
- while stack.len > 0:
- let node = stack.pop()
- if node.node == element:
- return node
- for child in node.elementList_rev:
- if child.t == stElement and child.pseudo == peNone:
- stack.add(child)
-
-func isDomElement*(styledNode: StyledNode): bool {.inline.} =
- styledNode.t == stElement and styledNode.pseudo == peNone
-
-# DOM-style getters, for Element interoperability...
-func parentElement*(node: StyledNode): StyledNode {.inline.} =
- node.parent
-
proc isValid*(styledNode: StyledNode; toReset: var seq[Element]): bool =
if styledNode.t in {stText, stReplacement}:
return true
@@ -114,16 +85,18 @@ proc isValid*(styledNode: StyledNode; toReset: var seq[Element]): bool =
if element.invalid:
toReset.add(element)
return false
- for d in DependencyType:
- for dep in styledNode.depends[d]:
- if d in dep.invalidDeps:
- toReset.add(dep)
+ # pseudo elements do not have selector dependencies, so we can skip
+ # this if node is nil.
+ for it in styledNode.depends.items:
+ if it.t in it.element.invalidDeps:
+ toReset.add(it.element)
return false
return true
-proc addDependency*(styledNode: StyledNode; dep: Element; t: DependencyType) =
- if dep notin styledNode.depends[t]:
- styledNode.depends[t].add(dep)
+proc add*(depends: var DependencyInfo; element: Element; t: DependencyType) =
+ let it = DependencyInfoItem(t: t, element: element)
+ if it notin depends.items:
+ depends.items.add(it)
func newStyledElement*(parent: StyledNode; element: Element): StyledNode =
return StyledNode(t: stElement, node: element, parent: parent)