2018-03-15 18:45:52 +01:00
|
|
|
// gomuks - A terminal Matrix client written in Go.
|
2019-01-17 13:13:25 +01:00
|
|
|
// Copyright (C) 2019 Tulir Asokan
|
2018-03-15 18:45:52 +01:00
|
|
|
//
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
2019-01-17 13:13:25 +01:00
|
|
|
// it under the terms of the GNU Affero General Public License as published by
|
2018-03-15 18:45:52 +01:00
|
|
|
// 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
|
2019-01-17 13:13:25 +01:00
|
|
|
// GNU Affero General Public License for more details.
|
2018-03-15 18:45:52 +01:00
|
|
|
//
|
2019-01-17 13:13:25 +01:00
|
|
|
// 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/>.
|
2018-03-15 18:45:52 +01:00
|
|
|
|
2018-04-09 22:45:54 +02:00
|
|
|
package ui
|
2018-03-15 18:45:52 +01:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2018-03-22 18:51:20 +01:00
|
|
|
"path/filepath"
|
2018-04-21 18:41:19 +02:00
|
|
|
"sort"
|
2018-03-15 18:45:52 +01:00
|
|
|
"strings"
|
2018-03-17 14:48:31 +01:00
|
|
|
"time"
|
2018-03-15 18:45:52 +01:00
|
|
|
|
2019-03-30 17:51:26 +01:00
|
|
|
"github.com/kyokomi/emoji"
|
2018-04-21 18:41:19 +02:00
|
|
|
"github.com/mattn/go-runewidth"
|
2019-01-17 13:13:25 +01:00
|
|
|
|
2019-03-26 18:57:44 +01:00
|
|
|
"maunium.net/go/gomuks/debug"
|
2019-06-17 11:27:31 +02:00
|
|
|
"maunium.net/go/gomuks/matrix/event"
|
2019-03-26 18:57:44 +01:00
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
"maunium.net/go/mauview"
|
|
|
|
|
2019-01-17 13:13:25 +01:00
|
|
|
"maunium.net/go/mautrix"
|
|
|
|
"maunium.net/go/tcell"
|
|
|
|
|
2018-06-01 23:44:21 +02:00
|
|
|
"maunium.net/go/gomuks/config"
|
2018-04-09 22:45:54 +02:00
|
|
|
"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"
|
2018-04-09 22:45:54 +02:00
|
|
|
"maunium.net/go/gomuks/ui/messages"
|
|
|
|
"maunium.net/go/gomuks/ui/widget"
|
2018-03-15 18:45:52 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
type RoomView struct {
|
2019-03-25 23:37:35 +01:00
|
|
|
topic *mauview.TextView
|
2018-03-17 00:27:30 +01:00
|
|
|
content *MessageView
|
2019-03-25 23:37:35 +01:00
|
|
|
status *mauview.TextField
|
2019-04-13 13:27:50 +02:00
|
|
|
userList *MemberList
|
2018-04-09 22:45:54 +02:00
|
|
|
ulBorder *widget.Border
|
2019-03-25 23:37:35 +01:00
|
|
|
input *mauview.InputArea
|
2018-03-18 20:24:03 +01:00
|
|
|
Room *rooms.Room
|
2018-04-21 18:41:19 +02:00
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
topicScreen *mauview.ProxyScreen
|
|
|
|
contentScreen *mauview.ProxyScreen
|
|
|
|
statusScreen *mauview.ProxyScreen
|
|
|
|
inputScreen *mauview.ProxyScreen
|
|
|
|
ulBorderScreen *mauview.ProxyScreen
|
|
|
|
ulScreen *mauview.ProxyScreen
|
|
|
|
|
2019-06-15 00:11:51 +02:00
|
|
|
userListLoaded bool
|
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
prevScreen mauview.Screen
|
|
|
|
|
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
|
|
|
|
2020-02-19 00:14:02 +01:00
|
|
|
editing *event.Event
|
|
|
|
editMoveText string
|
|
|
|
|
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{
|
2019-03-25 23:37:35 +01:00
|
|
|
topic: mauview.NewTextView(),
|
|
|
|
status: mauview.NewTextField(),
|
2019-04-13 13:27:50 +02:00
|
|
|
userList: NewMemberList(),
|
2018-04-09 22:45:54 +02:00
|
|
|
ulBorder: widget.NewBorder(),
|
2019-03-25 23:37:35 +01:00
|
|
|
input: mauview.NewInputArea(),
|
2018-03-22 16:36:06 +01:00
|
|
|
Room: room,
|
2019-03-25 23:37:35 +01:00
|
|
|
|
2019-03-26 18:57:44 +01:00
|
|
|
topicScreen: &mauview.ProxyScreen{OffsetX: 0, OffsetY: 0, Height: TopicBarHeight},
|
|
|
|
contentScreen: &mauview.ProxyScreen{OffsetX: 0, OffsetY: StatusBarHeight},
|
|
|
|
statusScreen: &mauview.ProxyScreen{OffsetX: 0, Height: StatusBarHeight},
|
|
|
|
inputScreen: &mauview.ProxyScreen{OffsetX: 0},
|
2019-03-25 23:37:35 +01:00
|
|
|
ulBorderScreen: &mauview.ProxyScreen{OffsetY: StatusBarHeight, Width: UserListBorderWidth},
|
2019-03-26 18:57:44 +01:00
|
|
|
ulScreen: &mauview.ProxyScreen{OffsetY: StatusBarHeight, Width: UserListWidth},
|
2019-03-25 23:37:35 +01:00
|
|
|
|
2019-03-26 18:57:44 +01:00
|
|
|
parent: parent,
|
|
|
|
config: parent.config,
|
2018-03-15 18:45:52 +01:00
|
|
|
}
|
2018-04-14 14:33:20 +02:00
|
|
|
view.content = NewMessageView(view)
|
2019-06-15 17:03:28 +02:00
|
|
|
view.Room.SetPreUnload(func() bool {
|
2019-06-15 16:04:08 +02:00
|
|
|
if view.parent.currentRoom == view {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
view.content.Unload()
|
|
|
|
return true
|
|
|
|
})
|
2019-06-15 17:03:28 +02:00
|
|
|
view.Room.SetPostLoad(view.loadTyping)
|
2018-03-22 15:44:24 +01:00
|
|
|
|
|
|
|
view.input.
|
2019-03-25 23:37:35 +01:00
|
|
|
SetBackgroundColor(tcell.ColorDefault).
|
2018-03-22 15:44:24 +01:00
|
|
|
SetPlaceholder("Send a message...").
|
2019-03-25 23:37:35 +01:00
|
|
|
SetPlaceholderTextColor(tcell.ColorGray).
|
2020-02-19 00:14:02 +01:00
|
|
|
SetTabCompleteFunc(view.InputTabComplete).
|
|
|
|
SetPressKeyUpAtStartFunc(view.EditPrevious).
|
|
|
|
SetPressKeyDownAtEndFunc(view.EditNext)
|
2018-03-22 15:44:24 +01:00
|
|
|
|
2018-03-15 18:45:52 +01:00
|
|
|
view.topic.
|
2019-03-26 18:57:44 +01:00
|
|
|
SetTextColor(tcell.ColorWhite).
|
|
|
|
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
|
|
|
|
|
|
|
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))
|
|
|
|
}
|
|
|
|
|
2018-03-22 15:44:24 +01:00
|
|
|
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 {
|
2019-03-25 23:37:35 +01:00
|
|
|
view.input.SetTextAndMoveCursor(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()
|
|
|
|
}
|
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
func (view *RoomView) Focus() {
|
|
|
|
view.input.Focus()
|
2018-03-22 15:44:24 +01:00
|
|
|
}
|
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
func (view *RoomView) Blur() {
|
|
|
|
view.input.Blur()
|
2018-03-22 15:44:24 +01:00
|
|
|
}
|
|
|
|
|
2018-04-21 18:41:19 +02:00
|
|
|
func (view *RoomView) GetStatus() string {
|
|
|
|
var buf strings.Builder
|
|
|
|
|
2020-02-19 00:14:02 +01:00
|
|
|
if view.editing != nil {
|
|
|
|
buf.WriteString("Editing message - ")
|
|
|
|
}
|
|
|
|
|
2018-04-21 18:41:19 +02:00
|
|
|
if len(view.completions.list) > 0 {
|
2020-02-19 00:14:02 +01: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 {
|
2019-03-25 23:37:35 +01:00
|
|
|
_, _ = fmt.Fprintf(&buf,
|
2018-04-21 18:41:19 +02:00
|
|
|
"Typing: %s and %s - ",
|
|
|
|
strings.Join(view.typing[:len(view.typing)-1], ", "), view.typing[len(view.typing)-1])
|
|
|
|
}
|
|
|
|
|
|
|
|
return strings.TrimSuffix(buf.String(), " - ")
|
|
|
|
}
|
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
// Constants defining the size of the room view grid.
|
|
|
|
const (
|
|
|
|
UserListBorderWidth = 1
|
|
|
|
UserListWidth = 20
|
|
|
|
StaticHorizontalSpace = UserListBorderWidth + UserListWidth
|
|
|
|
|
2019-03-26 18:57:44 +01:00
|
|
|
TopicBarHeight = 1
|
|
|
|
StatusBarHeight = 1
|
2019-03-25 23:37:35 +01:00
|
|
|
|
2019-03-26 18:57:44 +01:00
|
|
|
MaxInputHeight = 5
|
2019-03-25 23:37:35 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
func (view *RoomView) Draw(screen mauview.Screen) {
|
|
|
|
width, height := screen.Size()
|
2018-03-22 17:14:08 +01:00
|
|
|
if width <= 0 || height <= 0 {
|
|
|
|
return
|
|
|
|
}
|
2018-03-17 00:27:30 +01:00
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
if view.prevScreen != screen {
|
|
|
|
view.topicScreen.Parent = screen
|
|
|
|
view.contentScreen.Parent = screen
|
|
|
|
view.statusScreen.Parent = screen
|
|
|
|
view.inputScreen.Parent = screen
|
|
|
|
view.ulBorderScreen.Parent = screen
|
|
|
|
view.ulScreen.Parent = screen
|
|
|
|
view.prevScreen = screen
|
2018-03-22 17:14:08 +01:00
|
|
|
}
|
2019-03-25 23:37:35 +01:00
|
|
|
|
|
|
|
view.input.PrepareDraw(width)
|
|
|
|
inputHeight := view.input.GetTextHeight()
|
|
|
|
if inputHeight > MaxInputHeight {
|
|
|
|
inputHeight = MaxInputHeight
|
|
|
|
} else if inputHeight < 1 {
|
|
|
|
inputHeight = 1
|
|
|
|
}
|
2019-03-26 18:57:44 +01:00
|
|
|
contentHeight := height - inputHeight - TopicBarHeight - StatusBarHeight
|
|
|
|
contentWidth := width - StaticHorizontalSpace
|
|
|
|
if view.config.Preferences.HideUserList {
|
|
|
|
contentWidth = width
|
|
|
|
}
|
2019-03-25 23:37:35 +01:00
|
|
|
|
|
|
|
view.topicScreen.Width = width
|
|
|
|
view.contentScreen.Width = contentWidth
|
|
|
|
view.contentScreen.Height = contentHeight
|
|
|
|
view.statusScreen.OffsetY = view.contentScreen.YEnd()
|
|
|
|
view.statusScreen.Width = width
|
|
|
|
view.inputScreen.Width = width
|
|
|
|
view.inputScreen.OffsetY = view.statusScreen.YEnd()
|
|
|
|
view.inputScreen.Height = inputHeight
|
|
|
|
view.ulBorderScreen.OffsetX = view.contentScreen.XEnd()
|
|
|
|
view.ulBorderScreen.Height = contentHeight
|
|
|
|
view.ulScreen.OffsetX = view.ulBorderScreen.XEnd()
|
|
|
|
view.ulScreen.Height = contentHeight
|
2018-03-15 18:45:52 +01:00
|
|
|
|
2018-03-22 17:14:08 +01:00
|
|
|
// Draw everything
|
2019-03-25 23:37:35 +01:00
|
|
|
view.topic.Draw(view.topicScreen)
|
|
|
|
view.content.Draw(view.contentScreen)
|
2018-04-21 18:41:19 +02:00
|
|
|
view.status.SetText(view.GetStatus())
|
2019-03-25 23:37:35 +01:00
|
|
|
view.status.Draw(view.statusScreen)
|
|
|
|
view.input.Draw(view.inputScreen)
|
2018-06-01 23:43:56 +02:00
|
|
|
if !view.config.Preferences.HideUserList {
|
2019-03-25 23:37:35 +01:00
|
|
|
view.ulBorder.Draw(view.ulBorderScreen)
|
|
|
|
view.userList.Draw(view.ulScreen)
|
2018-05-22 21:06:48 +02:00
|
|
|
}
|
2018-03-15 18:45:52 +01:00
|
|
|
}
|
|
|
|
|
2019-03-25 23:37:35 +01:00
|
|
|
func (view *RoomView) OnKeyEvent(event mauview.KeyEvent) bool {
|
2019-03-30 17:51:26 +01:00
|
|
|
msgView := view.MessageView()
|
|
|
|
switch event.Key() {
|
|
|
|
case tcell.KeyPgUp:
|
|
|
|
if msgView.IsAtTop() {
|
|
|
|
go view.parent.LoadHistory(view.Room.ID)
|
|
|
|
}
|
|
|
|
msgView.AddScrollOffset(+msgView.Height() / 2)
|
|
|
|
return true
|
|
|
|
case tcell.KeyPgDn:
|
|
|
|
msgView.AddScrollOffset(-msgView.Height() / 2)
|
|
|
|
return true
|
|
|
|
case tcell.KeyEnter:
|
2019-04-10 00:42:27 +02:00
|
|
|
if event.Modifiers()&tcell.ModShift == 0 && event.Modifiers()&tcell.ModCtrl == 0 {
|
|
|
|
view.InputSubmit(view.input.GetText())
|
2019-03-30 17:51:26 +01:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2019-03-25 23:37:35 +01:00
|
|
|
return view.input.OnKeyEvent(event)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) OnPasteEvent(event mauview.PasteEvent) bool {
|
|
|
|
return view.input.OnPasteEvent(event)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) OnMouseEvent(event mauview.MouseEvent) bool {
|
2019-03-26 18:57:44 +01:00
|
|
|
switch {
|
|
|
|
case view.contentScreen.IsInArea(event.Position()):
|
|
|
|
return view.content.OnMouseEvent(view.contentScreen.OffsetMouseEvent(event))
|
|
|
|
case view.topicScreen.IsInArea(event.Position()):
|
|
|
|
return view.topic.OnMouseEvent(view.topicScreen.OffsetMouseEvent(event))
|
|
|
|
case view.inputScreen.IsInArea(event.Position()):
|
|
|
|
return view.input.OnMouseEvent(view.inputScreen.OffsetMouseEvent(event))
|
|
|
|
}
|
|
|
|
return false
|
2019-03-25 23:37:35 +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
|
|
|
}
|
|
|
|
|
2019-06-15 16:04:08 +02:00
|
|
|
func (view *RoomView) loadTyping() {
|
|
|
|
for index, user := range view.typing {
|
2018-03-18 20:24:03 +01:00
|
|
|
member := view.Room.GetMember(user)
|
2018-03-16 15:24:11 +01:00
|
|
|
if member != nil {
|
2019-06-15 16:04:08 +02:00
|
|
|
view.typing[index] = member.Displayname
|
2018-03-16 15:24:11 +01:00
|
|
|
}
|
|
|
|
}
|
2019-06-15 16:04:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) SetTyping(users []string) {
|
2018-04-21 18:41:19 +02:00
|
|
|
view.typing = users
|
2019-06-15 16:04:08 +02:00
|
|
|
if view.Room.Loaded() {
|
|
|
|
view.loadTyping()
|
|
|
|
}
|
2018-04-21 18:41:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
2018-04-21 19:19:43 +02:00
|
|
|
textWithoutPrefix := strings.TrimPrefix(existingText, "@")
|
2018-09-05 09:55:48 +02:00
|
|
|
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.
|
2018-09-05 09:55:48 +02:00
|
|
|
return []completion{{user.Displayname, userID}}
|
2018-04-21 18:41:19 +02:00
|
|
|
}
|
|
|
|
|
2018-09-05 09:55:48 +02:00
|
|
|
if strings.HasPrefix(user.Displayname, textWithoutPrefix) || strings.HasPrefix(userID, existingText) {
|
|
|
|
completions = append(completions, completion{user.Displayname, userID})
|
2018-03-17 14:48:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2019-03-30 17:51:26 +01:00
|
|
|
func (view *RoomView) autocompleteEmoji(word string) (completions []string) {
|
|
|
|
if len(word) == 0 || word[0] != ':' {
|
|
|
|
return
|
|
|
|
}
|
2019-06-16 18:54:54 +02:00
|
|
|
var valueCompletion1 string
|
|
|
|
var manyValues bool
|
2019-03-30 17:51:26 +01:00
|
|
|
for name, value := range emoji.CodeMap() {
|
|
|
|
if name == word {
|
|
|
|
return []string{value}
|
|
|
|
} else if strings.HasPrefix(name, word) {
|
|
|
|
completions = append(completions, name)
|
2019-06-16 18:54:54 +02:00
|
|
|
if valueCompletion1 == "" {
|
|
|
|
valueCompletion1 = value
|
|
|
|
} else if valueCompletion1 != value {
|
|
|
|
manyValues = true
|
|
|
|
}
|
2019-03-30 17:51:26 +01:00
|
|
|
}
|
|
|
|
}
|
2019-06-16 18:54:54 +02:00
|
|
|
if !manyValues && len(completions) > 0 {
|
|
|
|
return []string{emoji.CodeMap()[completions[0]]}
|
|
|
|
}
|
2019-03-30 17:51:26 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-02-19 00:14:02 +01:00
|
|
|
func (view *RoomView) SetEditing(evt *event.Event) {
|
|
|
|
if evt == nil {
|
|
|
|
view.editing = nil
|
|
|
|
view.SetInputText(view.editMoveText)
|
|
|
|
view.editMoveText = ""
|
|
|
|
} else {
|
|
|
|
if view.editing == nil {
|
|
|
|
view.editMoveText = view.GetInputText()
|
|
|
|
}
|
|
|
|
view.editing = evt
|
2020-02-19 20:27:37 +01:00
|
|
|
view.input.SetText(view.editing.Content.Body)
|
2020-02-19 00:14:02 +01:00
|
|
|
}
|
|
|
|
view.status.SetText(view.GetStatus())
|
|
|
|
}
|
|
|
|
|
2020-02-19 20:27:37 +01:00
|
|
|
func (view *RoomView) findMessageToEdit(forward bool) *event.Event {
|
2020-02-19 00:14:02 +01:00
|
|
|
currentFound := view.editing == nil
|
|
|
|
self := view.parent.matrix.Client().UserID
|
2020-02-19 20:27:37 +01:00
|
|
|
msgs := view.MessageView().messages
|
|
|
|
for i := 0; i < len(msgs); i++ {
|
|
|
|
index := i
|
|
|
|
if !forward {
|
|
|
|
index = len(msgs) - i - 1
|
|
|
|
}
|
|
|
|
evt := msgs[index]
|
2020-02-19 00:14:02 +01:00
|
|
|
if currentFound {
|
2020-02-19 20:27:37 +01:00
|
|
|
if evt.SenderID == self && evt.Event.Type == mautrix.EventMessage {
|
|
|
|
return evt.Event
|
2020-02-19 00:14:02 +01:00
|
|
|
}
|
2020-02-19 20:27:37 +01:00
|
|
|
} else if evt.EventID == view.editing.ID {
|
2020-02-19 00:14:02 +01:00
|
|
|
currentFound = true
|
|
|
|
}
|
|
|
|
}
|
2020-02-19 20:27:37 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) EditNext() {
|
|
|
|
if view.editing == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
foundEvent := view.findMessageToEdit(true)
|
2020-02-19 00:14:02 +01:00
|
|
|
view.SetEditing(foundEvent)
|
2020-02-19 20:27:37 +01:00
|
|
|
view.input.SetCursorOffset(-1)
|
2020-02-19 00:14:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) EditPrevious() {
|
2020-02-19 20:27:37 +01:00
|
|
|
foundEvent := view.findMessageToEdit(false)
|
2020-02-19 00:14:02 +01:00
|
|
|
if foundEvent != nil {
|
|
|
|
view.SetEditing(foundEvent)
|
2020-02-19 20:27:37 +01:00
|
|
|
view.input.SetCursorOffset(0)
|
2020-02-19 00:14:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-21 18:41:19 +02:00
|
|
|
func (view *RoomView) InputTabComplete(text string, cursorOffset int) {
|
2019-03-26 21:09:10 +01:00
|
|
|
debug.Print("Tab completing", cursorOffset, text)
|
2018-04-21 18:41:19 +02:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-30 17:51:26 +01:00
|
|
|
strCompletions = append(strCompletions, view.autocompleteEmoji(word)...)
|
|
|
|
|
2018-04-21 18:41:19 +02:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2019-04-10 00:04:39 +02:00
|
|
|
func (view *RoomView) InputSubmit(text string) {
|
|
|
|
if len(text) == 0 {
|
|
|
|
return
|
2020-02-19 00:14:02 +01:00
|
|
|
} else if cmd := view.parent.cmdProcessor.ParseCommand(view, text); view.editing == nil && cmd != nil {
|
2019-04-10 00:04:39 +02:00
|
|
|
go view.parent.cmdProcessor.HandleCommand(cmd)
|
|
|
|
} else {
|
|
|
|
go view.SendMessage(mautrix.MsgText, text)
|
|
|
|
}
|
2020-02-19 00:14:02 +01:00
|
|
|
view.editMoveText = ""
|
2019-04-10 00:04:39 +02:00
|
|
|
view.SetInputText("")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) SendMessage(msgtype mautrix.MessageType, text string) {
|
|
|
|
defer debug.Recover()
|
|
|
|
debug.Print("Sending message", msgtype, text, "to", view.Room.ID)
|
|
|
|
if !view.config.Preferences.DisableEmojis {
|
|
|
|
text = emoji.Sprint(text)
|
|
|
|
}
|
2020-02-19 00:14:02 +01:00
|
|
|
evt := view.parent.matrix.PrepareMarkdownMessage(view.Room.ID, msgtype, text, view.editing)
|
2019-06-15 00:11:51 +02:00
|
|
|
msg := view.parseEvent(evt)
|
2019-06-17 12:46:02 +02:00
|
|
|
view.content.AddMessage(msg, AppendMessage)
|
2020-02-19 00:14:02 +01:00
|
|
|
view.editing = nil
|
|
|
|
view.status.SetText(view.GetStatus())
|
2019-04-10 00:04:39 +02:00
|
|
|
eventID, err := view.parent.matrix.SendEvent(evt)
|
|
|
|
if err != nil {
|
2019-06-17 11:27:31 +02:00
|
|
|
msg.State = event.StateSendFail
|
2019-04-10 00:04:39 +02:00
|
|
|
// Show shorter version if available
|
|
|
|
if httpErr, ok := err.(mautrix.HTTPError); ok {
|
|
|
|
err = httpErr
|
|
|
|
if respErr := httpErr.RespError; respErr != nil {
|
|
|
|
err = respErr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
view.AddServiceMessage(fmt.Sprintf("Failed to send message: %v", err))
|
|
|
|
view.parent.parent.Render()
|
|
|
|
} else {
|
|
|
|
debug.Print("Event ID received:", eventID)
|
2019-06-15 00:11:51 +02:00
|
|
|
msg.EventID = eventID
|
2019-06-17 11:27:31 +02:00
|
|
|
msg.State = event.StateDefault
|
2019-06-15 00:11:51 +02:00
|
|
|
view.MessageView().setMessageID(msg)
|
|
|
|
view.parent.parent.Render()
|
2019-04-10 00:04:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-17 00:27:30 +01:00
|
|
|
func (view *RoomView) MessageView() *MessageView {
|
|
|
|
return view.content
|
|
|
|
}
|
2018-03-15 19:33:01 +01:00
|
|
|
|
2018-04-09 22:45:54 +02:00
|
|
|
func (view *RoomView) MxRoom() *rooms.Room {
|
|
|
|
return view.Room
|
|
|
|
}
|
|
|
|
|
2019-06-15 00:11:51 +02:00
|
|
|
func (view *RoomView) Update() {
|
|
|
|
view.topic.SetText(strings.Replace(view.Room.GetTopic(), "\n", " ", -1))
|
|
|
|
if !view.userListLoaded {
|
|
|
|
view.UpdateUserList()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-16 15:24:11 +01:00
|
|
|
func (view *RoomView) UpdateUserList() {
|
2019-04-13 13:27:50 +02:00
|
|
|
pls := &mautrix.PowerLevels{}
|
|
|
|
if plEvent := view.Room.GetStateEvent(mautrix.StatePowerLevels, ""); plEvent != nil {
|
|
|
|
pls = plEvent.Content.GetPowerLevels()
|
2018-03-17 14:48:31 +01:00
|
|
|
}
|
2019-04-13 13:27:50 +02:00
|
|
|
view.userList.Update(view.Room.GetMembers(), pls)
|
2019-06-15 00:11:51 +02:00
|
|
|
view.userListLoaded = true
|
2018-03-17 14:48:31 +01:00
|
|
|
}
|
|
|
|
|
2018-04-09 22:45:54 +02:00
|
|
|
func (view *RoomView) AddServiceMessage(text string) {
|
2019-04-10 00:04:39 +02:00
|
|
|
view.content.AddMessage(messages.NewServiceMessage(text), AppendMessage)
|
2018-04-09 22:45:54 +02:00
|
|
|
}
|
|
|
|
|
2019-06-17 11:27:31 +02:00
|
|
|
func (view *RoomView) parseEvent(evt *event.Event) *messages.UIMessage {
|
2019-04-10 20:06:19 +02:00
|
|
|
return messages.ParseEvent(view.parent.matrix, view.parent, view.Room, evt)
|
|
|
|
}
|
|
|
|
|
2019-06-17 12:46:02 +02:00
|
|
|
func (view *RoomView) AddHistoryEvent(evt *event.Event) {
|
|
|
|
if msg := view.parseEvent(evt); msg != nil {
|
|
|
|
view.content.AddMessage(msg, PrependMessage)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) AddEvent(evt *event.Event) ifc.Message {
|
|
|
|
if msg := view.parseEvent(evt); msg != nil {
|
|
|
|
view.content.AddMessage(msg, AppendMessage)
|
|
|
|
return msg
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) AddRedaction(redactedEvt *event.Event) {
|
|
|
|
view.AddEvent(redactedEvt)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (view *RoomView) AddEdit(evt *event.Event) {
|
|
|
|
if msg := view.parseEvent(evt); msg != nil {
|
|
|
|
view.content.AddMessage(msg, IgnoreMessage)
|
2019-06-15 00:11:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-10 20:06:19 +02:00
|
|
|
func (view *RoomView) GetEvent(eventID string) ifc.Message {
|
|
|
|
message, ok := view.content.messageIDs[eventID]
|
|
|
|
if !ok {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return message
|
2019-04-09 17:45:41 +02:00
|
|
|
}
|