459 lines
13 KiB
Java
459 lines
13 KiB
Java
package it.cavallium.warppi.gui.expression.blocks;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import it.cavallium.warppi.WarpPI;
|
|
import it.cavallium.warppi.device.display.DisplayOutputDevice;
|
|
import it.cavallium.warppi.gui.GraphicalElement;
|
|
import it.cavallium.warppi.gui.expression.Caret;
|
|
import it.cavallium.warppi.gui.expression.CaretState;
|
|
import it.cavallium.warppi.gui.expression.InputContext;
|
|
import it.cavallium.warppi.gui.graphicengine.BinaryFont;
|
|
import it.cavallium.warppi.gui.graphicengine.Renderer;
|
|
import it.cavallium.warppi.math.Function;
|
|
import it.cavallium.warppi.math.MathContext;
|
|
import it.cavallium.warppi.math.parser.MathParser;
|
|
import it.cavallium.warppi.math.parser.features.interfaces.Feature;
|
|
import it.cavallium.warppi.util.Error;
|
|
import it.cavallium.warppi.util.Errors;
|
|
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
|
import it.unimi.dsi.fastutil.objects.ObjectListIterator;
|
|
|
|
public class BlockContainer implements TreeContainer, GraphicalElement {
|
|
|
|
private static boolean initialized = false;
|
|
|
|
private int minWidth;
|
|
private int minHeight;
|
|
private final ObjectArrayList<Block> content;
|
|
private boolean small;
|
|
private int width;
|
|
private int height;
|
|
private int line;
|
|
public final boolean withBorder;
|
|
private boolean autoMinimums;
|
|
private final TreeBlock parent;
|
|
|
|
public BlockContainer() {
|
|
this(null, false, BlockContainer.getDefaultCharWidth(false), BlockContainer.getDefaultCharHeight(false), true);
|
|
autoMinimums = true;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent) {
|
|
this(parent, false, BlockContainer.getDefaultCharWidth(false), BlockContainer.getDefaultCharHeight(false), true);
|
|
autoMinimums = true;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent, final boolean small) {
|
|
this(parent, small, BlockContainer.getDefaultCharWidth(small), BlockContainer.getDefaultCharHeight(small), true);
|
|
autoMinimums = true;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent, final boolean small, final ObjectArrayList<Block> content) {
|
|
this(parent, small, BlockContainer.getDefaultCharWidth(small), BlockContainer.getDefaultCharHeight(small), content, true);
|
|
autoMinimums = true;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent, final boolean small, final boolean withBorder) {
|
|
this(parent, small, BlockContainer.getDefaultCharWidth(small), BlockContainer.getDefaultCharHeight(small), withBorder);
|
|
autoMinimums = true;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent, final boolean small, final int minWidth, final int minHeight, final boolean withBorder) {
|
|
this(parent, small, minWidth, minHeight, new ObjectArrayList<>(), withBorder);
|
|
autoMinimums = false;
|
|
}
|
|
|
|
public BlockContainer(final TreeBlock parent, final boolean small, final int minWidth, final int minHeight, final ObjectArrayList<Block> content, final boolean withBorder) {
|
|
this.parent = parent;
|
|
this.small = small;
|
|
this.minWidth = minWidth;
|
|
this.minHeight = minHeight;
|
|
this.withBorder = withBorder;
|
|
for (final Block b : content) {
|
|
if (b.isSmall() != small) {
|
|
b.setSmall(small);
|
|
}
|
|
}
|
|
this.content = content;
|
|
recomputeDimensions();
|
|
}
|
|
|
|
private BlockContainer(final TreeBlock parent, BlockContainer old, InputContext ic) {
|
|
this.autoMinimums = old.autoMinimums;
|
|
this.content = new ObjectArrayList<>();
|
|
for (Block b : old.content) {
|
|
this.content.add(b.clone(this, ic));
|
|
}
|
|
|
|
this.height = old.height;
|
|
this.line = old.line;
|
|
this.minHeight = old.minHeight;
|
|
this.minWidth = old.minWidth;
|
|
this.parent = parent;
|
|
this.small = old.small;
|
|
this.width = old.width;
|
|
this.withBorder = old.withBorder;
|
|
}
|
|
|
|
public BlockContainer clone(final TreeBlock parent, InputContext ic) {
|
|
return new BlockContainer(parent, this, ic);
|
|
}
|
|
|
|
@Override
|
|
public TreeBlock getParentBlock() {
|
|
return parent;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasParent() {
|
|
return parent != null;
|
|
}
|
|
|
|
public void addBlock(final int position, final Block b) {
|
|
addBlockUnsafe(position, b);
|
|
recomputeDimensions();
|
|
}
|
|
|
|
public void addBlockUnsafe(final int position, final Block b) {
|
|
b.setParent(this);
|
|
if (b.isSmall() != small) {
|
|
b.setSmall(small);
|
|
}
|
|
if (position >= content.size()) {
|
|
content.add(b);
|
|
} else {
|
|
content.add(position, b);
|
|
}
|
|
}
|
|
|
|
public void appendBlock(final Block b) {
|
|
appendBlockUnsafe(b);
|
|
recomputeDimensions();
|
|
}
|
|
|
|
public void appendBlockUnsafe(final Block b) {
|
|
b.setParent(this);
|
|
if (b.isSmall() != small) {
|
|
b.setSmall(small);
|
|
}
|
|
content.add(b);
|
|
}
|
|
|
|
public void removeBlock(final Block b) {
|
|
removeBlockUnsafe(b);
|
|
recomputeDimensions();
|
|
}
|
|
|
|
public void removeBlockUnsafe(final Block b) {
|
|
b.setParent(null);
|
|
content.remove(b);
|
|
}
|
|
|
|
public void removeAt(final int i) {
|
|
content.remove(i).setParent(null);
|
|
recomputeDimensions();
|
|
}
|
|
|
|
public BlockReference<?> getBlockAt(final int i) {
|
|
final Block b = content.get(i);
|
|
return new BlockReference<>(b, i, this);
|
|
}
|
|
|
|
public int getSize() {
|
|
return content.size();
|
|
}
|
|
|
|
public void clear() {
|
|
content.clear();
|
|
recomputeDimensions();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param ge
|
|
* Graphic Engine class.
|
|
* @param r
|
|
* Graphic Renderer class of <b>ge</b>.
|
|
* @param x
|
|
* Position relative to the window.
|
|
* @param y
|
|
* Position relative to the window.
|
|
* @param caret
|
|
* Position of the caret.
|
|
*/
|
|
public void draw(final DisplayOutputDevice ge, final Renderer r, final int x, final int y, final Caret caret) {
|
|
int paddingX = 1;
|
|
|
|
if (caret.getRemaining() == 0) {
|
|
if (content.size() > 0) {
|
|
BlockContainer.drawCaret(ge, r, caret, small, x, y + line - content.get(0).line, content.get(0).height);
|
|
} else {
|
|
BlockContainer.drawCaret(ge, r, caret, small, x, y, height);
|
|
}
|
|
}
|
|
|
|
if (withBorder && content.size() == 0) {
|
|
r.glColor(BlockContainer.getDefaultColor());
|
|
r.glDrawLine(x + paddingX, y, x + paddingX + width - 1, y);
|
|
r.glDrawLine(x + paddingX, y, x + paddingX, y + height - 1);
|
|
r.glDrawLine(x + paddingX + width - 1, y, x + paddingX + width - 1, y + height - 1);
|
|
r.glDrawLine(x + paddingX, y + height - 1, x + paddingX + width - 1, y + height - 1);
|
|
} else {
|
|
for (final Block b : content) {
|
|
caret.skip(1);
|
|
b.draw(ge, r, x + paddingX, y + line - b.line, caret);
|
|
paddingX += b.getWidth();
|
|
if (caret.getRemaining() == 0) {
|
|
BlockContainer.drawCaret(ge, r, caret, small, x + paddingX, y + line - b.line, b.height);
|
|
}
|
|
paddingX += 1;
|
|
}
|
|
}
|
|
caret.skip(1);
|
|
}
|
|
|
|
public boolean putBlock(final Caret caret, final Block newBlock) {
|
|
boolean added = false;
|
|
|
|
if (caret.getRemaining() == 0) {
|
|
addBlock(0, newBlock);
|
|
added = true;
|
|
}
|
|
|
|
int pos = 0;
|
|
for (final Block b : content) {
|
|
caret.skip(1);
|
|
pos++;
|
|
added = added | b.putBlock(caret, newBlock);
|
|
if (caret.getRemaining() == 0) {
|
|
addBlock(pos, newBlock);
|
|
added = true;
|
|
}
|
|
}
|
|
caret.skip(1);
|
|
if (added) {
|
|
recomputeDimensions();
|
|
}
|
|
return added;
|
|
}
|
|
|
|
public boolean delBlock(final Caret caret) {
|
|
boolean removed = false;
|
|
|
|
int pos = 0;
|
|
for (final Block b : content) {
|
|
caret.skip(1);
|
|
pos++;
|
|
final int deltaCaret = caret.getRemaining();
|
|
final int caretOldPos = caret.getPosition();
|
|
removed = removed | b.delBlock(caret);
|
|
if (caret.getRemaining() == 0 || removed == false && deltaCaret >= 0 && caret.getRemaining() < 0) {
|
|
ObjectArrayList<Block> blocks = this.getBlockAt(pos - 1).get().getInnerBlocks();
|
|
ObjectArrayList<BlockContainer> innerContainers = this.getBlockAt(pos - 1).get().getInnerContainers();
|
|
int innerContainersBeforeCaret = 0;
|
|
int currentBlockIndex = 0;
|
|
if (innerContainers != null) {
|
|
for (BlockContainer c : innerContainers) {
|
|
currentBlockIndex += c.computeCaretMaxBound();
|
|
if (currentBlockIndex > deltaCaret) {
|
|
break;
|
|
}
|
|
innerContainersBeforeCaret++;
|
|
}
|
|
}
|
|
// If the caret is at the end of a block with inner containers don't delete anything and enter into that block.
|
|
if (innerContainers == null || (innerContainers.size() - innerContainersBeforeCaret != 0)) {
|
|
removeAt(pos - 1);
|
|
if (blocks != null) {
|
|
ObjectListIterator<Block> blocksIterator = blocks.iterator();
|
|
int blockNum = 0;
|
|
while (blocksIterator.hasNext()) {
|
|
Block block = blocksIterator.next();
|
|
addBlockUnsafe(pos - 1 + blockNum, block);
|
|
blockNum++;
|
|
}
|
|
}
|
|
caret.setPosition(caretOldPos - innerContainersBeforeCaret);
|
|
removed = true;
|
|
}
|
|
}
|
|
}
|
|
caret.skip(1);
|
|
if (removed) {
|
|
recomputeDimensions();
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
public BlockReference<?> getBlock(final Caret caret) {
|
|
BlockReference<?> block = null;
|
|
|
|
int pos = 0;
|
|
for (final Block b : content) {
|
|
caret.skip(1);
|
|
pos++;
|
|
final int deltaCaret = caret.getRemaining();
|
|
|
|
block = b.getBlock(caret);
|
|
if (block != null) {
|
|
return block;
|
|
}
|
|
if (caret.getRemaining() == 0 || deltaCaret >= 0 && caret.getRemaining() < 0) {
|
|
block = getBlockAt(pos - 1);
|
|
return block;
|
|
}
|
|
}
|
|
caret.skip(1);
|
|
return block;
|
|
}
|
|
|
|
@Override
|
|
public void recomputeDimensions() {
|
|
int l = 0; //Line
|
|
int w = 0; //Width
|
|
int h2 = 0; //Height under the line. h = h2 + l
|
|
int h = 0; //Height
|
|
|
|
for (final Block b : content) {
|
|
w += b.getWidth() + 1;
|
|
final int bl = b.getLine();
|
|
final int bh = b.getHeight();
|
|
final int bh2 = bh - bl;
|
|
if (bl > l) {
|
|
l = bl;
|
|
}
|
|
if (bh2 > h2) {
|
|
h2 = bh2;
|
|
}
|
|
}
|
|
|
|
if (content.size() > 0) {
|
|
w -= 1;
|
|
}
|
|
|
|
h = h2 + l;
|
|
|
|
line = l;
|
|
if (w > minWidth) {
|
|
width = w;
|
|
} else {
|
|
width = minWidth;
|
|
}
|
|
if (h > minHeight) {
|
|
height = h;
|
|
} else {
|
|
height = minHeight;
|
|
line = height / 2;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getWidth() {
|
|
return width;
|
|
}
|
|
|
|
@Override
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
@Override
|
|
public int getLine() {
|
|
return line;
|
|
}
|
|
|
|
private static final BinaryFont[] defFonts = new BinaryFont[2];
|
|
private static final int[] defFontSizes = new int[4];
|
|
private static final int defColor = 0xFF000000;
|
|
|
|
public static void initializeFonts(final BinaryFont big, final BinaryFont small) {
|
|
BlockContainer.defFonts[0] = big;
|
|
BlockContainer.defFonts[1] = small;
|
|
BlockContainer.defFontSizes[0] = big.getCharacterWidth();
|
|
BlockContainer.defFontSizes[1] = big.getCharacterHeight();
|
|
BlockContainer.defFontSizes[2] = small.getCharacterWidth();
|
|
BlockContainer.defFontSizes[3] = small.getCharacterHeight();
|
|
BlockContainer.initialized = true;
|
|
}
|
|
|
|
public static boolean isInitialized() {
|
|
return BlockContainer.initialized;
|
|
}
|
|
|
|
public static BinaryFont getDefaultFont(final boolean small) {
|
|
BlockContainer.checkInitialized();
|
|
return BlockContainer.defFonts[small ? 1 : 0];
|
|
}
|
|
|
|
public static int getDefaultColor() {
|
|
return BlockContainer.defColor;
|
|
}
|
|
|
|
public static int getDefaultCharWidth(final boolean b) {
|
|
BlockContainer.checkInitialized();
|
|
return BlockContainer.defFontSizes[b ? 2 : 0];
|
|
}
|
|
|
|
public static int getDefaultCharHeight(final boolean b) {
|
|
BlockContainer.checkInitialized();
|
|
return BlockContainer.defFontSizes[b ? 3 : 1];
|
|
}
|
|
|
|
public static void drawCaret(final DisplayOutputDevice ge, final Renderer r, final Caret caret, final boolean small,
|
|
final int x, final int y, final int height) {
|
|
if (caret.getState() == CaretState.VISIBLE_ON) {
|
|
r.glColor(BlockContainer.getDefaultColor());
|
|
r.glFillColor(x, y, small ? 2 : 3, height);
|
|
caret.setLastLocation(x, y);
|
|
caret.setLastSize(small ? 2 : 3, height);
|
|
}
|
|
}
|
|
|
|
public void setSmall(final boolean small) {
|
|
this.small = small;
|
|
if (autoMinimums) {
|
|
minWidth = BlockContainer.getDefaultCharWidth(small);
|
|
minHeight = BlockContainer.getDefaultCharHeight(small);
|
|
}
|
|
for (final Block b : content) {
|
|
b.setSmall(small);
|
|
}
|
|
recomputeDimensions();
|
|
}
|
|
|
|
public ObjectArrayList<Block> getContent() {
|
|
return content.clone();
|
|
}
|
|
|
|
private static void checkInitialized() {
|
|
if (!BlockContainer.initialized) {
|
|
WarpPI.getPlatform().throwNewExceptionInInitializerError("Please initialize BlockContainer by running the method BlockContainer.initialize(...) first!");
|
|
}
|
|
}
|
|
|
|
public int computeCaretMaxBound() {
|
|
int maxpos = 0;
|
|
for (final Block b : content) {
|
|
maxpos += 1 + b.computeCaretMaxBound();
|
|
}
|
|
return maxpos + 1;
|
|
}
|
|
|
|
public Function toFunction(final MathContext context) throws Error {
|
|
final ObjectArrayList<Block> blocks = getContent();
|
|
final ObjectArrayList<Feature> blockFeatures = new ObjectArrayList<>();
|
|
|
|
for (final Block block : blocks) {
|
|
final Feature blockFeature = block.toFeature(context);
|
|
if (blockFeature == null) {
|
|
throw new Error(Errors.NOT_IMPLEMENTED, "The block " + block.getClass().getSimpleName() + " isn't a known Block");
|
|
}
|
|
blockFeatures.add(blockFeature);
|
|
}
|
|
|
|
final Function result = MathParser.joinFeatures(context, blockFeatures);
|
|
return result;
|
|
}
|
|
|
|
} |