Noah Petherbridge
07cefb6499
* New and completed widgets: Menu, MenuButton and MenuBar.
* MenuButton is a kind of Button that opens a popup Menu when clicked.
* MenuBar is a container of buttons designed to be attached to the top
of an application window ("File, Edit, View, Help")
* Supervisor manages the popup menus with its new concept of a Modal
Widget. Modal widgets take exclusive event priority for all mouse and
key events. The pop-up menu is a modal window, which means you must
click an option inside the menu OR clicking outside the menu will
close it and eat your click event (widgets outside the modal don't
receive events, but the modal itself gets an event that you've done
this).
80 lines
1.9 KiB
Go
80 lines
1.9 KiB
Go
package ui
|
|
|
|
import (
|
|
"git.kirsle.net/go/render"
|
|
)
|
|
|
|
// AbsolutePosition computes a widget's absolute X,Y position on the
|
|
// window on screen by crawling its parent widget tree.
|
|
func AbsolutePosition(w Widget) render.Point {
|
|
abs := w.Point()
|
|
|
|
var (
|
|
node = w
|
|
ok bool
|
|
)
|
|
|
|
for {
|
|
node, ok = node.Parent()
|
|
if !ok { // reached the top of the tree
|
|
return abs
|
|
}
|
|
|
|
abs.Add(node.Point())
|
|
}
|
|
}
|
|
|
|
// AbsoluteRect returns a Rect() offset with the absolute position.
|
|
// X and Y are the AbsolutePosition of the widget.
|
|
// W and H are the widget's width and height. (X,Y not added to them)
|
|
func AbsoluteRect(w Widget) render.Rect {
|
|
var (
|
|
P = AbsolutePosition(w)
|
|
R = w.Rect()
|
|
)
|
|
return render.Rect{
|
|
X: P.X,
|
|
Y: P.Y,
|
|
W: R.W,
|
|
H: R.H, // TODO: the Canvas in EditMode lets you draw pixels
|
|
// below the status bar if we do `+ R.Y` here.
|
|
}
|
|
}
|
|
|
|
// HasParent returns whether the target widget is a descendant of the parent.
|
|
// This scans the parents of the widget recursively until it finds a match.
|
|
func HasParent(w Widget, parent Widget) bool {
|
|
next, ok := w.Parent()
|
|
for ok {
|
|
if next == parent {
|
|
return true
|
|
}
|
|
next, ok = next.Parent()
|
|
}
|
|
return false
|
|
}
|
|
|
|
// widgetInFocusedWindow returns whether a widget (like a Button) is a
|
|
// descendant of a Window that is being Window Managed by Supervisor, and
|
|
// said window is in a Focused state.
|
|
//
|
|
// This is used by Supervisor to decide whether the widget should be given
|
|
// events or not: a widget in a non-focused window ignores events, so that a
|
|
// button in a "lower" window could not be clicked through a "higher" window
|
|
// that overlaps it.
|
|
func widgetInFocusedWindow(w Widget) (isManaged, isFocused bool) {
|
|
var node = w
|
|
|
|
for {
|
|
// Is the node a Window?
|
|
if window, ok := node.(*Window); ok {
|
|
return window.managed, window.Focused()
|
|
}
|
|
|
|
node, _ = node.Parent()
|
|
if node == nil {
|
|
return false, true // reached the root
|
|
}
|
|
}
|
|
}
|