Merge branch 'deep-message-rendering'

9 files changed, 642 insertions, 188 deletions

diff --git a/ui/messages/base.go b/ui/messages/base.go
index ba1902d..d045e42 100644
--- a/ui/messages/base.go
+++ b/ui/messages/base.go
@@ -21,9 +21,9 @@ import (
 	"time"
 
 	"maunium.net/go/mautrix"
+	"maunium.net/go/mauview"
 	"maunium.net/go/tcell"
 
-	"maunium.net/go/gomuks/config"
 	"maunium.net/go/gomuks/interface"
 	"maunium.net/go/gomuks/ui/messages/tstring"
 	"maunium.net/go/gomuks/ui/widget"
@@ -34,33 +34,30 @@ func init() {
 }
 
 type BaseMessage struct {
-	MsgID           string
-	MsgType         mautrix.MessageType
-	MsgSenderID     string
-	MsgSender       string
-	MsgSenderColor  tcell.Color
-	MsgTimestamp    time.Time
-	MsgState        ifc.MessageState
-	MsgIsHighlight  bool
-	MsgIsService    bool
-	buffer          []tstring.TString
-	plainBuffer     []tstring.TString
-	prevBufferWidth int
-	prevPrefs       config.UserPreferences
+	MsgID          string
+	MsgType        mautrix.MessageType
+	MsgSenderID    string
+	MsgSender      string
+	MsgSenderColor tcell.Color
+	MsgTimestamp   time.Time
+	MsgState       ifc.MessageState
+	MsgIsHighlight bool
+	MsgIsService   bool
+	buffer         []tstring.TString
+	plainBuffer    []tstring.TString
 }
 
 func newBaseMessage(id, sender, displayname string, msgtype mautrix.MessageType, timestamp time.Time) BaseMessage {
 	return BaseMessage{
-		MsgSenderID:     sender,
-		MsgSender:       displayname,
-		MsgTimestamp:    timestamp,
-		MsgSenderColor:  widget.GetHashColor(sender),
-		MsgType:         msgtype,
-		MsgID:           id,
-		prevBufferWidth: 0,
-		MsgState:        ifc.MessageStateDefault,
-		MsgIsHighlight:  false,
-		MsgIsService:    false,
+		MsgSenderID:    sender,
+		MsgSender:      displayname,
+		MsgTimestamp:   timestamp,
+		MsgSenderColor: widget.GetHashColor(sender),
+		MsgType:        msgtype,
+		MsgID:          id,
+		MsgState:       ifc.MessageStateDefault,
+		MsgIsHighlight: false,
+		MsgIsService:   false,
 	}
 }
 
@@ -227,3 +224,9 @@ func (msg *BaseMessage) IsService() bool {
 func (msg *BaseMessage) SetIsService(isService bool) {
 	msg.MsgIsService = isService
 }
+
+func (msg *BaseMessage) Draw(screen mauview.Screen) {
+	for y, line := range msg.buffer {
+		line.Draw(screen, 0, y)
+	}
+}
diff --git a/ui/messages/expandedtextmessage.go b/ui/messages/expandedtextmessage.go
index d889771..044613f 100644
--- a/ui/messages/expandedtextmessage.go
+++ b/ui/messages/expandedtextmessage.go
@@ -58,8 +58,3 @@ func (msg *ExpandedTextMessage) PlainText() string {
 func (msg *ExpandedTextMessage) CalculateBuffer(prefs config.UserPreferences, width int) {
 	msg.calculateBufferWithText(prefs, msg.MsgText, width)
 }
-
-// RecalculateBuffer calculates the buffer again with the previously provided width.
-func (msg *ExpandedTextMessage) RecalculateBuffer() {
-	msg.CalculateBuffer(msg.prevPrefs, msg.prevBufferWidth)
-}
diff --git a/ui/messages/htmlmessage.go b/ui/messages/htmlmessage.go
new file mode 100644
index 0000000..8685442
--- /dev/null
+++ b/ui/messages/htmlmessage.go
@@ -0,0 +1,411 @@
+// gomuks - A terminal Matrix client written in Go.
+// Copyright (C) 2019 Tulir Asokan
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package messages
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/mattn/go-runewidth"
+
+	"maunium.net/go/mautrix"
+	"maunium.net/go/mauview"
+	"maunium.net/go/tcell"
+
+	"maunium.net/go/gomuks/config"
+	"maunium.net/go/gomuks/ui/widget"
+)
+
+type HTMLMessage struct {
+	BaseMessage
+
+	Root HTMLEntity
+}
+
+func NewHTMLMessage(id, sender, displayname string, msgtype mautrix.MessageType, root HTMLEntity, timestamp time.Time) UIMessage {
+	return &HTMLMessage{
+		BaseMessage: newBaseMessage(id, sender, displayname, msgtype, timestamp),
+		Root:        root,
+	}
+}
+func (hw *HTMLMessage) Draw(screen mauview.Screen) {
+	hw.Root.Draw(screen)
+}
+
+func (hw *HTMLMessage) OnKeyEvent(event mauview.KeyEvent) bool {
+	return false
+}
+
+func (hw *HTMLMessage) OnMouseEvent(event mauview.MouseEvent) bool {
+	return false
+}
+
+func (hw *HTMLMessage) OnPasteEvent(event mauview.PasteEvent) bool {
+	return false
+}
+
+func (hw *HTMLMessage) CalculateBuffer(preferences config.UserPreferences, width int) {
+	if width <= 0 {
+		panic("Negative width in CalculateBuffer")
+	}
+	// TODO account for bare messages in initial startX
+	startX := 0
+	hw.Root.calculateBuffer(width, startX, preferences.BareMessageView)
+}
+
+func (hw *HTMLMessage) Height() int {
+	return hw.Root.Height()
+}
+
+func (hw *HTMLMessage) PlainText() string {
+	return hw.Root.PlainText()
+}
+
+func (hw *HTMLMessage) NotificationContent() string {
+	return hw.Root.PlainText()
+}
+
+type AdjustStyleFunc func(tcell.Style) tcell.Style
+
+type HTMLEntity interface {
+	AdjustStyle(AdjustStyleFunc) HTMLEntity
+	Draw(screen mauview.Screen)
+	IsBlock() bool
+	GetTag() string
+	PlainText() string
+	String() string
+	Height() int
+
+	calculateBuffer(width, startX int, bare bool) int
+	getStartX() int
+}
+
+type BlockquoteEntity struct {
+	*BaseHTMLEntity
+}
+
+func NewBlockquoteEntity(children []HTMLEntity) *BlockquoteEntity {
+	return &BlockquoteEntity{&BaseHTMLEntity{
+		Tag:      "blockquote",
+		Children: children,
+		Block:    true,
+		Indent:   2,
+	}}
+}
+
+func (be *BlockquoteEntity) Draw(screen mauview.Screen) {
+	be.BaseHTMLEntity.Draw(screen)
+	for y := 0; y < be.height; y++ {
+		screen.SetContent(0, y, '>', nil, be.Style)
+	}
+}
+
+func (be *BlockquoteEntity) String() string {
+	return fmt.Sprintf("&BlockquoteEntity{%s},\n", be.BaseHTMLEntity)
+}
+
+type ListEntity struct {
+	*BaseHTMLEntity
+	Ordered bool
+	Start   int
+}
+
+func digits(num int) int {
+	if num <= 0 {
+		return 0
+	}
+	return int(math.Floor(math.Log10(float64(num))) + 1)
+}
+
+func NewListEntity(ordered bool, start int, children []HTMLEntity) *ListEntity {
+	entity := &ListEntity{
+		BaseHTMLEntity: &BaseHTMLEntity{
+			Tag:      "ul",
+			Children: children,
+			Block:    true,
+			Indent:   2,
+		},
+		Ordered: ordered,
+		Start:   start,
+	}
+	if ordered {
+		entity.Tag = "ol"
+		entity.Indent += digits(start + len(children) - 1)
+	}
+	return entity
+}
+
+func (le *ListEntity) Draw(screen mauview.Screen) {
+	width, _ := screen.Size()
+
+	proxyScreen := &mauview.ProxyScreen{Parent: screen, OffsetX: le.Indent, Width: width - le.Indent}
+	for i, entity := range le.Children {
+		proxyScreen.Height = entity.Height()
+		if le.Ordered {
+			number := le.Start + i
+			line := fmt.Sprintf("%d. %s", number, strings.Repeat(" ", le.Indent-2-digits(number)))
+			widget.WriteLine(screen, mauview.AlignLeft, line, 0, proxyScreen.OffsetY, le.Indent, le.Style)
+		} else {
+			screen.SetContent(0, proxyScreen.OffsetY, '●', nil, le.Style)
+		}
+		entity.Draw(proxyScreen)
+		proxyScreen.OffsetY += entity.Height()
+	}
+}
+
+func (le *ListEntity) String() string {
+	return fmt.Sprintf("&ListEntity{Ordered=%t, Start=%d, Base=%s},\n", le.Ordered, le.Start, le.BaseHTMLEntity)
+}
+
+type BreakEntity struct {
+	*BaseHTMLEntity
+}
+
+func NewBreakEntity() *BreakEntity {
+	return &BreakEntity{&BaseHTMLEntity{
+		Tag:   "br",
+		Block: true,
+	}}
+}
+
+type BaseHTMLEntity struct {
+	// Permanent variables
+	Tag      string
+	Text     string
+	Style    tcell.Style
+	Children []HTMLEntity
+	Block    bool
+	Indent   int
+
+	DefaultHeight int
+
+	// Non-permanent variables (calculated buffer data)
+	buffer    []string
+	prevWidth int
+	startX    int
+	height    int
+}
+
+func NewHTMLTextEntity(text string) *BaseHTMLEntity {
+	return &BaseHTMLEntity{
+		Tag:  "text",
+		Text: text,
+	}
+}
+
+func NewHTMLEntity(tag string, children []HTMLEntity, block bool) *BaseHTMLEntity {
+	return &BaseHTMLEntity{
+		Tag:      tag,
+		Children: children,
+		Block:    block,
+	}
+}
+
+func (he *BaseHTMLEntity) AdjustStyle(fn AdjustStyleFunc) HTMLEntity {
+	for _, child := range he.Children {
+		child.AdjustStyle(fn)
+	}
+	he.Style = fn(he.Style)
+	return he
+}
+
+func (he *BaseHTMLEntity) IsBlock() bool {
+	return he.Block
+}
+
+func (he *BaseHTMLEntity) GetTag() string {
+	return he.Tag
+}
+
+func (he *BaseHTMLEntity) Height() int {
+	return he.height
+}
+
+func (he *BaseHTMLEntity) getStartX() int {
+	return he.startX
+}
+
+func (he *BaseHTMLEntity) String() string {
+	var buf strings.Builder
+	buf.WriteString("&BaseHTMLEntity{\n")
+	_, _ = fmt.Fprintf(&buf, `    Tag="%s", Style=%d, Block=%t, Indent=%d, startX=%d, height=%d,`,
+		he.Tag, he.Style, he.Block, he.Indent, he.startX, he.height)
+	buf.WriteRune('\n')
+	_, _ = fmt.Fprintf(&buf, `    Buffer=["%s"]`, strings.Join(he.buffer, "\", \""))
+	if len(he.Text) > 0 {
+		buf.WriteString(",\n")
+		_, _ = fmt.Fprintf(&buf, `    Text="%s"`, he.Text)
+	}
+	if len(he.Children) > 0 {
+		buf.WriteString(",\n")
+		buf.WriteString("    Children={")
+		for _, child := range he.Children {
+			buf.WriteString("\n        ")
+			buf.WriteString(strings.Join(strings.Split(strings.TrimRight(child.String(), "\n"), "\n"), "\n        "))
+		}
+		buf.WriteString("\n    },")
+	}
+	buf.WriteString("\n},\n")
+	return buf.String()
+}
+
+func (he *BaseHTMLEntity) PlainText() string {
+	if len(he.Children) == 0 {
+		return he.Text
+	}
+	var buf strings.Builder
+	buf.WriteString(he.Text)
+	newlined := false
+	for _, child := range he.Children {
+		if child.IsBlock() && !newlined {
+			buf.WriteRune('\n')
+		}
+		newlined = false
+		buf.WriteString(child.PlainText())
+		if child.IsBlock() {
+			buf.WriteRune('\n')
+			newlined = true
+		}
+	}
+	return buf.String()
+}
+
+func (he *BaseHTMLEntity) Draw(screen mauview.Screen) {
+	width, _ := screen.Size()
+	if len(he.buffer) > 0 {
+		x := he.startX
+		for y, line := range he.buffer {
+			widget.WriteLine(screen, mauview.AlignLeft, line, x, y, width, he.Style)
+			x = 0
+		}
+	}
+	if len(he.Children) > 0 {
+		prevBreak := false
+		proxyScreen := &mauview.ProxyScreen{Parent: screen, OffsetX: he.Indent, Width: width - he.Indent}
+		for i, entity := range he.Children {
+			if i != 0 && entity.getStartX() == 0 {
+				proxyScreen.OffsetY++
+			}
+			proxyScreen.Height = entity.Height()
+			entity.Draw(proxyScreen)
+			proxyScreen.OffsetY += entity.Height() - 1
+			_, isBreak := entity.(*BreakEntity)
+			if prevBreak && isBreak {
+				proxyScreen.OffsetY++
+			}
+			prevBreak = isBreak
+		}
+	}
+}
+
+func (he *BaseHTMLEntity) calculateBuffer(width, startX int, bare bool) int {
+	he.startX = startX
+	if he.Block {
+		he.startX = 0
+	}
+	he.height = 0
+	if len(he.Children) > 0 {
+		childStartX := he.startX
+		prevBreak := false
+		for _, entity := range he.Children {
+			if entity.IsBlock() || childStartX == 0 || he.height == 0 {
+				he.height++
+			}
+			childStartX = entity.calculateBuffer(width-he.Indent, childStartX, bare)
+			he.height += entity.Height() - 1
+			_, isBreak := entity.(*BreakEntity)
+			if prevBreak && isBreak {
+				he.height++
+			}
+			prevBreak = isBreak
+		}
+		if len(he.Text) == 0 && !he.Block {
+			return childStartX
+		}
+	}
+	if len(he.Text) > 0 {
+		he.prevWidth = width
+		if he.buffer == nil {
+			he.buffer = []string{}
+		}
+		bufPtr := 0
+		text := he.Text
+		textStartX := he.startX
+		for {
+			// TODO add option no wrap and character wrap options
+			extract := runewidth.Truncate(text, width-textStartX, "")
+			extract, wordWrapped := trim(extract, text, bare)
+			if !wordWrapped && textStartX > 0 {
+				if bufPtr < len(he.buffer) {
+					he.buffer[bufPtr] = ""
+				} else {
+					he.buffer = append(he.buffer, "")
+				}
+				bufPtr++
+				textStartX = 0
+				continue
+			}
+			if bufPtr < len(he.buffer) {
+				he.buffer[bufPtr] = extract
+			} else {
+				he.buffer = append(he.buffer, extract)
+			}
+			bufPtr++
+			text = text[len(extract):]
+			if len(text) == 0 {
+				he.buffer = he.buffer[:bufPtr]
+				he.height += len(he.buffer)
+				// This entity is over, return the startX for the next entity
+				if he.Block {
+					// ...except if it's a block entity
+					return 0
+				}
+				return textStartX + runewidth.StringWidth(extract)
+			}
+			textStartX = 0
+		}
+	}
+	if len(he.Text) == 0 && len(he.Children) == 0 {
+		he.height = he.DefaultHeight
+	}
+	return he.startX
+}
+
+func trim(extract, full string, bare bool) (string, bool) {
+	if len(extract) == len(full) {
+		return extract, true
+	}
+	if spaces := spacePattern.FindStringIndex(full[len(extract):]); spaces != nil && spaces[0] == 0 {
+		extract = full[:len(extract)+spaces[1]]
+	}
+	regex := boundaryPattern
+	if bare {
+		regex = bareBoundaryPattern
+	}
+	matches := regex.FindAllStringIndex(extract, -1)
+	if len(matches) > 0 {
+		if match := matches[len(matches)-1]; len(match) >= 2 {
+			if until := match[1]; until < len(extract) {
+				extract = extract[:until]
+				return extract, true
+			}
+		}
+	}
+	return extract, len(extract) > 0 && extract[len(extract)-1] == ' '
+}
diff --git a/ui/messages/imagemessage.go b/ui/messages/imagemessage.go
index cad76a4..968f29e 100644
--- a/ui/messages/imagemessage.go
+++ b/ui/messages/imagemessage.go
@@ -112,11 +112,4 @@ func (msg *ImageMessage) CalculateBuffer(prefs config.UserPreferences, width int
 	}
 
 	msg.buffer = image.Render()
-	msg.prevBufferWidth = width
-	msg.prevPrefs = prefs
-}
-
-// RecalculateBuffer calculates the buffer again with the previously provided width.
-func (msg *ImageMessage) RecalculateBuffer() {
-	msg.CalculateBuffer(msg.prevPrefs, msg.prevBufferWidth)
 }
diff --git a/ui/messages/message.go b/ui/messages/message.go
index 076cd87..db93879 100644
--- a/ui/messages/message.go
+++ b/ui/messages/message.go
@@ -19,7 +19,7 @@ package messages
 import (
 	"maunium.net/go/gomuks/config"
 	"maunium.net/go/gomuks/interface"
-	"maunium.net/go/gomuks/ui/messages/tstring"
+	"maunium.net/go/mauview"
 )
 
 // UIMessage is a wrapper for the content and metadata of a Matrix message intended to be displayed.
@@ -27,8 +27,7 @@ type UIMessage interface {
 	ifc.Message
 
 	CalculateBuffer(preferences config.UserPreferences, width int)
-	RecalculateBuffer()
-	Buffer() []tstring.TString
+	Draw(screen mauview.Screen)
 	Height() int
 	PlainText() string
 
diff --git a/ui/messages/parser/htmlparser.go b/ui/messages/parser/htmlparser.go
index f01d3cb..e658c61 100644
--- a/ui/messages/parser/htmlparser.go
+++ b/ui/messages/parser/htmlparser.go
@@ -17,12 +17,13 @@
 package parser
 
 import (
-	"fmt"
-	"math"
 	"regexp"
 	"strconv"
 	"strings"
 
+	"github.com/alecthomas/chroma"
+	"github.com/alecthomas/chroma/lexers"
+	"github.com/alecthomas/chroma/styles"
 	"github.com/lucasb-eyer/go-colorful"
 	"golang.org/x/net/html"
 
@@ -30,7 +31,7 @@ import (
 	"maunium.net/go/tcell"
 
 	"maunium.net/go/gomuks/matrix/rooms"
-	"maunium.net/go/gomuks/ui/messages/tstring"
+	"maunium.net/go/gomuks/ui/messages"
 	"maunium.net/go/gomuks/ui/widget"
 )
 
@@ -40,11 +41,6 @@ type htmlParser struct {
 	room *rooms.Room
 }
 
-type taggedTString struct {
-	tstring.TString
-	tag string
-}
-
 func AdjustStyleBold(style tcell.Style) tcell.Style {
 	return style.Bold(true)
 }
@@ -82,65 +78,53 @@ func (parser *htmlParser) getAttribute(node *html.Node, attribute string) string
 	return ""
 }
 
-func digits(num int) int {
-	if num <= 0 {
-		return 0
-	}
-	return int(math.Floor(math.Log10(float64(num))) + 1)
-}
-
-func (parser *htmlParser) listToTString(node *html.Node, stripLinebreak bool) tstring.TString {
+func (parser *htmlParser) listToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
+	children := parser.nodeToEntities(node.FirstChild, stripLinebreak)
 	ordered := node.Data == "ol"
-	taggedChildren := parser.nodeToTaggedTStrings(node.FirstChild, stripLinebreak)
-	counter := 1
-	indentLength := 0
+	start := 1
 	if ordered {
-		start := parser.getAttribute(node, "start")
-		if len(start) > 0 {
-			counter, _ = strconv.Atoi(start)
+		if startRaw := parser.getAttribute(node, "start"); len(startRaw) > 0 {
+			var err error
+			start, err = strconv.Atoi(startRaw)
+			if err != nil {
+				start = 1
+			}
 		}
-
-		longestIndex := (counter - 1) + len(taggedChildren)
-		indentLength = digits(longestIndex)
 	}
-	indent := strings.Repeat(" ", indentLength+2)
-	var children []tstring.TString
-	for _, child := range taggedChildren {
-		if child.tag != "li" {
-			continue
-		}
-		var prefix string
-		if ordered {
-			indexPadding := indentLength - digits(counter)
-			prefix = fmt.Sprintf("%d. %s", counter, strings.Repeat(" ", indexPadding))
-		} else {
-			prefix = "● "
+	listItems := children[:0]
+	for _, child := range children {
+		if child.GetTag() == "li" {
+			listItems = append(listItems, child)
 		}
-		str := child.TString.Prepend(prefix)
-		counter++
-		parts := str.Split('\n')
-		for i, part := range parts[1:] {
-			parts[i+1] = part.Prepend(indent)
-		}
-		str = tstring.Join(parts, "\n")
-		children = append(children, str)
 	}
-	return tstring.Join(children, "\n")
+	return messages.NewListEntity(ordered, start, listItems)
 }
 
-func (parser *htmlParser) basicFormatToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	str := parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak)
+func (parser *htmlParser) basicFormatToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
+	entity := &messages.BaseHTMLEntity{
+		Tag:      node.Data,
+		Children: parser.nodeToEntities(node.FirstChild, stripLinebreak),
+	}
 	switch node.Data {
 	case "b", "strong":
-		str.AdjustStyleFull(AdjustStyleBold)
+		entity.AdjustStyle(AdjustStyleBold)
 	case "i", "em":
-		str.AdjustStyleFull(AdjustStyleItalic)
+		entity.AdjustStyle(AdjustStyleItalic)
 	case "s", "del":
-		str.AdjustStyleFull(AdjustStyleStrikethrough)
+		entity.AdjustStyle(AdjustStyleStrikethrough)
 	case "u", "ins":
-		str.AdjustStyleFull(AdjustStyleUnderline)
+		entity.AdjustStyle(AdjustStyleUnderline)
+	case "font":
+		fgColor, ok := parser.parseColor(node, "data-mx-color", "color")
+		if ok {
+			entity.AdjustStyle(AdjustStyleTextColor(fgColor))
+		}
+		bgColor, ok := parser.parseColor(node, "data-mx-bg-color", "background-color")
+		if ok {
+			entity.AdjustStyle(AdjustStyleBackgroundColor(bgColor))
+		}
 	}
-	return str
+	return entity
 }
 
 func (parser *htmlParser) parseColor(node *html.Node, mainName, altName string) (color tcell.Color, ok bool) {
@@ -165,103 +149,200 @@ func (parser *htmlParser) parseColor(node *html.Node, mainName, altName string)
 	return tcell.NewRGBColor(int32(r), int32(g), int32(b)), true
 }
 
-func (parser *htmlParser) fontToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	str := parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak)
-	fgColor, ok := parser.parseColor(node, "data-mx-color", "color")
-	if ok {
-		str.AdjustStyleFull(AdjustStyleTextColor(fgColor))
-	}
-	bgColor, ok := parser.parseColor(node, "data-mx-bg-color", "background-color")
-	if ok {
-		str.AdjustStyleFull(AdjustStyleBackgroundColor(bgColor))
-	}
-	return str
-}
-
-func (parser *htmlParser) headerToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	children := parser.nodeToTStrings(node.FirstChild, stripLinebreak)
+func (parser *htmlParser) headerToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
 	length := int(node.Data[1] - '0')
 	prefix := strings.Repeat("#", length) + " "
-	return tstring.Join(children, "").Prepend(prefix)
+	return (&messages.BaseHTMLEntity{
+		Tag:      node.Data,
+		Text:     prefix,
+		Children: parser.nodeToEntities(node.FirstChild, stripLinebreak),
+	}).AdjustStyle(AdjustStyleBold)
 }
 
-func (parser *htmlParser) blockquoteToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	str := parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak)
-	childrenArr := str.TrimSpace().Split('\n')
-	for index, child := range childrenArr {
-		childrenArr[index] = child.Prepend("> ")
-	}
-	return tstring.Join(childrenArr, "\n")
+func (parser *htmlParser) blockquoteToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
+	return messages.NewBlockquoteEntity(parser.nodeToEntities(node.FirstChild, stripLinebreak))
 }
 
-func (parser *htmlParser) linkToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	str := parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak)
+func (parser *htmlParser) linkToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
+	entity := &messages.BaseHTMLEntity{
+		Tag:      "a",
+		Children: parser.nodeToEntities(node.FirstChild, stripLinebreak),
+	}
 	href := parser.getAttribute(node, "href")
 	if len(href) == 0 {
-		return str
+		return entity
 	}
 	match := matrixToURL.FindStringSubmatch(href)
 	if len(match) == 2 {
+		entity.Children = nil
 		pillTarget := match[1]
+		entity.Text = pillTarget
 		if pillTarget[0] == '@' {
 			if member := parser.room.GetMember(pillTarget); member != nil {
-				return tstring.NewColorTString(member.Displayname, widget.GetHashColor(pillTarget))
+				entity.Text = member.Displayname
+				entity.Style = entity.Style.Foreground(widget.GetHashColor(pillTarget))
 			}
 		}
-		return tstring.NewTString(pillTarget)
 	}
-	return str.Append(fmt.Sprintf(" (%s)", href))
+	// TODO add click action and underline on hover for links
+	return entity
 }
 
-func (parser *htmlParser) tagToTString(node *html.Node, stripLinebreak bool) tstring.TString {
+func (parser *htmlParser) imageToEntity(node *html.Node) messages.HTMLEntity {
+	alt := parser.getAttribute(node, "alt")
+	if len(alt) == 0 {
+		alt = parser.getAttribute(node, "title")
+		if len(alt) == 0 {
+			alt = "[inline image]"
+		}
+	}
+	entity := &messages.BaseHTMLEntity{
+		Tag:  "img",
+		Text: alt,
+	}
+	// TODO add click action and underline on hover for inline images
+	return entity
+}
+
+func colourToColor(colour chroma.Colour) tcell.Color {
+	if !colour.IsSet() {
+		return tcell.ColorDefault
+	}
+	return tcell.NewRGBColor(int32(colour.Red()), int32(colour.Green()), int32(colour.Blue()))
+}
+
+func styleEntryToStyle(se chroma.StyleEntry) tcell.Style {
+	return tcell.StyleDefault.
+		Bold(se.Bold == chroma.Yes).
+		Italic(se.Italic == chroma.Yes).
+		Underline(se.Underline == chroma.Yes).
+		Foreground(colourToColor(se.Colour)).
+		Background(colourToColor(se.Background))
+}
+
+func (parser *htmlParser) syntaxHighlight(text, language string) messages.HTMLEntity {
+	lexer := lexers.Get(language)
+	if lexer == nil {
+		return nil
+	}
+	iter, err := lexer.Tokenise(nil, text)
+	if err != nil {
+		return nil
+	}
+	style := styles.SolarizedDark
+	tokens := iter.Tokens()
+	children := make([]messages.HTMLEntity, len(tokens))
+	for i, token := range tokens {
+		if token.Value == "\n" {
+			children[i] = &messages.BaseHTMLEntity{Block: true, Tag: "br"}
+		} else {
+			children[i] = &messages.BaseHTMLEntity{
+				Tag:   token.Type.String(),
+				Text:  token.Value,
+				Style: styleEntryToStyle(style.Get(token.Type)),
+
+				DefaultHeight: 1,
+			}
+		}
+	}
+	return &messages.BaseHTMLEntity{
+		Tag:      "pre",
+		Block:    true,
+		Children: children,
+	}
+}
+
+func (parser *htmlParser) codeblockToEntity(node *html.Node) messages.HTMLEntity {
+	entity := &messages.BaseHTMLEntity{
+		Tag:   "pre",
+		Block: true,
+	}
+	// TODO allow disabling syntax highlighting
+	if node.FirstChild.Type == html.ElementNode && node.FirstChild.Data == "code" {
+		text := (&messages.BaseHTMLEntity{
+			Children: parser.nodeToEntities(node.FirstChild.FirstChild, false),
+		}).PlainText()
+		attr := parser.getAttribute(node.FirstChild, "class")
+		var lang string
+		for _, class := range strings.Split(attr, " ") {
+			if strings.HasPrefix(class, "language-") {
+				lang = class[len("language-"):]
+				break
+			}
+		}
+		if len(lang) != 0 {
+			if parsed := parser.syntaxHighlight(text, lang); parsed != nil {
+				return parsed
+			}
+		}
+	}
+	entity.Children = parser.nodeToEntities(node.FirstChild, false)
+	return entity
+}
+
+func (parser *htmlParser) tagNodeToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
 	switch node.Data {
 	case "blockquote":
-		return parser.blockquoteToTString(node, stripLinebreak)
+		return parser.blockquoteToEntity(node, stripLinebreak)
 	case "ol", "ul":
-		return parser.listToTString(node, stripLinebreak)
+		return parser.listToEntity(node, stripLinebreak)
 	case "h1", "h2", "h3", "h4", "h5", "h6":
-		return parser.headerToTString(node, stripLinebreak)
+		return parser.headerToEntity(node, stripLinebreak)
 	case "br":
-		return tstring.NewTString("\n")
-	case "b", "strong", "i", "em", "s", "del", "u", "ins":
-		return parser.basicFormatToTString(node, stripLinebreak)
-	case "font":
-		return parser.fontToTString(node, stripLinebreak)
+		return messages.NewBreakEntity()
+	case "b", "strong", "i", "em", "s", "del", "u", "ins", "font":
+		return parser.basicFormatToEntity(node, stripLinebreak)
 	case "a":
-		return parser.linkToTString(node, stripLinebreak)
-	case "p":
-		return parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak).Append("\n")
+		return parser.linkToEntity(node, stripLinebreak)
+	case "img":
+		return parser.imageToEntity(node)
 	case "pre":
-		return parser.nodeToTString(node.FirstChild, false)
+		return parser.codeblockToEntity(node)
 	default:
-		return parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak)
+		return &messages.BaseHTMLEntity{
+			Tag:      node.Data,
+			Children: parser.nodeToEntities(node.FirstChild, stripLinebreak),
+			Block:    parser.isBlockTag(node.Data),
+		}
 	}
 }
 
-func (parser *htmlParser) singleNodeToTString(node *html.Node, stripLinebreak bool) taggedTString {
+func (parser *htmlParser) singleNodeToEntity(node *html.Node, stripLinebreak bool) messages.HTMLEntity {
 	switch node.Type {
 	case html.TextNode:
 		if stripLinebreak {
 			node.Data = strings.Replace(node.Data, "\n", "", -1)
 		}
-		return taggedTString{tstring.NewTString(node.Data), "text"}
+		return &messages.BaseHTMLEntity{
+			Tag:  "text",
+			Text: node.Data,
+		}
 	case html.ElementNode:
-		return taggedTString{parser.tagToTString(node, stripLinebreak), node.Data}
+		return parser.tagNodeToEntity(node, stripLinebreak)
 	case html.DocumentNode:
-		return taggedTString{parser.nodeToTagAwareTString(node.FirstChild, stripLinebreak), "html"}
+		if node.FirstChild.Data == "html" && node.FirstChild.NextSibling == nil {
+			return parser.singleNodeToEntity(node.FirstChild, stripLinebreak)
+		}
+		return &messages.BaseHTMLEntity{
+			Tag:      "html",
+			Children: parser.nodeToEntities(node.FirstChild, stripLinebreak),
+			Block:    true,
+		}
 	default:
-		return taggedTString{tstring.NewBlankTString(), "unknown"}
+		return nil
 	}
 }
 
-func (parser *htmlParser) nodeToTaggedTStrings(node *html.Node, stripLinebreak bool) (strs []taggedTString) {
+func (parser *htmlParser) nodeToEntities(node *html.Node, stripLinebreak bool) (entities []messages.HTMLEntity) {
 	for ; node != nil; node = node.NextSibling {
-		strs = append(strs, parser.singleNodeToTString(node, stripLinebreak))
+		if entity := parser.singleNodeToEntity(node, stripLinebreak); entity != nil {
+			entities = append(entities, entity)
+		}
 	}
 	return
 }
 
-var BlockTags = []string{"p", "h1", "h2", "h3", "h4", "h5", "h6", "ol", "ul", "pre", "blockquote", "div", "hr", "table"}
+var BlockTags = []string{"p", "h1", "h2", "h3", "h4", "h5", "h6", "ol", "ul", "li", "pre", "blockquote", "div", "hr", "table"}
 
 func (parser *htmlParser) isBlockTag(tag string) bool {
 	for _, blockTag := range BlockTags {
@@ -272,51 +353,31 @@ func (parser *htmlParser) isBlockTag(tag string) bool {
 	return false
 }
 
-func (parser *htmlParser) nodeToTagAwareTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	strs := parser.nodeToTaggedTStrings(node, stripLinebreak)
-	output := tstring.NewBlankTString()
-	for _, str := range strs {
-		tstr := str.TString
-		if parser.isBlockTag(str.tag) {
-			tstr = tstr.Prepend("\n").Append("\n")
-		}
-		output = output.AppendTString(tstr)
-	}
-	return output.TrimSpace()
-}
-
-func (parser *htmlParser) nodeToTStrings(node *html.Node, stripLinebreak bool) (strs []tstring.TString) {
-	for ; node != nil; node = node.NextSibling {
-		strs = append(strs, parser.singleNodeToTString(node, stripLinebreak).TString)
-	}
-	return
-}
-
-func (parser *htmlParser) nodeToTString(node *html.Node, stripLinebreak bool) tstring.TString {
-	return tstring.Join(parser.nodeToTStrings(node, stripLinebreak), "")
-}
-
-func (parser *htmlParser) Parse(htmlData string) tstring.TString {
+func (parser *htmlParser) Parse(htmlData string) messages.HTMLEntity {
 	node, _ := html.Parse(strings.NewReader(htmlData))
-	return parser.nodeToTagAwareTString(node, true)
+	return parser.singleNodeToEntity(node, true)
 }
 
 // ParseHTMLMessage parses a HTML-formatted Matrix event into a UIMessage.
-func ParseHTMLMessage(room *rooms.Room, evt *mautrix.Event, senderDisplayname string) tstring.TString {
+func ParseHTMLMessage(room *rooms.Room, evt *mautrix.Event, senderDisplayname string) messages.HTMLEntity {
 	htmlData := evt.Content.FormattedBody
 	htmlData = strings.Replace(htmlData, "\t", "    ", -1)
 
 	parser := htmlParser{room}
-	str := parser.Parse(htmlData)
+	root := parser.Parse(htmlData)
+	root.(*messages.BaseHTMLEntity).Block = false
 
 	if evt.Content.MsgType == mautrix.MsgEmote {
-		str = tstring.Join([]tstring.TString{
-			tstring.NewTString("* "),
-			tstring.NewColorTString(senderDisplayname, widget.GetHashColor(evt.Sender)),
-			tstring.NewTString(" "),
-			str,
-		}, "")
+		root = &messages.BaseHTMLEntity{
+			Tag: "emote",
+			Children: []messages.HTMLEntity{
+				messages.NewHTMLTextEntity("* "),
+				messages.NewHTMLTextEntity("* ").AdjustStyle(AdjustStyleTextColor(widget.GetHashColor(evt.Sender))),
+				messages.NewHTMLTextEntity(" "),
+				root,
+			},
+		}
 	}
 
-	return str
+	return root
 }
diff --git a/ui/messages/parser/parser.go b/ui/messages/parser/parser.go
index 79e628a..e48bd5f 100644
--- a/ui/messages/parser/parser.go
+++ b/ui/messages/parser/parser.go
@@ -113,7 +113,7 @@ func ParseMessage(matrix ifc.MatrixContainer, room *rooms.Room, evt *mautrix.Eve
 				replyToEvt.Content.FormattedBody = html.EscapeString(replyToEvt.Content.Body)
 			}
 			evt.Content.FormattedBody = fmt.Sprintf(
-				"In reply to <a href='https://matrix.to/#/%[1]s'>%[1]s</a><blockquote>%[2]s</blockquote><br/>%[3]s",
+				"In reply to <a href='https://matrix.to/#/%[1]s'>%[1]s</a><blockquote>%[2]s</blockquote><br/><br/>%[3]s",
 				replyToEvt.Sender, replyToEvt.Content.FormattedBody, evt.Content.FormattedBody)
 		} else {
 			evt.Content.FormattedBody = fmt.Sprintf(
@@ -125,8 +125,7 @@ func ParseMessage(matrix ifc.MatrixContainer, room *rooms.Room, evt *mautrix.Eve
 	switch evt.Content.MsgType {
 	case "m.text", "m.notice", "m.emote":
 		if evt.Content.Format == mautrix.FormatHTML {
-			text := ParseHTMLMessage(room, evt, displayname)
-			return messages.NewExpandedTextMessage(evt.ID, evt.Sender, displayname, evt.Content.MsgType, text, ts)
+			return messages.NewHTMLMessage(evt.ID, evt.Sender, displayname, evt.Content.MsgType, ParseHTMLMessage(room, evt, displayname), ts)
 		}
 		evt.Content.Body = strings.Replace(evt.Content.Body, "\t", "    ", -1)
 		return messages.NewTextMessage(evt.ID, evt.Sender, displayname, evt.Content.MsgType, evt.Content.Body, ts)
diff --git a/ui/messages/textbase.go b/ui/messages/textbase.go
index 01e7b5c..321d998 100644
--- a/ui/messages/textbase.go
+++ b/ui/messages/textbase.go
@@ -92,6 +92,4 @@ func (msg *BaseMessage) calculateBufferWithText(prefs config.UserPreferences, te
 			str = str[len(extract):]
 		}
 	}
-	msg.prevBufferWidth = width
-	msg.prevPrefs = prefs
 }
diff --git a/ui/messages/textmessage.go b/ui/messages/textmessage.go
index 8ce9482..6364659 100644
--- a/ui/messages/textmessage.go
+++ b/ui/messages/textmessage.go
@@ -90,8 +90,3 @@ func (msg *TextMessage) PlainText() string {
 func (msg *TextMessage) CalculateBuffer(prefs config.UserPreferences, width int) {
 	msg.calculateBufferWithText(prefs, msg.getCache(), width)
 }
-
-// RecalculateBuffer calculates the buffer again with the previously provided width.
-func (msg *TextMessage) RecalculateBuffer() {
-	msg.CalculateBuffer(msg.prevPrefs, msg.prevBufferWidth)
-}