base

type App struct {
	// This is the App as a [goosi.App] interface, which preserves the actual identity
	// of the app when calling interface methods in the base App.
	This goosi.App `view:"-"`

	// Mu is the main mutex protecting access to app operations, including [App.RunOnMain] functions.
	Mu sync.Mutex `view:"-"`

	// MainQueue is the queue of functions to call on the main loop.
	// To add to it, use [App.RunOnMain].
	MainQueue chan FuncRun `view:"-"`

	// MainDone is a channel on which is a signal is sent when the main
	// loop of the app should be terminated.
	MainDone chan struct{} `view:"-"`

	// Nm is the name of the app.
	Nm string `label:"Name"`

	// OpenFls are files that have been set by the operating system to open at startup.
	OpenFls []string `label:"Open files"`

	// Quitting is whether the app is quitting and thus closing all of the windows
	Quitting bool

	// QuitReqFunc is a function to call when a quit is requested
	QuitReqFunc func()

	// QuitCleanFuncs are functions to call when the app is about to quit
	QuitCleanFuncs []func()

	// Dark is whether the system color theme is dark (as opposed to light)
	Dark bool
}

type AppMulti[W goosi.Window] struct {
	App

	// Windows are the windows associated with the app
	Windows []W

	// Screens are the screens associated with the app
	Screens []*goosi.Screen

	// AllScreens is a unique list of all screens ever seen, from which
	// information can be got if something is missing in [AppMulti.Screens]
	AllScreens []*goosi.Screen

	// CtxWindow is a dynamically set context window used for some operations
	CtxWindow W `label:"Context window"`
}

type AppSingle[D goosi.Drawer, W goosi.Window] struct {
	App

	// EvMgr is the event manager for the app
	EvMgr events.Mgr `label:"Event manger"`

	// Draw is the single [goosi.Drawer] used for the app.
	Draw D

	// Win is the single [goosi.Window] associated with the app.
	Win W `label:"Window"`

	// Scrn is the single [goosi.Screen] associated with the app.
	Scrn *goosi.Screen `label:"Screen"`

	// Insets are the size of any insets on the sides of the screen.
	Insets styles.Sides[int]
}

type AppSingler interface {
	goosi.App

	// EventMgr returns the single [events.Mgr] associated with this app.
	EventMgr() *events.Mgr

	// Drawer returns the single [goosi.Drawer] associated with this app.
	Drawer() goosi.Drawer

	// RenderGeom returns the actual effective geometry of the window used
	// for rendering content, which may be different from {0, [goosi.Screen.PixSize]}
	// due to insets caused by things like status bars and button overlays.
	RenderGeom() mat32.Geom2DInt
}

type FuncRun struct {
	F    func()
	Done chan struct{}
}

type Window[A goosi.App] struct {

	// This is the Window as a [goosi.Window] interface, which preserves the actual identity
	// of the window when calling interface methods in the base Window.
	This goosi.Window `view:"-"`

	// App is the [goosi.App] associated with the window.
	App A

	// Mu is the main mutex protecting access to window operations, including [Window.RunOnWin] functions.
	Mu sync.Mutex `view:"-"`

	// WinClose is a channel on which a single is sent to indicate that the
	// window should close.
	WinClose chan struct{} `view:"-"`

	// CloseReqFunc is the function to call on a close request
	CloseReqFunc func(win goosi.Window)

	// CloseCleanFunc is the function to call to close the window
	CloseCleanFunc func(win goosi.Window)

	// Nm is the name of the window
	Nm string `label:"Name"`

	// Titl is the title of the window
	Titl string `label:"Title"`

	// Flgs contains the flags associated with the window
	Flgs goosi.WindowFlags `label:"Flags" tableview:"-"`

	// FPS is the FPS (frames per second) for rendering the window
	FPS int

	// DestroyGPUFunc should be set to a function that will destroy GPU resources
	// in the main thread prior to destroying the drawer
	// and the surface; otherwise it is difficult to
	// ensure that the proper ordering of destruction applies.
	DestroyGPUFunc func()

	// CursorEnabled is whether the cursor is currently enabled
	CursorEnabled bool
}

type WindowMulti[A goosi.App, D goosi.Drawer] struct {
	Window[A]

	// EvMgr is the event manager for the window
	EvMgr events.Mgr `label:"Event manger"`

	// Draw is the [goosi.Drawer] used for this window.
	Draw D `label:"Drawer"`

	// Pos is the position of the window
	Pos image.Point `label:"Position"`

	// WnSize is the size of the window in window manager coordinates
	WnSize image.Point `label:"Window manager size"`

	// PixSize is the pixel size of the window in raw display dots
	PixSize image.Point `label:"Pixel size"`

	// DevicePixelRatio is a factor that scales the screen's
	// "natural" pixel coordinates into actual device pixels.
	// On OS-X, it is backingScaleFactor = 2.0 on "retina"
	DevicePixelRatio float32

	// PhysicalDPI is the physical dots per inch of the screen,
	// for generating true-to-physical-size output.
	// It is computed as 25.4 * (PixSize.X / PhysicalSize.X)
	// where 25.4 is the number of mm per inch.
	PhysDPI float32 `label:"Physical DPI"`

	// LogicalDPI is the logical dots per inch of the screen,
	// which is used for all rendering.
	// It is: transient zoom factor * screen-specific multiplier * PhysicalDPI
	LogDPI float32 `label:"Logical DPI"`
}

type WindowSingle[A AppSingler] struct {
	Window[A]
}