package container import ( "fmt" "github.com/diamondburned/cchat" "github.com/diamondburned/cchat-gtk/internal/log" "github.com/diamondburned/cchat-gtk/internal/ui/messages/input" "github.com/diamondburned/cchat-gtk/internal/ui/primitives" "github.com/gotk3/gotk3/gtk" "github.com/pkg/errors" ) type GridStore struct { *gtk.Grid Construct Constructor Controller Controller messages map[string]*gridMessage messageIDs []string // ids or nonces } func NewGridStore(constr Constructor, ctrl Controller) *GridStore { grid, _ := gtk.GridNew() grid.SetColumnSpacing(ColumnSpacing) grid.SetRowSpacing(5) grid.SetMarginStart(5) grid.SetMarginEnd(5) grid.Show() primitives.AddClass(grid, "message-grid") return &GridStore{ Grid: grid, Construct: constr, Controller: ctrl, messages: map[string]*gridMessage{}, } } func (c *GridStore) MessagesLen() int { return len(c.messages) } // findIndex searches backwards for idnonce. func (c *GridStore) findIndex(idnonce string) int { for i := len(c.messageIDs) - 1; i >= 0; i-- { if c.messageIDs[i] == idnonce { return i } } return -1 } type CoordinateTranslator interface { TranslateCoordinates(dest gtk.IWidget, srcX int, srcY int) (destX int, destY int, e error) } var _ CoordinateTranslator = (*gtk.Widget)(nil) func (c *GridStore) TranslateCoordinates(parent gtk.IWidget, msg GridMessage) (y int) { i := c.findIndex(msg.ID()) if i < 0 { return 0 } m, _ := c.messages[c.messageIDs[i]] w, _ := m.Focusable().(CoordinateTranslator) // x is not needed. _, y, err := w.TranslateCoordinates(parent, 0, 0) if err != nil { log.Error(errors.Wrap(err, "Failed to translate coords while focusing")) return } // log.Println("X:", x) // log.Println("Y:", y) return y } // Swap changes the message with the ID to the given message. This provides a // low level API for edits that need a new Attach method. // // TODO: combine compact and full so they share the same attach method. func (c *GridStore) SwapMessage(msg GridMessage) bool { // Get the current message's index. var ix = c.findIndex(msg.ID()) if ix == -1 { return false } // Wrap msg inside a *gridMessage if it's not already. mg, ok := msg.(*gridMessage) if !ok { mg = &gridMessage{GridMessage: msg} } // Add a row at index. The actual row we want to delete will be shifted // downwards. c.Grid.InsertRow(ix) // Let the new message be attached on top of the to-be-replaced message. mg.Attach(c.Grid, ix) // Set the message into the map. c.messages[mg.ID()] = mg // Delete the to-be-replaced message, which we have shifted downwards // earlier, so we add 1. c.Grid.RemoveRow(ix + 1) return true } // Before returns the message before the given ID, or nil if none. func (c *GridStore) Before(id string) GridMessage { return c.getOffsetted(id, -1) } // After returns the message after the given ID, or nil if none. func (c *GridStore) After(id string) GridMessage { return c.getOffsetted(id, 1) } func (c *GridStore) getOffsetted(id string, offset int) GridMessage { // Get the current index. var ix = c.findIndex(id) if ix == -1 { return nil } ix += offset if ix < 0 || ix >= len(c.messages) { return nil } return c.messages[c.messageIDs[ix]].GridMessage } // LatestMessageFrom returns the latest message with the given user ID. This is // used for the input prompt. func (c *GridStore) LatestMessageFrom(userID string) (msgID string, ok bool) { // FindMessage already looks from the latest messages. var msg = c.FindMessage(func(msg GridMessage) bool { return msg.AuthorID() == userID }) if msg == nil { return "", false } return msg.ID(), true } // FindMessage iterates backwards and returns the message if isMessage() returns // true on that message. func (c *GridStore) FindMessage(isMessage func(msg GridMessage) bool) GridMessage { for i := len(c.messageIDs) - 1; i >= 0; i-- { msg := c.messages[c.messageIDs[i]] // Ignore sending messages. if msg.presend != nil { continue } // Check. if msg := msg.GridMessage; isMessage(msg) { return msg } } return nil } // NthMessage returns the nth message. func (c *GridStore) NthMessage(n int) GridMessage { if len(c.messageIDs) > 0 && n >= 0 && n < len(c.messageIDs) { return c.messages[c.messageIDs[n]].GridMessage } return nil } // FirstMessage returns the first message. func (c *GridStore) FirstMessage() GridMessage { return c.NthMessage(0) } // LastMessage returns the latest message. func (c *GridStore) LastMessage() GridMessage { return c.NthMessage(c.MessagesLen() - 1) } // Message finds the message state in the container. It is not thread-safe. This // exists for backwards compatibility. func (c *GridStore) Message(msgID cchat.ID, nonce string) GridMessage { if m := c.message(msgID, nonce); m != nil { return m.GridMessage } return nil } func (c *GridStore) message(msgID cchat.ID, nonce string) *gridMessage { // Search using the ID first. m, ok := c.messages[msgID] if ok { return m } // Is this an existing message? if nonce != "" { // Things in this map are guaranteed to have presend != nil. m, ok := c.messages[nonce] if ok { // Replace the nonce key with ID. delete(c.messages, nonce) c.messages[msgID] = m // Set the right ID. m.presend.SetDone(msgID) // Destroy the presend struct. m.presend = nil // Replace the nonce inside the ID slice with the actual ID. if ix := c.findIndex(nonce); ix > -1 { c.messageIDs[ix] = msgID } else { log.Error(fmt.Errorf("Missed ID %s in slice index %d", msgID, ix)) } return m } } return nil } // AddPresendMessage inserts an input.PresendMessage into the container and // returning a wrapped widget interface. func (c *GridStore) AddPresendMessage(msg input.PresendMessage) PresendGridMessage { presend := c.Construct.NewPresendMessage(msg) msgc := &gridMessage{ GridMessage: presend, presend: presend, } // Set the message into the grid. msgc.Attach(c.Grid, c.MessagesLen()) // Append the NONCE. c.messageIDs = append(c.messageIDs, msgc.Nonce()) // Set the NONCE into the message map. c.messages[msgc.Nonce()] = msgc return presend } func (c *GridStore) PrependMessageUnsafe(msg cchat.MessageCreate) { msgc := &gridMessage{ GridMessage: c.Construct.NewMessage(msg), } c.Grid.InsertRow(0) msgc.Attach(c.Grid, 0) // Prepend the message ID. c.messageIDs = append(c.messageIDs, "") copy(c.messageIDs[1:], c.messageIDs) c.messageIDs[0] = msgc.ID() // Set the message into the map. c.messages[msgc.ID()] = msgc c.Controller.BindMenu(msgc) } func (c *GridStore) CreateMessageUnsafe(msg cchat.MessageCreate) { // Call the event handler last. defer c.Controller.AuthorEvent(msg.Author()) // Attempt to update before insertion (aka upsert). if msgc := c.Message(msg.ID(), msg.Nonce()); msgc != nil { msgc.UpdateAuthor(msg.Author()) msgc.UpdateContent(msg.Content(), false) msgc.UpdateTimestamp(msg.Time()) c.Controller.BindMenu(msgc) return } msgc := &gridMessage{ GridMessage: c.Construct.NewMessage(msg), } // Copy from PresendMessage. msgc.Attach(c.Grid, c.MessagesLen()) c.messageIDs = append(c.messageIDs, msgc.ID()) c.messages[msgc.ID()] = msgc c.Controller.BindMenu(msgc) } func (c *GridStore) UpdateMessageUnsafe(msg cchat.MessageUpdate) { // Call the event handler last. defer c.Controller.AuthorEvent(msg.Author()) if msgc := c.Message(msg.ID(), ""); msgc != nil { if author := msg.Author(); author != nil { msgc.UpdateAuthor(author) } if content := msg.Content(); !content.IsEmpty() { msgc.UpdateContent(content, true) } } return } func (c *GridStore) DeleteMessageUnsafe(msg cchat.MessageDelete) { c.PopMessage(msg.ID()) } // PopMessage deletes a message off of the list and return the deleted message. func (c *GridStore) PopMessage(id string) (msg GridMessage) { // Search for the index. var ix = c.findIndex(id) if ix < 0 { return nil } // Grab the message before deleting. msg = c.messages[id] // Remove off of the Gtk grid. c.Grid.RemoveRow(ix) // Pop off the slice. c.messageIDs = append(c.messageIDs[:ix], c.messageIDs[ix+1:]...) // Delete off the map. delete(c.messages, id) return }