mirror of
https://github.com/FluuxIO/go-xmpp.git
synced 2024-12-04 16:21:59 -08:00
329 lines
9.2 KiB
Go
329 lines
9.2 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/awesome-gocui/gocui"
|
|
"log"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
// Windows
|
|
chatLogWindow = "clw" // Where (received and sent) messages are logged
|
|
chatInputWindow = "iw" // Where messages are written
|
|
rawInputWindow = "rw" // Where raw stanzas are written
|
|
contactsListWindow = "cl" // Where the contacts list is shown, and contacts are selectable
|
|
menuWindow = "mw" // Where the menu is shown
|
|
|
|
// Menu options
|
|
disconnect = "Disconnect"
|
|
askServerForRoster = "Ask server for roster"
|
|
rawMode = "Switch to Send Raw Mode"
|
|
messageMode = "Switch to Send Message Mode"
|
|
contactList = "Contacts list"
|
|
backFromContacts = "<- Go back"
|
|
)
|
|
|
|
// To store names of views on top
|
|
type viewsState struct {
|
|
input string // Which input view is on top
|
|
side string // Which side view is on top
|
|
contacts []string // Contacts list
|
|
currentContact string // Contact we are currently messaging
|
|
}
|
|
|
|
var (
|
|
// Which window is on top currently on top of the other.
|
|
// This is the init setup
|
|
viewState = viewsState{
|
|
input: chatInputWindow,
|
|
side: menuWindow,
|
|
}
|
|
menuOptions = []string{contactList, rawMode, askServerForRoster, disconnect}
|
|
// Errors
|
|
servConnFail = errors.New("failed to connect to server. Check your configuration ? Exiting")
|
|
)
|
|
|
|
func setCurrentViewOnTop(g *gocui.Gui, name string) (*gocui.View, error) {
|
|
if _, err := g.SetCurrentView(name); err != nil {
|
|
return nil, err
|
|
}
|
|
return g.SetViewOnTop(name)
|
|
}
|
|
|
|
func layout(g *gocui.Gui) error {
|
|
maxX, maxY := g.Size()
|
|
|
|
if v, err := g.SetView(chatLogWindow, maxX/5, 0, maxX-1, 5*maxY/6-1, 0); err != nil {
|
|
if !gocui.IsUnknownView(err) {
|
|
return err
|
|
}
|
|
v.Title = "Chat log"
|
|
v.Wrap = true
|
|
v.Autoscroll = true
|
|
}
|
|
|
|
if v, err := g.SetView(contactsListWindow, 0, 0, maxX/5-1, 5*maxY/6-2, 0); err != nil {
|
|
if !gocui.IsUnknownView(err) {
|
|
return err
|
|
}
|
|
v.Title = "Contacts"
|
|
v.Wrap = true
|
|
v.Autoscroll = true
|
|
}
|
|
|
|
if v, err := g.SetView(menuWindow, 0, 0, maxX/5-1, 5*maxY/6-2, 0); err != nil {
|
|
if !gocui.IsUnknownView(err) {
|
|
return err
|
|
}
|
|
v.Title = "Menu"
|
|
v.Wrap = true
|
|
v.Autoscroll = true
|
|
fmt.Fprint(v, strings.Join(menuOptions, "\n"))
|
|
if _, err = setCurrentViewOnTop(g, menuWindow); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if v, err := g.SetView(rawInputWindow, 0, 5*maxY/6-1, maxX/1-1, maxY-1, 0); err != nil {
|
|
if !gocui.IsUnknownView(err) {
|
|
return err
|
|
}
|
|
v.Title = "Write or paste a raw stanza. Press \"Ctrl+E\" to send :"
|
|
v.Editable = true
|
|
v.Wrap = true
|
|
}
|
|
|
|
if v, err := g.SetView(chatInputWindow, 0, 5*maxY/6-1, maxX/1-1, maxY-1, 0); err != nil {
|
|
if !gocui.IsUnknownView(err) {
|
|
return err
|
|
}
|
|
v.Title = "Write a message :"
|
|
v.Editable = true
|
|
v.Wrap = true
|
|
|
|
if _, err = setCurrentViewOnTop(g, chatInputWindow); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func quit(g *gocui.Gui, v *gocui.View) error {
|
|
return gocui.ErrQuit
|
|
}
|
|
|
|
// Sends an input text from the user to the backend while also printing it in the chatlog window.
|
|
// KeyEnter is viewed as "\n" by gocui, so messages should only be one line, whereas raw sending has a different key
|
|
// binding and therefor should work with this too (for multiple lines stanzas)
|
|
func writeInput(g *gocui.Gui, v *gocui.View) error {
|
|
chatLogWindow, _ := g.View(chatLogWindow)
|
|
|
|
input := strings.Join(v.ViewBufferLines(), "\n")
|
|
|
|
fmt.Fprintln(chatLogWindow, "Me : ", input)
|
|
textChan <- input
|
|
|
|
v.Clear()
|
|
v.EditDeleteToStartOfLine()
|
|
return nil
|
|
}
|
|
|
|
func setKeyBindings(g *gocui.Gui) {
|
|
// ==========================
|
|
// All views
|
|
if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// ==========================
|
|
// Chat input
|
|
if err := g.SetKeybinding(chatInputWindow, gocui.KeyEnter, gocui.ModNone, writeInput); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
if err := g.SetKeybinding(chatInputWindow, gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// ==========================
|
|
// Raw input
|
|
if err := g.SetKeybinding(rawInputWindow, gocui.KeyCtrlE, gocui.ModNone, writeInput); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
if err := g.SetKeybinding(rawInputWindow, gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// ==========================
|
|
// Menu
|
|
if err := g.SetKeybinding(menuWindow, gocui.KeyArrowDown, gocui.ModNone, cursorDown); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(menuWindow, gocui.KeyArrowUp, gocui.ModNone, cursorUp); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(menuWindow, gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(menuWindow, gocui.KeyEnter, gocui.ModNone, getLine); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// ==========================
|
|
// Contacts list
|
|
if err := g.SetKeybinding(contactsListWindow, gocui.KeyArrowDown, gocui.ModNone, cursorDown); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(contactsListWindow, gocui.KeyArrowUp, gocui.ModNone, cursorUp); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(contactsListWindow, gocui.KeyEnter, gocui.ModNone, getLine); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
if err := g.SetKeybinding(contactsListWindow, gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
}
|
|
|
|
// General
|
|
// Used to handle menu selections and navigations
|
|
func getLine(g *gocui.Gui, v *gocui.View) error {
|
|
var l string
|
|
var err error
|
|
|
|
_, cy := v.Cursor()
|
|
if l, err = v.Line(cy); err != nil {
|
|
l = ""
|
|
}
|
|
if viewState.side == menuWindow {
|
|
if l == contactList {
|
|
cv, _ := g.View(contactsListWindow)
|
|
viewState.side = contactsListWindow
|
|
g.SetViewOnTop(contactsListWindow)
|
|
g.SetCurrentView(contactsListWindow)
|
|
if len(cv.ViewBufferLines()) == 0 {
|
|
printContactsToWindow(g, viewState.contacts)
|
|
}
|
|
} else if l == disconnect || l == askServerForRoster {
|
|
chlw, _ := g.View(chatLogWindow)
|
|
fmt.Fprintln(chlw, infoFormat+" Not yet implemented !")
|
|
} else if l == rawMode {
|
|
mw, _ := g.View(menuWindow)
|
|
viewState.input = rawInputWindow
|
|
g.SetViewOnTop(rawInputWindow)
|
|
g.SetCurrentView(rawInputWindow)
|
|
menuOptions[1] = messageMode
|
|
v.Clear()
|
|
v.EditDeleteToStartOfLine()
|
|
fmt.Fprintln(mw, strings.Join(menuOptions, "\n"))
|
|
message := "Now sending in raw stanza mode"
|
|
clv, _ := g.View(chatLogWindow)
|
|
fmt.Fprintln(clv, infoFormat+message)
|
|
} else if l == messageMode {
|
|
mw, _ := g.View(menuWindow)
|
|
viewState.input = chatInputWindow
|
|
g.SetViewOnTop(chatInputWindow)
|
|
g.SetCurrentView(chatInputWindow)
|
|
menuOptions[1] = rawMode
|
|
v.Clear()
|
|
v.EditDeleteToStartOfLine()
|
|
fmt.Fprintln(mw, strings.Join(menuOptions, "\n"))
|
|
message := "Now sending in messages mode"
|
|
clv, _ := g.View(chatLogWindow)
|
|
fmt.Fprintln(clv, infoFormat+message)
|
|
}
|
|
} else if viewState.side == contactsListWindow {
|
|
if l == backFromContacts {
|
|
viewState.side = menuWindow
|
|
g.SetViewOnTop(menuWindow)
|
|
g.SetCurrentView(menuWindow)
|
|
} else if l == "" {
|
|
return nil
|
|
} else {
|
|
// Updating the current correspondent, back-end side.
|
|
CorrespChan <- l
|
|
viewState.currentContact = l
|
|
// Showing the selected contact in contacts list
|
|
cl, _ := g.View(contactsListWindow)
|
|
cts := cl.ViewBufferLines()
|
|
cl.Clear()
|
|
printContactsToWindow(g, cts)
|
|
// Showing a message to the user, and switching back to input after the new contact is selected.
|
|
message := "Now sending messages to : " + l + " in a private conversation"
|
|
clv, _ := g.View(chatLogWindow)
|
|
fmt.Fprintln(clv, infoFormat+message)
|
|
g.SetCurrentView(chatInputWindow)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func printContactsToWindow(g *gocui.Gui, contactsList []string) {
|
|
cl, _ := g.View(contactsListWindow)
|
|
for _, c := range contactsList {
|
|
c = strings.ReplaceAll(c, " *", "")
|
|
if c == viewState.currentContact {
|
|
fmt.Fprintf(cl, c+" *\n")
|
|
} else {
|
|
fmt.Fprintf(cl, c+"\n")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Changing view between input and "menu/contacts" when pressing the specific key.
|
|
func nextView(g *gocui.Gui, v *gocui.View) error {
|
|
if v == nil || v.Name() == chatInputWindow || v.Name() == rawInputWindow {
|
|
_, err := g.SetCurrentView(viewState.side)
|
|
return err
|
|
} else if v.Name() == menuWindow || v.Name() == contactsListWindow {
|
|
_, err := g.SetCurrentView(viewState.input)
|
|
return err
|
|
}
|
|
|
|
// Should not be reached right now
|
|
_, err := g.SetCurrentView(chatInputWindow)
|
|
return err
|
|
}
|
|
|
|
func cursorDown(g *gocui.Gui, v *gocui.View) error {
|
|
if v != nil {
|
|
cx, cy := v.Cursor()
|
|
// Avoid going below the list of contacts. Although lines are stored in the view as a slice
|
|
// in the used lib. Therefor, if the number of lines is too big, the cursor will go past the last line since
|
|
// increasing slice capacity is done by doubling it. Last lines will be "nil" and reachable by the cursor
|
|
// in a dynamic context (such as contacts list)
|
|
cv := g.CurrentView()
|
|
h := cv.LinesHeight()
|
|
if cy+1 >= h {
|
|
return nil
|
|
}
|
|
// Lower cursor
|
|
if err := v.SetCursor(cx, cy+1); err != nil {
|
|
ox, oy := v.Origin()
|
|
if err := v.SetOrigin(ox, oy+1); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func cursorUp(g *gocui.Gui, v *gocui.View) error {
|
|
if v != nil {
|
|
ox, oy := v.Origin()
|
|
cx, cy := v.Cursor()
|
|
if err := v.SetCursor(cx, cy-1); err != nil && oy > 0 {
|
|
if err := v.SetOrigin(ox, oy-1); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|