WIP: Keyboard only operation

cmd/fyne_demo/screens/window.go

@@ -187,7 +187,12 @@ func loadWindowGroup() fyne.Widget {
 		}),
 		widget.NewButton("Fixed size window", func() {
 			w := fyne.CurrentApp().NewWindow("Fixed")
-			w.SetContent(fyne.NewContainerWithLayout(layout.NewCenterLayout(), widget.NewLabel("Hello World!")))
+			w.SetContent(fyne.NewContainerWithLayout(
+				layout.NewGridLayoutWithRows(3),
+				widget.NewLabel("Hello World!"),
+				widget.NewButton("Cancel", func() {w.Close()}),
+				widget.NewButton("OK", func() {w.Close()})),
+			)
 
 			w.Resize(fyne.NewSize(240, 180))
 			w.SetFixedSize(true)

dialog/base.go

@@ -38,6 +38,7 @@ type dialog struct {
 	content, label fyne.CanvasObject
 	dismiss        *widget.Button
 	parent         fyne.Window
+	oldFocus	   fyne.Focusable
 }
 
 // SetOnClosed allows to set a callback function that is called when
@@ -144,9 +145,16 @@ func newButtonList(buttons ...*widget.Button) fyne.CanvasObject {
 func (d *dialog) Show() {
 	d.sendResponse = true
 	d.win.Show()
+	d.oldFocus = d.win.Canvas.Focused()
+	if d.dismiss!=nil {
+		d.win.Canvas.Focus(d.dismiss)
+	} else {
+		d.win.Canvas.Focus(nil)
+	}
 }
 
 func (d *dialog) Hide() {
+	d.win.Canvas.Focus(d.oldFocus)
 	d.hideWithResponse(false)
 }
 

internal/app/focus.go

@@ -13,7 +13,12 @@ type FocusManager struct {
 func (f *FocusManager) nextInChain(current fyne.Focusable) fyne.Focusable {
 	var first, next fyne.Focusable
 	found := current == nil // if we have no starting point then pretend we matched already
-	driver.WalkVisibleObjectTree(f.canvas.Content(), func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
+	//OBS driver.WalkVisibleObjectTree(f.cavas.Content(), func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
+	content := f.canvas.Overlays().Top()
+	if content==nil {
+		content = f.canvas.Content()
+	}
+	driver.WalkVisibleObjectTree(content, func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
 		if w, ok := obj.(fyne.Disableable); ok && w.Disabled() {
 			// disabled widget cannot receive focus
 			return false
@@ -48,7 +53,13 @@ func (f *FocusManager) nextInChain(current fyne.Focusable) fyne.Focusable {
 func (f *FocusManager) previousInChain(current fyne.Focusable) fyne.Focusable {
 	var last, previous fyne.Focusable
 	found := false
-	driver.WalkVisibleObjectTree(f.canvas.Content(), func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
+
+	content := f.canvas.Overlays().Top()
+	if content==nil {
+		content = f.canvas.Content()
+	}
+	driver.WalkVisibleObjectTree(content, func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
+	//OBS driver.WalkVisibleObjectTree(f.canvas.Content(), func(obj fyne.CanvasObject, _ fyne.Position, _ fyne.Position, _ fyne.Size) bool {
 		if w, ok := obj.(fyne.Disableable); ok && w.Disabled() {
 			// disabled widget cannot receive focus
 			return false

internal/driver/glfw/menu_bar.go

@@ -16,11 +16,41 @@ var _ fyne.Widget = (*MenuBar)(nil)
 // MenuBar is a widget for displaying a fyne.MainMenu in a bar.
 type MenuBar struct {
 	widget.Base
-	Items []fyne.CanvasObject
-
+	Items      []fyne.CanvasObject
+	index      int
 	active     bool
-	activeItem *menuBarItem
 	canvas     fyne.Canvas
+	activeItem *menuBarItem
+}
+
+// HandleKey will process keys pressed when menu is open
+func (b *MenuBar) HandleKey(key fyne.KeyName) {
+	if key == fyne.KeyEscape {
+		b.deactivate()
+	} else if key == fyne.KeyEnter || key == fyne.KeyReturn || key == fyne.KeySpace {
+		// Simulate tapping on  menu entry
+		b.Items[b.index].(*menuBarItem).Child().Do()
+	} else if key == fyne.KeyRight {
+		// Move to the menu item at right
+		if b.index < len(b.Items)-1 {
+			b.Items[b.index].(*menuBarItem).Tapped(nil)
+			b.index++
+			b.Items[b.index].(*menuBarItem).Tapped(nil)
+		}
+	} else if key == fyne.KeyLeft {
+		// Move to the menu item at left
+		if b.index > 0 {
+			b.Items[b.index].(*menuBarItem).Tapped(nil)
+			b.index--
+			b.Items[b.index].(*menuBarItem).Tapped(nil)
+		}
+	} else if key == fyne.KeyUp {
+		// Move focus to menu item above
+		b.Items[b.index].(*menuBarItem).Child().Up()
+	} else if key == fyne.KeyDown {
+		// Move focus to menu item below
+		b.Items[b.index].(*menuBarItem).Child().Down()
+	}
 }
 
 // NewMenuBar creates a menu bar populated with items from the passed main menu structure.
@@ -106,6 +136,7 @@ func (b *MenuBar) activateChild(item *menuBarItem) {
 		return
 	}
 
+
 	item.Child().Show()
 	b.Refresh()
 }
@@ -114,7 +145,7 @@ func (b *MenuBar) deactivate() {
 	if !b.active {
 		return
 	}
-
+	b.active = false
 	b.active = false
 	if b.activeItem != nil {
 		defer b.activeItem.Child().Dismiss()

internal/driver/glfw/menu_bar_item.go

@@ -112,11 +112,22 @@ func (i *menuBarItem) Show() {
 // Tapped toggles the activation state of the menu bar.
 // It shows the item’s menu if the bar is activated and hides it if the bar is deactivated.
 // Implements: fyne.Tappable
-func (i *menuBarItem) Tapped(*fyne.PointEvent) {
+func (i *menuBarItem) Tapped(pos *fyne.PointEvent) {
 	if i.Parent.active {
 		i.Parent.deactivate()
 	} else {
+		// Set then menu bar's index to the tapped items index and update focus
 		i.Parent.activateChild(i)
+		for j := 0; j < len(i.Parent.Items); j++ {
+			if i.Parent.Items[j] == i {
+				i.Parent.index = j
+				if pos==nil {
+					i.Parent.Items[i.Parent.index].(*menuBarItem).Child().Up()
+				} else {
+					i.Parent.Items[i.Parent.index].(*menuBarItem).Child().Defocus()
+				}
+			}
+		}
 	}
 }
 
@@ -130,7 +141,6 @@ func (r *menuBarItemRenderer) BackgroundColor() color.Color {
 	if r.i.hovered || (r.i.child != nil && r.i.child.Visible()) {
 		return theme.HoverColor()
 	}
-
 	return color.Transparent
 }
 

internal/driver/glfw/menu_bar_test.go

@@ -112,7 +112,7 @@ func TestMenuBar(t *testing.T) {
 				},
 				{
 					actions:   []action{{"tap", buttonPos}},
-					wantImage: "menu_bar_hovered_content.png",
+					wantImage: "menu_bar_hovered_focused_content.png",
 				},
 			},
 		},
@@ -182,7 +182,7 @@ func TestMenuBar(t *testing.T) {
 				{
 					actions:    []action{{"tap", fileNewPos}},
 					wantAction: "new",
-					wantImage:  "menu_bar_initial.png",
+					wantImage:  "menu_bar_initial1.png",
 				},
 			},
 		},
@@ -198,7 +198,7 @@ func TestMenuBar(t *testing.T) {
 				{
 					actions:    []action{{"tap", fileOpenPos}},
 					wantAction: "open",
-					wantImage:  "menu_bar_initial.png",
+					wantImage:  "menu_bar_initial2.png",
 				},
 			},
 		},
@@ -222,7 +222,7 @@ func TestMenuBar(t *testing.T) {
 				{
 					actions:    []action{{"tap", fileRecentOlderOld1Pos}},
 					wantAction: "old 1",
-					wantImage:  "menu_bar_initial.png",
+					wantImage:  "menu_bar_initial3.png",
 				},
 			},
 		},
@@ -305,7 +305,7 @@ func TestMenuBar(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			test.MoveMouse(c, fyne.NewPos(0, 0))
 			test.TapCanvas(c, fyne.NewPos(0, 0))
-			test.AssertImageMatches(t, "menu_bar_initial.png", c.Capture())
+			test.AssertImageMatches(t, "menu_bar_initial4.png", c.Capture())
 			for i, s := range tt.steps {
 				t.Run("step "+strconv.Itoa(i+1), func(t *testing.T) {
 					lastAction = ""

internal/driver/glfw/window.go

@@ -15,6 +15,7 @@ import (
 	"fyne.io/fyne/internal/cache"
 	"fyne.io/fyne/internal/driver"
 	"fyne.io/fyne/internal/painter/gl"
+	"fyne.io/fyne/widget"
 
 	"github.com/go-gl/glfw/v3.3/glfw"
 )
@@ -621,11 +622,19 @@ func (w *window) mouseClicked(_ *glfw.Window, btn glfw.MouseButton, action glfw.
 		}
 	}
 
+	needsfocus := false
 	if layer != 1 { // 0 - overlay, 1 - menu, 2 - content
-		if wid, ok := co.(fyne.Focusable); ok {
-			w.canvas.Focus(wid)
-		} else {
-			w.canvas.Unfocus()
+		needsfocus = true
+
+		if wid := w.canvas.Focused(); wid != nil {
+			if wid.(fyne.CanvasObject) != co {
+				// Avoid changing focus when a toolbar button is pressed.
+				if _, isToolbarButton := co.(*widget.ToolbarButton); !isToolbarButton {
+					w.canvas.Unfocus()
+				}
+			} else {
+				needsfocus = false
+			}
 		}
 	}
 
@@ -635,6 +644,13 @@ func (w *window) mouseClicked(_ *glfw.Window, btn glfw.MouseButton, action glfw.
 		w.mouseButton = 0
 	}
 
+git	// we cannot switch here as objects may respond to multiple cases
+	if wid, ok := co.(fyne.Focusable); ok && needsfocus {
+		if dis, ok := wid.(fyne.Disableable); !ok || !dis.Disabled() {
+			w.canvas.Focus(wid)
+		}
+	}
+
 	// Check for double click/tap
 	doubleTapped := false
 	if action == glfw.Release && button == desktop.LeftMouseButton {
@@ -857,7 +873,26 @@ func (w *window) keyPressed(viewport *glfw.Window, key glfw.Key, scancode int, a
 	keyEvent := &fyne.KeyEvent{Name: keyName}
 	keyDesktopModifier := desktopModifier(mods)
 
-	if keyName == fyne.KeyTab {
+	// Activate the menu when the Alt key is pressed
+	focused := w.canvas.Focused()
+	isMenu := false
+	menu, ok := w.canvas.menu.(*MenuBar)
+	if ok {
+		isMenu = menu.active
+		if !isMenu && action == glfw.Press && (key == glfw.KeyLeftAlt || key == glfw.KeyRightAlt) &&
+			keyDesktopModifier == desktop.AltModifier {
+			mbi := menu.Items[0].(*menuBarItem)
+			mbi.Tapped(nil)
+		}
+	}
+	if isMenu {
+		if action == glfw.Release {
+			menu.HandleKey(keyName)
+		}
+		return
+	}
+
+	if keyName == fyne.KeyTab && action != glfw.Release && !isMenu {
 		if keyDesktopModifier == 0 {
 			if action != glfw.Release {
 				w.canvas.focusMgr.FocusNext(w.canvas.focused)
@@ -950,7 +985,6 @@ func (w *window) keyPressed(viewport *glfw.Window, key glfw.Key, scancode int, a
 	}
 
 	// No shortcut detected, pass down to TypedKey
-	focused := w.canvas.Focused()
 	if focused != nil {
 		w.queueEvent(func() { focused.TypedKey(keyEvent) })
 	} else if w.canvas.onTypedKey != nil {

theme/theme.go

@@ -61,6 +61,39 @@ func DarkTheme() fyne.Theme {
 	return theme
 }
 
+// shade will darken a light color and lighten a light color by the given % value
+// should use 4,8, 12 or 14 percent darken/lighten to implement google material design rules
+func Shade(c color.Color, pct uint32) color.Color {
+	r, g, b, a := c.RGBA()
+	if pct == 0 {
+		return color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}
+	}
+	if pct > 50 {
+		pct = 50
+	}
+	if r+g+b < 3*0x8080 {
+		// Lighten
+		return color.NRGBA{
+			R: uint8((r + (0x10000-r)*pct/50) >> 8),
+			G: uint8((g + (0x10000-g)*pct/50) >> 8),
+			B: uint8((b + (0x10000-b)*pct/50) >> 8),
+			A: uint8(a >> 8),
+		}
+	} else {
+		// Darken
+		return color.NRGBA{
+			R: uint8((r * (100 - pct) / 100) >> 8),
+			G: uint8((g * (100 - pct) / 100) >> 8),
+			B: uint8((b * (100 - pct) / 100) >> 8),
+			A: uint8(a >> 8),
+		}
+	}
+}
+
+const PressedShade = 14
+	const HoveredShade = 4
+const FocusedShade = 8
+
 func (t *builtinTheme) BackgroundColor() color.Color {
 	return t.background
 }
@@ -117,7 +150,7 @@ func (t *builtinTheme) HoverColor() color.Color {
 
 // FocusColor returns the color used to highlight a focused widget
 func (t *builtinTheme) FocusColor() color.Color {
-	return t.primary
+	return Shade(t.primary, FocusedShade)
 }
 
 // ScrollBarColor returns the color (and translucency) for a scrollBar
@@ -276,6 +309,16 @@ func HoverColor() color.Color {
 	return current().HoverColor()
 }
 
+// PressedColor returns the colour used for a pressed button
+func PressedColor() color.Color {
+	return Shade(FocusColor(), PressedShade)
+}
+
+// HoverFocused returns the colour used for a focused/primary hovered button
+func HoverFocusedColor() color.Color {
+	return Shade(FocusColor(), HoveredShade)
+}
+
 // FocusColor returns the color used to highlight a focussed widget
 func FocusColor() color.Color {
 	return current().FocusColor()