// Copyright (c) 2024, Přemysl Eric Janouch
// SPDX-License-Identifier: 0BSD package main import ( "bufio" "context" "encoding/binary" "flag" "fmt" "image/color" "io" "log" "net" "net/url" "os" "time" "fyne.io/fyne/v2" "fyne.io/fyne/v2/app" "fyne.io/fyne/v2/container" "fyne.io/fyne/v2/theme" "fyne.io/fyne/v2/widget" ) var ( debug = flag.Bool("debug", false, "enable debug output") projectName = "xA" projectVersion = "?" ) // --- Theme ------------------------------------------------------------------- type customTheme struct{} func convertColor(c int) color.Color { base16 := []uint16{ 0x000, 0x800, 0x080, 0x880, 0x008, 0x808, 0x088, 0xccc, 0x888, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff, } if c < 16 { r := 0xf & uint8(base16[c]>>8) g := 0xf & uint8(base16[c]>>4) b := 0xf & uint8(base16[c]) return color.RGBA{r * 0x11, g * 0x11, b * 0x11, 0xff} } if c >= 216 { return color.Gray{8 + uint8(c-216)*10} } var ( i = uint8(c - 16) r = i / 36 >> 0 g = (i / 6 >> 0) % 6 b = i % 6 ) if r != 0 { r = 55 + 40*r } if g != 0 { g = 55 + 40*g } if b != 0 { b = 55 + 40*b } return color.RGBA{r, g, b, 0xff} } var ircColors = make(map[fyne.ThemeColorName]color.Color) func ircColorName(color int) fyne.ThemeColorName { return fyne.ThemeColorName(fmt.Sprintf("irc%02x", color)) } func init() { for color := 0; color < 256; color++ { ircColors[ircColorName(color)] = convertColor(color) } } func (t *customTheme) Color( name fyne.ThemeColorName, variant fyne.ThemeVariant) color.Color { // Fuck this low contrast shit, text must be black. if name == theme.ColorNameForeground && variant == theme.VariantLight { return color.Black } // TODO(p): Consider constants for stuff like timestamps. if c, ok := ircColors[name]; ok { return c } return theme.DefaultTheme().Color(name, variant) } func (t *customTheme) Font(style fyne.TextStyle) fyne.Resource { return theme.DefaultTheme().Font(style) } func (t *customTheme) Icon(i fyne.ThemeIconName) fyne.Resource { return theme.DefaultTheme().Icon(i) } func (t *customTheme) Size(s fyne.ThemeSizeName) float32 { return theme.DefaultTheme().Size(s) } // --- Relay state ------------------------------------------------------------- type server struct { state RelayServerState user string userModes string } type bufferLineItem struct { format fyne.TextStyle // For RichTextStyle.ColorName. // XXX: Fyne's RichText doesn't support background colours. color fyne.ThemeColorName text string } type bufferLine struct { /// Leaked from another buffer, but temporarily staying in another one. leaked bool isUnimportant bool isHighlight bool rendition RelayRendition when time.Time items []bufferLineItem } type buffer struct { bufferName string hideUnimportant bool kind RelayBufferKind serverName string lines []bufferLine // TODO(p): Server by name or by pointer? // Channel: topic []bufferLineItem modes string // Stats: newMessages int newUnimportantMessages int highlighted bool // Input: input string inputStart, inputEnd int history []string historyAt int } type callback func(err error, response *RelayResponseData) var ( backendAddress string backendContext context.Context backendCancel context.CancelFunc // Connection state: commandSeq uint32 commandCallbacks map[uint32]callback buffers []buffer bufferCurrent string bufferLast string servers map[string]server // Widgets: wRichText *widget.RichText wRichScroll *container.Scroll wEntry *widget.Entry ) // ----------------------------------------------------------------------------- func relayReadMessage(r io.Reader) (m RelayEventMessage, ok bool) { var length uint32 if err := binary.Read(r, binary.BigEndian, &length); err != nil { log.Println("Event receive failed: " + err.Error()) return } b := make([]byte, length) if _, err := io.ReadFull(r, b); err != nil { log.Println("Event receive failed: " + err.Error()) return } if after, ok2 := m.ConsumeFrom(b); !ok2 { log.Println("Event deserialization failed") return } else if len(after) != 0 { log.Println("Event deserialization failed: trailing data") return } if *debug { log.Printf(" %v\n", b) j, err := m.MarshalJSON() if err != nil { log.Println("Event marshalling failed: " + err.Error()) return } log.Printf("<- %s\n", j) } return m, true } func relayMakeReceiver( ctx context.Context, conn net.Conn) <-chan RelayEventMessage { // The usual event message rarely gets above 1 kilobyte, // thus this is set to buffer up at most 1 megabyte or so. p := make(chan RelayEventMessage, 1000) r := bufio.NewReaderSize(conn, 65536) go func() { defer close(p) for { m, ok := relayReadMessage(r) if !ok { return } select { case p <- m: case <-ctx.Done(): return } } }() return p } func relayWriteMessage(conn net.Conn, commandData any) bool { m := RelayCommandMessage{ CommandSeq: commandSeq, Data: RelayCommandData{commandData}, } commandSeq++ b, ok := m.AppendTo(make([]byte, 4)) if !ok { log.Println("Command serialization failed") return false } binary.BigEndian.PutUint32(b[:4], uint32(len(b)-4)) if _, err := conn.Write(b); err != nil { log.Println("Command send failed: " + err.Error()) return false } if *debug { log.Printf("-> %v\n", b) } return true } func relayProcessMessage(m *RelayEventMessage) { switch data := m.Data.Interface.(type) { case RelayEventDataError: // TODO(p): Process callbacks. _ = data.CommandSeq _ = data.Error case RelayEventDataResponse: // TODO(p): Process callbacks. _ = data.CommandSeq _ = data.Data case RelayEventDataPing: // TODO(p): Send the command. _ = RelayCommandDataPingResponse{ Command: RelayCommandPingResponse, EventSeq: m.EventSeq, } // TODO(p): Process all remaining message kinds. case RelayEventDataBufferLine: case RelayEventDataBufferUpdate: case RelayEventDataBufferStats: case RelayEventDataBufferRename: case RelayEventDataBufferRemove: case RelayEventDataBufferActivate: case RelayEventDataBufferInput: case RelayEventDataBufferClear: case RelayEventDataServerUpdate: case RelayEventDataServerRename: case RelayEventDataServerRemove: } } func relayRun() { // TODO(p): Maybe reset state, and indicate in the UI that we're connecting. backendContext, backendCancel = context.WithCancel(context.Background()) defer backendCancel() conn, err := net.Dial("tcp", backendAddress) if err != nil { log.Println("Connection failed: " + err.Error()) // TODO(p): Display errors to the user. return } defer conn.Close() // TODO(p): How to send messages? // - It would probably make the most sense to have either a chan // (which makes code synchronize), or a locked slice. // - But I also need to wake the sender up somehow, // so maybe use a channel after all. // - Or maybe use a channel just for the signalling. // - Sending (semi-)synchronously is also an option, perhaps. // TODO(p): Handle any errors here. _ = relayWriteMessage(conn, &RelayCommandDataHello{ Command: RelayCommandHello, Version: RelayVersion, }) relayMessages := relayMakeReceiver(backendContext, conn) for { select { case m, ok := <-relayMessages: if !ok { break } relayProcessMessage(&m) default: break } } // TODO(p): Indicate in the UI that we're no longer connected. } func main() { flag.Usage = func() { fmt.Fprintf(flag.CommandLine.Output(), "Usage: %s [OPTION...] CONNECT\n\n", os.Args[0]) flag.PrintDefaults() } flag.Parse() if flag.NArg() < 1 || flag.NArg() > 1 { flag.Usage() os.Exit(1) } backendAddress = flag.Arg(0) a := app.New() a.Settings().SetTheme(&customTheme{}) w := a.NewWindow(projectName) // TODO(p): There should also be a widget.NewLabel() next to the entry. // - Probably another Border, even though this seems odd. wRichText = widget.NewRichText() wRichScroll = container.NewVScroll(wRichText) wEntry = widget.NewMultiLineEntry() w.SetContent(container.NewBorder(nil, wEntry, nil, nil, wRichScroll)) testURL, _ := url.Parse("https://x.com") wRichText.Segments = []widget.RichTextSegment{ &widget.ParagraphSegment{Texts: []widget.RichTextSegment{ &widget.TextSegment{Text: "Test"}, &widget.HyperlinkSegment{Text: "X", URL: testURL}, &widget.TextSegment{ Text: " is a website, certainly", Style: widget.RichTextStyleInline, }, }}, &widget.TextSegment{Style: widget.RichTextStyleParagraph}, &widget.SeparatorSegment{}, &widget.TextSegment{Text: "Paragraph"}, } wRichText.Wrapping = fyne.TextWrapWord wRichText.Refresh() go relayRun() w.ShowAndRun() }