Exemplo n.º 1
0
 @Nullable
 @Override
 public String computeTemplateKey(@NotNull CustomTemplateCallback callback) {
   Editor editor = callback.getEditor();
   String key =
       computeTemplateKeyWithoutContextChecking(
           editor.getDocument().getCharsSequence(), editor.getCaretModel().getOffset());
   if (key == null) return null;
   return isApplicableTemplate(
           getTemplateByKey(key), key, callback.getContext().getContainingFile(), editor)
       ? key
       : null;
 }
Exemplo n.º 2
0
  public void wrap(final String selection, @NotNull final CustomTemplateCallback callback) {
    InputValidatorEx validator =
        new InputValidatorEx() {
          public String getErrorText(String inputString) {
            if (!checkTemplateKey(inputString, callback)) {
              return XmlBundle.message("zen.coding.incorrect.abbreviation.error");
            }
            return null;
          }

          public boolean checkInput(String inputString) {
            return getErrorText(inputString) == null;
          }

          public boolean canClose(String inputString) {
            return checkInput(inputString);
          }
        };
    final String abbreviation =
        Messages.showInputDialog(
            callback.getProject(),
            XmlBundle.message("zen.coding.enter.abbreviation.dialog.label"),
            XmlBundle.message("zen.coding.title"),
            Messages.getQuestionIcon(),
            "",
            validator);
    if (abbreviation != null) {
      doWrap(selection, abbreviation, callback);
    }
  }
Exemplo n.º 3
0
  protected static void doWrap(
      final String selection, final String abbreviation, final CustomTemplateCallback callback) {
    final ZenCodingGenerator defaultGenerator =
        findApplicableDefaultGenerator(callback.getContext(), true);
    assert defaultGenerator != null;
    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              public void run() {
                CommandProcessor.getInstance()
                    .executeCommand(
                        callback.getProject(),
                        new Runnable() {
                          public void run() {
                            callback.fixInitialState(true);
                            ZenCodingNode node = parse(abbreviation, callback, defaultGenerator);
                            assert node != null;
                            PsiElement context = callback.getContext();
                            ZenCodingGenerator generator =
                                findApplicableGenerator(node, context, true);
                            List<ZenCodingFilter> filters = getFilters(node, context);

                            EditorModificationUtil.deleteSelectedText(callback.getEditor());
                            PsiDocumentManager.getInstance(callback.getProject())
                                .commitAllDocuments();

                            expand(node, generator, filters, selection, callback);
                          }
                        },
                        CodeInsightBundle.message("insert.code.template.command"),
                        null);
              }
            });
  }
Exemplo n.º 4
0
 @Nullable
 @Override
 public String computeTemplateKeyWithoutContextChecking(@NotNull CustomTemplateCallback callback) {
   Editor editor = callback.getEditor();
   return computeTemplateKeyWithoutContextChecking(
       editor.getDocument().getCharsSequence(), editor.getCaretModel().getOffset());
 }
Exemplo n.º 5
0
  @NotNull
  private static PsiElement deleteTemplateKey(
      @NotNull final PsiFile file,
      @NotNull final Document document,
      final int currentOffset,
      @NotNull final String key) {
    ApplicationManager.getApplication().assertIsDispatchThread();

    final int startOffset = currentOffset - key.length();
    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              @Override
              public void run() {
                CommandProcessor.getInstance()
                    .runUndoTransparentAction(
                        new Runnable() {
                          public void run() {
                            document.deleteString(startOffset, currentOffset);
                            PsiDocumentManager.getInstance(file.getProject())
                                .commitDocument(document);
                          }
                        });
              }
            });
    return CustomTemplateCallback.getContext(file, startOffset > 0 ? startOffset - 1 : startOffset);
  }
Exemplo n.º 6
0
    @Nullable
    private ZenCodingNode parseTemplate() {
      final ZenCodingToken token = nextToken();
      String templateKey = isHtml(myCallback) ? DEFAULT_TAG : null;
      boolean mustHaveSelector = true;

      if (token instanceof IdentifierToken) {
        templateKey = ((IdentifierToken) token).getText();
        mustHaveSelector = false;
        myIndex++;
      }

      if (templateKey == null) {
        return null;
      }

      final TemplateImpl template = myCallback.findApplicableTemplate(templateKey);
      if (template == null && !isXML11ValidQName(templateKey)) {
        return null;
      }

      final List<Pair<String, String>> attrList = parseSelectors();
      if (mustHaveSelector && attrList.size() == 0) {
        return null;
      }

      final TemplateToken templateToken = new TemplateToken(templateKey, attrList);

      if (!setTemplate(templateToken, template)) {
        return null;
      }
      return new TemplateNode(templateToken);
    }
 public static boolean isApplicable(
     @NotNull CustomLiveTemplate customLiveTemplate,
     @NotNull Editor editor,
     @NotNull PsiFile file,
     boolean wrapping) {
   return customLiveTemplate.isApplicable(
       file, CustomTemplateCallback.getOffset(editor), wrapping);
 }
Exemplo n.º 8
0
  @Override
  public void expand(@NotNull final String key, @NotNull final CustomTemplateCallback callback) {
    ApplicationManager.getApplication().assertIsDispatchThread();

    final PostfixTemplate template = getTemplateByKey(key);
    final Editor editor = callback.getEditor();
    final PsiFile file = callback.getContext().getContainingFile();
    if (isApplicableTemplate(template, key, file, editor)) {
      int currentOffset = editor.getCaretModel().getOffset();
      PsiElement newContext = deleteTemplateKey(file, editor.getDocument(), currentOffset, key);
      newContext =
          addSemicolonIfNeeded(
              editor, editor.getDocument(), newContext, currentOffset - key.length());
      expandTemplate(template, editor, newContext);
    } else {
      LOG.error("Template not found by key: " + key);
    }
  }
Exemplo n.º 9
0
  private static void expand(
      ZenCodingNode node,
      ZenCodingGenerator generator,
      List<ZenCodingFilter> filters,
      String surroundedText,
      CustomTemplateCallback callback) {
    if (surroundedText != null) {
      surroundedText = surroundedText.trim();
    }
    List<GenerationNode> genNodes = node.expand(-1, surroundedText, callback, true);
    LiveTemplateBuilder builder = new LiveTemplateBuilder();
    int end = -1;
    for (int i = 0, genNodesSize = genNodes.size(); i < genNodesSize; i++) {
      GenerationNode genNode = genNodes.get(i);
      TemplateImpl template = genNode.generate(callback, generator, filters, true);
      int e = builder.insertTemplate(builder.length(), template, null);
      if (end == -1 && end < builder.length()) {
        end = e;
      }
    }

    callback.startTemplate(
        builder.buildTemplate(),
        null,
        new TemplateEditingAdapter() {
          private TextRange myEndVarRange;
          private Editor myEditor;

          @Override
          public void beforeTemplateFinished(TemplateState state, Template template) {
            int variableNumber = state.getCurrentVariableNumber();
            if (variableNumber >= 0 && template instanceof TemplateImpl) {
              TemplateImpl t = (TemplateImpl) template;
              while (variableNumber < t.getVariableCount()) {
                String varName = t.getVariableNameAt(variableNumber);
                if (LiveTemplateBuilder.isEndVariable(varName)) {
                  myEndVarRange = state.getVariableRange(varName);
                  myEditor = state.getEditor();
                  break;
                }
                variableNumber++;
              }
            }
          }

          @Override
          public void templateFinished(Template template, boolean brokenOff) {
            if (brokenOff && myEndVarRange != null && myEditor != null) {
              int offset = myEndVarRange.getStartOffset();
              if (offset >= 0 && offset != myEditor.getCaretModel().getOffset()) {
                myEditor.getCaretModel().moveToOffset(offset);
                myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
              }
            }
          }
        });
  }
Exemplo n.º 10
0
 public boolean isApplicable(PsiFile file, int offset, boolean wrapping) {
   WebEditorOptions webEditorOptions = WebEditorOptions.getInstance();
   if (!webEditorOptions.isZenCodingEnabled()) {
     return false;
   }
   if (file == null) {
     return false;
   }
   PsiDocumentManager.getInstance(file.getProject()).commitAllDocuments();
   PsiElement element = CustomTemplateCallback.getContext(file, offset);
   return findApplicableDefaultGenerator(element, wrapping) != null;
 }
Exemplo n.º 11
0
  private static void expand(
      String key,
      @NotNull CustomTemplateCallback callback,
      String surroundedText,
      @NotNull ZenCodingGenerator defaultGenerator) {
    ZenCodingNode node = parse(key, callback, defaultGenerator);
    assert node != null;
    if (surroundedText == null) {
      if (node instanceof TemplateNode) {
        if (key.equals(((TemplateNode) node).getTemplateToken().getKey())
            && callback.findApplicableTemplates(key).size() > 1) {
          callback.startTemplate();
          return;
        }
      }
      callback.deleteTemplateKey(key);
    }

    PsiElement context = callback.getContext();
    ZenCodingGenerator generator = findApplicableGenerator(node, context, false);
    List<ZenCodingFilter> filters = getFilters(node, context);

    expand(node, generator, filters, surroundedText, callback);
  }
Exemplo n.º 12
0
 @NotNull
 private static XmlFile parseXmlFileInTemplate(
     String templateString, CustomTemplateCallback callback, boolean createPhysicalFile) {
   XmlFile xmlFile =
       (XmlFile)
           PsiFileFactory.getInstance(callback.getProject())
               .createFileFromText(
                   "dummy.xml",
                   StdFileTypes.XML,
                   templateString,
                   LocalTimeCounter.currentTime(),
                   createPhysicalFile);
   VirtualFile vFile = xmlFile.getVirtualFile();
   if (vFile != null) {
     vFile.putUserData(UndoConstants.DONT_RECORD_UNDO, Boolean.TRUE);
   }
   return xmlFile;
 }
Exemplo n.º 13
0
  @Nullable
  protected ZenCodingNode parseTemplate() {
    ZenCodingToken token = getToken();
    if (!(token instanceof IdentifierToken)) {
      return null;
    }
    String templateKey = ((IdentifierToken) token).getText();
    advance();

    TemplateImpl template = myCallback.findApplicableTemplate(templateKey);
    if (template == null && !ZenCodingUtil.isXML11ValidQName(templateKey)) {
      return null;
    }

    final TemplateToken templateToken = new TemplateToken(templateKey);
    if (!setTemplate(templateToken, template)) {
      return null;
    }
    return new TemplateNode(templateToken);
  }
Exemplo n.º 14
0
  private static Condition<PostfixTemplate> createIsApplicationTemplateFunction(
      @NotNull String key, @NotNull PsiFile file, @NotNull Editor editor) {
    int currentOffset = editor.getCaretModel().getOffset();
    final int newOffset = currentOffset - key.length();
    CharSequence fileContent = editor.getDocument().getCharsSequence();

    StringBuilder fileContentWithoutKey = new StringBuilder();
    fileContentWithoutKey.append(fileContent.subSequence(0, newOffset));
    fileContentWithoutKey.append(fileContent.subSequence(currentOffset, fileContent.length()));
    PsiFile copyFile = copyFile(file, fileContentWithoutKey);
    Document copyDocument = copyFile.getViewProvider().getDocument();
    if (copyDocument == null) {
      //noinspection unchecked
      return Condition.FALSE;
    }

    if (isSemicolonNeeded(copyFile, editor)) {
      fileContentWithoutKey.insert(newOffset, ';');
      copyFile = copyFile(file, fileContentWithoutKey);
      copyDocument = copyFile.getViewProvider().getDocument();
      if (copyDocument == null) {
        //noinspection unchecked
        return Condition.FALSE;
      }
    }

    final PsiElement context =
        CustomTemplateCallback.getContext(copyFile, newOffset > 0 ? newOffset - 1 : newOffset);
    final Document finalCopyDocument = copyDocument;
    return new Condition<PostfixTemplate>() {
      @Override
      public boolean value(PostfixTemplate template) {
        return template != null
            && template.isEnabled()
            && template.isApplicable(context, finalCopyDocument, newOffset);
      }
    };
  }
Exemplo n.º 15
0
 private static boolean isHtml(CustomTemplateCallback callback) {
   FileType type = callback.getFileType();
   return type == StdFileTypes.HTML || type == StdFileTypes.XHTML;
 }
Exemplo n.º 16
0
 public String computeTemplateKey(@NotNull CustomTemplateCallback callback) {
   ZenCodingGenerator generator = findApplicableDefaultGenerator(callback.getContext(), false);
   if (generator == null) return null;
   return generator.computeTemplateKey(callback);
 }
Exemplo n.º 17
0
 public void expand(String key, @NotNull CustomTemplateCallback callback) {
   ZenCodingGenerator defaultGenerator =
       findApplicableDefaultGenerator(callback.getContext(), false);
   assert defaultGenerator != null;
   expand(key, callback, null, defaultGenerator);
 }
Exemplo n.º 18
0
 public static boolean checkTemplateKey(String inputString, CustomTemplateCallback callback) {
   ZenCodingGenerator generator = findApplicableDefaultGenerator(callback.getContext(), true);
   assert generator != null;
   return checkTemplateKey(inputString, callback, generator);
 }