Initial commit

1 files changed, 232 insertions, 0 deletions

diff --git a/NET/worlds/console/GammaFrameState.java b/NET/worlds/console/GammaFrameState.java
new file mode 100644
index 0000000..16497a6
--- /dev/null
+++ b/NET/worlds/console/GammaFrameState.java
@@ -0,0 +1,232 @@
+package NET.worlds.console;
+
+import NET.worlds.core.IniFile;
+import java.awt.Dimension;
+import java.awt.Point;
+import java.awt.Toolkit;
+import java.util.StringTokenizer;
+
+public class GammaFrameState implements MainCallback {
+   private static final int defaultWidth = 568;
+   private static final int defaultHeight = 424;
+   private static final int minimumWidth = 142;
+   private static final int minimumHeight = 106;
+   private static int[] frameState = new int[5];
+   private static GammaFrame frame;
+   private static int handle;
+   private static String borderKey;
+   private static final String layoutKey = "ShaperLayout";
+   private static final String modeKey = "ChangeVideoMode";
+   private static final float scale = 100.0F;
+   private boolean initMaximized;
+   private int[] videoMode;
+
+   GammaFrameState(GammaFrame f) {
+      frame = f;
+      if (borderKey == null) {
+         borderKey = Gamma.shaperEnabled() ? "ShaperWindow" : "Window";
+      }
+
+      this.restoreBorder();
+      int[] mode = new int[2];
+      if (strToInts(IniFile.gamma().getIniString("ChangeVideoMode", ""), mode) == 2) {
+         this.videoMode = mode;
+      }
+
+      Main.register(this);
+   }
+
+   public static void saveBorder() {
+      int state;
+      if (handle != 0 && !isIconic(state = getFrameState())) {
+         Point loc = frame.getLocation();
+         Dimension size = new Dimension(Window.getWindowWidth(handle), Window.getWindowHeight(handle));
+         int[] newState = new int[frameState.length];
+         if (!isMaximized(newState[4] = state)) {
+            newState[0] = loc.x;
+            newState[1] = loc.y;
+            newState[2] = size.width;
+            newState[3] = size.height;
+         } else {
+            for (int i = 0; i < 4; i++) {
+               newState[i] = frameState[i];
+            }
+         }
+
+         for (int i = 0; i < frameState.length; i++) {
+            if (newState[i] != frameState[i]) {
+               IniFile var10000 = IniFile.gamma();
+               String var10001 = makeKey(borderKey);
+               frameState = newState;
+               var10000.setIniString(var10001, intsToStr(newState));
+               break;
+            }
+         }
+      }
+   }
+
+   private void restoreBorder() {
+      if (strToInts(IniFile.gamma().getIniString(makeKey(borderKey), ""), frameState) == 5) {
+         if (frameState[0] >= 0 && frameState[2] >= 142 && frameState[1] >= 0 && frameState[3] >= 106) {
+            if (isMaximized(frameState[4])) {
+               this.initMaximized = true;
+            } else {
+               frameState[4] = 0;
+               this.initMaximized = false;
+            }
+
+            frame.reshape(frameState[0], frameState[1], frameState[2], frameState[3]);
+         } else {
+            this.makeDefaultBorder();
+         }
+      } else {
+         this.makeDefaultBorder();
+      }
+   }
+
+   private void makeDefaultBorder() {
+      Dimension size = getScreenSize();
+      int dx = size.width - 568;
+      int dy = size.height - 424;
+      if (dx <= 0) {
+         dx = 0;
+      } else {
+         dx /= 2;
+      }
+
+      if (dy <= 0) {
+         dy = 0;
+      } else {
+         dy /= 2;
+      }
+
+      frameState[0] = dx;
+      frameState[1] = dy;
+      frameState[2] = 568;
+      frameState[3] = 424;
+      frameState[4] = 0;
+      this.initMaximized = false;
+      frame.reshape(dx, dy, 568, 424);
+   }
+
+   public static void saveLayout(int[] layout, float[] divider, boolean oneTile) {
+      IniFile.gamma().setIniString(makeKey("ShaperLayout"), intsToStr(layout) + " " + floatsToStr(divider) + " " + (oneTile ? "0" : "1"));
+   }
+
+   public static boolean restoreLayout(int[] argLayout, float[] argDivider) {
+      int[] layout = new int[argLayout.length];
+      float[] divider = new float[argDivider.length];
+      int[] tmp = new int[layout.length + divider.length + 1];
+      tmp[layout.length + divider.length] = 0;
+      if (strToInts(IniFile.gamma().getIniString(makeKey("ShaperLayout"), ""), tmp) < layout.length + divider.length) {
+         return true;
+      } else {
+         int[] used = new int[layout.length];
+
+         for (int i = 0; i < layout.length; i++) {
+            try {
+               used[layout[i] = tmp[i]]++;
+            } catch (ArrayIndexOutOfBoundsException var8) {
+               return true;
+            }
+         }
+
+         for (int i = 0; i < layout.length; i++) {
+            if (used[i] != 1) {
+               return true;
+            }
+         }
+
+         for (int ix = 0; ix < divider.length; ix++) {
+            float f = tmp[ix + layout.length] / 100.0F;
+            if (f < 0.0F || f > 1.0F) {
+               return true;
+            }
+
+            divider[ix] = f;
+         }
+
+         System.arraycopy(layout, 0, argLayout, 0, argLayout.length);
+         System.arraycopy(divider, 0, argDivider, 0, argDivider.length);
+         return tmp[layout.length + divider.length] == 0;
+      }
+   }
+
+   private static int getFrameState() {
+      return Window.getWindowState(handle);
+   }
+
+   public static boolean isIconic() {
+      return handle != 0 ? isIconic(getFrameState()) : false;
+   }
+
+   private static boolean isIconic(int state) {
+      return state == 1;
+   }
+
+   private static boolean isMaximized(int state) {
+      return state == 2;
+   }
+
+   private static Dimension getScreenSize() {
+      return Toolkit.getDefaultToolkit().getScreenSize();
+   }
+
+   private static String makeKey(String prefix) {
+      Dimension screenSize = getScreenSize();
+      return prefix + screenSize.width + "X" + screenSize.height;
+   }
+
+   private static String intsToStr(int[] arr) {
+      String s = "" + arr[0];
+
+      for (int i = 1; i < arr.length; i++) {
+         s = s + " " + arr[i];
+      }
+
+      return s;
+   }
+
+   private static String floatsToStr(float[] arr) {
+      int[] iarr = new int[arr.length];
+
+      for (int i = 0; i < arr.length; i++) {
+         iarr[i] = (int)(arr[i] * 100.0F);
+      }
+
+      return intsToStr(iarr);
+   }
+
+   private static int strToInts(String s, int[] arr) {
+      if (s == null) {
+         return 0;
+      } else {
+         StringTokenizer tok = new StringTokenizer(s, " ");
+
+         int i;
+         for (i = 0; i < arr.length && tok.hasMoreTokens(); i++) {
+            try {
+               arr[i] = Integer.parseInt(tok.nextToken());
+            } catch (NumberFormatException var5) {
+               break;
+            }
+         }
+
+         return i;
+      }
+   }
+
+   @Override
+   public void mainCallback() {
+      handle = Window.findWindow(frame.getTitle());
+      if (handle != 0) {
+         if (this.videoMode != null) {
+            Window.setVideoMode(handle, this.videoMode[0], this.videoMode[1]);
+         } else if (this.initMaximized) {
+            Window.setWindowState(handle, 2);
+         }
+
+         Main.unregister(this);
+      }
+   }
+}