Compare commits
No commits in common. "main" and "v0.7.1" have entirely different histories.
9
go.mod
9
go.mod
@ -1,13 +1,10 @@
|
||||
module git.tebibyte.media/tomo/backend
|
||||
|
||||
go 1.21.0
|
||||
|
||||
toolchain go1.22.2
|
||||
go 1.20
|
||||
|
||||
require (
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.0
|
||||
git.tebibyte.media/tomo/tomo v0.48.0
|
||||
git.tebibyte.media/tomo/typeset v0.8.0
|
||||
git.tebibyte.media/tomo/tomo v0.46.1
|
||||
git.tebibyte.media/tomo/typeset v0.7.1
|
||||
git.tebibyte.media/tomo/xgbkb v1.0.1
|
||||
github.com/jezek/xgb v1.1.1
|
||||
github.com/jezek/xgbutil v0.0.0-20231116234834-47f30c120111
|
||||
|
||||
10
go.sum
10
go.sum
@ -1,10 +1,8 @@
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.0 h1:dcZ/9/or7m8eTpf2B1Pu4CscplXh2INTXFartz+ExwE=
|
||||
git.tebibyte.media/sashakoshka/goutil v0.3.0/go.mod h1:e1OXLa+wX7x/F8n8gyxz2hnfVCEkWzGrZNX8/k/lR/M=
|
||||
git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
|
||||
git.tebibyte.media/tomo/tomo v0.48.0 h1:AE21ElHwUSPsX82ZWCnoNxJFi9Oswyd3dPDPMbxTueQ=
|
||||
git.tebibyte.media/tomo/tomo v0.48.0/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
|
||||
git.tebibyte.media/tomo/typeset v0.8.0 h1:4qA6oW4/3oPHj6/Zrp+JFJ53OmFSDvxs+J6BhO3DW00=
|
||||
git.tebibyte.media/tomo/typeset v0.8.0/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
|
||||
git.tebibyte.media/tomo/tomo v0.46.1 h1:/8fT6I9l4TK529zokrThbNDHGRvUsNgif1Zs++0PBSQ=
|
||||
git.tebibyte.media/tomo/tomo v0.46.1/go.mod h1:WrtilgKB1y8O2Yu7X4mYcRiqOlPR8NuUnoA/ynkQWrs=
|
||||
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/xgbkb v1.0.1 h1:b3HDUopjdQp1MZrb5Vpil4bOtk3NnNXtfQW27Blw2kE=
|
||||
git.tebibyte.media/tomo/xgbkb v1.0.1/go.mod h1:P5Du0yo5hUsojchW08t+Mds0XPIJXwMi733ZfklzjRw=
|
||||
github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJXZHsaM8b6OLVo6muQUQd4CwkH/D3fnnbHXA=
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
package system
|
||||
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/container"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
|
||||
type attrHierarchy [T tomo.Attr] struct {
|
||||
fallback T
|
||||
style ucontainer.Optional[T]
|
||||
user ucontainer.Optional[T]
|
||||
style util.Optional[T]
|
||||
user util.Optional[T]
|
||||
}
|
||||
|
||||
func (this *attrHierarchy[T]) SetFallback (fallback T) {
|
||||
|
||||
@ -7,21 +7,20 @@ import "git.tebibyte.media/tomo/tomo/data"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/container"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/image/color"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
|
||||
type box struct {
|
||||
system *System
|
||||
parent parent
|
||||
outer anyBox
|
||||
|
||||
tags ucontainer.Set[string]
|
||||
tags util.Set[string]
|
||||
role tomo.Role
|
||||
lastStyleNonce int
|
||||
lastIconSetNonce int
|
||||
styleApplicator *styleApplicator
|
||||
|
||||
minSize ucontainer.Memo[image.Point]
|
||||
minSize util.Memo[image.Point]
|
||||
bounds image.Rectangle
|
||||
innerClippingBounds image.Rectangle
|
||||
|
||||
@ -42,7 +41,7 @@ type box struct {
|
||||
focused bool
|
||||
pressed bool
|
||||
|
||||
canvas ucontainer.Memo[canvas.Canvas]
|
||||
canvas util.Memo[canvas.Canvas]
|
||||
drawer canvas.Drawer
|
||||
|
||||
on struct {
|
||||
@ -69,10 +68,10 @@ func (this *System) newBox (outer anyBox) *box {
|
||||
system: this,
|
||||
outer: outer,
|
||||
drawer: outer,
|
||||
tags: make(ucontainer.Set[string]),
|
||||
tags: make(util.Set[string]),
|
||||
}
|
||||
box.attrColor.SetFallback(tomo.AColor(color.Transparent))
|
||||
box.canvas = ucontainer.NewMemo (func () canvas.Canvas {
|
||||
box.canvas = util.NewMemo (func () canvas.Canvas {
|
||||
if box.parent == nil { return nil }
|
||||
parentCanvas := box.parent.getCanvas()
|
||||
if parentCanvas == nil { return nil }
|
||||
@ -83,7 +82,7 @@ func (this *System) newBox (outer anyBox) *box {
|
||||
box.drawer = box
|
||||
box.outer = box
|
||||
}
|
||||
box.minSize = ucontainer.NewMemo(box.calculateMinimumSize)
|
||||
box.minSize = util.NewMemo(box.calculateMinimumSize)
|
||||
return box
|
||||
}
|
||||
|
||||
@ -477,7 +476,7 @@ func (this *box) drawBorders (can canvas.Canvas) {
|
||||
rectangle := func (x0, y0, x1, y1 int, c color.Color) {
|
||||
area := image.Rect(x0, y0, x1, y1)
|
||||
if area.Empty() { return }
|
||||
if ucolor.Transparent(c) && this.parent != nil {
|
||||
if util.Transparent(c) && this.parent != nil {
|
||||
this.parent.drawBackgroundPart(can.SubCanvas(area))
|
||||
}
|
||||
pen.Fill(c)
|
||||
@ -683,7 +682,7 @@ func (this *box) transparent () bool {
|
||||
// TODO uncomment once we have
|
||||
// a way to detect texture transparency
|
||||
col := this.attrColor.Value().Color
|
||||
return col == nil || ucolor.Transparent(col) /*&&
|
||||
return col == nil || util.Transparent(col) /*&&
|
||||
(this.texture == nil || !this.texture.Opaque())*/
|
||||
}
|
||||
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
package system
|
||||
|
||||
import "image"
|
||||
import "slices"
|
||||
import "image/color"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
|
||||
type containerBox struct {
|
||||
*box
|
||||
@ -50,7 +50,7 @@ func (this *containerBox) OnContentBoundsChange (callback func()) event.Cookie {
|
||||
|
||||
func (this *containerBox) Add (child tomo.Object) {
|
||||
box := assertAnyBox(child.GetBox())
|
||||
if slices.Index(this.children, box) > -1 { return }
|
||||
if util.IndexOf(this.children, box) > -1 { return }
|
||||
|
||||
box.setParent(this)
|
||||
box.flushActionQueue()
|
||||
@ -61,26 +61,26 @@ func (this *containerBox) Add (child tomo.Object) {
|
||||
|
||||
func (this *containerBox) Remove (child tomo.Object) {
|
||||
box := assertAnyBox(child.GetBox())
|
||||
index := slices.Index(this.children, box)
|
||||
index := util.IndexOf(this.children, box)
|
||||
if index < 0 { return }
|
||||
|
||||
box.setParent(nil)
|
||||
this.children = slices.Delete(this.children, index, index + 1)
|
||||
this.children = util.Remove(this.children, index)
|
||||
this.invalidateLayout()
|
||||
this.invalidateMinimum()
|
||||
}
|
||||
|
||||
func (this *containerBox) Insert (child, before tomo.Object) {
|
||||
box := assertAnyBox(child.GetBox())
|
||||
if slices.Index(this.children, box) > -1 { return }
|
||||
if util.IndexOf(this.children, box) > -1 { return }
|
||||
|
||||
beforeBox := assertAnyBox(before.GetBox())
|
||||
index := slices.Index(this.children, beforeBox)
|
||||
index := util.IndexOf(this.children, beforeBox)
|
||||
|
||||
if index < 0 {
|
||||
this.children = append(this.children, box)
|
||||
} else {
|
||||
this.children = slices.Insert(this.children, index, box)
|
||||
this.children = util.Insert(this.children, index, box)
|
||||
}
|
||||
box.setParent(this)
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@ package system
|
||||
|
||||
import "image"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/config"
|
||||
|
||||
// TODO: once go v1.23 comes out, replace the explicit iterator calls here with
|
||||
// range loops
|
||||
@ -40,14 +39,15 @@ func (this *Hierarchy) HandleKeyDown (key input.Key, numberPad bool) {
|
||||
}
|
||||
if caught { return }
|
||||
|
||||
switch input.KC(key, this.modifiers) {
|
||||
case config.KeyChordFocusNext: this.focusNext()
|
||||
case config.KeyChordFocusPrevious: this.focusPrevious()
|
||||
// TODO: up, down, left, and right should find a box to the top, bottom,
|
||||
// left, and right respectively to move the focus to. we might want to
|
||||
// have four corresponding key chords in tomo/config.
|
||||
case input.KC(input.KeyDown, input.ModNone): this.focusNext()
|
||||
case input.KC(input.KeyUp, input.ModNone): this.focusPrevious()
|
||||
switch key {
|
||||
case input.KeyTab:
|
||||
if this.modifiers.Shift {
|
||||
this.focusPrevious()
|
||||
} else {
|
||||
this.focusNext()
|
||||
}
|
||||
case input.KeyUp: this.focusPrevious()
|
||||
case input.KeyDown: this.focusNext()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,7 +5,7 @@ import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/container"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
|
||||
// Hierarchy is coupled to a tomo.Window implementation, and manages a tree of
|
||||
// Boxes.
|
||||
@ -25,9 +25,9 @@ type Hierarchy struct {
|
||||
drags [10][]anyBox
|
||||
minimumSize image.Point
|
||||
|
||||
needStyle ucontainer.Set[anyBox]
|
||||
needLayout ucontainer.Set[anyBox]
|
||||
needDraw ucontainer.Set[anyBox]
|
||||
needStyle util.Set[anyBox]
|
||||
needLayout util.Set[anyBox]
|
||||
needDraw util.Set[anyBox]
|
||||
needRedo bool
|
||||
minimumClean bool
|
||||
}
|
||||
@ -53,9 +53,9 @@ func (this *System) NewHierarchy (link WindowLink) *Hierarchy {
|
||||
hierarchy := &Hierarchy {
|
||||
system: this,
|
||||
link: link,
|
||||
needStyle: make(ucontainer.Set[anyBox]),
|
||||
needLayout: make(ucontainer.Set[anyBox]),
|
||||
needDraw: make(ucontainer.Set[anyBox]),
|
||||
needStyle: make(util.Set[anyBox]),
|
||||
needLayout: make(util.Set[anyBox]),
|
||||
needDraw: make(util.Set[anyBox]),
|
||||
}
|
||||
this.hierarchies.Add(hierarchy)
|
||||
return hierarchy
|
||||
|
||||
@ -4,7 +4,7 @@ import "io"
|
||||
import "image"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/style"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/container"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
|
||||
// System is coupled to a tomo.Backend implementation, and manages Hierarchies
|
||||
// and Boxes.
|
||||
@ -17,7 +17,7 @@ type System struct {
|
||||
styleNonce int
|
||||
iconSetNonce int
|
||||
|
||||
hierarchies ucontainer.Set[*Hierarchy]
|
||||
hierarchies util.Set[*Hierarchy]
|
||||
}
|
||||
|
||||
// BackendLink allows the System to call up into the tomo.Backend implementation
|
||||
@ -41,7 +41,7 @@ type SurfaceLink interface {
|
||||
func New (link BackendLink) *System {
|
||||
return &System {
|
||||
link: link,
|
||||
hierarchies: make(ucontainer.Set[*Hierarchy]),
|
||||
hierarchies: make(util.Set[*Hierarchy]),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
package system
|
||||
|
||||
import "image"
|
||||
import "unicode"
|
||||
import "image/color"
|
||||
import "golang.org/x/image/font"
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
@ -12,7 +11,6 @@ import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/event"
|
||||
import "git.tebibyte.media/tomo/tomo/canvas"
|
||||
import "git.tebibyte.media/tomo/backend/internal/util"
|
||||
import "git.tebibyte.media/sashakoshka/goutil/container"
|
||||
|
||||
type textBox struct {
|
||||
*box
|
||||
@ -33,11 +31,9 @@ type textBox struct {
|
||||
selecting bool
|
||||
selectStart int
|
||||
dot text.Dot
|
||||
desiredX fixed.Int26_6
|
||||
|
||||
drawer typeset.Drawer
|
||||
face util.Cycler[font.Face]
|
||||
lineHeight ucontainer.Memo[fixed.Int26_6]
|
||||
drawer typeset.Drawer
|
||||
face util.Cycler[font.Face]
|
||||
|
||||
on struct {
|
||||
contentBoundsChange event.FuncBroadcaster
|
||||
@ -50,12 +46,6 @@ func (this *System) NewTextBox () tomo.TextBox {
|
||||
box.box = this.newBox(box)
|
||||
box.attrTextColor.SetFallback(tomo.ATextColor(color.Black))
|
||||
box.attrDotColor.SetFallback(tomo.ADotColor(color.RGBA { G: 255, B: 255, A: 255}))
|
||||
box.lineHeight = ucontainer.NewMemo(func () fixed.Int26_6 {
|
||||
face := box.face.Value()
|
||||
if face == nil { return 0 }
|
||||
metrics := face.Metrics()
|
||||
return metrics.Height
|
||||
})
|
||||
return box
|
||||
}
|
||||
|
||||
@ -99,41 +89,13 @@ func (this *textBox) SetSelectable (selectable bool) {
|
||||
}
|
||||
|
||||
func (this *textBox) Select (dot text.Dot) {
|
||||
this.selec(dot)
|
||||
}
|
||||
|
||||
func (this *textBox) selec (dot text.Dot) bool {
|
||||
if this.selectWithoutResettingDesiredX(dot) {
|
||||
this.desiredX = fixed.I(0)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (this *textBox) selectWithoutResettingDesiredX (dot text.Dot) bool {
|
||||
if !this.selectable { return false }
|
||||
if this.dot == dot { return false }
|
||||
if !this.selectable { return }
|
||||
if this.dot == dot { return }
|
||||
this.SetFocused(true)
|
||||
this.dot = dot
|
||||
this.scrollToDot()
|
||||
this.on.dotChange.Broadcast()
|
||||
this.invalidateDraw()
|
||||
return true
|
||||
}
|
||||
|
||||
func (this *textBox) userSelect (dot text.Dot) bool {
|
||||
if this.selec(dot) {
|
||||
this.on.dotChange.Broadcast()
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (this *textBox) userSelectWithoutResettingDesiredX (dot text.Dot) bool {
|
||||
if this.selectWithoutResettingDesiredX(dot) {
|
||||
this.on.dotChange.Broadcast()
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (this *textBox) Dot () text.Dot {
|
||||
@ -275,19 +237,20 @@ func (this *textBox) drawDot (can canvas.Canvas) {
|
||||
|
||||
pen := can.Pen()
|
||||
|
||||
bounds := this.InnerBounds()
|
||||
metrics := face.Metrics()
|
||||
dot := this.dot
|
||||
canonDot := dot.Canon()
|
||||
start := this.drawer.PositionAt(canonDot.Start).Add(fixPt(this.textOffset()))
|
||||
end := this.drawer.PositionAt(canonDot.End ).Add(fixPt(this.textOffset()))
|
||||
canonEnd := this.drawer.PositionAt(dot.End ).Add(fixPt(this.textOffset()))
|
||||
height := this.drawer.LineHeight().Round()
|
||||
ascent := fixed.Point26_6 { Y: metrics.Descent }
|
||||
descent := fixed.Point26_6 { Y: metrics.Ascent }
|
||||
bounds := this.InnerBounds()
|
||||
metrics := face.Metrics()
|
||||
dot := this.dot.Canon()
|
||||
start := this.drawer.PositionAt(dot.Start).Add(fixPt(this.textOffset()))
|
||||
end := this.drawer.PositionAt(dot.End ).Add(fixPt(this.textOffset()))
|
||||
height := this.drawer.LineHeight().Round()
|
||||
ascent := fixed.Point26_6 { Y: metrics.Descent }
|
||||
descent := fixed.Point26_6 { Y: metrics.Ascent }
|
||||
|
||||
switch {
|
||||
case canonDot.Empty():
|
||||
case dot.Empty():
|
||||
pen.Stroke(textColor)
|
||||
pen.StrokeWeight(1)
|
||||
pen.Path(roundPt(start.Add(ascent)), roundPt(start.Sub(descent)))
|
||||
|
||||
case start.Y == end.Y:
|
||||
pen.Fill(dotColor)
|
||||
@ -321,19 +284,6 @@ func (this *textBox) drawDot (can canvas.Canvas) {
|
||||
rect.Min.X = bounds.Min.X
|
||||
pen.Rectangle(rect)
|
||||
}
|
||||
|
||||
pen.Stroke(textColor)
|
||||
pen.StrokeWeight(1)
|
||||
beamTop := roundPt(canonEnd.Add(ascent)).Sub(image.Pt(0, 1))
|
||||
beamBottom := roundPt(canonEnd.Sub(descent))
|
||||
beamSerif := 3
|
||||
pen.Path(beamTop, beamBottom)
|
||||
pen.Path (
|
||||
beamTop.Sub(image.Pt(beamSerif - 1, 0)),
|
||||
beamTop.Add(image.Pt(beamSerif, 0)))
|
||||
pen.Path (
|
||||
beamBottom.Sub(image.Pt(beamSerif - 1, 0)),
|
||||
beamBottom.Add(image.Pt(beamSerif, 0)))
|
||||
}
|
||||
|
||||
func (this *textBox) textOffset () image.Point {
|
||||
@ -357,7 +307,7 @@ func (this *textBox) handleMouseDown (button input.Button) bool {
|
||||
index := this.runeUnderMouse()
|
||||
this.selectStart = index
|
||||
this.selecting = true
|
||||
this.userSelect(text.Dot { Start: this.selectStart, End: index })
|
||||
this.Select(text.Dot { Start: this.selectStart, End: index })
|
||||
}
|
||||
return this.box.handleMouseDown(button)
|
||||
}
|
||||
@ -366,7 +316,7 @@ func (this *textBox) handleMouseUp (button input.Button) bool {
|
||||
if this.mouseButtonCanDrag(button) && this.selecting {
|
||||
index := this.runeUnderMouse()
|
||||
this.selecting = false
|
||||
this.userSelect(text.Dot { Start: this.selectStart, End: index })
|
||||
this.Select(text.Dot { Start: this.selectStart, End: index })
|
||||
}
|
||||
return this.box.handleMouseUp(button)
|
||||
}
|
||||
@ -380,7 +330,7 @@ func (this *textBox) mouseButtonCanDrag (button input.Button) bool {
|
||||
func (this *textBox) handleMouseMove () bool {
|
||||
if this.selecting {
|
||||
index := this.runeUnderMouse()
|
||||
this.userSelect(text.Dot { Start: this.selectStart, End: index })
|
||||
this.Select(text.Dot { Start: this.selectStart, End: index })
|
||||
}
|
||||
return this.box.handleMouseMove()
|
||||
}
|
||||
@ -392,8 +342,6 @@ func (this *textBox) runeUnderMouse () int {
|
||||
return this.drawer.AtPosition(fixPt(position))
|
||||
}
|
||||
|
||||
// TODO the keynav here should make better use of input key chords.
|
||||
|
||||
func (this *textBox) handleKeyDown (key input.Key, numberPad bool) bool {
|
||||
if this.box.handleKeyDown(key, numberPad) { return true }
|
||||
if !this.selectable { return false }
|
||||
@ -401,87 +349,37 @@ func (this *textBox) handleKeyDown (key input.Key, numberPad bool) bool {
|
||||
// because fuck you thats why!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
modifiers := this.Window().Modifiers()
|
||||
dot := this.Dot()
|
||||
sel := modifiers.Shift()
|
||||
word := modifiers.Control()
|
||||
|
||||
moveVertically := func (delta fixed.Int26_6) {
|
||||
currentDot := 0
|
||||
if sel {
|
||||
currentDot = dot.End
|
||||
} else {
|
||||
currentDot = dot.Canon().Start
|
||||
if delta > fixed.I(0) { currentDot = dot.Canon().End }
|
||||
}
|
||||
|
||||
nextDot := 0
|
||||
if word {
|
||||
if delta > fixed.I(0) {
|
||||
nextDot = nextParagraph(this.runes, currentDot)
|
||||
} else {
|
||||
nextDot = previousParagraph(this.runes, currentDot)
|
||||
}
|
||||
} else {
|
||||
currentPosition := this.drawer.PositionAt(currentDot)
|
||||
if this.desiredX != fixed.I(0) {
|
||||
currentPosition.X = this.desiredX
|
||||
}
|
||||
nextPosition := currentPosition
|
||||
nextPosition.Y += this.lineHeight.Value().Mul(delta)
|
||||
this.desiredX = nextPosition.X
|
||||
nextDot = this.drawer.AtPosition(nextPosition)
|
||||
}
|
||||
|
||||
if sel {
|
||||
dot.End = nextDot
|
||||
this.userSelectWithoutResettingDesiredX(dot)
|
||||
} else {
|
||||
this.userSelectWithoutResettingDesiredX(text.EmptyDot(nextDot))
|
||||
}
|
||||
}
|
||||
|
||||
sel := modifiers.Shift
|
||||
word := modifiers.Control
|
||||
switch {
|
||||
case key == input.KeyHome || (modifiers.Alt() && key == input.KeyLeft):
|
||||
if word {
|
||||
dot.End = 0
|
||||
} else {
|
||||
dot.End = lineHomeSoft(this.runes, dot.End)
|
||||
}
|
||||
case key == input.KeyHome || (modifiers.Alt && key == input.KeyLeft):
|
||||
dot.End = 0
|
||||
if !sel { dot.Start = dot.End }
|
||||
this.userSelect(dot)
|
||||
this.Select(dot)
|
||||
return true
|
||||
case key == input.KeyEnd || (modifiers.Alt() && key == input.KeyRight):
|
||||
if word {
|
||||
dot.End = len(this.runes)
|
||||
} else {
|
||||
dot.End = lineEnd(this.runes, dot.End)
|
||||
}
|
||||
case key == input.KeyEnd || (modifiers.Alt && key == input.KeyRight):
|
||||
dot.End = len(this.text)
|
||||
if !sel { dot.Start = dot.End }
|
||||
this.userSelect(dot)
|
||||
this.Select(dot)
|
||||
return true
|
||||
case key == input.KeyLeft:
|
||||
if sel {
|
||||
this.userSelect(text.SelectLeft(this.runes, dot, word))
|
||||
this.Select(text.SelectLeft(this.runes, dot, word))
|
||||
} else {
|
||||
this.userSelect(text.MoveLeft(this.runes, dot, word))
|
||||
this.Select(text.MoveLeft(this.runes, dot, word))
|
||||
}
|
||||
return true
|
||||
case key == input.KeyRight:
|
||||
if sel {
|
||||
this.userSelect(text.SelectRight(this.runes, dot, word))
|
||||
this.Select(text.SelectRight(this.runes, dot, word))
|
||||
} else {
|
||||
this.userSelect(text.MoveRight(this.runes, dot, word))
|
||||
this.Select(text.MoveRight(this.runes, dot, word))
|
||||
}
|
||||
return true
|
||||
case key == input.KeyUp:
|
||||
moveVertically(fixed.I(-1))
|
||||
return true
|
||||
case key == input.KeyDown:
|
||||
moveVertically(fixed.I(1))
|
||||
return true
|
||||
case key == input.Key('a') && modifiers.Control():
|
||||
case key == input.Key('a') && modifiers.Control:
|
||||
dot.Start = 0
|
||||
dot.End = len(this.runes)
|
||||
this.userSelect(dot)
|
||||
dot.End = len(this.text)
|
||||
this.Select(dot)
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
@ -494,19 +392,15 @@ func (this *textBox) handleKeyUp (key input.Key, numberPad bool) bool {
|
||||
|
||||
modifiers := this.Window().Modifiers()
|
||||
switch {
|
||||
case key == input.KeyHome || (modifiers.Alt() && key == input.KeyLeft):
|
||||
case key == input.KeyHome || (modifiers.Alt && key == input.KeyLeft):
|
||||
return true
|
||||
case key == input.KeyEnd || (modifiers.Alt() && key == input.KeyRight):
|
||||
return true
|
||||
case key == input.KeyUp:
|
||||
return true
|
||||
case key == input.KeyDown:
|
||||
case key == input.KeyEnd || (modifiers.Alt && key == input.KeyRight):
|
||||
return true
|
||||
case key == input.KeyLeft:
|
||||
return true
|
||||
case key == input.KeyRight:
|
||||
return true
|
||||
case key == input.Key('a') && modifiers.Control():
|
||||
case key == input.Key('a') && modifiers.Control:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
@ -608,7 +502,6 @@ func (this *textBox) handleFaceChange () {
|
||||
this.drawer.SetFace(face)
|
||||
this.invalidateMinimum()
|
||||
this.invalidateLayout()
|
||||
this.lineHeight.Invalidate()
|
||||
}
|
||||
|
||||
func (this *textBox) recursiveReApply () {
|
||||
@ -630,70 +523,3 @@ func (this *textBox) recursiveReApply () {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: these two functions really could be better.
|
||||
|
||||
func previousParagraph (text []rune, index int) int {
|
||||
consecLF := 0
|
||||
if index >= len(text) { index = len(text) - 1 }
|
||||
for ; index > 0; index -- {
|
||||
char := text[index]
|
||||
if char == '\n' {
|
||||
consecLF ++
|
||||
} else if !unicode.IsSpace(char) {
|
||||
if consecLF >= 2 { return index + 1 }
|
||||
consecLF = 0
|
||||
}
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
func nextParagraph (text []rune, index int) int {
|
||||
consecLF := 0
|
||||
for ; index < len(text); index ++ {
|
||||
char := text[index]
|
||||
if char == '\n' {
|
||||
consecLF ++
|
||||
} else if !unicode.IsSpace(char) {
|
||||
if consecLF >= 2 { return index }
|
||||
consecLF = 0
|
||||
}
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
func lineHome (text []rune, index int) int {
|
||||
liminal := index < len(text) && text[index] == '\n'
|
||||
if index >= len(text) { index = len(text) - 1 }
|
||||
for index := index; index >= 0; index -- {
|
||||
char := text[index]
|
||||
if char == '\n' && !liminal {
|
||||
return index + 1
|
||||
}
|
||||
liminal = false
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func lineHomeSoft (text []rune, index int) int {
|
||||
home := lineHome(text, index)
|
||||
start := home
|
||||
for start < len(text) && unicode.IsSpace(text[start]) {
|
||||
start ++
|
||||
}
|
||||
if index == start {
|
||||
return home
|
||||
} else {
|
||||
return start
|
||||
}
|
||||
}
|
||||
|
||||
func lineEnd (text []rune, index int) int {
|
||||
for ; index < len(text); index ++ {
|
||||
char := text[index]
|
||||
if char == '\n' {
|
||||
return index
|
||||
}
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
@ -1,6 +1,100 @@
|
||||
package util
|
||||
|
||||
import "io"
|
||||
import "image/color"
|
||||
|
||||
// IndexOf returns the index of needle within haystack. If needle does not exist
|
||||
// within haystack, it returns -1.
|
||||
func IndexOf[T comparable] (haystack []T, needle T) int {
|
||||
for index, test := range haystack {
|
||||
if test == needle {
|
||||
return index
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// Remove removes an element from slice at index.
|
||||
func Remove[T any] (slice []T, index int) []T {
|
||||
return append(slice[:index], slice[index + 1:]...)
|
||||
}
|
||||
|
||||
// Insert inserts an element into slice at index.
|
||||
func Insert[T any] (slice []T, index int, element T) []T {
|
||||
slice = append(slice[:index + 1], slice[index:]...)
|
||||
slice[index] = element
|
||||
return slice
|
||||
}
|
||||
|
||||
// Transparent returns whether or not a color has transparency.
|
||||
func Transparent (c color.Color) bool {
|
||||
_, _, _, a := c.RGBA()
|
||||
return a != 0xFFFF
|
||||
}
|
||||
|
||||
// Set is a set of unique items, built on top of map.
|
||||
type Set[T comparable] map[T] struct { }
|
||||
|
||||
// Empty returns true if there are no items in the set.
|
||||
func (set Set[T]) Empty () bool {
|
||||
return set == nil || len(set) == 0
|
||||
}
|
||||
|
||||
// Has returns true if the set contains item.
|
||||
func (set Set[T]) Has (item T) bool {
|
||||
if set == nil {
|
||||
return false
|
||||
}
|
||||
_, ok := set[item]
|
||||
return ok
|
||||
}
|
||||
|
||||
// Add adds an item to the set.
|
||||
func (set Set[T]) Add (item T) {
|
||||
set[item] = struct { } { }
|
||||
}
|
||||
|
||||
// Pop removes the first accessible item from the set and returns it.
|
||||
func (set Set[T]) Pop () (item T) {
|
||||
for item := range set {
|
||||
delete(set, item)
|
||||
return item
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Memo holds a cached value.
|
||||
type Memo[T any] struct {
|
||||
cache T
|
||||
valid bool
|
||||
update func () T
|
||||
}
|
||||
|
||||
// NewMemo creates a new Memo which will take its value from the specified
|
||||
// update callback.
|
||||
func NewMemo[T any] (update func () T) Memo[T] {
|
||||
return Memo[T] {
|
||||
update: update,
|
||||
}
|
||||
}
|
||||
|
||||
// Value returns the Memo's value, updating it if the current cached value is
|
||||
// invalid.
|
||||
func (this *Memo[T]) Value () T {
|
||||
if !this.valid {
|
||||
this.cache = this.update()
|
||||
this.valid = true
|
||||
}
|
||||
return this.cache
|
||||
}
|
||||
|
||||
// Invalidate marks the Memo's value as invalid, which will cause it to be
|
||||
// updated the next time Value is called.
|
||||
func (this *Memo[T]) Invalidate () {
|
||||
var zero T
|
||||
this.cache = zero
|
||||
this.valid = false
|
||||
}
|
||||
|
||||
// Cycler stores a value and an accompanying io.Closer. When the value is set,
|
||||
// the closer associated with the previous value is closed.
|
||||
@ -30,3 +124,33 @@ func (this *Cycler[T]) Close () error {
|
||||
this.closer = nil
|
||||
return err
|
||||
}
|
||||
|
||||
// Optional is an optional value.
|
||||
type Optional[T any] struct {
|
||||
value T
|
||||
exists bool
|
||||
}
|
||||
|
||||
// Value returns the value and true if the value exists. If not, it returns the
|
||||
// last set value and false.
|
||||
func (this *Optional[T]) Value () (T, bool) {
|
||||
return this.value, this.exists
|
||||
}
|
||||
|
||||
// Set sets the value.
|
||||
func (this *Optional[T]) Set (value T) {
|
||||
this.value = value
|
||||
this.exists = true
|
||||
}
|
||||
|
||||
// Unset unsets the value.
|
||||
func (this *Optional[T]) Unset () {
|
||||
var zero T
|
||||
this.value = zero
|
||||
this.exists = false
|
||||
}
|
||||
|
||||
// Exists returns if the value is currently set.
|
||||
func (this *Optional[T]) Exists () bool {
|
||||
return this.exists
|
||||
}
|
||||
|
||||
20
x/event.go
20
x/event.go
@ -7,7 +7,6 @@ import "github.com/jezek/xgb/xproto"
|
||||
import "git.tebibyte.media/tomo/xgbkb"
|
||||
import "github.com/jezek/xgbutil/xevent"
|
||||
import "git.tebibyte.media/tomo/tomo/input"
|
||||
import "git.tebibyte.media/tomo/tomo/config"
|
||||
|
||||
type scrollSum struct {
|
||||
x, y int
|
||||
@ -227,7 +226,7 @@ func (window *window) handleKeyPress (
|
||||
key, numberPad := keycodeToKey(keyEvent.Detail, keyEvent.State)
|
||||
window.updateModifiers(keyEvent.State)
|
||||
|
||||
if config.KeyChordClose.Pressed(key, window.Modifiers()) && window.shy {
|
||||
if key == input.KeyEscape && window.shy {
|
||||
window.Close()
|
||||
} else {
|
||||
window.hierarchy.HandleKeyDown(key, numberPad)
|
||||
@ -434,15 +433,14 @@ func (window *window) compressMotionNotify (
|
||||
|
||||
func (window *window) updateModifiers (state uint16) {
|
||||
xModifiers := xgbkb.StateToModifiers(state)
|
||||
var modifiers input.Modifiers
|
||||
if xModifiers.Shift { modifiers |= input.ModShift }
|
||||
if xModifiers.ShiftLock { modifiers |= input.ModShift }
|
||||
if xModifiers.Control { modifiers |= input.ModControl }
|
||||
if xModifiers.Alt { modifiers |= input.ModAlt }
|
||||
if xModifiers.Meta { modifiers |= input.ModMeta }
|
||||
if xModifiers.Super { modifiers |= input.ModSuper }
|
||||
if xModifiers.Hyper { modifiers |= input.ModHyper }
|
||||
window.hierarchy.HandleModifiers(modifiers)
|
||||
window.hierarchy.HandleModifiers(input.Modifiers {
|
||||
Shift: xModifiers.Shift || xModifiers.ShiftLock,
|
||||
Control: xModifiers.Control,
|
||||
Alt: xModifiers.Alt,
|
||||
Meta: xModifiers.Meta,
|
||||
Super: xModifiers.Super,
|
||||
Hyper: xModifiers.Hyper,
|
||||
})
|
||||
}
|
||||
|
||||
func (window *window) updateMousePosition (x, y int16) {
|
||||
|
||||
125
x/window.go
125
x/window.go
@ -1,7 +1,6 @@
|
||||
package x
|
||||
|
||||
import "image"
|
||||
import "strings"
|
||||
|
||||
import "git.tebibyte.media/tomo/tomo"
|
||||
import "git.tebibyte.media/tomo/tomo/data"
|
||||
@ -42,10 +41,7 @@ type window struct {
|
||||
innerBounds image.Rectangle // bounds of the drawable area
|
||||
}
|
||||
|
||||
on struct {
|
||||
close event.FuncBroadcaster
|
||||
tryClose event.Broadcaster[func () bool]
|
||||
}
|
||||
onClose event.FuncBroadcaster
|
||||
}
|
||||
|
||||
type windowLink struct {
|
||||
@ -68,12 +64,27 @@ func (this *windowLink) NotifyMinimumSizeChange () {
|
||||
this.window.doMinimumSize()
|
||||
}
|
||||
|
||||
func (this *Backend) NewWindow (kind tomo.WindowKind, bounds image.Rectangle) (tomo.Window, error) {
|
||||
func (this *Backend) NewWindow (
|
||||
bounds image.Rectangle,
|
||||
) (
|
||||
output tomo.Window,
|
||||
err error,
|
||||
) {
|
||||
this.assert()
|
||||
window, err := this.newWindow(bounds, kind == tomo.WindowKindMenu)
|
||||
if err != nil { return nil, err }
|
||||
window.setKind(kind)
|
||||
return window, nil
|
||||
return this.newWindow(bounds, false)
|
||||
}
|
||||
|
||||
func (this *Backend) NewPlainWindow (
|
||||
bounds image.Rectangle,
|
||||
) (
|
||||
output tomo.Window,
|
||||
err error,
|
||||
) {
|
||||
this.assert()
|
||||
window, err := this.newWindow(bounds, false)
|
||||
window.setType("dock")
|
||||
|
||||
return window, err
|
||||
}
|
||||
|
||||
func (this *Backend) newWindow (
|
||||
@ -120,11 +131,7 @@ func (this *Backend) newWindow (
|
||||
if err != nil { return }
|
||||
|
||||
window.xWindow.WMGracefulClose (func (xWindow *xwindow.Window) {
|
||||
holdOff := false
|
||||
for _, callback := range window.on.tryClose.Listeners() {
|
||||
if !callback() { holdOff = true }
|
||||
}
|
||||
if !holdOff { window.Close() }
|
||||
window.Close()
|
||||
})
|
||||
|
||||
xevent.ExposeFun(window.handleExpose).
|
||||
@ -240,29 +247,56 @@ func (this *window) SetBounds (bounds image.Rectangle) {
|
||||
bounds.Min.Y + bounds.Dy())
|
||||
}
|
||||
|
||||
func (this *window) NewChild (kind tomo.WindowKind, bounds image.Rectangle) (tomo.Window, error) {
|
||||
func (this *window) NewChild (bounds image.Rectangle) (tomo.Window, error) {
|
||||
leader := this.leader
|
||||
|
||||
child, err := this.backend.newWindow (
|
||||
bounds.Add(this.metrics.innerBounds.Min), kind == tomo.WindowKindMenu)
|
||||
bounds.Add(this.metrics.innerBounds.Min), false)
|
||||
child.leader = leader
|
||||
if err != nil { return nil, err }
|
||||
|
||||
child.leader = leader
|
||||
err = child.setKind(kind)
|
||||
if err != nil { return nil, err }
|
||||
if kind == tomo.WindowKindModal {
|
||||
this.hasModal = true
|
||||
child.modalParent = this
|
||||
}
|
||||
child.setClientLeader(leader)
|
||||
leader.setClientLeader(leader)
|
||||
|
||||
icccm.WmTransientForSet (
|
||||
this.backend.x,
|
||||
child.xWindow.Id,
|
||||
leader.xWindow.Id)
|
||||
child.setType("UTILITY")
|
||||
// child.inheritProperties(leader.window)
|
||||
return child, err
|
||||
}
|
||||
|
||||
func (this *window) NewMenu (bounds image.Rectangle) (tomo.Window, error) {
|
||||
menu, err := this.backend.newWindow (
|
||||
bounds.Add(this.metrics.innerBounds.Min), true)
|
||||
menu.shy = true
|
||||
icccm.WmTransientForSet (
|
||||
this.backend.x,
|
||||
menu.xWindow.Id,
|
||||
this.xWindow.Id)
|
||||
menu.setType("POPUP_MENU")
|
||||
// menu.inheritProperties(this)
|
||||
return menu, err
|
||||
}
|
||||
|
||||
func (this *window) NewModal (bounds image.Rectangle) (tomo.Window, error) {
|
||||
modal, err := this.backend.newWindow (
|
||||
bounds.Add(this.metrics.innerBounds.Min), false)
|
||||
icccm.WmTransientForSet (
|
||||
this.backend.x,
|
||||
modal.xWindow.Id,
|
||||
this.xWindow.Id)
|
||||
ewmh.WmStateSet (
|
||||
this.backend.x,
|
||||
modal.xWindow.Id,
|
||||
[]string { "_NET_WM_STATE_MODAL" })
|
||||
modal.modalParent = this
|
||||
this.hasModal = true
|
||||
// modal.inheritProperties(window)
|
||||
return modal, err
|
||||
}
|
||||
|
||||
func (this *window) Modifiers () input.Modifiers {
|
||||
return this.hierarchy.Modifiers()
|
||||
}
|
||||
@ -296,12 +330,12 @@ func (this *window) Visible () bool {
|
||||
return this.visible
|
||||
}
|
||||
|
||||
func (this *window) Close () error {
|
||||
func (this *window) Close () {
|
||||
xevent .Detach(this.backend.x, this.xWindow.Id)
|
||||
keybind .Detach(this.backend.x, this.xWindow.Id)
|
||||
mousebind.Detach(this.backend.x, this.xWindow.Id)
|
||||
|
||||
this.on.close.Broadcast()
|
||||
this.onClose.Broadcast()
|
||||
if this.modalParent != nil {
|
||||
// we are a modal dialog, so unlock the parent
|
||||
this.modalParent.hasModal = false
|
||||
@ -311,15 +345,10 @@ func (this *window) Close () error {
|
||||
delete(this.backend.windows, this.xWindow.Id)
|
||||
this.xWindow.Destroy()
|
||||
this.hierarchy.Close()
|
||||
return nil // TODO maybe return an error? maybe join them?
|
||||
}
|
||||
|
||||
func (this *window) OnClose (callback func ()) event.Cookie {
|
||||
return this.on.close.Connect(callback)
|
||||
}
|
||||
|
||||
func (this *window) OnTryClose (callback func () bool) event.Cookie {
|
||||
return this.on.tryClose.Connect(callback)
|
||||
return this.onClose.Connect(callback)
|
||||
}
|
||||
|
||||
func (this *window) grabInput () {
|
||||
@ -335,19 +364,6 @@ func (this *window) ungrabInput () {
|
||||
mousebind.UngrabPointer(this.backend.x)
|
||||
}
|
||||
|
||||
func (this *window) setKind (kind tomo.WindowKind) error {
|
||||
err := this.setType(windowKindToType(kind))
|
||||
if err != nil { return err }
|
||||
if kind == tomo.WindowKindModal {
|
||||
err = this.setState("MODAL")
|
||||
if err != nil { return err }
|
||||
}
|
||||
if kind == tomo.WindowKindMenu {
|
||||
this.shy = true
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (this *window) setType (ty string) error {
|
||||
return ewmh.WmWindowTypeSet (
|
||||
this.backend.x,
|
||||
@ -355,13 +371,6 @@ func (this *window) setType (ty string) error {
|
||||
[]string { "_NET_WM_WINDOW_TYPE_" + ty })
|
||||
}
|
||||
|
||||
func (this *window) setState (state string) error {
|
||||
return ewmh.WmStateSet (
|
||||
this.backend.x,
|
||||
this.xWindow.Id,
|
||||
[]string { "_NET_WM_STATE_" + state })
|
||||
}
|
||||
|
||||
func (this *window) setClientLeader (leader *window) error {
|
||||
hints, _ := icccm.WmHintsGet(this.backend.x, this.xWindow.Id)
|
||||
if hints == nil {
|
||||
@ -467,15 +476,3 @@ func (this *window) doMinimumSize () {
|
||||
this.xWindow.Resize(newWidth, newHeight)
|
||||
}
|
||||
}
|
||||
|
||||
func windowKindToType (kind tomo.WindowKind) string {
|
||||
switch kind {
|
||||
case tomo.WindowKindNormal: return "NORMAL"
|
||||
case tomo.WindowKindPlain: return "DOCK"
|
||||
case tomo.WindowKindUtility: return "UTILITY"
|
||||
case tomo.WindowKindToolbar: return "MENU"
|
||||
case tomo.WindowKindMenu: return "POPUP_MENU"
|
||||
case tomo.WindowKindModal: return "NORMAL"
|
||||
default: return strings.ReplaceAll(strings.ToUpper(string(kind)), " ", "_")
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user