494 lines
15 KiB
Java
494 lines
15 KiB
Java
|
package org.warp.picalculator.gui;
|
||
|
|
||
|
import java.io.IOException;
|
||
|
import java.lang.management.ManagementFactory;
|
||
|
import java.lang.management.OperatingSystemMXBean;
|
||
|
import java.lang.reflect.Method;
|
||
|
import java.lang.reflect.Modifier;
|
||
|
import java.util.ArrayList;
|
||
|
|
||
|
import org.warp.picalculator.Main;
|
||
|
import org.warp.picalculator.Utils;
|
||
|
import org.warp.picalculator.device.Keyboard;
|
||
|
import org.warp.picalculator.gui.graphicengine.Display;
|
||
|
import org.warp.picalculator.gui.graphicengine.Drawable;
|
||
|
import org.warp.picalculator.gui.graphicengine.Renderer;
|
||
|
import org.warp.picalculator.gui.graphicengine.cpu.CPUDisplay;
|
||
|
import org.warp.picalculator.gui.graphicengine.gpu.GPUDisplay;
|
||
|
import org.warp.picalculator.gui.graphicengine.RAWFont;
|
||
|
import org.warp.picalculator.gui.graphicengine.RAWSkin;
|
||
|
import org.warp.picalculator.gui.screens.Screen;
|
||
|
|
||
|
import com.pi4j.wiringpi.Gpio;
|
||
|
|
||
|
public final class DisplayManager implements Drawable {
|
||
|
public static DisplayManager INSTANCE;
|
||
|
private static float brightness;
|
||
|
|
||
|
public static final Display display = chooseGraphicEngine();
|
||
|
public static Renderer renderer;
|
||
|
|
||
|
private static RAWSkin skin;
|
||
|
public static RAWFont[] fonts;
|
||
|
|
||
|
public static String error = null;
|
||
|
public String[] errorStackTrace = null;
|
||
|
public final static int[] glyphsHeight = new int[] { 9, 6, 12, 9 };
|
||
|
|
||
|
public static Screen screen;
|
||
|
public static String displayDebugString = "";
|
||
|
|
||
|
public DisplayManager(Screen screen) {
|
||
|
setScreen(screen);
|
||
|
INSTANCE = this;
|
||
|
loop();
|
||
|
}
|
||
|
/*
|
||
|
* private void load_skin() {
|
||
|
* try {
|
||
|
* skin_tex = glGenTextures();
|
||
|
* glBindTexture(GL_TEXTURE_2D, skin_tex);
|
||
|
* glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||
|
*
|
||
|
* InputStream in = new FileInputStream("skin.png");
|
||
|
* PNGDecoder decoder = new PNGDecoder(in);
|
||
|
*
|
||
|
* System.out.println("width="+decoder.getWidth());
|
||
|
* System.out.println("height="+decoder.getHeight());
|
||
|
*
|
||
|
* ByteBuffer buf =
|
||
|
* ByteBuffer.allocateDirect(4*decoder.getWidth()*decoder.getHeight());
|
||
|
* decoder.decode(buf, decoder.getWidth()*4, Format.RGBA);
|
||
|
* buf.flip();
|
||
|
*
|
||
|
* skin = buf;
|
||
|
* skin_w = decoder.getWidth();
|
||
|
* skin_h = decoder.getHeight();
|
||
|
* glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, skin_w,
|
||
|
* skin_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, skin);
|
||
|
* } catch (IOException ex) {
|
||
|
* ex.printStackTrace();
|
||
|
* }
|
||
|
* }
|
||
|
*/
|
||
|
|
||
|
private static Display chooseGraphicEngine() {
|
||
|
Display d;
|
||
|
d = new GPUDisplay();
|
||
|
if (d.isSupported()) return d;
|
||
|
d = new CPUDisplay();
|
||
|
if (d.isSupported()) return d;
|
||
|
throw new UnsupportedOperationException("No graphic engines available.");
|
||
|
}
|
||
|
|
||
|
public void setScreen(Screen screen) {
|
||
|
if (screen.initialized == false) {
|
||
|
if (screen.canBeInHistory) {
|
||
|
DisplayManager.currentSession = 0;
|
||
|
for (int i = DisplayManager.sessions.length - 1; i >= 1; i--) {
|
||
|
DisplayManager.sessions[i] = DisplayManager.sessions[i - 1];
|
||
|
}
|
||
|
DisplayManager.sessions[0] = screen;
|
||
|
} else {
|
||
|
DisplayManager.currentSession = -1;
|
||
|
}
|
||
|
}
|
||
|
screen.d = this;
|
||
|
try {
|
||
|
screen.create();
|
||
|
DisplayManager.screen = screen;
|
||
|
if (screen.initialized == false) {
|
||
|
screen.initialize();
|
||
|
}
|
||
|
} catch (final Exception e) {
|
||
|
e.printStackTrace();
|
||
|
System.exit(0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public void replaceScreen(Screen screen) {
|
||
|
if (screen.initialized == false) {
|
||
|
if (screen.canBeInHistory) {
|
||
|
DisplayManager.sessions[DisplayManager.currentSession] = screen;
|
||
|
} else {
|
||
|
DisplayManager.currentSession = -1;
|
||
|
for (int i = 0; i < DisplayManager.sessions.length - 2; i++) {
|
||
|
DisplayManager.sessions[i] = DisplayManager.sessions[i + 1];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
screen.d = this;
|
||
|
try {
|
||
|
screen.create();
|
||
|
DisplayManager.screen = screen;
|
||
|
if (screen.initialized == false) {
|
||
|
screen.initialize();
|
||
|
}
|
||
|
} catch (final Exception e) {
|
||
|
e.printStackTrace();
|
||
|
System.exit(0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public boolean canGoBack() {
|
||
|
if (DisplayManager.currentSession == -1) {
|
||
|
return DisplayManager.sessions[0] != null;
|
||
|
}
|
||
|
if (DisplayManager.screen != DisplayManager.sessions[DisplayManager.currentSession]) {
|
||
|
|
||
|
} else if (DisplayManager.currentSession + 1 < DisplayManager.sessions.length) {
|
||
|
if (DisplayManager.sessions[DisplayManager.currentSession + 1] != null) {
|
||
|
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
if (DisplayManager.sessions[DisplayManager.currentSession] != null) {
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
public void goBack() {
|
||
|
if (canGoBack()) {
|
||
|
if (DisplayManager.currentSession >= 0 && DisplayManager.screen != DisplayManager.sessions[DisplayManager.currentSession]) {} else {
|
||
|
DisplayManager.currentSession += 1;
|
||
|
}
|
||
|
DisplayManager.screen = DisplayManager.sessions[DisplayManager.currentSession];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public boolean canGoForward() {
|
||
|
if (DisplayManager.currentSession <= 0) { // -1 e 0
|
||
|
return false;
|
||
|
}
|
||
|
if (DisplayManager.screen != DisplayManager.sessions[DisplayManager.currentSession]) {
|
||
|
|
||
|
} else if (DisplayManager.currentSession > 0) {
|
||
|
if (DisplayManager.sessions[DisplayManager.currentSession - 1] != null) {
|
||
|
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
if (DisplayManager.sessions[DisplayManager.currentSession] != null) {
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
public void goForward() {
|
||
|
if (canGoForward()) {
|
||
|
if (DisplayManager.screen != DisplayManager.sessions[DisplayManager.currentSession]) {
|
||
|
|
||
|
} else {
|
||
|
DisplayManager.currentSession -= 1;
|
||
|
}
|
||
|
DisplayManager.screen = DisplayManager.sessions[DisplayManager.currentSession];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public Screen getScreen() {
|
||
|
return DisplayManager.screen;
|
||
|
}
|
||
|
|
||
|
private void load_skin() throws IOException {
|
||
|
skin = display.loadSkin("skin.png");
|
||
|
}
|
||
|
|
||
|
private void load_fonts() throws IOException {
|
||
|
fonts = new RAWFont[7];
|
||
|
fonts[0] = display.loadFont("big");
|
||
|
fonts[1] = display.loadFont("small");
|
||
|
fonts[2] = display.loadFont("ex");
|
||
|
fonts[3] = display.loadFont("big");
|
||
|
fonts[4] = display.loadFont("32");
|
||
|
fonts[5] = display.loadFont("square");
|
||
|
}
|
||
|
|
||
|
private void draw_init() {
|
||
|
renderer.glClear(display.getWidth(), display.getHeight());
|
||
|
}
|
||
|
|
||
|
private void draw_status() {
|
||
|
renderer.glColor(0xFFc5c2af);
|
||
|
renderer.glFillColor(0, 0, display.getWidth(), 20);
|
||
|
renderer.glColor3i(0, 0, 0);
|
||
|
renderer.glDrawLine(0, 20, display.getWidth() - 1, 20);
|
||
|
renderer.glColor3i(255, 255, 255);
|
||
|
skin.use(display);
|
||
|
if (Keyboard.shift) {
|
||
|
renderer.glFillRect(2 + 18 * 0, 2, 16, 16, 16 * 2, 16 * 0, 16, 16);
|
||
|
} else {
|
||
|
renderer.glFillRect(2 + 18 * 0, 2, 16, 16, 16 * 3, 16 * 0, 16, 16);
|
||
|
}
|
||
|
if (Keyboard.alpha) {
|
||
|
renderer.glFillRect(2 + 18 * 1, 2, 16, 16, 16 * 0, 16 * 0, 16, 16);
|
||
|
} else {
|
||
|
renderer.glFillRect(2 + 18 * 1, 2, 16, 16, 16 * 1, 16 * 0, 16, 16);
|
||
|
}
|
||
|
/*
|
||
|
if (Calculator.angleMode == AngleMode.DEG) {
|
||
|
drawSkinPart(8 + 18 * 2, 2, 16 * 4, 16 * 0, 16 + 16 * 4, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 3, 2, 16 * 7, 16 * 0, 16 + 16 * 7, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 4, 2, 16 * 9, 16 * 0, 16 + 16 * 9, 16 + 16 * 0);
|
||
|
} else if (Calculator.angleMode == AngleMode.RAD) {
|
||
|
drawSkinPart(8 + 18 * 2, 2, 16 * 5, 16 * 0, 16 + 16 * 5, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 3, 2, 16 * 6, 16 * 0, 16 + 16 * 6, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 4, 2, 16 * 9, 16 * 0, 16 + 16 * 9, 16 + 16 * 0);
|
||
|
} else if (Calculator.angleMode == AngleMode.GRA) {
|
||
|
drawSkinPart(8 + 18 * 2, 2, 16 * 5, 16 * 0, 16 + 16 * 5, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 3, 2, 16 * 7, 16 * 0, 16 + 16 * 7, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 4, 2, 16 * 8, 16 * 0, 16 + 16 * 8, 16 + 16 * 0);
|
||
|
} else {
|
||
|
drawSkinPart(8 + 18 * 2, 2, 16 * 5, 16 * 0, 16 + 16 * 5, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 3, 2, 16 * 7, 16 * 0, 16 + 16 * 7, 16 + 16 * 0);
|
||
|
drawSkinPart(8 + 18 * 4, 2, 16 * 9, 16 * 0, 16 + 16 * 9, 16 + 16 * 0);
|
||
|
}*/
|
||
|
|
||
|
int padding = 2;
|
||
|
|
||
|
final int brightness = (int) (Math.ceil(DisplayManager.brightness * 9));
|
||
|
if (brightness <= 10) {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * brightness, 16 * 1, 16, 16);
|
||
|
} else {
|
||
|
Utils.debug.println("Brightness error");
|
||
|
}
|
||
|
|
||
|
padding += 18 + 6;
|
||
|
|
||
|
final boolean canGoBack = canGoBack();
|
||
|
final boolean canGoForward = canGoForward();
|
||
|
|
||
|
if (Main.haxMode) {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * 18, 16 * 0, 16, 16);
|
||
|
padding += 18 + 6;
|
||
|
}
|
||
|
|
||
|
if (canGoBack && canGoForward) {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * 14, 16 * 0, 16, 16);
|
||
|
} else if (canGoBack) {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * 15, 16 * 0, 16, 16);
|
||
|
} else if (canGoForward) {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * 16, 16 * 0, 16, 16);
|
||
|
} else {
|
||
|
renderer.glFillRect(Main.screenSize[0] - (padding + 16), 2, 16, 16, 16 * 17, 16 * 0, 16, 16);
|
||
|
}
|
||
|
|
||
|
padding += 18;
|
||
|
|
||
|
screen.renderStatusbar();
|
||
|
}
|
||
|
|
||
|
private void draw_screen() {
|
||
|
screen.render();
|
||
|
}
|
||
|
|
||
|
private void draw_bottom() {
|
||
|
renderer.glDrawStringLeft(2, 90, displayDebugString);
|
||
|
|
||
|
Utils.getFont(false, true).use(DisplayManager.display);
|
||
|
DisplayManager.renderer.glColor4i(255, 0, 0, 40);
|
||
|
DisplayManager.renderer.glDrawStringLeft(5 + 1, Main.screenSize[1] - 20 + 1, "WORK IN PROGRESS.");
|
||
|
DisplayManager.renderer.glColor4i(255, 0, 0, 80);
|
||
|
DisplayManager.renderer.glDrawStringLeft(5, Main.screenSize[1] - 20, "WORK IN PROGRESS.");
|
||
|
}
|
||
|
|
||
|
private void draw_world() {
|
||
|
renderer.glColor3i(255, 255, 255);
|
||
|
|
||
|
if (error != null) {
|
||
|
Utils.getFont(false, false).use(display);
|
||
|
renderer.glColor3i(129, 28, 22);
|
||
|
renderer.glDrawStringRight(Main.screenSize[0] - 2, Main.screenSize[1] - DisplayManager.glyphsHeight[1] - 2, "ANDREA CAVALLI'S CALCULATOR");
|
||
|
renderer.glColor3i(149, 32, 26);
|
||
|
renderer.glDrawStringCenter((Main.screenSize[0] / 2), 22, error);
|
||
|
renderer.glColor3i(164, 34, 28);
|
||
|
int i = 22;
|
||
|
for (final String stackPart : errorStackTrace) {
|
||
|
renderer.glDrawStringLeft(2, 22 + i, stackPart);
|
||
|
i += 11;
|
||
|
}
|
||
|
fonts[0].use(display);
|
||
|
renderer.glColor3i(129, 28, 22);
|
||
|
renderer.glDrawStringCenter((Main.screenSize[0] / 2), 11, "UNEXPECTED EXCEPTION");
|
||
|
} else {
|
||
|
fonts[0].use(display);
|
||
|
draw_screen();
|
||
|
draw_status();
|
||
|
draw_bottom();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private void draw() {
|
||
|
draw_init();
|
||
|
draw_world();
|
||
|
}
|
||
|
|
||
|
private long precTime = -1;
|
||
|
|
||
|
@Override
|
||
|
public void refresh() {
|
||
|
float dt = 0;
|
||
|
final long newtime = System.nanoTime();
|
||
|
if (precTime == -1) {
|
||
|
dt = 0;
|
||
|
} else {
|
||
|
dt = (float) ((newtime - precTime) / 1000000000d);
|
||
|
}
|
||
|
precTime = newtime;
|
||
|
/*
|
||
|
* Calcoli
|
||
|
*/
|
||
|
checkDisplayResized();
|
||
|
|
||
|
screen.beforeRender(dt);
|
||
|
|
||
|
if (dt >= 0.03 || screen.mustBeRefreshed()) {
|
||
|
draw();
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
private void checkDisplayResized() {
|
||
|
if (display.wasResized()) {
|
||
|
Main.screenSize[0] = display.getWidth();
|
||
|
Main.screenSize[1] = display.getHeight();
|
||
|
}
|
||
|
};
|
||
|
|
||
|
public void loop() {
|
||
|
try {
|
||
|
load_skin();
|
||
|
load_fonts();
|
||
|
display.create();
|
||
|
renderer = display.getRenderer();
|
||
|
|
||
|
try {
|
||
|
screen.initialize();
|
||
|
} catch (final Exception e) {
|
||
|
e.printStackTrace();
|
||
|
System.exit(0);
|
||
|
}
|
||
|
|
||
|
//Debug thread
|
||
|
Thread dbgthrd = new Thread(() -> {
|
||
|
try {
|
||
|
while (true) {
|
||
|
for (int i = 0; i < 10; i++) {
|
||
|
System.out.println("============");
|
||
|
OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
|
||
|
for (Method method : operatingSystemMXBean.getClass().getDeclaredMethods()) {
|
||
|
method.setAccessible(true);
|
||
|
if (method.getName().startsWith("get") && Modifier.isPublic(method.getModifiers())) {
|
||
|
Object value;
|
||
|
try {
|
||
|
value = method.invoke(operatingSystemMXBean);
|
||
|
} catch (Exception e) {
|
||
|
value = e;
|
||
|
} // try
|
||
|
boolean percent = false;
|
||
|
boolean mb = false;
|
||
|
String displayName = method.getName();
|
||
|
String displayValue = value.toString();
|
||
|
if (displayName.endsWith("CpuLoad")) {
|
||
|
percent = true;
|
||
|
}
|
||
|
if (displayName.endsWith("MemorySize")) {
|
||
|
mb = true;
|
||
|
}
|
||
|
ArrayList<String> arr = new ArrayList<>();
|
||
|
arr.add("getFreePhysicalMemorySize");
|
||
|
arr.add("getProcessCpuLoad");
|
||
|
arr.add("getSystemCpuLoad");
|
||
|
arr.add("getTotalPhysicalMemorySize");
|
||
|
if (arr.contains(displayName)) {
|
||
|
if (percent) {
|
||
|
try {
|
||
|
System.out.println(displayName + " = " + (((int)(Float.parseFloat(displayValue) * 10000f))/100f) + "%");
|
||
|
}catch(Exception ex) {
|
||
|
System.out.println(displayName + " = " + displayValue);
|
||
|
}
|
||
|
} else if (mb) {
|
||
|
try {
|
||
|
System.out.println(displayName + " = " + (Long.parseLong(displayValue) / 1024L / 1024L) + " MB");
|
||
|
}catch(Exception ex) {
|
||
|
System.out.println(displayName + " = " + displayValue);
|
||
|
}
|
||
|
} else {
|
||
|
System.out.println(displayName + " = " + displayValue);
|
||
|
}
|
||
|
}
|
||
|
} // if
|
||
|
} // for
|
||
|
System.out.println("============");
|
||
|
Thread.sleep(5000);
|
||
|
}
|
||
|
}
|
||
|
} catch (final InterruptedException e) {
|
||
|
// TODO Auto-generated catch block
|
||
|
e.printStackTrace();
|
||
|
}
|
||
|
});
|
||
|
dbgthrd.setDaemon(true);
|
||
|
dbgthrd.setName("Debug performance thread");
|
||
|
dbgthrd.start();
|
||
|
|
||
|
display.start(this);
|
||
|
|
||
|
display.waitUntilExit();
|
||
|
} catch (final Exception ex) {
|
||
|
ex.printStackTrace();
|
||
|
} finally {}
|
||
|
}
|
||
|
|
||
|
public static void changeBrightness(float change) {
|
||
|
setBrightness(brightness + change);
|
||
|
}
|
||
|
|
||
|
public static void setBrightness(float newval) {
|
||
|
if (newval >= 0 && newval <= 1) {
|
||
|
brightness = newval;
|
||
|
if (Utils.debugOn == false) {
|
||
|
Gpio.pwmWrite(12, (int) Math.ceil(brightness * 1024));
|
||
|
// SoftPwm.softPwmWrite(12, (int)(Math.ceil(brightness*10)));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public static void cycleBrightness(boolean reverse) {
|
||
|
final float step = reverse ? -0.1f : 0.1f;
|
||
|
if (brightness + step > 1f) {
|
||
|
setBrightness(0f);
|
||
|
} else if (brightness + step <= 0f) {
|
||
|
setBrightness(1.0f);
|
||
|
} else {
|
||
|
changeBrightness(step);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public static float getBrightness() {
|
||
|
return brightness;
|
||
|
}
|
||
|
|
||
|
public static int currentSession = 0;
|
||
|
public static Screen[] sessions = new Screen[5];
|
||
|
|
||
|
@Deprecated
|
||
|
public static void colore(float f1, float f2, float f3, float f4) {
|
||
|
renderer.glColor4f(f1,f2,f3,f4);
|
||
|
}
|
||
|
|
||
|
public static Drawable getDrawable() {
|
||
|
return INSTANCE;
|
||
|
}
|
||
|
|
||
|
@Deprecated
|
||
|
public static void drawSkinPart(int x, int y, int uvX, int uvY, int uvX2, int uvY2) {
|
||
|
renderer.glFillRect(x, y, uvX2-uvX, uvY2-uvY, uvX, uvY, uvX2-uvX, uvY2-uvY);
|
||
|
}
|
||
|
}
|