Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
243,600 | record (LineExtensionInfo info, LineLayout layout) { } | LineExtensionData |
243,601 | boolean (int offset) { for (int i = 0; i < caretCount; ++i) { if (offset >= selectionStarts[i] && offset < selectionEnds[i]) return true; } return false; } | isOffsetInSelection |
243,602 | int[] (int line) { if (line < 0) line = 0; int offset = line >= myView.getEditor().getVisibleLineCount() ? myDocument.getTextLength() + 1 : visualLineToOffset(line); int lineHeight = myView.getLineHeight(); FoldingModelImpl foldingModel = myView.getEditor().getFoldingModel(); int idx = foldingModel.getLastCollapsedRegi... | visualLineToYRange |
243,603 | int (int visualLine, boolean above) { return EditorUtil.getInlaysHeight(myView.getEditor(), visualLine, above); } | getInlaysHeight |
243,604 | int (int logLine, int remainingLogColumn, boolean leansForward) { if (remainingLogColumn > 1 || remainingLogColumn == 1 && leansForward) { remainingLogColumn += myView.getEditor().getInlayModel().getAfterLineEndElementsForLogicalLine(logLine).size(); } return remainingLogColumn; } | logToVisWithInlays |
243,605 | int (int logLine, int remainingVisColumns, boolean[] leansForward) { if (remainingVisColumns == 0) return 0; int inlayCount = myView.getEditor().getInlayModel().getAfterLineEndElementsForLogicalLine(logLine).size(); if (inlayCount == 0) return remainingVisColumns; if (remainingVisColumns < inlayCount + 1) { leansForwar... | visToLogWithInlays |
243,606 | int (int offset, boolean leanForward) { EditorImpl editor = myView.getEditor(); offset = DocumentUtil.alignToCodePointBoundary(myDocument, offset); int result = EditorUtil.getNotFoldedLineStartOffset(editor, offset); SoftWrapModelImpl softWrapModel = editor.getSoftWrapModel(); List<? extends SoftWrap> softWraps = softW... | visualLineStartOffset |
243,607 | float (int line) { return myView.getEditor().isRightAligned() ? getRightAlignmentLineStartX(line) : myView.getInsets().left + (line == 0 ? myView.getPrefixTextWidthInPixels() : 0); } | getStartX |
243,608 | void () { if (!myView.getEditor().isRightAligned()) throw new IllegalStateException("Editor is not right-aligned"); } | checkRightAlignment |
243,609 | void (int logicalCharIndex, float x, boolean isRtl, int numChars) { int charPosition = isRtl ? numChars - logicalCharIndex - 2 : logicalCharIndex; if (charPosition >= 0 && charPosition < numChars - 1) { myCharPositions[charPosition] = x; } } | setCharPosition |
243,610 | Consumer<Graphics2D> (float x, float y, int startColumn, int endColumn) { assert startColumn >= 0; assert endColumn <= myCharPositions.length; assert startColumn < endColumn; return g -> { Color color = g.getColor(); assert color != null; float newX = x - getX(startColumn) + getX(endColumn); if (lastFragment == this &&... | draw |
243,611 | void (Graphics2D g, float x, float y, int startColumn, int endColumn) { updateStats(endColumn - startColumn, myCharPositions.length); if (startColumn == 0 && endColumn == myCharPositions.length) { g.drawGlyphVector(myGlyphVector, x, y); } else { Shape savedClip = g.getClip(); float startX = x - getX(startColumn); // We... | doDraw |
243,612 | int () { return myCodePoint2Offset == null ? myCharPositions.length : myCodePoint2Offset.length; } | getCodePointCount |
243,613 | int (int column) { if (myCodePoint2Offset == null) return column; if (column <= 0) return 0; if (column >= myCodePoint2Offset.length) return getLength(); return isRtl() ? getLength() - myCodePoint2Offset[myCodePoint2Offset.length - column] : myCodePoint2Offset[column]; } | visualColumnToVisualOffset |
243,614 | int (int startColumn) { return getCodePointCount(); } | getLogicalColumnCount |
243,615 | int (float startX) { return getCodePointCount(); } | getVisualColumnCount |
243,616 | int (float startX, int column) { return visualColumnToVisualOffset(column); } | visualColumnToOffset |
243,617 | int[] (float startX, float x) { float relX = x - startX; float prevPos = 0; int columnCount = getCodePointCount(); for (int i = 0; i < columnCount; i++) { int visualOffset = visualColumnToVisualOffset(i); float newPos = myCharPositions[visualOffset]; if (relX < (newPos + prevPos) / 2) { return new int[] {i, relX <= pre... | xToVisualColumn |
243,618 | float (float startX, int column) { return startX + getX(visualColumnToVisualOffset(column)); } | visualColumnToX |
243,619 | void (Graphics2D g) { if (lastFragment != null) { g.setColor(lastColor); lastFragment.doDraw(g, lastStartX, lastY, lastStartColumn, lastEndColumn); lastFragment = null; } } | flushDrawingCache |
243,620 | void (int charCount, int glyphCount) { if (!LOG.isDebugEnabled()) return; ourCharsProcessed += charCount; ourGlyphsProcessed += glyphCount; if (++ourDrawingCount == 10000) { LOG.debug("Text rendering stats: " + ourCharsProcessed + " chars, " + ourGlyphsProcessed + " glyps, ratio - " + ((float) ourGlyphsProcessed) / our... | updateStats |
243,621 | void (@NotNull IncrementalCacheUpdateEvent event) { onSoftWrapRecalculationEnd(event); } | onRecalculationEnd |
243,622 | void () { myEditor.getSoftWrapModel().getApplianceManager().removeListener(mySoftWrapChangeListener); invalidateCachedBlockInlayWidth(); } | dispose |
243,623 | int () { return EditorDocumentPriorities.EDITOR_TEXT_WIDTH_CACHE; } | getPriority |
243,624 | void (@NotNull DocumentEvent event) { assertValidState(); // should be called at the start, as it can initiate soft wrap calculations myAfterLineEndInlayUpdated = false; myDuringDocumentUpdate = true; if (myDocument.isInBulkUpdate()) return; final int offset = event.getOffset(); // Although the result of getMoveOffset(... | beforeDocumentChange |
243,625 | void (@NotNull DocumentEvent event) { myDuringDocumentUpdate = false; if (myDocument.isInBulkUpdate()) return; doInvalidateRange(myDocumentChangeStartOffset, myDocumentChangeEndOffset); if (myAfterLineEndInlayUpdated) { int lineEndOffset = DocumentUtil.getLineEndOffset(myDocumentChangeEndOffset, myDocument); doInvalida... | documentChanged |
243,626 | void (@NotNull FoldRegion region) { if (myDocument.isInBulkUpdate()) return; if (region.isValid()) { myFoldingChangeStartOffset = Math.min(myFoldingChangeStartOffset, region.getStartOffset()); myFoldingChangeEndOffset = Math.max(myFoldingChangeEndOffset, region.getEndOffset()); } } | onFoldRegionStateChange |
243,627 | void (@NotNull FoldRegion region) { if (!myDuringDocumentUpdate || myDocument.isInBulkUpdate() || !(region instanceof CustomFoldRegion)) return; myDocumentChangeStartOffset = Math.min(myDocumentChangeStartOffset, region.getStartOffset()); myDocumentChangeEndOffset = Math.max(myDocumentChangeEndOffset, region.getEndOffs... | beforeFoldRegionDisposed |
243,628 | void (@NotNull CustomFoldRegion region, int flags) { if ((flags & ChangeFlags.WIDTH_CHANGED) == 0 || myDocument.isInBulkUpdate() || checkDirty()) return; int startOffset = region.getStartOffset(); if (myEditor.getFoldingModel().getCollapsedRegionAtOffset(startOffset) != region) return; int visualLine = myEditor.offsetT... | onCustomFoldRegionPropertiesChange |
243,629 | void () { if (myDocument.isInBulkUpdate()) return; if (myFoldingChangeStartOffset <= myFoldingChangeEndOffset) { doInvalidateRange(myFoldingChangeStartOffset, myFoldingChangeEndOffset); } myFoldingChangeStartOffset = Integer.MAX_VALUE; myFoldingChangeEndOffset = Integer.MIN_VALUE; for (TextRange range : myDeferredRange... | onFoldProcessingEnd |
243,630 | void (@NotNull Inlay<?> inlay) { if (myDocument.isInBulkUpdate() || myEditor.getInlayModel().isInBatchMode()) return; if (inlay.getPlacement() == Inlay.Placement.INLINE || inlay.getPlacement() == Inlay.Placement.AFTER_LINE_END) { onLineInlayUpdate(inlay); } else if (myWidestBlockInlayValid && inlay.getWidthInPixels() >... | onAdded |
243,631 | void (@NotNull Inlay<?> inlay) { if (myDocument.isInBulkUpdate() || myEditor.getInlayModel().isInBatchMode()) return; if (inlay.getPlacement() == Inlay.Placement.INLINE || inlay.getPlacement() == Inlay.Placement.AFTER_LINE_END) { onLineInlayUpdate(inlay); } else if (inlay == myWidestBlockInlay) { invalidateCachedBlockI... | onRemoved |
243,632 | void (@NotNull Inlay<?> inlay, int changeFlags) { if (myDocument.isInBulkUpdate() || myEditor.getInlayModel().isInBatchMode() || (changeFlags & InlayModel.ChangeFlags.WIDTH_CHANGED) == 0) { return; } if (inlay.getPlacement() == Inlay.Placement.INLINE || inlay.getPlacement() == Inlay.Placement.AFTER_LINE_END) { onLineIn... | onUpdated |
243,633 | void (@NotNull Editor editor) { if (myDocument.isInBulkUpdate()) return; getPreferredSize(); // make sure size is calculated (in case it will be required while batch mode is active) } | onBatchModeStart |
243,634 | void (@NotNull Editor editor) { if (myDocument.isInBulkUpdate()) return; reset(); } | onBatchModeFinish |
243,635 | void (@NotNull Inlay<?> inlay) { if (myDuringDocumentUpdate) { if (inlay.getPlacement() == Inlay.Placement.AFTER_LINE_END) { myAfterLineEndInlayUpdated = true; } return; } int offset = inlay.getOffset(); if (inlay.getPlacement() == Inlay.Placement.AFTER_LINE_END) { offset = DocumentUtil.getLineEndOffset(offset, myDocum... | onLineInlayUpdate |
243,636 | void (IncrementalCacheUpdateEvent event) { if (myDocument.isInBulkUpdate()) return; boolean invalidate = true; if (myEditor.getFoldingModel().isInBatchFoldingOperation()) { myFoldingChangeStartOffset = Math.min(myFoldingChangeStartOffset, event.getStartOffset()); myFoldingChangeEndOffset = Math.max(myFoldingChangeEndOf... | onSoftWrapRecalculationEnd |
243,637 | boolean (int widthWithoutCaret) { return !myEditor.getSoftWrapModel().isSoftWrappingEnabled() || myEditor.getSoftWrapModel().isRespectAdditionalColumns() || widthWithoutCaret > myEditor.getScrollingModel().getVisibleArea().getWidth(); } | shouldRespectAdditionalColumns |
243,638 | int () { if (!myWidthIsValid) { assert !myDocument.isInBulkUpdate(); assert !myEditor.getInlayModel().isInBatchMode(); boolean needFullScan = true; if (myStartInvalidLine <= myEndInvalidLine && (myEndInvalidLine - myStartInvalidLine) < SPECIFIC_LINES_RECALC_THRESHOLD ) { IntPair pair = calculateTextPreferredWidth(mySta... | getTextPreferredWidth |
243,639 | int (int beginLine, int endLine) { if (!myWidthIsValid) { assert !myDocument.isInBulkUpdate(); assert !myEditor.getInlayModel().isInBatchMode(); calculateTextPreferredWidth(0, Integer.MAX_VALUE); } int maxWidth = beginLine == 0 && endLine == 0 ? (int)myView.getPrefixTextWidthInPixels() : 0; for (int i = beginLine; i < ... | getTextPreferredWidthWithoutCaret |
243,640 | void () { if (myMaxLineWithExtensionWidth > 0) { boolean hasNoExtensions = myEditor.processLineExtensions(myWidestLineWithExtension, __ -> false); if (hasNoExtensions) { myMaxLineWithExtensionWidth = 0; } } } | validateMaxLineWithExtension |
243,641 | IntPair (int startVisualLine, int endVisualLine) { if (checkDirty()) { return new IntPair(1, 0); } assertValidState(); VisualLinesIterator iterator = new VisualLinesIterator(myEditor, startVisualLine); int maxWidth = 0; int largestLineNumber = 0; int caretVisualLine = myEditor.getCaretModel().getVisualPosition().line; ... | calculateTextPreferredWidth |
243,642 | int (@NotNull VisualLinesIterator iterator, @Nullable Runnable quickEvaluationListener) { CustomFoldRegion customFoldRegion = iterator.getCustomFoldRegion(); if (customFoldRegion != null) { return customFoldRegion.getWidthInPixels(); } int visualLine = iterator.getVisualLine(); FoldRegion[] topLevelRegions = myEditor.g... | calculateLineWidth |
243,643 | boolean () { if (myView.getEditor().isPurePaintingMode()) return false; FoldingModelImpl model = myView.getEditor().getFoldingModel(); if (model.isFoldingEnabled()) return true; model.setFoldingEnabled(true); FoldRegion[] regions; try { regions = model.fetchTopLevel(); } finally { model.setFoldingEnabled(false); } retu... | shouldUseLineWidthCache |
243,644 | void (int startOffset, int endOffset) { if (checkDirty()) return; int startVisualLine = myView.offsetToVisualLine(startOffset, false); int endVisualLine = myView.offsetToVisualLine(endOffset, true); int lineDiff = myEditor.getVisibleLineCount() - myLineWidths.size(); invalidateWidth(lineDiff == 0 && startVisualLine == ... | doInvalidateRange |
243,645 | int () { if (!myWidestBlockInlayValid) { myWidestBlockInlayValid = true; myWidestBlockInlay = null; myEditor.getInlayModel().getBlockElementsInRange(0, myDocument.getTextLength()).forEach(inlay -> { if (inlay.getWidthInPixels() > getCachedWidestBlockInlayWidth() && !EditorUtil.isInlayFolded(inlay)) { myWidestBlockInlay... | getMaximumVisibleBlockInlayWidth |
243,646 | int () { return myWidestBlockInlay == null ? 0 : myWidestBlockInlay.getWidthInPixels(); } | getCachedWidestBlockInlayWidth |
243,647 | void () { myWidestBlockInlayValid = false; myWidestBlockInlay = null; } | invalidateCachedBlockInlayWidth |
243,648 | void (int startOffset, int endOffset) { if (checkDirty()) return; boolean purePaintingMode = myEditor.isPurePaintingMode(); boolean foldingEnabled = myEditor.getFoldingModel().isFoldingEnabled(); myEditor.setPurePaintingMode(false); myEditor.getFoldingModel().setFoldingEnabled(true); try { int startVisualLine = myView.... | onTextLayoutPerformed |
243,649 | void (boolean invalidateOneLine, int invalidVisualLine) { myWidthIsValid = false; if (invalidateOneLine) { myStartInvalidLine = Math.min(myStartInvalidLine, invalidVisualLine); myEndInvalidLine = Math.max(myEndInvalidLine, invalidVisualLine); } else { myStartInvalidLine = 0; myEndInvalidLine = Integer.MAX_VALUE; } } | invalidateWidth |
243,650 | boolean () { if (myEditor.getSoftWrapModel().isDirty()) { myDirty = true; return true; } if (myDirty) { int visibleLineCount = myEditor.getVisibleLineCount(); int lineDiff = visibleLineCount - myLineWidths.size(); if (lineDiff > 0) { myLineWidths.addAll(IntArrayList.wrap(new int[lineDiff])); } else if (lineDiff < 0) { ... | checkDirty |
243,651 | String () { return "[cached width: " + myWidthInPixels + ", longest visual line: " + myWidthDefiningLineNumber + ", cached width is valid: " + myWidthIsValid + ", widest block inlay: " + myWidestBlockInlay + ", widest block inlay is valid: " + myWidestBlockInlayValid + ", invalid visual lines: [" + myStartInvalidLine +... | dumpState |
243,652 | void () { if (myDocument.isInBulkUpdate() || myEditor.getInlayModel().isInBatchMode() || myDirty) return; // 'getVisibleLineCount' should be called before accessing 'myLineWidths', as it can trigger soft wrap calculations if (myEditor.getVisibleLineCount() != myLineWidths.size()) { LOG.error("Inconsistent state", new A... | assertValidState |
243,653 | void () { if (myDocument.isInBulkUpdate() || myEditor.getInlayModel().isInBatchMode() || myDirty) return; for (int visualLine = 0; visualLine < myLineWidths.size(); visualLine++) { int cachedWidth = myLineWidths.getInt(visualLine); if (cachedWidth < 0 || cachedWidth == UNKNOWN_WIDTH) continue; Ref<Boolean> quickEvaluat... | assertCorrectCachedWidths |
243,654 | Iterable<Fragment> (@NotNull EditorView view, int offset, boolean beforeSoftWrap) { return create(view, offset, beforeSoftWrap, false); } | create |
243,655 | Iterable<Fragment> (@NotNull EditorView view, int offset, boolean beforeSoftWrap, boolean align) { return () -> new VisualLineFragmentsIterator(view, offset, beforeSoftWrap, align); } | create |
243,656 | Iterable<Fragment> (@NotNull EditorView view, @NotNull VisualLinesIterator visualLinesIterator, @Nullable Runnable quickEvaluationListener, boolean align) { return () -> new VisualLineFragmentsIterator(view, visualLinesIterator, quickEvaluationListener, align); } | create |
243,657 | void (EditorView view, int visualLine, int startOffset, int startLogicalLine, int currentOrPrevWrapIndex, int nextFoldingIndex, @Nullable Runnable quickEvaluationListener, boolean align) { myQuickEvaluationListener = quickEvaluationListener; myView = view; EditorImpl editor = view.getEditor(); myScaleContext = ScaleCon... | init |
243,658 | double (int width) { return PaintUtil.alignToInt(width, myScaleContext); } | alignToInt |
243,659 | void () { mySegmentEndOffset = getCurrentFoldRegionStartOffset(); assert mySegmentEndOffset >= mySegmentStartOffset; if (mySegmentEndOffset > mySegmentStartOffset) { mySegmentEndOffset = Math.min(myNextWrapOffset, Math.min(mySegmentEndOffset, myDocument.getLineEndOffset(myCurrentEndLogicalLine))); boolean normalLineEnd... | setInlaysAndFragmentIterator |
243,660 | void () { int startOffset = myCurrentInlayIndex > 0 ? myInlays.get(myCurrentInlayIndex - 1).getOffset() : mySegmentStartOffset; int endOffset = myCurrentInlayIndex < myInlays.size() ? myInlays.get(myCurrentInlayIndex).getOffset() : mySegmentEndOffset; int lineStartOffset = myDocument.getLineStartOffset(myCurrentEndLogi... | setFragmentIterator |
243,661 | int () { if (myCurrentFoldRegionIndex >= myRegions.length) { return Integer.MAX_VALUE; } int nextFoldingOffset = myRegions[myCurrentFoldRegionIndex].getStartOffset(); return nextFoldingOffset < myNextWrapOffset ? nextFoldingOffset : Integer.MAX_VALUE; } | getCurrentFoldRegionStartOffset |
243,662 | float () { return myFoldRegion instanceof CustomFoldRegion ? ((CustomFoldRegion)myFoldRegion).getWidthInPixels() : myView.getFoldRegionLayout(myFoldRegion).getWidth(); } | getFoldRegionWidthInPixels |
243,663 | int () { int maxVisualColumn = 0; for (LineLayout.VisualFragment fragment : myView.getFoldRegionLayout(myFoldRegion).getFragmentsInVisualOrder(0)) { maxVisualColumn = fragment.getEndVisualColumn(); } return maxVisualColumn; } | getFoldRegionWidthInColumns |
243,664 | int[] (float x) { LineLayout layout = myView.getFoldRegionLayout(myFoldRegion); for (LineLayout.VisualFragment fragment : layout.getFragmentsInVisualOrder(0)) { if (x <= fragment.getEndX()) { return fragment.xToVisualColumn(x); } } return new int[] {myFoldRegionColumns, 1}; } | getVisualColumnForXInsideFoldRegion |
243,665 | float (int column) { LineLayout layout = myView.getFoldRegionLayout(myFoldRegion); for (LineLayout.VisualFragment fragment : layout.getFragmentsInVisualOrder(0)) { if (column <= fragment.getEndVisualColumn()) { return fragment.visualColumnToX(column); } } return getFoldRegionWidthInPixels(); } | getXForVisualColumnInsideFoldRegion |
243,666 | float (int offset) { return offset < myFoldRegion.getEndOffset() ? 0 : getFoldRegionWidthInPixels(); } | getXForOffsetInsideFoldRegion |
243,667 | boolean () { return !(myFoldRegion instanceof CustomFoldRegion) && (mySegmentStartOffset == getCurrentFoldRegionStartOffset() || myFragmentIterator == null || myFragmentIterator.hasNext()); } | hasNext |
243,668 | Fragment () { if (!hasNext()) throw new NoSuchElementException(); myPrevX = myCurrentX; if (mySegmentStartOffset == getCurrentFoldRegionStartOffset()) { myDelegate = null; myFoldRegion = myRegions[myCurrentFoldRegionIndex]; assert myFoldRegion.isValid(); myFoldRegionColumns = getFoldRegionWidthInColumns(); mySegmentSta... | next |
243,669 | void () { throw new UnsupportedOperationException(); } | remove |
243,670 | boolean () { return myLocation.atEnd(); } | atEnd |
243,671 | void () { checkEnd(); if (y != UNSET) { y += EditorUtil.getTotalInlaysHeight(getBlockInlaysBelow()); y += getLineHeight(); } if (myNextLocation == null) { myLocation.advance(); } else { myLocation = myNextLocation; myNextLocation = null; } myInlaysSet = false; if (y != UNSET && !atEnd()) { y += EditorUtil.getTotalInlay... | advance |
243,672 | int () { checkEnd(); return myLocation.visualLine; } | getVisualLine |
243,673 | int () { checkEnd(); return myLocation.offset; } | getVisualLineStartOffset |
243,674 | int () { checkEnd(); setNextLocation(); return myNextLocation.atEnd() ? myDocument.getTextLength() : myNextLocation.softWrap == myLocation.softWrap ? myDocument.getLineEndOffset(myNextLocation.logicalLine - 2) : myNextLocation.offset; } | getVisualLineEndOffset |
243,675 | int () { checkEnd(); int foldIndex = myLocation.foldRegion; if (foldIndex < myFoldRegions.length) { FoldRegion foldRegion = myFoldRegions[foldIndex]; if (foldRegion.getPlaceholderText().isEmpty() && foldRegion.getStartOffset() == myLocation.offset) { return myDocument.getLineNumber(foldRegion.getEndOffset()); } } retur... | getDisplayedLogicalLine |
243,676 | int () { checkEnd(); return myLocation.logicalLine - 1; } | getStartLogicalLine |
243,677 | int () { checkEnd(); setNextLocation(); return myNextLocation.atEnd() ? Math.max(0, myDocument.getLineCount() - 1) : myNextLocation.logicalLine - (myNextLocation.softWrap == myLocation.softWrap ? 2 : 1); } | getEndLogicalLine |
243,678 | int () { checkEnd(); return myLocation.softWrap - 1; } | getStartOrPrevWrapIndex |
243,679 | int () { checkEnd(); return myLocation.foldRegion; } | getStartFoldingIndex |
243,680 | int () { checkEnd(); if (y == UNSET) { y = myEditor.visualLineToY(myLocation.visualLine); } return y; } | getY |
243,681 | boolean () { checkEnd(); return myLocation.softWrap > 0 && myLocation.softWrap <= mySoftWraps.size() && mySoftWraps.get(myLocation.softWrap - 1).getStart() == myLocation.offset; } | startsWithSoftWrap |
243,682 | boolean () { checkEnd(); return myLocation.softWrap < mySoftWraps.size() && mySoftWraps.get(myLocation.softWrap).getStart() == getVisualLineEndOffset(); } | endsWithSoftWrap |
243,683 | CustomFoldRegion () { checkEnd(); int foldIndex = myLocation.foldRegion; if (foldIndex < myFoldRegions.length) { FoldRegion foldRegion = myFoldRegions[foldIndex]; if (foldRegion instanceof CustomFoldRegion && foldRegion.getStartOffset() == myLocation.offset) { return (CustomFoldRegion)foldRegion; } } return null; } | getCustomFoldRegion |
243,684 | boolean () { return getCustomFoldRegion() != null; } | isCustomFoldRegionLine |
243,685 | int () { CustomFoldRegion region = getCustomFoldRegion(); return region == null ? myLineHeight : region.getHeightInPixels(); } | getLineHeight |
243,686 | void () { if (atEnd()) throw new IllegalStateException("Iteration finished"); } | checkEnd |
243,687 | void () { if (myNextLocation == null) { myNextLocation = myLocation.clone(); myNextLocation.advance(); } } | setNextLocation |
243,688 | void () { if (myInlaysSet) return; myInlaysSet = true; myInlaysAbove.clear(); myInlaysBelow.clear(); setNextLocation(); List<Inlay<?>> inlays = myEditor.getInlayModel() .getBlockElementsInRange(myLocation.offset, myNextLocation.atEnd() ? myDocument.getTextLength() : myNextLocation.offset - 1); for (Inlay<?> inlay : inl... | setInlays |
243,689 | void () { int nextWrapOffset = getNextSoftWrapOffset(); offset = getNextVisualLineStartOffset(nextWrapOffset); if (offset == Integer.MAX_VALUE) { offset = -1; } else if (offset == nextWrapOffset) { softWrap++; } visualLine++; while (foldRegion < myFoldRegions.length && myFoldRegions[foldRegion].getStartOffset() < offse... | advance |
243,690 | int () { return softWrap < mySoftWraps.size() ? mySoftWraps.get(softWrap).getStart() : Integer.MAX_VALUE; } | getNextSoftWrapOffset |
243,691 | int (int nextWrapOffset) { while (logicalLine < myDocument.getLineCount()) { int lineStartOffset = myDocument.getLineStartOffset(logicalLine); if (lineStartOffset > nextWrapOffset) return nextWrapOffset; logicalLine++; if (!isCollapsed(lineStartOffset)) return lineStartOffset; } return nextWrapOffset; } | getNextVisualLineStartOffset |
243,692 | boolean (int offset) { while (foldRegion < myFoldRegions.length) { FoldRegion region = myFoldRegions[foldRegion]; if (offset <= region.getStartOffset()) return false; if (offset <= region.getEndOffset()) return true; foldRegion++; } return false; } | isCollapsed |
243,693 | boolean () { return offset == -1; } | atEnd |
243,694 | Location () { try { return (Location)super.clone(); } catch (CloneNotSupportedException e) { throw new RuntimeException(e); } } | clone |
243,695 | int () { return myChange.getStart(); } | getStart |
243,696 | int () { return myChange.getEnd(); } | getEnd |
243,697 | CharSequence () { return myChange.getText(); } | getText |
243,698 | int () { return myIndentInColumns; } | getIndentInColumns |
243,699 | int () { return myIndentInPixels; } | getIndentInPixels |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.