146 lines
3.4 KiB
Go
146 lines
3.4 KiB
Go
// 12 december 2015
|
|
|
|
package ui
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
// #include "pkgui.h"
|
|
import "C"
|
|
|
|
// no need to lock this; only the GUI thread can access it
|
|
var controls = make(map[*C.uiControl]Control)
|
|
|
|
// Control represents a GUI control. It provdes methods
|
|
// common to all Controls.
|
|
//
|
|
// The preferred way to create new Controls is to use
|
|
// ControlBase; see ControlBase below.
|
|
type Control interface {
|
|
// LibuiControl returns the uiControl pointer for the Control.
|
|
// This is intended for use when adding a control to a
|
|
// container.
|
|
LibuiControl() uintptr
|
|
|
|
// Destroy destroys the Control.
|
|
Destroy()
|
|
|
|
// Handle returns the OS-level handle that backs the
|
|
// Control. On OSs that use reference counting for
|
|
// controls, Handle does not increment the reference
|
|
// count; you are sharing package ui's reference.
|
|
Handle() uintptr
|
|
|
|
// Visible returns whether the Control is visible.
|
|
Visible() bool
|
|
|
|
// Show shows the Control.
|
|
Show()
|
|
|
|
// Hide shows the Control. Hidden controls do not participate
|
|
// in layout (that is, Box, Grid, etc. does not reserve space for
|
|
// hidden controls).
|
|
Hide()
|
|
|
|
// Enabled returns whether the Control is enabled.
|
|
Enabled() bool
|
|
|
|
// Enable enables the Control.
|
|
Enable()
|
|
|
|
// Disable disables the Control.
|
|
Disable()
|
|
}
|
|
|
|
// ControlBase is an implementation of Control that provides
|
|
// all the methods that Control requires. To use it, embed a
|
|
// ControlBase (not a *ControlBase) into your structure, then
|
|
// assign the result of NewControlBase to that field:
|
|
//
|
|
// type MyControl struct {
|
|
// ui.ControlBase
|
|
// c *C.MyControl
|
|
// }
|
|
//
|
|
// func NewMyControl() *MyControl {
|
|
// m := &NewMyControl{
|
|
// c: C.newMyControl(),
|
|
// }
|
|
// m.ControlBase = ui.NewControlBase(m, uintptr(unsafe.Pointer(c)))
|
|
// return m
|
|
// }
|
|
type ControlBase struct {
|
|
iface Control
|
|
c *C.uiControl
|
|
}
|
|
|
|
// NewControlBase creates a new ControlBase. See the
|
|
// documentation of ControlBase for an example.
|
|
// NewControl should only be called once per instance of Control.
|
|
func NewControlBase(iface Control, c uintptr) ControlBase {
|
|
b := ControlBase{
|
|
iface: iface,
|
|
c: (*C.uiControl)(unsafe.Pointer(c)),
|
|
}
|
|
controls[b.c] = b.iface
|
|
return b
|
|
}
|
|
|
|
func (c *ControlBase) LibuiControl() uintptr {
|
|
return uintptr(unsafe.Pointer(c.c))
|
|
}
|
|
|
|
func (c *ControlBase) Destroy() {
|
|
delete(controls, c.c)
|
|
C.uiControlDestroy(c.c)
|
|
}
|
|
|
|
func (c *ControlBase) Handle() uintptr {
|
|
return uintptr(C.uiControlHandle(c.c))
|
|
}
|
|
|
|
func (c *ControlBase) Visible() bool {
|
|
return tobool(C.uiControlVisible(c.c))
|
|
}
|
|
|
|
func (c *ControlBase) Show() {
|
|
C.uiControlShow(c.c)
|
|
}
|
|
|
|
func (c *ControlBase) Hide() {
|
|
C.uiControlHide(c.c)
|
|
}
|
|
|
|
func (c *ControlBase) Enabled() bool {
|
|
return tobool(C.uiControlEnabled(c.c))
|
|
}
|
|
|
|
func (c *ControlBase) Enable() {
|
|
C.uiControlEnable(c.c)
|
|
}
|
|
|
|
func (c *ControlBase) Disable() {
|
|
C.uiControlDisable(c.c)
|
|
}
|
|
|
|
// ControlFromLibui returns the Control associated with a libui
|
|
// uiControl. This is intended for implementing event handlers
|
|
// on the Go side, to prevent sharing Go pointers with C.
|
|
// This function only works on Controls that use ControlBase.
|
|
func ControlFromLibui(c uintptr) Control {
|
|
// comma-ok form to avoid creating nil entries
|
|
cc, _ := controls[(*C.uiControl)(unsafe.Pointer(c))]
|
|
return cc
|
|
}
|
|
|
|
func touiControl(c uintptr) *C.uiControl {
|
|
return (*C.uiControl)(unsafe.Pointer(c))
|
|
}
|
|
|
|
// LibuiFreeText allows implementations of Control
|
|
// to call the libui function uiFreeText.
|
|
func LibuiFreeText(c uintptr) {
|
|
C.uiFreeText((*C.char)(unsafe.Pointer(c)))
|
|
}
|