Feature: Open ClickGui on More Screens (#302)

Author: PoTheMagicDragon

src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt

@@ -65,7 +65,9 @@ open class CollectionSetting<R : Any>(
 	private var searchFilter = ""
 
 	val selectListeners = mutableListOf<SafeContext.(R) -> Unit>()
+	val unsafeSelectListeners = mutableListOf<(R) -> Unit>()
 	val deselectListeners = mutableListOf<SafeContext.(R) -> Unit>()
+	val unsafeDeselectListeners = mutableListOf<(R) -> Unit>()
 
 	override val isModified: Boolean
 		get() = with(originalCore) {
@@ -113,6 +115,7 @@ open class CollectionSetting<R : Any>(
 								flags = DontClosePopups
 							) {
 								value.add(v)
+								unsafeSelectListeners.forEach { listener -> listener(v) }
 								runSafe { selectListeners.forEach { listener -> listener(v) } }
 							}
 						}
@@ -134,6 +137,8 @@ open class CollectionSetting<R : Any>(
 							value.add(item)
 						}
 					}
+					currentlySelected.forEach { v -> unsafeDeselectListeners.forEach { listener -> listener(v) } }
+					value.forEach { v -> unsafeSelectListeners.forEach { listener -> listener(v) } }
 					runSafe {
 						currentlySelected.forEach { v -> deselectListeners.forEach { listener -> listener(v) } }
 						value.forEach { v -> selectListeners.forEach { listener -> listener(v) } }
@@ -159,6 +164,7 @@ open class CollectionSetting<R : Any>(
 								flags = DontClosePopups
 							) {
 								value.remove(v)
+								unsafeDeselectListeners.forEach { listener -> listener(v) }
 								runSafe { deselectListeners.forEach { listener -> listener(v) } }
 							}
 						}
@@ -175,10 +181,18 @@ open class CollectionSetting<R : Any>(
 		fun <T : CollectionSetting<R>, R : Any> T.onSelect(block: SafeContext.(R) -> Unit) =
 			apply { selectListeners.add(block) }
 
+		@ConfigEntryDsl
+		fun <T : CollectionSetting<R>, R : Any> T.onSelectUnsafe(block: (R) -> Unit) =
+			apply { unsafeSelectListeners.add(block) }
+
 		@ConfigEntryDsl
 		fun <T : CollectionSetting<R>, R : Any> T.onDeselect(block: SafeContext.(R) -> Unit) =
 			apply { deselectListeners.add(block) }
 
+		@ConfigEntryDsl
+		fun <T : CollectionSetting<R>, R : Any> T.onDeselectUnsafe(block: (R) -> Unit) =
+			apply { unsafeDeselectListeners.add(block) }
+
 		@Suppress("unchecked_cast")
 		@ConfigEditorD5l
 		fun <T : Any> ConfigEditor.SettingEditBuilder<Collection<T>>.immutableCollection(collection: Collection<T>) {

src/main/kotlin/com/lambda/config/settings/complex/KeybindSetting.kt

@@ -26,14 +26,16 @@ import com.lambda.brigadier.argument.word
 import com.lambda.brigadier.executeWithResult
 import com.lambda.brigadier.optional
 import com.lambda.brigadier.required
+import com.lambda.Lambda.mc
 import com.lambda.config.Config
 import com.lambda.config.entries.ConfigEntryDsl
 import com.lambda.config.entries.Setting
 import com.lambda.config.entries.SettingEntryLayer
 import com.lambda.context.SafeContext
 import com.lambda.event.Muteable
 import com.lambda.event.events.ButtonEvent
-import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
+import com.lambda.threading.runSafe
 import com.lambda.gui.dsl.ImGuiBuilder
 import com.lambda.imgui.ImGui.isMouseClicked
 import com.lambda.imgui.flag.ImGuiCol
@@ -78,28 +80,39 @@ class KeybindSetting(
     ) : this(name, description, config, layer, visibility, Bind(defaultValue.code, 0, -1), muteable, alwaysListen, screenCheck)
 
     private val pressListeners = mutableListOf<SafeContext.(ButtonEvent) -> Unit>()
+    private val unsafePressListeners = mutableListOf<(ButtonEvent) -> Unit>()
     private val repeatListeners = mutableListOf<SafeContext.(ButtonEvent) -> Unit>()
+    private val unsafeRepeatListeners = mutableListOf<(ButtonEvent) -> Unit>()
     private val releaseListeners = mutableListOf<SafeContext.(ButtonEvent) -> Unit>()
+    private val unsafeReleaseListeners = mutableListOf<(ButtonEvent) -> Unit>()
 
     private var listening = false
 
     override val isMuted
         get() = muteable?.isMuted == true && !alwaysListening
 
     init {
-        listen<ButtonEvent.Keyboard.Press> { event -> onButtonEvent(event) }
-        listen<ButtonEvent.Mouse.Click> { event -> onButtonEvent(event) }
+        listenUnsafe<ButtonEvent.Keyboard.Press> { event -> onButtonEvent(event) }
+        listenUnsafe<ButtonEvent.Mouse.Click> { event -> onButtonEvent(event) }
     }
 
-    private fun SafeContext.onButtonEvent(event: ButtonEvent) {
+    private fun onButtonEvent(event: ButtonEvent) {
         if (mc.options.commandKey.isPressed ||
             (screenCheck && mc.currentScreen != null) ||
             !event.satisfies(value)) return
 
         if (event.isPressed) {
-            if (event.isRepeated) repeatListeners.forEach { it(event) }
-            else pressListeners.forEach { it(event) }
-        } else if (event.isReleased) releaseListeners.forEach { it(event) }
+            if (event.isRepeated) {
+                unsafeRepeatListeners.forEach { it(event) }
+                runSafe { repeatListeners.forEach { it(event) } }
+            } else {
+                unsafePressListeners.forEach { it(event) }
+                runSafe { pressListeners.forEach { it(event) } }
+            }
+        } else if (event.isReleased) {
+            unsafeReleaseListeners.forEach { it(event) }
+            runSafe { releaseListeners.forEach { it(event) } }
+        }
     }
 
     override fun ImGuiBuilder.buildLayout() {
@@ -211,11 +224,20 @@ class KeybindSetting(
         @ConfigEntryDsl
         fun KeybindSetting.onPress(block: SafeContext.(ButtonEvent) -> Unit) = apply { pressListeners.add(block) }
 
+        @ConfigEntryDsl
+        fun KeybindSetting.onPressUnsafe(block: (ButtonEvent) -> Unit) = apply { unsafePressListeners.add(block) }
+
         @ConfigEntryDsl
         fun KeybindSetting.onRepeat(block: SafeContext.(ButtonEvent) -> Unit) = apply { repeatListeners.add(block) }
 
+        @ConfigEntryDsl
+        fun KeybindSetting.onRepeatUnsafe(block: (ButtonEvent) -> Unit) = apply { unsafeRepeatListeners.add(block) }
+
         @ConfigEntryDsl
         fun KeybindSetting.onRelease(block: SafeContext.(ButtonEvent) -> Unit) = apply { releaseListeners.add(block) }
+
+        @ConfigEntryDsl
+        fun KeybindSetting.onReleaseUnsafe(block: (ButtonEvent) -> Unit) = apply { unsafeReleaseListeners.add(block) }
     }
 }
 

src/main/kotlin/com/lambda/gui/DearImGui.kt

@@ -108,6 +108,13 @@ object DearImGui : Loadable {
             null
         )
 
+        // When the GUI is open over a menu screen, the in-game world blur (applied via the
+        // screen's GUI render layers) isn't available, so blur the whole framebuffer here —
+        // after the parent screen has fully rendered but before ImGui draws on top.
+        if (ClickGuiLayout.open && ClickGuiLayout.backgroundBlur && LambdaScreen.parentScreen != null) {
+            mc.gameRenderer.renderBlur()
+        }
+
         GlStateManager._glBindFramebuffer(GL_FRAMEBUFFER, prevFramebuffer)
 
         implGlfw.newFrame()

src/main/kotlin/com/lambda/gui/LambdaScreen.kt

@@ -23,10 +23,43 @@ import net.minecraft.client.gui.screen.Screen
 import net.minecraft.text.Text
 
 object LambdaScreen : Screen(Text.of("Lambda")) {
+    /**
+     * The screen the GUI was opened over (e.g. the title screen).
+     * Null when opened in-game; in that case closing returns to gameplay.
+     */
+    var parentScreen: Screen? = null
+
     override fun shouldPause() = false
     override fun removed() = ClickGuiLayout.close()
     override fun render(context: DrawContext?, mouseX: Int, mouseY: Int, deltaTicks: Float) {}
 
+    override fun renderBackground(context: DrawContext, mouseX: Int, mouseY: Int, delta: Float) {
+        if (parentScreen == null) {
+            // In-game: keep vanilla behavior (blur + darken the rendered world).
+            super.renderBackground(context, mouseX, mouseY, delta)
+            return
+        }
+        // Off-screen mouse coords keep the parent's widgets from showing a hover state.
+        parentScreen?.renderBackground(context, -1, -1, delta)
+        parentScreen?.render(context, -1, -1, delta)
+        // Flush deferred elements (e.g. widget text) so the darkening overlay covers them.
+        context.drawDeferredElements()
+        // NOTE: no GUI-layer applyBlur() here. MC's layer blur only blurs background
+        // layers, never foreground widgets. To blur the whole parent (widgets included)
+        // we run a framebuffer-level blur in DearImGui.render() after the full GUI pass.
+    }
+
+    override fun resize(width: Int, height: Int) {
+        super.resize(width, height)
+        parentScreen?.resize(width, height)
+    }
+
+    override fun close() {
+        val previous = parentScreen
+        parentScreen = null
+        client?.setScreen(previous)
+    }
+
     override fun applyBlur(context: DrawContext?) {
         if (!ClickGuiLayout.backgroundBlur) return
         super.applyBlur(context)

src/main/kotlin/com/lambda/gui/OverlayBackgroundScreen.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2026 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.gui
+
+/**
+ * Implemented by screens the click GUI can open over that hold resources (e.g. textures)
+ * which must survive being temporarily replaced by [LambdaScreen].
+ *
+ * Opening the GUI calls [net.minecraft.client.MinecraftClient.setScreen], which fires
+ * [net.minecraft.client.gui.screen.Screen.removed] on the screen being overlaid — screens
+ * that free resources there would lose them even though the GUI restores the screen on close.
+ * [onOverlaidByGui] is invoked just before that happens so the screen can retain its resources.
+ */
+interface OverlayBackgroundScreen {
+    fun onOverlaidByGui()
+}

src/main/kotlin/com/lambda/gui/components/ClickGuiLayout.kt

@@ -22,12 +22,13 @@ import com.lambda.config.Config
 import com.lambda.config.Tab
 import com.lambda.config.categories.GuiCategory
 import com.lambda.config.entries.Setting.Companion.onValueChange
-import com.lambda.config.settings.complex.KeybindSetting.Companion.onPress
+import com.lambda.config.settings.complex.KeybindSetting.Companion.onPressUnsafe
 import com.lambda.core.Loadable
 import com.lambda.event.events.GuiEvent
-import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
 import com.lambda.gui.DearImGui
 import com.lambda.gui.LambdaScreen
+import com.lambda.gui.OverlayBackgroundScreen
 import com.lambda.gui.MenuBar
 import com.lambda.gui.MenuBar.buildMenuBar
 import com.lambda.gui.components.QuickSearch.renderQuickSearch
@@ -45,6 +46,7 @@ import com.lambda.imgui.flag.ImGuiHoveredFlags
 import com.lambda.imgui.flag.ImGuiWindowFlags
 import com.lambda.module.ModuleRegistry
 import com.lambda.module.modules.client.Client
+import com.lambda.module.modules.combat.autodisconnect.AutoDisconnectScreen
 import com.lambda.module.tag.ModuleTag
 import com.lambda.module.tag.ModuleTag.Companion.shownTags
 import com.lambda.sound.LambdaSound
@@ -56,9 +58,11 @@ import com.lambda.util.WindowUtils.setLambdaWindowIcon
 import net.minecraft.SharedConstants
 import net.minecraft.client.gui.screen.ChatScreen
 import net.minecraft.client.gui.screen.Screen
+import net.minecraft.client.gui.screen.TitleScreen
 import net.minecraft.client.gui.screen.ingame.AnvilScreen
 import net.minecraft.client.gui.screen.ingame.CommandBlockScreen
 import net.minecraft.client.gui.screen.ingame.SignEditScreen
+import net.minecraft.client.gui.screen.multiplayer.MultiplayerScreen
 import net.minecraft.client.util.Icons
 import java.awt.Color
 
@@ -69,12 +73,29 @@ object ClickGuiLayout : Loadable, Config(
 ) {
 	var open = false
 	var developerMode = false
+	// onPressUnsafe (not onPress) so the GUI can also be toggled from menu screens
+	// (title, multiplayer, world-select) where there is no SafeContext, not just in-game.
 	val keybind by setting("Keybind", KeyCode.Y, screenCheck = false)
-		.onPress {
-			if (!open && mc.currentScreen != null) return@onPress
-			if (DearImGui.io.wantTextInput) return@onPress
+		.onPressUnsafe {
+			if (DearImGui.io.wantTextInput) return@onPressUnsafe
+			if (!open && !canOpenOver(mc.currentScreen)) return@onPressUnsafe
 			toggle()
 		}
+
+	/**
+	 * Screens (besides the in-game/null case) the GUI is allowed to open over.
+	 * Add a class here to support opening the GUI on another screen.
+	 */
+	private val backgroundScreenTypes = mutableListOf(
+		TitleScreen::class.java,
+		MultiplayerScreen::class.java,
+		AutoDisconnectScreen::class.java,
+	)
+
+	/** True when the GUI may be opened over [screen]; null means in-game. */
+	fun canOpenOver(screen: Screen?): Boolean =
+		screen == null || backgroundScreenTypes.any { it.isInstance(screen) }
+
 	private var initialLayoutComplete = false
 	private var frameCount = 0
 	private var activeDragWindowName: String? = null
@@ -246,8 +267,8 @@ object ClickGuiLayout : Loadable, Config(
 	@Tab(COLORS_TAB) val modalWindowDimBg by setting("Modal Window Dim Background", Color(35, 0, 14, 90))
 
 	init {
-		listen<GuiEvent.NewImguiFrame> {
-			if (!open) return@listen
+		listenUnsafe<GuiEvent.NewImguiFrame> {
+			if (!open) return@listenUnsafe
 
 			buildLayout {
 				buildMenuBar()
@@ -361,16 +382,21 @@ object ClickGuiLayout : Loadable, Config(
 
 	fun toggle() {
 		if (open) {
-			close()
+			// LambdaScreen.close() restores the background screen and triggers
+			// removed() -> close(), which flips `open` off and plays the sound.
 			LambdaScreen.close()
 		} else {
-			if (!mc.currentScreen.hasInput) {
-				if (Client.clientSounds) LambdaSound.ModuleOn.play()
-				mc.setScreen(LambdaScreen)
-				open = true
-				frameCount = 0
-				initialLayoutComplete = false
-			}
+			val current = mc.currentScreen
+			if (current.hasInput) return
+			if (Client.clientSounds) LambdaSound.ModuleOn.play()
+			LambdaScreen.parentScreen = if (current is LambdaScreen) null else current
+			// Let the parent retain resources past the removed() that setScreen triggers,
+			// since we restore it when the GUI closes.
+			(current as? OverlayBackgroundScreen)?.onOverlaidByGui()
+			mc.setScreen(LambdaScreen)
+			open = true
+			frameCount = 0
+			initialLayoutComplete = false
 		}
 	}
 

src/main/kotlin/com/lambda/module/modules/combat/autodisconnect/AutoDisconnectScreen.kt

@@ -17,6 +17,7 @@
 
 package com.lambda.module.modules.combat.autodisconnect
 
+import com.lambda.gui.OverlayBackgroundScreen
 import com.lambda.util.render.CursorOverrideProvider
 import net.minecraft.client.gl.RenderPipelines
 import net.minecraft.client.gui.Click
@@ -32,8 +33,11 @@ import net.minecraft.client.gui.widget.ScrollableTextWidget
 import net.minecraft.text.Text
 import kotlin.math.min
 
-class AutoDisconnectScreen(private val details: DisconnectDetails) :
-    Screen(Text.literal("Disconnected: ").append(details.reason)) {
+class AutoDisconnectScreen(
+    private val details: DisconnectDetails
+) : Screen(Text.literal("Disconnected: ").append(details.reason)),
+    OverlayBackgroundScreen
+{
     //state
     private val parent = TitleScreen()
     private var showDetails = !details.hideDetails
@@ -106,6 +110,12 @@ class AutoDisconnectScreen(private val details: DisconnectDetails) :
         releaseTexture()
     }
 
+    override fun onOverlaidByGui() {
+        // The click GUI temporarily replaces this screen and restores it on close,
+        // so keep the screenshot texture instead of releasing it on removed().
+        keepTextureOnRemove = true
+    }
+
     private fun openImagePreview() {
         keepTextureOnRemove = true
         client?.setScreen(ImagePreviewScreen(this, details))