new-gui/structs.go

package gui

import (
	"sync"
	"embed"
	"go.wit.com/gui/widget"
)

//
// All GUI Data Structures and functions that are external
// within the toolkit/ abstraction layer
//
// More than one Window does not exist in every GUI situtaion and
// can never be. On many toolkits you have to have 'tabs', like
// Native Windows and MacOS toolkits
//
// If that is the case, this code abstracts the concept of
// windows and makes each window a 'tab' in a single window.
//
// Reminder from Goals: This is for simple GUI's.
// For example, a "Mouse Control Panel" not the GIMP or blender.
//

var me guiConfig

// Range(1, 10) includes the values 1 and 10
// almost all toolkits use integers so there doesn't
// seem to be a good idea to use 'type any' here as it
// just makes things more complicated for no good reason
type RangeMovedToWidget struct {
	Low int
	High int
}

// type List []string

type guiConfig struct {
	// a toolkit requirement. never allow more than one per program
	initOnce sync.Once

	// This is the master node. The Binary Tree starts here
	rootNode *Node

	// A node off of rootNode for passing debugging flags
	flag	*Node

	counter    int  // used to make unique WidgetId's

	// sets the chan for the plugins to call back too
	guiChan chan widget.Action

	// option to pass in compiled plugins as embedded files
	resFS	embed.FS

	// used to beautify logging to Stdout
//	depth      int
//	prefix     string
}

/*
	The Node is a binary tree. This is how all GUI elements are stored
	simply the name and the size of whatever GUI element exists

	value : most widgets need 1 value. this is it.
		For a window -- the title. For a button -- the name

	hidden : this means the widget is not displayed yet. In that
		case, don't waste time trying to pass information to
		the toolkits. This makes things efficient and fast if
		the GUI does not have to display anything

	Custom() : if the user does something like click on a button,
		this function will be called. (this should probably
		be renamed Callback()

	progname : a short name to reference the widgets in the debugger
		n.NewButton("click here to send it").SetProgName("SENT")

	parent, children : the binary tree

	pad, margin, expand : re-think these names and clarify

*/

type Node struct {
	id	int // should be unique
	hidden	bool // don't update the toolkits when it's hidden
	changed bool // do we need to inform the toolkit something changed?
	enabled bool // if false, then the the user can't click on it

	WidgetType	widget.WidgetType

	// most widgets need one value, this is current alue
	value	any

	// this can programatically identify the widget
	// The name must be unique
	progname string  // a name useful for debugging

	// for widgets that a user select from a list of strings
	strings []string

	// how to arrange widgets
	direction widget.Orientation

	// this function is run when there are mouse or keyboard events
	Custom func()

	parent	*Node
	children []*Node


	// RETHINK EVERYTHING BELOW HERE
	pad	bool // the toolkit may use this. it's up to the toolkit
	margin	bool // the toolkit may use this. it's up to the toolkit
	expand	bool // the toolkit may use this. it's up to the toolkit


	// used for Windows in toolkits measured in pixels
	width  int
	height int

	// used for anything that needs a range (for example: a slider)
	X	int
	Y	int

	// the grid widget max width and height
	// the max height can be implemented in the toolkit plugin
	// to restrict the number of rows to display
	W	int
	H	int

	// where the next widget should be put in this grid
	NextW	int
	NextH	int

	// if this widget is in a grid, this is the position of a widget
	AtW	int
	AtH	int
}