Fix ReactiveComponent

I swear it worked before!

Author: Geolykt

settings.gradle

@@ -9,7 +9,6 @@ pluginManagement {
             name = 'QuiltMC Releases'
             url 'https://maven.quiltmc.org/repository/release/'
         }
-        mavenLocal()
     }
 }
 

src/main/java/de/geolykt/starloader/api/gui/Drawing.java

@@ -153,10 +153,27 @@ public static float drawText(@NotNull String message, float x, float y, @NotNull
         return implementation.drawText(message, x, y, color);
     }
 
+    /**
+     * Fills a rectangle on the main drawing batch (as provided by {@link #getDrawingBatch()})
+     * with a certain color.
+     *
+     * @param x         The X-position to draw on; it is the left corner of the rectangle.
+     * @param y         The Y-position to draw on; it is not known which corner it corresponds to. Caution is advised
+     * @param width     The width of the rectangle.
+     * @param height    The height of the rectangle.
+     * @param camera    The camera to use. It transforms x/y-positions as well as width and height of the drawn rectangle.
+     * @param fillColor The GDX color to fill it with.
+     * @since 1.5.0
+     */
+    public static void fillRect(float x, float y, float width, float height, @NotNull Color fillColor, @NotNull Camera camera) {
+        implementation.fillRect(x, y, width, height, fillColor, camera);
+    }
+
     /**
      * <b>As specified by the APINote, this method has unintended consequences. It does not only operate
      * like a fillRect() method, but also draws a frame around the rectangle. More specifically
      * this frame is assumed to be linked with {@link TextureProvider#getAlternateWindowNinepatch()}.</b>
+     * To fill the contents of a window/screen, use {@link #fillRect(float, float, float, float, Color, Camera)} instead.
      *
      * <p>Fills a rectangle with a given width and height with a specified color. As a
      * friendly reminder, the position 0,0 is the lower left corner and as the
@@ -172,8 +189,7 @@ public static float drawText(@NotNull String message, float x, float y, @NotNull
      *          anything but the Widget. Act carefully for you may not want to call
      *          this method.
      */
-    public static void fillWindow(float x, float y, float width, float height, @NotNull Color color,
-            @NotNull Camera camera) {
+    public static void fillWindow(float x, float y, float width, float height, @NotNull Color color, @NotNull Camera camera) {
         implementation.fillWindow(x, y, width, height, color, camera);
     }
 

src/main/java/de/geolykt/starloader/api/gui/DrawingImpl.java

@@ -115,6 +115,20 @@ public default float drawText(@NotNull String message, float x, float y, @NotNul
         return this.drawText(message, x, y, color.toGalimulatorColor());
     }
 
+    /**
+     * Fills a rectangle on the main drawing batch (as provided by {@link #getMainDrawingBatch()})
+     * with a certain color.
+     *
+     * @param x         The X-position to draw on; it is the left corner of the rectangle.
+     * @param y         The Y-position to draw on; it is not known which corner it corresponds to. Caution is advised
+     * @param width     The width of the rectangle.
+     * @param height    The height of the rectangle.
+     * @param camera    The camera to use. It transforms x/y-positions as well as width and height of the drawn rectangle.
+     * @param fillColor The GDX color to fill it with.
+     * @since 1.5.0
+     */
+    public void fillRect(float x, float y, float width, float height, @NotNull Color fillColor, @NotNull Camera camera);
+
     /**
      * <b>As specified by the APINote, this method has unintended consequences. It does not only operate
      * like a fillRect() method, but also draws a frame around the rectangle. More specifically

src/main/java/de/geolykt/starloader/api/gui/TextureProvider.java

@@ -3,9 +3,22 @@
 import org.jetbrains.annotations.NotNull;
 
 import com.badlogic.gdx.graphics.g2d.NinePatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
 
 public interface TextureProvider {
 
+    /**
+     * Obtains the texture region that is resolved by the given name.
+     * Should there be no texture region by the given name (yet), then the texture
+     * region for flower.png is returned. It will also return that texture region for an
+     * empty name.
+     *
+     * @param name The name of the texture region. Usually the name of a file within the sprites folder.
+     * @return The texture region registered under the name, or the texture region of flower.png
+     */
+    @NotNull
+    public TextureRegion findTextureRegion(@NotNull String name);
+
     /**
      * Obtains the ninepatch responsible for alternative window frames.
      * This ninepatch corresponds to the "window3.png" sprite.
@@ -14,7 +27,8 @@ public interface TextureProvider {
      *
      * @return The alternate window ninepatch
      */
-    public @NotNull NinePatch getAlternateWindowNinepatch();
+    @NotNull
+    public NinePatch getAlternateWindowNinepatch();
 
     /**
      * Obtains the ninepatch responsible for button background of more non-rounded rectangular buttons.
@@ -24,15 +38,17 @@ public interface TextureProvider {
      *
      * @return The box button ninepatch
      */
-    public @NotNull NinePatch getBoxButtonNinePatch();
+    @NotNull
+    public NinePatch getBoxButtonNinePatch();
 
     /**
      * Obtains the ninepatch responsible for button background of most buttons.
      * This ninepatch corresponds to the "button3.png" sprite.
      *
      * @return The button ninepatch
      */
-    public @NotNull NinePatch getRoundedButtonNinePatch();
+    @NotNull
+    public NinePatch getRoundedButtonNinePatch();
 
     /**
      * Obtains the ninepatch responsible for window frames.
@@ -42,5 +58,6 @@ public interface TextureProvider {
      *
      * @return The window ninepatch
      */
-    public @NotNull NinePatch getWindowNinepatch();
+    @NotNull
+    public NinePatch getWindowNinepatch();
 }

src/main/java/de/geolykt/starloader/api/gui/screen/ReactiveComponent.java

@@ -7,9 +7,8 @@
 
 /**
  * Interface that provides reactive behaviour for mouse movements.
- * Should always be implemented alongside {@link ScreenComponent}.
  */
-public interface ReactiveComponent {
+public interface ReactiveComponent extends ScreenComponent {
 
     /**
      * Called when the mouse moves over the component.
@@ -19,11 +18,17 @@ public interface ReactiveComponent {
      * @param componentX The X-position of the component relative to the screen. Use for drawing operations only.
      * @param componentY The Y-position of the component relative to the screen. Use for drawing operations only.
      * @param camera The camera supplied for drawing operations.
+     * @deprecated Not yet implemented
      */
+    @Deprecated(forRemoval = false, since = "1.5.0")
     public void onHover(int screenX, int screenY, int componentX, int componentY, @NotNull Camera camera);
 
     /**
      * Called when the user clicks on the component.
+     * The documentation of screenX, screenY, componentX and componentY is done as intended. The future me should not come to the idea
+     * that the documentation was wrong. However the variable names might be misleading ...
+     *
+     * <p>screenY will be inverted compared to the rendering y's. You might want to do component.getHeight() - screenY to obtain a more usable height.
      *
      * @param screenX The Y-position of the mouse relative to this component. Bound between {@link ScreenComponent#getWidth()} and {@code 0}
      * @param screenY The Y-position of the mouse relative to this component. Bound between {@link ScreenComponent#getHeight()} and {@code 0}

src/main/java/de/geolykt/starloader/api/gui/screen/Screen.java

@@ -16,7 +16,7 @@ public interface Screen extends Iterable<Map.Entry<Vector2, ScreenComponent>> {
 
     /**
      * Adds a child component to this screen.
-     * Note: while this method might look attractive, only the fewest implementations support it.
+     * Note: while this method might look attractive, some implementations may not support it.
      * {@link ScreenBuilder} exposes {@link ScreenBuilder#addComponentProvider(ComponentProvider)},
      * which you may want to use instead.
      *
@@ -26,10 +26,10 @@ public interface Screen extends Iterable<Map.Entry<Vector2, ScreenComponent>> {
 
     /**
      * Checks whether {@link #addChild(ScreenComponent)} is a valid operation in this implementation.
-     * This method is needed as many implementation will create their children by their needs,
+     * This method is needed as some implementation will create their children by their needs,
      * at which point it is hard to implement potential foreign children getting added by external means.
      *
-     * @return Where {@link #addChild(ScreenComponent)} is a valid operation.
+     * @return True when {@link #addChild(ScreenComponent)} is a valid operation, false otherwise
      */
     public boolean canAddChildren();
 

src/main/java/de/geolykt/starloader/api/gui/screen/ScreenBuilder.java

@@ -139,7 +139,7 @@ public void addComponentProvider(@NotNull ComponentProvider provider) {
      * Sets the title of the screen as shown in the screen header.
      * The default color of this title is white.
      * This method is a required operation and otherwise {@link #build()} will fail,
-     * except if {@link #setHeaderEnabled(boolean)} was called if false as a parameter.
+     * except if {@link #setHeaderEnabled(boolean)} was called with false as a parameter.
      *
      * @param title The title of the screen.
      */

src/main/java/de/geolykt/starloader/impl/DrawingManager.java

@@ -14,6 +14,7 @@
 import com.badlogic.gdx.graphics.g2d.BitmapFont;
 import com.badlogic.gdx.graphics.g2d.NinePatch;
 import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.math.Vector3;
 
 import de.geolykt.starloader.api.NullUtils;
@@ -90,11 +91,34 @@ public float drawText(@NotNull String message, float x, float y, @NotNull GalCol
         }
     }
 
+    @Override
+    public void fillRect(float x, float y, float width, float height, @NotNull Color fillColor, @NotNull Camera camera) {
+        SpriteBatch drawBatch = getMainDrawingBatch();
+        boolean beganDrawing = false;
+        if (!drawBatch.isDrawing()) {
+            drawBatch.begin();
+            beganDrawing = true;
+        }
+        TextureRegion region = findTextureRegion("whitesquare.png");
+        drawBatch.setColor(fillColor);
+        drawBatch.setProjectionMatrix(camera.combined);
+        drawBatch.draw(region, x, y, width, height);
+        if (beganDrawing) {
+            drawBatch.end();
+        }
+    }
+
     @Override
     public void fillWindow(float x, float y, float width, float height, @NotNull Color color, @NotNull Camera camera) {
         GalFX.a(x, y, width, height, new GalColor(color), camera);
     }
 
+    @Override
+    @NotNull
+    public TextureRegion findTextureRegion(@NotNull String name) {
+        return NullUtils.requireNotNull(GalFX.b(name));
+    }
+
     @SuppressWarnings("null")
     @Override
     public @NotNull NinePatch getAlternateWindowNinepatch() {

src/main/java/de/geolykt/starloader/impl/gui/SLScreenWidget.java

@@ -20,6 +20,7 @@
 import de.geolykt.starloader.api.gui.screen.ReactiveComponent;
 import de.geolykt.starloader.api.gui.screen.Screen;
 import de.geolykt.starloader.api.gui.screen.ScreenComponent;
+import de.geolykt.starloader.impl.gui.ScreenComponentPositioningMeta.UnmodifableScreenComponentPositoningMetaIterator;
 
 import snoddasmannen.galimulator.GalColor;
 
@@ -32,12 +33,14 @@ public class SLScreenWidget extends SLAbstractWidget implements Screen {
     /**
      * The list of components displayed by the screen instance.
      */
-    protected final @NotNull List<@NotNull ScreenComponent> components;
+    @NotNull
+    protected final List<@NotNull ScreenComponent> components;
 
     /**
      * The colour of the header bar. Usually it is orange, however can be set to a different colour in the constructor.
      */
-    protected final @NotNull GalColor headerColor;
+    @NotNull
+    protected final GalColor headerColor;
 
     /**
      * The value returned by {@link #isHeadless()}.
@@ -47,7 +50,8 @@ public class SLScreenWidget extends SLAbstractWidget implements Screen {
     /**
      * The title of the screen. Set in the constructor.
      */
-    protected final @NotNull String title;
+    @NotNull
+    protected final String title;
 
     /**
      * The width of the screen, set by the constructor.
@@ -59,7 +63,13 @@ public class SLScreenWidget extends SLAbstractWidget implements Screen {
      * A dynamic provider for the width of the screen. This has to be null if {@link #width} is a non -1 value, but
      * cannot be null if {@link #width} has a -1 value.
      */
-    protected final @Nullable IntSupplier widthProvider;
+    @Nullable
+    protected final IntSupplier widthProvider;
+
+    @NotNull
+    private final List<ScreenComponentPositioningMeta> componentPositioningMeta = new ArrayList<>();
+
+    private double lastRenderHeight = Double.NaN;
 
     /**
      * The constructor of this screen instance.
@@ -217,11 +227,7 @@ public boolean isHeadless() {
 
     @Override
     public Iterator<Entry<Vector2, ScreenComponent>> iterator() {
-        @SuppressWarnings("null")
-        @NotNull Iterator<ScreenComponent> components = this.components.iterator();
-        Camera c = getCamera();
-        int height = (c == null ? getHeight() : (int) c.viewportHeight);
-        return new SLScreenWidgetIterator(height, isHeadless(), getInnerWidth(), components, true);
+        return new UnmodifableScreenComponentPositoningMetaIterator(this.componentPositioningMeta);
     }
 
     @Override
@@ -246,31 +252,39 @@ protected final void paintBackground() {
     }
 
     protected void renderSLChildComponents() {
+        @SuppressWarnings("null")
+        @NotNull Iterator<ScreenComponent> hackvar = this.components.iterator();
         Camera c = NullUtils.requireNotNull(getCamera(), "The internal camera may not be null in order for draw operations to succeed.");
-        for (Map.Entry<Vector2, ScreenComponent> component : this) {
-            Vector2 pos = component.getKey();
-            component.getValue().renderAt((int) pos.x, (int) pos.y, c); // TODO originally the render operation had offsets, but not anymore. Explore why this may have been dumb to remove
+        int height = getHeight();
+        Iterator<Map.Entry<Vector2, ScreenComponent>> populator = new SLScreenWidgetPopulator(height, isHeadless(), getInnerWidth(), hackvar, false);
+
+        componentPositioningMeta.clear();
+        lastRenderHeight = height;
+        while (populator.hasNext()) {
+            Map.Entry<Vector2, ScreenComponent> componentEntry = populator.next();
+            Vector2 pos = componentEntry.getKey();
+            ScreenComponent component = componentEntry.getValue();
+            int width = component.renderAt((int) pos.x, (int) pos.y, c); // TODO originally the render operation had offsets, but not anymore. Explore why this may have been dumb to remove. (#getInnerWidth does not make any sense anymore dummy.)
+            componentPositioningMeta.add(new ScreenComponentPositioningMeta(pos, width, component.getHeight(), component));
         }
     }
 
     @Override
     protected void tap(double x, double y, boolean isLongTap) {
-        Camera c = NullUtils.requireNotNull(getCamera(), "Camera may not be null.");
-        for (Map.Entry<Vector2, ScreenComponent> component : this) {
-            // For galimulator, y = 0, x = 0 is the lower left edge, positive numbers go more towards the upper right.
-            // We follow the same principle within our screen API.
-            ScreenComponent comp = component.getValue();
-            if (!(comp instanceof ReactiveComponent)) {
+        Camera c = NullUtils.requireNotNull(getCamera());
+        double actualY = lastRenderHeight - y - 25.0D; // GDX and galimulator are a bit strange, but it makes sense once you get the gist.
+        for (ScreenComponentPositioningMeta posMeta : this.componentPositioningMeta) {
+            if (!(posMeta.component instanceof ReactiveComponent)) {
                 continue;
             }
-            Vector2 pos = component.getKey();
-            if ((x >= pos.x && x <= pos.x + comp.getWidth())
-                    && (y <= pos.y && y >= pos.y - comp.getHeight())) {
-                // FIXME galimulator provides values that I did not expect. Was my initial reverse-engineering wrong?
+            ReactiveComponent component = (ReactiveComponent) posMeta.component;
+            Vector2 pos = posMeta.pos;
+            if ((x >= pos.x && x <= pos.x + posMeta.width)
+                    && (pos.y <= actualY && (pos.y + posMeta.height) >= actualY)) {
                 if (isLongTap) {
-                    ((ReactiveComponent) comp).onLongClick((int) (x - pos.x), (int) (y - pos.y) + comp.getHeight(), (int) pos.x, (int) pos.y, c);
+                    component.onLongClick((int) (x - pos.x), (int) (posMeta.height - (actualY - pos.y)), (int) pos.x, (int) pos.y, c);
                 } else {
-                    ((ReactiveComponent) comp).onClick((int) (x - pos.x), (int) (y - pos.y) + comp.getHeight(), (int) pos.x, (int) pos.y, c);
+                    component.onClick((int) (x - pos.x), (int) (posMeta.height - (actualY - pos.y)), (int) pos.x, (int) pos.y, c);
                 }
             }
         }

…der/impl/gui/SLScreenWidgetIterator.java …er/impl/gui/SLScreenWidgetPopulator.javasrc/main/java/de/geolykt/starloader/impl/gui/SLScreenWidgetIterator.java renamed to src/main/java/de/geolykt/starloader/impl/gui/SLScreenWidgetPopulator.java src/main/java/de/geolykt/starloader/impl/gui/SLScreenWidgetIterator.java renamed to src/main/java/de/geolykt/starloader/impl/gui/SLScreenWidgetPopulator.java

@@ -13,12 +13,15 @@
 import de.geolykt.starloader.api.gui.screen.LineWrappingInfo;
 import de.geolykt.starloader.api.gui.screen.Screen;
 import de.geolykt.starloader.api.gui.screen.ScreenComponent;
+import de.geolykt.starloader.impl.gui.ScreenComponentPositioningMeta.UnmodifableScreenComponentPositoningMetaIterator;
 
 /**
- * Internal class that implements the iterator required by the {@link Screen} interface.
+ * Internal class that fits the components based on their meta.
  * For use with {@link SLScreenWidget}, it iterates based on insertion order.
+ * The iterator required by the {@link Screen} interface is implemented by
+ * the {@link UnmodifableScreenComponentPositoningMetaIterator}.
  */
-final class SLScreenWidgetIterator implements Iterator<Map.Entry<Vector2, ScreenComponent>> {
+final class SLScreenWidgetPopulator implements Iterator<Map.Entry<Vector2, ScreenComponent>> {
 
     private final @NotNull Iterator<ScreenComponent> components;
     private final int maxWidth;
@@ -28,7 +31,7 @@ final class SLScreenWidgetIterator implements Iterator<Map.Entry<Vector2, Screen
     private int x;
     private int y;
 
-    public SLScreenWidgetIterator(int viewportHeight, boolean headless, int innerWidth, @NotNull Iterator<ScreenComponent> components, boolean supportRemove) {
+    public SLScreenWidgetPopulator(int viewportHeight, boolean headless, int innerWidth, @NotNull Iterator<ScreenComponent> components, boolean supportRemove) {
         this.components = components;
         this.y = viewportHeight;
         if (!headless) {