gomuks/ui/room-view.go

382 lines
11 KiB
Go
Raw Normal View History

2018-03-15 18:45:52 +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-15 18:45:52 +01:00
import (
"fmt"
2018-11-13 23:00:35 +01:00
"maunium.net/go/mautrix"
2018-03-22 18:51:20 +01:00
"path/filepath"
2018-04-21 18:41:19 +02:00
"sort"
2018-03-22 20:44:46 +01:00
"strconv"
2018-03-15 18:45:52 +01:00
"strings"
"time"
2018-03-15 18:45:52 +01:00
2018-04-21 18:41:19 +02:00
"github.com/mattn/go-runewidth"
2018-06-01 23:44:21 +02:00
"maunium.net/go/gomuks/config"
"maunium.net/go/gomuks/interface"
2018-04-21 18:41:19 +02:00
"maunium.net/go/gomuks/lib/util"
2018-03-22 22:46:43 +01:00
"maunium.net/go/gomuks/matrix/rooms"
"maunium.net/go/gomuks/ui/messages"
"maunium.net/go/gomuks/ui/widget"
"maunium.net/go/tcell"
2018-03-15 18:45:52 +01:00
"maunium.net/go/tview"
)
type RoomView struct {
*tview.Box
topic *tview.TextView
2018-03-17 00:27:30 +01:00
content *MessageView
2018-03-15 18:45:52 +01:00
status *tview.TextView
2018-03-15 19:33:01 +01:00
userList *tview.TextView
ulBorder *widget.Border
input *widget.AdvancedInputField
2018-03-18 20:24:03 +01:00
Room *rooms.Room
2018-04-21 18:41:19 +02:00
2018-04-22 20:05:42 +02:00
parent *MainView
2018-06-01 23:43:56 +02:00
config *config.Config
2018-04-22 20:05:42 +02:00
2018-04-21 18:41:19 +02:00
typing []string
2018-04-22 20:05:42 +02:00
2018-04-21 18:41:19 +02:00
completions struct {
list []string
textCache string
time time.Time
}
2018-03-15 19:33:01 +01:00
}
2018-04-22 20:05:42 +02:00
func NewRoomView(parent *MainView, room *rooms.Room) *RoomView {
2018-03-15 18:45:52 +01:00
view := &RoomView{
2018-03-22 16:36:06 +01:00
Box: tview.NewBox(),
topic: tview.NewTextView(),
status: tview.NewTextView(),
userList: tview.NewTextView(),
ulBorder: widget.NewBorder(),
input: widget.NewAdvancedInputField(),
2018-03-22 16:36:06 +01:00
Room: room,
2018-04-22 20:05:42 +02:00
parent: parent,
2018-06-01 23:43:56 +02:00
config: parent.config,
2018-03-15 18:45:52 +01:00
}
2018-04-14 14:33:20 +02:00
view.content = NewMessageView(view)
2018-03-22 15:44:24 +01:00
view.input.
SetFieldBackgroundColor(tcell.ColorDefault).
SetPlaceholder("Send a message...").
2018-04-21 18:41:19 +02:00
SetPlaceholderExtColor(tcell.ColorGray).
SetTabCompleteFunc(view.InputTabComplete)
2018-03-22 15:44:24 +01:00
2018-03-15 18:45:52 +01:00
view.topic.
2018-03-16 15:24:11 +01:00
SetText(strings.Replace(room.GetTopic(), "\n", " ", -1)).
2018-03-15 18:45:52 +01:00
SetBackgroundColor(tcell.ColorDarkGreen)
2018-03-22 15:44:24 +01:00
2018-03-15 18:45:52 +01:00
view.status.SetBackgroundColor(tcell.ColorDimGray)
2018-03-22 15:44:24 +01:00
2018-03-26 21:03:30 +02:00
view.userList.
SetDynamicColors(true).
SetWrap(false)
2018-03-22 15:44:24 +01:00
return view
}
2018-03-22 18:51:20 +01:00
func (view *RoomView) logPath(dir string) string {
return filepath.Join(dir, fmt.Sprintf("%s.gmxlog", view.Room.ID))
}
func (view *RoomView) SaveHistory(dir string) error {
return view.MessageView().SaveHistory(view.logPath(dir))
}
func (view *RoomView) LoadHistory(matrix ifc.MatrixContainer, dir string) (int, error) {
return view.MessageView().LoadHistory(matrix, view.logPath(dir))
2018-03-22 18:51:20 +01:00
}
2018-03-22 15:44:24 +01:00
func (view *RoomView) SetInputCapture(fn func(room *RoomView, event *tcell.EventKey) *tcell.EventKey) *RoomView {
view.input.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
return fn(view, event)
})
return view
}
func (view *RoomView) SetMouseCapture(fn func(room *RoomView, event *tcell.EventMouse) *tcell.EventMouse) *RoomView {
view.input.SetMouseCapture(func(event *tcell.EventMouse) *tcell.EventMouse {
return fn(view, event)
})
return view
}
2018-03-22 15:44:24 +01:00
func (view *RoomView) SetInputSubmitFunc(fn func(room *RoomView, text string)) *RoomView {
view.input.SetDoneFunc(func(key tcell.Key) {
if key == tcell.KeyEnter {
fn(view, view.input.GetText())
}
})
return view
}
func (view *RoomView) SetInputChangedFunc(fn func(room *RoomView, text string)) *RoomView {
view.input.SetChangedFunc(func(text string) {
fn(view, text)
})
return view
}
func (view *RoomView) SetInputText(newText string) *RoomView {
view.input.SetText(newText)
2018-03-15 18:45:52 +01:00
return view
}
2018-03-22 15:44:24 +01:00
func (view *RoomView) GetInputText() string {
return view.input.GetText()
}
func (view *RoomView) GetInputField() *widget.AdvancedInputField {
2018-03-22 15:44:24 +01:00
return view.input
}
func (view *RoomView) Focus(delegate func(p tview.Primitive)) {
delegate(view.input)
}
2018-04-21 18:41:19 +02:00
func (view *RoomView) GetStatus() string {
var buf strings.Builder
if len(view.completions.list) > 0 {
2018-06-01 23:44:21 +02:00
if view.completions.textCache != view.input.GetText() || view.completions.time.Add(10*time.Second).Before(time.Now()) {
2018-04-21 18:41:19 +02:00
view.completions.list = []string{}
} else {
buf.WriteString(strings.Join(view.completions.list, ", "))
buf.WriteString(" - ")
}
}
if len(view.typing) == 1 {
buf.WriteString("Typing: " + view.typing[0])
buf.WriteString(" - ")
} else if len(view.typing) > 1 {
fmt.Fprintf(&buf,
"Typing: %s and %s - ",
strings.Join(view.typing[:len(view.typing)-1], ", "), view.typing[len(view.typing)-1])
}
return strings.TrimSuffix(buf.String(), " - ")
}
2018-03-15 18:45:52 +01:00
func (view *RoomView) Draw(screen tcell.Screen) {
x, y, width, height := view.GetRect()
if width <= 0 || height <= 0 {
return
}
2018-03-17 00:27:30 +01:00
// Constants defining the size of the room view grid.
const (
UserListBorderWidth = 1
UserListWidth = 20
StaticHorizontalSpace = UserListBorderWidth + UserListWidth
TopicBarHeight = 1
StatusBarHeight = 1
InputBarHeight = 1
StaticVerticalSpace = TopicBarHeight + StatusBarHeight + InputBarHeight
)
// Calculate actual grid based on view rectangle and constants defined above.
var (
contentHeight = height - StaticVerticalSpace
contentWidth = width - StaticHorizontalSpace
userListBorderColumn = x + contentWidth
userListColumn = userListBorderColumn + UserListBorderWidth
topicRow = y
contentRow = topicRow + TopicBarHeight
statusRow = contentRow + contentHeight
inputRow = statusRow + StatusBarHeight
)
2018-06-01 23:43:56 +02:00
if view.config.Preferences.HideUserList {
contentWidth = width
}
// Update the rectangles of all the children.
view.topic.SetRect(x, topicRow, width, TopicBarHeight)
view.content.SetRect(x, contentRow, contentWidth, contentHeight)
view.status.SetRect(x, statusRow, width, StatusBarHeight)
2018-06-01 23:43:56 +02:00
if !view.config.Preferences.HideUserList && userListColumn > x {
view.userList.SetRect(userListColumn, contentRow, UserListWidth, contentHeight)
view.ulBorder.SetRect(userListBorderColumn, contentRow, UserListBorderWidth, contentHeight)
}
view.input.SetRect(x, inputRow, width, InputBarHeight)
2018-03-15 18:45:52 +01:00
// Draw everything
view.Box.Draw(screen)
2018-03-15 18:45:52 +01:00
view.topic.Draw(screen)
view.content.Draw(screen)
2018-04-21 18:41:19 +02:00
view.status.SetText(view.GetStatus())
2018-03-15 18:45:52 +01:00
view.status.Draw(screen)
2018-03-22 15:44:24 +01:00
view.input.Draw(screen)
2018-06-01 23:43:56 +02:00
if !view.config.Preferences.HideUserList {
view.ulBorder.Draw(screen)
view.userList.Draw(screen)
}
2018-03-15 18:45:52 +01:00
}
2018-04-21 18:41:19 +02:00
func (view *RoomView) SetCompletions(completions []string) {
view.completions.list = completions
view.completions.textCache = view.input.GetText()
view.completions.time = time.Now()
2018-03-18 20:24:03 +01:00
}
2018-03-15 18:45:52 +01:00
func (view *RoomView) SetTyping(users []string) {
2018-03-16 15:24:11 +01:00
for index, user := range users {
2018-03-18 20:24:03 +01:00
member := view.Room.GetMember(user)
2018-03-16 15:24:11 +01:00
if member != nil {
users[index] = member.Displayname
2018-03-16 15:24:11 +01:00
}
}
2018-04-21 18:41:19 +02:00
view.typing = users
}
type completion struct {
displayName string
id string
2018-03-15 18:45:52 +01:00
}
2018-04-22 19:13:57 +02:00
func (view *RoomView) autocompleteUser(existingText string) (completions []completion) {
textWithoutPrefix := strings.TrimPrefix(existingText, "@")
for userID, user := range view.Room.GetMembers() {
if user.Displayname == textWithoutPrefix || userID == existingText {
2018-04-21 18:41:19 +02:00
// Exact match, return that.
return []completion{{user.Displayname, userID}}
2018-04-21 18:41:19 +02:00
}
if strings.HasPrefix(user.Displayname, textWithoutPrefix) || strings.HasPrefix(userID, existingText) {
completions = append(completions, completion{user.Displayname, userID})
}
}
return
}
2018-04-22 19:13:57 +02:00
func (view *RoomView) autocompleteRoom(existingText string) (completions []completion) {
2018-04-22 20:05:42 +02:00
for _, room := range view.parent.rooms {
alias := room.Room.GetCanonicalAlias()
if alias == existingText {
// Exact match, return that.
return []completion{{alias, room.Room.ID}}
}
if strings.HasPrefix(alias, existingText) {
completions = append(completions, completion{alias, room.Room.ID})
continue
}
}
return
2018-04-21 18:41:19 +02:00
}
func (view *RoomView) InputTabComplete(text string, cursorOffset int) {
str := runewidth.Truncate(text, cursorOffset, "")
word := findWordToTabComplete(str)
startIndex := len(str) - len(word)
var strCompletions []string
var strCompletion string
2018-04-22 19:13:57 +02:00
completions := view.autocompleteUser(word)
completions = append(completions, view.autocompleteRoom(word)...)
2018-04-21 18:41:19 +02:00
if len(completions) == 1 {
completion := completions[0]
strCompletion = fmt.Sprintf("[%s](https://matrix.to/#/%s)", completion.displayName, completion.id)
if startIndex == 0 {
strCompletion = strCompletion + ": "
}
} else if len(completions) > 1 {
for _, completion := range completions {
strCompletions = append(strCompletions, completion.displayName)
}
}
if len(strCompletions) > 0 {
strCompletion = util.LongestCommonPrefix(strCompletions)
sort.Sort(sort.StringSlice(strCompletions))
}
if len(strCompletion) > 0 {
text = str[0:startIndex] + strCompletion + text[len(str):]
}
view.input.SetTextAndMoveCursor(text)
view.SetCompletions(strCompletions)
}
2018-03-17 00:27:30 +01:00
func (view *RoomView) MessageView() *MessageView {
return view.content
}
2018-03-15 19:33:01 +01:00
func (view *RoomView) MxRoom() *rooms.Room {
return view.Room
}
2018-03-16 15:24:11 +01:00
func (view *RoomView) UpdateUserList() {
var joined strings.Builder
var invited strings.Builder
for userID, user := range view.Room.GetMembers() {
2018-03-16 15:24:11 +01:00
if user.Membership == "join" {
joined.WriteString(widget.AddColor(user.Displayname, widget.GetHashColorName(userID)))
joined.WriteRune('\n')
} else if user.Membership == "invite" {
invited.WriteString(widget.AddColor(user.Displayname, widget.GetHashColorName(userID)))
invited.WriteRune('\n')
2018-03-16 15:24:11 +01:00
}
}
view.userList.Clear()
fmt.Fprintf(view.userList, "%s\n", joined.String())
if invited.Len() > 0 {
fmt.Fprintf(view.userList, "\nInvited:\n%s", invited.String())
}
}
2018-11-13 23:00:35 +01:00
func (view *RoomView) newUIMessage(id, sender string, msgtype mautrix.MessageType, text string, timestamp time.Time) messages.UIMessage {
2018-03-18 20:24:03 +01:00
member := view.Room.GetMember(sender)
displayname := sender
if member != nil {
displayname = member.Displayname
}
msg := messages.NewTextMessage(id, sender, displayname, msgtype, text, timestamp)
return msg
2018-03-22 20:44:46 +01:00
}
2018-11-13 23:00:35 +01:00
func (view *RoomView) NewTempMessage(msgtype mautrix.MessageType, text string) ifc.Message {
2018-03-22 20:44:46 +01:00
now := time.Now()
id := strconv.FormatInt(now.UnixNano(), 10)
sender := ""
if ownerMember := view.Room.GetMember(view.Room.GetSessionOwner()); ownerMember != nil {
sender = ownerMember.Displayname
}
message := view.newUIMessage(id, sender, msgtype, text, now)
message.SetState(ifc.MessageStateSending)
view.AddMessage(message, ifc.AppendMessage)
2018-03-22 20:44:46 +01:00
return message
}
func (view *RoomView) AddServiceMessage(text string) {
message := view.newUIMessage(view.parent.matrix.Client().TxnID(), "*", "gomuks.service", text, time.Now())
message.SetIsService(true)
view.AddMessage(message, ifc.AppendMessage)
}
func (view *RoomView) AddMessage(message ifc.Message, direction ifc.MessageDirection) {
view.content.AddMessage(message, direction)
2018-03-15 18:45:52 +01:00
}