How to process grid_line and flush events properly

[stefanwatt]

Hi I hope it's ok to ask this here.
I'm trying to build a GUI with wails so of course goneovim is a great point of inspiration.
I was trying to get started with a very minimal POC implementation that only draws the main grid without handling multiple windows, popupmenus etc.
I think I have a decent understanding of how it's supposed to work after reading through the neovim UI docs and some of the source code of goneovim.
I process grid_line events to build up a content grid and send that to the frontend on flush events.
However I can never get the full grid to be displayed.
The status line is always rendered fine and updates well. The first three lines of a file as well, but not the rest.
Moving the cursor will reveal more content, but I can never get it to render the last line for some reason.
As far as I can tell neovim is just not sending these lines in the grid_line event.

Here's some of the code:

//neovim.go
func StartListening(servername string, ctx context.Context) {
	cols := 100
	rows := 40
	screen = NewScreen(ctx, cols, rows)
	var err error
	NvimInstance, err = nvim.NewChildProcess(
		nvim.ChildProcessCommand("nvim"),
		nvim.ChildProcessArgs("--embed", "/tmp/foo.lua"),
		nvim.ChildProcessContext(context.Background()),
	)
	if err != nil {
		log.Println(err)
		return
	}
	defer NvimInstance.Close()
	var result string

	opts := make(map[string]interface{})
	opts["ext_cmdline"] = true
	opts["ext_linegrid"] = true
	opts["ext_messages"] = true
	err = NvimInstance.AttachUI(cols, rows, opts)
	if err != nil {
		utils.Log(err.Error())
	}
	NvimInstance.RegisterHandler("redraw", func(updates ...[]interface{}) {
		screen.handleRedraw(updates)
	})
...
//screen.go
type Screen struct {
	Content      [][]*Cell `json:"content"`
	rows         int
	cols         int
	grids        map[int][][]*Cell
	ctx          context.Context
}

func NewScreen(ctx context.Context, cols int, rows int) *Screen {
	content := make([][]*Cell, rows)
	for i := range content {
		content[i] = make([]*Cell, cols)
		for j := range content[i] {
			content[i][j] = &Cell{
				Char:      " ",
				Highlight: 0,
			}
		}
	}

	return &Screen{
		Content:      content,
		rows:         rows,
		cols:         cols,
		grids:        map[int][][]*Cell{1: content}, // Grid 1 is the main content grid
		ctx:          ctx,
	}
}

func (s *Screen) handleRedraw(updates [][]interface{}) {
	for _, update := range updates {
		if len(update) == 0 {
			continue
		}

		event := update[0].(string)
		args := update[1:]

		switch event {
		case "grid_clear":
			s.gridClear(args)
		case "grid_line":
			s.gridLine(args)
		case "flush":
			s.flush()
		case "cmdline_show":
			Runtime.EventsEmit(s.ctx, "cmdline_show")
		case "cmdline_hide":
			Runtime.EventsEmit(s.ctx, "cmdline_hide")
		}
	}
}

func (s *Screen) gridLine(args []interface{}) {
	if len(args) < 1 {
		return
	}
	gridArgs, ok := args[0].([]interface{})
	if !ok || len(gridArgs) < 4 {
		return
	}
	gridId := utils.ReflectToInt(gridArgs[0])
	row := utils.ReflectToInt(gridArgs[1])
	col := utils.ReflectToInt(gridArgs[2])
	if row >= 7 && row <= 10 {
		utils.Log(fmt.Sprintf("grid_line: grid=%d, row=%d, col=%d", gridId, row, col))
	}
	if gridId != 1 {
		return
	}
	cells := gridArgs[3].([]interface{})

	if row >= s.rows || col >= s.cols {
		return
	}

	currentCol := col
	for _, cell := range cells {
		cellData, ok := cell.([]interface{})
		if !ok || len(cellData) == 0 {
			continue
		}

		char := cellData[0].(string)
		repeat := 1
		if len(cellData) > 2 {
			repeat = utils.ReflectToInt(cellData[2])
		}

		hl := 0
		if len(cellData) > 1 {
			hl = utils.ReflectToInt(cellData[1])
		}

		for i := 0; i < repeat && currentCol < s.cols; i++ {
			if row < len(s.Content) && currentCol < len(s.Content[row]) {
				s.Content[row][currentCol] = &Cell{
					Char:      char,
					Highlight: hl,
				}
				currentCol++
			}
		}
	}
}

func (s *Screen) flush() {
	Runtime.EventsEmit(s.ctx, "flush", s.Content)
}

As far as I understand it should be sufficient to parse and render only gridId 1 for now, but I also tried with ext_multigrid
and checked the different grids for the "missing" text.
Even tho the file that I'm opening in the underlying neovim instance has 9 lines I will always only see the three first lines after the initial round of flushes.

I checked if it's a viewport issue. as far as I can tell from the win_viewport event the concerning rows are indeed inside the viewport as expected. The statusline isn't, but is rendered on the main grid anyways.

I also checked if it's some sort of an issue with my config by using nvim -u NONE, but also to no avail.

I don't expect anyone to "do the work for me", but any help is greatly appreciated 🧡

[stefanwatt]

Answering my own question:
I changed the signature of gridLine:

func (s *Screen) gridLine(gridId int, row int, col int, cells []interface{}) {
	grid, exists := s.Grids[gridId]
	if !exists {
		return
	}

	if row >= grid.Height || col >= grid.Width {
		utils.Log(fmt.Sprintf("Row %d or col %d out of bounds for grid %d (max: %d,%d)",
			row, col, gridId, grid.Height-1, grid.Width-1))
		return
	}
	currentCol := col
	for _, cell := range cells {
		cellData, ok := cell.([]interface{})
		if !ok || len(cellData) == 0 {
			continue
		}

		char := cellData[0].(string)
		repeat := 1
		if len(cellData) > 2 {
			repeat = utils.ReflectToInt(cellData[2])
		}

		hl := 0
		if len(cellData) > 1 {
			hl = utils.ReflectToInt(cellData[1])
		}

		for i := 0; i < repeat && currentCol < grid.Width; i++ {
			if row < len(grid.Cells) && currentCol < len(grid.Cells[row]) {
				grid.Cells[row][currentCol] = &Cell{
					Char:      char,
					Highlight: hl,
				}
				currentCol++
			}
		}
	}
}

and then also the call site:

		case "grid_line":
			utils.Log("grid_line")
			for _, arg := range args {
				gridArgs := arg.([]interface{})
				gridId := utils.ReflectToInt(gridArgs[0])
				utils.Log(fmt.Sprintf("grid_line event for grid#%d", gridId))
				row := utils.ReflectToInt(gridArgs[1])
				col := utils.ReflectToInt(gridArgs[2])
				cells := gridArgs[3].([]interface{})
				s.gridLine(gridId, row, col, cells)
			}

[akiyosi]

@stefanwatt
Sorry for the late reply.
I am thinking that perhaps the problem with the code before the change was

	gridArgs, ok := args[0].([]interface{})
	if !ok || len(gridArgs) < 4 {
		return
	}

If you have any other questions, feel free to discuss with me.

[stefanwatt]

@akiyosi

Sorry for the late reply.

No worries.
You're project helped me a lot already.
Once I got over the intial hump it's been a breeze developing this in Go.
If all goes well you might get some friendly competition soon 😄

If you have any other questions, feel free to discuss with me.

Thanks for the offfer. I might take you up on that.
Can I contact you directly somehow?

[akiyosi]

Can I contact you directly somehow?

Communication in this discussions is better for me :)

[stefanwatt]

@akiyosi

Communication in this discussions is better for me :)

understandable

Have you also encountered the problem where some residual windows are left behind sometimes even when they are closed in the underlying neovim instance?
I'm using my own file-manager which opens a three-way vertical split in a new tab. Whenever I close the file-manager the right window of the three would not receive a close event.
At first I thought I'm not cleaning up the windows properly in the plugin, but that's not the case.
It's always the last window that I close in the plugin that stays open in my GUI because it doesn't receive a close/hide event.
So when I changed the order of window closing in the plugin teardown from left,center,right to e.g. right,left,center
then the center window will be the one that stays open in my GUI.

It happens with the preview window from fzf-lua as well for example, which further confirms that it's not an issue with my file-manager-plugin.

[akiyosi]

@stefanwatt
As long as all UI events are properly handled, windows should never be left behind. It’s likely that there’s a missing handler or incomplete processing for some grid-related or window-related events.