refactoring
authorEugene Kudelevsky <Eugene.Kudelevsky@jetbrains.com>
Sat, 10 Apr 2010 13:08:24 +0000 (17:08 +0400)
committerEugene Kudelevsky <Eugene.Kudelevsky@jetbrains.com>
Sat, 10 Apr 2010 13:08:24 +0000 (17:08 +0400)
platform/lang-impl/src/com/intellij/codeInsight/template/CustomLiveTemplate.java
platform/lang-impl/src/com/intellij/codeInsight/template/CustomTemplateCallback.java
platform/lang-impl/src/com/intellij/codeInsight/template/TemplateInvokationListener.java
platform/lang-impl/src/com/intellij/codeInsight/template/impl/WrapWithCustomTemplateAction.java
xml/impl/src/com/intellij/codeInsight/template/zencoding/XmlZenCodingInterpreter.java
xml/impl/src/com/intellij/codeInsight/template/zencoding/XmlZenCodingTemplate.java

index 232d9038554893f04419ab49e230c78b5a7ec5dc..47bbc2c689c880e32f9309b1ceb05908d3ec05d7 100644 (file)
@@ -31,7 +31,7 @@ public interface CustomLiveTemplate {
 
   boolean isApplicable(PsiFile file, int offset, boolean selection);
 
-  void expand(String key, @NotNull CustomTemplateCallback callback, @Nullable TemplateInvokationListener listener);
+  void expand(String key, @NotNull CustomTemplateCallback callback);
 
   void wrap(String selection, @NotNull CustomTemplateCallback callback, @Nullable TemplateInvokationListener listener);
 
index cdc489bea740ffacd3e52c49c9f159310d1c702d..bc9f0e5796c703f1d3ac0880e85418b71e561ad7 100644 (file)
@@ -101,19 +101,14 @@ public class CustomTemplateCallback {
    * @param predefinedVarValues
    * @param listener            @return returns if template invokation is finished
    */
-  public boolean startTemplate(@NotNull String key,
-                               Map<String, String> predefinedVarValues,
-                               @Nullable TemplateInvokationListener listener) {
+  public void startTemplate(@NotNull String key,
+                            Map<String, String> predefinedVarValues) {
     List<TemplateImpl> templates = getMatchingTemplates(key);
     templates = filterApplicableCandidates(templates);
     if (templates.size() > 0) {
       TemplateImpl template = templates.get(0);
-      return startTemplate(template, predefinedVarValues, listener);
-    }
-    else if (listener != null) {
-      listener.finished(false);
+      startTemplate(template, predefinedVarValues);
     }
-    return true;
   }
 
   /**
@@ -155,14 +150,10 @@ public class CustomTemplateCallback {
     }
     return templateFinished[0];
   }*/
-  public boolean startTemplate(@NotNull TemplateImpl template,
-                               Map<String, String> predefinedVarValues,
-                               @Nullable final TemplateInvokationListener listener) {
-    moveToOffset(myBuilder.insertTemplate(myOffset, template, predefinedVarValues));
-    if (listener != null) {
-      listener.finished(false);
-    }
-    return true;
+  public void startTemplate(@NotNull TemplateImpl template,
+                            Map<String, String> predefinedVarValues) {
+    int offset = myBuilder.insertTemplate(myOffset, template, predefinedVarValues);
+    moveToOffset(offset);
   }
 
   /*private void reformat() {
index b9ea84a799c6be35881ecfa5755df7f0c4d1586f..47e40b5e1222c57d3f7173c52d828053fea92e7b 100644 (file)
@@ -19,5 +19,5 @@ package com.intellij.codeInsight.template;
  * @author Eugene.Kudelevsky
  */
 public interface TemplateInvokationListener {
-  void finished(boolean inSeparateEvent);
+  void finished();
 }
index e5fcba18c6571d85e7bcff4768df7c19f3b5b5a2..937de4b5ab899070976ebbd0a04fe5c3543e841f 100644 (file)
@@ -65,7 +65,7 @@ public class WrapWithCustomTemplateAction extends AnAction {
       selection = selection.trim();
       final CustomTemplateCallback callback = new CustomTemplateCallback(myEditor, myFile);
       myTemplate.wrap(selection, callback, new TemplateInvokationListener() {
-        public void finished(boolean inSeparateEvent) {
+        public void finished() {
           callback.finish();
         }
       });
index 853a9e0365ced1b1f00f0e585cce7e6cee007cba..8198ee9842cd6875c880ed97c813972c0a8c0dae 100644 (file)
@@ -16,7 +16,6 @@
 package com.intellij.codeInsight.template.zencoding;
 
 import com.intellij.codeInsight.template.CustomTemplateCallback;
-import com.intellij.codeInsight.template.TemplateInvokationListener;
 import com.intellij.codeInsight.template.impl.TemplateImpl;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.application.ApplicationManager;
@@ -52,33 +51,24 @@ class XmlZenCodingInterpreter {
   private static final String NUMBER_IN_ITERATION_PLACE_HOLDER = "$";
 
   private final List<Token> myTokens;
-  private final int myFromIndex;
 
   private final CustomTemplateCallback myCallback;
-  private final TemplateInvokationListener myListener;
   private final String mySurroundedText;
 
   private State myState;
 
   private XmlZenCodingInterpreter(List<Token> tokens,
-                                  int fromIndex,
                                   CustomTemplateCallback callback,
                                   State initialState,
-                                  String surroundedText,
-                                  TemplateInvokationListener listener) {
+                                  String surroundedText) {
     myTokens = tokens;
-    myFromIndex = fromIndex;
     myCallback = callback;
     mySurroundedText = surroundedText;
-    myListener = listener;
     myState = initialState;
   }
 
-  private void finish(boolean inSeparateEvent) {
+  private void finish() {
     myCallback.gotoEndOffset();
-    if (myListener != null) {
-      myListener.finished(inSeparateEvent);
-    }
   }
 
   private void gotoChild(Object templateBoundsKey) {
@@ -111,23 +101,21 @@ class XmlZenCodingInterpreter {
 
   // returns if expanding finished
 
-  public static boolean interpret(List<Token> tokens,
-                                  int startIndex,
-                                  CustomTemplateCallback callback,
-                                  State initialState,
-                                  String surroundedText,
-                                  TemplateInvokationListener listener) {
+  public static void interpret(List<Token> tokens,
+                               int startIndex,
+                               CustomTemplateCallback callback,
+                               State initialState,
+                               String surroundedText) {
     XmlZenCodingInterpreter interpreter =
-      new XmlZenCodingInterpreter(tokens, startIndex, callback, initialState, surroundedText, listener);
-    return interpreter.invoke(startIndex);
+      new XmlZenCodingInterpreter(tokens, callback, initialState, surroundedText);
+    interpreter.invoke(startIndex);
   }
 
-  private boolean invoke(int startIndex) {
+  private void invoke(int startIndex) {
     final int n = myTokens.size();
     TemplateToken templateToken = null;
     int number = -1;
     for (int i = startIndex; i < n; i++) {
-      final int finalI = i;
       Token token = myTokens.get(i);
       switch (myState) {
         case OPERATION:
@@ -137,29 +125,18 @@ class XmlZenCodingInterpreter {
               if (sign == '+' || (mySurroundedText == null && sign == XmlZenCodingTemplate.MARKER)) {
                 final Object key = new Object();
                 myCallback.fixStartOfTemplate(key);
-                TemplateInvokationListener listener = new TemplateInvokationListener() {
-                  public void finished(boolean inSeparateEvent) {
-                    myState = State.WORD;
-                    if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
-                      myCallback.fixEndOffset();
-                    }
-                    if (sign == '+') {
-                      myCallback.gotoEndOfTemplate(key);
-                    }
-                    if (inSeparateEvent) {
-                      invoke(finalI + 1);
-                    }
-                  }
-                };
-                if (!invokeTemplate(templateToken, myCallback, listener, 0)) {
-                  return false;
+                invokeTemplate(templateToken, myCallback, 0);
+                myState = State.WORD;
+                if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
+                  myCallback.fixEndOffset();
+                }
+                if (sign == '+') {
+                  myCallback.gotoEndOfTemplate(key);
                 }
                 templateToken = null;
               }
               else if (sign == '>' || (mySurroundedText != null && sign == XmlZenCodingTemplate.MARKER)) {
-                if (!startTemplateAndGotoChild(templateToken, finalI)) {
-                  return false;
-                }
+                startTemplateAndGotoChild(templateToken);
                 templateToken = null;
               }
               else if (sign == '*') {
@@ -193,19 +170,16 @@ class XmlZenCodingInterpreter {
           if (token instanceof MarkerToken || token instanceof OperationToken) {
             char sign = token instanceof OperationToken ? ((OperationToken)token).mySign : XmlZenCodingTemplate.MARKER;
             if (sign == '+' || (mySurroundedText == null && sign == XmlZenCodingTemplate.MARKER)) {
-              if (!invokeTemplateSeveralTimes(templateToken, 0, number, finalI)) {
-                return false;
-              }
+              invokeTemplateSeveralTimes(templateToken, 0, number);
               templateToken = null;
             }
             else if (number > 1) {
-              return invokeTemplateAndProcessTail(templateToken, 0, number, i + 1, startIndex != myFromIndex);
+              invokeTemplateAndProcessTail(templateToken, 0, number, i + 1);
+              return;
             }
             else {
               assert number == 1;
-              if (!startTemplateAndGotoChild(templateToken, finalI)) {
-                return false;
-              }
+              startTemplateAndGotoChild(templateToken);
               templateToken = null;
             }
             myState = State.WORD;
@@ -219,58 +193,30 @@ class XmlZenCodingInterpreter {
     if (mySurroundedText != null) {
       insertText(myCallback, mySurroundedText);
     }
-    finish(startIndex != myFromIndex);
-    return true;
+    finish();
   }
 
-  private boolean startTemplateAndGotoChild(TemplateToken templateToken, final int index) {
+  private void startTemplateAndGotoChild(TemplateToken templateToken) {
     final Object key = new Object();
     myCallback.fixStartOfTemplate(key);
-    TemplateInvokationListener listener = new TemplateInvokationListener() {
-      public void finished(boolean inSeparateEvent) {
-        myState = State.WORD;
-        gotoChild(key);
-        if (inSeparateEvent) {
-          invoke(index + 1);
-        }
-      }
-    };
-    if (!invokeTemplate(templateToken, myCallback, listener, 0)) {
-      return false;
-    }
-    return true;
+    invokeTemplate(templateToken, myCallback, 0);
+    myState = State.WORD;
+    gotoChild(key);
   }
 
-  private boolean invokeTemplateSeveralTimes(final TemplateToken templateToken,
-                                             final int startIndex,
-                                             final int count,
-                                             final int globalIndex) {
+  private void invokeTemplateSeveralTimes(final TemplateToken templateToken,
+                                          final int startIndex,
+                                          final int count) {
     final Object key = new Object();
     myCallback.fixStartOfTemplate(key);
     for (int i = startIndex; i < count; i++) {
-      final int finalI = i;
-      TemplateInvokationListener listener = new TemplateInvokationListener() {
-        public void finished(boolean inSeparateEvent) {
-          myState = State.WORD;
-          if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
-            myCallback.fixEndOffset();
-          }
-          myCallback.gotoEndOfTemplate(key);
-          if (inSeparateEvent) {
-            if (finalI + 1 < count) {
-              invokeTemplateSeveralTimes(templateToken, finalI + 1, count, globalIndex);
-            }
-            else {
-              invoke(globalIndex + 1);
-            }
-          }
-        }
-      };
-      if (!invokeTemplate(templateToken, myCallback, listener, i)) {
-        return false;
+      invokeTemplate(templateToken, myCallback, i);
+      myState = State.WORD;
+      if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
+        myCallback.fixEndOffset();
       }
+      myCallback.gotoEndOfTemplate(key);
     }
-    return true;
   }
 
   private static void insertText(CustomTemplateCallback callback, String text) {
@@ -278,45 +224,22 @@ class XmlZenCodingInterpreter {
     callback.insertString(offset, text);
   }
 
-  private boolean invokeTemplateAndProcessTail(final TemplateToken templateToken,
-                                               final int startIndex,
-                                               final int count,
-                                               final int tailStart,
-                                               boolean separateEvent) {
+  private void invokeTemplateAndProcessTail(final TemplateToken templateToken,
+                                            final int startIndex,
+                                            final int count,
+                                            final int tailStart) {
     final Object key = new Object();
     myCallback.fixStartOfTemplate(key);
     for (int i = startIndex; i < count; i++) {
-      final int finalI = i;
-      final boolean[] flag = new boolean[]{false};
-      TemplateInvokationListener listener = new TemplateInvokationListener() {
-        public void finished(boolean inSeparateEvent) {
-          gotoChild(key);
-          if (interpret(myTokens, tailStart, myCallback, State.WORD, mySurroundedText, new TemplateInvokationListener() {
-            public void finished(boolean inSeparateEvent) {
-              if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
-                myCallback.fixEndOffset();
-              }
-              myCallback.gotoEndOfTemplate(key);
-              if (inSeparateEvent) {
-                invokeTemplateAndProcessTail(templateToken, finalI + 1, count, tailStart, true);
-              }
-            }
-          })) {
-            if (inSeparateEvent) {
-              invokeTemplateAndProcessTail(templateToken, finalI + 1, count, tailStart, true);
-            }
-          }
-          else {
-            flag[0] = true;
-          }
-        }
-      };
-      if (!invokeTemplate(templateToken, myCallback, listener, i) || flag[0]) {
-        return false;
+      invokeTemplate(templateToken, myCallback, i);
+      gotoChild(key);
+      interpret(myTokens, tailStart, myCallback, State.WORD, mySurroundedText);
+      if (myCallback.getOffset() != myCallback.getEndOfTemplate(key)) {
+        myCallback.fixEndOffset();
       }
+      myCallback.gotoEndOfTemplate(key);
     }
-    finish(separateEvent);
-    return true;
+    finish();
   }
 
   private static boolean containsAttrsVar(TemplateImpl template) {
@@ -395,13 +318,12 @@ class XmlZenCodingInterpreter {
     return null;
   }
 
-  private static boolean invokeTemplate(TemplateToken token,
-                                        final CustomTemplateCallback callback,
-                                        final TemplateInvokationListener listener,
-                                        int numberInIteration) {
+  private static void invokeTemplate(TemplateToken token,
+                                     final CustomTemplateCallback callback,
+                                     int numberInIteration) {
     List<Pair<String, String>> attr2value = new ArrayList<Pair<String, String>>(token.myAttribute2Value);
     if (callback.isLiveTemplateApplicable(token.myKey)) {
-      return invokeExistingLiveTemplate(token, callback, listener, numberInIteration, attr2value);
+      invokeExistingLiveTemplate(token, callback, numberInIteration, attr2value);
     }
     else {
       TemplateImpl template = new TemplateImpl("", "");
@@ -417,15 +339,14 @@ class XmlZenCodingInterpreter {
       }
       template.setToReformat(true);
       Map<String, String> predefinedValues = buildPredefinedValues(attr2value, numberInIteration);
-      return callback.startTemplate(template, predefinedValues, listener);
+      callback.startTemplate(template, predefinedValues);
     }
   }
 
-  private static boolean invokeExistingLiveTemplate(TemplateToken token,
-                                                    CustomTemplateCallback callback,
-                                                    TemplateInvokationListener listener,
-                                                    int numberInIteration,
-                                                    List<Pair<String, String>> attr2value) {
+  private static void invokeExistingLiveTemplate(TemplateToken token,
+                                                 CustomTemplateCallback callback,
+                                                 int numberInIteration,
+                                                 List<Pair<String, String>> attr2value) {
     if (token.myTemplate != null) {
       if (attr2value.size() > 0 || XmlZenCodingTemplate.isTrueXml(callback)) {
         TemplateImpl modifiedTemplate = token.myTemplate.copy();
@@ -461,14 +382,15 @@ class XmlZenCodingInterpreter {
           modifiedTemplate.setString(text);
           removeVariablesWhichHasNoSegment(modifiedTemplate);
           Map<String, String> predefinedValues = buildPredefinedValues(attr2value, numberInIteration);
-          return callback.startTemplate(modifiedTemplate, predefinedValues, listener);
+          callback.startTemplate(modifiedTemplate, predefinedValues);
+          return;
         }
       }
-      return callback.startTemplate(token.myTemplate, null, listener);
+      callback.startTemplate(token.myTemplate, null);
     }
     else {
       Map<String, String> predefinedValues = buildPredefinedValues(attr2value, numberInIteration);
-      return callback.startTemplate(token.myKey, predefinedValues, listener);
+      callback.startTemplate(token.myKey, predefinedValues);
     }
   }
 
index 53dcca8c5549af7db348b0316b2db0809d359736..a50fb18297afcc866cce86954892eb791f3220db 100644 (file)
@@ -360,17 +360,16 @@ public class XmlZenCodingTemplate implements CustomLiveTemplate {
     return false;
   }
 
-  public void expand(String key, @NotNull CustomTemplateCallback callback, @Nullable TemplateInvokationListener listener) {
-    expand(key, callback, null, listener);
+  public void expand(String key, @NotNull CustomTemplateCallback callback) {
+    expand(key, callback, null);
   }
 
   private static void expand(String key,
                              @NotNull CustomTemplateCallback callback,
-                             String surroundedText,
-                             @Nullable TemplateInvokationListener listener) {
+                             String surroundedText) {
     List<Token> tokens = parse(key, callback);
     assert tokens != null;
-    XmlZenCodingInterpreter.interpret(tokens, 0, callback, State.WORD, surroundedText, listener);
+    XmlZenCodingInterpreter.interpret(tokens, 0, callback, State.WORD, surroundedText);
   }
 
   public void wrap(final String selection,
@@ -411,7 +410,10 @@ public class XmlZenCodingTemplate implements CustomLiveTemplate {
             EditorModificationUtil.deleteSelectedText(callback.getEditor());
             PsiDocumentManager.getInstance(callback.getProject()).commitAllDocuments();
             callback.fixInitialState();
-            expand(abbreviation, callback, selection, listener);
+            expand(abbreviation, callback, selection);
+            if (listener != null) {
+              listener.finished();
+            }
           }
         }, CodeInsightBundle.message("insert.code.template.command"), null);
       }
@@ -435,16 +437,15 @@ public class XmlZenCodingTemplate implements CustomLiveTemplate {
     int caretAt = editor.getCaretModel().getOffset();
     if (isApplicable(file, caretAt)) {
       final CustomTemplateCallback callback = new CustomTemplateCallback(editor, file);
-      TemplateInvokationListener listener = new TemplateInvokationListener() {
-        public void finished(boolean inSeparateEvent) {
-          callback.finish();
-        }
-      };
       if (abbreviation != null) {
         String selection = callback.getEditor().getSelectionModel().getSelectedText();
         assert selection != null;
         selection = selection.trim();
-        doWrap(selection, abbreviation, callback, listener);
+        doWrap(selection, abbreviation, callback, new TemplateInvokationListener() {
+          public void finished() {
+            callback.finish();
+          }
+        });
       }
       else {
         XmlZenCodingTemplate template = new XmlZenCodingTemplate();
@@ -452,7 +453,8 @@ public class XmlZenCodingTemplate implements CustomLiveTemplate {
         if (key != null) {
           int offsetBeforeKey = caretAt - key.length();
           callback.getEditor().getDocument().deleteString(offsetBeforeKey, caretAt);
-          template.expand(key, callback, listener);
+          template.expand(key, callback);
+          callback.finish();
           return true;
         }
         // if it is simple live template invokation, we should start it using TemplateManager because template may be ambiguous