Merge pull request #30 from HaleyWang/develop

fix bug

build.gradle

@@ -64,6 +64,7 @@ dependencies {
     compile 'com.formdev:flatlaf:0.22'
 
     compile 'org.swinglabs:swingx:1.6.1'
+    implementation 'javax.annotation:javax.annotation-api:1.3.2'
 
 
 

src/main/java/com/haleywang/putty/util/FontUtilities.java

@@ -1,6 +1,6 @@
 package com.haleywang.putty.util;
 
-import sun.swing.SwingLazyValue;
+import com.SwingLazyValue;
 
 import javax.swing.UIManager;
 import java.awt.Font;

src/main/java/com/haleywang/putty/view/side/SideView.java

@@ -297,12 +297,45 @@ public void saveCommand() {
         SwingUtilities.invokeLater(() -> {
             String command = commandEditorPanel.getUpdateCommandTextArea().getText();
             String commandName = commandEditorPanel.getCommandNameTextField().getText();
-            commandEditorPanel.syncCommandsTree();
+
+            boolean isTmp = false;
+            String jsonPath = commandEditorPanel.getPathLb().getText();
+            String tmpPath = "Commands root/_tmp/@0";
+            System.out.println(" ======= jsonPath === " + jsonPath);
+            if (StringUtils.isBlank(jsonPath) || tmpPath.equals(jsonPath)) {
+                commandEditorPanel.getPathLb().setText(tmpPath);
+                isTmp = true;
+            } else {
+                commandEditorPanel.syncCommandsTree();
+            }
 
             Object userDataObject = ((DefaultMutableTreeNode) commandsTreePanel.getCommandsTreeView().getModel().getRoot()).getUserObject();
 
-            Gson gson = new GsonBuilder().setPrettyPrinting().create();
+            if (isTmp && userDataObject instanceof CommandDto) {
+                CommandDto rootCommandDto = (CommandDto) userDataObject;
+
+                CommandDto tmpGroup = rootCommandDto.getChildren().stream().filter(c -> "_tmp".equals(c.getName()))
+                        .findFirst().orElseGet(() -> {
+                            CommandDto tmpGroup1 = new CommandDto();
+                            tmpGroup1.setName("_tmp");
+                            tmpGroup1.addChild(new CommandDto());
+                            rootCommandDto.addChild(tmpGroup1);
+                            return tmpGroup1;
+                        });
+
+                CommandDto tmpCmd = tmpGroup.getChildren().stream().findFirst().orElseGet(() -> {
+                    CommandDto cmd = new CommandDto();
+                    tmpGroup.addChild(cmd);
+                    return cmd;
+                });
 
+                tmpCmd.setName(commandName);
+                tmpCmd.setCommand(command);
+
+
+            }
+
+            Gson gson = new GsonBuilder().setPrettyPrinting().create();
             String commandsJson = gson.toJson(userDataObject);
             FILE_STORAGE.saveCommandsData(commandsJson, commandsTreePanel.getCurrentPathWithLeafIndex());
 

src/main/java/com/haleywang/putty/view/side/subview/CommandEditorPanel.java

@@ -292,6 +292,10 @@ public PlaceholderTextField getCommandNameTextField() {
         return commandNameTextField;
     }
 
+    public JLabel getPathLb() {
+        return pathLb;
+    }
+
     public void syncCommandsTree() {
         String command = getUpdateCommandTextArea().getText();
         String commandName = getCommandNameTextField().getText();

src/main/java/com/haleywang/putty/view/side/subview/CommandsTreePanel.java

@@ -147,7 +147,7 @@ private static TreePath getTreePath(JTree tree, String path) {
             searchedPath.append("/" + rootNodeText);
             Preconditions.checkNotNull(rootNode, "JTree does not have a root node!");
             String errMsg = "JTree root node does not match: Expected </" + getPathText(tree, treePath) + "> Actual: <"
-                    + searchedPath.toString() + ">";
+                    + searchedPath.toString() + ">, path:" + path;
             Preconditions.checkArgument(searchedPath.toString().equals("/" + getPathText(tree, treePath)), errMsg);
         }
         for (int i = start; i < tokens.length; i++) {

src/main/javaopen/com/ConstructorAccessor.java

@@ -0,0 +1,7 @@
+package com;
+
+import java.lang.reflect.InvocationTargetException;
+
+public interface ConstructorAccessor {
+    Object newInstance(Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException;
+}

src/main/javaopen/com/ReflectUtil.java

@@ -0,0 +1,181 @@
+package com;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
+
+public final class ReflectUtil {
+    public static final String PROXY_PACKAGE = "com.sun.proxy";
+
+    private ReflectUtil() {
+    }
+
+    public static Class<?> forName(String var0) throws ClassNotFoundException {
+        checkPackageAccess(var0);
+        return Class.forName(var0);
+    }
+
+    public static Object newInstance(Class<?> var0) throws InstantiationException, IllegalAccessException {
+        checkPackageAccess(var0);
+        return var0.newInstance();
+    }
+
+
+    private static boolean isSubclassOf(Class<?> var0, Class<?> var1) {
+        while(var0 != null) {
+            if (var0 == var1) {
+                return true;
+            }
+
+            var0 = var0.getSuperclass();
+        }
+
+        return false;
+    }
+
+
+
+    public static void checkPackageAccess(Class<?> var0) {
+        checkPackageAccess(var0.getName());
+        if (isNonPublicProxyClass(var0)) {
+            checkProxyPackageAccess(var0);
+        }
+
+    }
+
+    public static void checkPackageAccess(String var0) {
+        SecurityManager var1 = System.getSecurityManager();
+        if (var1 != null) {
+            String var2 = var0.replace('/', '.');
+            int var3;
+            if (var2.startsWith("[")) {
+                var3 = var2.lastIndexOf(91) + 2;
+                if (var3 > 1 && var3 < var2.length()) {
+                    var2 = var2.substring(var3);
+                }
+            }
+
+            var3 = var2.lastIndexOf(46);
+            if (var3 != -1) {
+                var1.checkPackageAccess(var2.substring(0, var3));
+            }
+        }
+
+    }
+
+    public static boolean isPackageAccessible(Class<?> var0) {
+        try {
+            checkPackageAccess(var0);
+            return true;
+        } catch (SecurityException var2) {
+            return false;
+        }
+    }
+
+    private static boolean isAncestor(ClassLoader var0, ClassLoader var1) {
+        ClassLoader var2 = var1;
+
+        do {
+            var2 = var2.getParent();
+            if (var0 == var2) {
+                return true;
+            }
+        } while(var2 != null);
+
+        return false;
+    }
+
+    public static boolean needsPackageAccessCheck(ClassLoader var0, ClassLoader var1) {
+        if (var0 != null && var0 != var1) {
+            if (var1 == null) {
+                return true;
+            } else {
+                return !isAncestor(var0, var1);
+            }
+        } else {
+            return false;
+        }
+    }
+
+    public static void checkProxyPackageAccess(Class<?> var0) {
+        SecurityManager var1 = System.getSecurityManager();
+        if (var1 != null && Proxy.isProxyClass(var0)) {
+            Class[] var2 = var0.getInterfaces();
+            int var3 = var2.length;
+
+            for(int var4 = 0; var4 < var3; ++var4) {
+                Class var5 = var2[var4];
+                checkPackageAccess(var5);
+            }
+        }
+
+    }
+
+    public static void checkProxyPackageAccess(ClassLoader var0, Class<?>... var1) {
+        SecurityManager var2 = System.getSecurityManager();
+        if (var2 != null) {
+            Class[] var3 = var1;
+            int var4 = var1.length;
+
+            for(int var5 = 0; var5 < var4; ++var5) {
+                Class var6 = var3[var5];
+                ClassLoader var7 = var6.getClassLoader();
+                if (needsPackageAccessCheck(var0, var7)) {
+                    checkPackageAccess(var6);
+                }
+            }
+        }
+
+    }
+
+    public static boolean isNonPublicProxyClass(Class<?> var0) {
+        String var1 = var0.getName();
+        int var2 = var1.lastIndexOf(46);
+        String var3 = var2 != -1 ? var1.substring(0, var2) : "";
+        return Proxy.isProxyClass(var0) && !var3.equals("com.sun.proxy");
+    }
+
+    public static void checkProxyMethod(Object var0, Method var1) {
+        if (var0 != null && Proxy.isProxyClass(var0.getClass())) {
+            if (Modifier.isStatic(var1.getModifiers())) {
+                throw new IllegalArgumentException("Can't handle static method");
+            } else {
+                Class var2 = var1.getDeclaringClass();
+                if (var2 == Object.class) {
+                    String var3 = var1.getName();
+                    if (var3.equals("hashCode") || var3.equals("equals") || var3.equals("toString")) {
+                        return;
+                    }
+                }
+
+                if (!isSuperInterface(var0.getClass(), var2)) {
+                    throw new IllegalArgumentException("Can't handle: " + var1);
+                }
+            }
+        } else {
+            throw new IllegalArgumentException("Not a Proxy instance");
+        }
+    }
+
+    private static boolean isSuperInterface(Class<?> var0, Class<?> var1) {
+        Class[] var2 = var0.getInterfaces();
+        int var3 = var2.length;
+
+        for(int var4 = 0; var4 < var3; ++var4) {
+            Class var5 = var2[var4];
+            if (var5 == var1) {
+                return true;
+            }
+
+            if (isSuperInterface(var5, var1)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static boolean isVMAnonymousClass(Class<?> var0) {
+        return var0.getName().indexOf("/") > -1;
+    }
+}

src/main/javaopen/com/SwingLazyValue.java

@@ -0,0 +1,92 @@
+package com;
+
+
+import javax.swing.UIDefaults;
+import javax.swing.UIDefaults.LazyValue;
+import javax.swing.plaf.ColorUIResource;
+import java.awt.Color;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public class SwingLazyValue implements LazyValue {
+    private final String className;
+    private final String methodName;
+    private Object[] args;
+
+    public SwingLazyValue(String var1) {
+        this(var1, (String)null);
+    }
+
+    public SwingLazyValue(String var1, String var2) {
+        this(var1, var2, (Object[])null);
+    }
+
+    public SwingLazyValue(String var1, Object[] var2) {
+        this(var1, (String)null, var2);
+    }
+
+    public SwingLazyValue(String var1, String var2, Object[] var3) {
+        this.className = var1;
+        this.methodName = var2;
+        if (var3 != null) {
+            this.args = (Object[])var3.clone();
+        }
+
+    }
+
+    @Override
+    public Object createValue(UIDefaults var1) {
+        try {
+            ReflectUtil.checkPackageAccess(this.className);
+            Class var2 = Class.forName(this.className, true, (ClassLoader)null);
+            Class[] var3;
+            if (this.methodName != null) {
+                var3 = this.getClassArray(this.args);
+                Method var6 = var2.getMethod(this.methodName, var3);
+                this.makeAccessible(var6);
+                return var6.invoke(var2, this.args);
+            } else {
+                var3 = this.getClassArray(this.args);
+                Constructor var4 = var2.getConstructor(var3);
+                this.makeAccessible(var4);
+                return var4.newInstance(this.args);
+            }
+        } catch (Exception var5) {
+            return null;
+        }
+    }
+
+    private void makeAccessible(final AccessibleObject var1) {
+        AccessController.doPrivileged(new PrivilegedAction<Void>() {
+            @Override
+            public Void run() {
+                var1.setAccessible(true);
+                return null;
+            }
+        });
+    }
+
+    private Class[] getClassArray(Object[] var1) {
+        Class[] var2 = null;
+        if (var1 != null) {
+            var2 = new Class[var1.length];
+
+            for(int var3 = 0; var3 < var1.length; ++var3) {
+                if (var1[var3] instanceof Integer) {
+                    var2[var3] = Integer.TYPE;
+                } else if (var1[var3] instanceof Boolean) {
+                    var2[var3] = Boolean.TYPE;
+                } else if (var1[var3] instanceof ColorUIResource) {
+                    var2[var3] = Color.class;
+                } else {
+                    var2[var3] = var1[var3].getClass();
+                }
+            }
+        }
+
+        return var2;
+    }
+}