[Mainline Feature] New GUI Framework

src/main/java/cam72cam/mod/gui_v2/GuiUtils.java

@@ -0,0 +1,84 @@
+package cam72cam.mod.gui_v2;
+
+import cam72cam.mod.MinecraftClient;
+import cam72cam.mod.ModCore;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.control.PositionedPanel;
+import cam72cam.mod.gui_v2.core.ScreenWrapper;
+import cam72cam.mod.text.PlayerMessage;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.event.ClickEvent;
+
+public class GuiUtils {
+    public static int mouseX;
+    public static int mouseY;
+
+    public static int getMouseX() {
+        return mouseX;
+    }
+
+    public static int getMouseY() {
+        return mouseY;
+    }
+
+    public static int getTextWidth(PlayerMessage text) {
+        return getTextWidth(text.internal.getFormattedText());
+    }
+
+    public static int getTextWidth(String text) {
+        return Minecraft.getMinecraft().fontRenderer.getStringWidth(text);
+    }
+
+    public static int getScreenWidth() {
+        return new ScaledResolution(Minecraft.getMinecraft()).getScaledWidth();
+    }
+
+    public static int getScreenHeight() {
+        return new ScaledResolution(Minecraft.getMinecraft()).getScaledHeight();
+    }
+
+    public static boolean isPrintable(char c) {
+        return !Character.isISOControl(c) && Character.isDefined(c);
+    }
+
+    public static boolean insidePositionedPanel(AbstractWidget<?> widget) {
+        AbstractWidget<?> parent = widget;
+        while ((parent = parent.getParent()) != null) {
+            if (parent instanceof PositionedPanel) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** Try to open an external link in player's browser */
+    public void openLink(String url){
+        if (ScreenWrapper.getInstance() != null) {
+            ITextComponent component = new TextComponentString("");
+            component.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, url));
+            ScreenWrapper.getInstance().handleComponentClick(component);
+        } else {
+            ModCore.error("Trying to open a link outside a screen: %s", url);
+            if (MinecraftClient.isReady() && MinecraftClient.getPlayer() != null) {
+                MinecraftClient.getPlayer().sendMessage(PlayerMessage.url(url));
+            }
+        }
+    }
+
+    /** Try to open an external link in player's browser */
+    public static void openFile(String path){
+        if (ScreenWrapper.getInstance() != null) {
+            ITextComponent component = new TextComponentString("");
+            component.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_FILE, path));
+            ScreenWrapper.getInstance().handleComponentClick(component);
+        } else {
+            ModCore.error("Trying to open a file outside a screen: %s", path);
+            if (MinecraftClient.isReady() && MinecraftClient.getPlayer() != null) {
+                MinecraftClient.getPlayer().sendMessage(PlayerMessage.direct("Please check this location on your computer: " + path));
+            }
+        }
+    }
+}

src/main/java/cam72cam/mod/gui_v2/control/AbstractPanel.java

@@ -0,0 +1,249 @@
+package cam72cam.mod.gui_v2.control;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.core.actions.*;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.ScissorStack;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.input.Keyboard;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public abstract class AbstractPanel<T extends AbstractPanel<T>> extends AbstractWidget<T>
+        implements IClickable, IDraggable, IUpdatable, IScrollable, IKeyboardListener {
+    private final List<ILayoutable<?>> children;
+    private final List<ILayoutable<?>> controller;
+
+    private IFocusable active;
+
+    public AbstractPanel(int width, int height) {
+        super();
+        this.setBound(0, 0, width, height);
+        this.children = new ArrayList<>();
+        this.controller = new ArrayList<>();
+
+//        this.setForegroundRenderFunc((gui, panel) -> panel.renderBound(gui, 0xFFFFFFFF));
+    }
+
+    public void addChildren(ILayoutable<?> child) {
+        addChildren(Collections.singleton(child));
+    }
+
+    public void addChildren(ILayoutable<?>... children) {
+        addChildren(Arrays.asList(children));
+    }
+
+    public void addChildren(Iterable<ILayoutable<?>> children) {
+        for (ILayoutable<?> child : children) {
+            if (child == this) {
+                throw new IllegalArgumentException("Cannot add self as child panel!");
+            }
+            this.children.add(child);
+            if (child instanceof AbstractWidget<?>) {
+                ((AbstractWidget<?>) child).parent = this;
+            }
+        }
+        layout(this.x(), this.y());
+    }
+
+    public List<ILayoutable<?>> getChildren() {
+        return children;
+    }
+
+    public List<ILayoutable<?>> getVisibleChildren() {
+        return children.stream().filter(ILayoutable::isVisible).collect(Collectors.toList());
+    }
+
+    public void clearChildren() {
+        this.children.clear();
+    }
+
+    protected void addController(ILayoutable<?> ctrl) {
+        this.controller.add(ctrl);
+        if (ctrl instanceof AbstractWidget<?>) {
+            ((AbstractWidget<?>) ctrl).parent = this;
+        }
+    }
+
+    public void renderPanel(GuiRenderer renderer, ScissorStack stack) {
+        stack.pushPanel(this);
+        this.getVisibleChildren().forEach(child -> {
+            stack.push(child);
+            drawWidget(child, renderer, stack);
+            stack.pop();
+        });
+        stack.pop();
+        stack.push(this);
+        this.controller.forEach(ctrl -> {
+            stack.push(ctrl);
+            drawWidget(ctrl, renderer, stack);
+            stack.pop();
+        });
+        drawWidget(this, renderer, stack);
+        stack.pop();
+    }
+
+    private void drawWidget(ILayoutable<?> widget, GuiRenderer renderer, ScissorStack stack) {
+        if (widget instanceof IUpdatable) {
+            ((IUpdatable) widget).preRender();
+        }
+        if (widget != this && widget instanceof AbstractPanel) {
+            ((AbstractPanel<?>) widget).renderPanel(renderer, stack);
+        } else {
+            widget.renderBackground(renderer, stack);
+            widget.render(renderer, stack);
+            widget.renderForeground(renderer, stack);
+        }
+        if (widget instanceof IUpdatable) {
+            ((IUpdatable) widget).postRender();
+        }
+    }
+
+    public void renderBound(GuiRenderer renderer, int argb) {
+        renderer.drawRect(x(), y(), 1, height(), argb);
+        renderer.drawRect(x(), y(), width()-1, 1, argb);
+        renderer.drawRect(x() + width()-1, y(), 1, height(), argb);
+        renderer.drawRect(x(), y() + height()-1, width(), 1, argb);
+    }
+
+    /* Indicate actual range excluded panel basics like ScrollPane's scroll bar */
+    public int panelX() {
+        return x();
+    }
+    public int panelY() {
+        return y();
+    }
+    public int panelWidth() {
+        return width();
+    }
+    public int panelHeight() {
+        return height();
+    }
+
+    protected boolean isHoveringPanel() {
+        return isHoveringPanel(GuiUtils.getMouseX(), GuiUtils.getMouseY());
+    }
+    protected boolean isHoveringPanel(int mouseX, int mouseY) {
+        boolean flag = true;
+        if (parent != null) {
+            flag = parent.isHovering(mouseX, mouseY);
+        }
+        return flag && mouseX >= this.panelX() && mouseX <= this.panelX() + this.width()
+                    && mouseY >= this.panelY() && mouseY <= this.panelY() + this.height();
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IClickable.class).anyMatch(c -> c.onClick(hand, x, y))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IClickable.class)
+                .anyMatch(c -> c.onClick(hand, x, y));
+    }
+
+    @Override
+    public boolean onDrag(Player.Hand hand, int mouseX, int mouseY) {
+        if (active instanceof IDraggable) {
+            return ((IDraggable) active).onDrag(hand, mouseX, mouseY);
+        }
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IDraggable.class).anyMatch(c -> c.onDrag(hand, mouseX, mouseY))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IDraggable.class)
+                .anyMatch(c -> c.onDrag(hand, mouseX, mouseY));
+    }
+
+    @Override
+    public boolean onRelease(Player.Hand hand, int mouseX, int mouseY) {
+        if (active instanceof IDraggable) {
+            return ((IDraggable) active).onRelease(hand, mouseX, mouseY);
+        }
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IDraggable.class).anyMatch(c -> c.onRelease(hand, mouseX, mouseY))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IDraggable.class)
+                .anyMatch(c -> c.onRelease(hand, mouseX, mouseY));
+    }
+
+    @Override
+    public boolean onScroll(int mouseX, int mouseY, double deltaScroll) {
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IScrollable.class).anyMatch(c -> c.onScroll(mouseX, mouseY, deltaScroll))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IScrollable.class)
+                .anyMatch(c -> c.onScroll(mouseX, mouseY, deltaScroll));
+    }
+
+    @Override
+    public void onTick() {
+        castedStream(controller, IUpdatable.class).forEach(IUpdatable::onTick);
+        castedStream(getVisibleChildren(), IUpdatable.class).forEach(IUpdatable::onTick);
+    }
+
+    @Override
+    public boolean onKeyPressed(Keyboard.KeyCode key) {
+        if (active instanceof IKeyboardListener) {
+            return ((IKeyboardListener) active).onKeyPressed(key);
+        }
+        if (castedStream(controller, IKeyboardListener.class).anyMatch(c -> c.onKeyPressed(key))) {
+            return true;
+        }
+        return castedStream(getVisibleChildren(), IKeyboardListener.class)
+                .anyMatch(c -> c.onKeyPressed(key));
+    }
+
+    @Override
+    public boolean onCharTyped(char ch) {
+        if (active instanceof IKeyboardListener) {
+            if (((IKeyboardListener) active).onCharTyped(ch)) return true;
+        }
+        if (castedStream(controller, IKeyboardListener.class).anyMatch(c -> c.onCharTyped(ch))) {
+            return true;
+        }
+        return castedStream(getVisibleChildren(), IKeyboardListener.class)
+                .anyMatch(c -> c.onCharTyped(ch));
+    }
+
+    @Override
+    protected void requestFocus(IFocusable focusing) {
+        if (this.parent != null) {
+            super.requestFocus(focusing);
+            return;
+        }
+        if (this.active != null) {
+            this.active.onFocusLost();
+        }
+        focusing.onFocusGained();
+        this.active = focusing;
+    }
+    @Override
+    public void freeFocus() {
+        if (this.parent != null) {
+            super.freeFocus();
+            return;
+        }
+        if (this.active != null) {
+            this.active.onFocusLost();
+        }
+        this.active = null;
+    }
+
+    private static <E, I> Stream<I> castedStream(Collection<E> elements, Class<I> interface1) {
+        return elements.stream().filter(interface1::isInstance).map(interface1::cast);
+    }
+}