gomuks/ui/message-view.go

548 lines
14 KiB
Go
Raw Normal View History

2018-03-17 00:27:30 +01:00
// gomuks - A terminal Matrix client written in Go.
// Copyright (C) 2018 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
package ui
2018-03-17 00:27:30 +01:00
import (
2018-03-22 18:51:20 +01:00
"encoding/gob"
"fmt"
"math"
2018-03-22 18:51:20 +01:00
"os"
"strings"
2018-03-17 00:27:30 +01:00
"github.com/mattn/go-runewidth"
"maunium.net/go/gomuks/debug"
"maunium.net/go/gomuks/interface"
2018-04-14 14:33:20 +02:00
"maunium.net/go/gomuks/lib/open"
"maunium.net/go/gomuks/ui/messages"
2018-04-14 14:33:20 +02:00
"maunium.net/go/gomuks/ui/messages/tstring"
"maunium.net/go/gomuks/ui/widget"
2018-04-14 14:33:20 +02:00
"maunium.net/go/tcell"
2018-03-17 00:27:30 +01:00
"maunium.net/go/tview"
)
type MessageView struct {
*tview.Box
2018-04-14 14:33:20 +02:00
parent *RoomView
2018-03-17 00:27:30 +01:00
ScrollOffset int
MaxSenderWidth int
DateFormat string
2018-03-17 00:27:30 +01:00
TimestampFormat string
TimestampWidth int
2018-03-20 11:16:32 +01:00
LoadingMessages bool
2018-03-17 00:27:30 +01:00
2018-03-20 11:16:32 +01:00
widestSender int
prevWidth int
prevHeight int
prevMsgCount int
prevBareMode bool
2018-03-17 00:27:30 +01:00
messageIDs map[string]messages.UIMessage
messages []messages.UIMessage
2018-03-20 11:16:32 +01:00
textBuffer []tstring.TString
metaBuffer []ifc.MessageMeta
2018-03-17 00:27:30 +01:00
}
2018-04-14 14:33:20 +02:00
func NewMessageView(parent *RoomView) *MessageView {
2018-03-17 00:27:30 +01:00
return &MessageView{
2018-04-14 14:33:20 +02:00
Box: tview.NewBox(),
parent: parent,
MaxSenderWidth: 15,
TimestampWidth: len(messages.TimeFormat),
ScrollOffset: 0,
2018-03-17 00:27:30 +01:00
messages: make([]messages.UIMessage, 0),
messageIDs: make(map[string]messages.UIMessage),
textBuffer: make([]tstring.TString, 0),
metaBuffer: make([]ifc.MessageMeta, 0),
2018-03-20 11:16:32 +01:00
widestSender: 5,
prevWidth: -1,
prevHeight: -1,
prevMsgCount: -1,
prevBareMode: false,
2018-03-17 00:27:30 +01:00
}
}
2018-03-22 18:51:20 +01:00
func (view *MessageView) SaveHistory(path string) error {
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0600)
if err != nil {
return err
}
defer file.Close()
enc := gob.NewEncoder(file)
err = enc.Encode(view.messages)
if err != nil {
return err
}
return nil
}
func (view *MessageView) LoadHistory(matrix ifc.MatrixContainer, path string) (int, error) {
2018-03-22 18:51:20 +01:00
file, err := os.OpenFile(path, os.O_RDONLY, 0600)
if err != nil {
if os.IsNotExist(err) {
return 0, nil
}
return -1, err
}
defer file.Close()
var msgs []messages.UIMessage
2018-03-22 18:51:20 +01:00
dec := gob.NewDecoder(file)
err = dec.Decode(&msgs)
2018-03-22 18:51:20 +01:00
if err != nil {
return -1, err
}
view.messages = make([]messages.UIMessage, len(msgs))
indexOffset := 0
for index, message := range msgs {
if message != nil {
view.messages[index-indexOffset] = message
view.updateWidestSender(message.Sender())
message.RegisterMatrix(matrix)
} else {
indexOffset++
}
2018-03-22 18:51:20 +01:00
}
return len(view.messages), nil
}
func (view *MessageView) updateWidestSender(sender string) {
2018-03-17 00:27:30 +01:00
if len(sender) > view.widestSender {
view.widestSender = len(sender)
if view.widestSender > view.MaxSenderWidth {
view.widestSender = view.MaxSenderWidth
}
}
}
func (view *MessageView) UpdateMessageID(ifcMessage ifc.Message, newID string) {
message, ok := ifcMessage.(messages.UIMessage)
if !ok {
debug.Print("[Warning] Passed non-UIMessage ifc.Message object to UpdateMessageID().")
debug.PrintStack()
return
}
delete(view.messageIDs, message.ID())
message.SetID(newID)
view.messageIDs[message.ID()] = message
}
func (view *MessageView) AddMessage(ifcMessage ifc.Message, direction ifc.MessageDirection) {
if ifcMessage == nil {
return
}
message, ok := ifcMessage.(messages.UIMessage)
if !ok {
debug.Print("[Warning] Passed non-UIMessage ifc.Message object to AddMessage().")
debug.PrintStack()
2018-03-22 18:51:20 +01:00
return
}
oldMsg, messageExists := view.messageIDs[message.ID()]
if messageExists {
view.replaceMessage(oldMsg, message)
direction = ifc.IgnoreMessage
2018-03-17 00:27:30 +01:00
}
view.updateWidestSender(message.Sender())
_, _, width, _ := view.GetRect()
2018-05-22 23:44:29 +02:00
bare := view.parent.parent.bareMessages
if !bare {
width -= view.TimestampWidth + TimestampSenderGap + view.widestSender + SenderMessageGap
}
message.CalculateBuffer(bare, width)
if direction == ifc.AppendMessage {
if view.ScrollOffset > 0 {
2018-03-22 18:51:20 +01:00
view.ScrollOffset += message.Height()
}
view.messages = append(view.messages, message)
view.appendBuffer(message)
} else if direction == ifc.PrependMessage {
view.messages = append([]messages.UIMessage{message}, view.messages...)
} else if oldMsg != nil {
view.replaceBuffer(oldMsg, message)
} else {
2018-04-24 15:51:40 +02:00
debug.Print("Unexpected AddMessage() call: Direction is not append or prepend, but message is new.")
debug.PrintStack()
2018-03-17 00:27:30 +01:00
}
view.messageIDs[message.ID()] = message
2018-03-20 11:16:32 +01:00
}
2018-03-17 00:27:30 +01:00
func (view *MessageView) appendBuffer(message messages.UIMessage) {
2018-03-20 11:16:32 +01:00
if len(view.metaBuffer) > 0 {
prevMeta := view.metaBuffer[len(view.metaBuffer)-1]
if prevMeta != nil && prevMeta.FormatDate() != message.FormatDate() {
view.textBuffer = append(view.textBuffer, tstring.NewColorTString(
fmt.Sprintf("Date changed to %s", message.FormatDate()),
tcell.ColorGreen))
view.metaBuffer = append(view.metaBuffer, &messages.BasicMeta{
BTimestampColor: tcell.ColorDefault, BTextColor: tcell.ColorGreen})
2018-03-20 11:16:32 +01:00
}
}
2018-03-17 00:27:30 +01:00
2018-03-22 18:51:20 +01:00
view.textBuffer = append(view.textBuffer, message.Buffer()...)
for range message.Buffer() {
2018-03-20 11:16:32 +01:00
view.metaBuffer = append(view.metaBuffer, message)
}
view.prevMsgCount++
2018-03-20 11:16:32 +01:00
}
func (view *MessageView) replaceMessage(original messages.UIMessage, new messages.UIMessage) {
view.messageIDs[new.ID()] = new
for index, msg := range view.messages {
if msg == original {
view.messages[index] = new
}
}
}
func (view *MessageView) replaceBuffer(original messages.UIMessage, new messages.UIMessage) {
start := -1
end := -1
for index, meta := range view.metaBuffer {
if meta == original {
if start == -1 {
start = index
}
end = index
} else if start != -1 {
break
}
}
if start == -1 {
2018-04-24 15:51:40 +02:00
debug.Print("Called replaceBuffer() with message that was not in the buffer:", original.ID())
2018-04-24 16:12:08 +02:00
debug.PrintStack()
view.appendBuffer(new)
return
}
if len(view.textBuffer) > end {
end++
}
view.textBuffer = append(append(view.textBuffer[0:start], new.Buffer()...), view.textBuffer[end:]...)
if len(new.Buffer()) != end-start+1 {
metaBuffer := view.metaBuffer[0:start]
for range new.Buffer() {
metaBuffer = append(metaBuffer, new)
}
view.metaBuffer = append(metaBuffer, view.metaBuffer[end:]...)
} else {
for i := start; i < end; i++ {
view.metaBuffer[i] = new
}
}
}
func (view *MessageView) recalculateBuffers() {
_, _, width, height := view.GetRect()
2018-05-22 23:44:29 +02:00
bareMode := view.parent.parent.bareMessages
if !bareMode {
width -= view.TimestampWidth + TimestampSenderGap + view.widestSender + SenderMessageGap
}
recalculateMessageBuffers := width != view.prevWidth || bareMode != view.prevBareMode
if recalculateMessageBuffers || len(view.messages) != view.prevMsgCount {
view.textBuffer = []tstring.TString{}
view.metaBuffer = []ifc.MessageMeta{}
view.prevMsgCount = 0
for i, message := range view.messages {
if message == nil {
debug.Print("O.o found nil message at", i)
break
}
if recalculateMessageBuffers {
message.CalculateBuffer(bareMode, width)
}
2018-03-20 11:16:32 +01:00
view.appendBuffer(message)
2018-03-17 00:27:30 +01:00
}
}
view.prevHeight = height
view.prevWidth = width
view.prevBareMode = bareMode
2018-03-17 00:27:30 +01:00
}
2018-04-15 13:03:05 +02:00
func (view *MessageView) handleMessageClick(message ifc.MessageMeta) bool {
switch message := message.(type) {
case *messages.ImageMessage:
open.Open(message.Path())
case messages.UIMessage:
debug.Print("Message clicked:", message.NotificationContent())
}
return false
}
func (view *MessageView) handleUsernameClick(message ifc.MessageMeta, prevMessage ifc.MessageMeta) bool {
uiMessage, ok := message.(messages.UIMessage)
if !ok {
return false
}
prevUIMessage, _ := prevMessage.(messages.UIMessage)
if prevUIMessage != nil && prevUIMessage.Sender() == uiMessage.Sender() {
return false
}
if len(uiMessage.Sender()) == 0 {
2018-04-15 13:03:05 +02:00
return false
}
sender := fmt.Sprintf("[%s](https://matrix.to/#/%s)", uiMessage.Sender(), uiMessage.SenderID())
2018-04-15 13:03:05 +02:00
cursorPos := view.parent.input.GetCursorOffset()
text := view.parent.input.GetText()
var buf strings.Builder
2018-04-15 13:03:05 +02:00
if cursorPos == 0 {
buf.WriteString(sender)
buf.WriteRune(':')
buf.WriteRune(' ')
buf.WriteString(text)
2018-04-15 13:03:05 +02:00
} else {
textBefore := runewidth.Truncate(text, cursorPos, "")
textAfter := text[len(textBefore):]
buf.WriteString(textBefore)
buf.WriteString(sender)
buf.WriteRune(' ')
buf.WriteString(textAfter)
2018-04-15 13:03:05 +02:00
}
newText := buf.String()
2018-04-15 13:03:05 +02:00
view.parent.input.SetText(string(newText))
view.parent.input.SetCursorOffset(cursorPos + len(newText) - len(text))
return true
}
2018-04-14 14:33:20 +02:00
func (view *MessageView) HandleClick(x, y int, button tcell.ButtonMask) bool {
if button != tcell.Button1 {
2018-04-14 14:33:20 +02:00
return false
}
_, _, _, height := view.GetRect()
line := view.TotalHeight() - view.ScrollOffset - height + y
if line < 0 || line >= view.TotalHeight() {
2018-04-14 14:33:20 +02:00
return false
}
message := view.metaBuffer[line]
2018-04-14 14:33:20 +02:00
var prevMessage ifc.MessageMeta
2018-04-15 13:03:05 +02:00
if y != 0 && line > 0 {
2018-04-14 14:33:20 +02:00
prevMessage = view.metaBuffer[line-1]
}
usernameX := view.TimestampWidth + TimestampSenderGap
messageX := usernameX + view.widestSender + SenderMessageGap
2018-04-15 13:03:05 +02:00
shouldRerender := false
2018-04-14 14:33:20 +02:00
if x >= messageX {
2018-04-15 13:03:05 +02:00
shouldRerender = view.handleMessageClick(message)
2018-04-14 14:33:20 +02:00
} else if x >= usernameX {
2018-04-15 13:03:05 +02:00
shouldRerender = view.handleUsernameClick(message, prevMessage)
2018-04-14 14:33:20 +02:00
}
2018-04-15 13:03:05 +02:00
return shouldRerender
}
2018-03-20 11:16:32 +01:00
const PaddingAtTop = 5
func (view *MessageView) AddScrollOffset(diff int) {
_, _, _, height := view.GetRect()
2018-03-20 11:16:32 +01:00
totalHeight := view.TotalHeight()
2018-03-26 13:31:44 +02:00
if diff >= 0 && view.ScrollOffset+diff >= totalHeight-height+PaddingAtTop {
view.ScrollOffset = totalHeight - height + PaddingAtTop
} else {
view.ScrollOffset += diff
2018-03-20 11:16:32 +01:00
}
2018-03-26 13:31:44 +02:00
if view.ScrollOffset > totalHeight-height+PaddingAtTop {
view.ScrollOffset = totalHeight - height + PaddingAtTop
}
if view.ScrollOffset < 0 {
view.ScrollOffset = 0
2018-03-20 11:16:32 +01:00
}
}
func (view *MessageView) Height() int {
_, _, _, height := view.GetRect()
return height
}
func (view *MessageView) TotalHeight() int {
return len(view.textBuffer)
2018-03-17 00:27:30 +01:00
}
func (view *MessageView) IsAtTop() bool {
_, _, _, height := view.GetRect()
totalHeight := len(view.textBuffer)
return view.ScrollOffset >= totalHeight-height+PaddingAtTop
2018-03-17 00:27:30 +01:00
}
const (
TimestampSenderGap = 1
SenderSeparatorGap = 1
SenderMessageGap = 3
)
2018-03-26 13:31:44 +02:00
func getScrollbarStyle(scrollbarHere, isTop, isBottom bool) (char rune, style tcell.Style) {
char = '│'
style = tcell.StyleDefault
if scrollbarHere {
style = style.Foreground(tcell.ColorGreen)
}
if isTop {
if scrollbarHere {
char = '╥'
} else {
char = '┬'
}
} else if isBottom {
if scrollbarHere {
char = '╨'
} else {
char = '┴'
}
} else if scrollbarHere {
char = '║'
}
return
}
2018-04-15 13:03:05 +02:00
func (view *MessageView) calculateScrollBar(height int) (scrollBarHeight, scrollBarPos int) {
viewportHeight := float64(height)
contentHeight := float64(view.TotalHeight())
scrollBarHeight = int(math.Ceil(viewportHeight / (contentHeight / viewportHeight)))
scrollBarPos = height - int(math.Round(float64(view.ScrollOffset)/contentHeight*viewportHeight))
return
}
func (view *MessageView) getIndexOffset(screen tcell.Screen, height, messageX int) (indexOffset int) {
indexOffset = view.TotalHeight() - view.ScrollOffset - height
if indexOffset <= -PaddingAtTop {
message := "Scroll up to load more messages."
if view.LoadingMessages {
message = "Loading more messages..."
}
_, y, _, _ := view.GetRect()
2018-04-15 13:03:05 +02:00
widget.WriteLineSimpleColor(screen, message, messageX, y, tcell.ColorGreen)
}
return
}
2018-03-17 00:27:30 +01:00
2018-05-22 23:44:29 +02:00
func (view *MessageView) CapturePlaintext(height int) string {
var buf strings.Builder
indexOffset := view.TotalHeight() - view.ScrollOffset - height
var prevMessage messages.UIMessage
for line := 0; line < height; line++ {
index := indexOffset + line
if index < 0 {
continue
}
meta := view.metaBuffer[index]
message, ok := meta.(messages.UIMessage)
if ok && message != prevMessage {
fmt.Fprintf(&buf, "%s <%s> %s\n", message.FormatTime(), message.Sender(), message.PlainText())
prevMessage = message
}
}
return buf.String()
}
2018-04-15 13:03:05 +02:00
func (view *MessageView) Draw(screen tcell.Screen) {
x, y, _, height := view.GetRect()
view.recalculateBuffers()
if view.TotalHeight() == 0 {
widget.WriteLineSimple(screen, "It's quite empty in here.", x, y+height)
return
2018-03-17 00:27:30 +01:00
}
usernameX := x + view.TimestampWidth + TimestampSenderGap
messageX := usernameX + view.widestSender + SenderMessageGap
separatorX := usernameX + view.widestSender + SenderSeparatorGap
2018-03-17 00:27:30 +01:00
2018-05-22 23:44:29 +02:00
bareMode := view.parent.parent.bareMessages
if bareMode {
messageX = x
}
2018-04-15 13:03:05 +02:00
indexOffset := view.getIndexOffset(screen, height, messageX)
2018-03-22 22:40:26 +01:00
if len(view.textBuffer) != len(view.metaBuffer) {
debug.Printf("Unexpected text/meta buffer length mismatch: %d != %d.", len(view.textBuffer), len(view.metaBuffer))
return
}
2018-03-22 22:40:26 +01:00
2018-04-15 13:03:05 +02:00
scrollBarHeight, scrollBarPos := view.calculateScrollBar(height)
var prevMeta ifc.MessageMeta
firstLine := true
2018-03-26 13:31:44 +02:00
skippedLines := 0
2018-03-20 11:16:32 +01:00
for line := 0; line < height; line++ {
index := indexOffset + line
if index < 0 {
2018-03-26 13:31:44 +02:00
skippedLines++
2018-03-20 11:16:32 +01:00
continue
} else if index >= view.TotalHeight() {
2018-03-20 11:16:32 +01:00
break
2018-03-17 00:27:30 +01:00
}
2018-03-26 13:31:44 +02:00
showScrollbar := line-skippedLines >= scrollBarPos-scrollBarHeight && line-skippedLines < scrollBarPos
isTop := firstLine && view.ScrollOffset+height >= view.TotalHeight()
2018-03-26 13:31:44 +02:00
isBottom := line == height-1 && view.ScrollOffset == 0
borderChar, borderStyle := getScrollbarStyle(showScrollbar, isTop, isBottom)
firstLine = false
2018-03-26 13:31:44 +02:00
if !bareMode {
screen.SetContent(separatorX, y+line, borderChar, nil, borderStyle)
}
2018-03-20 11:16:32 +01:00
text, meta := view.textBuffer[index], view.metaBuffer[index]
if meta != prevMeta {
if len(meta.FormatTime()) > 0 {
widget.WriteLineSimpleColor(screen, meta.FormatTime(), x, y+line, meta.TimestampColor())
2018-03-20 12:01:59 +01:00
}
if !bareMode && (prevMeta == nil || meta.Sender() != prevMeta.Sender()) {
widget.WriteLineColor(
screen, tview.AlignRight, meta.Sender(),
2018-03-25 13:21:59 +02:00
usernameX, y+line, view.widestSender,
meta.SenderColor())
2018-03-17 00:27:30 +01:00
}
2018-03-20 11:16:32 +01:00
prevMeta = meta
2018-03-17 00:27:30 +01:00
}
text.Draw(screen, messageX, y+line)
2018-03-17 00:27:30 +01:00
}
}