gomuks/ui/view-main.go

529 lines
14 KiB
Go
Raw Normal View History

2018-03-13 20:58:43 +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/>.
2018-03-18 20:24:03 +01:00
package ui
2018-03-13 20:58:43 +01:00
import (
2018-03-17 13:32:01 +01:00
"fmt"
2018-03-13 20:58:43 +01:00
"strings"
"time"
2018-03-17 13:32:01 +01:00
"unicode"
2018-03-13 20:58:43 +01:00
2018-03-15 17:25:16 +01:00
"maunium.net/go/gomatrix"
2018-03-18 20:24:03 +01:00
"maunium.net/go/gomuks/config"
"maunium.net/go/gomuks/debug"
2018-03-18 20:24:03 +01:00
"maunium.net/go/gomuks/interface"
"maunium.net/go/gomuks/lib/notification"
"maunium.net/go/gomuks/matrix/pushrules"
"maunium.net/go/gomuks/matrix/rooms"
"maunium.net/go/gomuks/ui/messages/parser"
2018-03-18 20:24:03 +01:00
"maunium.net/go/gomuks/ui/widget"
"maunium.net/go/tcell"
2018-03-14 21:19:26 +01:00
"maunium.net/go/tview"
2018-03-13 20:58:43 +01:00
)
2018-03-15 19:53:04 +01:00
type MainView struct {
*tview.Flex
2018-03-15 19:53:04 +01:00
roomList *RoomList
roomView *tview.Pages
rooms map[string]*RoomView
2018-03-15 19:53:04 +01:00
lastFocusTime time.Time
2018-03-18 20:24:03 +01:00
matrix ifc.MatrixContainer
gmx ifc.Gomuks
config *config.Config
2018-03-15 19:53:04 +01:00
parent *GomuksUI
}
2018-03-15 20:28:21 +01:00
func (ui *GomuksUI) NewMainView() tview.Primitive {
mainView := &MainView{
Flex: tview.NewFlex(),
roomList: NewRoomList(),
2018-03-15 19:53:04 +01:00
roomView: tview.NewPages(),
rooms: make(map[string]*RoomView),
2018-03-15 19:53:04 +01:00
2018-03-23 13:44:36 +01:00
matrix: ui.gmx.Matrix(),
2018-03-15 19:53:04 +01:00
gmx: ui.gmx,
2018-03-18 20:24:03 +01:00
config: ui.gmx.Config(),
2018-03-15 19:53:04 +01:00
parent: ui,
}
mainView.SetDirection(tview.FlexColumn)
mainView.AddItem(mainView.roomList, 25, 0, false)
mainView.AddItem(widget.NewBorder(), 1, 0, false)
mainView.AddItem(mainView.roomView, 0, 1, true)
2018-04-25 06:01:00 +02:00
mainView.BumpFocus()
2018-03-13 20:58:43 +01:00
2018-03-15 20:28:21 +01:00
ui.mainView = mainView
return mainView
2018-03-13 20:58:43 +01:00
}
func (view *MainView) BumpFocus() {
view.lastFocusTime = time.Now()
}
func (view *MainView) InputChanged(roomView *RoomView, text string) {
2018-03-15 20:28:21 +01:00
if len(text) == 0 {
2018-03-22 15:44:24 +01:00
go view.matrix.SendTyping(roomView.Room.ID, false)
2018-03-15 20:28:21 +01:00
} else if text[0] != '/' {
2018-03-22 15:44:24 +01:00
go view.matrix.SendTyping(roomView.Room.ID, true)
2018-03-15 20:28:21 +01:00
}
2018-03-15 19:53:04 +01:00
}
2018-03-17 13:32:01 +01:00
func findWordToTabComplete(text string) string {
output := ""
runes := []rune(text)
for i := len(runes) - 1; i >= 0; i-- {
if unicode.IsSpace(runes[i]) {
break
}
output = string(runes[i]) + output
}
return output
}
func (view *MainView) InputSubmit(roomView *RoomView, text string) {
if len(text) == 0 {
return
} else if text[0] == '/' {
args := strings.SplitN(text, " ", 2)
command := strings.ToLower(args[0])
args = args[1:]
2018-03-22 20:44:46 +01:00
go view.HandleCommand(roomView, command, args)
} else {
2018-03-22 20:44:46 +01:00
view.SendMessage(roomView, text)
}
2018-03-22 15:44:24 +01:00
roomView.SetInputText("")
}
func (view *MainView) SendMessage(roomView *RoomView, text string) {
2018-03-22 20:44:46 +01:00
tempMessage := roomView.NewTempMessage("m.text", text)
go view.sendTempMessage(roomView, tempMessage, text)
2018-03-22 20:44:46 +01:00
}
func (view *MainView) sendTempMessage(roomView *RoomView, tempMessage ifc.Message, text string) {
defer debug.Recover()
2018-05-10 14:47:24 +02:00
debug.Print("Sending message", tempMessage.Type(), text)
eventID, err := view.matrix.SendMarkdownMessage(roomView.Room.ID, tempMessage.Type(), text)
2018-03-22 20:44:46 +01:00
if err != nil {
tempMessage.SetState(ifc.MessageStateFailed)
if httpErr, ok := err.(gomatrix.HTTPError); ok {
if respErr, ok := httpErr.WrappedError.(gomatrix.RespError); ok {
// Show shorter version if available
err = respErr
}
}
2018-04-21 18:41:19 +02:00
roomView.AddServiceMessage(fmt.Sprintf("Failed to send message: %v", err))
view.parent.Render()
2018-03-22 20:44:46 +01:00
} else {
2018-05-10 14:47:24 +02:00
debug.Print("Event ID received:", eventID)
2018-03-22 20:44:46 +01:00
roomView.MessageView().UpdateMessageID(tempMessage, eventID)
}
2018-03-15 19:53:04 +01:00
}
func (view *MainView) HandleCommand(roomView *RoomView, command string, args []string) {
defer debug.Recover()
2018-03-18 20:24:03 +01:00
debug.Print("Handling command", command, args)
2018-03-13 20:58:43 +01:00
switch command {
2018-03-22 20:44:46 +01:00
case "/me":
text := strings.Join(args, " ")
tempMessage := roomView.NewTempMessage("m.emote", text)
go view.sendTempMessage(roomView, tempMessage, text)
2018-03-22 20:44:46 +01:00
view.parent.Render()
2018-03-14 23:14:39 +01:00
case "/quit":
2018-03-15 19:53:04 +01:00
view.gmx.Stop()
2018-03-14 23:14:39 +01:00
case "/clearcache":
2018-03-22 18:51:20 +01:00
view.config.Clear()
2018-03-15 19:53:04 +01:00
view.gmx.Stop()
case "/panic":
panic("This is a test panic.")
2018-04-13 23:34:25 +02:00
case "/part", "/leave":
err := view.matrix.LeaveRoom(roomView.Room.ID)
debug.Print("Leave room error:", err)
if err == nil {
view.RemoveRoom(roomView.Room)
}
2018-03-14 23:14:39 +01:00
case "/join":
2018-03-13 20:58:43 +01:00
if len(args) == 0 {
roomView.AddServiceMessage("Usage: /join <room>")
2018-03-15 19:53:04 +01:00
break
2018-03-13 20:58:43 +01:00
}
2018-05-10 19:07:24 +02:00
identifer := args[0]
server := ""
if len(args) > 1 {
server = args[1]
}
room, err := view.matrix.JoinRoom(identifer, server)
debug.Print("Join room error:", err)
if err == nil {
view.AddRoom(room)
}
2018-05-10 14:47:24 +02:00
case "/logout":
view.matrix.Logout()
2018-03-16 15:24:11 +01:00
default:
roomView.AddServiceMessage("Unknown command.")
2018-03-13 20:58:43 +01:00
}
}
func (view *MainView) KeyEventHandler(roomView *RoomView, key *tcell.EventKey) *tcell.EventKey {
view.BumpFocus()
2018-03-17 00:27:30 +01:00
k := key.Key()
2018-03-20 11:16:32 +01:00
if key.Modifiers() == tcell.ModCtrl || key.Modifiers() == tcell.ModAlt {
2018-03-25 13:21:59 +02:00
switch k {
case tcell.KeyDown:
view.SwitchRoom(view.roomList.Next())
2018-03-25 13:21:59 +02:00
case tcell.KeyUp:
view.SwitchRoom(view.roomList.Previous())
2018-03-25 13:21:59 +02:00
default:
2018-03-14 21:19:26 +01:00
return key
2018-03-13 20:58:43 +01:00
}
} else if k == tcell.KeyPgUp || k == tcell.KeyPgDn || k == tcell.KeyUp || k == tcell.KeyDown || k == tcell.KeyEnd || k == tcell.KeyHome {
2018-03-22 15:44:24 +01:00
msgView := roomView.MessageView()
if msgView.IsAtTop() && (k == tcell.KeyPgUp || k == tcell.KeyUp) {
go view.LoadHistory(roomView.Room.ID)
}
switch k {
case tcell.KeyPgUp:
msgView.AddScrollOffset(msgView.Height() / 2)
case tcell.KeyPgDn:
msgView.AddScrollOffset(-msgView.Height() / 2)
case tcell.KeyUp:
msgView.AddScrollOffset(1)
case tcell.KeyDown:
msgView.AddScrollOffset(-1)
case tcell.KeyHome:
msgView.AddScrollOffset(msgView.TotalHeight())
case tcell.KeyEnd:
msgView.AddScrollOffset(-msgView.TotalHeight())
2018-03-17 00:27:30 +01:00
}
2018-03-13 20:58:43 +01:00
} else {
return key
}
return nil
}
const WheelScrollOffsetDiff = 3
func isInArea(x, y int, p tview.Primitive) bool {
rx, ry, rw, rh := p.GetRect()
return x >= rx && y >= ry && x < rx+rw && y < ry+rh
}
func (view *MainView) MouseEventHandler(roomView *RoomView, event *tcell.EventMouse) *tcell.EventMouse {
if event.Buttons() == tcell.ButtonNone || event.HasMotion() {
return event
}
view.BumpFocus()
msgView := roomView.MessageView()
x, y := event.Position()
switch {
case isInArea(x, y, msgView):
mx, my, _, _ := msgView.GetRect()
switch event.Buttons() {
case tcell.WheelUp:
if msgView.IsAtTop() {
go view.LoadHistory(roomView.Room.ID)
} else {
msgView.AddScrollOffset(WheelScrollOffsetDiff)
2018-03-26 13:31:44 +02:00
view.parent.Render()
}
case tcell.WheelDown:
msgView.AddScrollOffset(-WheelScrollOffsetDiff)
2018-03-26 13:31:44 +02:00
view.parent.Render()
if msgView.ScrollOffset == 0 {
roomView.Room.MarkRead()
}
default:
2018-04-14 14:33:20 +02:00
if msgView.HandleClick(x-mx, y-my, event.Buttons()) {
view.parent.Render()
}
}
case isInArea(x, y, view.roomList):
switch event.Buttons() {
case tcell.WheelUp:
view.roomList.AddScrollOffset(-WheelScrollOffsetDiff)
view.parent.Render()
case tcell.WheelDown:
view.roomList.AddScrollOffset(WheelScrollOffsetDiff)
view.parent.Render()
case tcell.Button1:
_, rly, _, _ := msgView.GetRect()
line := y - rly + 1
switchToTag, switchToRoom := view.roomList.HandleClick(x, line, event.Modifiers() == tcell.ModCtrl)
if switchToRoom != nil {
view.SwitchRoom(switchToTag, switchToRoom)
} else {
view.parent.Render()
}
}
default:
debug.Print("Unhandled mouse event:", event.Buttons(), event.Modifiers(), x, y)
}
return event
}
2018-04-24 01:13:17 +02:00
func (view *MainView) SwitchRoom(tag string, room *rooms.Room) {
if room == nil {
return
}
view.roomView.SwitchToPage(room.ID)
roomView := view.rooms[room.ID]
if roomView.MessageView().ScrollOffset == 0 {
roomView.Room.MarkRead()
}
2018-04-24 01:13:17 +02:00
view.roomList.SetSelected(tag, room)
view.parent.app.SetFocus(view)
2018-03-15 19:53:04 +01:00
view.parent.Render()
}
2018-03-22 15:44:24 +01:00
func (view *MainView) Focus(delegate func(p tview.Primitive)) {
2018-04-24 01:13:17 +02:00
room := view.roomList.SelectedRoom()
if room != nil {
roomView, ok := view.rooms[room.ID]
if ok {
delegate(roomView)
}
2018-03-22 15:44:24 +01:00
}
}
2018-03-22 18:51:20 +01:00
func (view *MainView) SaveAllHistory() {
for _, room := range view.rooms {
err := room.SaveHistory(view.config.HistoryDir)
if err != nil {
debug.Printf("Failed to save history of %s: %v", room.Room.GetTitle(), err)
}
}
}
func (view *MainView) addRoomPage(room *rooms.Room) {
if !view.roomView.HasPage(room.ID) {
roomView := NewRoomView(view, room).
2018-03-22 15:44:24 +01:00
SetInputSubmitFunc(view.InputSubmit).
SetInputChangedFunc(view.InputChanged).
SetInputCapture(view.KeyEventHandler).
SetMouseCapture(view.MouseEventHandler)
view.rooms[room.ID] = roomView
view.roomView.AddPage(room.ID, roomView, true, false)
2018-03-16 15:24:11 +01:00
roomView.UpdateUserList()
2018-03-22 18:51:20 +01:00
_, err := roomView.LoadHistory(view.matrix, view.config.HistoryDir)
2018-03-22 18:51:20 +01:00
if err != nil {
debug.Printf("Failed to load history of %s: %v", roomView.Room.GetTitle(), err)
}
2018-03-16 15:24:11 +01:00
}
}
func (view *MainView) GetRoom(roomID string) ifc.RoomView {
2018-04-24 01:13:17 +02:00
room, ok := view.rooms[roomID]
if !ok {
view.AddRoom(view.matrix.GetRoom(roomID))
room, ok := view.rooms[roomID]
if !ok {
return nil
}
2018-04-24 01:13:17 +02:00
return room
}
return room
}
func (view *MainView) AddRoom(room *rooms.Room) {
if view.roomList.Contains(room.ID) {
debug.Print("Add aborted", room.ID)
2018-03-16 15:24:11 +01:00
return
}
debug.Print("Adding", room.ID)
view.roomList.Add(room)
view.addRoomPage(room)
if !view.roomList.HasSelected() {
view.SwitchRoom(view.roomList.First())
}
2018-03-16 15:24:11 +01:00
}
func (view *MainView) RemoveRoom(room *rooms.Room) {
roomView := view.GetRoom(room.ID)
2018-03-25 13:21:59 +02:00
if roomView == nil {
debug.Print("Remove aborted", room.ID)
2018-03-16 15:24:11 +01:00
return
}
debug.Print("Removing", room.ID)
view.roomList.Remove(room)
view.SwitchRoom(view.roomList.Selected())
view.roomView.RemovePage(room.ID)
delete(view.rooms, room.ID)
2018-03-20 11:16:32 +01:00
view.parent.Render()
2018-03-16 15:24:11 +01:00
}
2018-04-24 15:51:40 +02:00
func (view *MainView) SetRooms(rooms map[string]*rooms.Room) {
2018-03-15 19:53:04 +01:00
view.roomList.Clear()
2018-03-16 15:24:11 +01:00
view.roomView.Clear()
view.rooms = make(map[string]*RoomView)
2018-04-24 15:51:40 +02:00
for _, room := range rooms {
if room.HasLeft {
continue
}
view.roomList.Add(room)
view.addRoomPage(room)
2018-04-24 01:13:17 +02:00
}
view.SwitchRoom(view.roomList.First())
}
func (view *MainView) UpdateTags(room *rooms.Room, newTags []rooms.RoomTag) {
if len(newTags) == 0 {
for _, tag := range room.RawTags {
view.roomList.RemoveFromTag(tag.Tag, room)
}
view.roomList.AddToTag(rooms.RoomTag{Tag: "", Order: "0.5"}, room)
2018-04-24 01:13:17 +02:00
} else if len(room.RawTags) == 0 {
view.roomList.RemoveFromTag("", room)
for _, tag := range newTags {
view.roomList.AddToTag(tag, room)
2018-04-24 01:13:17 +02:00
}
} else {
NewTags:
for _, newTag := range newTags {
for _, oldTag := range room.RawTags {
if newTag.Tag == oldTag.Tag {
continue NewTags
}
}
view.roomList.AddToTag(newTag, room)
2018-04-24 01:13:17 +02:00
}
OldTags:
for _, oldTag := range room.RawTags {
for _, newTag := range newTags {
if newTag.Tag == oldTag.Tag {
continue OldTags
}
}
view.roomList.RemoveFromTag(oldTag.Tag, room)
}
2018-03-13 20:58:43 +01:00
}
2018-04-24 01:13:17 +02:00
room.RawTags = newTags
2018-03-13 20:58:43 +01:00
}
2018-03-15 19:53:04 +01:00
func (view *MainView) SetTyping(room string, users []string) {
roomView, ok := view.rooms[room]
2018-03-14 23:14:39 +01:00
if ok {
2018-03-15 18:45:52 +01:00
roomView.SetTyping(users)
2018-03-15 19:53:04 +01:00
view.parent.Render()
2018-03-14 23:14:39 +01:00
}
}
2018-03-26 17:04:10 +02:00
func sendNotification(room *rooms.Room, sender, text string, critical, sound bool) {
if room.GetTitle() != sender {
sender = fmt.Sprintf("%s (%s)", sender, room.GetTitle())
}
2018-04-25 06:01:00 +02:00
debug.Printf("Sending notification with body \"%s\" from %s in room ID %s (critical=%v, sound=%v)", text, sender, room.ID, critical, sound)
2018-03-26 17:04:10 +02:00
notification.Send(sender, text, critical, sound)
}
func (view *MainView) NotifyMessage(room *rooms.Room, message ifc.Message, should pushrules.PushActionArrayShould) {
// Whether or not the room where the message came is the currently shown room.
2018-04-24 01:13:17 +02:00
isCurrent := room == view.roomList.SelectedRoom()
// Whether or not the terminal window is focused.
2018-04-25 06:01:00 +02:00
isFocused := time.Now().Add(-30 * time.Second).Before(view.lastFocusTime)
// Whether or not the push rules say this message should be notified about.
shouldNotify := (should.Notify || !should.NotifySpecified) && message.Sender() != view.config.Session.UserID
if !isCurrent {
// The message is not in the current room, show new message status in room list.
room.HasNewMessages = true
room.Highlighted = should.Highlight || room.Highlighted
if shouldNotify {
room.UnreadMessages++
}
}
if shouldNotify && !isFocused {
// Push rules say notify and the terminal is not focused, send desktop notification.
2018-03-26 17:04:10 +02:00
shouldPlaySound := should.PlaySound && should.SoundName == "default"
sendNotification(room, message.Sender(), message.NotificationContent(), should.Highlight, shouldPlaySound)
}
message.SetIsHighlight(should.Highlight)
view.roomList.Bump(room)
2018-03-13 20:58:43 +01:00
}
func (view *MainView) InitialSyncDone() {
view.roomList.Clear()
for _, room := range view.rooms {
view.roomList.Add(room.Room)
}
}
func (view *MainView) LoadHistory(room string) {
defer debug.Recover()
roomView := view.rooms[room]
2018-03-20 11:16:32 +01:00
batch := roomView.Room.PrevBatch
lockTime := time.Now().Unix() + 1
2018-03-22 16:36:06 +01:00
roomView.Room.LockHistory()
2018-03-20 11:16:32 +01:00
roomView.MessageView().LoadingMessages = true
defer func() {
2018-03-22 16:36:06 +01:00
roomView.Room.UnlockHistory()
2018-03-20 11:16:32 +01:00
roomView.MessageView().LoadingMessages = false
}()
// There's no clean way to try to lock a mutex, so we just check if we still
// want to continue after we get the lock. This function should always be ran
// in a goroutine, so the blocking doesn't matter.
if time.Now().Unix() >= lockTime || batch != roomView.Room.PrevBatch {
return
}
debug.Print("Fetching history for", room, "starting from", batch)
2018-03-20 11:16:32 +01:00
history, prevBatch, err := view.matrix.GetHistory(roomView.Room.ID, batch, 50)
if err != nil {
roomView.AddServiceMessage("Failed to fetch history")
2018-03-18 20:24:03 +01:00
debug.Print("Failed to fetch history for", roomView.Room.ID, err)
return
}
2018-03-20 11:16:32 +01:00
roomView.Room.PrevBatch = prevBatch
for _, evt := range history {
message := view.ParseEvent(roomView, &evt)
if message != nil {
roomView.AddMessage(message, ifc.PrependMessage)
}
}
2018-03-22 18:51:20 +01:00
err = roomView.SaveHistory(view.config.HistoryDir)
if err != nil {
2018-03-23 00:07:44 +01:00
debug.Printf("Failed to save history of %s: %v", roomView.Room.GetTitle(), err)
2018-03-22 18:51:20 +01:00
}
view.config.Session.Save()
2018-03-20 11:16:32 +01:00
view.parent.Render()
}
func (view *MainView) ParseEvent(roomView ifc.RoomView, evt *gomatrix.Event) ifc.Message {
return parser.ParseEvent(view.matrix, roomView.MxRoom(), evt)
}