Keep desktop detail pane visible

.codex/skills/keepassgo-ship-it/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: keepassgo-ship-it
+description: KeePassGO-specific ship workflow. Use when the user says `ship it` in this repository and expects the current work to be committed, the Arch package rebuilt and installed, the Android APK rebuilt and zipped, the ZIP uploaded to Nextcloud, and the rebuilt app launched in the emulator with a controlled demo vault opened.
+---
+
+# KeePassGO Ship It
+
+Use this skill only in the KeePassGO repository. This is not a global shorthand.
+
+Use it together with:
+- `android-emulator-debug` for emulator and `adb` mechanics
+- `keepass-credentials` for Nextcloud credentials
+- `public-repo-sanitization` before the commit/push step
+
+## Meaning Of `ship it`
+
+When the user says `ship it`, do all of this unless they narrow the scope:
+
+1. Commit the relevant KeePassGO source changes first.
+2. Build and install the Arch package from that committed source.
+3. Build the Android APK from that same committed source.
+4. Zip the APK.
+5. Upload the ZIP to the user's configured Nextcloud DAV destination for this repository.
+6. Install the rebuilt APK in the emulator.
+7. Launch the rebuilt app in the emulator.
+8. Open a controlled demo vault in the emulator.
+
+Do not stop after the commit or after the package build. `ship it` means finish the full loop.
+
+## Required Sequence
+
+### 1. Commit First
+
+- Make sure the worktree state intended for shipping is committed before building.
+- If the repo is dirty in unrelated ways, commit only the relevant changes.
+- Before the commit or push, run the public-repo sanitization checks.
+
+### 2. Build And Install The Arch Package
+
+From the repo root:
+
+```sh
+make archlinux-pkgbuild
+cd packaging/archlinux/keepassgo-git
+makepkg -si --noconfirm
+```
+
+The installed package version must correspond to the committed source, not a dirty worktree.
+
+### 3. Build The APK
+
+Use the repo's known-good local JDK unless the environment already proves otherwise:
+
+```sh
+JAVA_HOME=/usr/lib/jvm/java-25-openjdk make apk
+```
+
+If that JDK is unavailable on the current host, use the working replacement already established for the machine and say so in the closeout.
+
+### 4. Zip The APK
+
+- Create the ZIP under the globally required temporary secret-safe directory.
+- Use a name that includes the commit, for example:
+  `keepassgo-<shortsha>-apk.zip`
+
+### 5. Upload To Nextcloud
+
+- Get credentials and the DAV endpoint with `keepass-http`, not by asking the user if KeePass likely has them.
+- Prefer the established KeePass entry and DAV destination already in use for this repository's shipping workflow.
+- Use the globally required temporary secret-safe directory for any temporary curl config or secret material.
+- Ensure that directory exists with mode `700`.
+- Create secret temp files with mode `600`.
+- After upload, zero and unlink the temp secret file. Do not use `rm -f` or `rm -rf`.
+
+### 6. Emulator Install And Launch
+
+- Reuse the existing emulator session if one is already running.
+- Install with replacement:
+
+```sh
+adb install -r build/keepassgo.apk
+```
+
+- Launch KeePassGO and confirm it is focused.
+- Treat the emulator as timing-sensitive. If Android shows a transient "Wait" style ANR dialog and the user says the app is otherwise fine, do not misclassify that as an app-logic failure.
+
+### 7. Open A Controlled Demo Vault
+
+- Do not rely on the user's real vault for this step.
+- Use a controlled/sanitized demo vault that you can unlock yourself.
+- Open it in the emulator before closing out `ship it`.
+- Capture a screenshot if needed to verify the app really rendered and opened the vault.
+
+## Closeout Requirements
+
+When reporting back after `ship it`, include:
+- the commit that was shipped
+- the installed Arch package version
+- the APK path
+- the uploaded ZIP URL
+- confirmation that the emulator app was launched
+- confirmation that the controlled demo vault was opened
+
+## Constraints
+
+- Keep this workflow specific to KeePassGO.
+- Preserve emulator state; do not kill or reset it unless the user explicitly asks.
+- Do not use `rm -rf`.
+- Do not use `rm -f`.

internal/appui/app.go

@@ -15,6 +15,7 @@ import (
 	"gioui.org/io/key"
 	"gioui.org/io/pointer"
 	"gioui.org/layout"
+	"gioui.org/op"
 	"gioui.org/op/clip"
 	"gioui.org/op/paint"
 	"gioui.org/unit"
@@ -488,8 +489,12 @@ type ui struct {
 	deleteGroupPath                      []string
 	apiPolicyGroupScope                  bool
 	apiTokenSecret                       string
-	phoneSyncMenuAnchor                  image.Point
-	phoneMainMenuAnchor                  image.Point
+	phoneSyncMenuOrigin                  image.Point
+	phoneMainMenuOrigin                  image.Point
+	phoneSyncMenuSize                    image.Point
+	phoneMainMenuSize                    image.Point
+	phoneSyncMenuCall                    op.CallOp
+	phoneMainMenuCall                    op.CallOp
 	phoneSyncMenuVisible                 bool
 	phoneMainMenuVisible                 bool
 	selectedAuditIndex                   int
@@ -1845,8 +1850,17 @@ func (u *ui) navigationHeaderLabel() string {
 
 func (u *ui) entryRow(gtx layout.Context, click *widget.Clickable, idx int, item entry) layout.Dimensions {
 	for click.Clicked(gtx) {
-		_ = u.state.ToggleVisibleIndex(idx)
+		if !u.shouldShowDetailPane() {
+			if idx >= 0 && idx < len(u.visible) {
+				u.state.SelectedEntryID = u.visible[idx].ID
+			}
+		} else {
+			_ = u.state.ToggleVisibleIndex(idx)
+		}
 		u.loadSelectedEntryIntoEditor()
+		if u.invalidate != nil {
+			u.invalidate()
+		}
 	}
 	return click.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
 		selected := item.ID == u.state.SelectedEntryID
@@ -2009,21 +2023,8 @@ func (u *ui) detailPanel(gtx layout.Context) layout.Dimensions {
 	return panel(gtx, func(gtx layout.Context) layout.Dimensions {
 		if u.shouldShowDesktopWorkingHeader() {
 			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
-				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-					return layout.Flex{Alignment: layout.Middle, Spacing: layout.SpaceStart}.Layout(gtx,
-						layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
-							return layout.Dimensions{}
-						}),
-						layout.Rigid(u.syncButtonGroup),
-						layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
-						layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-							btn := material.Button(u.theme, &u.lockVault, "Lock")
-							return btn.Layout(gtx)
-						}),
-						layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
-						layout.Rigid(u.mainMenuButtonGroup),
-					)
-				}),
+				layout.Rigid(u.headerActions),
+				layout.Rigid(u.desktopHeaderMenus),
 				layout.Rigid(layout.Spacer{Height: unit.Dp(12)}.Layout),
 				layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
 					return u.detailPanelContent(gtx)
@@ -2044,7 +2045,7 @@ func (u *ui) detailPanelContent(gtx layout.Context) layout.Dimensions {
 		panel := u.staticDetailPanel()
 		return layout.Flex{Axis: layout.Vertical}.Layout(gtx, panel...)
 	case detaillayout.ModeEmpty:
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx, u.emptyDetailChildren()...)
+		return layout.Dimensions{}
 	}
 	item, ok := u.selectedEntry()
 	if mode == detaillayout.ModeEditor {
@@ -2084,22 +2085,6 @@ func (u *ui) staticDetailPanel() []layout.FlexChild {
 	}
 }
 
-func (u *ui) emptyDetailChildren() []layout.FlexChild {
-	return []layout.FlexChild{
-		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			lbl := material.Label(u.theme, unit.Sp(18), "Entry details")
-			lbl.Color = accentColor
-			return lbl.Layout(gtx)
-		}),
-		layout.Rigid(layout.Spacer{Height: unit.Dp(8)}.Layout),
-		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			lbl := material.Label(u.theme, unit.Sp(16), u.detailPlaceholderMessage())
-			lbl.Color = mutedColor
-			return lbl.Layout(gtx)
-		}),
-	}
-}
-
 func (u *ui) detailEditorContent(gtx layout.Context, hasSelected bool) layout.Dimensions {
 	rows := []layout.Widget{
 		func(gtx layout.Context) layout.Dimensions {

internal/appui/frame.go

@@ -3,6 +3,7 @@ package appui
 import (
 	"errors"
 	"fmt"
+	"image"
 	"path/filepath"
 	"slices"
 	"strings"
@@ -19,6 +20,7 @@ import (
 	"git.julianfamily.org/keepassgo/internal/apiaudit"
 	"git.julianfamily.org/keepassgo/internal/apitokens"
 	"git.julianfamily.org/keepassgo/internal/appstate"
+	detaillayout "git.julianfamily.org/keepassgo/internal/appui/detail/layout"
 	"git.julianfamily.org/keepassgo/internal/clipboard"
 	"git.julianfamily.org/keepassgo/internal/session"
 )
@@ -590,6 +592,12 @@ func (u *ui) layout(gtx layout.Context) layout.Dimensions {
 	paint.FillShape(gtx.Ops, bgColor, clip.Rect{Max: gtx.Constraints.Max}.Op())
 	u.phoneSyncMenuVisible = false
 	u.phoneMainMenuVisible = false
+	u.phoneSyncMenuOrigin = image.Point{}
+	u.phoneMainMenuOrigin = image.Point{}
+	u.phoneSyncMenuSize = image.Point{}
+	u.phoneMainMenuSize = image.Point{}
+	u.phoneSyncMenuCall = op.CallOp{}
+	u.phoneMainMenuCall = op.CallOp{}
 	u.syncHostedAPI()
 	u.filter()
 	u.processShortcuts(gtx)
@@ -615,9 +623,7 @@ func (u *ui) layout(gtx layout.Context) layout.Dimensions {
 		layout.Stacked(u.securityDialogOverlay),
 		layout.Stacked(u.remotePrefsDialogOverlay),
 		layout.Stacked(u.approvalDialogOverlay),
-		layout.Stacked(func(gtx layout.Context) layout.Dimensions {
-			return u.phoneHeaderMenus(gtx)
-		}),
+		layout.Expanded(u.phoneHeaderMenus),
 		layout.Stacked(u.statusToast),
 	)
 }
@@ -679,12 +685,14 @@ func (u *ui) handleHeaderActionClicks(gtx layout.Context) {
 		if u.syncMenuOpen {
 			u.mainMenuOpen = false
 		}
+		u.maybeLogHeaderMenuToggle("sync", u.syncMenuOpen)
 	}
 	for u.toggleMainMenu.Clicked(gtx) {
 		u.mainMenuOpen = !u.mainMenuOpen
 		if u.mainMenuOpen {
 			u.syncMenuOpen = false
 		}
+		u.maybeLogHeaderMenuToggle("main", u.mainMenuOpen)
 	}
 	for u.openAdvancedSync.Clicked(gtx) {
 		u.openAdvancedSyncDialog()
@@ -1303,6 +1311,11 @@ func (u *ui) primaryContent(gtx layout.Context) layout.Dimensions {
 		return u.lifecycleScreen(gtx)
 	case u.shouldUseLockedSinglePane():
 		return u.detailPanel(gtx)
+	case !u.shouldShowDetailPane():
+		if u.usesCompactViewport() {
+			return u.listPanel(gtx)
+		}
+		return u.widePrimaryContent(gtx)
 	case u.usesCompactViewport():
 		return u.compactPrimaryContent(gtx)
 	default:
@@ -1310,6 +1323,17 @@ func (u *ui) primaryContent(gtx layout.Context) layout.Dimensions {
 	}
 }
 
+func (u *ui) shouldShowDetailPane() bool {
+	_, hasSelectedEntry := u.selectedEntry()
+	mode := detaillayout.Resolve(
+		u.isVaultLocked(),
+		u.state.Section == appstate.SectionAPITokens || u.state.Section == appstate.SectionAPIAudit || u.state.Section == appstate.SectionAbout,
+		hasSelectedEntry,
+		u.editingEntry,
+	)
+	return mode != detaillayout.ModeEmpty
+}
+
 func (u *ui) compactPrimaryContent(gtx layout.Context) layout.Dimensions {
 	u.phoneSpan = gtx.Constraints.Max.Y
 	listHeight := int(float32(gtx.Constraints.Max.Y) * u.phoneSplit.Value)

internal/appui/header.go

@@ -36,71 +36,125 @@ func (u *ui) header(gtx layout.Context) layout.Dimensions {
 }
 
 func (u *ui) headerActions(gtx layout.Context) layout.Dimensions {
-	if u.shouldShowLifecycleSetup() || u.isVaultLocked() || u.shouldShowDesktopWorkingHeader() {
+	if u.shouldShowLifecycleSetup() || u.isVaultLocked() {
 		return layout.Dimensions{}
 	}
-	spacing := gtx.Dp(unit.Dp(8))
-	metrics := headerlayout.ActionMetrics{Spacing: spacing, SyncInnerSpacing: gtx.Dp(unit.Dp(3))}
-	if !u.usesCompactViewport() {
-		metrics.SyncInnerSpacing = gtx.Dp(unit.Dp(4))
-	}
-	actionCluster := func(gtx layout.Context) layout.Dimensions {
-		return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				metrics.SyncDims, metrics.SyncPrimaryDims, metrics.SyncToggleDims = u.syncButtonGroupWithMetrics(gtx)
-				return metrics.SyncDims
-			}),
-			layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				btn := material.Button(u.theme, &u.lockVault, "Lock")
-				metrics.LockDims = btn.Layout(gtx)
-				return metrics.LockDims
-			}),
-			layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
-			layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-				metrics.MainDims = u.mainMenuButtonGroup(gtx)
-				return metrics.MainDims
-			}),
-		)
-	}
-
-	rowOps := op.Record(gtx.Ops)
-	metrics.RowDims = actionCluster(gtx)
-	rowCall := rowOps.Stop()
-	metrics.RowOriginX = max(0, gtx.Constraints.Max.X-metrics.RowDims.Size.X)
-
-	surface := headerlayout.DropdownSurface{ContainerWidth: gtx.Constraints.Max.X, LeftInset: 0, TopInset: 0}
-
-	rowDims := layout.E.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
-		rowCall.Add(gtx.Ops)
-		return metrics.RowDims
-	})
+	cluster := u.newHeaderActionCluster(gtx)
+	rowDims := cluster.layout(gtx, u)
 	if u.usesCompactViewport() {
-		u.maybeLogHeaderBounds(newHeaderButtonBounds(image.Pt(u.frameInsetPx, u.frameInsetPx), metrics.Bounds()))
+		u.maybeLogHeaderBounds(newHeaderButtonBounds(image.Pt(u.frameInsetPx, u.frameInsetPx), cluster.Metrics.Bounds()))
 	}
 
 	if u.usesCompactViewport() {
-		if u.syncMenuOpen {
-			u.phoneSyncMenuVisible = true
-			u.phoneSyncMenuAnchor = metrics.SyncAnchor().Point()
-		}
-		if u.mainMenuOpen {
-			u.phoneMainMenuVisible = true
-			u.phoneMainMenuAnchor = metrics.MainAnchor().Point()
-		}
+		cluster.prepareCompactMenus(gtx, u)
 		return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, rowDims.Size.Y)}
 	}
-
-	if u.syncMenuOpen {
-		surface.Draw(gtx, metrics.SyncAnchor(), u.syncMenu)
-	}
-	if u.mainMenuOpen {
-		surface.Draw(gtx, metrics.MainAnchor(), u.mainMenu)
-	}
-
 	return rowDims
 }
 
+type headerActionCluster struct {
+	Metrics  headerlayout.ActionMetrics
+	SyncMenu layout.Widget
+	MainMenu layout.Widget
+}
+
+func (c headerActionCluster) ShowSyncMenu() bool { return c.SyncMenu != nil }
+
+func (c headerActionCluster) ShowMainMenu() bool { return c.MainMenu != nil }
+
+func (u *ui) newHeaderActionCluster(gtx layout.Context) headerActionCluster {
+	cluster := headerActionCluster{
+		SyncMenu: u.syncMenuWidget(),
+		MainMenu: u.mainMenuWidget(),
+	}
+	spacing := gtx.Dp(unit.Dp(8))
+	cluster.Metrics = headerlayout.ActionMetrics{Spacing: spacing, SyncInnerSpacing: gtx.Dp(unit.Dp(3))}
+	if !u.usesCompactViewport() {
+		cluster.Metrics.SyncInnerSpacing = gtx.Dp(unit.Dp(4))
+	}
+	return cluster
+}
+
+func (c *headerActionCluster) layout(gtx layout.Context, u *ui) layout.Dimensions {
+	rowOps := op.Record(gtx.Ops)
+	c.Metrics.RowDims = c.layoutRow(gtx, u)
+	rowCall := rowOps.Stop()
+	c.Metrics.RowOriginX = max(0, gtx.Constraints.Max.X-c.Metrics.RowDims.Size.X)
+	return layout.E.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+		rowCall.Add(gtx.Ops)
+		return c.Metrics.RowDims
+	})
+}
+
+func (c headerActionCluster) activeMenu() layout.Widget {
+	switch {
+	case c.ShowSyncMenu():
+		return c.SyncMenu
+	case c.ShowMainMenu():
+		return c.MainMenu
+	default:
+		return nil
+	}
+}
+
+func (c *headerActionCluster) layoutRow(gtx layout.Context, u *ui) layout.Dimensions {
+	return layout.Flex{Spacing: layout.SpaceStart}.Layout(gtx,
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			c.Metrics.SyncDims, c.Metrics.SyncPrimaryDims, c.Metrics.SyncToggleDims = u.syncButtonGroupWithMetrics(gtx)
+			return c.Metrics.SyncDims
+		}),
+		layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			btn := material.Button(u.theme, &u.lockVault, "Lock")
+			c.Metrics.LockDims = btn.Layout(gtx)
+			return c.Metrics.LockDims
+		}),
+		layout.Rigid(layout.Spacer{Width: unit.Dp(8)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			c.Metrics.MainDims = u.mainMenuButtonGroup(gtx)
+			return c.Metrics.MainDims
+		}),
+	)
+}
+
+func (c *headerActionCluster) prepareCompactMenus(gtx layout.Context, u *ui) {
+	compactSurface := headerlayout.DropdownSurface{
+		ContainerWidth: gtx.Constraints.Max.X,
+		LeftInset:      u.frameInsetPx,
+		TopInset:       u.frameInsetPx,
+	}
+	if c.ShowSyncMenu() {
+		u.phoneSyncMenuVisible = true
+		u.maybeLogHeaderMenuToggle("sync-visible", true)
+		placement, menuCall := compactSurface.Place(gtx, c.Metrics.SyncAnchor(), c.SyncMenu)
+		u.phoneSyncMenuOrigin = placement.Origin
+		u.phoneSyncMenuSize = placement.Size
+		u.phoneSyncMenuCall = menuCall
+		u.maybeLogHeaderMenuPlacement("sync-phone", compactSurface, placement)
+	}
+	if c.ShowMainMenu() {
+		u.phoneMainMenuVisible = true
+		u.maybeLogHeaderMenuToggle("main-visible", true)
+		placement, menuCall := compactSurface.Place(gtx, c.Metrics.MainAnchor(), c.MainMenu)
+		u.phoneMainMenuOrigin = placement.Origin
+		u.phoneMainMenuSize = placement.Size
+		u.phoneMainMenuCall = menuCall
+		u.maybeLogHeaderMenuPlacement("main-phone", compactSurface, placement)
+	}
+}
+
+func (c headerActionCluster) layoutMenuRow(gtx layout.Context) layout.Dimensions {
+	menu := c.activeMenu()
+	if menu == nil {
+		return layout.Dimensions{}
+	}
+	fullWidthGTX := gtx
+	fullWidthGTX.Constraints.Min = image.Point{}
+	fullWidthGTX.Constraints.Min.X = fullWidthGTX.Constraints.Max.X
+	dims := layout.E.Layout(fullWidthGTX, menu)
+	return layout.Dimensions{Size: image.Pt(fullWidthGTX.Constraints.Max.X, dims.Size.Y)}
+}
+
 type headerButtonBounds struct {
 	SyncPrimary image.Rectangle
 	SyncToggle  image.Rectangle
@@ -143,21 +197,40 @@ func (u *ui) phoneHeaderMenus(gtx layout.Context) layout.Dimensions {
 	if !u.usesCompactViewport() || (!u.syncMenuVisibleOnPhone() && !u.mainMenuVisibleOnPhone()) {
 		return layout.Dimensions{}
 	}
-	gtx.Constraints.Min = gtx.Constraints.Max
-	contentInsetPx := gtx.Dp(unit.Dp(16))
-	surface := headerlayout.DropdownSurface{
-		ContainerWidth: max(0, gtx.Constraints.Max.X-(contentInsetPx*2)),
-		LeftInset:      contentInsetPx,
-		TopInset:       contentInsetPx,
-	}
 
+	cluster := u.newHeaderActionCluster(gtx)
 	if u.syncMenuVisibleOnPhone() {
-		surface.Draw(gtx, headerlayout.DropdownAnchor{TriggerRightX: u.phoneSyncMenuAnchor.X, TriggerBottomY: u.phoneSyncMenuAnchor.Y}, u.syncMenu)
+		return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+			stack := op.Offset(image.Pt(0, max(0, u.phoneSyncMenuOrigin.Y-u.frameInsetPx))).Push(gtx.Ops)
+			defer stack.Pop()
+			dims := cluster.layoutMenuRow(gtx)
+			return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, max(dims.Size.Y, u.phoneSyncMenuOrigin.Y))}
+		})
 	}
 	if u.mainMenuVisibleOnPhone() {
-		surface.Draw(gtx, headerlayout.DropdownAnchor{TriggerRightX: u.phoneMainMenuAnchor.X, TriggerBottomY: u.phoneMainMenuAnchor.Y}, u.mainMenu)
+		return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
+			stack := op.Offset(image.Pt(0, max(0, u.phoneMainMenuOrigin.Y-u.frameInsetPx))).Push(gtx.Ops)
+			defer stack.Pop()
+			dims := cluster.layoutMenuRow(gtx)
+			return layout.Dimensions{Size: image.Pt(gtx.Constraints.Max.X, max(dims.Size.Y, u.phoneMainMenuOrigin.Y))}
+		})
 	}
-	return layout.Dimensions{Size: gtx.Constraints.Max}
+	return layout.Dimensions{}
+}
+
+func (u *ui) desktopHeaderMenus(gtx layout.Context) layout.Dimensions {
+	if u.usesCompactViewport() || (!u.syncMenuOpen && !u.mainMenuOpen) {
+		return layout.Dimensions{}
+	}
+	cluster := u.newHeaderActionCluster(gtx)
+	dims := cluster.layoutMenuRow(gtx)
+	if dims.Size.Y == 0 {
+		return dims
+	}
+	return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
+		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions { return dims }),
+	)
 }
 
 func (u *ui) syncMenuVisibleOnPhone() bool {
@@ -212,6 +285,13 @@ func (u *ui) brandImage(gtx layout.Context, src paint.ImageOp, widthDP, heightDP
 	return img.Layout(gtx)
 }
 
+func (u *ui) mainMenuWidget() layout.Widget {
+	if !u.mainMenuOpen {
+		return nil
+	}
+	return u.mainMenu
+}
+
 func (u *ui) mainMenu(gtx layout.Context) layout.Dimensions {
 	rows := []layout.Widget{
 		func(gtx layout.Context) layout.Dimensions {
@@ -231,7 +311,7 @@ func (u *ui) mainMenu(gtx layout.Context) layout.Dimensions {
 			return tonedButton(gtx, u.theme, &u.openSecuritySettings, "Settings")
 		},
 	}
-	return headerview.MainMenu(gtx, u.theme, rows, compactCard)
+	return headerview.MainMenu(gtx, u.theme, rows, compactCard, nil)
 }
 
 func (u *ui) mainMenuButtonGroup(gtx layout.Context) layout.Dimensions {
@@ -243,7 +323,7 @@ func (u *ui) mainMenuButtonGroup(gtx layout.Context) layout.Dimensions {
 }
 
 func intrinsicCompactCard(gtx layout.Context, w layout.Widget) layout.Dimensions {
-	return headerlayout.IntrinsicCompactCard(gtx, w, compactCard)
+	return headerlayout.IntrinsicCompactCard(gtx, w, compactCard, nil)
 }
 
 func menuActionWidth(gtx layout.Context, rows []layout.Widget) int {

internal/appui/header/layout/dropdown.go

@@ -38,6 +38,12 @@ type DropdownSurface struct {
 	TopInset       int
 }
 
+type DropdownPlacement struct {
+	Anchor DropdownAnchor
+	Origin image.Point
+	Size   image.Point
+}
+
 func (s DropdownSurface) MenuConstraints(gtx layout.Context) layout.Context {
 	menuGTX := gtx
 	menuGTX.Constraints.Min = image.Point{}
@@ -51,13 +57,22 @@ func (s DropdownSurface) Origin(anchor DropdownAnchor, menuWidth int) image.Poin
 	return image.Pt(x, y)
 }
 
-func (s DropdownSurface) Draw(gtx layout.Context, anchor DropdownAnchor, menu layout.Widget) layout.Dimensions {
+func (s DropdownSurface) Place(gtx layout.Context, anchor DropdownAnchor, menu layout.Widget) (DropdownPlacement, op.CallOp) {
 	menuGTX := s.MenuConstraints(gtx)
 	menuOps := op.Record(gtx.Ops)
 	menuDims := layout.Inset{Top: unit.Dp(6)}.Layout(menuGTX, menu)
 	menuCall := menuOps.Stop()
 	menuOrigin := s.Origin(anchor, menuDims.Size.X)
-	stack := op.Offset(menuOrigin).Push(gtx.Ops)
+	return DropdownPlacement{
+		Anchor: anchor,
+		Origin: menuOrigin,
+		Size:   menuDims.Size,
+	}, menuCall
+}
+
+func (s DropdownSurface) Draw(gtx layout.Context, anchor DropdownAnchor, menu layout.Widget) layout.Dimensions {
+	placement, menuCall := s.Place(gtx, anchor, menu)
+	stack := op.Offset(placement.Origin).Push(gtx.Ops)
 	menuCall.Add(gtx.Ops)
 	stack.Pop()
 	return layout.Dimensions{Size: gtx.Constraints.Max}

internal/appui/header/layout/menu.go

@@ -8,13 +8,16 @@ import (
 	"gioui.org/unit"
 )
 
-func IntrinsicCompactCard(gtx layout.Context, w layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions) layout.Dimensions {
+func IntrinsicCompactCard(gtx layout.Context, w layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions, logger func(name string, constraints layout.Constraints, dims layout.Dimensions)) layout.Dimensions {
 	measureGTX := gtx
 	measureGTX.Constraints.Min = image.Point{}
 	measureGTX.Constraints.Max.X = gtx.Constraints.Max.X
 	macro := op.Record(gtx.Ops)
 	contentDims := w(measureGTX)
 	_ = macro.Stop()
+	if logger != nil {
+		logger("intrinsic-measure", measureGTX.Constraints, contentDims)
+	}
 	width := contentDims.Size.X + gtx.Dp(unit.Dp(20))
 	maxWidth := gtx.Constraints.Max.X
 	if maxWidth > 0 && width > maxWidth {
@@ -24,7 +27,11 @@ func IntrinsicCompactCard(gtx layout.Context, w layout.Widget, card func(layout.
 		gtx.Constraints.Min.X = width
 		gtx.Constraints.Max.X = width
 	}
-	return card(gtx, w)
+	dims := card(gtx, w)
+	if logger != nil {
+		logger("intrinsic-card", gtx.Constraints, dims)
+	}
+	return dims
 }
 
 func MenuActionWidth(gtx layout.Context, rows []layout.Widget) int {

internal/appui/header/menu.go

@@ -2,6 +2,7 @@ package header
 
 import (
 	"image/color"
+	"image"
 
 	"gioui.org/layout"
 	"gioui.org/unit"
@@ -10,9 +11,12 @@ import (
 	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
 )
 
-func MainMenu(gtx layout.Context, theme *material.Theme, rows []layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions) layout.Dimensions {
+func MainMenu(gtx layout.Context, theme *material.Theme, rows []layout.Widget, card func(layout.Context, layout.Widget) layout.Dimensions, logger func(name string, constraints layout.Constraints, dims layout.Dimensions)) layout.Dimensions {
 	rowWidth := headerlayout.MenuActionWidth(gtx, rows)
-	return headerlayout.IntrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
+	if logger != nil {
+		logger("row-width", gtx.Constraints, layout.Dimensions{Size: image.Pt(rowWidth, 0)})
+	}
+	dims := headerlayout.IntrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
 		children := make([]layout.FlexChild, 0, (len(rows)*2)-1)
 		for i, row := range rows {
 			if i > 0 {
@@ -23,8 +27,16 @@ func MainMenu(gtx layout.Context, theme *material.Theme, rows []layout.Widget, c
 				return headerlayout.RightAlignedAction(gtx, rowWidth, current)
 			}))
 		}
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx, children...)
-	}, card)
+		dims := layout.Flex{Axis: layout.Vertical}.Layout(gtx, children...)
+		if logger != nil {
+			logger("rows", gtx.Constraints, dims)
+		}
+		return dims
+	}, card, logger)
+	if logger != nil {
+		logger("card", gtx.Constraints, dims)
+	}
+	return dims
 }
 
 func MainMenuButtonGroup(gtx layout.Context, theme *material.Theme, click *widget.Clickable, icon *widget.Icon, open bool, selectedColor, accentColor color.NRGBA) layout.Dimensions {

internal/appui/header_sync_menu.go

@@ -1,11 +1,13 @@
 package appui
 
 import (
+	"image"
 	"image/color"
 	"runtime"
 	"strings"
 
 	"gioui.org/layout"
+	"gioui.org/op"
 	"gioui.org/unit"
 	"gioui.org/widget"
 	"gioui.org/widget/material"
@@ -14,11 +16,6 @@ import (
 	"git.julianfamily.org/keepassgo/internal/vault"
 )
 
-func (u *ui) syncButtonGroup(gtx layout.Context) layout.Dimensions {
-	group, _, _ := u.syncButtonGroupWithMetrics(gtx)
-	return group
-}
-
 func (u *ui) syncButtonGroupWithMetrics(gtx layout.Context) (layout.Dimensions, layout.Dimensions, layout.Dimensions) {
 	spacing := unit.Dp(4)
 	if u.usesCompactViewport() {
@@ -58,6 +55,13 @@ func (u *ui) syncMenuToggle(gtx layout.Context) layout.Dimensions {
 	return btn.Layout(gtx)
 }
 
+func (u *ui) syncMenuWidget() layout.Widget {
+	if !u.syncMenuOpen {
+		return nil
+	}
+	return u.syncMenu
+}
+
 func (u *ui) syncMenu(gtx layout.Context) layout.Dimensions {
 	model := u.buildSyncMenuModel()
 	profiles := u.availableRemoteProfiles()
@@ -70,9 +74,44 @@ func (u *ui) syncMenu(gtx layout.Context) layout.Dimensions {
 	}
 	actionRows := u.syncMenuActionRows(model)
 	actionWidth := menuActionWidth(gtx, actionRows)
-	return intrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
-		return layout.Flex{Axis: layout.Vertical}.Layout(gtx, u.syncMenuRows(model, profiles, credentials, actionWidth)...)
-	})
+	menu := func(gtx layout.Context) layout.Dimensions {
+		return intrinsicCompactCard(gtx, func(gtx layout.Context) layout.Dimensions {
+			return layout.Flex{Axis: layout.Vertical}.Layout(gtx, u.syncMenuRows(model, profiles, credentials, actionWidth)...)
+		})
+	}
+	reserveWidth := u.syncMenuTrailingReserveWidth(gtx)
+	if reserveWidth <= 0 {
+		return menu(gtx)
+	}
+	return layout.Flex{}.Layout(gtx,
+		layout.Rigid(menu),
+		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
+			return layout.Dimensions{Size: image.Pt(reserveWidth, 0)}
+		}),
+	)
+}
+
+func (u *ui) syncMenuTrailingReserveWidth(gtx layout.Context) int {
+	spacing := gtx.Dp(unit.Dp(8))
+	if u.usesCompactViewport() {
+		spacing = gtx.Dp(unit.Dp(8))
+	}
+
+	measureGTX := gtx
+	measureGTX.Constraints.Min = image.Point{}
+
+	lockOps := op.Record(gtx.Ops)
+	lockDims := func(gtx layout.Context) layout.Dimensions {
+		btn := material.Button(u.theme, &u.lockVault, "Lock")
+		return btn.Layout(gtx)
+	}(measureGTX)
+	_ = lockOps.Stop()
+
+	menuOps := op.Record(gtx.Ops)
+	menuDims := u.mainMenuButtonGroup(measureGTX)
+	_ = menuOps.Stop()
+
+	return spacing + lockDims.Size.X + spacing + menuDims.Size.X
 }
 
 func (u *ui) syncMenuActionRows(model syncmodel.MenuModel) []layout.Widget {
@@ -119,14 +158,7 @@ func (u *ui) syncMenuRows(model syncmodel.MenuModel, profiles []vault.RemoteProf
 }
 
 func (u *ui) syncMenuPrimaryRows(model syncmodel.MenuModel, actionWidth int) []layout.FlexChild {
-	rows := []layout.FlexChild{
-		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
-			lbl := material.Label(u.theme, unit.Sp(11), "Need another source or direction?")
-			lbl.Color = mutedColor
-			return lbl.Layout(gtx)
-		}),
-		layout.Rigid(layout.Spacer{Height: unit.Dp(6)}.Layout),
-	}
+	rows := []layout.FlexChild{}
 	if model.ShowShare {
 		rows = append(rows, layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 			return layout.Flex{Axis: layout.Vertical}.Layout(gtx,

internal/appui/settings.go

@@ -17,6 +17,7 @@ import (
 	"gioui.org/widget"
 	"gioui.org/widget/material"
 	editormodel "git.julianfamily.org/keepassgo/internal/appui/editor"
+	headerlayout "git.julianfamily.org/keepassgo/internal/appui/header/layout"
 	"git.julianfamily.org/keepassgo/internal/appui/platform"
 	settingsmodel "git.julianfamily.org/keepassgo/internal/appui/settings"
 	"git.julianfamily.org/keepassgo/internal/vault"
@@ -309,6 +310,32 @@ func (u *ui) maybeLogHeaderBounds(bounds headerButtonBounds) {
 	u.lastHeaderBoundsLog = line
 }
 
+func (u *ui) maybeLogHeaderMenuToggle(menu string, open bool) {
+	if !u.debugLogHeaderBounds {
+		return
+	}
+	platform.LogInfo("KeePassGO", fmt.Sprintf("keepassgo header-menu-toggle menu=%s open=%t", menu, open))
+}
+
+func (u *ui) maybeLogHeaderMenuPlacement(menu string, surface headerlayout.DropdownSurface, placement headerlayout.DropdownPlacement) {
+	if !u.debugLogHeaderBounds {
+		return
+	}
+	platform.LogInfo("KeePassGO", fmt.Sprintf(
+		"keepassgo header-menu-placement menu=%s anchor=%d,%d origin=%d,%d size=%dx%d container=%d inset=%d,%d",
+		menu,
+		placement.Anchor.TriggerRightX,
+		placement.Anchor.TriggerBottomY,
+		placement.Origin.X,
+		placement.Origin.Y,
+		placement.Size.X,
+		placement.Size.Y,
+		surface.ContainerWidth,
+		surface.LeftInset,
+		surface.TopInset,
+	))
+}
+
 func (u *ui) showStatusMessage(message string) {
 	u.state.StatusMessage = message
 	if u.accessibilityPrefs.ReducedMotion {