Updates to graphic engines and incognites options
This commit is contained in:
parent
6e17aa4660
commit
72e151b1e4
|
|
@ -1,4 +1,4 @@
|
|||
eclipse.preferences.version=1
|
||||
encoding//src/main/java=UTF-8
|
||||
encoding//src/main/java/org/warp/picalculator/gui/expression/blocks/BlockParenthesis.java=UTF-8
|
||||
encoding//src/main/java/org/warp/picalculator/math/MathematicalSymbols.java=UTF-8
|
||||
encoding/<project>=UTF-8
|
||||
|
|
|
|||
5
pom.xml
5
pom.xml
|
|
@ -34,6 +34,11 @@
|
|||
<artifactId>pi4j-core</artifactId>
|
||||
<version>1.1</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.fusesource.jansi</groupId>
|
||||
<artifactId>jansi</artifactId>
|
||||
<version>1.15</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
<properties>
|
||||
<maven.compiler.source>1.8</maven.compiler.source>
|
||||
|
|
|
|||
|
|
@ -344,6 +344,41 @@ public class Keyboard {
|
|||
Keyboard.keyPressed(Key.NONE);
|
||||
}
|
||||
break;
|
||||
case com.jogamp.newt.event.KeyEvent.VK_UP:
|
||||
case KeyEvent.VK_UP:
|
||||
//UP
|
||||
row = 1;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = true;
|
||||
if (!Keyboard.shift && !Keyboard.alpha) {
|
||||
Keyboard.keyPressed(Key.UP);
|
||||
} else {
|
||||
Keyboard.keyPressed(Key.NONE);
|
||||
}
|
||||
break;
|
||||
case com.jogamp.newt.event.KeyEvent.VK_DOWN:
|
||||
case KeyEvent.VK_DOWN:
|
||||
//DOWN
|
||||
row = 3;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = true;
|
||||
if (!Keyboard.shift && !Keyboard.alpha) {
|
||||
Keyboard.keyPressed(Key.DOWN);
|
||||
} else {
|
||||
Keyboard.keyPressed(Key.NONE);
|
||||
}
|
||||
break;
|
||||
case (short) 12:
|
||||
//DOWN
|
||||
row = 2;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = true;
|
||||
if (!Keyboard.shift && !Keyboard.alpha) {
|
||||
Keyboard.keyPressed(Key.OK);
|
||||
} else {
|
||||
Keyboard.keyPressed(Key.NONE);
|
||||
}
|
||||
break;
|
||||
case com.jogamp.newt.event.KeyEvent.VK_NUMPAD4:
|
||||
case KeyEvent.VK_NUMPAD4:
|
||||
if (!Keyboard.shift && !Keyboard.alpha) {
|
||||
|
|
@ -608,6 +643,30 @@ public class Keyboard {
|
|||
} else {
|
||||
keyPressed(Key.RIGHT);
|
||||
}
|
||||
} else if (row == 1 && col == 4) {
|
||||
if (shift) {
|
||||
keyPressed(Key.NONE);
|
||||
} else if (alpha) {
|
||||
keyPressed(Key.NONE);
|
||||
} else {
|
||||
keyPressed(Key.UP);
|
||||
}
|
||||
} else if (row == 2 && col == 4) {
|
||||
if (shift) {
|
||||
keyPressed(Key.NONE);
|
||||
} else if (alpha) {
|
||||
keyPressed(Key.NONE);
|
||||
} else {
|
||||
keyPressed(Key.OK);
|
||||
}
|
||||
} else if (row == 3 && col == 4) {
|
||||
if (shift) {
|
||||
keyPressed(Key.NONE);
|
||||
} else if (alpha) {
|
||||
keyPressed(Key.NONE);
|
||||
} else {
|
||||
keyPressed(Key.DOWN);
|
||||
}
|
||||
} else if (row == 3 && col == 4) {
|
||||
if (shift) {
|
||||
keyPressed(Key.NONE);
|
||||
|
|
|
|||
8
src/main/java/org/warp/picalculator/device/KeyboardEventListener.java
Executable file → Normal file
8
src/main/java/org/warp/picalculator/device/KeyboardEventListener.java
Executable file → Normal file
|
|
@ -3,11 +3,7 @@ package org.warp.picalculator.device;
|
|||
import org.warp.picalculator.device.Keyboard.Key;
|
||||
|
||||
public interface KeyboardEventListener {
|
||||
public default boolean keyPressed(Key k) {
|
||||
return false;
|
||||
}
|
||||
public abstract boolean keyPressed(Key k);
|
||||
|
||||
public default boolean keyReleased(Key k) {
|
||||
return false;
|
||||
}
|
||||
public abstract boolean keyReleased(Key k);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,8 @@ import org.warp.picalculator.gui.graphicengine.RenderingLoop;
|
|||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
import org.warp.picalculator.gui.graphicengine.cpu.CPUEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.gpu.GPUEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.headless.HeadlessEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.headless256.Headless8Engine;
|
||||
import org.warp.picalculator.gui.graphicengine.headless8.Headless256Engine;
|
||||
import org.warp.picalculator.gui.graphicengine.BinaryFont;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
import org.warp.picalculator.gui.screens.Screen;
|
||||
|
|
@ -84,9 +85,14 @@ public final class DisplayManager implements RenderingLoop {
|
|||
Utils.debug.println("Using CPU Graphic Engine");
|
||||
return d;
|
||||
}
|
||||
d = new HeadlessEngine();
|
||||
d = new Headless256Engine();
|
||||
if (d.isSupported()) {
|
||||
System.err.println("Using Headless Engine! This is a problem! No other graphic engines are available.");
|
||||
System.err.println("Using Headless 256 Engine! This is a problem! No other graphic engines are available.");
|
||||
return d;
|
||||
}
|
||||
d = new Headless8Engine();
|
||||
if (d.isSupported()) {
|
||||
System.err.println("Using Headless basic Engine! This is a problem! No other graphic engines are available.");
|
||||
return d;
|
||||
}
|
||||
throw new UnsupportedOperationException("No graphic engines available.");
|
||||
|
|
|
|||
|
|
@ -5,13 +5,21 @@ public class Caret {
|
|||
private int pos;
|
||||
private int remaining;
|
||||
private CaretState state;
|
||||
private int[] lastSize;
|
||||
private int[] lastLocation;
|
||||
|
||||
public Caret(CaretState state, int pos) {
|
||||
this(state, pos, new int[]{0, 0}, new int[]{2, 5});
|
||||
}
|
||||
|
||||
public Caret(CaretState state, int pos, int[] lastLocation, int[] lastSize) {
|
||||
this.state = state;
|
||||
this.pos = pos;
|
||||
remaining = pos;
|
||||
this.lastLocation = lastLocation;
|
||||
this.lastSize = lastSize;
|
||||
}
|
||||
|
||||
|
||||
public void skip(int i) {
|
||||
remaining -= i;
|
||||
}
|
||||
|
|
@ -49,4 +57,23 @@ public class Caret {
|
|||
public void resetRemaining() {
|
||||
remaining = pos;
|
||||
}
|
||||
|
||||
public void setLastLocation(int x, int y) {
|
||||
lastLocation[0]=x;
|
||||
lastLocation[1]=y;
|
||||
}
|
||||
|
||||
public int[] getLastLocation() {
|
||||
return new int[]{lastLocation[0],lastLocation[1]};
|
||||
}
|
||||
|
||||
public void setLastSize(int w, int h) {
|
||||
lastSize[0]=w;
|
||||
lastSize[1]=h;
|
||||
}
|
||||
|
||||
public int[] getLastSize() {
|
||||
return new int[]{lastSize[0],lastSize[1]};
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,41 @@
|
|||
package org.warp.picalculator.gui.expression;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
import org.warp.picalculator.device.KeyboardEventListener;
|
||||
import org.warp.picalculator.gui.GraphicalElement;
|
||||
import org.warp.picalculator.gui.expression.blocks.Block;
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
|
||||
public abstract class ExtraMenu<T extends Block> implements Serializable, KeyboardEventListener {
|
||||
|
||||
private static final long serialVersionUID = -6944683477814944299L;
|
||||
|
||||
public ExtraMenu(T block) {
|
||||
this.block = block;
|
||||
this.location = new int[]{0,0};
|
||||
this.width = 0;
|
||||
this.height = 0;
|
||||
}
|
||||
|
||||
public final T block;
|
||||
protected int width;
|
||||
protected int height;
|
||||
protected int[] location;
|
||||
|
||||
public abstract void draw(GraphicEngine ge, Renderer r, Caret caret);
|
||||
|
||||
public abstract void open();
|
||||
|
||||
public abstract void close();
|
||||
|
||||
public boolean beforeRender(float delta, Caret caret) {
|
||||
int[] l = caret.getLastLocation();
|
||||
int[] cs = caret.getLastSize();
|
||||
location[0]=l[0]-block.getWidth()/2-width/2;
|
||||
location[1]=l[1]+cs[1];
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -2,6 +2,7 @@ package org.warp.picalculator.gui.expression.blocks;
|
|||
|
||||
import org.warp.picalculator.gui.GraphicalElement;
|
||||
import org.warp.picalculator.gui.expression.Caret;
|
||||
import org.warp.picalculator.gui.expression.ExtraMenu;
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
|
||||
|
|
@ -28,6 +29,8 @@ public abstract class Block implements GraphicalElement {
|
|||
|
||||
public abstract boolean delBlock(Caret caret);
|
||||
|
||||
public abstract Block getBlock(Caret caret);
|
||||
|
||||
@Override
|
||||
public abstract void recomputeDimensions();
|
||||
|
||||
|
|
@ -55,4 +58,8 @@ public abstract class Block implements GraphicalElement {
|
|||
public abstract void setSmall(boolean small);
|
||||
|
||||
public abstract int getClassID();
|
||||
|
||||
public ExtraMenu getExtraMenu() {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,11 @@ public class BlockChar extends Block {
|
|||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
width = BlockContainer.getDefaultCharWidth(small);
|
||||
|
|
|
|||
|
|
@ -125,6 +125,7 @@ public class BlockContainer implements GraphicalElement {
|
|||
}
|
||||
|
||||
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);
|
||||
|
|
@ -190,6 +191,28 @@ public class BlockContainer implements GraphicalElement {
|
|||
return removed;
|
||||
}
|
||||
|
||||
public Block getBlock(Caret caret) {
|
||||
boolean found = false;
|
||||
Block block = null;
|
||||
|
||||
int pos = 0;
|
||||
for (final Block b : content) {
|
||||
caret.skip(1);
|
||||
pos++;
|
||||
final int deltaCaret = caret.getRemaining();
|
||||
|
||||
block= b.getBlock(caret);
|
||||
found = found | (block != null);
|
||||
if (caret.getRemaining() == 0 || (found == false && deltaCaret >= 0 && caret.getRemaining() < 0)) {
|
||||
block = getBlockAt(pos - 1);
|
||||
found = true;
|
||||
return block;
|
||||
}
|
||||
}
|
||||
caret.skip(1);
|
||||
return block;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
int l = 0; //Line
|
||||
|
|
@ -282,6 +305,8 @@ public class BlockContainer implements GraphicalElement {
|
|||
if (caret.getState() == CaretState.VISIBLE_ON) {
|
||||
r.glColor(getDefaultColor());
|
||||
r.glFillColor(x, y, small?2:3, height);
|
||||
caret.setLastLocation(x, y);
|
||||
caret.setLastSize(small?2:3, height);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ public class BlockDivision extends Block {
|
|||
BlockContainer.getDefaultFont(small).use(ge);
|
||||
r.glColor(BlockContainer.getDefaultColor());
|
||||
containerUp.draw(ge, r, x + 1 + paddingLeftUpper, y, caret);
|
||||
r.glColor(BlockContainer.getDefaultColor());
|
||||
r.glDrawLine(x, y + h1 + 1, x + width - 1, y + h1 + 1);
|
||||
containerDown.draw(ge, r, x + 1 + paddingLeftLower, y + h1 + 3, caret);
|
||||
}
|
||||
|
|
@ -52,6 +53,17 @@ public class BlockDivision extends Block {
|
|||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
Block bl = null;
|
||||
bl = containerUp.getBlock(caret);
|
||||
if (bl != null) {
|
||||
return bl;
|
||||
}
|
||||
bl = containerDown.getBlock(caret);
|
||||
return bl;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
final int w1 = containerUp.getWidth();
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@ import org.warp.picalculator.gui.graphicengine.Renderer;
|
|||
public class BlockExponentialNotation extends BlockPower {
|
||||
private int bw;
|
||||
private int bh;
|
||||
|
||||
public static final int CLASS_ID = 0x00000006;
|
||||
|
||||
@Override
|
||||
public void draw(GraphicEngine ge, Renderer r, int x, int y, Caret caret) {
|
||||
|
|
@ -23,4 +25,9 @@ public class BlockExponentialNotation extends BlockPower {
|
|||
bh = BlockContainer.getDefaultCharHeight(small);
|
||||
this.width+=bw;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getClassID() {
|
||||
return CLASS_ID;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,6 +52,11 @@ public class BlockParenthesis extends Block {
|
|||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
return containerNumber.getBlock(caret);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
chw = BlockContainer.getDefaultCharWidth(small);
|
||||
|
|
|
|||
|
|
@ -43,6 +43,11 @@ public class BlockPower extends Block {
|
|||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
return containerExponent.getBlock(caret);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
|
|
|
|||
|
|
@ -51,6 +51,11 @@ public class BlockSquareRoot extends Block {
|
|||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
return containerNumber.getBlock(caret);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,190 @@
|
|||
package org.warp.picalculator.gui.expression.blocks;
|
||||
|
||||
import org.warp.picalculator.device.Keyboard.Key;
|
||||
import org.warp.picalculator.gui.DisplayManager;
|
||||
import org.warp.picalculator.gui.expression.Caret;
|
||||
import org.warp.picalculator.gui.expression.ExtraMenu;
|
||||
import org.warp.picalculator.gui.graphicengine.BinaryFont;
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
import org.warp.picalculator.math.functions.Variable;
|
||||
import org.warp.picalculator.math.functions.Variable.V_TYPE;
|
||||
|
||||
public class BlockVariable extends Block {
|
||||
|
||||
public static final int CLASS_ID = 0x00000007;
|
||||
|
||||
private final char ch;
|
||||
private final VariableMenu menu;
|
||||
private V_TYPE type;
|
||||
private int color;
|
||||
|
||||
public BlockVariable(char ch) {
|
||||
this.ch = ch;
|
||||
this.menu = new VariableMenu(this);
|
||||
this.type = V_TYPE.UNKNOWN;
|
||||
this.color = 0xFF304ffe;
|
||||
recomputeDimensions();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void draw(GraphicEngine ge, Renderer r, int x, int y, Caret caret) {
|
||||
BlockContainer.getDefaultFont(small).use(ge);
|
||||
r.glColor(color);
|
||||
r.glDrawCharLeft(x, y, ch);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean putBlock(Caret caret, Block newBlock) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean delBlock(Caret caret) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(Caret caret) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void recomputeDimensions() {
|
||||
width = BlockContainer.getDefaultCharWidth(small);
|
||||
height = BlockContainer.getDefaultCharHeight(small);
|
||||
line = height / 2;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSmall(boolean small) {
|
||||
this.small = small;
|
||||
recomputeDimensions();
|
||||
}
|
||||
|
||||
public char getChar() {
|
||||
return ch;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getClassID() {
|
||||
return CLASS_ID;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int computeCaretMaxBound() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ExtraMenu<?> getExtraMenu() {
|
||||
return menu;
|
||||
}
|
||||
|
||||
public class VariableMenu extends ExtraMenu<BlockVariable> {
|
||||
|
||||
boolean mustRefresh = true;
|
||||
String text = "";
|
||||
private int color;
|
||||
|
||||
public VariableMenu(BlockVariable var) {
|
||||
super(var);
|
||||
}
|
||||
|
||||
private static final long serialVersionUID = 3941994107852212764L;
|
||||
|
||||
@Override
|
||||
public void open() {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean keyPressed(Key k) {
|
||||
switch (k) {
|
||||
case LEFT:
|
||||
case UP:
|
||||
switch (block.type) {
|
||||
case UNKNOWN:
|
||||
block.type = V_TYPE.SOLUTION;
|
||||
break;
|
||||
case COEFFICIENT:
|
||||
block.type = V_TYPE.UNKNOWN;
|
||||
break;
|
||||
case SOLUTION:
|
||||
default:
|
||||
block.type = V_TYPE.COEFFICIENT;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case RIGHT:
|
||||
case DOWN:
|
||||
case EQUAL:
|
||||
case SIMPLIFY:
|
||||
switch (block.type) {
|
||||
case UNKNOWN:
|
||||
block.type = V_TYPE.COEFFICIENT;
|
||||
break;
|
||||
case COEFFICIENT:
|
||||
block.type = V_TYPE.SOLUTION;
|
||||
break;
|
||||
case SOLUTION:
|
||||
default:
|
||||
block.type = V_TYPE.UNKNOWN;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean keyReleased(Key k) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean beforeRender(float delta, Caret caret) {
|
||||
if (super.beforeRender(delta, caret)||mustRefresh) {
|
||||
mustRefresh = false;
|
||||
switch (block.type) {
|
||||
case UNKNOWN:
|
||||
color = 0xFF304ffe;
|
||||
break;
|
||||
case COEFFICIENT:
|
||||
color = 0xFFf50057;
|
||||
break;
|
||||
case SOLUTION:
|
||||
default:
|
||||
color = 0xFF64dd17;
|
||||
break;
|
||||
}
|
||||
block.color = color;
|
||||
text = block.type.toString();
|
||||
BinaryFont f = BlockContainer.getDefaultFont(true);
|
||||
width = 2+f.getStringWidth(text)+2;
|
||||
height = 2+f.getCharacterHeight()+2;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void draw(GraphicEngine ge, Renderer r, Caret caret) {
|
||||
BlockContainer.getDefaultFont(true).use(ge);
|
||||
r.glColor3f(1.0f, 1.0f, 1.0f);
|
||||
r.glFillColor(location[0], location[1], width, height);
|
||||
r.glColor(color);
|
||||
r.glDrawStringCenter(location[0]+width/2, location[1]+2, text);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -3,9 +3,11 @@ package org.warp.picalculator.gui.expression.containers;
|
|||
import java.io.ObjectOutputStream;
|
||||
import java.io.Serializable;
|
||||
|
||||
import org.warp.picalculator.device.KeyboardEventListener;
|
||||
import org.warp.picalculator.gui.GraphicalElement;
|
||||
import org.warp.picalculator.gui.expression.Caret;
|
||||
import org.warp.picalculator.gui.expression.CaretState;
|
||||
import org.warp.picalculator.gui.expression.ExtraMenu;
|
||||
import org.warp.picalculator.gui.expression.blocks.Block;
|
||||
import org.warp.picalculator.gui.expression.blocks.BlockContainer;
|
||||
import org.warp.picalculator.gui.expression.layouts.InputLayout;
|
||||
|
|
@ -23,6 +25,7 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
private float caretTime;
|
||||
private int maxPosition = 0;
|
||||
private boolean parsed = false;
|
||||
private ExtraMenu<?> extra;
|
||||
|
||||
public InputContainer() {
|
||||
caret = new Caret(CaretState.VISIBLE_ON, 0);
|
||||
|
|
@ -51,12 +54,13 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
}
|
||||
caretTime = 0;
|
||||
caret.turnOn();
|
||||
closeExtra();
|
||||
}
|
||||
|
||||
public void typeChar(String c) {
|
||||
typeChar(c.charAt(0));
|
||||
}
|
||||
|
||||
|
||||
public void del() {
|
||||
caret.resetRemaining();
|
||||
if (root.delBlock(caret)) {
|
||||
|
|
@ -68,6 +72,13 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
}
|
||||
caret.turnOn();
|
||||
caretTime = 0;
|
||||
closeExtra();
|
||||
}
|
||||
|
||||
|
||||
public Block getSelectedBlock() {
|
||||
caret.resetRemaining();
|
||||
return root.getBlock(caret);
|
||||
}
|
||||
|
||||
public void moveLeft() {
|
||||
|
|
@ -79,6 +90,7 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
}
|
||||
caret.turnOn();
|
||||
caretTime = 0;
|
||||
closeExtra();
|
||||
}
|
||||
|
||||
public void moveRight() {
|
||||
|
|
@ -90,6 +102,7 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
}
|
||||
caret.turnOn();
|
||||
caretTime = 0;
|
||||
closeExtra();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -128,6 +141,10 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
somethingChanged = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (extra != null) {
|
||||
somethingChanged = somethingChanged|extra.beforeRender(delta, caret);
|
||||
}
|
||||
|
||||
return somethingChanged;
|
||||
}
|
||||
|
|
@ -146,6 +163,9 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
public void draw(GraphicEngine ge, Renderer r, int x, int y) {
|
||||
caret.resetRemaining();
|
||||
root.draw(ge, r, x, y, caret);
|
||||
if (extra != null) {
|
||||
extra.draw(ge, r, caret);
|
||||
}
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
|
|
@ -169,6 +189,7 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
}
|
||||
caret.turnOn();
|
||||
caretTime = 0;
|
||||
closeExtra();
|
||||
}
|
||||
|
||||
public void setParsed(boolean parsed) {
|
||||
|
|
@ -187,4 +208,33 @@ public abstract class InputContainer implements GraphicalElement, InputLayout, S
|
|||
public ObjectArrayList<Block> getContent() {
|
||||
return root.getContent();
|
||||
}
|
||||
|
||||
public void toggleExtra() {
|
||||
if (extra == null) {
|
||||
Block selectedBlock = getSelectedBlock();
|
||||
if (selectedBlock != null) {
|
||||
extra = selectedBlock.getExtraMenu();
|
||||
extra.open();
|
||||
}
|
||||
} else {
|
||||
extra.close();
|
||||
extra = null;
|
||||
}
|
||||
}
|
||||
|
||||
public void closeExtra() {
|
||||
if (extra != null) {
|
||||
extra.close();
|
||||
extra = null;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isExtraOpened() {
|
||||
return extra != null;
|
||||
}
|
||||
|
||||
public KeyboardEventListener getExtraKeyboardEventListener() {
|
||||
return extra;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ import org.warp.picalculator.gui.expression.blocks.BlockDivision;
|
|||
import org.warp.picalculator.gui.expression.blocks.BlockParenthesis;
|
||||
import org.warp.picalculator.gui.expression.blocks.BlockPower;
|
||||
import org.warp.picalculator.gui.expression.blocks.BlockSquareRoot;
|
||||
import org.warp.picalculator.gui.expression.blocks.BlockVariable;
|
||||
import org.warp.picalculator.math.MathematicalSymbols;
|
||||
|
||||
public class NormalInputContainer extends InputContainer {
|
||||
|
|
@ -52,6 +53,11 @@ public class NormalInputContainer extends InputContainer {
|
|||
case '9':
|
||||
return new BlockChar(c);
|
||||
default:
|
||||
for (char v : MathematicalSymbols.variables) {
|
||||
if (c == v) {
|
||||
return new BlockVariable(c);
|
||||
}
|
||||
}
|
||||
return new BlockChar(c);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -471,7 +471,6 @@ public class CPUEngine implements GraphicEngine {
|
|||
|
||||
@Override
|
||||
public boolean isSupported() {
|
||||
if (true) return false;
|
||||
return GraphicsEnvironment.isHeadless() == false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -125,7 +125,6 @@ public class GPUEngine implements org.warp.picalculator.gui.graphicengine.Graphi
|
|||
|
||||
@Override
|
||||
public boolean isSupported() {
|
||||
if (true) return false;
|
||||
boolean available = false;
|
||||
boolean errored = false;
|
||||
try {
|
||||
|
|
|
|||
|
|
@ -242,11 +242,31 @@ class NEWTWindow implements GLEventListener {
|
|||
row = 2;
|
||||
col = 3;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = false;
|
||||
break;
|
||||
case KeyEvent.VK_RIGHT:
|
||||
//RIGHT
|
||||
row = 2;
|
||||
col = 5;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = false;
|
||||
break;
|
||||
case KeyEvent.VK_UP:
|
||||
//UP
|
||||
row = 1;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = false;
|
||||
break;
|
||||
case KeyEvent.VK_DOWN:
|
||||
//Down
|
||||
row = 3;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = false;
|
||||
break;
|
||||
case (short) 12:
|
||||
//Down
|
||||
row = 2;
|
||||
col = 4;
|
||||
Keyboard.debugKeysDown[row - 1][col - 1] = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,115 +0,0 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
import org.warp.picalculator.gui.graphicengine.RenderingLoop;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
|
||||
public class HeadlessEngine implements org.warp.picalculator.gui.graphicengine.GraphicEngine {
|
||||
|
||||
private HeadlessRenderer r = new HeadlessRenderer();
|
||||
private boolean stopped;
|
||||
|
||||
@Override
|
||||
public int[] getSize() {
|
||||
return new int[]{480, 320};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isInitialized() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTitle(String title) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setResizable(boolean r) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDisplayMode(int ww, int wh) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void create() {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean wasResized() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getWidth() {
|
||||
return 480;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getHeight() {
|
||||
return 320;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void destroy() {
|
||||
stopped = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void start(RenderingLoop d) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void repaint() {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public Renderer getRenderer() {
|
||||
return r;
|
||||
}
|
||||
|
||||
@Override
|
||||
public HeadlessFont loadFont(String file) throws IOException {
|
||||
return new HeadlessFont();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HeadlessSkin loadSkin(String file) throws IOException {
|
||||
return new HeadlessSkin();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void waitUntilExit() {
|
||||
try {
|
||||
do {
|
||||
Thread.sleep(500);
|
||||
} while (stopped==false);
|
||||
} catch (final InterruptedException e) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSupported() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean doesRefreshPauses() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
|
||||
public class HeadlessRenderer implements Renderer {
|
||||
|
||||
HeadlessFont currentFont;
|
||||
|
||||
@Override
|
||||
public void glColor3i(int r, int gg, int b) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor(int c) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4i(int red, int green, int blue, int alpha) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor3f(float red, float green, float blue) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4f(float red, float green, float blue, float alpha) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4i(int red, int green, int blue, int alpha) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4f(float red, float green, float blue, float alpha) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public int glGetClearColor() {
|
||||
// TODO Auto-generated method stub
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor(int c) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClear(int screenWidth, int screenHeight) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawLine(float x0, float y0, float x1, float y1) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillRect(float x, float y, float width, float height, float uvX, float uvY, float uvWidth,
|
||||
float uvHeight) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillColor(float x, float y, float width, float height) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharLeft(int x, int y, char ch) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharCenter(int x, int y, char ch) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharRight(int x, int y, char ch) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringLeft(float x, float y, String text) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringCenter(float x, float y, String text) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringRight(float x, float y, String text) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearSkin() {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public HeadlessFont getCurrentFont() {
|
||||
return currentFont;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
|
||||
public class HeadlessSkin implements Skin {
|
||||
|
||||
@Override
|
||||
public void load(String file) throws IOException {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize(GraphicEngine d) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void use(GraphicEngine d) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless256;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.logging.ConsoleHandler;
|
||||
|
||||
import org.fusesource.jansi.AnsiConsole;
|
||||
import org.warp.picalculator.Main;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
import org.warp.picalculator.gui.graphicengine.RenderingLoop;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
|
||||
public class Headless8Engine implements org.warp.picalculator.gui.graphicengine.GraphicEngine {
|
||||
|
||||
private Headless8Renderer r = new Headless8Renderer();
|
||||
private boolean stopped = true;
|
||||
private RenderingLoop renderLoop;
|
||||
protected static final int C_WIDTH = Main.screenSize[0]/2;//;60;
|
||||
protected static final int C_HEIGHT = Main.screenSize[1]/3;//;40;
|
||||
public static final int C_MUL_X = 2;//8;
|
||||
public static final int C_MUL_Y = 3;//8;
|
||||
private String title = Main.calculatorName;
|
||||
|
||||
@Override
|
||||
public int[] getSize() {
|
||||
ConsoleHandler ch = new ConsoleHandler();
|
||||
return new int[]{C_WIDTH, C_HEIGHT};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isInitialized() {
|
||||
return !stopped;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTitle(String title) {
|
||||
this.title = title;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setResizable(boolean r) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDisplayMode(int ww, int wh) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void create() {
|
||||
AnsiConsole.systemInstall();
|
||||
AnsiConsole.out.print(Headless8Renderer.ANSI_PREFIX+"?25l");
|
||||
stopped = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean wasResized() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getWidth() {
|
||||
return C_WIDTH*C_MUL_X;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getHeight() {
|
||||
return C_HEIGHT*C_MUL_Y;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void destroy() {
|
||||
stopped = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void start(RenderingLoop d) {
|
||||
this.renderLoop = d;
|
||||
final Thread th = new Thread(() -> {
|
||||
try {
|
||||
double extratime = 0;
|
||||
while (!stopped) {
|
||||
final long start = System.currentTimeMillis();
|
||||
repaint();
|
||||
final long end = System.currentTimeMillis();
|
||||
final double delta = (end - start) / 1000d;
|
||||
final int deltaInt = (int) Math.floor(delta);
|
||||
final int extraTimeInt = (int) Math.floor(extratime);
|
||||
if (extraTimeInt + deltaInt < 200) {
|
||||
Thread.sleep(200 - (extraTimeInt + deltaInt));
|
||||
extratime = 0;
|
||||
} else {
|
||||
extratime += delta - 200d;
|
||||
}
|
||||
}
|
||||
} catch (final InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
th.setName("Console rendering thread");
|
||||
th.setDaemon(true);
|
||||
th.start();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void repaint() {
|
||||
renderLoop.refresh();
|
||||
r.curColor = 0x1C;
|
||||
r.glDrawStringCenter((C_WIDTH*C_MUL_X)/2, 0, title);
|
||||
AnsiConsole.out.print(Headless8Renderer.ANSI_PREFIX+"1;1H");
|
||||
for (int y = 0; y < C_HEIGHT; y++) {
|
||||
int precBgColor = -1;
|
||||
int precFgColor = -1;
|
||||
int curBgColor = -1;
|
||||
int curFgColor = -1;
|
||||
for (int x = 0; x < C_WIDTH; x++) {
|
||||
curBgColor = (r.colorMatrix[x+y*C_WIDTH]&0xF0)>>4;
|
||||
curFgColor = r.colorMatrix[x+y*C_WIDTH]&0x0F;
|
||||
if (precBgColor != curBgColor) {
|
||||
AnsiConsole.out.print(Headless8Renderer.ANSI_PREFIX+Headless8Renderer.ansiBgColorPrefix+Headless8Renderer.colorANSI[curBgColor]+Headless8Renderer.ansiColorSuffix);
|
||||
}
|
||||
if (precFgColor != curFgColor) {
|
||||
AnsiConsole.out.print(Headless8Renderer.ANSI_PREFIX+Headless8Renderer.ansiFgColorPrefix+Headless8Renderer.colorANSI[curFgColor]+Headless8Renderer.ansiColorSuffix);
|
||||
}
|
||||
|
||||
AnsiConsole.out.print(r.charmatrix[x+y*C_WIDTH]);
|
||||
|
||||
precBgColor = curBgColor;
|
||||
precFgColor = curFgColor;
|
||||
}
|
||||
|
||||
AnsiConsole.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Renderer getRenderer() {
|
||||
return r;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless8Font loadFont(String file) throws IOException {
|
||||
return new Headless8Font();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless8Skin loadSkin(String file) throws IOException {
|
||||
return new Headless8Skin(file);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void waitUntilExit() {
|
||||
try {
|
||||
do {
|
||||
Thread.sleep(500);
|
||||
} while (stopped==false);
|
||||
} catch (final InterruptedException e) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSupported() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean doesRefreshPauses() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,11 +1,11 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless;
|
||||
package org.warp.picalculator.gui.graphicengine.headless256;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.BinaryFont;
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
|
||||
public class HeadlessFont implements BinaryFont {
|
||||
public class Headless8Font implements BinaryFont {
|
||||
|
||||
@Override
|
||||
public void load(String file) throws IOException {
|
||||
|
|
@ -0,0 +1,470 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless256;
|
||||
|
||||
import org.warp.picalculator.Main;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
|
||||
public class Headless8Renderer implements Renderer {
|
||||
|
||||
Headless8Font currentFont;
|
||||
protected char[] charmatrix = new char[Headless8Engine.C_WIDTH*Headless8Engine.C_HEIGHT];
|
||||
protected int[] colorMatrix = new int[Headless8Engine.C_WIDTH*Headless8Engine.C_HEIGHT];
|
||||
protected int clearColor = hexColor(0xc5, 0xc2, 0xaf);
|
||||
protected int curColor = clearColor;
|
||||
public Headless8Skin currentSkin;
|
||||
|
||||
public static final String ANSI_PREFIX = "\u001B[";
|
||||
public static final String ansiFgColorPrefix = "3";
|
||||
public static final String ansiBgColorPrefix = "4";
|
||||
public static final String ansiColorSuffix = "m";
|
||||
public static final String[] colorANSI = new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "0;1", "1;1", "2;1", "3;1", "4;1", "5;1", "6;1", "7;1"};
|
||||
|
||||
public static final String ANSI_RESET = "\u001B[0m";
|
||||
public static final char FILL = 0xDB;
|
||||
|
||||
|
||||
private int hexColor(int red, int green, int blue) {
|
||||
int r1=red, r2, g1=green, g2, b1=blue, b2;
|
||||
|
||||
float[] match = new float[16];
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 0;
|
||||
b2 = 0;
|
||||
match[0]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 205;
|
||||
g2 = 0;
|
||||
b2 = 0;
|
||||
match[1]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 205;
|
||||
b2 = 0;
|
||||
match[2]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 205;
|
||||
g2 = 205;
|
||||
b2 = 0;
|
||||
match[3]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 0;
|
||||
b2 = 238;
|
||||
match[4]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 205;
|
||||
g2 = 0;
|
||||
b2 = 205;
|
||||
match[5]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 205;
|
||||
b2 = 205;
|
||||
match[6]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 229;
|
||||
g2 = 229;
|
||||
b2 = 229;
|
||||
match[7]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 127;
|
||||
g2 = 127;
|
||||
b2 = 127;
|
||||
match[8]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 255;
|
||||
g2 = 0;
|
||||
b2 = 0;
|
||||
match[9]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 255;
|
||||
b2 = 0;
|
||||
match[0xa]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 255;
|
||||
g2 = 255;
|
||||
b2 = 0;
|
||||
match[0xb]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 92;
|
||||
g2 = 92;
|
||||
b2 = 255;
|
||||
match[0xc]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 255;
|
||||
g2 = 0;
|
||||
b2 = 255;
|
||||
match[0xd]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 0;
|
||||
g2 = 255;
|
||||
b2 = 255;
|
||||
match[0xe]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
// COLOR
|
||||
r2 = 255;
|
||||
g2 = 255;
|
||||
b2 = 255;
|
||||
match[0xf]=(r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
|
||||
|
||||
int minIndex = 0;
|
||||
for (int i = 1; i < match.length; i++) {
|
||||
float newnumber = match[i];
|
||||
if ((newnumber < match[minIndex])) {
|
||||
minIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
return minIndex;
|
||||
}
|
||||
|
||||
private int[] hexColorReverse(int i) {
|
||||
switch (i) {
|
||||
case 0x0:
|
||||
return new int[]{0,0,0};
|
||||
case 0x1:
|
||||
return new int[]{205,0,0};
|
||||
case 0x2:
|
||||
return new int[]{0,205,0};
|
||||
case 0x3:
|
||||
return new int[]{205,205,0};
|
||||
case 0x4:
|
||||
return new int[]{0,0,238};
|
||||
case 0x5:
|
||||
return new int[]{205,0,205};
|
||||
case 0x6:
|
||||
return new int[]{0,205,205};
|
||||
case 0x7:
|
||||
return new int[]{229,229,229};
|
||||
case 0x8:
|
||||
return new int[]{127,127,127};
|
||||
case 0x9:
|
||||
return new int[]{255,0,0};
|
||||
case 0xa:
|
||||
return new int[]{0,255,0};
|
||||
case 0xb:
|
||||
return new int[]{255,255,0};
|
||||
case 0xc:
|
||||
return new int[]{92,92,255};
|
||||
case 0xd:
|
||||
return new int[]{255,0,255};
|
||||
case 0xe:
|
||||
return new int[]{0,255,255};
|
||||
default:
|
||||
return new int[]{255,255,255};
|
||||
}
|
||||
}
|
||||
|
||||
private int colorUnion(int[] col) {
|
||||
return 0xFF<<24|col[0]<<16|col[1]<<8|col[2];
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor3i(int r, int gg, int b) {
|
||||
curColor = hexColor(r, gg, b);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor(int c) {
|
||||
curColor = hexColor(c >> 16 & 0xFF, c >> 8 & 0xFF, c & 0xFF);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4i(int red, int green, int blue, int alpha) {
|
||||
curColor = hexColor(red, green, blue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor3f(float red, float green, float blue) {
|
||||
curColor = hexColor((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4f(float red, float green, float blue, float alpha) {
|
||||
curColor = hexColor((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4i(int red, int green, int blue, int alpha) {
|
||||
clearColor = hexColor(red, green, blue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4f(float red, float green, float blue, float alpha) {
|
||||
clearColor = hexColor((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public int glGetClearColor() {
|
||||
return clearColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor(int c) {
|
||||
clearColor = hexColor(c >> 16 & 0xFF, c >> 8 & 0xFF, c & 0xFF);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClear(int screenWidth, int screenHeight) {
|
||||
clearAll();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawLine(float x1, float y1, float x2, float y2) {
|
||||
x1/=Headless8Engine.C_MUL_X;
|
||||
x2/=Headless8Engine.C_MUL_X;
|
||||
y1/=Headless8Engine.C_MUL_Y;
|
||||
y2/=Headless8Engine.C_MUL_Y;
|
||||
|
||||
int dx = (int) Math.abs(x2 - x1);
|
||||
int dy = (int) Math.abs(y2 - y1);
|
||||
|
||||
int sx = (x1 < x2) ? 1 : -1;
|
||||
int sy = (y1 < y2) ? 1 : -1;
|
||||
|
||||
int err = dx - dy;
|
||||
|
||||
while (true) {
|
||||
if (((int)x1) >= Headless8Engine.C_WIDTH || ((int)y1) >= Headless8Engine.C_HEIGHT ||
|
||||
((int)x2) >= Headless8Engine.C_WIDTH || ((int)y2) >= Headless8Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
int precBG = colorMatrix[((int)x1) + ((int)y1) * Headless8Engine.C_WIDTH]&0xF0;
|
||||
colorMatrix[((int)x1) + ((int)y1) * Headless8Engine.C_WIDTH] = precBG|curColor;
|
||||
charmatrix[((int)x1) + ((int)y1) * Headless8Engine.C_WIDTH] = FILL;
|
||||
|
||||
if (x1 == x2 && y1 == y2) {
|
||||
break;
|
||||
}
|
||||
|
||||
int e2 = 2 * err;
|
||||
|
||||
if (e2 > -dy) {
|
||||
err = err - dy;
|
||||
x1 = x1 + sx;
|
||||
}
|
||||
|
||||
if (e2 < dx) {
|
||||
err = err + dx;
|
||||
y1 = y1 + sy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillRect(float x, float y, float width, float height, float uvX, float uvY, float uvWidth, float uvHeight) {
|
||||
if (currentSkin != null) {
|
||||
glDrawSkin((int) (x/Headless8Engine.C_MUL_X), (int) (y/Headless8Engine.C_MUL_Y), (int) (uvX/Headless8Engine.C_MUL_X), (int) (uvY/Headless8Engine.C_MUL_Y), (int) ((uvWidth + uvX)/Headless8Engine.C_MUL_X), (int) ((uvHeight + uvY)/Headless8Engine.C_MUL_Y), true);
|
||||
} else {
|
||||
glFillColor(x, y, width, height);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillColor(float x, float y, float width, float height) {
|
||||
glFillColor(x, y, width, height, FILL, curColor);
|
||||
}
|
||||
|
||||
private void glFillColor(float x, float y, float width, float height, char character, int color) {
|
||||
final int ix = (int) x/Headless8Engine.C_MUL_X;
|
||||
final int iy = (int) y/Headless8Engine.C_MUL_Y;
|
||||
final int iw = (int) width/Headless8Engine.C_MUL_X;
|
||||
final int ih = (int) height/Headless8Engine.C_MUL_Y;
|
||||
|
||||
int x1 = ix + iw;
|
||||
int y1 = iy + ih;
|
||||
if (ix >= Headless8Engine.C_WIDTH || iy >= Headless8Engine.C_WIDTH) {
|
||||
return;
|
||||
}
|
||||
if (x1 >= Headless8Engine.C_WIDTH) {
|
||||
x1 = Headless8Engine.C_WIDTH;
|
||||
}
|
||||
if (y1 >= Headless8Engine.C_HEIGHT) {
|
||||
y1 = Headless8Engine.C_HEIGHT;
|
||||
}
|
||||
final int sizeW = Headless8Engine.C_WIDTH;
|
||||
for (int px = ix; px < x1; px++) {
|
||||
for (int py = iy; py < y1; py++) {
|
||||
int precBG = colorMatrix[(px) + (py) * sizeW]&0xF0;
|
||||
colorMatrix[(px) + (py) * sizeW] = precBG|color;
|
||||
charmatrix[(px) + (py) * sizeW] = character;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void glDrawCharLeft(int x, int y, char ch) {
|
||||
final int cx = ((int)x)/Headless8Engine.C_MUL_X;
|
||||
final int cy = ((int)y)/Headless8Engine.C_MUL_Y;
|
||||
if (cx >= Headless8Engine.C_WIDTH || cy >= Headless8Engine.C_HEIGHT) {
|
||||
return;
|
||||
}
|
||||
charmatrix[cx+cy*Headless8Engine.C_WIDTH] = ch;
|
||||
int precBG = colorMatrix[cx+cy*Headless8Engine.C_WIDTH]&0xF0;
|
||||
colorMatrix[cx+cy*Headless8Engine.C_WIDTH] = precBG|curColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharCenter(int x, int y, char ch) {
|
||||
glDrawCharLeft(x,y,ch);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharRight(int x, int y, char ch) {
|
||||
final int cx = ((int)x)/Headless8Engine.C_MUL_X-1;
|
||||
final int cy = ((int)y)/Headless8Engine.C_MUL_Y;
|
||||
if (cx >= Headless8Engine.C_WIDTH || cy >= Headless8Engine.C_HEIGHT) {
|
||||
return;
|
||||
}
|
||||
charmatrix[cx+cy*Headless8Engine.C_WIDTH] = ch;
|
||||
int precBG = colorMatrix[cx+cy*Headless8Engine.C_WIDTH]&0xF0;
|
||||
colorMatrix[cx+cy*Headless8Engine.C_WIDTH] = precBG|curColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringLeft(float x, float y, String text) {
|
||||
final int cx = ((int)x)/Headless8Engine.C_MUL_X;
|
||||
final int cy = ((int)y)/Headless8Engine.C_MUL_Y;
|
||||
int i = 0;
|
||||
for (char c : text.toCharArray()) {
|
||||
if (cx+i >= Headless8Engine.C_WIDTH || cy >= Headless8Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
charmatrix[cx+i+cy*Headless8Engine.C_WIDTH] = c;
|
||||
int precBG = colorMatrix[cx+i+cy*Headless8Engine.C_WIDTH]&0xF0;
|
||||
colorMatrix[cx+i+cy*Headless8Engine.C_WIDTH] = precBG|curColor;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringCenter(float x, float y, String text) {
|
||||
final int cx = ((int)x)/Headless8Engine.C_MUL_X-text.length()/2;
|
||||
final int cy = ((int)y)/Headless8Engine.C_MUL_Y;
|
||||
int i = 0;
|
||||
for (char c : text.toCharArray()) {
|
||||
if (cx+i >= Headless8Engine.C_WIDTH || cy >= Headless8Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
charmatrix[cx+i+cy*Headless8Engine.C_WIDTH] = c;
|
||||
int precBG = colorMatrix[cx+i+cy*Headless8Engine.C_WIDTH]&0xF0;
|
||||
colorMatrix[cx+i+cy*Headless8Engine.C_WIDTH] = precBG|curColor;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringRight(float x, float y, String text) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
|
||||
private void glDrawSkin(int x0, int y0, int s0, int t0, int s1, int t1, boolean transparent) {
|
||||
int oldColor;
|
||||
int newColor;
|
||||
final int onex = s0 <= s1 ? 1 : -1;
|
||||
final int oney = t0 <= t1 ? 1 : -1;
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
if (onex == -1) {
|
||||
final int s00 = s0;
|
||||
s0 = s1;
|
||||
s1 = s00;
|
||||
width = s1 - s0;
|
||||
}
|
||||
if (oney == -1) {
|
||||
final int t00 = t0;
|
||||
t0 = t1;
|
||||
t1 = t00;
|
||||
height = t1 - t0;
|
||||
}
|
||||
if (x0 >= Headless8Engine.C_WIDTH || y0 >= Headless8Engine.C_WIDTH) {
|
||||
return;
|
||||
}
|
||||
if (x0 + width >= Headless8Engine.C_WIDTH) {
|
||||
s1 = Headless8Engine.C_WIDTH - x0 + s0;
|
||||
}
|
||||
if (y0 + height >= Headless8Engine.C_HEIGHT) {
|
||||
t1 = Headless8Engine.C_HEIGHT - y0 + t0;
|
||||
}
|
||||
if (x0 < 0) {
|
||||
if (onex == -1) {
|
||||
width += x0;
|
||||
s1 += x0 + 1;
|
||||
} else {
|
||||
s0 -= x0;
|
||||
}
|
||||
x0 = 0;
|
||||
}
|
||||
if (y0 < 0) {
|
||||
if (oney == -1) {
|
||||
height += y0;
|
||||
t1 += y0 + 1;
|
||||
} else {
|
||||
t0 -= y0;
|
||||
}
|
||||
y0 = 0;
|
||||
}
|
||||
int pixelX;
|
||||
int pixelY;
|
||||
for (int texx = 0; texx < s1 - s0; texx++) {
|
||||
for (int texy = 0; texy < t1 - t0; texy++) {
|
||||
pixelX = (x0 + texx * onex + width);
|
||||
pixelY = (y0 + texy * oney + height);
|
||||
if (pixelY < Headless8Engine.C_HEIGHT) {
|
||||
if (pixelX - (pixelX % Headless8Engine.C_WIDTH) == 0) {
|
||||
newColor = currentSkin.skinData[(s0 + texx) + (t0 + texy) * currentSkin.skinSize[0]];
|
||||
if (transparent) {
|
||||
oldColor = colorUnion(hexColorReverse((colorMatrix[pixelX + pixelY * Headless8Engine.C_WIDTH]&0xF0)>>4));
|
||||
final float a2 = (newColor >> 24 & 0xFF) / 255f;
|
||||
final float a1 = 1f - a2;
|
||||
final int r = (int) ((oldColor >> 16 & 0xFF) * a1 + (newColor >> 16 & 0xFF) * a2);
|
||||
final int g = (int) ((oldColor >> 8 & 0xFF) * a1 + (newColor >> 8 & 0xFF) * a2);
|
||||
final int b = (int) ((oldColor & 0xFF) * a1 + (newColor & 0xFF) * a2);
|
||||
newColor = 0xFF000000 | r << 16 | g << 8 | b;
|
||||
}
|
||||
int bgColor = colorMatrix[pixelX + pixelY * Headless8Engine.C_WIDTH] & 0xF0;
|
||||
colorMatrix[pixelX + pixelY * Headless8Engine.C_WIDTH] = bgColor|hexColor(newColor >> 16 & 0xFF, newColor >> 8 & 0xFF, newColor & 0xFF);
|
||||
charmatrix[pixelX + pixelY * Headless8Engine.C_WIDTH] = FILL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearSkin() {
|
||||
currentSkin = null;
|
||||
}
|
||||
|
||||
protected void clearAll() {
|
||||
for (int i = 0; i < Headless8Engine.C_WIDTH*Headless8Engine.C_HEIGHT; i++) {
|
||||
charmatrix[i]=' ';
|
||||
colorMatrix[i] = clearColor<<4;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless8Font getCurrentFont() {
|
||||
return currentFont;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless256;
|
||||
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.geom.AffineTransform;
|
||||
import java.awt.image.AffineTransformOp;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.IOException;
|
||||
|
||||
import javax.imageio.ImageIO;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
import org.warp.picalculator.gui.graphicengine.cpu.CPUEngine.CPURenderer;
|
||||
|
||||
public class Headless8Skin implements Skin {
|
||||
|
||||
public int[] skinData;
|
||||
public int[] skinSize;
|
||||
|
||||
Headless8Skin(String file) throws IOException {
|
||||
load(file);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load(String file) throws IOException {
|
||||
final BufferedImage img = ImageIO.read(this.getClass().getResource("/" + file));
|
||||
skinData = getMatrixOfImage(img);
|
||||
skinSize = new int[] { img.getWidth(), img.getHeight() };
|
||||
}
|
||||
|
||||
public static int[] getMatrixOfImage(BufferedImage bufferedImage) {
|
||||
BufferedImage after = new BufferedImage(bufferedImage.getWidth(null), bufferedImage.getHeight(null), BufferedImage.TYPE_INT_ARGB);
|
||||
AffineTransform at = new AffineTransform();
|
||||
at.scale(1f/((float)Headless8Engine.C_MUL_X), 1f/((float)Headless8Engine.C_MUL_Y));
|
||||
AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
|
||||
after = scaleOp.filter(bufferedImage, after);
|
||||
|
||||
|
||||
final int width = after.getWidth(null);
|
||||
final int height = after.getHeight(null);
|
||||
final int[] pixels = new int[width * height];
|
||||
for (int i = 0; i < width; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
pixels[i + j * width] = after.getRGB(i, j);
|
||||
}
|
||||
}
|
||||
|
||||
return pixels;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize(GraphicEngine d) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void use(GraphicEngine d) {
|
||||
((Headless8Renderer) d.getRenderer()).currentSkin = this;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless8;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.logging.ConsoleHandler;
|
||||
|
||||
import org.fusesource.jansi.AnsiConsole;
|
||||
import org.warp.picalculator.Main;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
import org.warp.picalculator.gui.graphicengine.RenderingLoop;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
|
||||
public class Headless256Engine implements org.warp.picalculator.gui.graphicengine.GraphicEngine {
|
||||
|
||||
private Headless256Renderer r = new Headless256Renderer();
|
||||
private boolean stopped = true;
|
||||
private RenderingLoop renderLoop;
|
||||
protected static final int C_WIDTH = Main.screenSize[0]/2;//;60;
|
||||
protected static final int C_HEIGHT = Main.screenSize[1]/3;//;40;
|
||||
public static final int C_MUL_X = 2;//8;
|
||||
public static final int C_MUL_Y = 3;//8;
|
||||
private String title = Main.calculatorName;
|
||||
|
||||
@Override
|
||||
public int[] getSize() {
|
||||
ConsoleHandler ch = new ConsoleHandler();
|
||||
return new int[]{C_WIDTH, C_HEIGHT};
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isInitialized() {
|
||||
return !stopped;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTitle(String title) {
|
||||
this.title = title;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setResizable(boolean r) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDisplayMode(int ww, int wh) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void create() {
|
||||
AnsiConsole.systemInstall();
|
||||
AnsiConsole.out.print(Headless256Renderer.ANSI_PREFIX+"?25l");
|
||||
stopped = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean wasResized() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getWidth() {
|
||||
return C_WIDTH*C_MUL_X;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getHeight() {
|
||||
return C_HEIGHT*C_MUL_Y;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void destroy() {
|
||||
stopped = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void start(RenderingLoop d) {
|
||||
this.renderLoop = d;
|
||||
final Thread th = new Thread(() -> {
|
||||
try {
|
||||
double extratime = 0;
|
||||
while (!stopped) {
|
||||
final long start = System.currentTimeMillis();
|
||||
repaint();
|
||||
final long end = System.currentTimeMillis();
|
||||
final double delta = (end - start) / 1000d;
|
||||
final int deltaInt = (int) Math.floor(delta);
|
||||
final int extraTimeInt = (int) Math.floor(extratime);
|
||||
if (extraTimeInt + deltaInt < 200) {
|
||||
Thread.sleep(200 - (extraTimeInt + deltaInt));
|
||||
extratime = 0;
|
||||
} else {
|
||||
extratime += delta - 200d;
|
||||
}
|
||||
}
|
||||
} catch (final InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
th.setName("Console rendering thread");
|
||||
th.setDaemon(true);
|
||||
th.start();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void repaint() {
|
||||
renderLoop.refresh();
|
||||
r.curColor = 0x1C;
|
||||
r.glDrawStringCenter((C_WIDTH*C_MUL_X)/2, 0, title);
|
||||
AnsiConsole.out.print(Headless256Renderer.ANSI_PREFIX+"1;1H");
|
||||
for (int y = 0; y < C_HEIGHT; y++) {
|
||||
int precBgColor = -1;
|
||||
int precFgColor = -1;
|
||||
int curBgColor = -1;
|
||||
int curFgColor = -1;
|
||||
for (int x = 0; x < C_WIDTH; x++) {
|
||||
curBgColor = r.bgColorMatrix[x+y*C_WIDTH];
|
||||
curFgColor = r.fgColorMatrix[x+y*C_WIDTH];
|
||||
if (precBgColor != curBgColor) {
|
||||
AnsiConsole.out.print(Headless256Renderer.ANSI_PREFIX+Headless256Renderer.ansiBgColorPrefix+curBgColor+Headless256Renderer.ansiColorSuffix);
|
||||
}
|
||||
if (precFgColor != curFgColor) {
|
||||
AnsiConsole.out.print(Headless256Renderer.ANSI_PREFIX+Headless256Renderer.ansiFgColorPrefix+curFgColor+Headless256Renderer.ansiColorSuffix);
|
||||
}
|
||||
|
||||
AnsiConsole.out.print(r.charmatrix[x+y*C_WIDTH]);
|
||||
|
||||
precBgColor = curBgColor;
|
||||
precFgColor = curFgColor;
|
||||
}
|
||||
|
||||
AnsiConsole.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Renderer getRenderer() {
|
||||
return r;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless256Font loadFont(String file) throws IOException {
|
||||
return new Headless256Font();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless256Skin loadSkin(String file) throws IOException {
|
||||
return new Headless256Skin(file);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void waitUntilExit() {
|
||||
try {
|
||||
do {
|
||||
Thread.sleep(500);
|
||||
} while (stopped==false);
|
||||
} catch (final InterruptedException e) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSupported() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean doesRefreshPauses() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless8;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.BinaryFont;
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
|
||||
public class Headless256Font implements BinaryFont {
|
||||
|
||||
@Override
|
||||
public void load(String file) throws IOException {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize(GraphicEngine d) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void use(GraphicEngine d) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getStringWidth(String text) {
|
||||
return 5*text.length();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getCharacterWidth() {
|
||||
return 5;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getCharacterHeight() {
|
||||
return 5;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,339 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless8;
|
||||
|
||||
import org.warp.picalculator.Main;
|
||||
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||||
|
||||
public class Headless256Renderer implements Renderer {
|
||||
|
||||
Headless256Font currentFont;
|
||||
protected char[] charmatrix = new char[Headless256Engine.C_WIDTH*Headless256Engine.C_HEIGHT];
|
||||
protected int[] fgColorMatrix = new int[Headless256Engine.C_WIDTH*Headless256Engine.C_HEIGHT];
|
||||
protected int[] bgColorMatrix = new int[Headless256Engine.C_WIDTH*Headless256Engine.C_HEIGHT];
|
||||
protected int clearColor = rgbToX256(0xc5, 0xc2, 0xaf);
|
||||
protected int curColor = clearColor;
|
||||
public Headless256Skin currentSkin;
|
||||
|
||||
public static final String ANSI_PREFIX = "\u001B[";
|
||||
public static final String ansiFgColorPrefix = "38;5;";
|
||||
public static final String ansiBgColorPrefix = "48;5;";
|
||||
public static final String ansiColorSuffix = "m";
|
||||
|
||||
public static final String ANSI_RESET = "\u001B[0m";
|
||||
public static final char FILL = 0xDB;
|
||||
public static final int TRANSPARENT = 0xF0000;
|
||||
|
||||
|
||||
public static int v2ci(int v_U) {
|
||||
return v_U < 48 ? 0 : v_U < 115 ? 1 : (v_U - 35) / 40;
|
||||
}
|
||||
|
||||
public static int colorIndex(int ir, int ig, int ib) {
|
||||
return 36 * ir + 6 * ig + ib;
|
||||
}
|
||||
|
||||
public static int distSquare(int a, int b, int c, int a_U, int b_U, int c_U) {
|
||||
return (a - a_U) * (a - a_U) + (b - b_U) * (b - b_U) + (c - c_U) * (c - c_U);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the represented colors back from the index
|
||||
*/
|
||||
public static int[] i2cv = {0, 0x5f, 0x87, 0xaf, 0xd7, 0xff};
|
||||
|
||||
public static int rgbToX256(int r_U, int g_U, int b_U) {
|
||||
// Calculate the nearest 0-based color index at 16 .. 231
|
||||
|
||||
int ir = v2ci(r_U), ig = v2ci(g_U), ib = v2ci(b_U); // 0..5 each
|
||||
/* 0..215, lazy evaluation */
|
||||
|
||||
// Calculate the nearest 0-based gray index at 232 .. 255
|
||||
int average = (r_U + g_U + b_U) / 3;
|
||||
int grayIndex = average > 238 ? 23 : (average - 3) / 10; // 0..23
|
||||
|
||||
int cr = i2cv[ir], cg = i2cv[ig], cb = i2cv[ib]; // r/g/b, 0..255 each
|
||||
int gv = 8 + 10 * grayIndex; // same value for r/g/b, 0..255
|
||||
|
||||
// Return the one which is nearer to the original input rgb value
|
||||
|
||||
int colorErr = distSquare(cr, cg, cb, r_U, g_U, b_U);
|
||||
int grayErr = distSquare(gv, gv, gv, r_U, g_U, b_U);
|
||||
return colorErr <= grayErr ? 16 + colorIndex(ir, ig, ib) : 232 + grayIndex;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor3i(int r, int gg, int b) {
|
||||
curColor = rgbToX256(r, gg, b);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor(int c) {
|
||||
curColor = rgbToX256(c >> 16 & 0xFF, c >> 8 & 0xFF, c & 0xFF);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4i(int red, int green, int blue, int alpha) {
|
||||
curColor = rgbToX256(red, green, blue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor3f(float red, float green, float blue) {
|
||||
curColor = rgbToX256((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glColor4f(float red, float green, float blue, float alpha) {
|
||||
curColor = rgbToX256((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4i(int red, int green, int blue, int alpha) {
|
||||
clearColor = rgbToX256(red, green, blue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor4f(float red, float green, float blue, float alpha) {
|
||||
clearColor = rgbToX256((int)(red*255), (int)(green*255), (int)(blue*255));
|
||||
}
|
||||
|
||||
@Override
|
||||
public int glGetClearColor() {
|
||||
return clearColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearColor(int c) {
|
||||
clearColor = rgbToX256(c >> 16 & 0xFF, c >> 8 & 0xFF, c & 0xFF);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClear(int screenWidth, int screenHeight) {
|
||||
clearAll();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawLine(float x1, float y1, float x2, float y2) {
|
||||
x1/=Headless256Engine.C_MUL_X;
|
||||
x2/=Headless256Engine.C_MUL_X;
|
||||
y1/=Headless256Engine.C_MUL_Y;
|
||||
y2/=Headless256Engine.C_MUL_Y;
|
||||
|
||||
int dx = (int) Math.abs(x2 - x1);
|
||||
int dy = (int) Math.abs(y2 - y1);
|
||||
|
||||
int sx = (x1 < x2) ? 1 : -1;
|
||||
int sy = (y1 < y2) ? 1 : -1;
|
||||
|
||||
int err = dx - dy;
|
||||
|
||||
while (true) {
|
||||
if (((int)x1) >= Headless256Engine.C_WIDTH || ((int)y1) >= Headless256Engine.C_HEIGHT ||
|
||||
((int)x2) >= Headless256Engine.C_WIDTH || ((int)y2) >= Headless256Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
bgColorMatrix[((int)x1) + ((int)y1) * Headless256Engine.C_WIDTH] = curColor;
|
||||
charmatrix[((int)x1) + ((int)y1) * Headless256Engine.C_WIDTH] = ' ';
|
||||
|
||||
if (x1 == x2 && y1 == y2) {
|
||||
break;
|
||||
}
|
||||
|
||||
int e2 = 2 * err;
|
||||
|
||||
if (e2 > -dy) {
|
||||
err = err - dy;
|
||||
x1 = x1 + sx;
|
||||
}
|
||||
|
||||
if (e2 < dx) {
|
||||
err = err + dx;
|
||||
y1 = y1 + sy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillRect(float x, float y, float width, float height, float uvX, float uvY, float uvWidth, float uvHeight) {
|
||||
if (currentSkin != null) {
|
||||
glDrawSkin((int) (x/Headless256Engine.C_MUL_X), (int) (y/Headless256Engine.C_MUL_Y), (int) (uvX/Headless256Engine.C_MUL_X), (int) (uvY/Headless256Engine.C_MUL_Y), (int) ((uvWidth + uvX)/Headless256Engine.C_MUL_X), (int) ((uvHeight + uvY)/Headless256Engine.C_MUL_Y), true);
|
||||
} else {
|
||||
glFillColor(x, y, width, height);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glFillColor(float x, float y, float width, float height) {
|
||||
final int ix = (int) x/Headless256Engine.C_MUL_X;
|
||||
final int iy = (int) y/Headless256Engine.C_MUL_Y;
|
||||
final int iw = (int) width/Headless256Engine.C_MUL_X;
|
||||
final int ih = (int) height/Headless256Engine.C_MUL_Y;
|
||||
|
||||
int x1 = ix + iw;
|
||||
int y1 = iy + ih;
|
||||
if (ix >= Headless256Engine.C_WIDTH || iy >= Headless256Engine.C_WIDTH) {
|
||||
return;
|
||||
}
|
||||
if (x1 >= Headless256Engine.C_WIDTH) {
|
||||
x1 = Headless256Engine.C_WIDTH;
|
||||
}
|
||||
if (y1 >= Headless256Engine.C_HEIGHT) {
|
||||
y1 = Headless256Engine.C_HEIGHT;
|
||||
}
|
||||
final int sizeW = Headless256Engine.C_WIDTH;
|
||||
for (int px = ix; px < x1; px++) {
|
||||
for (int py = iy; py < y1; py++) {
|
||||
bgColorMatrix[(px) + (py) * sizeW] = curColor;
|
||||
charmatrix[(px) + (py) * sizeW] = ' ';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void glDrawCharLeft(int x, int y, char ch) {
|
||||
final int cx = ((int)x)/Headless256Engine.C_MUL_X;
|
||||
final int cy = ((int)y)/Headless256Engine.C_MUL_Y;
|
||||
if (cx >= Headless256Engine.C_WIDTH || cy >= Headless256Engine.C_HEIGHT) {
|
||||
return;
|
||||
}
|
||||
charmatrix[cx+cy*Headless256Engine.C_WIDTH] = ch;
|
||||
fgColorMatrix[cx+cy*Headless256Engine.C_WIDTH] = curColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharCenter(int x, int y, char ch) {
|
||||
glDrawCharLeft(x,y,ch);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawCharRight(int x, int y, char ch) {
|
||||
final int cx = ((int)x)/Headless256Engine.C_MUL_X-1;
|
||||
final int cy = ((int)y)/Headless256Engine.C_MUL_Y;
|
||||
if (cx >= Headless256Engine.C_WIDTH || cy >= Headless256Engine.C_HEIGHT) {
|
||||
return;
|
||||
}
|
||||
charmatrix[cx+cy*Headless256Engine.C_WIDTH] = ch;
|
||||
fgColorMatrix[cx+cy*Headless256Engine.C_WIDTH] = curColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringLeft(float x, float y, String text) {
|
||||
final int cx = ((int)x)/Headless256Engine.C_MUL_X;
|
||||
final int cy = ((int)y)/Headless256Engine.C_MUL_Y;
|
||||
int i = 0;
|
||||
for (char c : text.toCharArray()) {
|
||||
if (cx+i >= Headless256Engine.C_WIDTH || cy >= Headless256Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
charmatrix[cx+i+cy*Headless256Engine.C_WIDTH] = c;
|
||||
fgColorMatrix[cx+i+cy*Headless256Engine.C_WIDTH] = curColor;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringCenter(float x, float y, String text) {
|
||||
final int cx = ((int)x)/Headless256Engine.C_MUL_X-text.length()/2;
|
||||
final int cy = ((int)y)/Headless256Engine.C_MUL_Y;
|
||||
int i = 0;
|
||||
for (char c : text.toCharArray()) {
|
||||
if (cx+i >= Headless256Engine.C_WIDTH || cy >= Headless256Engine.C_HEIGHT) {
|
||||
break;
|
||||
}
|
||||
charmatrix[cx+i+cy*Headless256Engine.C_WIDTH] = c;
|
||||
fgColorMatrix[cx+i+cy*Headless256Engine.C_WIDTH] = curColor;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDrawStringRight(float x, float y, String text) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
|
||||
private void glDrawSkin(int x0, int y0, int s0, int t0, int s1, int t1, boolean transparent) {
|
||||
int oldColor;
|
||||
int newColor;
|
||||
final int onex = s0 <= s1 ? 1 : -1;
|
||||
final int oney = t0 <= t1 ? 1 : -1;
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
if (onex == -1) {
|
||||
final int s00 = s0;
|
||||
s0 = s1;
|
||||
s1 = s00;
|
||||
width = s1 - s0;
|
||||
}
|
||||
if (oney == -1) {
|
||||
final int t00 = t0;
|
||||
t0 = t1;
|
||||
t1 = t00;
|
||||
height = t1 - t0;
|
||||
}
|
||||
if (x0 >= Headless256Engine.C_WIDTH || y0 >= Headless256Engine.C_WIDTH) {
|
||||
return;
|
||||
}
|
||||
if (x0 + width >= Headless256Engine.C_WIDTH) {
|
||||
s1 = Headless256Engine.C_WIDTH - x0 + s0;
|
||||
}
|
||||
if (y0 + height >= Headless256Engine.C_HEIGHT) {
|
||||
t1 = Headless256Engine.C_HEIGHT - y0 + t0;
|
||||
}
|
||||
if (x0 < 0) {
|
||||
if (onex == -1) {
|
||||
width += x0;
|
||||
s1 += x0 + 1;
|
||||
} else {
|
||||
s0 -= x0;
|
||||
}
|
||||
x0 = 0;
|
||||
}
|
||||
if (y0 < 0) {
|
||||
if (oney == -1) {
|
||||
height += y0;
|
||||
t1 += y0 + 1;
|
||||
} else {
|
||||
t0 -= y0;
|
||||
}
|
||||
y0 = 0;
|
||||
}
|
||||
int pixelX;
|
||||
int pixelY;
|
||||
for (int texx = 0; texx < s1 - s0; texx++) {
|
||||
for (int texy = 0; texy < t1 - t0; texy++) {
|
||||
pixelX = (x0 + texx * onex + width);
|
||||
pixelY = (y0 + texy * oney + height);
|
||||
if (pixelY < Headless256Engine.C_HEIGHT) {
|
||||
if (pixelX - (pixelX % Headless256Engine.C_WIDTH) == 0) {
|
||||
int bgColor = bgColorMatrix[pixelX + pixelY * Headless256Engine.C_WIDTH];
|
||||
newColor = currentSkin.skinData[(s0 + texx) + (t0 + texy) * currentSkin.skinSize[0]];
|
||||
if (transparent && !((newColor&TRANSPARENT) == TRANSPARENT)) {
|
||||
charmatrix[pixelX + pixelY * Headless256Engine.C_WIDTH] = ' ';
|
||||
bgColorMatrix[pixelX + pixelY * Headless256Engine.C_WIDTH] = newColor;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glClearSkin() {
|
||||
currentSkin = null;
|
||||
}
|
||||
|
||||
protected void clearAll() {
|
||||
for (int i = 0; i < Headless256Engine.C_WIDTH*Headless256Engine.C_HEIGHT; i++) {
|
||||
charmatrix[i]=' ';
|
||||
bgColorMatrix[i] = clearColor;
|
||||
fgColorMatrix[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Headless256Font getCurrentFont() {
|
||||
return currentFont;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
package org.warp.picalculator.gui.graphicengine.headless8;
|
||||
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.geom.AffineTransform;
|
||||
import java.awt.image.AffineTransformOp;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.IOException;
|
||||
|
||||
import javax.imageio.ImageIO;
|
||||
|
||||
import org.warp.picalculator.gui.graphicengine.GraphicEngine;
|
||||
import org.warp.picalculator.gui.graphicengine.Skin;
|
||||
import org.warp.picalculator.gui.graphicengine.cpu.CPUEngine.CPURenderer;
|
||||
|
||||
public class Headless256Skin implements Skin {
|
||||
|
||||
public int[] skinData;
|
||||
public int[] skinSize;
|
||||
|
||||
Headless256Skin(String file) throws IOException {
|
||||
load(file);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load(String file) throws IOException {
|
||||
final BufferedImage img = ImageIO.read(this.getClass().getResource("/" + file));
|
||||
skinData = getMatrixOfImage(img);
|
||||
skinSize = new int[] { img.getWidth(), img.getHeight() };
|
||||
}
|
||||
|
||||
public static int[] getMatrixOfImage(BufferedImage bufferedImage) {
|
||||
BufferedImage after = new BufferedImage(bufferedImage.getWidth(null), bufferedImage.getHeight(null), BufferedImage.TYPE_INT_ARGB);
|
||||
AffineTransform at = new AffineTransform();
|
||||
at.scale(1f/((float)Headless256Engine.C_MUL_X), 1f/((float)Headless256Engine.C_MUL_Y));
|
||||
AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
|
||||
after = scaleOp.filter(bufferedImage, after);
|
||||
|
||||
|
||||
final int width = after.getWidth(null);
|
||||
final int height = after.getHeight(null);
|
||||
final int[] pixels = new int[width * height];
|
||||
for (int i = 0; i < width; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
int rgb = after.getRGB(i, j);
|
||||
int r = (rgb >> 16) &0xFF;
|
||||
int g = (rgb >> 8) &0xFF;
|
||||
int b = rgb &0xFF;
|
||||
boolean transparent = ((rgb >> 24) & 0xFF) <= 128;
|
||||
pixels[i + j * width] = Headless256Renderer.rgbToX256(r, g, b)|(transparent?Headless256Renderer.TRANSPARENT:0);
|
||||
}
|
||||
}
|
||||
|
||||
return pixels;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize(GraphicEngine d) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void use(GraphicEngine d) {
|
||||
((Headless256Renderer) d.getRenderer()).currentSkin = this;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -132,260 +132,278 @@ public class MathInputScreen extends Screen {
|
|||
public boolean keyPressed(Key k) {
|
||||
Utils.debug.println(k.toString());
|
||||
switch (k) {
|
||||
case STEP:
|
||||
// if (newExpression.length() > 0) {
|
||||
// if (firstStep) {
|
||||
// try {
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// showVariablesDialog(() -> {
|
||||
// currentExpression = newExpression;
|
||||
// calc.f2 = calc.f;
|
||||
// firstStep = false;
|
||||
// step();
|
||||
// });
|
||||
// } catch (final Exception ex) {
|
||||
// if (Utils.debugOn) {
|
||||
// ex.printStackTrace();
|
||||
// }
|
||||
// throw new Error(Errors.SYNTAX_ERROR);
|
||||
// }
|
||||
// } catch (final Error e) {
|
||||
// final StringWriter sw = new StringWriter();
|
||||
// final PrintWriter pw = new PrintWriter(sw);
|
||||
// e.printStackTrace(pw);
|
||||
// d.errorStackTrace = sw.toString().toUpperCase().replace("\t", " ").replace("\r", "").split("\n");
|
||||
// DisplayManager.error = e.id.toString();
|
||||
// System.err.println(e.id);
|
||||
// }
|
||||
// } else {
|
||||
// step();
|
||||
// }
|
||||
// }
|
||||
// return true;
|
||||
case SIMPLIFY:
|
||||
if (DisplayManager.error != null) {
|
||||
//TODO: make the error management a global API rather than being relegated to this screen.
|
||||
Utils.debug.println("Resetting after error...");
|
||||
DisplayManager.error = null;
|
||||
calc.f = null;
|
||||
calc.f2 = null;
|
||||
calc.resultsCount = 0;
|
||||
return true;
|
||||
} else {
|
||||
try {
|
||||
try {
|
||||
if (!userInput.isAlreadyParsed() && !userInput.isEmpty()) {
|
||||
Expression expr = MathParser.parseInput(calc, userInput);
|
||||
if (calc.f == null | calc.f2 == null) {
|
||||
calc.f = new ObjectArrayList<>();
|
||||
calc.f2 = new ObjectArrayList<>();
|
||||
} else {
|
||||
calc.f.clear();
|
||||
calc.f2.clear();
|
||||
}
|
||||
calc.f.add(expr);
|
||||
ObjectArrayList<Function> resultExpression = expr.solve();
|
||||
ObjectArrayList<Block> resultBlocks = MathParser.parseOutput(calc, resultExpression);
|
||||
result.setContent(resultBlocks);
|
||||
// showVariablesDialog(() -> {
|
||||
// currentExpression = newExpression;
|
||||
// simplify();
|
||||
// });
|
||||
}
|
||||
} catch (final Exception ex) {
|
||||
if (Utils.debugOn) {
|
||||
ex.printStackTrace();
|
||||
}
|
||||
throw new Error(Errors.SYNTAX_ERROR);
|
||||
}
|
||||
} catch (final Error e) {
|
||||
final StringWriter sw = new StringWriter();
|
||||
final PrintWriter pw = new PrintWriter(sw);
|
||||
e.printStackTrace(pw);
|
||||
d.errorStackTrace = sw.toString().toUpperCase().replace("\t", " ").replace("\r", "").split("\n");
|
||||
DisplayManager.error = e.id.toString();
|
||||
System.err.println(e.id);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
case NUM0:
|
||||
typeChar('0');
|
||||
return true;
|
||||
case NUM1:
|
||||
typeChar('1');
|
||||
return true;
|
||||
case NUM2:
|
||||
typeChar('2');
|
||||
return true;
|
||||
case NUM3:
|
||||
typeChar('3');
|
||||
return true;
|
||||
case NUM4:
|
||||
typeChar('4');
|
||||
return true;
|
||||
case NUM5:
|
||||
typeChar('5');
|
||||
return true;
|
||||
case NUM6:
|
||||
typeChar('6');
|
||||
return true;
|
||||
case NUM7:
|
||||
typeChar('7');
|
||||
return true;
|
||||
case NUM8:
|
||||
typeChar('8');
|
||||
return true;
|
||||
case NUM9:
|
||||
typeChar('9');
|
||||
return true;
|
||||
case PLUS:
|
||||
typeChar('+');
|
||||
return true;
|
||||
case MINUS:
|
||||
typeChar('-');
|
||||
return true;
|
||||
case PLUS_MINUS:
|
||||
typeChar('±');
|
||||
return true;
|
||||
case MULTIPLY:
|
||||
typeChar('*');
|
||||
return true;
|
||||
case DIVIDE:
|
||||
typeChar('/');
|
||||
return true;
|
||||
case PARENTHESIS_OPEN:
|
||||
typeChar('(');
|
||||
return true;
|
||||
case PARENTHESIS_CLOSE:
|
||||
typeChar(')');
|
||||
return true;
|
||||
case DOT:
|
||||
typeChar('.');
|
||||
return true;
|
||||
case EQUAL:
|
||||
typeChar('=');
|
||||
return true;
|
||||
case SQRT:
|
||||
typeChar('Ⓐ');
|
||||
return true;
|
||||
case ROOT:
|
||||
typeChar('√');
|
||||
return true;
|
||||
case POWER_OF_2:
|
||||
typeChar(MathematicalSymbols.POWER_OF_TWO);
|
||||
return true;
|
||||
case POWER_OF_x:
|
||||
typeChar(MathematicalSymbols.POWER);
|
||||
return true;
|
||||
case PI:
|
||||
typeChar(MathematicalSymbols.PI);
|
||||
return true;
|
||||
case LETTER_X:
|
||||
typeChar(MathematicalSymbols.variables[23]);
|
||||
return true;
|
||||
case LETTER_Y:
|
||||
typeChar(MathematicalSymbols.variables[24]);
|
||||
return true;
|
||||
case SINE:
|
||||
typeChar(MathematicalSymbols.SINE);
|
||||
return true;
|
||||
case COSINE:
|
||||
typeChar(MathematicalSymbols.COSINE);
|
||||
return true;
|
||||
case TANGENT:
|
||||
typeChar(MathematicalSymbols.TANGENT);
|
||||
return true;
|
||||
case ARCSINE:
|
||||
typeChar(MathematicalSymbols.ARC_SINE);
|
||||
return true;
|
||||
case ARCCOSINE:
|
||||
typeChar(MathematicalSymbols.ARC_COSINE);
|
||||
return true;
|
||||
case ARCTANGENT:
|
||||
typeChar(MathematicalSymbols.ARC_TANGENT);
|
||||
return true;
|
||||
case DELETE:
|
||||
userInput.del();
|
||||
case OK:
|
||||
userInput.toggleExtra();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case LEFT:
|
||||
userInput.moveLeft();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case RIGHT:
|
||||
userInput.moveRight();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case RESET:
|
||||
userInput.clear();
|
||||
result.clear();
|
||||
if (DisplayManager.error != null) {
|
||||
Utils.debug.println("Resetting after error...");
|
||||
DisplayManager.error = null;
|
||||
}
|
||||
return true;
|
||||
case SURD_MODE:
|
||||
calc.exactMode = !calc.exactMode;
|
||||
if (calc.exactMode == false) {
|
||||
calc.f2 = solveExpression(calc.f2);
|
||||
} else {
|
||||
result.clear();
|
||||
Keyboard.keyPressed(Key.SIMPLIFY);
|
||||
}
|
||||
return true;
|
||||
case debug1:
|
||||
DisplayManager.INSTANCE.setScreen(new EmptyScreen());
|
||||
return true;
|
||||
case HISTORY_BACK:
|
||||
// if (DisplayManager.INSTANCE.canGoBack()) {
|
||||
// if (currentExpression != null && currentExpression.length() > 0 & DisplayManager.sessions[DisplayManager.currentSession + 1] instanceof MathInputScreen) {
|
||||
// newExpression = currentExpression;
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// } catch (final Error e) {}
|
||||
// }
|
||||
// }
|
||||
return false;
|
||||
case HISTORY_FORWARD:
|
||||
// if (DisplayManager.INSTANCE.canGoForward()) {
|
||||
// if (currentExpression != null && currentExpression.length() > 0 & DisplayManager.sessions[DisplayManager.currentSession - 1] instanceof MathInputScreen) {
|
||||
// newExpression = currentExpression;
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// } catch (final Error e) {}
|
||||
// }
|
||||
// }
|
||||
return false;
|
||||
case debug_DEG:
|
||||
if (calc.angleMode.equals(AngleMode.DEG) == false) {
|
||||
calc.angleMode = AngleMode.DEG;
|
||||
if (userInput.isExtraOpened()) {
|
||||
userInput.closeExtra();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case debug_RAD:
|
||||
if (calc.angleMode.equals(AngleMode.RAD) == false) {
|
||||
calc.angleMode = AngleMode.RAD;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case debug_GRA:
|
||||
if (calc.angleMode.equals(AngleMode.GRA) == false) {
|
||||
calc.angleMode = AngleMode.GRA;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case DRG_CYCLE:
|
||||
if (calc.angleMode.equals(AngleMode.DEG) == true) {
|
||||
calc.angleMode = AngleMode.RAD;
|
||||
} else if (calc.angleMode.equals(AngleMode.RAD) == true) {
|
||||
calc.angleMode = AngleMode.GRA;
|
||||
} else {
|
||||
calc.angleMode = AngleMode.DEG;
|
||||
}
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
if (userInput.isExtraOpened() && userInput.getExtraKeyboardEventListener().keyPressed(k)) {
|
||||
return true;
|
||||
} else {
|
||||
switch (k) {
|
||||
|
||||
case STEP:
|
||||
// if (newExpression.length() > 0) {
|
||||
// if (firstStep) {
|
||||
// try {
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// showVariablesDialog(() -> {
|
||||
// currentExpression = newExpression;
|
||||
// calc.f2 = calc.f;
|
||||
// firstStep = false;
|
||||
// step();
|
||||
// });
|
||||
// } catch (final Exception ex) {
|
||||
// if (Utils.debugOn) {
|
||||
// ex.printStackTrace();
|
||||
// }
|
||||
// throw new Error(Errors.SYNTAX_ERROR);
|
||||
// }
|
||||
// } catch (final Error e) {
|
||||
// final StringWriter sw = new StringWriter();
|
||||
// final PrintWriter pw = new PrintWriter(sw);
|
||||
// e.printStackTrace(pw);
|
||||
// d.errorStackTrace = sw.toString().toUpperCase().replace("\t", " ").replace("\r", "").split("\n");
|
||||
// DisplayManager.error = e.id.toString();
|
||||
// System.err.println(e.id);
|
||||
// }
|
||||
// } else {
|
||||
// step();
|
||||
// }
|
||||
// }
|
||||
// return true;
|
||||
case SIMPLIFY:
|
||||
if (DisplayManager.error != null) {
|
||||
//TODO: make the error management a global API rather than being relegated to this screen.
|
||||
Utils.debug.println("Resetting after error...");
|
||||
DisplayManager.error = null;
|
||||
calc.f = null;
|
||||
calc.f2 = null;
|
||||
calc.resultsCount = 0;
|
||||
return true;
|
||||
} else {
|
||||
try {
|
||||
try {
|
||||
if (!userInput.isAlreadyParsed() && !userInput.isEmpty()) {
|
||||
Expression expr = MathParser.parseInput(calc, userInput);
|
||||
if (calc.f == null | calc.f2 == null) {
|
||||
calc.f = new ObjectArrayList<>();
|
||||
calc.f2 = new ObjectArrayList<>();
|
||||
} else {
|
||||
calc.f.clear();
|
||||
calc.f2.clear();
|
||||
}
|
||||
calc.f.add(expr);
|
||||
ObjectArrayList<Function> resultExpression = expr.solve();
|
||||
ObjectArrayList<Block> resultBlocks = MathParser.parseOutput(calc, resultExpression);
|
||||
result.setContent(resultBlocks);
|
||||
// showVariablesDialog(() -> {
|
||||
// currentExpression = newExpression;
|
||||
// simplify();
|
||||
// });
|
||||
}
|
||||
} catch (final Exception ex) {
|
||||
if (Utils.debugOn) {
|
||||
ex.printStackTrace();
|
||||
}
|
||||
throw new Error(Errors.SYNTAX_ERROR);
|
||||
}
|
||||
} catch (final Error e) {
|
||||
final StringWriter sw = new StringWriter();
|
||||
final PrintWriter pw = new PrintWriter(sw);
|
||||
e.printStackTrace(pw);
|
||||
d.errorStackTrace = sw.toString().toUpperCase().replace("\t", " ").replace("\r", "").split("\n");
|
||||
DisplayManager.error = e.id.toString();
|
||||
System.err.println(e.id);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
case NUM0:
|
||||
typeChar('0');
|
||||
return true;
|
||||
case NUM1:
|
||||
typeChar('1');
|
||||
return true;
|
||||
case NUM2:
|
||||
typeChar('2');
|
||||
return true;
|
||||
case NUM3:
|
||||
typeChar('3');
|
||||
return true;
|
||||
case NUM4:
|
||||
typeChar('4');
|
||||
return true;
|
||||
case NUM5:
|
||||
typeChar('5');
|
||||
return true;
|
||||
case NUM6:
|
||||
typeChar('6');
|
||||
return true;
|
||||
case NUM7:
|
||||
typeChar('7');
|
||||
return true;
|
||||
case NUM8:
|
||||
typeChar('8');
|
||||
return true;
|
||||
case NUM9:
|
||||
typeChar('9');
|
||||
return true;
|
||||
case PLUS:
|
||||
typeChar('+');
|
||||
return true;
|
||||
case MINUS:
|
||||
typeChar('-');
|
||||
return true;
|
||||
case PLUS_MINUS:
|
||||
typeChar('±');
|
||||
return true;
|
||||
case MULTIPLY:
|
||||
typeChar('*');
|
||||
return true;
|
||||
case DIVIDE:
|
||||
typeChar('/');
|
||||
return true;
|
||||
case PARENTHESIS_OPEN:
|
||||
typeChar('(');
|
||||
return true;
|
||||
case PARENTHESIS_CLOSE:
|
||||
typeChar(')');
|
||||
return true;
|
||||
case DOT:
|
||||
typeChar('.');
|
||||
return true;
|
||||
case EQUAL:
|
||||
typeChar('=');
|
||||
return true;
|
||||
case SQRT:
|
||||
typeChar('Ⓐ');
|
||||
return true;
|
||||
case ROOT:
|
||||
typeChar('√');
|
||||
return true;
|
||||
case POWER_OF_2:
|
||||
typeChar(MathematicalSymbols.POWER_OF_TWO);
|
||||
return true;
|
||||
case POWER_OF_x:
|
||||
typeChar(MathematicalSymbols.POWER);
|
||||
return true;
|
||||
case PI:
|
||||
typeChar(MathematicalSymbols.PI);
|
||||
return true;
|
||||
case LETTER_X:
|
||||
typeChar(MathematicalSymbols.variables[23]);
|
||||
return true;
|
||||
case LETTER_Y:
|
||||
typeChar(MathematicalSymbols.variables[24]);
|
||||
return true;
|
||||
case SINE:
|
||||
typeChar(MathematicalSymbols.SINE);
|
||||
return true;
|
||||
case COSINE:
|
||||
typeChar(MathematicalSymbols.COSINE);
|
||||
return true;
|
||||
case TANGENT:
|
||||
typeChar(MathematicalSymbols.TANGENT);
|
||||
return true;
|
||||
case ARCSINE:
|
||||
typeChar(MathematicalSymbols.ARC_SINE);
|
||||
return true;
|
||||
case ARCCOSINE:
|
||||
typeChar(MathematicalSymbols.ARC_COSINE);
|
||||
return true;
|
||||
case ARCTANGENT:
|
||||
typeChar(MathematicalSymbols.ARC_TANGENT);
|
||||
return true;
|
||||
case DELETE:
|
||||
userInput.del();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case LEFT:
|
||||
userInput.moveLeft();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case RIGHT:
|
||||
userInput.moveRight();
|
||||
mustRefresh = true;
|
||||
return true;
|
||||
case RESET:
|
||||
userInput.clear();
|
||||
result.clear();
|
||||
if (DisplayManager.error != null) {
|
||||
Utils.debug.println("Resetting after error...");
|
||||
DisplayManager.error = null;
|
||||
}
|
||||
return true;
|
||||
case SURD_MODE:
|
||||
calc.exactMode = !calc.exactMode;
|
||||
if (calc.exactMode == false) {
|
||||
calc.f2 = solveExpression(calc.f2);
|
||||
} else {
|
||||
result.clear();
|
||||
Keyboard.keyPressed(Key.SIMPLIFY);
|
||||
}
|
||||
return true;
|
||||
case debug1:
|
||||
DisplayManager.INSTANCE.setScreen(new EmptyScreen());
|
||||
return true;
|
||||
case HISTORY_BACK:
|
||||
// if (DisplayManager.INSTANCE.canGoBack()) {
|
||||
// if (currentExpression != null && currentExpression.length() > 0 & DisplayManager.sessions[DisplayManager.currentSession + 1] instanceof MathInputScreen) {
|
||||
// newExpression = currentExpression;
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// } catch (final Error e) {}
|
||||
// }
|
||||
// }
|
||||
return false;
|
||||
case HISTORY_FORWARD:
|
||||
// if (DisplayManager.INSTANCE.canGoForward()) {
|
||||
// if (currentExpression != null && currentExpression.length() > 0 & DisplayManager.sessions[DisplayManager.currentSession - 1] instanceof MathInputScreen) {
|
||||
// newExpression = currentExpression;
|
||||
// try {
|
||||
// interpreta(true);
|
||||
// } catch (final Error e) {}
|
||||
// }
|
||||
// }
|
||||
return false;
|
||||
case debug_DEG:
|
||||
if (calc.angleMode.equals(AngleMode.DEG) == false) {
|
||||
calc.angleMode = AngleMode.DEG;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case debug_RAD:
|
||||
if (calc.angleMode.equals(AngleMode.RAD) == false) {
|
||||
calc.angleMode = AngleMode.RAD;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case debug_GRA:
|
||||
if (calc.angleMode.equals(AngleMode.GRA) == false) {
|
||||
calc.angleMode = AngleMode.GRA;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
case DRG_CYCLE:
|
||||
if (calc.angleMode.equals(AngleMode.DEG) == true) {
|
||||
calc.angleMode = AngleMode.RAD;
|
||||
} else if (calc.angleMode.equals(AngleMode.RAD) == true) {
|
||||
calc.angleMode = AngleMode.GRA;
|
||||
} else {
|
||||
calc.angleMode = AngleMode.DEG;
|
||||
}
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -524,7 +542,18 @@ public class MathInputScreen extends Screen {
|
|||
|
||||
@Override
|
||||
public boolean keyReleased(Key k) {
|
||||
return false;
|
||||
if (k == Key.OK) {
|
||||
return true;
|
||||
} else {
|
||||
if (userInput.isExtraOpened() && userInput.getExtraKeyboardEventListener().keyReleased(k)) {
|
||||
return true;
|
||||
} else {
|
||||
switch (k) {
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void showVariablesDialog() {
|
||||
|
|
@ -585,7 +614,7 @@ public class MathInputScreen extends Screen {
|
|||
} else if (f instanceof FunctionSingle) {
|
||||
res.addAll(getKnownVariables(new Function[] { ((FunctionSingle) f).getParameter() }));
|
||||
} else if (f instanceof Variable) {
|
||||
if (((Variable) f).getType() == Variable.V_TYPE.KNOWN) {
|
||||
if (((Variable) f).getType() == Variable.V_TYPE.COEFFICIENT) {
|
||||
if (!res.contains(f)) {
|
||||
res.add(f);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
package org.warp.picalculator.gui.screens;
|
||||
|
||||
import org.warp.picalculator.device.KeyboardEventListener;
|
||||
import org.warp.picalculator.device.Keyboard.Key;
|
||||
import org.warp.picalculator.gui.DisplayManager;
|
||||
|
||||
public abstract class Screen {
|
||||
public abstract class Screen implements KeyboardEventListener {
|
||||
public DisplayManager d;
|
||||
public boolean created = false;
|
||||
public boolean initialized = false;
|
||||
|
|
@ -38,8 +39,4 @@ public abstract class Screen {
|
|||
public abstract void beforeRender(float dt);
|
||||
|
||||
public abstract boolean mustBeRefreshed();
|
||||
|
||||
public abstract boolean keyPressed(Key k);
|
||||
|
||||
public abstract boolean keyReleased(Key k);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ public class Variable implements Function {
|
|||
|
||||
protected char var;
|
||||
protected final MathContext root;
|
||||
protected V_TYPE type = V_TYPE.KNOWN;
|
||||
protected V_TYPE type = V_TYPE.COEFFICIENT;
|
||||
|
||||
public Variable(MathContext root, char val, V_TYPE type) {
|
||||
this.root = root;
|
||||
|
|
@ -90,7 +90,7 @@ public class Variable implements Function {
|
|||
}
|
||||
|
||||
public static enum V_TYPE {
|
||||
KNOWN, UNKNOWN, SOLUTION
|
||||
COEFFICIENT, UNKNOWN, SOLUTION
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
Loading…
Reference in New Issue