gocui/click.go

package main

import (
	"github.com/awesome-gocui/gocui"
	"go.wit.com/log"
	"go.wit.com/toolkits/tree"
	"go.wit.com/widget"
)

// set isCurrent = false everywhere
func (w *guiWidget) unsetCurrent() {
	w.isCurrent = false

	if w.node.WidgetType == widget.Tab {
		// n.tk.color = &colorTab
		// n.setColor()
	}

	for _, child := range w.children {
		child.unsetCurrent()
	}
}

// when adding a new widget, this will update the display
// of the current widgets if that widget is supposed
// to be in current display
func (w *guiWidget) updateCurrent() {
	log.Log(NOW, "updateCurrent()", w.String())
	if w.WidgetType == widget.Tab {
		if w.IsCurrent() {
			// n.tk.color = &colorActiveT
			w.setColor(&colorActiveT)
			w.hideView()
			w.showView()
			w.setCurrentTab()
		} else {
			// n.tk.color = &colorTab
			// n.setColor()
		}
		return
	}
	if w.WidgetType == widget.Window {
		if w.IsCurrent() {
			// setCurrentWindow(n)
		}
		return
	}
	if w.WidgetType == widget.Root {
		return
	}
	w.parent.updateCurrent()
}

// shows the widgets in a window
func (w *guiWidget) setCurrentWindow() {
	if w.IsCurrent() {
		return
	}
	if w.WidgetType != widget.Window {
		return
	}
	var rootTK *guiWidget
	rootTK = me.treeRoot.TK.(*guiWidget)
	rootTK.unsetCurrent()

	if w.hasTabs {
		// set isCurrent = true on the first tab
		for _, child := range w.children {
			child.isCurrent = true
			break
		}
	} else {
		w.isCurrent = true
	}
}

// shows the widgets in a tab
func (w *guiWidget) setCurrentTab() {
	var p, rootTK *guiWidget
	if w.WidgetType != widget.Tab {
		return
	}
	rootTK = me.treeRoot.TK.(*guiWidget)
	rootTK.unsetCurrent()
	w.isCurrent = true
	p = w.parent
	p.isCurrent = true
	log.Log(NOW, "setCurrent()", w.String())
}

func (w *guiWidget) doWidgetClick() {
	switch w.WidgetType {
	case widget.Root:
		// THIS IS THE BEGINING OF THE LAYOUT
		log.Log(NOW, "doWidgetClick()", w.String())
		wRoot := me.treeRoot.TK.(*guiWidget)
		wRoot.redoWindows(0, 0)
	case widget.Flag:
		log.Log(NOW, "doWidgetClick() FLAG widget name =", w.String())
		log.Log(NOW, "doWidgetClick() if this is the dropdown menu, handle it here?")
	case widget.Window:
		log.Log(NOW, "doWidgetClick() START on window", w.String())
		if me.currentWindow == w.node {
			if !w.active {
				return
			}
		}
		if me.currentWindow != nil {
			var curw *guiWidget
			curw = me.currentWindow.TK.(*guiWidget)
			curw.unsetCurrent()
			curw.setColor(&colorWindow)
			curw.hideWidgets()
		}
		me.currentWindow = w.node

		log.Log(NOW, "doWidgetClick() set currentWindow to", w.String())
		w.setColor(&colorActiveW)

		w.active = false
		// w.dumpTree("before")
		w.placeWidgets(3, 2)
		w.showWidgets()

		hideFake()
		showDebug = true

		// w.dumpTree("after")
	case widget.Group:
		// n.placeWidgets(p.tk.startH, newH)
		// w.dumpTree("click start")
		if w.active {
			w.active = false
			w.placeWidgets(w.startW, w.startH)
			w.showWidgets()
			/*
				for _, child := range w.children {
					log.Log(INFO, "START W,H", startW, startH)
					child.placeWidgets(startW, startH)
					child.showWidgets()
				}
			*/
		} else {
			w.active = true
			for _, child := range w.children {
				child.hideWidgets()
			}
		}
		// w.dumpTree("click end")
	case widget.Checkbox:
		if w.node.State.Checked {
			log.Log(WARN, "checkbox is being set to false")
			w.node.State.Checked = false
			w.setCheckbox()
		} else {
			log.Log(WARN, "checkbox is being set to true")
			w.node.State.Checked = true
			w.setCheckbox()
		}
		me.myTree.SendUserEvent(w.node)
	case widget.Grid:
		newR := w.realGocuiSize()

		// w,h := n.logicalSize()
		// w := newR.w1 - newR.w0
		// h := newR.h1 - newR.h0

		w.placeGrid(newR.w0, newR.h0)
		w.showWidgets()
	case widget.Box:
		// w.showWidgetPlacement(logNow, "drawTree()")
		if w.direction == widget.Horizontal {
			log.Log(NOW, "BOX IS HORIZONTAL", w.String())
		} else {
			log.Log(NOW, "BOX IS VERTICAL", w.String())
		}
		w.placeWidgets(me.RawW, me.RawH)
		w.toggleTree()
	case widget.Button:
		// doUserEvent(n)
		me.myTree.SendUserEvent(w.node)
	case widget.Combobox:
		log.Log(NOW, "do the combobox here")
		var ddItems string
		for i, s := range w.vals {
			log.Log(NOW, "ddItem:", w.String(), i, s)
			ddItems += s + "\n"
		}
		if me.ddview == nil {
			me.ddview = makeDropdownView(ddItems)
		}
		showDropdownItems(ddItems)
		me.ddNode = w.node
	case widget.Dropdown:
		log.Log(NOW, "do the dropdown here")
		var ddItems string
		for i, s := range w.vals {
			log.Log(NOW, "ddItem:", w.String(), i, s)
			ddItems += s + "\n"
		}
		/*
		if me.ddview == nil {
			me.ddview = makeDropdownView(ddItems)
		}
		*/
		showDropdownItems(ddItems)
		me.ddNode = w.node
		/*
			var tk *guiWidget
			tk = me.ddview.TK.(*guiWidget)
			log.Log(NOW, "doWidgetClick() visible =", tk.Visible())
			if tk.Visible() {
				tk.SetVisible(false)
				me.baseGui.DeleteView("ddview")
				tk.v = nil
			} else {
				me.ddNode = w.node
				log.Log(NOW, "new dns list should be set to:", ddItems)
				tk.labelN = ddItems
				tk.SetText(ddItems)
				tk.SetVisible(true)
				fmt.Fprint(tk.v, ddItems)
			}
			for i, s := range tk.vals {
				log.Log(NOW, "AddText()", tk.String(), i, s)
			}
		*/
	default:
	}
}

var toggle bool = true

func (w *guiWidget) toggleTree() {
	if toggle {
		w.drawTree(toggle)
		toggle = false
	} else {
		w.hideWidgets()
		toggle = true
	}
}

// display the widgets in the binary tree
func (w *guiWidget) drawTree(draw bool) {
	if w == nil {
		return
	}
	w.showWidgetPlacement("drawTree()")
	if draw {
		// w.textResize()
		w.showView()
	} else {
		w.deleteView()
	}

	for _, child := range w.children {
		child.drawTree(draw)
	}
}

func click(g *gocui.Gui, v *gocui.View) error {
	// var l string
	// var err error

	log.Log(INFO, "click() START", v.Name())
	// n := me.rootNode.findWidgetName(v.Name())
	n := findUnderMouse()
	var w *guiWidget
	w = n.TK.(*guiWidget)
	if w != nil {
		log.Log(NOW, "click() Found widget =", w.node.WidgetId, w.String(), ",", w.labelN)
		if w.String() == "DropBox" {
			log.Log(NOW, "click() this is the dropdown menu. set a flag here what did I click? where is the mouse?")
			log.Log(NOW, "click() set a global dropdown clicked flag=true here")
			me.ddClicked = true
		}
		w.doWidgetClick()
	} else {
		log.Log(NOW, "click() could not find node name =", v.Name())
	}

	if _, err := g.SetCurrentView(v.Name()); err != nil {
		log.Log(NOW, "click() END err =", err)
		return err
	}

	log.Log(NOW, "click() END")
	return nil
}

func findUnderMouse() *tree.Node {
	var found *tree.Node
	var widgets []*tree.Node
	var f func(n *tree.Node)
	w, h := me.baseGui.MousePosition()

	ddTK := me.ddview.TK.(*guiWidget)
	// if the dropdown view is visable, close it
	if ddTK.Visible() {
		ddTK.dropdownClicked(w, h)
		return me.ddview
	}

	// find buttons that are below where the mouse button click
	f = func(n *tree.Node) {
		var widget *guiWidget
		widget = n.TK.(*guiWidget)

		// ignore widgets that are not visible
		if widget.Visible() {
			if (widget.gocuiSize.w0 <= w) && (w <= widget.gocuiSize.w1) &&
				(widget.gocuiSize.h0 <= h) && (h <= widget.gocuiSize.h1) {
				widgets = append(widgets, n)
				found = n
			}
		}

		for _, child := range widget.children {
			f(child.node)
		}
	}
	f(me.treeRoot)
	// widgets has everything that matches
	// TODO: pop up menu with a list of them
	for _, n := range widgets {
		//log(logNow, "ctrlDown() FOUND widget", widget.id, widget.name)
		widget := n.TK.(*guiWidget)
		widget.showWidgetPlacement("findUnderMouse() FOUND")
	}
	return found
}

// find the widget under the mouse click
func ctrlDown(g *gocui.Gui, v *gocui.View) error {
	var found *tree.Node
	// var widgets []*node
	// var f func (n *node)
	found = findUnderMouse()
	if me.ctrlDown == nil {
		setupCtrlDownWidget()

		var tk *guiWidget
		tk = me.ctrlDown.TK.(*guiWidget)
		tk.labelN = found.String()
		tk.cuiName = "ctrlDown"
		// me.ctrlDown.parent = me.rootNode
	}
	var tk *guiWidget
	tk = me.ctrlDown.TK.(*guiWidget)
	if found == nil {
		found = me.treeRoot
	}
	tk.labelN = found.String()
	foundtk := found.TK.(*guiWidget)
	newR := foundtk.realGocuiSize()
	tk.gocuiSize.w0 = newR.w0
	tk.gocuiSize.h0 = newR.h0
	tk.gocuiSize.w1 = newR.w1
	tk.gocuiSize.h1 = newR.h1
	if tk.Visible() {
		// me.ctrlDown.hideView()
	} else {
		// me.ctrlDown.showView()
	}
	// me.ctrlDown.showWidgetPlacement("ctrlDown:")
	return nil
}