Changeset 1195 for trunk/src/org/expeditee/actions/Actions.java

Timestamp:

11/28/18 15:27:56 (6 years ago)

Author:

bln4

Message:

org.expeditee.actions ->
org.exepdtiee.settings.legacy ->

There is a new, slightly improved, way of running actions. The old type of running actions can be used by changing a setting under the legacy category (new settings category). The new way of running actions allows actions to be written to take both the text item on the cursor and the text item that represents the actions.

File:

• trunk/src/org/expeditee/actions/Actions.java (modified) (9 diffs)

trunk/src/org/expeditee/actions/Actions.java

@@ -391 +391 @@
          * Performs the given action command. The source frame and item are given
          * because they are required by some actions. Note that the source frame
-         * does not ahve to be the items parent frame.
+         * does not have to be the items parent frame.
          * 
          * If multiple actions exist with the name command.takeWhile(_ != ' ') then
@@ -406 +406 @@
          * @throws Exception
          */
-        public static Object PerformAction(final Frame source, final Item launcher,
+        public static Object LegacyPerformAction(final Frame source, final Item launcher,
                         final String command) throws Exception {
+                MessageBay.displayMessage("Using Legacy code to execute action: " + command);
                 final String actionName = getName(command);
                 final String parameters = command.substring(actionName.length()).trim();
@@ -422 +423 @@
                 final String lowercaseName = actionName.toLowerCase();
                 final Method firstCanditate = _Actions.get(lowercaseName);
-                //      if this is not the name of a method, it may be the name of an agent
+                // if this is not the name of a method, it may be the name of an agent
                 if (firstCanditate == null) {
                         String commandAgent = command.substring(actionName.length()).trim();
@@ -475 +476 @@
                 // arguments.
                 for (final Method canditate : canditates) {
-                        final Object[] paramObjects = CreateObjects(canditate, source,
+                        final Object[] paramObjects = LegacyCreateObjects(canditate, source,
                                         launcher, parameters);
                         try {
@@ -493 +494 @@
                 throw new RuntimeException(errorBuilder.toString());
         }
-
+        
+
+        private static Object PerformAction(final Frame source, final Item launcher, final String command, final Item actionItem) throws Exception {
+                final String actionName = getName(command);
+                final String parameters = command.substring(actionName.length()).trim();
+
+                // Check for protection on frame.
+                if (ItemUtils.ContainsTag(source.getItems(), "@No" + actionName)) {
+                        final String errorMsg = "Frame is protected by @No" + actionName
+                                        + " tag.";
+                        MessageBay.errorMessage(errorMsg);
+                        throw new RuntimeException(errorMsg);
+                }
+
+                // Find all canditates. Sort by quantity of arguments.
+                final String lowercaseName = actionName.toLowerCase();
+                final Method firstCanditate = _Actions.get(lowercaseName);
+                // if this is not the name of a method, it may be the name of an agent
+                if (firstCanditate == null) {
+                        String commandAgent = command.substring(actionName.length()).trim();
+                        if(commandAgent.length() == 0 && launcher instanceof Text && launcher.isFloating())
+                                commandAgent = launcher.getText();
+                        LaunchAgent(actionName, commandAgent, source, launcher);
+                        return null;
+                }
+                //      need to save the frame if we are navigating away from it so we dont
+                //      loose changes
+                if (firstCanditate.getDeclaringClass().getName().equals(NAVIGATIONS_CLASS)) {
+                        FrameIO.SaveFrame(DisplayController.getCurrentFrame());
+                }
+                final List<Method> canditates = new LinkedList<Method>();
+                canditates.add(firstCanditate);
+                int i = 0;
+                while (_Actions.containsKey(lowercaseName + i))
+                        canditates.add(_Actions.get(lowercaseName + i++));
+                canditates.sort(new Comparator<Method>() {
+                        @Override
+                        public int compare(final Method m1, final Method m2) {
+                                final int parameterCountDifference = m2.getParameterCount() - m1.getParameterCount();
+                                if(parameterCountDifference == 0) {
+                                        final Class<?>[] m1ParamTypes = m1.getParameterTypes();
+                                        final Class<?>[] m2ParamTypes = m2.getParameterTypes();
+                                
+                                        //final ArrayList<Class<?>> typeOrder = Arrays.asList(Integer.TYPE, Double.TYPE, Float.TYPE, String.class);
+                                        // The above line doesn't compile in Eclipse Mars with the compile set to v1.8
+                                        // So changed to the following (low-tech) way:
+                                        ArrayList<Class<?>> typeOrder = new ArrayList<Class<?>>();
+                                        typeOrder.add(Integer.TYPE);
+                                        typeOrder.add(Double.TYPE);
+                                        typeOrder.add(Float.TYPE);
+                                        typeOrder.add(String.class);
+                                        
+                                         for(int i = 0,o = 0; i < m1ParamTypes.length && o < m2ParamTypes.length; i++,o++) {
+                                                final Class<?> m1ParamType = m1ParamTypes[i];
+                                                final Class<?> m2ParamType = m2ParamTypes[o];
+                                                final int m1ParamTypeIndex = typeOrder.indexOf(m1ParamType) != -1 ? 
+                                                                                typeOrder.indexOf(m1ParamType) : typeOrder.size();
+                                                final int m2ParamTypeIndex = typeOrder.indexOf(m2ParamType) != -1 ? 
+                                                                                typeOrder.indexOf(m2ParamType) : typeOrder.size();
+                                                final int paramMagnitude = m2ParamTypeIndex - m1ParamTypeIndex;
+                                                if(paramMagnitude != 0) return paramMagnitude;
+                                        }
+                                }
+                                return parameterCountDifference;
+                        }
+                });
+
+                // Find best candidate. Start searching with the candidate with most
+                // arguments.
+                for (final Method canditate : canditates) {
+                        final Object[] paramObjects = CreateObjects(canditate, source,
+                                        launcher, parameters, actionItem);
+                        try {
+                                if (paramObjects != null)
+                                        return canditate.invoke(null, paramObjects);
+                        } catch (final Exception e) {
+                                Logger.Log(e);
+                                e.printStackTrace();
+                        }
+                }
+                assert (canditates.size() > 0);
+                final String nl = System.getProperty("line.separator");
+                final StringBuilder errorBuilder = new StringBuilder(
+                                "Incorrect parameters for " + actionName + nl + "Canditates: ");
+                for (final Method canditate : canditates)
+                        errorBuilder.append(canditate + nl);
+                throw new RuntimeException(errorBuilder.toString());
+        }
+        
         // /**
         // * Performs the given action command. The source Frame and Item are given
@@ -865 +954 @@
          * @return The created array of Objects
          */
-        public static Object[] CreateObjects(Method method, Frame source,
+        public static Object[] LegacyCreateObjects(Method method, Frame source,
                         Item launcher, String values) {
                 // The parameter types that should be created from the given String
@@ -927 +1016 @@
                 return objects;
         }
+        
+
+        private static Object[] CreateObjects(final Method method, final Frame source, final Item launcher, String values, final Item actionItem) {
+                final Class<?>[] paramTypes = method.getParameterTypes();
+                final int paramCount = paramTypes.length;
+                int ind = 0;
+                
+                // If the canditate method has no parameters then we have already searched through all canditates with a greater number of parameters, so we can return new Object[0]
+                if (paramCount == 0) { return new Object[0]; }
+                
+                // Resolved parameters
+                final Object[] objects = new Object[paramCount];
+                
+                // If the ind'th parameter is a Frame then the source is the ind'th argument
+                if (paramTypes[ind] == Frame.class) { objects[ind++] = source; }
+                //Text user_t = ...
+                
+                // method = setFooAction(Dot i)
+                //Item action_i = user_t;
+                // If the ind'th parameter is a the same class as launcher then the launcher is the ind'th argument
+                //if (paramCount > ind && paramTypes[ind] == launcher.getClass() && Item.class.isAssignableFrom(paramTypes[ind])) { objects[ind++] = launcher; }
+                if (paramCount > ind && launcher.getClass().isAssignableFrom(paramTypes[ind])) { objects[ind++] = launcher; }
+                // Otherwise, try using the launcher's text as a replacement for values
+                else if (launcher != null && launcher.isFloating()) { values = launcher.getText(); }
+                
+                // If the ind'th parameter is a the same class as actionItem then the actionItem is the ind'th argument.
+                if (paramCount > ind && actionItem.getClass().isAssignableFrom(paramTypes[ind])) { objects[ind++] = actionItem; }
+                
+                // foo(Frame, Item, Item)
+                // currentFrame, laucher, actionItem
+                
+                // foo(Frame, Item, Item, String)
+                
+                // foo(Frame, Item)
+                
+                // Parse the remainder of the parameters
+                String param = values;
+                for (; ind < objects.length; ind++) {
+                        // If we are at the last parameter, then try cram the remaining content in as the parameter
+                        if (ind == objects.length - 1 && values.length() > 0) {
+                                param = values.trim();
+                                // The one exception is if we are starting a double quote enclosed string.  In that case, the content following the string (if any) is discarded without the matching process failing.
+                                if (param.length() > 0 && param.charAt(0) == '"') {
+                                        final int endOfString = param.indexOf('"', 1);
+                                        if (endOfString > 0) { param = param.substring(1, endOfString); }
+                                }
+                        }
+                        // Otherwise, strip off the next value.
+                        else {
+                                param = ParseValue(values);
+                                values = RemainingParams(values);
+                        }
+                        // Attempt to convert the param canditate to an object.  If this fails, we have failed to create a sane list of a variables to match to this method canditate.
+                        try {
+                                Object o = Conversion.Convert(paramTypes[ind], param);
+                                if (o == null) { return null; }
+                                objects[ind] = o;
+                        } catch (final Exception e) { return null; }
+                }
+                
+                return objects;
+        }
+
 
         /**
@@ -1041 +1193 @@
         }
 
-        public static Object PerformActionCatchErrors(Frame current, Item launcher,
+        public static Object LegacyPerformActionCatchErrors(Frame current, Item launcher,
                         String command) {
                 try {
-                        return PerformAction(current, launcher, command);
+                        return LegacyPerformAction(current, launcher, command);
                 } catch (RuntimeException e) {
                         e.printStackTrace();
@@ -1055 +1207 @@
                 return null;
         }
+        
+
+        public static Object PerformActionCatchErrors(final Frame current, final Item launcher, final String command, final Item actionItem) {
+                try {
+                        return PerformAction(current, launcher, command, actionItem);
+                } catch (RuntimeException e) {
+                        e.printStackTrace();
+                        MessageBay.errorMessage("Action failed: " + e.getMessage());
+                } catch (Exception e) {
+                        e.printStackTrace();
+                        MessageBay.errorMessage("Action failed: "
+                                        + e.getClass().getSimpleName());
+                }
+                return null;
+        }
 
         /**