path: root/table.go

// a table is a grid with X columns and 1 row of header names
// that means that the toolkits might be able to sort the table
// pushing traditional application development to the display
// is that a good idea?

package gui

import (
	"go.wit.com/lib/protobuf/guipb"
	"go.wit.com/log"
	"go.wit.com/widget"
	"google.golang.org/protobuf/types/known/anypb"
)

/*
// makes a grid inside an existing Widget
func (n *Node) NewTable(title string) *NodeTable {
	t := new(NodeTable)

	t.grid = n.RawGrid().SetProgName("PB GRID")

	t.tb = t.grid.newNode(title, widget.Table)
	t.tb.label = title

	return t
}

type NodeColumn struct {
	Title string
	Vals  []string
}

type NodeTable struct {
	grid   *Node
	tb     *Node
	Custom func()
}

func (parent *Node) ShowTableCallback(pb *guipb.Table, f func(id int)) {
}
*/

func (n *Node) findInTablePB(pb *guipb.Table) *guipb.Widget {
	if n.tablepb == nil {
		log.Info("SOMETHING WAS WRONG. gui.findInTablePB() n.tablepb == nil for widget id", n.id)
		return nil
	}
	for _, r := range pb.StringRows {
		if r.Header.Id == int64(n.id) {
			log.Info("gui.findInTablePB() found widget", r.Header)
			return r.Header
		}
		for _, w := range r.Widgets {
			if w.Id == int64(n.id) {
				log.Info("gui.findInTablePB() found widget", w)
				return w
			}
		}
	}

	for _, r := range pb.ButtonRows {
		if r.Header.Id == int64(n.id) {
			log.Info("gui.findInTablePB() found widget", r.Header)
			return r.Header
		}
		for _, w := range r.Widgets {
			if w.Id == int64(n.id) {
				log.Info("gui.findInTablePB() found widget", w)
				return w
			}
		}
	}

	for _, r := range pb.IntRows {
		if r.Header.Id == int64(n.id) {
			log.Info("gui.findInTablePB() found widget", r.Header)
			return r.Header
		}
		for _, w := range r.Widgets {
			if w.Id == int64(n.id) {
				log.Info("gui.findInTablePB() found widget", w)
				return w
			}
		}
	}

	for _, r := range pb.TimeRows {
		if r.Header.Id == int64(n.id) {
			log.Info("gui.findInTablePB() found widget", r.Header)
			return r.Header
		}
		for _, w := range r.Widgets {
			if w.Id == int64(n.id) {
				log.Info("gui.findInTablePB() found widget", w)
				return w
			}
		}
	}
	log.Info("SOMETHING WAS WRONG. gui.findInTablePB() didn't find widget id", n.id)
	return nil
}

func (n *Node) isWidgetInTable() (bool, *guipb.Table) {
	if n.id == 0 {
		return false, nil
	}
	if n.progname == "gridtablePB" {
		n.findInTablePB(n.tablepb)
		return true, n.tablepb
	}
	if n.parent == nil {
		return false, nil
	}
	return n.parent.isWidgetInTable()
}

func (parent *Node) ShowTable(pb *guipb.Table) {
	// make a new action and populate the current node state
	// this should be parent and not rootNode?
	a := getNewAction(me.rootNode, widget.Show)

	// store the mapping for the grid widget to the parent widget
	pb.Parent = new(guipb.Widget)
	pb.Parent.Id = int64(parent.id)
	pb.Parent.Name = pb.Title

	grid := parent.makeTableGrid(pb) // generates the protobuf table
	parent.numberTableGrid(pb)       // sets the X,Y locations in the table protobuf grid
	grid.tablepb = pb

	nt := guipb.NewTables()
	nt.Append(pb)
	a.TablePB, err = nt.Marshal()
	if err != nil {
		log.Info("unmarshal error", err)
		return
	}
	log.Info("NewStable() send action to plugin", "pb len =", len(a.TablePB))
	sendActionToPlugin(a)
}

func (parent *Node) UpdateTable(pb *guipb.Table) {
	a := getNewAction(parent, widget.Show)

	log.Info("gui.UpdateTable() TODO: move the widget update val logic here instead of tree")

	nt := guipb.NewTables()
	nt.Append(pb)
	a.TablePB, err = nt.Marshal()
	if err != nil {
		log.Info("unmarshal error", err)
		return
	}
	sendActionToPlugin(a)
}

func (parent *Node) DeleteTable(pb *guipb.Table) {
	a := getNewAction(parent, widget.Delete)

	log.Info("gui.DeleteTable()")
	if pb.Grid == nil {
		log.Info("gui.DeleteTable() Error: pb.Grid == nil")
		return
	}

	a.WidgetId = int(pb.Grid.Id)
	sendActionToPlugin(a)
}

func (parent *Node) numberTableGrid(pb *guipb.Table) {
	var h int = 0
	var w int = 0
	for _, name := range pb.Order {
		// log.Info("got order:", t.Title, name)
		if parent.numberTableRow(pb, name, w) {
			// log.Info("tree:row() COLUMN GOOD", t.Title, name, w, h)
		} else {
			log.Info("tree:row() COLOMN FAIL", pb.Title, name, w, h)
		}

		w += 1
	}
}

func (parent *Node) numberTableRow(pb *guipb.Table, name string, w int) bool {
	var h int = 0
	for _, r := range pb.StringRows {
		if name != r.Header.Name {
			// log.Info("skip string row:", r.Header.Name, "!=", name)
			continue
		}
		// log.Info("tree: Add()ing to grid here", r.Header.Id, r.Header.Name, w, h)
		r.Header.Location = new(guipb.Location)
		r.Header.Location.X = int64(w)
		r.Header.Location.Y = int64(h)
		h += 1
		for _, v := range r.Widgets {
			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
			v.Location = new(guipb.Location)
			v.Location.X = int64(w)
			v.Location.Y = int64(h)
			h += 1
		}
		return true
	}

	for _, r := range pb.ButtonRows {
		if name != r.Header.Name {
			// log.Info("skip string row:", r.Header.Name, "!=", name)
			continue
		}
		// log.Info("tree: Add()ing to grid here", r.Header.Id, r.Header.Name, w, h)
		r.Header.Location = new(guipb.Location)
		r.Header.Location.X = int64(w)
		r.Header.Location.Y = int64(h)
		h += 1
		for _, v := range r.Widgets {
			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
			v.Location = new(guipb.Location)
			v.Location.X = int64(w)
			v.Location.Y = int64(h)
			h += 1
		}
		return true
	}

	for _, r := range pb.IntRows {
		if name != r.Header.Name {
			// log.Info("skip string row:", r.Header.Name, "!=", name)
			continue
		}
		// log.Info("tree: Add()ing to grid here", r.Header.Id, r.Header.Name, w, h)
		r.Header.Location = new(guipb.Location)
		r.Header.Location.X = int64(w)
		r.Header.Location.Y = int64(h)
		h += 1
		for _, v := range r.Widgets {
			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
			v.Location = new(guipb.Location)
			v.Location.X = int64(w)
			v.Location.Y = int64(h)
			h += 1
		}
		return true
	}

	for _, r := range pb.TimeRows {
		if name != r.Header.Name {
			// log.Info("skip string row:", r.Header.Name, "!=", name)
			continue
		}
		// log.Info("tree: Add()ing to grid here", r.Header.Id, r.Header.Name, w, h)
		r.Header.Location = new(guipb.Location)
		r.Header.Location.X = int64(w)
		r.Header.Location.Y = int64(h)
		h += 1
		for _, v := range r.Widgets {
			// log.Info("tree: Add()ing to grid here", v.Id, v.Name, w, h)
			v.Location = new(guipb.Location)
			v.Location.X = int64(w)
			v.Location.Y = int64(h)
			h += 1
		}
		return true
	}

	return false
}

func (parent *Node) makeTableGrid(pb *guipb.Table) *Node {
	grid := addNode()
	grid.progname = "gridtablePB"
	grid.WidgetType = widget.Grid

	pb.Grid = new(guipb.Widget)
	pb.Grid.Id = int64(grid.id)
	pb.Grid.Name = "gridtablePB"

	parent.children = append(parent.children, grid)
	grid.parent = parent

	for _, r := range pb.StringRows {
		// log.Info("gui: got string row:", pb.Title, i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			label.WidgetType = widget.Label
			label.parent = grid
			label.enabled = true
			grid.children = append(grid.children, label)

			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			pbwidget.Name = v
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new string", pbwidget)
		}
	}

	for _, r := range pb.ButtonRows {
		// log.Info("gui: got string row:", pb.Title, i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			label.WidgetType = widget.Button
			label.parent = grid
			label.enabled = true
			grid.children = append(grid.children, label)

			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			pbwidget.Name = v
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new string", pbwidget)
		}
	}

	for _, r := range pb.IntRows {
		// log.Info("gui: got int row:", i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			label.WidgetType = widget.Label
			label.parent = grid
			label.enabled = true
			grid.children = append(grid.children, label)

			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			pbwidget.Size = v
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new int", pbwidget)
		}
	}

	for _, r := range pb.TimeRows {
		// log.Info("gui: got time row:", i, r.Header, r.Vals)
		header := addNode()
		r.Header.Id = int64(header.id)
		for _, v := range r.Vals {
			label := addNode()
			label.WidgetType = widget.Label
			label.parent = grid
			label.enabled = true
			grid.children = append(grid.children, label)

			pbwidget := new(guipb.Widget)
			pbwidget.Id = int64(label.id)
			anyValue, err := anypb.New(v)
			if err != nil {
				log.Info("gui: failed to add time", err)
				continue
			}
			pbwidget.Val = anyValue
			r.Widgets = append(r.Widgets, pbwidget)
			// log.Info("gui: added new val", pbwidget)
		}
	}

	return grid
}