fixed unicode characters on last column

draw_buffer.go

@@ -1,29 +1,36 @@
 package tui
 
 import (
+	"git.milar.in/milarin/slices"
 	"github.com/gdamore/tcell"
+	"github.com/mattn/go-runewidth"
 )
 
 func drawBuffer(scr tcell.Screen, buf *ViewBuffer) {
-	// buf.ForEach(func(x, y int, rn Rune) {
-	// 	scr.SetContent(x, y, rn.Rn, nil, rn.Style)
-	// })
-
 	buf.ForEachLine(func(y int, content []Rune) {
 		for x := 0; x < buf.Width(); x++ {
 			rn := content[x]
-			if rn.Rn >= '─' && rn.Rn <= '╿' {
-				scr.SetContent(x, y, rn.Rn, []rune{content[x+1].Rn}, rn.Style)
-				x++
+
+			extraRuneCount := runewidth.RuneWidth(rn.Rn) - 1
+			var extraRunes []Rune
+			if x+1+extraRuneCount < len(content) {
+				extraRunes = content[x+1 : x+1+extraRuneCount]
 			} else {
-				scr.SetContent(x, y, rn.Rn, nil, rn.Style)
+				extraRunes = content[x+1 : x+1]
 			}
+
+			scr.SetContent(x, y, rn.Rn, slices.Map(extraRunes, getRune), rn.Style)
+			x += extraRuneCount
 		}
 	})
 
 	scr.Show()
 }
 
+func getRune(rn Rune) rune {
+	return rn.Rn
+}
+
 func truncateBuffer(buf *ViewBuffer, w, h int) *ViewBuffer {
 	if w < 0 {
 		w = buf.Width()

events.go

@@ -2,7 +2,33 @@ package tui
 
 type Events interface {
 
-	// KeyPressed is called every time a key or key-combination is pressed.
-	// If KeyPressed returns true, the event will not be passed onto child views
+	// OnKeyPressed is called every time a key or key-combination is pressed.
+	// If OnKeyPressed returns true, the event will not be passed onto child views
 	OnKeyPressed(event *KeyEvent) (consumed bool)
+
+	// OnMouseEvent is called every time the mouse was used in any way.
+	// That includes mouse movement, button presses and scroll wheel usage
+	// If OnMouseClicked returns true, the event will not be passed onto child views
+	OnMouseEvent(event *MouseEvent) (consumed bool)
+}
+
+type EventTmpl struct {
+	KeyPressed func(event *KeyEvent) (consumed bool)
+	MouseEvent func(event *MouseEvent) (consumed bool)
+}
+
+var _ Events = &EventTmpl{}
+
+func (e *EventTmpl) OnKeyPressed(event *KeyEvent) (consumed bool) {
+	if e.KeyPressed == nil {
+		return false
+	}
+	return e.KeyPressed(event)
+}
+
+func (e *EventTmpl) OnMouseEvent(event *MouseEvent) (consumed bool) {
+	if e.MouseEvent == nil {
+		return false
+	}
+	return e.MouseEvent(event)
 }

go.mod

@@ -1,16 +1,20 @@
-module git.tordarus.net/Tordarus/tui
+module git.milar.in/milarin/tui
 
 go 1.18
 
 require (
-	git.tordarus.net/Tordarus/buf2d v1.1.1
+	git.milar.in/milarin/adverr v1.1.0
+	git.milar.in/milarin/buf2d v1.1.7
+	git.milar.in/milarin/ds v0.0.2
+	git.milar.in/milarin/gmath v0.0.3
+	git.milar.in/milarin/slices v0.0.8
 	github.com/gdamore/tcell v1.4.0
-	golang.org/x/text v0.3.7
+	github.com/mattn/go-runewidth v0.0.7
 )
 
 require (
 	github.com/gdamore/encoding v1.0.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
-	github.com/mattn/go-runewidth v0.0.7 // indirect
 	golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756 // indirect
+	golang.org/x/text v0.3.7 // indirect
 )

go.sum

@@ -1,5 +1,13 @@
-git.tordarus.net/Tordarus/buf2d v1.1.1 h1:rYvQ2YveqogCoKy5andQxuORPusWbUhpnqJhzVkTlRs=
-git.tordarus.net/Tordarus/buf2d v1.1.1/go.mod h1:XXPpS8nQK0gUI0ki7ftV/qlprsGCRWFVSD4ybvDuUL8=
+git.milar.in/milarin/adverr v1.1.0 h1:jD9WnOvs40lfMhvqQ7cllOaRJNBMWr1f07/s9jAadp0=
+git.milar.in/milarin/adverr v1.1.0/go.mod h1:joU9sBb7ySyNv4SpTXB0Z4o1mjXsArBw4N27wjgzj9E=
+git.milar.in/milarin/buf2d v1.1.7 h1:c+YEM4jthzaLmifx9PfP1Gy4ozQxh9+0menyShj0qU0=
+git.milar.in/milarin/buf2d v1.1.7/go.mod h1:yiJgXMuUXTQ/Dzc/N3iIMa4riyL5y1aQgZOZfzNIWHo=
+git.milar.in/milarin/ds v0.0.2 h1:vCA3mDxZUNfvHpzrdz7SeBUKiPn74NTopo915IUG7I0=
+git.milar.in/milarin/ds v0.0.2/go.mod h1:HJK7QERcRvV9j7xzEocrKUtW+1q4JB1Ly4Bj54chfwI=
+git.milar.in/milarin/gmath v0.0.3 h1:ii6rKNItS55O/wtIFhD1cTN2BMwDZjTBmiOocKURvxM=
+git.milar.in/milarin/gmath v0.0.3/go.mod h1:HDLftG5RLpiNGKiIWh+O2G1PYkNzyLDADO8Cd/1abiE=
+git.milar.in/milarin/slices v0.0.8 h1:qN9TE3tkArdTixMKSnwvNPcApwAjxpLVwA5a9k1rm2s=
+git.milar.in/milarin/slices v0.0.8/go.mod h1:qMhdtMnfWswc1rHpwgNw33lB84aNEkdBn5BDiYA+G3k=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=

layouts/layout_border.go

@@ -1,26 +1,29 @@
-package views
+package layouts
 
 import (
-	"git.tordarus.net/Tordarus/tui"
+	"git.milar.in/milarin/tui"
 )
 
-// BorderGroup ia a tui.Group which places its children onto a given tui.Side
-type BorderGroup struct {
+// BorderLayout ia a tui.Layout which places its children onto a given tui.Side
+type BorderLayout struct {
 	tui.ViewTmpl
 	views            map[Slot]tui.View
 	horizontalLayout *LayoutResult
 	verticalLayout   *LayoutResult
+
+	viewDims map[Slot]tui.Dimension
 }
 
-var _ tui.Group = &BorderGroup{}
+var _ tui.Layout = &BorderLayout{}
 
-func NewBorderGroup() *BorderGroup {
-	return &BorderGroup{
-		views: map[Slot]tui.View{},
+func NewBorderLayout() *BorderLayout {
+	return &BorderLayout{
+		views:    map[Slot]tui.View{},
+		viewDims: map[Slot]tui.Dimension{},
 	}
 }
 
-func (g *BorderGroup) Views() []tui.View {
+func (g *BorderLayout) Views() []tui.View {
 	s := make([]tui.View, 0, len(g.views))
 	for _, view := range g.views {
 		s = append(s, view)
@@ -28,15 +31,15 @@ func (g *BorderGroup) Views() []tui.View {
 	return s
 }
 
-func (g *BorderGroup) SetView(v tui.View, slot Slot) {
+func (g *BorderLayout) SetView(v tui.View, slot Slot) {
 	g.views[slot] = v
 }
 
-func (g *BorderGroup) View(slot Slot) tui.View {
+func (g *BorderLayout) View(slot Slot) tui.View {
 	return g.views[slot]
 }
 
-func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
+func (g *BorderLayout) Draw(buf *tui.ViewBuffer) {
 	g.ViewTmpl.Draw(buf)
 
 	if g.verticalLayout == nil {
@@ -76,6 +79,7 @@ func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
 			topHeight = int(float64(buf.Height()) * float64(topHeight) / float64(verticalLayout.Sum.Height))
 		}
 
+		g.viewDims[Top] = tui.D(0, 0, buf.Width(), topHeight)
 		view.Draw(buf.Sub(0, 0, buf.Width(), topHeight))
 	}
 
@@ -88,6 +92,7 @@ func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
 			bottomHeight = int(float64(buf.Height()) * float64(bottomHeight) / float64(verticalLayout.Sum.Height))
 		}
 
+		g.viewDims[Bottom] = tui.D(0, buf.Height()-bottomHeight, buf.Width(), bottomHeight)
 		view.Draw(buf.Sub(0, buf.Height()-bottomHeight, buf.Width(), bottomHeight))
 	}
 
@@ -100,6 +105,7 @@ func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
 			leftWidth = int(float64(buf.Width()) * float64(leftWidth) / float64(horizontalLayout.Sum.Width))
 		}
 
+		g.viewDims[Left] = tui.D(0, topHeight, leftWidth, buf.Height()-topHeight-bottomHeight)
 		view.Draw(buf.Sub(0, topHeight, leftWidth, buf.Height()-topHeight-bottomHeight))
 	}
 
@@ -112,10 +118,12 @@ func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
 			rightWidth = int(float64(buf.Width()) * float64(rightWidth) / float64(horizontalLayout.Sum.Width))
 		}
 
+		g.viewDims[Right] = tui.D(buf.Width()-rightWidth, topHeight, rightWidth, buf.Height()-topHeight-bottomHeight)
 		view.Draw(buf.Sub(buf.Width()-rightWidth, topHeight, rightWidth, buf.Height()-topHeight-bottomHeight))
 	}
 
 	if view, ok := g.views[Center]; ok {
+		g.viewDims[Center] = tui.D(leftWidth, topHeight, buf.Width()-leftWidth-rightWidth, buf.Height()-topHeight-bottomHeight)
 		view.Draw(buf.Sub(leftWidth, topHeight, buf.Width()-leftWidth-rightWidth, buf.Height()-topHeight-bottomHeight))
 	}
 
@@ -123,27 +131,45 @@ func (g *BorderGroup) Draw(buf *tui.ViewBuffer) {
 	g.horizontalLayout = nil
 }
 
-func (g *BorderGroup) Layout() (prefWidth, prefHeight int) {
+func (g *BorderLayout) Layout() (prefWidth, prefHeight int) {
 	g.verticalLayout = CalculateLayoutResult([]tui.View{g.View(Top), g.View(Center), g.View(Bottom)})
 	g.horizontalLayout = CalculateLayoutResult([]tui.View{g.View(Left), g.View(Center), g.View(Right)})
 	return -1, -1
 }
 
-func (g *BorderGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+func (g *BorderLayout) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+	if g.KeyPressed != nil {
+		return g.KeyPressed(event)
+	}
+
 	for _, view := range g.Views() {
-		if view.OnKeyPressed(event) {
+		if consumed := view.OnKeyPressed(event); consumed {
 			return true
 		}
 	}
 	return false
 }
 
-type Slot uint8
+func (g *BorderLayout) OnMouseEvent(event *tui.MouseEvent) (consumed bool) {
+	if g.MouseEvent != nil {
+		return g.MouseEvent(event)
+	}
+
+	for slot, dim := range g.viewDims {
+		if event.Position.In(dim) {
+			g.views[slot].OnMouseEvent(event)
+			return true
+		}
+	}
+	return false
+}
+
+type Slot string
 
 const (
-	Top Slot = iota
-	Bottom
-	Left
-	Right
-	Center
+	Top    Slot = "top"
+	Bottom Slot = "bottom"
+	Left   Slot = "left"
+	Right  Slot = "right"
+	Center Slot = "center"
 )

layouts/layout_coord.go

@@ -1,22 +1,22 @@
-package views
+package layouts
 
-import "git.tordarus.net/Tordarus/tui"
+import "git.milar.in/milarin/tui"
 
-// CoordGroup is a tui.Group which places its children on predefined coordinates
-type CoordGroup struct {
+// CoordLayout is a tui.Layout which places its children on predefined coordinates
+type CoordLayout struct {
 	tui.ViewTmpl
 	views map[tui.View]tui.Dimension
 }
 
-var _ tui.Group = &CoordGroup{}
+var _ tui.Layout = &CoordLayout{}
 
-func NewCoordGroup() *CoordGroup {
-	return &CoordGroup{
+func NewCoordLayout() *CoordLayout {
+	return &CoordLayout{
 		views: map[tui.View]tui.Dimension{},
 	}
 }
 
-func (g *CoordGroup) Views() []tui.View {
+func (g *CoordLayout) Views() []tui.View {
 	s := make([]tui.View, 0, len(g.views))
 	for v := range g.views {
 		s = append(s, v)
@@ -26,20 +26,25 @@ func (g *CoordGroup) Views() []tui.View {
 
 // SetView places v at the given coordinates with the given dimensions.
 // v will be added to g's children if not already added before
-func (g *CoordGroup) SetView(v tui.View, x, y, width, height int) {
+func (g *CoordLayout) SetView(v tui.View, x, y, width, height int) {
 	g.views[v] = tui.Dimension{Point: tui.Point{X: x, Y: y}, Size: tui.Size{Width: width, Height: height}}
 }
-func (g *CoordGroup) Draw(buf *tui.ViewBuffer) {
+
+func (g *CoordLayout) Draw(buf *tui.ViewBuffer) {
 	for v, d := range g.views {
 		v.Draw(buf.Sub(d.X, d.Y, d.Width, d.Height))
 	}
 }
 
-func (v *CoordGroup) Layout() (prefWidth, prefHeight int) {
+func (v *CoordLayout) Layout() (prefWidth, prefHeight int) {
 	return -1, -1
 }
 
-func (g *CoordGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+func (g *CoordLayout) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+	if g.KeyPressed != nil {
+		return g.KeyPressed(event)
+	}
+
 	for _, view := range g.Views() {
 		if view.OnKeyPressed(event) {
 			return true
@@ -47,3 +52,5 @@ func (g *CoordGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
 	}
 	return false
 }
+
+// TODO OnMouseEvent

layouts/layout_flow.go

@@ -1,54 +1,65 @@
-package views
+package layouts
 
 import (
-	"git.tordarus.net/Tordarus/tui"
+	"git.milar.in/milarin/tui"
 )
 
-// FlowGroup ia a tui.Group which places its children in a linear layout
-type FlowGroup struct {
+// FlowLayout ia a tui.Layout which places its children in a linear layout
+type FlowLayout struct {
 	tui.ViewTmpl
 	views           []tui.View
 	lastLayoutPhase *LayoutResult
 
+	viewDims map[tui.View]tui.Dimension
+
 	// Orientation defines in which direction the children will be placed
 	Orientation tui.Orientation
 }
 
-var _ tui.Group = &FlowGroup{}
+var _ tui.Layout = &FlowLayout{}
 
-func NewFlowGroup(orientation tui.Orientation) *FlowGroup {
-	return &FlowGroup{
+func NewFlowLayout(orientation tui.Orientation) *FlowLayout {
+	return &FlowLayout{
 		views:       make([]tui.View, 0),
+		viewDims:    map[tui.View]tui.Dimension{},
 		Orientation: orientation,
 	}
 }
 
-func (g *FlowGroup) Views() []tui.View {
-	return g.views[:]
+func (g *FlowLayout) Views() []tui.View {
+	return g.views
 }
 
-func (g *FlowGroup) AppendViews(v ...tui.View) {
+func (g *FlowLayout) AppendViews(v ...tui.View) {
 	g.views = append(g.views, v...)
 }
 
-func (g *FlowGroup) PrependViews(v ...tui.View) {
+func (g *FlowLayout) PrependViews(v ...tui.View) {
 	g.views = append(v, g.views...)
 }
 
-func (g *FlowGroup) InsertView(v tui.View, index int) {
+func (g *FlowLayout) InsertView(v tui.View, index int) {
 	g.views = append(g.views[:index], append([]tui.View{v}, g.views[index:]...)...)
 }
 
-func (g *FlowGroup) RemoveView(v tui.View) {
+func (g *FlowLayout) removeView(v tui.View) {
 	for index, view := range g.Views() {
-		if view == v {
-			g.views = append(g.views[:index], g.views[index:]...)
+		if v == view {
+			delete(g.viewDims, view)
+			g.views = append(g.views[:index], g.views[index+1:]...)
 			return
 		}
 	}
 }
 
-func (g *FlowGroup) Draw(buf *tui.ViewBuffer) {
+func (g *FlowLayout) RemoveViews(v ...tui.View) {
+	views := append(make([]tui.View, 0, len(v)), v...)
+	for _, view := range views {
+		g.removeView(view)
+	}
+}
+
+func (g *FlowLayout) Draw(buf *tui.ViewBuffer) {
 	g.ViewTmpl.Draw(buf)
 
 	if g.lastLayoutPhase == nil {
@@ -58,6 +69,9 @@ func (g *FlowGroup) Draw(buf *tui.ViewBuffer) {
 
 	if g.Orientation == tui.Horizontal {
 		remainingSpacePerView := buf.Width() - layout.Sum.Width
+		if remainingSpacePerView < 0 {
+			remainingSpacePerView = 0
+		}
 		if layout.HorizontalNegativeCount > 0 {
 			remainingSpacePerView /= layout.HorizontalNegativeCount
 		}
@@ -71,11 +85,19 @@ func (g *FlowGroup) Draw(buf *tui.ViewBuffer) {
 				size.Width = iff(layout.Sum.Width > buf.Width(), 0, remainingSpacePerView)
 			}
 
+			g.viewDims[view] = tui.D(x, 0, size.Width, size.Height)
 			view.Draw(buf.Sub(x, 0, size.Width, size.Height))
+
 			x += size.Width
+			if x >= buf.Width() {
+				break
+			}
 		}
 	} else if g.Orientation == tui.Vertical {
 		remainingSpacePerView := buf.Height() - layout.Sum.Height
+		if remainingSpacePerView < 0 {
+			remainingSpacePerView = 0
+		}
 		if layout.VerticalNegativeCount > 0 {
 			remainingSpacePerView /= layout.VerticalNegativeCount
 		}
@@ -89,15 +111,20 @@ func (g *FlowGroup) Draw(buf *tui.ViewBuffer) {
 				size.Height = iff(layout.Sum.Height > buf.Height(), 0, remainingSpacePerView)
 			}
 
+			g.viewDims[view] = tui.D(0, y, size.Width, size.Height)
 			view.Draw(buf.Sub(0, y, size.Width, size.Height))
+
 			y += size.Height
+			if y >= buf.Height() {
+				break
+			}
 		}
 	}
 
 	g.lastLayoutPhase = nil
 }
 
-func (g *FlowGroup) Layout() (prefWidth, prefHeight int) {
+func (g *FlowLayout) Layout() (prefWidth, prefHeight int) {
 	layout := CalculateLayoutResult(g.Views())
 	g.lastLayoutPhase = layout
 
@@ -106,14 +133,18 @@ func (g *FlowGroup) Layout() (prefWidth, prefHeight int) {
 		prefHeight = iff(layout.VerticalNegativeCount == 0, layout.Max.Height, -1)
 	} else if g.Orientation == tui.Vertical {
 		prefWidth = iff(layout.HorizontalNegativeCount == 0, layout.Max.Width, -1)
-		prefHeight = iff(layout.VerticalNegativeCount == 0, layout.Sum.Width, -1)
+		prefHeight = iff(layout.VerticalNegativeCount == 0, layout.Sum.Height, -1)
 	}
 
 	layout.Pref = tui.Size{Width: prefWidth, Height: prefHeight}
 	return
 }
 
-func (g *FlowGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+func (g *FlowLayout) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+	if g.KeyPressed != nil {
+		return g.KeyPressed(event)
+	}
+
 	for _, view := range g.Views() {
 		if view.OnKeyPressed(event) {
 			return true
@@ -121,3 +152,13 @@ func (g *FlowGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
 	}
 	return false
 }
+
+func (g *FlowLayout) OnMouseEvent(event *tui.MouseEvent) (consumed bool) {
+	for view, dim := range g.viewDims {
+		if event.Position.In(dim) {
+			view.OnMouseEvent(event)
+			return true
+		}
+	}
+	return false
+}

layouts/layout_grid.go

@@ -0,0 +1,3 @@
+package layouts
+
+// TODO

layouts/layout_separator.go

@@ -1,11 +1,11 @@
-package views
+package layouts
 
 import (
-	"git.tordarus.net/Tordarus/tui"
+	"git.milar.in/milarin/tui"
 )
 
-// SeperatorGroup ia a tui.Group which separates
-type SeperatorGroup struct {
+// SeperatorLayout ia a tui.Layout which separates its view into gravity-based portions
+type SeperatorLayout struct {
 	tui.ViewTmpl
 	views []tui.View
 
@@ -15,39 +15,39 @@ type SeperatorGroup struct {
 	Orientation tui.Orientation
 }
 
-var _ tui.Group = &SeperatorGroup{}
+var _ tui.Layout = &SeperatorLayout{}
 
-func NewSeparatorGroup(orientation tui.Orientation) *SeperatorGroup {
-	return &SeperatorGroup{
+func NewSeparatorLayout(orientation tui.Orientation) *SeperatorLayout {
+	return &SeperatorLayout{
 		views:       make([]tui.View, 0),
 		gravity:     map[tui.View]int{},
 		Orientation: orientation,
 	}
 }
 
-func (g *SeperatorGroup) Views() []tui.View {
+func (g *SeperatorLayout) Views() []tui.View {
 	return g.views[:]
 }
 
-func (g *SeperatorGroup) AppendView(v tui.View, gravity int) {
+func (g *SeperatorLayout) AppendView(v tui.View, gravity int) {
 	g.views = append(g.views, v)
 	g.gravitySum += gravity
 	g.gravity[v] = gravity
 }
 
-func (g *SeperatorGroup) PrependView(v tui.View, gravity int) {
+func (g *SeperatorLayout) PrependView(v tui.View, gravity int) {
 	g.views = append([]tui.View{v}, g.views...)
 	g.gravitySum += gravity
 	g.gravity[v] = gravity
 }
 
-func (g *SeperatorGroup) InsertView(v tui.View, index int, gravity int) {
+func (g *SeperatorLayout) InsertView(v tui.View, index int, gravity int) {
 	g.views = append(g.views[:index], append([]tui.View{v}, g.views[index:]...)...)
 	g.gravitySum += gravity
 	g.gravity[v] = gravity
 }
 
-func (g *SeperatorGroup) SetGravity(v tui.View, gravity int) {
+func (g *SeperatorLayout) SetGravity(v tui.View, gravity int) {
 	for _, view := range g.Views() {
 		if view == v {
 			g.gravitySum += gravity - g.gravity[v]
@@ -57,7 +57,7 @@ func (g *SeperatorGroup) SetGravity(v tui.View, gravity int) {
 	}
 }
 
-func (g *SeperatorGroup) RemoveView(v tui.View) {
+func (g *SeperatorLayout) RemoveView(v tui.View) {
 	for index, view := range g.Views() {
 		if view == v {
 			g.views = append(g.views[:index], g.views[index:]...)
@@ -68,11 +68,11 @@ func (g *SeperatorGroup) RemoveView(v tui.View) {
 	}
 }
 
-func (g *SeperatorGroup) View(slot Slot) tui.View {
-	return g.views[slot]
+func (g *SeperatorLayout) View(index int) tui.View {
+	return g.views[index]
 }
 
-func (g *SeperatorGroup) Draw(buf *tui.ViewBuffer) {
+func (g *SeperatorLayout) Draw(buf *tui.ViewBuffer) {
 	g.ViewTmpl.Draw(buf)
 
 	if g.Orientation == tui.Horizontal {
@@ -97,15 +97,22 @@ func (g *SeperatorGroup) Draw(buf *tui.ViewBuffer) {
 
 }
 
-func (g *SeperatorGroup) Layout() (prefWidth, prefHeight int) {
+func (g *SeperatorLayout) Layout() (prefWidth, prefHeight int) {
 	return -1, -1
 }
 
-func (g *SeperatorGroup) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+func (g *SeperatorLayout) OnKeyPressed(event *tui.KeyEvent) (consumed bool) {
+	if g.KeyPressed != nil {
+		return g.KeyPressed(event)
+	}
+
 	for _, view := range g.Views() {
 		if view.OnKeyPressed(event) {
 			return true
 		}
 	}
+
 	return false
 }
+
+// TODO OnMouseEvent

layouts/utils.go

@@ -0,0 +1,73 @@
+package layouts
+
+import (
+	"math"
+
+	"git.milar.in/milarin/gmath"
+	"git.milar.in/milarin/tui"
+)
+
+func iff[T any](condition bool, trueValue, falseValue T) T {
+	if condition {
+		return trueValue
+	}
+	return falseValue
+}
+
+type LayoutResult struct {
+	Sizes map[tui.View]tui.Size
+
+	Sum  tui.Size
+	Min  tui.Size
+	Max  tui.Size
+	Pref tui.Size
+
+	Count int
+
+	VerticalNegativeCount   int
+	HorizontalNegativeCount int
+}
+
+func CalculateLayoutResult(views []tui.View) *LayoutResult {
+	result := &LayoutResult{
+		Sizes: map[tui.View]tui.Size{},
+
+		Sum: tui.Size{Width: 0, Height: 0},
+		Min: tui.Size{Width: math.MaxInt, Height: math.MaxInt},
+		Max: tui.Size{Width: -1, Height: -1},
+
+		Count: 0,
+
+		VerticalNegativeCount:   0,
+		HorizontalNegativeCount: 0,
+	}
+
+	for _, view := range views {
+		if view == nil {
+			continue
+		}
+
+		result.Count++
+
+		width, height := view.Layout()
+		result.Sizes[view] = tui.Size{Width: width, Height: height}
+
+		if width > 0 {
+			result.Sum.Width += width
+			result.Min.Width = gmath.Min(result.Min.Width, width)
+			result.Max.Width = gmath.Max(result.Max.Width, width)
+		} else if width < 0 {
+			result.HorizontalNegativeCount++
+		}
+
+		if height > 0 {
+			result.Sum.Height += height
+			result.Min.Height = gmath.Min(result.Min.Height, height)
+			result.Max.Height = gmath.Max(result.Max.Height, height)
+		} else if height < 0 {
+			result.VerticalNegativeCount++
+		}
+	}
+
+	return result
+}

modals/modal_info.go

@@ -0,0 +1,29 @@
+package modals
+
+import (
+	"git.milar.in/milarin/tui/views"
+)
+
+type InfoModal struct {
+	*views.FrameView
+}
+
+func NewInfoModal(message string) *InfoModal {
+	tv := views.NewTextView(message)
+	bv := views.NewBorderView(views.NewMarginView(tv, 0, 1, 0, 1))
+	fv := views.NewFrameView(bv)
+	fv.DontClearBuffer = true
+
+	m := &InfoModal{
+		FrameView: fv,
+	}
+
+	// m.KeyPressed = func(event *tui.KeyEvent) (consumed bool) {
+	// 	// if event.Key() == tcell.KeyEnter || event.Key() == tcell.KeyESC {
+
+	// 	// }
+	// 	return true
+	// }
+
+	return m
+}

screen.go

@@ -1,21 +1,35 @@
 package tui
 
 import (
-	"errors"
 	"fmt"
 
-	"git.tordarus.net/Tordarus/buf2d"
+	"git.milar.in/milarin/adverr"
+	"git.milar.in/milarin/buf2d"
+	"git.milar.in/milarin/ds"
 	"github.com/gdamore/tcell"
 )
 
 type Screen struct {
-	scr    tcell.Screen
-	buf    *ViewBuffer
-	stopCh chan error
-	Root   View
+	EventTmpl
 
-	// KeyPressed is called every time a key or key-combination is pressed.
-	KeyPressed func(event *KeyEvent) (consumed bool)
+	scr tcell.Screen
+	buf *ViewBuffer
+
+	stopCh   chan error
+	redrawCh chan struct{}
+	started  bool
+
+	modals ds.Stack[View]
+
+	// Root is the root view which is currently shown on screen
+	Root View
+
+	// Some unicode characters need more bytes than one. For these characters,
+	// an additional last column will be provided in the internal view buffer.
+	// That way, these characters can also be shown on the right most column.
+	//
+	// You should enable this flag if you have missing unicode characters in the last column.
+	UnicodeSupport bool
 }
 
 func NewScreen(root View) (*Screen, error) {
@@ -25,38 +39,33 @@ func NewScreen(root View) (*Screen, error) {
 	}
 
 	s := &Screen{
-		Root:   root,
-		scr:    scr,
-		stopCh: make(chan error, 1),
+		Root:     root,
+		scr:      scr,
+		stopCh:   make(chan error, 1),
+		redrawCh: make(chan struct{}, 1),
+		modals:   ds.NewArrayStack[View](),
 	}
 
-	go s.eventloop()
+	s.KeyPressed = CloseOnCtrlC(s)
 
 	return s, nil
 }
 
-func (s *Screen) eventloop() {
-	for evt := s.scr.PollEvent(); evt != nil; evt = s.scr.PollEvent() {
-		switch event := evt.(type) {
-		case *tcell.EventResize:
-			go s.Redraw()
-		case *tcell.EventKey:
-			go s.onKeyPressed(event)
-		default:
-			s.StopWithError(errors.New(fmt.Sprintf("%#v", event)))
-		}
-	}
-	s.StopWithError(errors.New("unknown error occured"))
-}
-
 func (s *Screen) Start() error {
 	err := s.scr.Init()
 	if err != nil {
 		return err
 	}
-	defer s.scr.Fini()
 
-	s.Redraw()
+	defer s.scr.Fini()
+	defer close(s.redrawCh)
+
+	s.scr.EnableMouse()
+
+	go s.eventloop()
+	go s.drawloop()
+
+	s.started = true
 	return <-s.stopCh
 }
 
@@ -69,20 +78,129 @@ func (s *Screen) StopWithError(err error) {
 }
 
 func (s *Screen) onKeyPressed(event *KeyEvent) {
+	if !s.modals.Empty() {
+		s.modals.Peek().OnKeyPressed(event)
+		return
+	}
+
 	if s.KeyPressed == nil || !s.KeyPressed(event) {
 		s.Root.OnKeyPressed(event)
 	}
 	s.Redraw()
 }
 
-func (s *Screen) Redraw() {
-	w, h := s.scr.Size()
-
-	if s.buf == nil || s.buf.Width() != w || s.buf.Height() != h {
-		s.buf = buf2d.NewBuffer(w, h, DefaultRune)
+func (s *Screen) onMouseEvent(event *MouseEvent) {
+	if event.Button != MouseButtonNone {
+		defer s.Redraw()
 	}
 
-	rw, rh := s.Root.Layout()
-	s.Root.Draw(truncateBuffer(s.buf, rw, rh))
-	drawBuffer(s.scr, s.buf)
+	if !s.modals.Empty() {
+		s.modals.Peek().OnMouseEvent(event)
+		return
+	}
+
+	if s.MouseEvent != nil && s.MouseEvent(event) {
+		return
+	}
+
+	s.Root.OnMouseEvent(event)
+}
+
+func convertMouseEvent(original *tcell.EventMouse) *MouseEvent {
+	x, y := original.Position()
+	return &MouseEvent{
+		Position:  P(x, y),
+		Button:    convertMouseButton(original.Buttons()),
+		Modifiers: original.Modifiers(),
+	}
+}
+
+func (s *Screen) Redraw() {
+	if s.started {
+		s.redrawCh <- struct{}{}
+	}
+}
+
+func (s *Screen) eventloop() {
+	defer s.handlePanic("panicked while handling event")
+
+	for evt := s.scr.PollEvent(); evt != nil; evt = s.scr.PollEvent() {
+		switch event := evt.(type) {
+		case *tcell.EventResize:
+			s.Redraw()
+		case *tcell.EventKey:
+			s.startPanicSafeThread("panicked while handling key event", func() { s.onKeyPressed(event) })
+		case *tcell.EventMouse:
+			s.startPanicSafeThread("panicked while handling mouse event", func() { s.onMouseEvent(convertMouseEvent(event)) })
+		default:
+			s.StopWithError(fmt.Errorf("%#v", event))
+		}
+	}
+}
+
+func (s *Screen) startPanicSafeThread(errorMessage string, f func()) {
+	go func() {
+		defer s.handlePanic(errorMessage)
+		f()
+	}()
+}
+
+func (s *Screen) drawloop() {
+	defer s.handlePanic("panicked while redrawing")
+
+	for range s.redrawCh {
+		s.prepareViewBuffer()
+
+		// draw root view
+		rw, rh := s.Root.Layout()
+		s.Root.Draw(truncateBuffer(s.buf, rw, rh))
+
+		// draw modals
+		for i := 0; i < s.modals.Size(); i++ {
+			v := s.modals.PeekAt(i)
+			mw, mh := v.Layout()
+			v.Draw(s.buf.Sub(0, 0, iff(mw >= 0, mw, s.buf.Width()), iff(mh >= 0, mh, s.buf.Height())))
+		}
+
+		// draw buffer onto screen
+		drawBuffer(s.scr, s.buf)
+	}
+}
+
+func (s *Screen) prepareViewBuffer() {
+	w, h := s.scr.Size()
+
+	if s.UnicodeSupport {
+		if s.buf == nil || s.buf.Width() != w-1 || s.buf.Height() != h {
+			s.buf = buf2d.NewBuffer(w, h, DefaultRune).Sub(0, 0, w-1, h)
+		} else {
+			s.buf.Fill(DefaultRune)
+		}
+	} else {
+		if s.buf == nil || s.buf.Width() != w || s.buf.Height() != h {
+			s.buf = buf2d.NewBuffer(w, h, DefaultRune)
+		} else {
+			s.buf.Fill(DefaultRune)
+		}
+	}
+}
+
+func (s *Screen) handlePanic(msg string) {
+	if err := recover(); err != nil {
+		if e, ok := err.(error); ok {
+			s.StopWithError(adverr.Wrap(msg, e))
+		} else {
+			s.StopWithError(adverr.Wrap(msg, fmt.Errorf("%v", err)))
+		}
+	}
+}
+
+func (s *Screen) OpenModal(v View) {
+	s.modals.Push(v)
+	s.Redraw()
+}
+
+func (s *Screen) CloseModal() {
+	s.modals.Pop()
+	s.Redraw()
 }

tests/screen_test.go

@@ -3,59 +3,181 @@ package tui
 import (
 	"errors"
 	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"strconv"
 	"testing"
+	"time"
 
-	"git.tordarus.net/Tordarus/tui"
-	"git.tordarus.net/Tordarus/tui/views"
+	"git.milar.in/milarin/tui"
+	"git.milar.in/milarin/tui/layouts"
+	"git.milar.in/milarin/tui/modals"
+	"git.milar.in/milarin/tui/views"
 	"github.com/gdamore/tcell"
 )
 
-func TestFlowGroup(t *testing.T) {
-	textView := views.NewTextView("hello world!")
-	textView.SetStyle(tui.StyleDefault.Background(tcell.ColorRed).Foreground(tcell.ColorBlack))
+var logger *log.Logger
 
-	marginView := views.NewMarginView(textView)
-	marginView.SetMargin(3, 1, 1, 0)
+func initDebugLogger() func() {
+	out, err := os.Create("output.log")
+	if err != nil {
+		panic(err)
+	}
+	logger = log.New(out, "", log.LstdFlags|log.Lmicroseconds)
 
-	//borderView := views.NewBorderView(textView)
+	return func() {
+		out.Close()
+	}
+}
 
-	textView2 := views.NewTextView("Hi!")
-	textView2.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue).Foreground(tcell.ColorYellow))
+func TestScrollView(t *testing.T) {
+	//defer initDebugLogger()()
 
-	growView := views.NewGrowView()
-	growView.SetStyle(tui.StyleDefault.Background(tcell.ColorGreen))
+	textViews := make([]tui.View, 0, 50)
 
-	growView2 := views.NewGrowView()
-	growView2.SetStyle(tui.StyleDefault.Background(tcell.ColorYellow))
+	for i := 0; i < cap(textViews); i++ {
+		textViews = append(textViews, views.NewTextView(strconv.Itoa(i)))
+		textViews[i].SetStyle(textViews[i].Style().Foreground(tcell.ColorBlack).Background(tcell.Color(rand.Intn(int(tcell.ColorYellowGreen)))))
+	}
 
-	flowGroup := views.NewFlowGroup(tui.Vertical)
-	flowGroup.AppendViews(marginView, growView, textView2)
+	flowLayout := layouts.NewFlowLayout(tui.Vertical)
+	flowLayout.AppendViews(textViews...)
 
-	constrainView := views.NewConstrainView(flowGroup)
-	constrainView.SetStyle(tui.StyleDefault.Background(tcell.ColorPurple))
-	constrainView.Constrain(-1, -1)
+	scrollView := views.NewScrollView(flowLayout)
 
-	screen, err := tui.NewScreen(constrainView)
+	screen, err := tui.NewScreen(scrollView)
 	if err != nil {
 		t.Error(err)
 		return
 	}
 
 	screen.KeyPressed = func(event *tui.KeyEvent) (consumed bool) {
-		textView.Text = event.When().String()
-
-		if event.Key() == tcell.KeyCtrlC {
+		switch event.Key() {
+		case tcell.KeyCtrlC:
 			screen.StopWithError(errors.New(fmt.Sprintf("key: %#v | rune: %s", event.Key(), string(event.Rune()))))
+		case tcell.KeyPgDn:
+			scrollView.Scroll(10, 0)
+		case tcell.KeyPgUp:
+			scrollView.Scroll(-10, 0)
+		}
+		return true
+	}
+
+	screen.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		//textViews[0].(*views.TextView).Text = fmt.Sprintf("mouse position: %d | %d", event.X, event.Y)
+		//textViews[1].(*views.TextView).Text = fmt.Sprintf("mouse button: %d", event.Button)
+
+		if event.Button == tui.MouseWheelUp {
+			scrollView.Scroll(-1, 0)
+			return true
+		} else if event.Button == tui.MouseWheelDown {
+			scrollView.Scroll(1, 0)
+			return true
+		} else if event.Button == tui.MouseButtonMiddle {
+			panic("hi")
 		}
 
-		return true
+		return false
 	}
 
 	err = screen.Start()
 	fmt.Println(err)
 }
 
-func TestSeparatorGroup(t *testing.T) {
+func TestBorderView(t *testing.T) {
+	textView := views.NewTextView("hello world! こんにちは！")
+	borderView := views.NewBorderView(textView)
+	//borderView2 := views.NewBorderView(borderView)
+
+	screen, err := tui.NewScreen(views.NewGrowView(borderView))
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if err := screen.Start(); err != nil {
+		fmt.Println(err)
+	}
+}
+
+func TestGrowView(t *testing.T) {
+	textView := views.NewTextView("hello world")
+	textView.SetStyle(textView.Style().Background(tcell.ColorYellow).Foreground(tcell.ColorBlack))
+	growView := views.NewGrowView(textView)
+
+	screen, err := tui.NewScreen(growView)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if err := screen.Start(); err != nil {
+		fmt.Println(err)
+	}
+}
+
+func TestMousePosition(t *testing.T) {
+	textView := views.NewTextView("hello world")
+
+	screen, err := tui.NewScreen(textView)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	screen.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		textView.Text = fmt.Sprintf("position: %s", event.Position.String())
+		return true
+	}
+
+	modal := modals.NewInfoModal("Programm wird geschlossen")
+	screen.OpenModal(modal)
+
+	go func() {
+		time.Sleep(3 * time.Second)
+		screen.Stop()
+	}()
+
+	if err := screen.Start(); err != nil {
+		fmt.Println(err)
+	}
+}
+
+func TestFlowLayout(t *testing.T) {
+	textView := views.NewTextView("hello world!")
+	textView.SetStyle(tui.StyleDefault.Background(tcell.ColorRed).Foreground(tcell.ColorBlack))
+
+	textView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		textView.Text = "hi"
+		return true
+	}
+
+	//borderView := views.NewBorderView(textView)
+
+	textView2 := views.NewTextView("Hi!")
+	textView2.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue).Foreground(tcell.ColorYellow))
+
+	growView := views.NewGrowView(nil)
+	growView.SetStyle(tui.StyleDefault.Background(tcell.ColorGreen))
+
+	growView2 := views.NewGrowView(nil)
+	growView2.SetStyle(tui.StyleDefault.Background(tcell.ColorYellow))
+
+	flowLayout := layouts.NewFlowLayout(tui.Vertical)
+	flowLayout.AppendViews(textView, growView, textView2)
+
+	screen, err := tui.NewScreen(flowLayout)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	err = screen.Start()
+	fmt.Println(err)
+}
+
+func TestSeparatorLayout(t *testing.T) {
 	textView := views.NewTextView("hello world!")
 	textView.SetStyle(tui.StyleDefault.Background(tcell.ColorRed).Foreground(tcell.ColorBlack))
 
@@ -64,18 +186,18 @@ func TestSeparatorGroup(t *testing.T) {
 	textView2 := views.NewTextView("Hi!")
 	textView2.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue).Foreground(tcell.ColorYellow))
 
-	growView := views.NewGrowView()
+	growView := views.NewGrowView(nil)
 	growView.SetStyle(tui.StyleDefault.Background(tcell.ColorGreen))
 
-	growView2 := views.NewGrowView()
+	growView2 := views.NewGrowView(nil)
 	growView2.SetStyle(tui.StyleDefault.Background(tcell.ColorYellow))
 
-	separatorGroup := views.NewSeparatorGroup(tui.Vertical)
-	separatorGroup.AppendView(frameView, 1)
-	separatorGroup.AppendView(growView, 1)
-	separatorGroup.AppendView(textView2, 1)
+	separatorLayout := layouts.NewSeparatorLayout(tui.Vertical)
+	separatorLayout.AppendView(frameView, 1)
+	separatorLayout.AppendView(growView, 1)
+	separatorLayout.AppendView(textView2, 1)
 
-	screen, err := tui.NewScreen(separatorGroup)
+	screen, err := tui.NewScreen(separatorLayout)
 	if err != nil {
 		t.Error(err)
 		return
@@ -95,48 +217,74 @@ func TestSeparatorGroup(t *testing.T) {
 	fmt.Println(err)
 }
 
-func TestBorderGroup(t *testing.T) {
-	topView := views.NewConstrainView(nil)
+func TestBorderLayout(t *testing.T) {
+	textView := views.NewTextView("")
+	textView.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue))
+	textView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		if event.Button == tui.MouseButtonLeft {
+			textView.SetStyle(tui.StyleDefault.Background(tcell.ColorRed))
+			return true
+		}
+		return false
+	}
+
+	topView := views.NewConstrainView(textView, -1, -1)
 	topView.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue))
-	topView.Constrain(10, 10)
 
-	bottomView := views.NewConstrainView(nil)
+	bottomView := views.NewConstrainView(nil, 10, 10)
 	bottomView.SetStyle(tui.StyleDefault.Background(tcell.ColorRed))
-	bottomView.Constrain(10, 10)
+	bottomView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		if event.Button == tui.MouseButtonLeft {
+			bottomView.SetStyle(tui.StyleDefault.Background(tcell.ColorBlue))
+			return true
+		}
+		return false
+	}
 
-	leftView := views.NewConstrainView(nil)
+	leftView := views.NewConstrainView(nil, 10, 10)
 	leftView.SetStyle(tui.StyleDefault.Background(tcell.ColorYellow))
-	leftView.Constrain(10, 10)
+	leftView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		if event.Button == tui.MouseButtonLeft {
+			leftView.SetStyle(tui.StyleDefault.Background(tcell.ColorGreen))
+			return true
+		}
+		return false
+	}
 
-	rightView := views.NewConstrainView(nil)
+	rightView := views.NewConstrainView(nil, 10, 10)
 	rightView.SetStyle(tui.StyleDefault.Background(tcell.ColorGreen))
-	rightView.Constrain(10, 10)
+	rightView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		if event.Button == tui.MouseButtonLeft {
+			rightView.SetStyle(tui.StyleDefault.Background(tcell.ColorYellow))
+			return true
+		}
+		return false
+	}
 
-	centerView := views.NewConstrainView(nil)
+	centerView := views.NewConstrainView(nil, 10, 10)
 	centerView.SetStyle(tui.StyleDefault.Background(tcell.ColorPurple))
-	centerView.Constrain(10, 10)
+	centerView.MouseEvent = func(event *tui.MouseEvent) (consumed bool) {
+		if event.Button == tui.MouseButtonLeft {
+			centerView.SetStyle(tui.StyleDefault.Background(tcell.ColorOrange))
+			return true
+		}
+		return false
+	}
 
-	borderGroup := views.NewBorderGroup()
-	borderGroup.SetStyle(tui.StyleDefault.Background(tcell.ColorPurple))
-	borderGroup.SetView(topView, views.Top)
-	borderGroup.SetView(bottomView, views.Bottom)
-	borderGroup.SetView(leftView, views.Left)
-	borderGroup.SetView(rightView, views.Right)
-	borderGroup.SetView(centerView, views.Center)
+	borderLayout := layouts.NewBorderLayout()
+	borderLayout.SetStyle(tui.StyleDefault.Background(tcell.ColorPurple))
+	borderLayout.SetView(topView, layouts.Top)
+	borderLayout.SetView(bottomView, layouts.Bottom)
+	borderLayout.SetView(leftView, layouts.Left)
+	borderLayout.SetView(rightView, layouts.Right)
+	borderLayout.SetView(centerView, layouts.Center)
 
-	screen, err := tui.NewScreen(borderGroup)
+	screen, err := tui.NewScreen(borderLayout)
 	if err != nil {
 		t.Error(err)
 		return
 	}
 
-	screen.KeyPressed = func(event *tui.KeyEvent) (consumed bool) {
-		if event.Key() == tcell.KeyCtrlC {
-			screen.StopWithError(errors.New(fmt.Sprintf("key: %#v | rune: %s", event.Key(), string(event.Rune()))))
-		}
-		return true
-	}
-
 	err = screen.Start()
 	fmt.Println(err)
 }

tmpl_modal.go

@@ -0,0 +1,21 @@
+package tui
+
+type ModalTmpl[T any] struct {
+	WrapperTmpl
+
+	resultCh chan T
+	screen   *Screen
+}
+
+var _ Modal[int] = &ModalTmpl[int]{}
+
+func (m *ModalTmpl[T]) Open(s *Screen) <-chan T {
+	m.resultCh = make(chan T)
+	m.screen = s
+	return m.resultCh
+}
+
+func (m *ModalTmpl[T]) Close(result T) {
+	m.resultCh <- result
+	m.screen.CloseModal() // TODO which modal
+}

tmpl_view.go

@@ -1,6 +1,7 @@
 package tui
 
 type ViewTmpl struct {
+	EventTmpl
 	style *Style
 }
 
@@ -14,10 +15,6 @@ func (v *ViewTmpl) Layout() (prefWidth, prefHeight int) {
 	return -1, -1
 }
 
-func (v *ViewTmpl) OnKeyPressed(event *KeyEvent) (consumed bool) {
-	return false
-}
-
 func (v *ViewTmpl) SetStyle(s Style) {
 	v.style = &s
 }

tmpl_wrapper.go

@@ -29,18 +29,18 @@ func (v *WrapperTmpl) OnKeyPressed(event *KeyEvent) (consumed bool) {
 	return v.ViewTmpl.OnKeyPressed(event)
 }
 
-func (v *WrapperTmpl) SetStyle(s Style) {
+func (v *WrapperTmpl) OnMouseEvent(event *MouseEvent) (consumed bool) {
 	if v.view != nil {
-		v.view.SetStyle(s)
-		return
+		return v.view.OnMouseEvent(event)
 	}
+	return v.ViewTmpl.OnMouseEvent(event)
+}
+
+func (v *WrapperTmpl) SetStyle(s Style) {
 	v.ViewTmpl.SetStyle(s)
 }
 
 func (v *WrapperTmpl) Style() Style {
-	if v.view != nil {
-		return v.view.Style()
-	}
 	return v.ViewTmpl.Style()
 }
 

types.go

@@ -1,7 +1,9 @@
 package tui
 
 import (
-	"git.tordarus.net/Tordarus/buf2d"
+	"fmt"
+
+	"git.milar.in/milarin/buf2d"
 	"github.com/gdamore/tcell"
 )
 
@@ -16,15 +18,43 @@ type Point struct {
 	X, Y int
 }
 
+func P(x, y int) Point {
+	return Point{x, y}
+}
+
+func (p Point) In(d Dimension) bool {
+	return p.X >= d.X && p.X < d.X+d.Width && p.Y >= d.Y && p.Y < d.Y+d.Height
+}
+
+func (p Point) String() string {
+	return fmt.Sprintf("P(%d, %d)", p.X, p.Y)
+}
+
 type Size struct {
 	Width, Height int
 }
 
+func S(w, h int) Size {
+	return Size{w, h}
+}
+
+func (s Size) String() string {
+	return fmt.Sprintf("S(%d, %d)", s.Width, s.Height)
+}
+
 type Dimension struct {
 	Point
 	Size
 }
 
+func D(x, y, w, h int) Dimension {
+	return Dimension{P(x, y), S(w, h)}
+}
+
+func (d Dimension) String() string {
+	return fmt.Sprintf("D(%d, %d, %d, %d)", d.X, d.Y, d.Width, d.Height)
+}
+
 type Orientation uint8
 
 const (
@@ -41,6 +71,16 @@ const (
 	SideRight
 )
 
+// Horizontal returns true if s is either SideLeft or SideRight
+func (s Side) Horizontal() bool {
+	return s == SideLeft || s == SideRight
+}
+
+// Vertical returns true if s is either SideTop or SideBottom
+func (s Side) Vertical() bool {
+	return s == SideTop || s == SideBottom
+}
+
 type Anchor uint8
 
 const (
@@ -54,3 +94,49 @@ const (
 	AnchorBottom
 	AnchorBottomRight
 )
+
+type MouseEvent struct {
+	Position  Point
+	Button    MouseButton
+	Modifiers tcell.ModMask
+}
+
+type MouseButton uint8
+
+const (
+	MouseButtonNone MouseButton = iota
+	MouseButtonLeft
+	MouseButtonMiddle
+	MouseButtonRight
+	MouseButtonNext
+	MouseButtonPrev
+
+	MouseWheelUp
+	MouseWheelDown
+	MouseWheelLeft
+	MouseWheelRight
+)
+
+func convertMouseButton(mask tcell.ButtonMask) MouseButton {
+	if mask&tcell.Button1 == tcell.Button1 {
+		return MouseButtonLeft
+	} else if mask&tcell.Button2 == tcell.Button2 {
+		return MouseButtonMiddle
+	} else if mask&tcell.Button3 == tcell.Button3 {
+		return MouseButtonRight
+	} else if mask&tcell.Button4 == tcell.Button4 {
+		return MouseButtonNext
+	} else if mask&tcell.Button5 == tcell.Button5 {
+		return MouseButtonPrev
+	} else if mask&tcell.WheelUp == tcell.WheelUp {
+		return MouseWheelUp
+	} else if mask&tcell.WheelDown == tcell.WheelDown {
+		return MouseWheelDown
+	} else if mask&tcell.WheelLeft == tcell.WheelLeft {
+		return MouseWheelLeft
+	} else if mask&tcell.WheelRight == tcell.WheelRight {
+		return MouseWheelRight
+	}
+
+	return MouseButtonNone
+}

utils.go

@@ -3,7 +3,9 @@ package tui
 import (
 	"strings"
 
-	"golang.org/x/text/width"
+	"git.milar.in/milarin/gmath"
+	"github.com/gdamore/tcell"
+	"github.com/mattn/go-runewidth"
 )
 
 // WriteString writes a whole string to the buffer at position (x,y)
@@ -31,7 +33,7 @@ func WriteMultiLineString(b *ViewBuffer, str string, style Style, x, y int) (max
 			return
 		}
 		lineWidth := WriteString(b, line, style, x, y+dy)
-		maxLineWidth = max(maxLineWidth, lineWidth)
+		maxLineWidth = gmath.Max(maxLineWidth, lineWidth)
 	}
 	return maxLineWidth, len(lines)
 }
@@ -50,35 +52,22 @@ func MeasureMultiLineString(str string) (maxLineWidth, lineCount int) {
 	lines := strings.Split(str, "\n")
 	for _, line := range lines {
 		lineWidth := MeasureString(line)
-		maxLineWidth = max(maxLineWidth, lineWidth)
+		maxLineWidth = gmath.Max(maxLineWidth, lineWidth)
 	}
 	return maxLineWidth, len(lines)
 }
 
 func runeWidth(r rune) int {
+	return runewidth.RuneWidth(r)
 	//fmt.Println(r, width.LookupRune(r).Kind())
-	switch width.LookupRune(r).Kind() {
-	case width.EastAsianFullwidth:
-		fallthrough
-	case width.EastAsianWide:
-		return 2
-	default:
-		return 1
-	}
-}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
+	// switch width.LookupRune(r).Kind() {
+	// case width.EastAsianFullwidth:
+	// 	fallthrough
+	// case width.EastAsianWide:
+	// 	return 2
+	// default:
+	// 	return 1
+	// }
 }
 
 func iff[T any](condition bool, trueValue, falseValue T) T {
@@ -112,3 +101,26 @@ func ConstrainBufferToAnchor(buf *ViewBuffer, anchor Anchor, width, height int)
 		return buf.Sub(buf.Width()-width, buf.Height()-height, width, height)
 	}
 }
+
+// CloseOnCtrlC returns a KeyPress handler which closes the screen when Ctrl-C is pressed.
+// This is the default behavior for all new screens.
+// CloseOnCtrlC is a shorthand for CloseOnKeyPressed(screen, tcell.KeyCtrlC)
+func CloseOnCtrlC(screen *Screen) func(event *KeyEvent) (consumed bool) {
+	return CloseOnKeyPressed(screen, tcell.KeyCtrlC)
+}
+
+// CloseOnKeyPressed returns a KeyPress handler which closes the screen when the given key is pressed.
+func CloseOnKeyPressed(screen *Screen, key tcell.Key) func(event *KeyEvent) (consumed bool) {
+	return func(event *KeyEvent) (consumed bool) {
+		if event.Key() == key {
+			screen.Stop()
+			return true
+		}
+
+		if screen.Root != nil {
+			return screen.Root.OnKeyPressed(event)
+		}
+
+		return false
+	}
+}

view.go

@@ -21,20 +21,30 @@ type View interface {
 	Draw(buf *ViewBuffer)
 }
 
-// Group defines the behavior of a View which can hold multiple sub views
-type Group interface {
+// Layout defines the behavior of a View which can hold multiple sub views
+type Layout interface {
 	View
 
 	Views() []View
 }
 
-// Wrapper defines the behavior of a GroupView which can hold exactly one sub view.
+// Wrapper defines the behavior of a Layout which can hold exactly one sub view.
 // To define custom Wrappers, it is recommended to add WrapperTmpl
 // as the promoted anonymous field for your custom Wrapper struct.
 // It implements the Wrapper interface with useful default behavior
 type Wrapper interface {
-	Group
+	Layout
 
 	SetView(View)
 	View() View
 }
+
+// Modal defines the behavior of a Wrapper which captures
+// all screen space and all events when opened and can return results.
+// It can be used to make dialogs, alert boxes and context menus
+type Modal[T any] interface {
+	Wrapper
+
+	Open(s *Screen) <-chan T
+	Close(result T)
+}

views/borderview.go

@@ -1,93 +0,0 @@
-package views
-
-import "git.tordarus.net/Tordarus/tui"
-
-// BorderView is a tui.Wrapper which draws an ASCII border around its view.
-// Be aware that box drawing characters must share the same tui.Style with the next character.
-// This can lead to color artifacts when using BorderView with colored styles.
-type BorderView struct {
-	tui.WrapperTmpl
-	Border BorderBox
-}
-
-var _ tui.View = &BorderView{}
-
-func NewBorderView(view tui.View) *BorderView {
-	v := new(BorderView)
-	v.SetView(view)
-	v.Border = ThinBorder()
-	return v
-}
-
-func (g *BorderView) Draw(buf *tui.ViewBuffer) {
-	g.View().Draw(buf.Sub(1, 1, buf.Width()-2, buf.Height()-2))
-
-	buf.Set(0, 0, tui.Rune{Rn: g.Border.TopLeft, Style: g.Style()})
-	buf.Set(buf.Width()-1, 0, tui.Rune{Rn: g.Border.TopRight, Style: g.Style()})
-
-	buf.Set(0, buf.Height()-1, tui.Rune{Rn: g.Border.BottomLeft, Style: g.Style()})
-	buf.Set(buf.Width()-1, buf.Height()-1, tui.Rune{Rn: g.Border.BottomRight, Style: g.Style()})
-
-	for x := 1; x < buf.Width()-1; x++ {
-		buf.Set(x, 0, tui.Rune{Rn: g.Border.Horizontal, Style: g.Style()})
-		buf.Set(x, buf.Height()-1, tui.Rune{Rn: g.Border.Horizontal, Style: g.Style()})
-	}
-
-	for y := 1; y < buf.Height()-1; y++ {
-		buf.Set(0, y, tui.Rune{Rn: g.Border.Vertical, Style: g.Style()})
-		buf.Set(buf.Width()-1, y, tui.Rune{Rn: g.Border.Vertical, Style: g.Style()})
-	}
-}
-
-func (v *BorderView) Layout() (prefWidth, prefHeight int) {
-	w, h := v.View().Layout()
-	w = iff(w > 0, w+2, w)
-	h = iff(h > 0, h+2, h)
-	return w, h
-}
-
-func (v *BorderView) Style() tui.Style {
-	return v.ViewTmpl.Style()
-}
-
-type BorderBox struct {
-	TopLeft     rune
-	TopRight    rune
-	BottomLeft  rune
-	BottomRight rune
-	Horizontal  rune
-	Vertical    rune
-}
-
-func ThickBorder() BorderBox {
-	return BorderBox{
-		TopLeft:     '┏',
-		TopRight:    '┓',
-		BottomLeft:  '┗',
-		BottomRight: '┛',
-		Horizontal:  '━',
-		Vertical:    '┃',
-	}
-}
-
-func ThinBorder() BorderBox {
-	return BorderBox{
-		TopLeft:     '┌',
-		TopRight:    '┐',
-		BottomLeft:  '└',
-		BottomRight: '┘',
-		Horizontal:  '─',
-		Vertical:    '│',
-	}
-}
-
-func DoubleBorder() BorderBox {
-	return BorderBox{
-		TopLeft:     '╔',
-		TopRight:    '╗',
-		BottomLeft:  '╚',
-		BottomRight: '╝',
-		Horizontal:  '═',
-		Vertical:    '║',
-	}
-}

views/constrainview.go

@@ -1,29 +0,0 @@
-package views
-
-import (
-	"git.tordarus.net/Tordarus/tui"
-)
-
-// ConstrainView is a tui.Wrapper which constrains the dimensions of its View
-type ConstrainView struct {
-	tui.WrapperTmpl
-	MaxWidth  int
-	MaxHeight int
-}
-
-var _ tui.View = &ConstrainView{}
-
-func NewConstrainView(view tui.View) *ConstrainView {
-	v := new(ConstrainView)
-	v.SetView(view)
-	v.Constrain(-1, -1)
-	return v
-}
-
-func (v *ConstrainView) Constrain(maxWidth, maxHeight int) {
-	v.MaxWidth, v.MaxHeight = maxWidth, maxHeight
-}
-
-func (v *ConstrainView) Layout() (prefWidth, prefHeight int) {
-	return v.MaxWidth, v.MaxHeight
-}

views/growview.go

@@ -1,20 +0,0 @@
-package views
-
-import (
-	"git.tordarus.net/Tordarus/tui"
-)
-
-// GrowView is a tui.View which always demands all available space
-type GrowView struct {
-	tui.ViewTmpl
-}
-
-var _ tui.View = &GrowView{}
-
-func NewGrowView() *GrowView {
-	return &GrowView{}
-}
-
-func (v *GrowView) Layout() (prefWidth, prefHeight int) {
-	return -1, -1
-}

views/utils.go

@@ -1,86 +1,8 @@
 package views
 
-import (
-	"math"
-
-	"git.tordarus.net/Tordarus/tui"
-)
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
 func iff[T any](condition bool, trueValue, falseValue T) T {
 	if condition {
 		return trueValue
 	}
 	return falseValue
 }
-
-type LayoutResult struct {
-	Sizes map[tui.View]tui.Size
-
-	Sum  tui.Size
-	Min  tui.Size
-	Max  tui.Size
-	Pref tui.Size
-
-	Count int
-
-	VerticalNegativeCount   int
-	HorizontalNegativeCount int
-}
-
-func CalculateLayoutResult(views []tui.View) *LayoutResult {
-	result := &LayoutResult{
-		Sizes: map[tui.View]tui.Size{},
-
-		Sum: tui.Size{Width: 0, Height: 0},
-		Min: tui.Size{Width: math.MaxInt, Height: math.MaxInt},
-		Max: tui.Size{Width: -1, Height: -1},
-
-		Count: 0,
-
-		VerticalNegativeCount:   0,
-		HorizontalNegativeCount: 0,
-	}
-
-	for _, view := range views {
-		if view == nil {
-			continue
-		}
-
-		result.Count++
-
-		width, height := view.Layout()
-		result.Sizes[view] = tui.Size{Width: width, Height: height}
-
-		if width > 0 {
-			result.Sum.Width += width
-			result.Min.Width = min(result.Min.Width, width)
-			result.Max.Width = max(result.Max.Width, width)
-		} else if width < 0 {
-			result.HorizontalNegativeCount++
-		}
-
-		if height > 0 {
-			result.Sum.Height += height
-			result.Min.Height = min(result.Min.Height, height)
-			result.Max.Height = max(result.Max.Height, height)
-		} else if height < 0 {
-			result.VerticalNegativeCount++
-		}
-	}
-
-	return result
-}

views/view_border.go

@@ -0,0 +1,155 @@
+package views
+
+import "git.milar.in/milarin/tui"
+
+// BorderView is a tui.Wrapper which draws an ASCII border around its view.
+// Be aware that box drawing characters must share the same tui.Style with the next character.
+// This can lead to color artifacts when using BorderView with colored styles.
+type BorderView struct {
+	tui.WrapperTmpl
+	Border     BorderBox
+	ShowBorder map[tui.Side]bool
+}
+
+var _ tui.Wrapper = &BorderView{}
+
+// NewBorderView create a new BorderView which show borders on the given sides around its view.
+// If no sides are given, all sides will have a border by default
+func NewBorderView(view tui.View, showBorders ...tui.Side) *BorderView {
+	v := new(BorderView)
+	v.SetView(view)
+	v.Border = ThinBorder()
+
+	if len(showBorders) == 0 {
+		v.ShowBorder = map[tui.Side]bool{
+			tui.SideBottom: true,
+			tui.SideTop:    true,
+			tui.SideLeft:   true,
+			tui.SideRight:  true,
+		}
+	} else {
+		v.ShowBorder = map[tui.Side]bool{}
+		for _, border := range showBorders {
+			v.ShowBorder[border] = true
+		}
+	}
+
+	return v
+}
+
+func (g *BorderView) Draw(buf *tui.ViewBuffer) {
+	viewbuf := buf
+
+	// limit view buffer for child view
+	if g.ShowBorder[tui.SideTop] {
+		viewbuf = viewbuf.Sub(0, 1, viewbuf.Width(), viewbuf.Height())
+	}
+	if g.ShowBorder[tui.SideBottom] {
+		viewbuf = viewbuf.Sub(0, 0, viewbuf.Width(), viewbuf.Height()-1)
+	}
+	if g.ShowBorder[tui.SideLeft] {
+		viewbuf = viewbuf.Sub(1, 0, viewbuf.Width(), viewbuf.Height())
+	}
+	if g.ShowBorder[tui.SideRight] {
+		viewbuf = viewbuf.Sub(0, 0, viewbuf.Width()-1, viewbuf.Height())
+	}
+
+	// draw child view
+	g.View().Draw(viewbuf)
+
+	// draw horizontal lines
+	for x := 0; x < buf.Width(); x++ {
+		if g.ShowBorder[tui.SideTop] {
+			buf.Set(x, 0, tui.Rune{Rn: g.Border.Horizontal, Style: g.Style()})
+		}
+		if g.ShowBorder[tui.SideBottom] {
+			buf.Set(x, buf.Height()-1, tui.Rune{Rn: g.Border.Horizontal, Style: g.Style()})
+		}
+	}
+
+	// draw vertical lines
+	for y := 0; y < buf.Height(); y++ {
+		if g.ShowBorder[tui.SideLeft] {
+			buf.Set(0, y, tui.Rune{Rn: g.Border.Vertical, Style: g.Style()})
+		}
+		if g.ShowBorder[tui.SideRight] {
+			buf.Set(buf.Width()-1, y, tui.Rune{Rn: g.Border.Vertical, Style: g.Style()})
+		}
+	}
+
+	// draw corners
+	if g.ShowBorder[tui.SideTop] {
+		if g.ShowBorder[tui.SideLeft] {
+			buf.Set(0, 0, tui.Rune{Rn: g.Border.TopLeft, Style: g.Style()})
+		}
+		if g.ShowBorder[tui.SideRight] {
+			buf.Set(buf.Width()-1, 0, tui.Rune{Rn: g.Border.TopRight, Style: g.Style()})
+		}
+	}
+	if g.ShowBorder[tui.SideBottom] {
+		if g.ShowBorder[tui.SideLeft] {
+			buf.Set(0, buf.Height()-1, tui.Rune{Rn: g.Border.BottomLeft, Style: g.Style()})
+		}
+		if g.ShowBorder[tui.SideRight] {
+			buf.Set(buf.Width()-1, buf.Height()-1, tui.Rune{Rn: g.Border.BottomRight, Style: g.Style()})
+		}
+	}
+}
+
+func (v *BorderView) Layout() (prefWidth, prefHeight int) {
+	w, h := v.View().Layout()
+
+	for side, border := range v.ShowBorder {
+		if border {
+			if side.Horizontal() && w >= 0 {
+				w++
+			} else if side.Vertical() && h >= 0 {
+				h++
+			}
+		}
+	}
+
+	return w, h
+}
+
+type BorderBox struct {
+	TopLeft     rune
+	TopRight    rune
+	BottomLeft  rune
+	BottomRight rune
+	Horizontal  rune
+	Vertical    rune
+}
+
+func ThickBorder() BorderBox {
+	return BorderBox{
+		TopLeft:     '┏',
+		TopRight:    '┓',
+		BottomLeft:  '┗',
+		BottomRight: '┛',
+		Horizontal:  '━',
+		Vertical:    '┃',
+	}
+}
+
+func ThinBorder() BorderBox {
+	return BorderBox{
+		TopLeft:     '┌',
+		TopRight:    '┐',
+		BottomLeft:  '└',
+		BottomRight: '┘',
+		Horizontal:  '─',
+		Vertical:    '│',
+	}
+}
+
+func DoubleBorder() BorderBox {
+	return BorderBox{
+		TopLeft:     '╔',
+		TopRight:    '╗',
+		BottomLeft:  '╚',
+		BottomRight: '╝',
+		Horizontal:  '═',
+		Vertical:    '║',
+	}
+}

views/view_constrain.go

@@ -0,0 +1,37 @@
+package views
+
+import (
+	"git.milar.in/milarin/gmath"
+	"git.milar.in/milarin/tui"
+)
+
+// ConstrainView is a tui.Wrapper which constrains the dimensions of its View
+type ConstrainView struct {
+	tui.WrapperTmpl
+	MaxWidth  int
+	MaxHeight int
+}
+
+var _ tui.Wrapper = &ConstrainView{}
+
+func NewConstrainView(view tui.View, maxWidth, maxHeight int) *ConstrainView {
+	v := new(ConstrainView)
+	v.SetView(view)
+	v.Constrain(maxWidth, maxHeight)
+	return v
+}
+
+func (v *ConstrainView) Constrain(maxWidth, maxHeight int) {
+	v.MaxWidth, v.MaxHeight = maxWidth, maxHeight
+}
+
+func (v *ConstrainView) Layout() (prefWidth, prefHeight int) {
+	if v.View() == nil {
+		return v.MaxWidth, v.MaxHeight
+	}
+
+	vw, vh := v.View().Layout()
+	prefWidth = iff(vw >= 0, gmath.Min(vw, v.MaxWidth), v.MaxWidth)
+	prefHeight = iff(vh >= 0, gmath.Min(vh, v.MaxHeight), v.MaxHeight)
+	return
+}

views/view_frame.go

@@ -1,14 +1,16 @@
 package views
 
-import "git.tordarus.net/Tordarus/tui"
+import "git.milar.in/milarin/tui"
 
 // FrameView is a tui.Wrapper which draws its view preferably with preferred size on its tui.Anchor point
 type FrameView struct {
 	tui.WrapperTmpl
 	Anchor tui.Anchor
+
+	DontClearBuffer bool
 }
 
-var _ tui.View = &FrameView{}
+var _ tui.Wrapper = &FrameView{}
 
 func NewFrameView(view tui.View) *FrameView {
 	v := new(FrameView)
@@ -18,7 +20,9 @@ func NewFrameView(view tui.View) *FrameView {
 }
 
 func (g *FrameView) Draw(buf *tui.ViewBuffer) {
-	g.ViewTmpl.Draw(buf)
+	if !g.DontClearBuffer {
+		g.ViewTmpl.Draw(buf)
+	}
 
 	w, h := g.View().Layout()
 	w = iff(w >= 0, w, buf.Width())
@@ -29,7 +33,3 @@ func (g *FrameView) Draw(buf *tui.ViewBuffer) {
 func (v *FrameView) Layout() (prefWidth, prefHeight int) {
 	return -1, -1
 }
-
-func (v *FrameView) Style() tui.Style {
-	return v.ViewTmpl.Style()
-}

views/view_grow.go

@@ -0,0 +1,22 @@
+package views
+
+import (
+	"git.milar.in/milarin/tui"
+)
+
+// GrowView is a tui.Wrapper which always demands all available space
+type GrowView struct {
+	tui.WrapperTmpl
+}
+
+var _ tui.View = &GrowView{}
+
+func NewGrowView(view tui.View) *GrowView {
+	g := &GrowView{}
+	g.SetView(view)
+	return g
+}
+
+func (v *GrowView) Layout() (prefWidth, prefHeight int) {
+	return -1, -1
+}

views/view_margin.go

@@ -1,6 +1,6 @@
 package views
 
-import "git.tordarus.net/Tordarus/tui"
+import "git.milar.in/milarin/tui"
 
 // MarginView is a tui.Wrapper which applies margin around its view
 type MarginView struct {
@@ -8,12 +8,12 @@ type MarginView struct {
 	Margin map[tui.Side]int
 }
 
-var _ tui.View = &MarginView{}
+var _ tui.Wrapper = &MarginView{}
 
-func NewMarginView(view tui.View) *MarginView {
+func NewMarginView(view tui.View, top, right, bottom, left int) *MarginView {
 	v := new(MarginView)
 	v.SetView(view)
-	v.SetMargin(0, 0, 0, 0)
+	v.SetMargin(top, right, bottom, left)
 	return v
 }
 
@@ -34,10 +34,6 @@ func (v *MarginView) Layout() (prefWidth, prefHeight int) {
 	return w, h
 }
 
-func (v *MarginView) Style() tui.Style {
-	return v.ViewTmpl.Style()
-}
-
 func (v *MarginView) SetMargin(top, right, bottom, left int) {
 	v.Margin = map[tui.Side]int{
 		tui.SideTop:    top,

views/view_scroll.go

@@ -0,0 +1,143 @@
+package views
+
+import (
+	"math"
+
+	"git.milar.in/milarin/buf2d"
+	"git.milar.in/milarin/gmath"
+	"git.milar.in/milarin/tui"
+	"github.com/gdamore/tcell"
+)
+
+// ScrollView is a tui.View which can hold an arbitrary large view.
+// If the sub view does not fit into its bounds, scroll bars will be shown
+type ScrollView struct {
+	tui.WrapperTmpl
+	buf *tui.ViewBuffer
+
+	width, height int
+
+	verticalScrollOffset   int
+	horizontalScrollOffset int
+}
+
+var _ tui.Wrapper = &ScrollView{}
+
+func NewScrollView(view tui.View) *ScrollView {
+	v := new(ScrollView)
+	v.SetView(view)
+	return v
+}
+
+func (v *ScrollView) Draw(buf *tui.ViewBuffer) {
+	v.ViewTmpl.Draw(buf)
+
+	w, h := v.View().Layout()
+
+	if v.buf == nil || v.buf.Width() != w || v.buf.Height() != h {
+		v.buf = buf2d.NewBuffer(w, h, tui.DefaultRune)
+	}
+
+	v.Scroll(0, 0) // limit scroll offset boundaries
+	v.View().Draw(v.buf)
+
+	scrollH, scrollV := v.determineViewportSize(buf)
+	copyBufferWidth, copyBufferHeight := 0, 0
+
+	if scrollH {
+		copyBufferWidth = v.width
+	} else {
+		copyBufferWidth = v.buf.Width()
+	}
+
+	if scrollV {
+		copyBufferHeight = v.height
+	} else {
+		copyBufferHeight = v.buf.Height()
+	}
+
+	// copy buffer
+	for x := 0; x < copyBufferWidth; x++ {
+		for y := 0; y < copyBufferHeight; y++ {
+			buf.Set(x, y, v.buf.Get(v.horizontalScrollOffset+x, v.verticalScrollOffset+y))
+		}
+	}
+
+	scrollVHeight := int(float64(buf.Height()) / float64(v.buf.Height()) * float64(v.height))
+	scrollVStart := int(math.Ceil(float64(v.verticalScrollOffset) / float64(v.buf.Height()) * float64(v.height)))
+
+	scrollHStart := int(float64(v.horizontalScrollOffset) / float64(v.buf.Width()) * float64(v.width))
+	scrollHWidth := int(math.Ceil(float64(buf.Width()) / float64(v.buf.Width()) * float64(v.width)))
+
+	// guarantee minimum scroll bar thumb size of 1 TODO inaccurate for small scales
+	if scrollVHeight <= 0 {
+		scrollVHeight = 1
+		if scrollVStart >= v.height {
+			scrollVStart = v.height - 1
+		}
+	}
+	if scrollHWidth <= 0 {
+		scrollHWidth = 1
+		if scrollHStart >= v.width {
+			scrollHStart = v.width - 1
+		}
+	}
+
+	// vertical scrollbar
+	if scrollV {
+		for y := 0; y < v.height; y++ {
+			var style tcell.Style
+			if y >= scrollVStart && y < scrollVStart+scrollVHeight {
+				style = tui.StyleDefault.Background(tcell.ColorWhite)
+			} else {
+				style = tui.StyleDefault.Background(tcell.ColorDarkSlateGray)
+			}
+			buf.Set(v.width, y, tui.Rune{Rn: ' ', Style: style})
+		}
+	}
+
+	// horizontal scrollbar
+	if scrollH {
+		for x := 0; x < v.width; x++ {
+			var style tcell.Style
+			if x >= scrollHStart && x < scrollHStart+scrollHWidth {
+				style = tui.StyleDefault.Background(tcell.ColorWhite)
+			} else {
+				style = tui.StyleDefault.Background(tcell.ColorDarkSlateGray)
+			}
+			buf.Set(x, v.height, tui.Rune{Rn: ' ', Style: style})
+		}
+	}
+}
+
+func (v *ScrollView) Layout() (prefWidth, prefHeight int) {
+	return -1, -1
+}
+
+func (v *ScrollView) Scroll(verticalOffset, horizontalOffset int) {
+	if v.buf != nil {
+		v.verticalScrollOffset = gmath.Clamp(v.verticalScrollOffset+verticalOffset, 0, gmath.Max(v.buf.Height()-v.height, 0))
+		v.horizontalScrollOffset = gmath.Clamp(v.horizontalScrollOffset+horizontalOffset, 0, gmath.Max(v.buf.Width()-v.width, 0))
+	} else {
+		v.verticalScrollOffset = v.verticalScrollOffset + verticalOffset
+		v.horizontalScrollOffset = v.horizontalScrollOffset + horizontalOffset
+	}
+}
+
+func (v *ScrollView) determineViewportSize(buf *tui.ViewBuffer) (scrollbarH, scrollbarV bool) {
+	v.width, v.height = buf.Width()-1, buf.Height()-1
+	scrollbarV = v.buf.Height() > v.height
+	scrollbarH = v.buf.Width() > v.width
+
+	if scrollbarV && !scrollbarH {
+		v.height++
+		scrollbarV = v.buf.Height() > v.height
+	}
+
+	if !scrollbarV && scrollbarH {
+		v.width++
+		scrollbarH = v.buf.Width() > v.width
+	}
+
+	return
+}

views/view_text.go

@@ -1,7 +1,7 @@
 package views
 
 import (
-	"git.tordarus.net/Tordarus/tui"
+	"git.milar.in/milarin/tui"
 )
 
 // TextView is a tui.View which prints text
@@ -12,17 +12,17 @@ type TextView struct {
 
 var _ tui.View = &TextView{}
 
-func (v *TextView) Draw(buf *tui.ViewBuffer) {
-	v.ViewTmpl.Draw(buf)
-	tui.WriteMultiLineString(buf, v.Text, v.Style(), 0, 0)
-}
-
 func NewTextView(text string) *TextView {
 	return &TextView{
 		Text: text,
 	}
 }
 
+func (v *TextView) Draw(buf *tui.ViewBuffer) {
+	v.ViewTmpl.Draw(buf)
+	tui.WriteMultiLineString(buf, v.Text, v.Style(), 0, 0)
+}
+
 func (v *TextView) Layout() (prefWidth, prefHeight int) {
 	return tui.MeasureMultiLineString(v.Text)
 }