Fix virtual keyboard config

- KeyInfo was leftover code from toying around with various implementations. String is sufficient in current implementation.

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Build with Gradle
+
+on: [ push, pull_request ]
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+      - name: Validate Gradle Wrapper
+        uses: gradle/actions/wrapper-validation@v3
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 21
+          check-latest: true
+      - name: Build with Gradle
+        run: ./gradlew build
+      - name: Upload artifacts to GitHub
+        uses: actions/upload-artifact@v4
+        with:
+          name: MidnightControls-Artifacts
+          path: /build/libs/

.github/workflows/gradlebuild.yml

@@ -1,23 +0,0 @@
-name: Gradle Build
-
-on: [ push, pull_request ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 16
-        uses: actions/setup-java@v1
-        with:
-          java-version: 16
-          server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
-          settings-path: ${{ github.workspace }} # location for the settings.xml file
-
-      - name: Build with Gradle
-        run: ./gradlew build
-
-      - uses: actions/upload-artifact@v2
-        with:
-          name: Artifacts
-          path: ./build/libs/

.github/workflows/modrinth_update.yml

@@ -1,23 +0,0 @@
-name: Gradle Build
-
-on:
-  release:
-    types:
-      - published
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 16
-        uses: actions/setup-java@v1
-        with:
-          java-version: 16
-          server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
-          settings-path: ${{ github.workspace }} # location for the settings.xml file
-
-      - name: Build with Gradle
-        env:
-          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
-        run: ./gradlew publishModrinth

.github/workflows/publish.yml

@@ -1,30 +1,24 @@
-name: Gradle Package
+name: Publish to Modrinth
 
 on:
-  push:
-    tags:
-      - '*'
+  release:
+    types:
+      - published
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
+  publish:
+    runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 16
-        uses: actions/setup-java@v1
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+      - name: Validate Gradle Wrapper
+        uses: gradle/actions/wrapper-validation@v3
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
         with:
-          java-version: 16
-          server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
-          settings-path: ${{ github.workspace }} # location for the settings.xml file
-
-      - name: Build with Gradle
-        run: ./gradlew build
-
-      - uses: actions/upload-artifact@v2
-        with:
-          name: Artifacts
-          path: ./build/libs/
-
+          distribution: 'temurin'
+          java-version: 21
+          check-latest: true
       # The USERNAME and PASSWORD need to correspond to the credentials environment variables used in
       # the publishing section of your build.gradle
       - name: Publish to GitHub Packages and other Mavens
@@ -38,3 +32,7 @@ jobs:
           midnightcontrols_MAVEN: ${{ secrets.MAVEN_URL }}
           MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }}
           MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+      - name: Publish to Modrinth
+        env:
+          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+        run: ./gradlew publishModrinth

README.md

@@ -8,7 +8,7 @@
 [![Version](https://img.shields.io/github/v/tag/TeamMidnightDust/MidnightControls?label=version&style=round)](https://github.com/TeamMidnightDust/MidnightControls/releases)
 ![Environment: Client](https://img.shields.io/badge/environment-client-1976d2?style=round)
 [![Mod loader: Quilt/Fabric]][Quilt]
-[![Java 17](https://img.shields.io/badge/language-Java%2017-9B599A.svg?style=round)](https://www.oracle.com/java/technologies/downloads/#java17)
+[![Java 21](https://img.shields.io/badge/language-Java%2021-9B599A.svg?style=round)](https://www.oracle.com/java/technologies/downloads/#java21)
 [![GitHub license](https://img.shields.io/github/license/TeamMidnightDust/MidnightControls?style=round)](LICENSE)
 
 A Fabric Minecraft mod which adds better controls, reach-around and controller support.  

common/build.gradle

@@ -39,7 +39,7 @@ dependencies {
     modCompileOnlyApi "org.quiltmc:quilt-json5:1.0.0"
     modImplementation "maven.modrinth:sodium:${project.sodium_version}-fabric"
     modCompileOnlyApi "maven.modrinth:emi:${project.emi_version}"
-    modCompileOnlyApi "maven.modrinth:emotecraft:${project.emotecraft_version}"
+    modImplementation "maven.modrinth:emotecraft:${project.emotecraft_version}"
     modCompileOnlyApi "io.github.kosmx:bendy-lib:${project.bendylib_version}"
     modCompileOnlyApi "dev.isxander:yet-another-config-lib:${project.yacl_version}"
     modCompileOnlyApi "maven.modrinth:inventory-tabs-updated:${project.inventorytabs_version}"

common/src/main/java/eu/midnightdust/midnightcontrols/client/MidnightControlsClient.java

@@ -26,6 +26,7 @@ import eu.midnightdust.midnightcontrols.client.mixin.KeyBindingIDAccessor;
 import eu.midnightdust.midnightcontrols.client.ring.ButtonBindingRingAction;
 import eu.midnightdust.midnightcontrols.client.ring.MidnightRing;
 import eu.midnightdust.midnightcontrols.client.util.platform.NetworkUtil;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.MouseClickInterceptor;
 import net.minecraft.client.gui.screen.Screen;
 import org.thinkingstudio.obsidianui.hud.HudManager;
 import eu.midnightdust.midnightcontrols.client.touch.TouchInput;
@@ -75,6 +76,7 @@ public class MidnightControlsClient extends MidnightControls {
     public static final MidnightInput input = new MidnightInput();
     public static final MidnightRing ring = new MidnightRing();
     public static final MidnightReacharound reacharound = new MidnightReacharound();
+    public static final MouseClickInterceptor clickInterceptor = new MouseClickInterceptor();
     public static boolean isWayland;
     private static MidnightControlsHud hud;
     private static ControlsMode previousControlsMode;
@@ -86,12 +88,16 @@ public class MidnightControlsClient extends MidnightControls {
         int period = 1; // repeat every 0.001 sec. (1000 times a second)
         Timer timer = new Timer();
         timer.scheduleAtFixedRate(new TimerTask() {
-            public void run() { // TODO: Add a try/catch here after the alpha testing period
-                if (lateInitDone && client.isRunning()) {
-                    if (MidnightControlsConfig.controlsMode == ControlsMode.CONTROLLER && (client.isWindowFocused() || MidnightControlsConfig.unfocusedInput)) {
-                        input.tickCameraStick();
-                        input.updateCamera();
+            public void run() {
+                try {
+                    if (lateInitDone && client.isRunning()) {
+                        if (MidnightControlsConfig.controlsMode == ControlsMode.CONTROLLER && (client.isWindowFocused() || MidnightControlsConfig.unfocusedInput)) {
+                            input.tickCameraStick();
+                            input.updateCamera();
+                        }
                     }
+                } catch (Exception | Error e) {
+                    MidnightControls.logger.error("Exception encountered in camera loop: ",e);
                 }
             }
         }, delay, period);
@@ -200,6 +206,7 @@ public class MidnightControlsClient extends MidnightControls {
         RainbowColor.tick();
         TouchInput.tick();
     }
+
     /**
      * Called when opening a screen.
      */

common/src/main/java/eu/midnightdust/midnightcontrols/client/MidnightControlsConfig.java

@@ -88,6 +88,7 @@ public class MidnightControlsConfig extends MidnightConfig {
     @Entry(category = SCREENS, name = "midnightcontrols.menu.virtual_mouse") public static boolean virtualMouse = false;
     @Entry(category = SCREENS, name = "midnightcontrols.menu.virtual_mouse.skin") public static VirtualMouseSkin virtualMouseSkin = VirtualMouseSkin.DEFAULT_LIGHT;
     @Entry(category = SCREENS, name = "midnightcontrols.menu.hide_cursor") public static boolean hideNormalMouse = false;
+    @Entry(category = SCREENS, name = "midnightcontrols.menu.virtual_keyboard") public static boolean virtualKeyboard = false;
     @Entry(category = CONTROLLER, name = "Controller ID") @Hidden public static Object controllerID = 0;
     @Entry(category = CONTROLLER, name = "2nd Controller ID") @Hidden public static Object secondControllerID = -1;
     @Entry(category = VISUAL, name = "midnightcontrols.menu.controller_type") public static ControllerType controllerType = ControllerType.DEFAULT;
@@ -374,6 +375,7 @@ public class MidnightControlsConfig extends MidnightConfig {
         unfocusedInput = false;
         virtualMouse = false;
         virtualMouseSkin = VirtualMouseSkin.DEFAULT_LIGHT;
+        virtualKeyboard = false;
         controllerID = 0;
         secondControllerID = -1;
         controllerType = ControllerType.DEFAULT;

common/src/main/java/eu/midnightdust/midnightcontrols/client/compat/EmotecraftCompat.java

@@ -1,36 +1,51 @@
 package eu.midnightdust.midnightcontrols.client.compat;
 
 import eu.midnightdust.midnightcontrols.client.controller.InputManager;
-import io.github.kosmx.emotes.arch.gui.EmoteMenuImpl;
-import io.github.kosmx.emotes.arch.gui.screen.ingame.FastChosseScreen;
+import eu.midnightdust.midnightcontrols.client.mixin.MouseAccessor;
+import io.github.kosmx.emotes.arch.screen.ingame.FastMenuScreen;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.Screen;
+import org.joml.Vector2i;
+import org.lwjgl.glfw.GLFW;
 
 public class EmotecraftCompat {
     private static final MinecraftClient client = MinecraftClient.getInstance();
 
     public static void openEmotecraftScreen(Screen parent) {
-        client.setScreen(new EmoteMenuImpl(parent));
+        client.setScreen(new FastMenuScreen(parent));
     }
     public static boolean isEmotecraftScreen(Screen screen) {
-        return screen instanceof FastChosseScreen;
+        return screen instanceof FastMenuScreen;
     }
 
+    static int prevIndex = -1;
     public static void handleEmoteSelector(int index) {
-        if (client.currentScreen instanceof FastChosseScreen) {
-            int x = client.getWindow().getWidth() / 2;
-            int y = client.getWindow().getHeight() / 2;
-            switch (index) {
-                case 0, 3, 5 -> x -= 200;
-                case 2, 4, 7 -> x += 200;
-            }
-            switch (index) {
-                case 0, 1, 2 -> y -= 200;
-                case 5, 6, 7 -> y += 200;
-            }
-            InputManager.queueMousePosition(x, y);
+        try {
+            if (client.currentScreen instanceof FastMenuScreen) {
+                boolean stickReleased = index == -1 && prevIndex != -1;
+                var pos = calcMousePos(stickReleased ? prevIndex : index);
+                InputManager.queueMousePosition(pos.x, pos.y);
+                InputManager.INPUT_MANAGER.updateMousePosition(client);
 
-            InputManager.INPUT_MANAGER.updateMousePosition(client);
+                if (stickReleased) {
+                    ((MouseAccessor) client.mouse).midnightcontrols$onMouseButton(client.getWindow().getHandle(), GLFW.GLFW_MOUSE_BUTTON_LEFT, GLFW.GLFW_PRESS, 0);
+                    prevIndex = -1;
+                }
+                else prevIndex = index;
+            } else prevIndex = -1;
+        } catch (Exception ignored) {}
+    }
+    public static Vector2i calcMousePos(int index) {
+        int x = client.getWindow().getWidth() / 2;
+        int y = client.getWindow().getHeight() / 2;
+        switch (index) {
+            case 0, 3, 5 -> x -= 275;
+            case 2, 4, 7 -> x += 275;
         }
+        switch (index) {
+            case 0, 1, 2 -> y -= 275;
+            case 5, 6, 7 -> y += 275;
+        }
+        return new Vector2i(x, y);
     }
 }

common/src/main/java/eu/midnightdust/midnightcontrols/client/controller/MovementHandler.java

@@ -15,6 +15,7 @@ import eu.midnightdust.midnightcontrols.client.util.MathUtil;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.entity.attribute.EntityAttributes;
+import net.minecraft.util.PlayerInput;
 import net.minecraft.util.math.MathHelper;
 import org.jetbrains.annotations.NotNull;
 
@@ -48,11 +49,8 @@ public final class MovementHandler implements PressAction {
     public void applyMovement(@NotNull ClientPlayerEntity player) {
         if (!this.shouldOverrideMovement)
             return;
-        // TODO
-//        player.input.playerInput.pressingForward = this.pressingForward;
-//        player.input.pressingBack = this.pressingBack;
-//        player.input.pressingLeft = this.pressingLeft;
-//        player.input.pressingRight = this.pressingRight;
+        player.input.playerInput = new PlayerInput(this.pressingForward, this.pressingBack, this.pressingLeft, this.pressingRight,
+                player.input.playerInput.jump(), player.input.playerInput.sneak(), player.input.playerInput.sprint());
 
         polarUtil.calculate(this.movementSideways, this.movementForward, this.slowdownFactor);
         player.input.movementForward = polarUtil.polarY;

common/src/main/java/eu/midnightdust/midnightcontrols/client/gui/MidnightControlsSettingsScreen.java

@@ -64,6 +64,7 @@ public class MidnightControlsSettingsScreen extends SpruceScreen {
     private final SpruceOption eyeTrackingAsMouseOption;
     private final SpruceOption eyeTrackingDeadzone;
     private final SpruceOption virtualMouseOption;
+    private final SpruceOption virtualKeyboardOption;
     private final SpruceOption hideCursorOption;
     private final SpruceOption resetOption;
     private final SpruceOption advancedConfigOption;
@@ -299,6 +300,8 @@ public class MidnightControlsSettingsScreen extends SpruceScreen {
                 value -> MidnightControlsConfig.unfocusedInput = value, Text.translatable("midnightcontrols.menu.unfocused_input.tooltip"));
         this.virtualMouseOption = new SpruceToggleBooleanOption("midnightcontrols.menu.virtual_mouse", () -> MidnightControlsConfig.virtualMouse,
                 value -> MidnightControlsConfig.virtualMouse = value, Text.translatable("midnightcontrols.menu.virtual_mouse.tooltip"));
+        this.virtualKeyboardOption = new SpruceToggleBooleanOption("midnightcontrols.menu.virtual_keyboard", () -> MidnightControlsConfig.virtualMouse,
+                value -> MidnightControlsConfig.virtualKeyboard = value, Text.translatable("midnightcontrols.menu.virtual_keyboard.tooltip"));
         this.hideCursorOption = new SpruceToggleBooleanOption("midnightcontrols.menu.hide_cursor", () -> MidnightControlsConfig.hideNormalMouse,
                 value -> MidnightControlsConfig.hideNormalMouse = value, Text.translatable("midnightcontrols.menu.hide_cursor.tooltip"));
         // Touch options
@@ -390,6 +393,7 @@ public class MidnightControlsSettingsScreen extends SpruceScreen {
         list.addSingleOptionEntry(this.yAxisRotationSpeedOption);
         list.addSingleOptionEntry(this.mouseSpeedOption);
         list.addSingleOptionEntry(this.virtualMouseOption);
+        list.addSingleOptionEntry(this.virtualKeyboardOption);
         list.addSingleOptionEntry(this.hideCursorOption);
         list.addSingleOptionEntry(this.joystickAsMouseOption);
         list.addSingleOptionEntry(this.eyeTrackingAsMouseOption);

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/AbstractSignEditScreenAccessor.java

@@ -0,0 +1,15 @@
+package eu.midnightdust.midnightcontrols.client.mixin;
+
+import net.minecraft.block.entity.SignText;
+import net.minecraft.client.gui.screen.ingame.AbstractSignEditScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(AbstractSignEditScreen.class)
+public interface AbstractSignEditScreenAccessor {
+    @Accessor("text")
+    SignText midnightcontrols$getText();
+
+    @Accessor("text")
+    void midnightcontrols$setText(SignText text);
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/BookEditScreenAccessor.java

@@ -0,0 +1,28 @@
+package eu.midnightdust.midnightcontrols.client.mixin;
+
+import net.minecraft.client.gui.screen.ingame.BookEditScreen;
+import net.minecraft.client.util.SelectionManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(BookEditScreen.class)
+public interface BookEditScreenAccessor {
+    @Accessor("signing")
+    boolean midnightcontrols$isSigning();
+
+    @Accessor("title")
+    String midnightcontrols$getTitle();
+
+    @Accessor("title")
+    void midnightcontrols$setTitle(String title);
+
+    @Accessor("currentPageSelectionManager")
+    SelectionManager midnightcontrols$getCurrentPageSelectionManager();
+
+    @Invoker("getCurrentPageContent")
+    String midnightcontrols$getCurrentPageContent();
+
+    @Invoker("setPageContent")
+    void midnightcontrols$setPageContent(String newContent);
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/ClientPlayerEntityMixin.java

@@ -77,7 +77,7 @@ public abstract class ClientPlayerEntityMixin extends AbstractClientPlayerEntity
         }
     }
 
-    @Inject(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick(ZF)V", shift = At.Shift.AFTER))
+    @Inject(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick()V", shift = At.Shift.AFTER))
     public void onInputUpdate(CallbackInfo ci) {
         MovementHandler.HANDLER.applyMovement((ClientPlayerEntity) (Object) this);
     }

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/CreativeInventoryScreenAccessor.java

@@ -58,4 +58,10 @@ public interface CreativeInventoryScreenAccessor {
      */
     @Invoker("hasScrollbar")
     boolean midnightcontrols$hasScrollbar();
+
+    /**
+     * Triggers searching the creative inventory from the current value of the internal {@link net.minecraft.client.gui.widget.TextFieldWidget}
+     */
+    @Invoker("search")
+    void midnightcontrols$search();
 }

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/GameOptionsScreenMixin.java

@@ -33,17 +33,24 @@ import static eu.midnightdust.midnightcontrols.MidnightControls.id;
 @Mixin(GameOptionsScreen.class)
 public abstract class GameOptionsScreenMixin extends Screen {
     @Shadow @Nullable protected OptionListWidget body;
-    @Unique TextIconButtonWidget midnightcontrols$button = TextIconButtonWidget.builder(Text.translatable("midnightcontrols.menu.title.controller"), (button -> this.client.setScreen(new MidnightControlsSettingsScreen(this, false))), true)
+    @Unique TextIconButtonWidget midnightcontrols$button = TextIconButtonWidget.builder(Text.translatable("midnightcontrols.menu.title.controller"),
+                    (button -> this.client.setScreen(new MidnightControlsSettingsScreen(this, false))), true)
             .dimension(20,20).texture(id("icon/controller"), 20, 20).build();
 
     protected GameOptionsScreenMixin(Text title) {
         super(title);
     }
 
-    @Inject(method = "init", at = @At("TAIL"))
+    @Inject(method = "initBody", at = @At("TAIL"))
     public void midnightcontrols$addMCButton(CallbackInfo ci) {
         if (this.getClass().toString().equals(ControlsOptionsScreen.class.toString())) {
             this.midnightcontrols$setButtonPos();
+            this.addSelectableChild(midnightcontrols$button);
+        }
+    }
+    @Inject(method = "init", at = @At("TAIL"))
+    public void midnightcontrols$drawMCButton(CallbackInfo ci) {
+        if (this.getClass().toString().equals(ControlsOptionsScreen.class.toString())) {
             this.addDrawableChild(midnightcontrols$button);
         }
     }

common/src/main/java/eu/midnightdust/midnightcontrols/client/mixin/WorldRendererMixin.java

@@ -68,7 +68,7 @@ public abstract class WorldRendererMixin {
 
     @Inject(
             method = "renderTargetBlockOutline",
-            at = @At("TAIL")
+            at = @At("HEAD")
     )
     private void onOutlineRender(Camera camera, VertexConsumerProvider.Immediate vertexConsumers, MatrixStack matrices, boolean translucent, CallbackInfo ci) {
         if (((MidnightControlsConfig.controlsMode == ControlsMode.CONTROLLER && MidnightControlsConfig.touchInControllerMode) || MidnightControlsConfig.controlsMode == ControlsMode.TOUCHSCREEN)

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/KeyboardLayout.java

@@ -0,0 +1,60 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class KeyboardLayout {
+
+    public static KeyboardLayout QWERTY = new KeyboardLayout(createQwertyLetterLayout(), createSymbolLayout());
+
+    private final List<List<String>> letters;
+    private final List<List<String>> symbols;
+
+    private KeyboardLayout(List<List<String>> letters, List<List<String>> symbols) {
+        this.letters = letters;
+        this.symbols = symbols;
+    }
+
+    public List<List<String>> getLetters() {
+        return letters;
+    }
+
+    public List<List<String>> getSymbols() {
+        return symbols;
+    }
+
+    private static List<List<String>> createQwertyLetterLayout() {
+        List<List<String>> letters = new ArrayList<>();
+        letters.add(Arrays.asList(
+                "q", "w", "e", "r", "t",
+                "y", "u", "i", "o", "p"
+        ));
+        letters.add(Arrays.asList(
+                "a", "s", "d", "f", "g",
+                "h", "j", "k", "l"
+        ));
+        letters.add(Arrays.asList(
+                "z", "x", "c", "v",
+                "b", "n", "m"
+        ));
+        return letters;
+    }
+
+    private static List<List<String>> createSymbolLayout() {
+        List<List<String>> symbols = new ArrayList<>();
+        symbols.add(Arrays.asList(
+                "1", "2", "3", "4", "5",
+                "6", "7", "8", "9", "0"
+        ));
+        symbols.add(Arrays.asList(
+                "@", "#", "$", "%", "&",
+                "*", "-", "+", "(", ")"
+        ));
+        symbols.add(Arrays.asList(
+                "!", "\"", "'", ":", ";",
+                ",", ".", "?", "/"
+        ));
+        return symbols;
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/MouseClickInterceptor.java

@@ -0,0 +1,36 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard;
+
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler.AbstractScreenClickHandler;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler.BookEditScreenClickHandler;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler.DefaultScreenClickHandler;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler.SignEditScreenClickHandler;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.ingame.BookEditScreen;
+import net.minecraft.client.gui.screen.ingame.SignEditScreen;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class MouseClickInterceptor {
+
+    private final Map<Class<?>, AbstractScreenClickHandler<?>> clickHandlers;
+
+    public MouseClickInterceptor() {
+        this.clickHandlers = new HashMap<>();
+        this.clickHandlers.put(BookEditScreen.class, new BookEditScreenClickHandler());
+        this.clickHandlers.put(SignEditScreen.class, new SignEditScreenClickHandler());
+        this.clickHandlers.put(Screen.class, new DefaultScreenClickHandler());
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends Screen> void intercept(T screen, double mouseX, double mouseY) {
+        AbstractScreenClickHandler<T> handler = (AbstractScreenClickHandler<T>) clickHandlers.get(screen.getClass());
+
+        if (handler == null) {
+            handler = (AbstractScreenClickHandler<T>) clickHandlers.get(Screen.class);
+        }
+
+        handler.handle(screen, mouseX, mouseY);
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/clickhandler/AbstractScreenClickHandler.java

@@ -0,0 +1,7 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler;
+
+import net.minecraft.client.gui.screen.Screen;
+
+public abstract class AbstractScreenClickHandler<T extends Screen> {
+    public abstract void handle(T screen, double mouseX, double mouseY);
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/clickhandler/BookEditScreenClickHandler.java

@@ -0,0 +1,36 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler;
+
+import eu.midnightdust.midnightcontrols.client.mixin.BookEditScreenAccessor;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.gui.VirtualKeyboardScreen;
+import net.minecraft.client.gui.screen.ingame.BookEditScreen;
+
+import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.client;
+
+public class BookEditScreenClickHandler extends AbstractScreenClickHandler<BookEditScreen> {
+    @Override
+    public void handle(BookEditScreen screen, double mouseX, double mouseY) {
+        // don't open the keyboard if a UI element was clicked
+        if(screen.hoveredElement(mouseX, mouseY).isPresent()) {
+            return;
+        }
+
+        var accessor = (BookEditScreenAccessor) screen;
+
+        VirtualKeyboardScreen virtualKeyboardScreen;
+        if(accessor.midnightcontrols$isSigning()) {
+            virtualKeyboardScreen = new VirtualKeyboardScreen(accessor.midnightcontrols$getTitle(), (text) -> {
+                client.setScreen(screen);
+                accessor.midnightcontrols$setTitle(text);
+            }, true);
+        }
+        else {
+            virtualKeyboardScreen = new VirtualKeyboardScreen(accessor.midnightcontrols$getCurrentPageContent(), (text) -> {
+                client.setScreen(screen);
+                accessor.midnightcontrols$setPageContent(text);
+                accessor.midnightcontrols$getCurrentPageSelectionManager().putCursorAtEnd();
+            }, true);
+        }
+
+        client.setScreen(virtualKeyboardScreen);
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/clickhandler/DefaultScreenClickHandler.java

@@ -0,0 +1,144 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler;
+
+import eu.midnightdust.midnightcontrols.client.mixin.CreativeInventoryScreenAccessor;
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.gui.VirtualKeyboardScreen;
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.ParentElement;
+import net.minecraft.client.gui.screen.ChatScreen;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.ingame.CreativeInventoryScreen;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.client;
+
+public class DefaultScreenClickHandler extends AbstractScreenClickHandler<Screen> {
+
+    private Screen parentScreen;
+    private List<Integer> textFieldElementPath;
+
+    @Override
+    public void handle(Screen screen, double mouseX, double mouseY) {
+        var textField = findClickedTextField(screen.children(), mouseX, mouseY);
+        if (textField == null) {
+            return;
+        }
+
+        this.parentScreen = screen;
+        this.textFieldElementPath = calculatePathToElement(screen, textField.asElement());
+
+        var virtualKeyboardScreen = new VirtualKeyboardScreen(textField.getText(), this::handleKeyboardClose, false);
+        client.setScreen(virtualKeyboardScreen);
+    }
+
+    private void handleKeyboardClose(String newText) {
+        if (this.parentScreen == null || this.textFieldElementPath == null) {
+            return;
+        }
+
+        client.setScreen(this.parentScreen);
+        TextFieldWrapper textField = findTextFieldByPath(this.parentScreen, this.textFieldElementPath);
+        if (textField == null) {
+            return;
+        }
+
+        textField.setText(newText);
+
+        switch (this.parentScreen) {
+            case CreativeInventoryScreen creativeInventoryScreen -> {
+                var accessor = (CreativeInventoryScreenAccessor) creativeInventoryScreen;
+                accessor.midnightcontrols$search();
+            }
+            case ChatScreen chatScreen -> {
+                // send the chat message
+                chatScreen.keyPressed(GLFW.GLFW_KEY_ENTER, 0, 0);
+            }
+            default -> {
+            }
+        }
+    }
+
+
+    private TextFieldWrapper findClickedTextField(List<? extends Element> elements, double mouseX, double mouseY) {
+        for (Element element : elements) {
+            if (TextFieldWrapper.isValidTextField(element)) {
+                TextFieldWrapper textField = new TextFieldWrapper(element);
+                if (textField.isMouseOver(mouseX, mouseY) && textField.isFocused()) {
+                    return textField;
+                }
+            }
+
+            if (element instanceof ParentElement parentElement) {
+                TextFieldWrapper found = findClickedTextField(parentElement.children(), mouseX, mouseY);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Calculates the path between a parent and a target in the UI hierarchy
+     */
+    protected List<Integer> calculatePathToElement(Element parent, Element target) {
+        if (!(parent instanceof ParentElement parentElement)) {
+            return null;
+        }
+
+        List<? extends Element> children = parentElement.children();
+
+        for (int i = 0; i < children.size(); i++) {
+            Element child = children.get(i);
+
+            if (child == target) {
+                return Collections.singletonList(i);
+            }
+
+            if (child instanceof ParentElement) {
+                List<Integer> subPath = calculatePathToElement(child, target);
+                if (subPath != null) {
+                    List<Integer> fullPath = new ArrayList<>(subPath.size() + 1);
+                    fullPath.add(i);
+                    fullPath.addAll(subPath);
+                    return fullPath;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    protected TextFieldWrapper findTextFieldByPath(Element parent, List<Integer> path) {
+        if (path == null || path.isEmpty()) {
+            return null;
+        }
+
+        if (!(parent instanceof ParentElement parentElement)) {
+            return null;
+        }
+
+        List<? extends Element> children = parentElement.children();
+        int index = path.get(0);
+
+        if (index < 0 || index >= children.size()) {
+            return null;
+        }
+
+        Element child = children.get(index);
+
+        if (path.size() == 1) {
+            return TextFieldWrapper.isValidTextField(child) ? new TextFieldWrapper(child) : null;
+        }
+
+        if (child instanceof ParentElement) {
+            return findTextFieldByPath(child, path.subList(1, path.size()));
+        }
+
+        return null;
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/clickhandler/SignEditScreenClickHandler.java

@@ -0,0 +1,16 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler;
+
+import eu.midnightdust.midnightcontrols.client.mixin.AbstractSignEditScreenAccessor;
+import net.minecraft.client.gui.screen.ingame.SignEditScreen;
+
+public class SignEditScreenClickHandler extends AbstractScreenClickHandler<SignEditScreen>  {
+    @Override
+    public void handle(SignEditScreen screen, double mouseX, double mouseY) {
+        // don't open the keyboard if a UI element was clicked
+        if(screen.hoveredElement(mouseX, mouseY).isPresent()) {
+            return;
+        }
+
+        var accessor = (AbstractSignEditScreenAccessor) screen;
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/clickhandler/TextFieldWrapper.java

@@ -0,0 +1,77 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.clickhandler;
+
+import net.minecraft.client.gui.Element;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import org.thinkingstudio.obsidianui.widget.text.SpruceTextFieldWidget;
+
+public record TextFieldWrapper(Object textField) {
+
+    public TextFieldWrapper {
+        if (!isValidTextField(textField)) {
+            throw new IllegalArgumentException("Type " + textField.getClass() + " is not marked as a valid text field");
+        }
+    }
+
+    Element asElement() {
+        return (Element) textField;
+    }
+
+    String getText() {
+        switch (textField) {
+            case SpruceTextFieldWidget spruceTextField -> {
+                return spruceTextField.getText();
+            }
+            case TextFieldWidget vanillaTextField -> {
+                return vanillaTextField.getText();
+            }
+            default -> {
+                return null;
+            }
+        }
+    }
+
+    void setText(String text) {
+        switch (textField) {
+            case SpruceTextFieldWidget spruceTextField -> {
+                spruceTextField.setText(text);
+            }
+            case TextFieldWidget vanillaTextField -> {
+                vanillaTextField.setText(text);
+            }
+            default -> {
+            }
+        }
+    }
+
+    boolean isMouseOver(double mouseX, double mouseY) {
+        switch (textField) {
+            case SpruceTextFieldWidget spruceTextField -> {
+                return spruceTextField.isMouseOver(mouseX, mouseY);
+            }
+            case TextFieldWidget vanillaTextField -> {
+                return vanillaTextField.isMouseOver(mouseX, mouseY);
+            }
+            default -> {
+                return false;
+            }
+        }
+    }
+
+    boolean isFocused() {
+        switch (textField) {
+            case SpruceTextFieldWidget spruceTextField -> {
+                return spruceTextField.isFocused();
+            }
+            case TextFieldWidget vanillaTextField -> {
+                return vanillaTextField.isFocused();
+            }
+            default -> {
+                return false;
+            }
+        }
+    }
+
+    static boolean isValidTextField(Object textField) {
+        return textField instanceof TextFieldWidget || textField instanceof SpruceTextFieldWidget;
+    }
+}

common/src/main/java/eu/midnightdust/midnightcontrols/client/virtualkeyboard/gui/VirtualKeyboardScreen.java

@@ -0,0 +1,300 @@
+package eu.midnightdust.midnightcontrols.client.virtualkeyboard.gui;
+
+import eu.midnightdust.midnightcontrols.client.virtualkeyboard.KeyboardLayout;
+import net.minecraft.client.gui.DrawContext;
+import net.minecraft.text.Text;
+import org.thinkingstudio.obsidianui.Position;
+import org.thinkingstudio.obsidianui.SpruceTexts;
+import org.thinkingstudio.obsidianui.screen.SpruceScreen;
+import org.thinkingstudio.obsidianui.widget.SpruceButtonWidget;
+import org.thinkingstudio.obsidianui.widget.container.SpruceContainerWidget;
+import org.thinkingstudio.obsidianui.widget.text.SpruceTextAreaWidget;
+
+import java.util.List;
+
+public class VirtualKeyboardScreen extends SpruceScreen {
+
+    @FunctionalInterface
+    public interface CloseCallback {
+        void onClose(String text);
+    }
+
+    private static final int STANDARD_KEY_WIDTH = 20;
+    private static final int SPECIAL_KEY_WIDTH = (int) (STANDARD_KEY_WIDTH * 1.5);
+    private static final int KEY_HEIGHT = 20;
+    private static final int HORIZONTAL_SPACING = 2;
+    private static final int VERTICAL_SPACING = 4;
+    private static final int CONTAINER_PADDING = 10;
+
+    // Key symbols
+    private static final String BACKSPACE_SYMBOL = "\b";
+    private static final String NEWLINE_SYMBOL = "\n";
+    private static final String SPACE_SYMBOL = " ";
+
+    private final StringBuilder buffer;
+    private final CloseCallback closeCallback;
+    private final KeyboardLayout layout;
+    private final boolean newLineSupport;
+
+    private boolean capsMode;
+    private boolean symbolMode;
+    private SpruceTextAreaWidget bufferDisplayArea;
+    private SpruceContainerWidget keyboardContainer;
+
+    public VirtualKeyboardScreen(String initialText, CloseCallback closeCallback, boolean newLineSupport) {
+        super(Text.literal("Virtual Keyboard"));
+        this.buffer = new StringBuilder(initialText);
+        this.closeCallback = closeCallback;
+        this.layout = KeyboardLayout.QWERTY;
+        this.capsMode = false;
+        this.symbolMode = false;
+        this.newLineSupport = newLineSupport;
+    }
+
+    @Override
+    protected void init() {
+        super.init();
+
+        this.bufferDisplayArea = createBufferDisplayArea();
+        this.addDrawableChild(this.bufferDisplayArea);
+
+        rebuildKeyboard();
+
+        int doneButtonY = this.keyboardContainer.getY() + this.keyboardContainer.getHeight() + VERTICAL_SPACING * 2;
+        this.addDrawableChild(
+                new SpruceButtonWidget(
+                        Position.of(this, this.width / 2 - 50, doneButtonY),
+                        100,
+                        20,
+                        SpruceTexts.GUI_DONE,
+                        btn -> this.close()
+                )
+        );
+    }
+
+    @Override
+    public void render(DrawContext drawContext, int mouseX, int mouseY, float delta) {
+        this.renderBackground(drawContext, mouseX, mouseY, delta);
+        super.render(drawContext, mouseX, mouseY, delta);
+    }
+
+    @Override
+    public boolean shouldPause() {
+        return false;
+    }
+
+    @Override
+    public void close() {
+        super.close();
+        if (this.closeCallback != null) {
+            this.closeCallback.onClose(this.buffer.toString());
+        }
+    }
+
+    private void rebuildKeyboard() {
+        if (this.keyboardContainer != null) {
+            this.remove(this.keyboardContainer);
+        }
+
+        var layoutKeys = getActiveKeyLayout();
+        var keyboardContainer = createKeyboardContainer(layoutKeys);
+
+        addLayoutRows(keyboardContainer, layoutKeys);
+        addFunctionKeys(keyboardContainer);
+        addBottomRow(keyboardContainer);
+
+        this.keyboardContainer = keyboardContainer;
+        this.addDrawableChild(this.keyboardContainer);
+    }
+
+    private SpruceContainerWidget createKeyboardContainer(List<List<String>> layoutKeys) {
+        int containerWidth = this.width;
+        int totalKeyboardHeight = calculateKeyboardHeight(layoutKeys);
+        int keyboardY = this.bufferDisplayArea.getY() + this.bufferDisplayArea.getHeight() + VERTICAL_SPACING * 2;
+
+        return new SpruceContainerWidget(
+                Position.of(0, keyboardY),
+                containerWidth,
+                totalKeyboardHeight
+        );
+    }
+
+    private SpruceTextAreaWidget createBufferDisplayArea() {
+        int lineCount = this.newLineSupport ? 4 : 1;
+        int bufferX = this.width / 2 - 100;
+        int bufferY = this.height / 4 - VERTICAL_SPACING * 5 - 5;
+        int bufferWidth = 200;
+        int desiredHeight = (this.textRenderer.fontHeight + 2) * lineCount + 6;
+
+        var bufferDisplay = new SpruceTextAreaWidget(
+                Position.of(bufferX, bufferY),
+                bufferWidth,
+                desiredHeight,
+                Text.literal("Buffer Display")
+        );
+        bufferDisplay.setText(this.buffer.toString());
+        bufferDisplay.setEditable(false);
+        bufferDisplay.setUneditableColor(0xFFFFFFFF);
+        bufferDisplay.setDisplayedLines(lineCount);
+        bufferDisplay.setCursorToEnd();
+
+        return bufferDisplay;
+    }
+
+    private int calculateKeyboardHeight(List<List<String>> keyRows) {
+        return keyRows.size() * (KEY_HEIGHT + VERTICAL_SPACING) +
+                (KEY_HEIGHT + VERTICAL_SPACING) + // space for bottom row
+                CONTAINER_PADDING * 2; // top and bottom padding
+    }
+
+    private void addLayoutRows(SpruceContainerWidget container, List<List<String>> keyLayoutRows) {
+        int currentY = CONTAINER_PADDING;
+
+        for (List<String> row : keyLayoutRows) {
+            int rowWidth = calculateRowWidth(row);
+            // center row
+            int currentX = (container.getWidth() - rowWidth) / 2;
+
+            for (String key : row) {
+                String displayText = (this.capsMode && !this.symbolMode) ? key.toUpperCase() : key;
+                container.addChild(
+                        new SpruceButtonWidget(
+                                Position.of(currentX, currentY),
+                                STANDARD_KEY_WIDTH,
+                                KEY_HEIGHT,
+                                Text.literal(displayText),
+                                btn -> handleKeyPress(displayText)
+                        )
+                );
+
+                currentX += STANDARD_KEY_WIDTH + HORIZONTAL_SPACING;
+            }
+
+            currentY += KEY_HEIGHT + VERTICAL_SPACING;
+        }
+    }
+
+    private int calculateRowWidth(List<String> row) {
+        int rowWidth = 0;
+        for (int i = 0; i < row.size(); i++) {
+            rowWidth += STANDARD_KEY_WIDTH;
+            // padding
+            if (i < row.size() - 1) {
+                rowWidth += HORIZONTAL_SPACING;
+            }
+        }
+        return rowWidth;
+    }
+
+    private void addFunctionKeys(SpruceContainerWidget container) {
+        List<String> firstRow = getActiveKeyLayout().get(0);
+        int firstRowWidth = calculateRowWidth(firstRow);
+
+        // position backspace at the right of the first row
+        int backspaceWidth = (int) (STANDARD_KEY_WIDTH * 1.5);
+        int backspaceX = (container.getWidth() + firstRowWidth) / 2 + HORIZONTAL_SPACING;
+
+        container.addChild(
+                new SpruceButtonWidget(
+                        Position.of(backspaceX, CONTAINER_PADDING),
+                        backspaceWidth,
+                        KEY_HEIGHT,
+                        Text.literal("←"),
+                        btn -> handleKeyPress(BACKSPACE_SYMBOL)
+                )
+        );
+
+
+        if (this.newLineSupport) {
+            // position newline at the right of the second row
+            List<String> secondRow = getActiveKeyLayout().get(1);
+            int newlineWidth = (int) (STANDARD_KEY_WIDTH * 1.5);
+            int secondRowWidth = calculateRowWidth(secondRow);
+            int newlineX = (container.getWidth() + secondRowWidth) / 2 + HORIZONTAL_SPACING;
+            int newlineY = CONTAINER_PADDING + (KEY_HEIGHT + VERTICAL_SPACING);
+
+            container.addChild(
+                    new SpruceButtonWidget(
+                            Position.of(newlineX, newlineY),
+                            newlineWidth,
+                            KEY_HEIGHT,
+                            Text.literal("⏎"),
+                            btn -> handleKeyPress(NEWLINE_SYMBOL)
+                    )
+            );
+        }
+    }
+
+    private void addBottomRow(SpruceContainerWidget container) {
+        // calculate positions for bottom row
+        int rowY = CONTAINER_PADDING + getActiveKeyLayout().size() * (KEY_HEIGHT + VERTICAL_SPACING);
+
+        // space bar - wide key in the middle
+        double spaceWidthFactor = 5.0;
+        int spaceKeyWidth = (int) (STANDARD_KEY_WIDTH * spaceWidthFactor);
+        int spaceX = (container.getWidth() - spaceKeyWidth) / 2;
+
+        container.addChild(
+                new SpruceButtonWidget(
+                        Position.of(spaceX, rowY),
+                        spaceKeyWidth,
+                        KEY_HEIGHT,
+                        Text.literal("Space"),
+                        btn -> handleKeyPress(SPACE_SYMBOL)
+                )
+        );
+
+        // caps key - left of space
+        if (!this.symbolMode) {
+            int capsX = spaceX - SPECIAL_KEY_WIDTH - HORIZONTAL_SPACING * 2;
+            var capsModeButton = new SpruceButtonWidget(
+                    Position.of(capsX, rowY),
+                    SPECIAL_KEY_WIDTH,
+                    KEY_HEIGHT,
+                    Text.literal(this.capsMode ? "caps" : "CAPS"),
+                    btn -> toggleCapsMode());
+
+            container.addChild(capsModeButton);
+        }
+
+        // symbols key - right of space
+        int symbolsX = spaceX + spaceKeyWidth + HORIZONTAL_SPACING * 2;
+        var symbolModeButton = new SpruceButtonWidget(
+                Position.of(symbolsX, rowY),
+                SPECIAL_KEY_WIDTH,
+                KEY_HEIGHT,
+                Text.literal(this.symbolMode ? "ABC" : "123?!"),
+                btn -> toggleSymbolMode()
+        );
+        container.addChild(symbolModeButton);
+    }
+
+    private void handleKeyPress(String key) {
+        if (key.equals(BACKSPACE_SYMBOL)) {
+            if (!this.buffer.isEmpty()) {
+                this.buffer.deleteCharAt(buffer.length() - 1);
+            }
+        } else {
+            this.buffer.append(key);
+        }
+
+        if (this.bufferDisplayArea != null) {
+            this.bufferDisplayArea.setText(this.buffer.toString());
+            this.bufferDisplayArea.setCursorToEnd();
+        }
+    }
+
+    private List<List<String>> getActiveKeyLayout() {
+        return this.symbolMode ? this.layout.getSymbols() : this.layout.getLetters();
+    }
+
+    private void toggleCapsMode() {
+        this.capsMode = !this.capsMode;
+        rebuildKeyboard();
+    }
+
+    private void toggleSymbolMode() {
+        this.symbolMode = !this.symbolMode;
+        rebuildKeyboard();
+    }
+}

common/src/main/resources/assets/midnightcontrols/lang/en_us.json

@@ -220,6 +220,8 @@
   "midnightcontrols.menu.virtual_mouse": "Virtual Mouse",
   "midnightcontrols.menu.virtual_mouse.tooltip": "Enables the virtual mouse, which is useful during splitscreen.",
   "midnightcontrols.menu.virtual_mouse.skin": "Virtual Mouse Skin",
+  "midnightcontrols.menu.virtual_keyboard": "Virtual Keyboard",
+  "midnightcontrols.menu.virtual_keyboard.tooltip": "Enables a virtual on-screen keyboard",
   "midnightcontrols.menu.hide_cursor": "Hide Normal Mouse Cursor",
   "midnightcontrols.menu.hide_cursor.tooltip": "Hides the normal mouse cursor, leaving only the virtual mouse visible.",
   "midnightcontrols.narrator.unbound": "Unbound %s",

common/src/main/resources/assets/midnightcontrols/lang/pt_br.json

@@ -0,0 +1,238 @@
+{
+  "midnightcontrols.midnightconfig.title": "Configurações avançadas do MidnightControls",
+  "midnightcontrols.midnightconfig.enum.VirtualMouseSkin.DEFAULT_LIGHT": "Padrão claro",
+  "midnightcontrols.midnightconfig.enum.VirtualMouseSkin.DEFAULT_DARK": "Padrão escuro",
+  "midnightcontrols.midnightconfig.enum.VirtualMouseSkin.SECOND_LIGHT": "Segundo claro",
+  "midnightcontrols.midnightconfig.enum.VirtualMouseSkin.SECOND_DARK": "Segundo escuro",
+  "midnightcontrols.midnightconfig.enum.ControllerType.DEFAULT": "Padrão",
+  "midnightcontrols.midnightconfig.enum.ControllerType.DUALSHOCK": "DualShock",
+  "midnightcontrols.midnightconfig.enum.ControllerType.DUALSENSE": "DualSense",
+  "midnightcontrols.midnightconfig.enum.ControllerType.SWITCH": "Controle de Switch/Wii",
+  "midnightcontrols.midnightconfig.enum.ControllerType.XBOX": "Controle de Xbox One/Series",
+  "midnightcontrols.midnightconfig.enum.ControllerType.XBOX_360": "Controle de Xbox 360",
+  "midnightcontrols.midnightconfig.enum.ControllerType.STEAM_CONTROLLER": "Controle da Steam",
+  "midnightcontrols.midnightconfig.enum.ControllerType.STEAM_DECK": "Steam Deck",
+  "midnightcontrols.midnightconfig.enum.ControllerType.OUYA": "Controle de OUYA",
+  "midnightcontrols.midnightconfig.enum.ControllerType.NUMBERED": "Controle númerado",
+  "midnightcontrols.midnightconfig.enum.ControlsMode.DEFAULT": "Teclado/Mouse",
+  "midnightcontrols.midnightconfig.enum.ControlsMode.CONTROLLER": "Controle",
+  "midnightcontrols.midnightconfig.enum.ControlsMode.TOUCHSCREEN": "Tela sensível ao toque (Beta)",
+  "midnightcontrols.midnightconfig.enum.HudSide.LEFT": "Esquerda",
+  "midnightcontrols.midnightconfig.enum.HudSide.RIGHT": "Direita",
+  "midnightcontrols.midnightconfig.enum.TouchMode.CROSSHAIR": "Na mira",
+  "midnightcontrols.midnightconfig.enum.TouchMode.FINGER_POS": "Posição do dedo",
+  "midnightcontrols.midnightconfig.enum.CameraMode.FLAT": "Plano",
+  "midnightcontrols.midnightconfig.enum.CameraMode.ADAPTIVE": "Adaptativo",
+  "key.categories.midnightcontrols": "MidnightControls",
+  "key.midnightcontrols.look_down": "Olhar para baixo",
+  "key.midnightcontrols.look_left": "Olhar para a esquerda",
+  "key.midnightcontrols.look_right": "Olhar para a direita",
+  "key.midnightcontrols.look_up": "Olhar para cima",
+  "key.midnightcontrols.ring": "Abrir anel de teclas não vinculadas",
+  "midnightcontrols.action.attack": "Atacar",
+  "midnightcontrols.action.back": "Voltar",
+  "midnightcontrols.action.chat": "Abrir bate-papo",
+  "midnightcontrols.action.controls_ring": "Abrir anel de teclas não vinculadas",
+  "midnightcontrols.action.debug_screen": "Abrir HUD de depuração (F3)",
+  "midnightcontrols.action.drop_item": "Soltar item",
+  "midnightcontrols.action.drink": "Beber",
+  "midnightcontrols.action.eat": "Comer",
+  "midnightcontrols.action.equip": "Equipar",
+  "midnightcontrols.action.exit": "Sair da tela",
+  "midnightcontrols.action.forward": "Para frente",
+  "midnightcontrols.action.hit": "Atacar",
+  "midnightcontrols.action.hotbar_left": "Move a barra rápida para esquerda",
+  "midnightcontrols.action.hotbar_right": "Move a barra rápida para direita",
+  "midnightcontrols.action.inventory": "Invetário",
+  "midnightcontrols.action.jump": "Pular",
+  "midnightcontrols.action.left": "Esquerda",
+  "midnightcontrols.action.pause_game": "Pausar",
+  "midnightcontrols.action.pick_block": "Pegar bloco",
+  "midnightcontrols.action.pickup": "Pegar",
+  "midnightcontrols.action.pickup_all": "Pegar todos",
+  "midnightcontrols.action.place": "Colocar",
+  "midnightcontrols.action.player_list": "Lista de jogadores",
+  "midnightcontrols.action.quick_move": "Mover rápido",
+  "midnightcontrols.action.right": "Direita",
+  "midnightcontrols.action.screenshot": "Tirar Screenshot",
+  "midnightcontrols.action.slot_up": "Mover Slot para cima",
+  "midnightcontrols.action.slot_down": "Mover Slot para baixo",
+  "midnightcontrols.action.slot_left": "Mover Slot para esquerda",
+  "midnightcontrols.action.slot_right": "Mover Slot para direita",
+  "midnightcontrols.action.sneak": "Esgueirar",
+  "midnightcontrols.action.sprint": "Correr",
+  "midnightcontrols.action.swap_hands": "Trocar de mãos",
+  "midnightcontrols.action.toggle_perspective": "Alternar perspectiva",
+  "midnightcontrols.action.toggle_smooth_camera": "Ativar câmera cinemática",
+  "midnightcontrols.action.page_back": "Página anterior",
+  "midnightcontrols.action.page_next": "Próxima página",
+  "midnightcontrols.action.tab_back": "Aba anterior",
+  "midnightcontrols.action.tab_next": "Próxima aba",
+  "midnightcontrols.action.take": "Pegar item",
+  "midnightcontrols.action.take_all": "Pegar pilha",
+  "midnightcontrols.action.use": "Usar",
+  "midnightcontrols.action.zoom": "Zoom",
+  "midnightcontrols.action.zoom_in": "Aumentar o Zoom",
+  "midnightcontrols.action.zoom_out": "Diminuir o Zoom",
+  "midnightcontrols.action.zoom_reset": "Resetar o Zoom",
+  "midnightcontrols.action.emi_page_left": "Página anterior",
+  "midnightcontrols.action.emi_page_right": "Próxima pickup",
+  "midnightcontrols.category.emi": "EMI",
+  "midnightcontrols.button.a": "A",
+  "midnightcontrols.button.b": "B",
+  "midnightcontrols.button.x": "X",
+  "midnightcontrols.button.y": "Y",
+  "midnightcontrols.button.left_bumper": "Botão L1",
+  "midnightcontrols.button.right_bumper": "Botão R1",
+  "midnightcontrols.button.back": "Voltar",
+  "midnightcontrols.button.start": "Começar",
+  "midnightcontrols.button.guide": "Guia",
+  "midnightcontrols.button.left_thumb": "Analógico esquerdo",
+  "midnightcontrols.button.right_thumb": "Analógico direito",
+  "midnightcontrols.button.dpad_up": "Botão direcional para cima",
+  "midnightcontrols.button.dpad_right": "Botão direcional para direita",
+  "midnightcontrols.button.dpad_down": "Botão direcional para baixo",
+  "midnightcontrols.button.dpad_left": "Botão direcional para esquerda",
+  "midnightcontrols.button.l4": "L4",
+  "midnightcontrols.button.l5": "L5",
+  "midnightcontrols.button.r4": "R4",
+  "midnightcontrols.button.r5": "L5",
+  "midnightcontrols.axis.left_x+": "Esquerda X+",
+  "midnightcontrols.axis.left_y+": "Esquerda Y+",
+  "midnightcontrols.axis.right_x+": "Direita X+",
+  "midnightcontrols.axis.right_y+": "Direita Y+",
+  "midnightcontrols.axis.left_trigger": "Gatilho da esquerda",
+  "midnightcontrols.axis.right_trigger": "Gatilho da direita",
+  "midnightcontrols.axis.left_x-": "Esquerda X-",
+  "midnightcontrols.axis.left_y-": "Esquerda Y-",
+  "midnightcontrols.axis.right_x-": "Direita X-",
+  "midnightcontrols.axis.right_y-": "Direita Y-",
+  "midnightcontrols.button.unknown": "Desconhecido (%d)",
+  "midnightcontrols.controller.tutorial.title": "Jogue o jogo com um controle!",
+  "midnightcontrols.controller.tutorial.description": "Vá para %s -> %s -> %s",
+  "midnightcontrols.controller.connected": "Controle %d conectado.",
+  "midnightcontrols.controller.disconnected": "Controle %d desconectado.",
+  "midnightcontrols.controller.mappings.1": "Para configurar o mapeamento do controle, por favor use %s",
+  "midnightcontrols.controller.mappings.3": "e cole o mapeamento no editor de arquivos do mapeamento.",
+  "midnightcontrols.controller.mappings.error": "Erro ao carregar mapeamentos.",
+  "midnightcontrols.controller.mappings.error.write": "Erro ao gravar mapeamentos no arquivo.",
+  "midnightcontrols.controller.mappings.updated": "Atualizando mapeamentos!",
+  "midnightcontrols.controller_type.default": "Padrão",
+  "midnightcontrols.controller_type.dualshock": "DualShock",
+  "midnightcontrols.controller_type.dualsense": "DualSense",
+  "midnightcontrols.controller_type.switch": "Controle de Switch/Wii",
+  "midnightcontrols.controller_type.xbox": "Controle de Xbox One/Series",
+  "midnightcontrols.controller_type.xbox_360": "Controle de Xbox 360",
+  "midnightcontrols.controller_type.steam_controller": "Controle da Steam",
+  "midnightcontrols.controller_type.steam_deck": "Steam Deck",
+  "midnightcontrols.controller_type.ouya": "Controle de OUYA",
+  "midnightcontrols.controller_type.numbered": "Controle númerado",
+  "midnightcontrols.controls_mode.default": "Teclado/Mouse",
+  "midnightcontrols.controls_mode.controller": "Controle",
+  "midnightcontrols.controls_mode.touchscreen": "Tela sensível ao toque (Beta)",
+  "midnightcontrols.hud_side.LEFT": "Esquerda",
+  "midnightcontrols.hud_side.RIGHT": "Direita",
+  "midnightcontrols.menu.analog_movement": "Movemento analógico",
+  "midnightcontrols.menu.analog_movement.tooltip": "Quando possível, ative o movemento analógico.",
+  "midnightcontrols.menu.auto_switch_mode": "Modo de troca automática",
+  "midnightcontrols.menu.auto_switch_mode.tooltip": "Se o modo de controle deve ser alterado automaticamente para o controle quando um for conectado.",
+  "midnightcontrols.menu.camera_mode": "Modo de câmera",
+  "midnightcontrols.menu.controller": "Controle",
+  "midnightcontrols.menu.controller2": "Segundo controle",
+  "midnightcontrols.menu.controller2.tooltip": "Segundo controle a ser usado, o que permite (por exemplo) o suporte a Joy-Cons.",
+  "midnightcontrols.menu.controller_toggle_sneak": "Alternar Esgueirar no Controle",
+  "midnightcontrols.menu.controller_toggle_sprint": "Alternar Correr no Controle",
+  "midnightcontrols.menu.controller_type": "Tipo de controle",
+  "midnightcontrols.menu.controller_type.tooltip": "O tipo de controle que você está usando (é preciso para mostrar os botões corretos)",
+  "midnightcontrols.menu.controls_mode": "Modo",
+  "midnightcontrols.menu.controls_mode.tooltip": "O modo de controle.",
+  "midnightcontrols.menu.copy_controller_guid": "Copiar o GUID",
+  "midnightcontrols.menu.current_controller_guid": "GUID do controle atual: %s",
+  "midnightcontrols.menu.double_tap_to_sprint": "Toque duplo para correr",
+  "midnightcontrols.menu.double_tap_to_sprint.tooltip": "Alterna se a tecla Andar para Frente faz o jogador correr quando pressionada duas vezes rapidamente",
+  "midnightcontrols.menu.fast_block_placing": "Colocação Rápida de Blocos",
+  "midnightcontrols.menu.fast_block_placing.tooltip": "Enquanto voando no criativo, ativar a Colocação de Rápida de Blocos. §cEm alguns servidores isso pode ser considerado como trapaça.",
+  "midnightcontrols.menu.fly_drifting": "Derrapagem ao Voar",
+  "midnightcontrols.menu.fly_drifting.tooltip": "Enquanto voando, ativa a deparragem/inércia Vanilla.",
+  "midnightcontrols.menu.fly_drifting_vertical": "Derrapagem vertical ao Voar",
+  "midnightcontrols.menu.fly_drifting_vertical.tooltip": "Enquanto voando, ativa a deparragem/inércia vertical Vanilla.",
+  "midnightcontrols.menu.hud_enable": "Ativar HUD",
+  "midnightcontrols.menu.hud_enable.tooltip": "Alterna o indicador de botão do controle na tela.",
+  "midnightcontrols.menu.hud_side": "Lado do HUD",
+  "midnightcontrols.menu.hud_side.tooltip": "A posição do HUD.",
+  "midnightcontrols.menu.invert_right_x_axis": "Inverter X Direito",
+  "midnightcontrols.menu.invert_right_y_axis": "Inverter Y Direito",
+  "midnightcontrols.menu.joystick_as_mouse": "Sempre usar analógico esquerdo como mouse",
+  "midnightcontrols.menu.joystick_as_mouse.tooltip": "Fazer o analógico agir como um mouse em todos os menus.",
+  "midnightcontrols.menu.eye_tracker_as_mouse": "Usar o rastreador ocular como um mouse",
+  "midnightcontrols.menu.eye_tracker_as_mouse.tooltip": "Substituir o mouse com um dispositivo de rastreamento ocular, (por exemplo) o Tobii 5.",
+  "midnightcontrols.menu.eye_tracker_deadzone": "Tamanho da zona morta do rastreador ocular",
+  "midnightcontrols.menu.eye_tracker_deadzone.tooltip": "Parar o movimento da camera quando olhar perto da mira",
+  "midnightcontrols.menu.keyboard_controls": "Controles do teclado...",
+  "midnightcontrols.menu.left_dead_zone": "Zona morta do analógico esquerdo",
+  "midnightcontrols.menu.left_dead_zone.tooltip": "A zona morta para o analógico esquerdo do controle.",
+  "midnightcontrols.menu.mappings.open_input_str": "Abrir editor de arquivo de mapeamentos",
+  "midnightcontrols.menu.max_left_x_value": "Valor máximo do eixo X esquerdo",
+  "midnightcontrols.menu.max_left_x_value.tooltip": "Altera o valor máximo considerado pelo mod para o eixo X esquerdo. Útil se o seu eixo não usa toda a faixa e parece lento.",
+  "midnightcontrols.menu.max_left_y_value": "Valor máximo do eixo Y esquerdo",
+  "midnightcontrols.menu.max_left_y_value.tooltip": "Altera o valor máximo considerado pelo mod para o eixo Y esquerdo. Útil se o seu eixo não usa toda a faixa e parece lento.",
+  "midnightcontrols.menu.max_right_x_value": "Valor máximo do eixo X direito",
+  "midnightcontrols.menu.max_right_x_value.tooltip": "Altera o valor máximo considerado pelo mod para o eixo X direito. Útil se o seu eixo não usa toda a faixa e parece lento.",
+  "midnightcontrols.menu.max_right_y_value": "Valor máximo do eixo Y direito",
+  "midnightcontrols.menu.max_right_y_value.tooltip": "Altera o valor máximo considerado pelo mod para o eixo Y direito. Útil se o seu eixo não usa toda a faixa e parece lento.",
+  "midnightcontrols.menu.mouse_speed": "Velocidade do mouse",
+  "midnightcontrols.menu.mouse_speed.tooltip": "A velocidade do mouse emulado pelo controle",
+  "midnightcontrols.menu.move_chat": "Mover a caixa do chat para o topo",
+  "midnightcontrols.menu.move_chat.tooltip": "Move a caixa do chat para o topo, para uma melhor digitação em dispositivos com teclados na tela.",
+  "midnightcontrols.menu.multiple_mapping_tip": "(Dica: Você também pode inserir múltiplos mapeamentos ao mesmo tempo)",
+  "midnightcontrols.menu.reacharound.horizontal": "Colocação frontal de blocos",
+  "midnightcontrols.menu.reacharound.horizontal.tooltip": "Ativa colocação frontal de blocos, §cEm alguns servidores isso pode ser considerado como trapaça.§r.",
+  "midnightcontrols.menu.reacharound.vertical": "Alcance vertical",
+  "midnightcontrols.menu.reacharound.vertical.tooltip": "Ativa alcance vertical, §c§cEm alguns servidores isso pode ser considerado como trapaça.§r.",
+  "midnightcontrols.menu.reload_controller_mappings": "Recarregar o mapeamento do controle",
+  "midnightcontrols.menu.reload_controller_mappings.tooltip": "Recarrega o arquivo de mapeamentos do controle.",
+  "midnightcontrols.menu.right_dead_zone": "Zona morta do analógico direito",
+  "midnightcontrols.menu.right_dead_zone.tooltip": "A zona morta para o analógico direito do controle..",
+  "midnightcontrols.menu.rotation_speed": "Velocidade de rotação do eixo X",
+  "midnightcontrols.menu.rotation_speed.tooltip": "A velocidade de rotação do eixo X da câmera no modo controle.",
+  "midnightcontrols.menu.y_axis_rotation_speed": "Velocidade de rotação do eixo Y",
+  "midnightcontrols.menu.y_axis_rotation_speed.tooltip": "A velocidade de rotação do eixo Y da câmera no modo controle.",
+  "midnightcontrols.menu.separate_controller_profile": "Separar perfil do controle",
+  "midnightcontrols.menu.separator.controller": "Controle",
+  "midnightcontrols.menu.separator.general": "Geral",
+  "midnightcontrols.menu.title": "MidnightControls - Configurações",
+  "midnightcontrols.menu.title.controller": "Configurações do controle",
+  "midnightcontrols.menu.title.controller_controls": "Mapeamento de controle",
+  "midnightcontrols.menu.title.gameplay": "Configurações de jogabilidade",
+  "midnightcontrols.menu.title.general": "Configurações gerais",
+  "midnightcontrols.menu.title.hud": "Configurações de HUD",
+  "midnightcontrols.menu.title.mappings.string": "Editor de arquivo de mapeamentos",
+  "midnightcontrols.menu.title.touch": "Configurações de toque",
+  "midnightcontrols.menu.title.visual": "Configurações de aparência",
+  "midnightcontrols.menu.touch_break_delay": "Atrasado de destruição do toque",
+  "midnightcontrols.menu.touch_speed": "Velocidade do toque",
+  "midnightcontrols.menu.invert_touch": "Inverter direção do toque",
+  "midnightcontrols.menu.touch_mode": "Modo de interação de toque",
+  "midnightcontrols.menu.touch_transparency": "Transparência do HUD de toque",
+  "midnightcontrols.menu.touch_with_controller": "Toque no modo do controle",
+  "midnightcontrols.menu.unfocused_input": "Entrada desfocada",
+  "midnightcontrols.menu.unfocused_input.tooltip": "Permite entrada de sinais do controle quando a janela não está em foco.",
+  "midnightcontrols.menu.virtual_mouse": "Mouse virtual",
+  "midnightcontrols.menu.virtual_mouse.tooltip": "Ativa o mouse virtual, que é útil durante o modo tela dividida.",
+  "midnightcontrols.menu.virtual_mouse.skin": "Tema do mouse virtual",
+  "midnightcontrols.menu.hide_cursor": "Desativar cursor do mouse padrão",
+  "midnightcontrols.menu.hide_cursor.tooltip": "Esconde o cursor padrão do mouse, deixando apenas o mouse virtual visível.",
+  "midnightcontrols.narrator.unbound": "Desmapear %s",
+  "midnightcontrols.not_bound": "Não mapeado",
+  "midnightcontrols.virtual_mouse.skin.default_light": "Padrão claro",
+  "midnightcontrols.virtual_mouse.skin.default_dark": "Padrão escuro",
+  "midnightcontrols.virtual_mouse.skin.second_light": "Segundo claro",
+  "midnightcontrols.virtual_mouse.skin.second_dark": "Segundo escuro",
+  "midnightcontrols.midnightconfig.category.controller": "Controle",
+  "midnightcontrols.midnightconfig.category.misc": "Variados",
+  "midnightcontrols.midnightconfig.category.screens": "Telas",
+  "midnightcontrols.midnightconfig.category.gameplay": "Jogabilidade",
+  "midnightcontrols.midnightconfig.category.touch": "Toque",
+  "midnightcontrols.midnightconfig.category.visual": "Visual",
+  "modmenu.descriptionTranslation.midnightcontrols": "Adiciona suporte a controles e aprimora o controle no geral.\nDerivado do LambdaControls, que infelizmente foi descontinuado."
+}

common/src/main/resources/midnightcontrols.mixins.json

@@ -1,9 +1,10 @@
 {
   "required": true,
   "package": "eu.midnightdust.midnightcontrols.client.mixin",
-  "compatibilityLevel": "JAVA_16",
+  "compatibilityLevel": "JAVA_21",
   "client": [
     "AdvancementsScreenAccessor",
+    "BookEditScreenAccessor",
     "ChatScreenMixin",
     "ClickableWidgetAccessor",
     "ClientPlayerEntityMixin",
@@ -22,6 +23,7 @@
     "RecipeBookScreenAccessor",
     "RecipeBookWidgetAccessor",
     "ScreenMixin",
+    "AbstractSignEditScreenAccessor",
     "TabNavigationWidgetAccessor",
     "WorldRendererMixin"
   ],

common/src/main/resources/midnightcontrols_compat.mixins.json

@@ -2,7 +2,7 @@
   "required": true,
   "package": "eu.midnightdust.midnightcontrols.client.compat.mixin",
   "plugin": "eu.midnightdust.midnightcontrols.client.compat.MidnightControlsMixinPlugin",
-  "compatibilityLevel": "JAVA_16",
+  "compatibilityLevel": "JAVA_21",
   "client": [
     "sodium.SodiumOptionsGUIAccessor"
   ],

fabric/build.gradle

@@ -92,7 +92,8 @@ unifiedPublishing {
             curseforge {
                 token = CURSEFORGE_TOKEN
                 id = rootProject.curseforge_id
-                gameVersions.addAll "Java 21", project.minecraft_version, project.supported_versions
+                gameVersions.addAll "Java 21", project.minecraft_version
+                if (project.supported_versions != "") gameVersions.addAll project.supported_versions
             }
         }
 
@@ -102,7 +103,8 @@ unifiedPublishing {
                 token = MODRINTH_TOKEN
                 id = rootProject.modrinth_id
                 version = "$project.version-$project.name"
-                gameVersions.addAll project.minecraft_version, project.supported_versions
+                gameVersions.addAll project.minecraft_version
+                if (project.supported_versions != "") gameVersions.addAll project.supported_versions
             }
         }
     }

fabric/src/main/java/eu/midnightdust/midnightcontrols/fabric/MidnightControlsClientFabric.java

@@ -3,6 +3,7 @@ package eu.midnightdust.midnightcontrols.fabric;
 import eu.midnightdust.midnightcontrols.MidnightControlsConstants;
 import eu.midnightdust.midnightcontrols.client.MidnightControlsClient;
 import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
+import eu.midnightdust.midnightcontrols.fabric.event.MouseClickListener;
 import eu.midnightdust.midnightcontrols.packet.ControlsModePayload;
 import eu.midnightdust.midnightcontrols.packet.FeaturePayload;
 import eu.midnightdust.midnightcontrols.packet.HelloPayload;
@@ -11,11 +12,12 @@ import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
 import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
 import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.client.screen.v1.ScreenEvents;
+import net.fabricmc.fabric.api.client.screen.v1.ScreenMouseEvents;
 import net.fabricmc.fabric.api.resource.ResourceManagerHelper;
 import net.fabricmc.fabric.api.resource.ResourcePackActivationType;
 import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.ModContainer;
-import org.thinkingstudio.obsidianui.fabric.event.OpenScreenCallback;
 
 import java.util.Optional;
 
@@ -51,6 +53,9 @@ public class MidnightControlsClientFabric implements ClientModInitializer {
         ClientPlayConnectionEvents.DISCONNECT.register((handler, client) -> MidnightControlsClient.onLeave());
 
         ClientTickEvents.START_CLIENT_TICK.register(MidnightControlsClient::onTick);
+        ScreenEvents.AFTER_INIT.register((client, screen, scaledWidth, scaledHeight) -> {
+            ScreenMouseEvents.allowMouseClick(screen).register(new MouseClickListener(screen));
+        });
 
         FabricLoader.getInstance().getModContainer(MidnightControlsConstants.NAMESPACE).ifPresent(modContainer -> {
             ResourceManagerHelper.registerBuiltinResourcePack(id("bedrock"), modContainer, ResourcePackActivationType.NORMAL);

fabric/src/main/java/eu/midnightdust/midnightcontrols/fabric/event/MouseClickListener.java

@@ -0,0 +1,40 @@
+package eu.midnightdust.midnightcontrols.fabric.event;
+import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
+import net.fabricmc.fabric.api.client.screen.v1.ScreenMouseEvents;
+import net.minecraft.client.gui.screen.Screen;
+
+import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.clickInterceptor;
+
+public class MouseClickListener implements ScreenMouseEvents.AllowMouseClick {
+    private final Screen screen;
+
+    public MouseClickListener(Screen screen) {
+        this.screen = screen;
+    }
+
+    @Override
+    public boolean allowMouseClick(Screen screen, double mouseX, double mouseY, int button) {
+        if(MidnightControlsConfig.virtualKeyboard) {
+            clickInterceptor.intercept(screen, mouseX, mouseY);
+        }
+        return true;
+    }
+
+    // Add equals and hashCode to prevent duplicate registrations
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof MouseClickListener) {
+            return ((MouseClickListener) obj).screen == this.screen;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return screen.hashCode();
+    }
+
+
+
+
+}

fabric/src/main/resources/fabric.mod.json

@@ -54,7 +54,7 @@
     "fabric": ">=0.71.0",
     "minecraft": ">=1.20.5",
     "obsidianui": ">=0.2.5",
-    "java": ">=17"
+    "java": ">=21"
   },
   "suggests": {
     "kontrolo": "*"

gradle.properties

@@ -2,34 +2,34 @@
 org.gradle.parallel=true
 org.gradle.jvmargs=-Xmx2048M
 
-minecraft_version=1.21.3
-supported_versions=1.21.2
-yarn_mappings=1.21.3+build.2
+minecraft_version=1.21.4
+supported_versions=
+yarn_mappings=1.21.4+build.1
 enabled_platforms=fabric,neoforge
 
 archives_base_name=midnightcontrols
-mod_version=1.10.0+1.21.3-alpha.1
+mod_version=1.10.5
 maven_group=eu.midnightdust
-release_type=beta
+release_type=release
 modrinth_id = bXX9h73M
 curseforge_id = 621768
 # Configure the IDs here after creating the projects on the websites
 
-midnightlib_version=1.6.4
+midnightlib_version=1.6.8+1.21.4
 
 fabric_loader_version=0.16.9
-fabric_api_version=0.107.3+1.21.3
+fabric_api_version=0.110.5+1.21.4
 
-neoforge_version=21.3.28-beta
+neoforge_version=21.4.9-beta
 yarn_mappings_patch_neoforge_version = 1.21+build.4
 
 quilt_loader_version=0.19.0-beta.18
 quilt_fabric_api_version=7.0.1+0.83.0-1.20
 
 sodium_version=mc1.21-0.6.0-beta.1
-obsidianui_version=0.2.9+mc1.21.3
+obsidianui_version=0.2.10+mc1.21.3
 modmenu_version=10.0.0-beta.1
-emotecraft_version=2.1.3-SNAPSHOT-build.29-MC1.19-fabric
+emotecraft_version=2.5.5+1.21.4-fabric
 bendylib_version=2.0.+
 emi_version=1.1.10+1.21+fabric
 libgui_version=6.0.0+1.19

neoforge/build.gradle

@@ -104,7 +104,8 @@ unifiedPublishing {
             curseforge {
                 token = CURSEFORGE_TOKEN
                 id = rootProject.curseforge_id
-                gameVersions.addAll "Java 21", project.minecraft_version, project.supported_versions
+                gameVersions.addAll "Java 21", project.minecraft_version
+                if (project.supported_versions != "") gameVersions.addAll project.supported_versions
             }
         }
 
@@ -114,7 +115,8 @@ unifiedPublishing {
                 token = MODRINTH_TOKEN
                 id = rootProject.modrinth_id
                 version = "$project.version-$project.name"
-                gameVersions.addAll project.minecraft_version, project.supported_versions
+                gameVersions.addAll project.minecraft_version
+                if (project.supported_versions != "") gameVersions.addAll project.supported_versions
             }
         }
     }

neoforge/src/main/java/eu/midnightdust/midnightcontrols/client/util/platform/neoforge/NetworkUtilImpl.java

@@ -19,7 +19,12 @@ public class NetworkUtilImpl {
             handler.send(packet);
     }
     public static void sendPayloadC2S(CustomPayload payload) {
-        if (handler != null && client.world != null)
-            handler.send(new CustomPayloadC2SPacket(payload));
+        if (handler != null && client.world != null) {
+            try {
+                handler.send(new CustomPayloadC2SPacket(payload));
+            } catch (Exception e) {
+                e.fillInStackTrace();
+            }
+        }
     }
 }

neoforge/src/main/java/eu/midnightdust/midnightcontrols/neoforge/MidnightControlsClientNeoforge.java

@@ -5,6 +5,7 @@ import eu.midnightdust.midnightcontrols.client.MidnightControlsConfig;
 import eu.midnightdust.midnightcontrols.client.util.platform.NetworkUtil;
 import eu.midnightdust.midnightcontrols.packet.ControlsModePayload;
 import eu.midnightdust.midnightcontrols.packet.HelloPayload;
+import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.resource.DirectoryResourcePack;
 import net.minecraft.resource.ResourcePackInfo;
 import net.minecraft.resource.ResourcePackPosition;
@@ -21,6 +22,7 @@ import net.neoforged.fml.common.Mod;
 import net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent;
 import net.neoforged.neoforge.client.event.ClientTickEvent;
 import net.neoforged.neoforge.client.event.RegisterKeyMappingsEvent;
+import net.neoforged.neoforge.client.event.ScreenEvent;
 import net.neoforged.neoforge.event.AddPackFindersEvent;
 import net.neoforged.neoforgespi.locating.IModFile;
 
@@ -34,6 +36,8 @@ import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.BIN
 import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.BINDING_LOOK_UP;
 import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.BINDING_RING;
 import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.client;
+import static eu.midnightdust.midnightcontrols.client.MidnightControlsClient.clickInterceptor;
+
 
 @Mod(value = NAMESPACE, dist = Dist.CLIENT)
 public class MidnightControlsClientNeoforge {
@@ -90,5 +94,15 @@ public class MidnightControlsClientNeoforge {
         public static void startClientTick(ClientTickEvent.Pre event) {
             MidnightControlsClient.onTick(client);
         }
+        @SubscribeEvent
+        public static void onMouseButtonPressed(ScreenEvent.MouseButtonPressed.Pre event) {
+            if (MidnightControlsConfig.virtualKeyboard && !event.isCanceled()) {
+                Screen screen = event.getScreen();
+                double mouseX = event.getMouseX();
+                double mouseY = event.getMouseY();
+
+                clickInterceptor.intercept(screen, mouseX, mouseY);
+            }
+        }
     }
 }