WIP: Button can be configured to accept multiple keys as triggers.

widgets/button/button.go

@@ -220,7 +220,7 @@ func (b *Button) Options() widgetapi.Options {
 	return widgetapi.Options{
 		MinimumSize:  image.Point{width, height},
 		MaximumSize:  image.Point{width, height},
-		WantKeyboard: b.opts.keyScope,
+		WantKeyboard: widgetapi.KeyScopeGlobal,
 		WantMouse:    widgetapi.MouseScopeGlobal,
 	}
 }

widgets/button/formdemo/formdemo.go

@@ -0,0 +1,115 @@
+// Copyright 2019 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Binary buttondemo shows the functionality of a button widget.
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/mum4k/termdash"
+	"github.com/mum4k/termdash/align"
+	"github.com/mum4k/termdash/cell"
+	"github.com/mum4k/termdash/container"
+	"github.com/mum4k/termdash/linestyle"
+	"github.com/mum4k/termdash/terminal/tcell"
+	"github.com/mum4k/termdash/terminal/terminalapi"
+	"github.com/mum4k/termdash/widgets/button"
+	"github.com/mum4k/termdash/widgets/segmentdisplay"
+)
+
+func main() {
+	t, err := tcell.New()
+	if err != nil {
+		panic(err)
+	}
+	defer t.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	val := 0
+	display, err := segmentdisplay.New()
+	if err != nil {
+		panic(err)
+	}
+	if err := display.Write([]*segmentdisplay.TextChunk{
+		segmentdisplay.NewChunk(fmt.Sprintf("%d", val)),
+	}); err != nil {
+		panic(err)
+	}
+
+	addB, err := button.New("<Submit>", func() error {
+		val++
+		return display.Write([]*segmentdisplay.TextChunk{
+			segmentdisplay.NewChunk(fmt.Sprintf("%d", val)),
+		})
+	},
+		button.GlobalKey('s'),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	subB, err := button.New("<Cancel>", func() error {
+		val--
+		return display.Write([]*segmentdisplay.TextChunk{
+			segmentdisplay.NewChunk(fmt.Sprintf("%d", val)),
+		})
+	},
+		button.FillColor(cell.ColorNumber(220)),
+		button.GlobalKey('c'),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	c, err := container.New(
+		t,
+		container.Border(linestyle.Light),
+		container.BorderTitle("PRESS Q TO QUIT"),
+		container.SplitHorizontal(
+			container.Top(
+				container.PlaceWidget(display),
+			),
+			container.Bottom(
+				container.SplitVertical(
+					container.Left(
+						container.PlaceWidget(addB),
+						container.AlignHorizontal(align.HorizontalRight),
+					),
+					container.Right(
+						container.PlaceWidget(subB),
+						container.AlignHorizontal(align.HorizontalLeft),
+					),
+				),
+			),
+			container.SplitPercent(60),
+		),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	quitter := func(k *terminalapi.Keyboard) {
+		if k.Key == 'q' || k.Key == 'Q' {
+			cancel()
+		}
+	}
+
+	if err := termdash.Run(ctx, t, c, termdash.KeyboardSubscriber(quitter), termdash.RedrawInterval(100*time.Millisecond)); err != nil {
+		panic(err)
+	}
+}

widgets/button/options.go

@@ -47,8 +47,7 @@ type options struct {
 	shadowColor cell.Color
 	height      int
 	width       int
-	key         keyboard.Key
-	keyScope    widgetapi.KeyScope
+	keyScopes   []*keyScope
 	keyUpDelay  time.Duration
 }
 
@@ -66,6 +65,12 @@ func (o *options) validate() error {
 	return nil
 }
 
+// keyScope stores a key and its scope.
+type keyScope struct {
+	key   keyboard.Key
+	scope widgetapi.KeyScope
+}
+
 // newOptions returns options with the default values set.
 func newOptions(text string) *options {
 	return &options{
@@ -129,23 +134,31 @@ func WidthFor(text string) Option {
 	})
 }
 
-// Key configures the keyboard key that presses the button.
+// Key configures the keyboard keys that press the button.
+// Can be specified multiple times to provide multiple keys.
 // The widget responds to this key only if its container is focused.
 // When not provided, the widget ignores all keyboard events.
 func Key(k keyboard.Key) Option {
 	return option(func(opts *options) {
-		opts.key = k
-		opts.keyScope = widgetapi.KeyScopeFocused
+		ks := &keyScope{
+			key:   k,
+			scope: widgetapi.KeyScopeFocused,
+		}
+		opts.keyScopes = append(opts.keyScopes, ks)
 	})
 }
 
-// GlobalKey is like Key, but makes the widget respond to the key even if its
+// GlobalKey is like Key, but makes the widget respond to the keys even if its
 // container isn't focused.
+// Can be specified multiple times to provide multiple keys.
 // When not provided, the widget ignores all keyboard events.
 func GlobalKey(k keyboard.Key) Option {
 	return option(func(opts *options) {
-		opts.key = k
-		opts.keyScope = widgetapi.KeyScopeGlobal
+		ks := &keyScope{
+			key:   k,
+			scope: widgetapi.KeyScopeGlobal,
+		}
+		opts.keyScopes = append(opts.keyScopes, ks)
 	})
 }