boolean () { if (myInProgress) { return false; } // Check if we need to recalculate soft wraps due to indent settings change. boolean indentChanged = false; IndentType currentIndentType = getIndentToUse(); boolean useCustomIndent = currentIndentType == IndentType.CUSTOM; int currentCustomIndent = myEditor.getSettings().getCustomSoftWrapIndent(); if (useCustomIndent ^ myCustomIndentUsedLastTime || useCustomIndent && myCustomIndentValueUsedLastTime != currentCustomIndent) { indentChanged = true; } myCustomIndentUsedLastTime = useCustomIndent; myCustomIndentValueUsedLastTime = currentCustomIndent; // Check if we need to recalculate soft wraps due to visible area width change. int currentVisibleAreaWidth = myAvailableWidth; if (!indentChanged && myVisibleAreaWidth == currentVisibleAreaWidth) { return recalculateSoftWraps(); // Recalculate existing dirty regions if any. } // We experienced the following situation: // 1. Editor is configured to show scroll bars only when necessary; // 2. Editor with active soft wraps is changed in order for the vertical scroll bar to appear; // 3. Vertical scrollbar consumes vertical space, hence, soft wraps are recalculated because of the visual area width change; // 4. Newly recalculated soft wraps trigger editor size update; // 5. Editor size update starts scroll pane update which, in turn, disables vertical scroll bar at first (the reason for that // lays somewhere at the swing depth); // 6. Soft wraps are recalculated because of visible area width change caused by the disabled vertical scroll bar; // 7. Go to the step 4; // I.e. we have an endless EDT activity that stops only when editor is re-sized in a way to avoid vertical scroll bar. // That's why we don't recalculate soft wraps when visual area width is changed to the vertical scroll bar width value assuming // that such a situation is triggered by the scroll bar (dis)appearance. if (currentVisibleAreaWidth - myVisibleAreaWidth == getVerticalScrollBarWidth()) { myVisibleAreaWidth = currentVisibleAreaWidth; return recalculateSoftWraps(); } // We want to adjust viewport's 'y' coordinate on complete recalculation, so, we remember number of soft-wrapped lines // before the target offset on recalculation start and compare it with the number of soft-wrapped lines before the same offset // after the recalculation. final ScrollingModelEx scrollingModel = myEditor.getScrollingModel(); int yScrollOffset = scrollingModel.getVerticalScrollOffset(); int anchorOffset = myLastTopLeftCornerOffset; int softWrapsBefore = getNumberOfSoftWrapsBefore(anchorOffset); // Drop information about processed lines. reset(); myStorage.removeAll(); myVisibleAreaWidth = currentVisibleAreaWidth; final boolean result = recalculateSoftWraps(); if (!result) { return false; } // Adjust viewport's 'y' coordinate if necessary. int softWrapsNow = getNumberOfSoftWrapsBefore(anchorOffset); if (softWrapsNow != softWrapsBefore) { scrollingModel.disableAnimation(); try { scrollingModel.scrollVertically(yScrollOffset + (softWrapsNow - softWrapsBefore) * myEditor.getLineHeight()); } finally { scrollingModel.enableAnimation(); } } updateLastTopLeftCornerOffset(); return true; }