Java Code Examples for com.intellij.openapi.editor.RangeMarker#dispose()

public static void applyEdit(Editor editor, TextEdit textEdit, Document document) {
    RangeMarker marker = document.createRangeMarker(LSPIJUtils.toOffset(textEdit.getRange().getStart(), document), LSPIJUtils.toOffset(textEdit.getRange().getEnd(), document));
    int startOffset = marker.getStartOffset();
    int endOffset = marker.getEndOffset();
    String text = textEdit.getNewText();
    if (text != null) {
        text = text.replaceAll("\r", "");
    }
    if (text == null || "".equals(text)) {
        document.deleteString(startOffset, endOffset);
    } else if (endOffset - startOffset <= 0) {
        document.insertString(startOffset, text);
    } else {
        document.replaceString(startOffset, endOffset, text);
    }
    if (text != null && !"".equals(text)) {
        editor.getCaretModel().moveCaretRelatively(text.length(), 0, false, false, true);
    }
    marker.dispose();
}
 

/**
 * Replace the text within the given range and reformat it according to the user's
 * code style/formatting rules.
 *
 * NOTE: The PSI may be entirely invalidated and re-created by this call.
 *
 * @param range Range of text or PsiElements to replace.
 * @param text Replacement text (may be null).
 */
public void replaceAndFormat(@NotNull final TextRange range, @Nullable String text) {
  if (null == text) {
    text = "";
  }

  // Mark the beginning and end so that we have the proper range after adding text.
  // Greedy means that the text immediately added at the beginning/end of the marker are included.
  RangeMarker marker = document.createRangeMarker(range);
  marker.setGreedyToLeft(true);
  marker.setGreedyToRight(true);

  try {

    document.replaceString(range.getStartOffset(), range.getEndOffset(), text);

    //PsiDocumentManager.getInstance(file.getProject()).commitDocument(document); // force update PSI.

    if (marker.isValid()) { // If the range wasn't reduced to zero.
      CodeStyleManager.getInstance(file.getProject()).reformatText(file, marker.getStartOffset(), marker.getEndOffset());
    }
  }
  finally {
    marker.dispose();
  }
}
 

@RequiredReadAction
public static <T extends PsiElement> T forcePsiPostprocessAndRestoreElement(@Nonnull T element,
                                                                            boolean useFileLanguage) {
  final PsiFile psiFile = element.getContainingFile();
  final Document document = psiFile.getViewProvider().getDocument();
  //if (document == null) return element;
  final Language language = useFileLanguage ? psiFile.getLanguage() : PsiUtilCore.getDialect(element);
  final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(psiFile.getProject());
  final RangeMarker rangeMarker = document.createRangeMarker(element.getTextRange());
  documentManager.doPostponedOperationsAndUnblockDocument(document);
  documentManager.commitDocument(document);

  T elementInRange = findElementInRange(psiFile, rangeMarker.getStartOffset(), rangeMarker.getEndOffset(),
                                        (Class<? extends T>)element.getClass(),
                                        language, element);
  rangeMarker.dispose();
  return elementInRange;
}
 

private void setDirtyScope(int passId, RangeMarker scope) {
  RangeMarker marker = dirtyScopes.get(passId);
  if (marker != scope) {
    if (marker != null) {
      marker.dispose();
    }
    dirtyScopes.put(passId, scope);
  }
}
 

@Override
public void dispose() {
  synchronized (myMap) {
    myDisposed = true;
    for (RangeMarker rangeMarker : myMap.values()) {
      rangeMarker.dispose();
    }
  }
}
 

public void replaceSegmentAt(int index, int start, int end, boolean preserveGreediness) {
  RangeMarker rangeMarker = mySegments.get(index);
  boolean greedyToLeft = rangeMarker.isGreedyToLeft();
  boolean greedyToRight = rangeMarker.isGreedyToRight();
  rangeMarker.dispose();

  Document doc = myEditor.getDocument();
  rangeMarker = doc.createRangeMarker(start, end);
  rangeMarker.setGreedyToLeft(greedyToLeft || !preserveGreediness);
  rangeMarker.setGreedyToRight(greedyToRight || !preserveGreediness);
  mySegments.set(index, rangeMarker);
}
 

void clear() {
  myInfos.clear();
  for (RangeMarker marker : myRangeMarkers) {
    marker.dispose();
  }
  myRangeMarkers.clear();
}
 

@Override
public void dispose() {
  for (Pair<Integer, RangeMarker> pair : myRangesToReindent) {
    RangeMarker marker = pair.second;
    if (marker.isValid()) {
      marker.dispose();
    }
  }
}
 

public void exclude(FindResult occurrence) {
  boolean include = false;
  for (RangeMarker rangeMarker : myExcluded) {
    if (TextRange.areSegmentsEqual(rangeMarker, occurrence)) {
      myExcluded.remove(rangeMarker);
      rangeMarker.dispose();
      include = true;
      break;
    }
  }
  if (!include) {
    myExcluded.add(myEditor.getDocument().createRangeMarker(occurrence.getStartOffset(), occurrence.getEndOffset(), true));
  }
  notifyChanged();
}
 

private void updateExcluded() {
  Set<RangeMarker> invalid = new HashSet<>();
  for (RangeMarker marker : myExcluded) {
    if (!marker.isValid()) {
      invalid.add(marker);
      marker.dispose();
    }
  }
  myExcluded.removeAll(invalid);
}
 

@Override
protected void moveOffsetAfter(boolean success) {
  super.moveOffsetAfter(success);
  if (myOccurrenceMarkers != null) {
    for (RangeMarker marker : myOccurrenceMarkers) {
      marker.dispose();
    }
  }
  if (myExprMarker != null && !isRestart()) {
    myExprMarker.dispose();
  }
}
 

public void removeAll() {
  for (RangeMarker segment : mySegments) {
    segment.dispose();
  }
  mySegments.clear();
}