GUIText.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.gui.textinput;
 
import com.realtime.crossfire.jxclient.gui.gui.ActivatableGUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElementListener;
import com.realtime.crossfire.jxclient.gui.gui.GuiUtils;
import com.realtime.crossfire.jxclient.gui.gui.KeyPressedHandler;
import com.realtime.crossfire.jxclient.gui.gui.TooltipManager;
import com.realtime.crossfire.jxclient.gui.keybindings.KeyEvent2;
import com.realtime.crossfire.jxclient.gui.label.NewCharModel;
import com.realtime.crossfire.jxclient.settings.CommandHistory;
import com.realtime.crossfire.jxclient.skin.skin.GuiFactory;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.font.FontRenderContext;
import java.awt.geom.RectangularShape;
import java.io.IOException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class GUIText extends ActivatableGUIElement implements KeyPressedHandler {
 
    private static final long serialVersionUID = 1;
 
    private static final int SCROLL_CHARS = 8;
 
    @NotNull
    private final CommandCallback commandCallback;
 
    @Nullable
    private final CommandHistory commandHistory;
 
    @NotNull
    private final NewCharModel newCharModel;
 
    @NotNull
    private final Image activeImage;
 
    @NotNull
    private final Image inactiveImage;
 
    @NotNull
    private final Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
 
    @Nullable
    private final Clipboard selection = Toolkit.getDefaultToolkit().getSystemSelection();
 
    @NotNull
    private final Font font;
 
    @NotNull
    private final Color inactiveColor;
 
    @NotNull
    private final Color activeColor;
 
    private final int margin;
 
    @NotNull
    private final StringBuilder text;
 
    private final Dimension preferredSize;
 
    private boolean hideInput;
 
    private int cursor;
 
    private int offset;
 
    @NotNull
    private final Object syncCursor = new Object();
 
    protected GUIText(@NotNull final CommandCallback commandCallback, @Nullable final CommandHistory commandHistory, @NotNull final TooltipManager tooltipManager, @NotNull final GUIElementListener elementListener, @NotNull final String name, @NotNull final NewCharModel newCharModel, @NotNull final Image activeImage, @NotNull final Image inactiveImage, @NotNull final Font font, @NotNull final Color inactiveColor, @NotNull final Color activeColor, final int margin, @NotNull final String text, @NotNull final GuiFactory guiFactory) {
        super(tooltipManager, elementListener, name, false, guiFactory);
        this.commandCallback = commandCallback;
        this.commandHistory = commandHistory;
        this.newCharModel = newCharModel;
        this.activeImage = activeImage;
        this.inactiveImage = inactiveImage;
        this.font = font;
        this.inactiveColor = inactiveColor;
        this.activeColor = activeColor;
        this.margin = margin;
        this.text = new StringBuilder(text);
        preferredSize = new Dimension(activeImage.getWidth(null), activeImage.getHeight(null));
        if (!preferredSize.equals(new Dimension(inactiveImage.getWidth(null), inactiveImage.getHeight(null)))) {
            throw new IllegalArgumentException("active image size differs from inactive image size");
        }
        setCursor(this.text.length());
        if (name.equals("account_character_create")) {
            setChangedListener(this::updateErrorText);
            updateErrorText();
        }
    }
 
    public void setText(@NotNull final String text) {
        this.text.setLength(0);
        this.text.append(text);
        setCursor(this.text.length());
    }
 
    @NotNull
    public String getText() {
        return text.toString();
    }
 
    @Override
    public void paintComponent(@NotNull final Graphics g) {
        super.paintComponent(g);
 
        final Graphics2D g2 = (Graphics2D)g;
        final Image image = isActive() ? activeImage : inactiveImage;
        for (int x = 0; x < getWidth(); x += image.getWidth(null)) {
            g2.drawImage(image, x, 0, null);
        }
        g2.setFont(font);
        final String tmp;
        final int y;
        synchronized (syncCursor) {
            tmp = getDisplayText();
            final FontRenderContext fontRenderContext = g2.getFontRenderContext();
            final RectangularShape rectangle = font.getStringBounds(tmp, fontRenderContext);
            y = (int)Math.round(getHeight()-rectangle.getMaxY()-rectangle.getMinY())/2;
            if (isActive()) {
                final String tmpPrefix = tmp.substring(0, cursor-offset);
                final String tmpCursor = tmp.substring(0, cursor-offset+1);
                final RectangularShape rectanglePrefix = font.getStringBounds(tmpPrefix, fontRenderContext);
                final RectangularShape rectangleCursor = font.getStringBounds(tmpCursor, fontRenderContext);
                final int cursorX1 = (int)Math.round(rectanglePrefix.getWidth());
                final int cursorX2 = (int)Math.round(rectangleCursor.getWidth());
                g2.setColor(inactiveColor);
                g2.fillRect(margin+cursorX1, 0, cursorX2-cursorX1, getHeight());
            }
        }
        g2.setColor(isActive() ? activeColor : inactiveColor);
        g2.drawString(tmp, margin, y);
    }
 
    @NotNull
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getPreferredSize() {
        return new Dimension(preferredSize);
    }
 
    @NotNull
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getMinimumSize() {
        return new Dimension(preferredSize);
    }
 
    @NotNull
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getMaximumSize() {
        return new Dimension(preferredSize);
    }
 
    @NotNull
    private String getDisplayText() {
        final String tmpText = text.substring(offset);
        if (!hideInput) {
            return tmpText+" ";
        }
 
        final String template = "****************************************************************************************************************************************************************";
        final String hiddenText = template.substring(0, Math.min(tmpText.length(), template.length()));
        return hiddenText+" ";
    }
 
    @Override
    public void mouseClicked(@NotNull final MouseEvent e) {
        super.mouseClicked(e);
 
        if (!isEnabled()) {
            return;
        }
 
        final int b = e.getButton();
        switch (b) {
        case MouseEvent.BUTTON1:
            setActive(true);
            setChanged();
            break;
 
        case MouseEvent.BUTTON2:
            break;
 
        case MouseEvent.BUTTON3:
            break;
        }
    }
 
    @Override
    protected void activeChanged() {
        setChanged();
    }
 
    @Override
    public boolean keyPressed(@NotNull final KeyEvent2 e) {
        if (!isEnabled()) {
            return false;
        }
 
        switch (e.getKeyCode()) {
        case KeyEvent.VK_ENTER:
            markInactivePending();
            final String command = text.toString();
            commandCallback.updatePlayerName(command);
            execute(command);
            if (!hideInput && commandHistory != null) {
                commandHistory.addCommand(command);
            }
            setInactiveIfPending();
            return true;
 
        case KeyEvent.VK_BACK_SPACE:
            synchronized (syncCursor) {
                if (cursor > 0) {
                    text.delete(cursor-1, cursor);
                    setCursor(cursor-1);
                }
            }
            return true;
 
        case KeyEvent.VK_DELETE:
            synchronized (syncCursor) {
                if (cursor < text.length()) {
                    text.delete(cursor, cursor+1);
                    setChanged();
                }
            }
            return true;
 
        case KeyEvent.VK_KP_LEFT:
        case KeyEvent.VK_LEFT:
            synchronized (syncCursor) {
                if (cursor > 0) {
                    setCursor(cursor-1);
                }
            }
            return true;
 
        case KeyEvent.VK_KP_RIGHT:
        case KeyEvent.VK_RIGHT:
            synchronized (syncCursor) {
                if (cursor < text.length()) {
                    setCursor(cursor+1);
                }
            }
            return true;
 
        case KeyEvent.VK_KP_UP:
        case KeyEvent.VK_UP:
            if (historyPrev()) {
                return true;
            }
            break;
 
        case KeyEvent.VK_KP_DOWN:
        case KeyEvent.VK_DOWN:
            if (historyNext()) {
                return true;
            }
            break;
 
        case KeyEvent.VK_HOME:
            synchronized (syncCursor) {
                if (cursor > 0) {
                    setCursor(0);
                }
            }
            return true;
 
        case KeyEvent.VK_END:
            synchronized (syncCursor) {
                if (cursor < text.length()) {
                    setCursor(text.length());
                }
            }
            return true;
 
        case KeyEvent.VK_C:              // CTRL-C
            if ((e.getModifiers()&KeyEvent2.MASK) == KeyEvent2.CTRL) {
                copy();
                return true;
            }
            break;
 
        case KeyEvent.VK_N:              // CTRL-N
            if ((e.getModifiers()&KeyEvent2.MASK) == KeyEvent2.CTRL && historyNext()) {
                return true;
            }
            break;
 
        case KeyEvent.VK_P:              // CTRL-P
            if ((e.getModifiers()&KeyEvent2.MASK) == KeyEvent2.CTRL && historyPrev()) {
                return true;
            }
            break;
 
        case KeyEvent.VK_V:              // CTRL-V
            if ((e.getModifiers()&KeyEvent2.MASK) == KeyEvent2.CTRL) {
                paste();
                return true;
            }
            break;
        }
 
        final char ch = e.getKeyChar();
        if (ch != KeyEvent.CHAR_UNDEFINED && ch != (char)127 && ch >= ' ') {
            insertChar(ch);
            return true;
        }
 
        return false;
    }
 
    private boolean historyPrev() {
        if (commandHistory == null) {
            return false;
        }
        final String commandUp = commandHistory.up();
        if (commandUp != null) {
            setText(commandUp);
        }
        return true;
    }
 
    private boolean historyNext() {
        if (commandHistory == null) {
            return false;
        }
        final String commandDown = commandHistory.down();
        setText(commandDown == null ? "" : commandDown);
        return true;
    }
 
    private void insertChar(final char ch) {
        synchronized (syncCursor) {
            text.insert(cursor, ch);
            setCursor(cursor+1);
        }
    }
 
    private void insertString(@NotNull final String str) {
        synchronized (syncCursor) {
            text.insert(cursor, str);
            setCursor(cursor+str.length());
        }
    }
 
    protected abstract void execute(@NotNull final String command);
 
    public void setHideInput(final boolean hideInput) {
        if (this.hideInput != hideInput) {
            this.hideInput = hideInput;
            setChanged();
        }
    }
 
    private void setCursor(final int cursor) {
        synchronized (syncCursor) {
            //noinspection StatementWithEmptyBody
            if (getGraphics() == null) { // XXX: hack
                // ignore
            } else if (this.cursor < cursor) {
                // cursor moved right
 
                while (true) {
                    final String tmp = getDisplayText();
                    final String tmpCursor = tmp.substring(0, cursor-offset+1);
                    //final RectangularShape rectangleCursor = font.getStringBounds(tmpCursor, fontRenderContext);
                    final Dimension dimension = GuiUtils.getTextDimension(tmpCursor, getFontMetrics(font));
                    //final int cursorX = (int)Math.round(rectangleCursor.getWidth());
                    final int cursorX = dimension.width;
                    if (cursorX < getWidth()) {
                        break;
                    }
 
                    if (offset+SCROLL_CHARS > cursor) {
                        offset = cursor;
                        break;
                    }
 
                    offset += SCROLL_CHARS;
                }
            } else if (this.cursor > cursor) {
                // cursor moved left
 
                while (cursor < offset) {
                    if (offset <= SCROLL_CHARS) {
                        offset = 0;
                        break;
                    }
 
                    offset -= SCROLL_CHARS;
                }
            }
 
            this.cursor = cursor;
        }
        setChanged();
    }
 
    private void copy() {
        final Transferable selection = new StringSelection(text.toString());
        if (this.selection != null) {
            this.selection.setContents(selection, null);
        }
        clipboard.setContents(selection, null);
    }
 
    private void paste() {
        Transferable content = null;
        if (selection != null) {
            content = selection.getContents(this);
        }
        if (content == null) {
            content = clipboard.getContents(this);
        }
        if (content == null) {
            return;
        }
 
        final String str;
        try {
            str = (String)content.getTransferData(DataFlavor.stringFlavor);
        } catch (final IOException|UnsupportedFlavorException ignored) {
            return;
        }
        insertString(str);
    }
 
    private void updateErrorText() {
        final String name = text.toString();
        @Nullable final String text;
        if (name.isEmpty()) {
            text = "The character name must not be empty.";
        } else if (name.length() > 255) {
            text = "The character name is too long.";
        } else {
            text = null;
        }
        newCharModel.setErrorText(NewCharModel.PRIORITY_CHARACTER_NAME, text);
    }
 
}