diff --git a/spec/text-editor-presenter-spec.coffee b/spec/text-editor-presenter-spec.coffee index 2ee966630..662b9d483 100644 --- a/spec/text-editor-presenter-spec.coffee +++ b/spec/text-editor-presenter-spec.coffee @@ -45,7 +45,7 @@ describe "TextEditorPresenter", -> expectStateUpdate = (presenter, fn) -> updatedState = false - disposable = presenter.onDidUpdateState -> + disposable = presenter.onNeedsUpdate -> updatedState = true disposable.dispose() fn() @@ -61,21 +61,20 @@ describe "TextEditorPresenter", -> lineHeight: 10 horizontalScrollbarHeight: 10 verticalScrollbarWidth: 10 - {state} = presenter - expect(state.horizontalScrollbar.visible).toBe false + expect(presenter.getState().horizontalScrollbar.visible).toBe false # ::contentFrameWidth itself is smaller than scrollWidth presenter.setContentFrameWidth(editor.getMaxScreenLineLength() * 10) - expect(state.horizontalScrollbar.visible).toBe true + expect(presenter.getState().horizontalScrollbar.visible).toBe true # restore... presenter.setContentFrameWidth(editor.getMaxScreenLineLength() * 10 + 1) - expect(state.horizontalScrollbar.visible).toBe false + expect(presenter.getState().horizontalScrollbar.visible).toBe false # visible vertical scrollbar makes the clientWidth smaller than the scrollWidth presenter.setExplicitHeight((editor.getLineCount() * 10) - 1) - expect(state.horizontalScrollbar.visible).toBe true + expect(presenter.getState().horizontalScrollbar.visible).toBe true it "is false if the editor is mini", -> presenter = buildPresenter @@ -83,18 +82,18 @@ describe "TextEditorPresenter", -> contentFrameWidth: editor.getMaxScreenLineLength() * 10 - 10 baseCharacterWidth: 10 - expect(presenter.state.horizontalScrollbar.visible).toBe true + expect(presenter.getState().horizontalScrollbar.visible).toBe true editor.setMini(true) - expect(presenter.state.horizontalScrollbar.visible).toBe false + expect(presenter.getState().horizontalScrollbar.visible).toBe false editor.setMini(false) - expect(presenter.state.horizontalScrollbar.visible).toBe true + expect(presenter.getState().horizontalScrollbar.visible).toBe true describe ".height", -> it "tracks the value of ::horizontalScrollbarHeight", -> presenter = buildPresenter(horizontalScrollbarHeight: 10) - expect(presenter.state.horizontalScrollbar.height).toBe 10 + expect(presenter.getState().horizontalScrollbar.height).toBe 10 expectStateUpdate presenter, -> presenter.setHorizontalScrollbarHeight(20) - expect(presenter.state.horizontalScrollbar.height).toBe 20 + expect(presenter.getState().horizontalScrollbar.height).toBe 20 describe ".right", -> it "is ::verticalScrollbarWidth if the vertical scrollbar is visible and 0 otherwise", -> @@ -105,37 +104,36 @@ describe "TextEditorPresenter", -> lineHeight: 10 horizontalScrollbarHeight: 10 verticalScrollbarWidth: 10 - {state} = presenter - expect(state.horizontalScrollbar.right).toBe 0 + expect(presenter.getState().horizontalScrollbar.right).toBe 0 presenter.setExplicitHeight((editor.getLineCount() * 10) - 1) - expect(state.horizontalScrollbar.right).toBe 10 + expect(presenter.getState().horizontalScrollbar.right).toBe 10 describe ".scrollWidth", -> it "is initialized as the max of the ::contentFrameWidth and the width of the longest line", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 presenter = buildPresenter(contentFrameWidth: 10 * maxLineLength + 20, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 20 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 20 it "updates when the ::contentFrameWidth changes", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setContentFrameWidth(10 * maxLineLength + 20) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 20 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 20 it "updates when the ::baseCharacterWidth changes", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(15) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 15 * maxLineLength + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 15 * maxLineLength + 1 it "updates when the scoped character widths change", -> waitsForPromise -> atom.packages.activatePackage('language-javascript') @@ -144,58 +142,58 @@ describe "TextEditorPresenter", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setScopedCharacterWidth(['source.js', 'support.function.js'], 'p', 20) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe (10 * (maxLineLength - 2)) + (20 * 2) + 1 # 2 of the characters are 20px wide now instead of 10px wide + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe (10 * (maxLineLength - 2)) + (20 * 2) + 1 # 2 of the characters are 20px wide now instead of 10px wide it "updates when ::softWrapped changes on the editor", -> presenter = buildPresenter(contentFrameWidth: 470, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 expectStateUpdate presenter, -> editor.setSoftWrapped(true) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe presenter.clientWidth expectStateUpdate presenter, -> editor.setSoftWrapped(false) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 it "updates when the longest line changes", -> presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 expectStateUpdate presenter, -> editor.setCursorBufferPosition([editor.getLongestScreenRow(), 0]) expectStateUpdate presenter, -> editor.insertText('xyz') - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 describe ".scrollLeft", -> it "tracks the value of ::scrollLeft", -> presenter = buildPresenter(scrollLeft: 10, verticalScrollbarWidth: 10, contentFrameWidth: 500) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe 10 + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe 10 expectStateUpdate presenter, -> presenter.setScrollLeft(50) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe 50 + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe 50 it "never exceeds the computed scrollWidth minus the computed clientWidth", -> presenter = buildPresenter(scrollLeft: 10, verticalScrollbarWidth: 10, explicitHeight: 100, contentFrameWidth: 500) expectStateUpdate presenter, -> presenter.setScrollLeft(300) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> presenter.setContentFrameWidth(600) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> presenter.setVerticalScrollbarWidth(5) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> editor.getBuffer().delete([[6, 0], [6, Infinity]]) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth # Scroll top only gets smaller when needed as dimensions change, never bigger - scrollLeftBefore = presenter.state.horizontalScrollbar.scrollLeft + scrollLeftBefore = presenter.getState().horizontalScrollbar.scrollLeft expectStateUpdate presenter, -> editor.getBuffer().insert([6, 0], new Array(100).join('x')) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe scrollLeftBefore + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe scrollLeftBefore it "never goes negative", -> presenter = buildPresenter(scrollLeft: 10, verticalScrollbarWidth: 10, contentFrameWidth: 500) expectStateUpdate presenter, -> presenter.setScrollLeft(-300) - expect(presenter.state.horizontalScrollbar.scrollLeft).toBe 0 + expect(presenter.getState().horizontalScrollbar.scrollLeft).toBe 0 describe ".verticalScrollbar", -> describe ".visible", -> @@ -208,28 +206,27 @@ describe "TextEditorPresenter", -> lineHeight: 10 horizontalScrollbarHeight: 10 verticalScrollbarWidth: 10 - {state} = presenter - expect(state.verticalScrollbar.visible).toBe false + expect(presenter.getState().verticalScrollbar.visible).toBe false # ::explicitHeight itself is smaller than scrollWidth presenter.setExplicitHeight(editor.getLineCount() * 10 - 1) - expect(state.verticalScrollbar.visible).toBe true + expect(presenter.getState().verticalScrollbar.visible).toBe true # restore... presenter.setExplicitHeight(editor.getLineCount() * 10) - expect(state.verticalScrollbar.visible).toBe false + expect(presenter.getState().verticalScrollbar.visible).toBe false # visible horizontal scrollbar makes the clientHeight smaller than the scrollHeight presenter.setContentFrameWidth(editor.getMaxScreenLineLength() * 10) - expect(state.verticalScrollbar.visible).toBe true + expect(presenter.getState().verticalScrollbar.visible).toBe true describe ".width", -> it "is assigned based on ::verticalScrollbarWidth", -> presenter = buildPresenter(verticalScrollbarWidth: 10) - expect(presenter.state.verticalScrollbar.width).toBe 10 + expect(presenter.getState().verticalScrollbar.width).toBe 10 expectStateUpdate presenter, -> presenter.setVerticalScrollbarWidth(20) - expect(presenter.state.verticalScrollbar.width).toBe 20 + expect(presenter.getState().verticalScrollbar.width).toBe 20 describe ".bottom", -> it "is ::horizontalScrollbarHeight if the horizontal scrollbar is visible and 0 otherwise", -> @@ -240,131 +237,130 @@ describe "TextEditorPresenter", -> lineHeight: 10 horizontalScrollbarHeight: 10 verticalScrollbarWidth: 10 - {state} = presenter - expect(state.verticalScrollbar.bottom).toBe 0 + expect(presenter.getState().verticalScrollbar.bottom).toBe 0 presenter.setContentFrameWidth(editor.getMaxScreenLineLength() * 10) - expect(state.verticalScrollbar.bottom).toBe 10 + expect(presenter.getState().verticalScrollbar.bottom).toBe 10 describe ".scrollHeight", -> it "is initialized based on the lineHeight, the number of lines, and the height", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 10 presenter = buildPresenter(scrollTop: 0, lineHeight: 10, explicitHeight: 500) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe 500 + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe 500 it "updates when the ::lineHeight changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> presenter.setLineHeight(20) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 20 + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 20 it "updates when the line count changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> editor.getBuffer().append("\n\n\n") - expect(presenter.state.verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe editor.getScreenLineCount() * 10 it "updates when ::explicitHeight changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> presenter.setExplicitHeight(500) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe 500 + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe 500 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe presenter.contentHeight expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", true) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.verticalScrollbar.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().verticalScrollbar.scrollHeight).toBe presenter.contentHeight describe ".scrollTop", -> it "tracks the value of ::scrollTop", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 20, horizontalScrollbarHeight: 10) - expect(presenter.state.verticalScrollbar.scrollTop).toBe 10 + expect(presenter.getState().verticalScrollbar.scrollTop).toBe 10 expectStateUpdate presenter, -> presenter.setScrollTop(50) - expect(presenter.state.verticalScrollbar.scrollTop).toBe 50 + expect(presenter.getState().verticalScrollbar.scrollTop).toBe 50 it "never exceeds the computed scrollHeight minus the computed clientHeight", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(100) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setExplicitHeight(60) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setHorizontalScrollbarHeight(5) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> editor.getBuffer().delete([[8, 0], [12, 0]]) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight # Scroll top only gets smaller when needed as dimensions change, never bigger - scrollTopBefore = presenter.state.verticalScrollbar.scrollTop + scrollTopBefore = presenter.getState().verticalScrollbar.scrollTop expectStateUpdate presenter, -> editor.getBuffer().insert([9, Infinity], '\n\n\n') - expect(presenter.state.verticalScrollbar.scrollTop).toBe scrollTopBefore + expect(presenter.getState().verticalScrollbar.scrollTop).toBe scrollTopBefore it "never goes negative", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(-100) - expect(presenter.state.verticalScrollbar.scrollTop).toBe 0 + expect(presenter.getState().verticalScrollbar.scrollTop).toBe 0 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.contentHeight - presenter.clientHeight atom.config.set("editor.scrollPastEnd", true) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.verticalScrollbar.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().verticalScrollbar.scrollTop).toBe presenter.contentHeight - presenter.clientHeight describe ".hiddenInput", -> describe ".top/.left", -> it "is positioned over the last cursor it is in view and the editor is focused", -> editor.setCursorBufferPosition([3, 6]) presenter = buildPresenter(focused: false, explicitHeight: 50, contentFrameWidth: 300, horizontalScrollbarHeight: 0, verticalScrollbarWidth: 0) - expectValues presenter.state.hiddenInput, {top: 0, left: 0} + expectValues presenter.getState().hiddenInput, {top: 0, left: 0} expectStateUpdate presenter, -> presenter.setFocused(true) - expectValues presenter.state.hiddenInput, {top: 3 * 10, left: 6 * 10} + expectValues presenter.getState().hiddenInput, {top: 3 * 10, left: 6 * 10} expectStateUpdate presenter, -> presenter.setScrollTop(15) - expectValues presenter.state.hiddenInput, {top: (3 * 10) - 15, left: 6 * 10} + expectValues presenter.getState().hiddenInput, {top: (3 * 10) - 15, left: 6 * 10} expectStateUpdate presenter, -> presenter.setScrollLeft(35) - expectValues presenter.state.hiddenInput, {top: (3 * 10) - 15, left: (6 * 10) - 35} + expectValues presenter.getState().hiddenInput, {top: (3 * 10) - 15, left: (6 * 10) - 35} expectStateUpdate presenter, -> presenter.setScrollTop(40) - expectValues presenter.state.hiddenInput, {top: 0, left: (6 * 10) - 35} + expectValues presenter.getState().hiddenInput, {top: 0, left: (6 * 10) - 35} expectStateUpdate presenter, -> presenter.setScrollLeft(70) - expectValues presenter.state.hiddenInput, {top: 0, left: 0} + expectValues presenter.getState().hiddenInput, {top: 0, left: 0} expectStateUpdate presenter, -> editor.setCursorBufferPosition([11, 43]) - expectValues presenter.state.hiddenInput, {top: 50 - 10, left: 300 - 10} + expectValues presenter.getState().hiddenInput, {top: 50 - 10, left: 300 - 10} newCursor = null expectStateUpdate presenter, -> newCursor = editor.addCursorAtBufferPosition([6, 10]) - expectValues presenter.state.hiddenInput, {top: (6 * 10) - 40, left: (10 * 10) - 70} + expectValues presenter.getState().hiddenInput, {top: (6 * 10) - 40, left: (10 * 10) - 70} expectStateUpdate presenter, -> newCursor.destroy() - expectValues presenter.state.hiddenInput, {top: 50 - 10, left: 300 - 10} + expectValues presenter.getState().hiddenInput, {top: 50 - 10, left: 300 - 10} expectStateUpdate presenter, -> presenter.setFocused(false) - expectValues presenter.state.hiddenInput, {top: 0, left: 0} + expectValues presenter.getState().hiddenInput, {top: 0, left: 0} describe ".height", -> it "is assigned based on the line height", -> presenter = buildPresenter() - expect(presenter.state.hiddenInput.height).toBe 10 + expect(presenter.getState().hiddenInput.height).toBe 10 expectStateUpdate presenter, -> presenter.setLineHeight(20) - expect(presenter.state.hiddenInput.height).toBe 20 + expect(presenter.getState().hiddenInput.height).toBe 20 describe ".width", -> it "is assigned based on the width of the character following the cursor", -> @@ -373,93 +369,93 @@ describe "TextEditorPresenter", -> runs -> editor.setCursorBufferPosition([3, 6]) presenter = buildPresenter() - expect(presenter.state.hiddenInput.width).toBe 10 + expect(presenter.getState().hiddenInput.width).toBe 10 expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(15) - expect(presenter.state.hiddenInput.width).toBe 15 + expect(presenter.getState().hiddenInput.width).toBe 15 expectStateUpdate presenter, -> presenter.setScopedCharacterWidth(['source.js', 'storage.modifier.js'], 'r', 20) - expect(presenter.state.hiddenInput.width).toBe 20 + expect(presenter.getState().hiddenInput.width).toBe 20 it "is 2px at the end of lines", -> presenter = buildPresenter() editor.setCursorBufferPosition([3, Infinity]) - expect(presenter.state.hiddenInput.width).toBe 2 + expect(presenter.getState().hiddenInput.width).toBe 2 describe ".content", -> describe ".scrollingVertically", -> it "is true for ::stoppedScrollingDelay milliseconds following a changes to ::scrollTop", -> presenter = buildPresenter(scrollTop: 10, stoppedScrollingDelay: 200, explicitHeight: 100) - expect(presenter.state.content.scrollingVertically).toBe false + expect(presenter.getState().content.scrollingVertically).toBe false expectStateUpdate presenter, -> presenter.setScrollTop(0) - expect(presenter.state.content.scrollingVertically).toBe true + expect(presenter.getState().content.scrollingVertically).toBe true advanceClock(100) - expect(presenter.state.content.scrollingVertically).toBe true + expect(presenter.getState().content.scrollingVertically).toBe true presenter.setScrollTop(10) advanceClock(100) - expect(presenter.state.content.scrollingVertically).toBe true + expect(presenter.getState().content.scrollingVertically).toBe true expectStateUpdate presenter, -> advanceClock(100) - expect(presenter.state.content.scrollingVertically).toBe false + expect(presenter.getState().content.scrollingVertically).toBe false describe ".scrollHeight", -> it "is initialized based on the lineHeight, the number of lines, and the height", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) - expect(presenter.state.content.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().content.scrollHeight).toBe editor.getScreenLineCount() * 10 presenter = buildPresenter(scrollTop: 0, lineHeight: 10, explicitHeight: 500) - expect(presenter.state.content.scrollHeight).toBe 500 + expect(presenter.getState().content.scrollHeight).toBe 500 it "updates when the ::lineHeight changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> presenter.setLineHeight(20) - expect(presenter.state.content.scrollHeight).toBe editor.getScreenLineCount() * 20 + expect(presenter.getState().content.scrollHeight).toBe editor.getScreenLineCount() * 20 it "updates when the line count changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> editor.getBuffer().append("\n\n\n") - expect(presenter.state.content.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().content.scrollHeight).toBe editor.getScreenLineCount() * 10 it "updates when ::explicitHeight changes", -> presenter = buildPresenter(scrollTop: 0, lineHeight: 10) expectStateUpdate presenter, -> presenter.setExplicitHeight(500) - expect(presenter.state.content.scrollHeight).toBe 500 + expect(presenter.getState().content.scrollHeight).toBe 500 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.content.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().content.scrollHeight).toBe presenter.contentHeight expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", true) - expect(presenter.state.content.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) + expect(presenter.getState().content.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.content.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().content.scrollHeight).toBe presenter.contentHeight describe ".scrollWidth", -> it "is initialized as the max of the computed clientWidth and the width of the longest line", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(explicitHeight: 100, contentFrameWidth: 50, baseCharacterWidth: 10, verticalScrollbarWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 1 presenter = buildPresenter(explicitHeight: 100, contentFrameWidth: 10 * maxLineLength + 20, baseCharacterWidth: 10, verticalScrollbarWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 20 - 10 # subtract vertical scrollbar width + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 20 - 10 # subtract vertical scrollbar width it "updates when the ::contentFrameWidth changes", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setContentFrameWidth(10 * maxLineLength + 20) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 20 + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 20 it "updates when the ::baseCharacterWidth changes", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setBaseCharacterWidth(15) - expect(presenter.state.content.scrollWidth).toBe 15 * maxLineLength + 1 + expect(presenter.getState().content.scrollWidth).toBe 15 * maxLineLength + 1 it "updates when the scoped character widths change", -> waitsForPromise -> atom.packages.activatePackage('language-javascript') @@ -468,184 +464,184 @@ describe "TextEditorPresenter", -> maxLineLength = editor.getMaxScreenLineLength() presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * maxLineLength + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * maxLineLength + 1 expectStateUpdate presenter, -> presenter.setScopedCharacterWidth(['source.js', 'support.function.js'], 'p', 20) - expect(presenter.state.content.scrollWidth).toBe (10 * (maxLineLength - 2)) + (20 * 2) + 1 # 2 of the characters are 20px wide now instead of 10px wide + expect(presenter.getState().content.scrollWidth).toBe (10 * (maxLineLength - 2)) + (20 * 2) + 1 # 2 of the characters are 20px wide now instead of 10px wide it "updates when ::softWrapped changes on the editor", -> presenter = buildPresenter(contentFrameWidth: 470, baseCharacterWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 expectStateUpdate presenter, -> editor.setSoftWrapped(true) - expect(presenter.state.horizontalScrollbar.scrollWidth).toBe presenter.clientWidth + expect(presenter.getState().horizontalScrollbar.scrollWidth).toBe presenter.clientWidth expectStateUpdate presenter, -> editor.setSoftWrapped(false) - expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 it "updates when the longest line changes", -> presenter = buildPresenter(contentFrameWidth: 50, baseCharacterWidth: 10) - expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 expectStateUpdate presenter, -> editor.setCursorBufferPosition([editor.getLongestScreenRow(), 0]) expectStateUpdate presenter, -> editor.insertText('xyz') - expect(presenter.state.content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 + expect(presenter.getState().content.scrollWidth).toBe 10 * editor.getMaxScreenLineLength() + 1 describe ".scrollTop", -> it "tracks the value of ::scrollTop", -> presenter = buildPresenter(scrollTop: 10, lineHeight: 10, explicitHeight: 20) - expect(presenter.state.content.scrollTop).toBe 10 + expect(presenter.getState().content.scrollTop).toBe 10 expectStateUpdate presenter, -> presenter.setScrollTop(50) - expect(presenter.state.content.scrollTop).toBe 50 + expect(presenter.getState().content.scrollTop).toBe 50 it "never exceeds the computed scroll height minus the computed client height", -> presenter = buildPresenter(scrollTop: 10, lineHeight: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(100) - expect(presenter.state.content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setExplicitHeight(60) - expect(presenter.state.content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setHorizontalScrollbarHeight(5) - expect(presenter.state.content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> editor.getBuffer().delete([[8, 0], [12, 0]]) - expect(presenter.state.content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight # Scroll top only gets smaller when needed as dimensions change, never bigger - scrollTopBefore = presenter.state.verticalScrollbar.scrollTop + scrollTopBefore = presenter.getState().verticalScrollbar.scrollTop expectStateUpdate presenter, -> editor.getBuffer().insert([9, Infinity], '\n\n\n') - expect(presenter.state.content.scrollTop).toBe scrollTopBefore + expect(presenter.getState().content.scrollTop).toBe scrollTopBefore it "never goes negative", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(-100) - expect(presenter.state.content.scrollTop).toBe 0 + expect(presenter.getState().content.scrollTop).toBe 0 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.content.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.contentHeight - presenter.clientHeight atom.config.set("editor.scrollPastEnd", true) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.content.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) + expect(presenter.getState().content.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.content.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().content.scrollTop).toBe presenter.contentHeight - presenter.clientHeight describe ".scrollLeft", -> it "tracks the value of ::scrollLeft", -> presenter = buildPresenter(scrollLeft: 10, lineHeight: 10, baseCharacterWidth: 10, verticalScrollbarWidth: 10, contentFrameWidth: 500) - expect(presenter.state.content.scrollLeft).toBe 10 + expect(presenter.getState().content.scrollLeft).toBe 10 expectStateUpdate presenter, -> presenter.setScrollLeft(50) - expect(presenter.state.content.scrollLeft).toBe 50 + expect(presenter.getState().content.scrollLeft).toBe 50 it "never exceeds the computed scrollWidth minus the computed clientWidth", -> presenter = buildPresenter(scrollLeft: 10, lineHeight: 10, baseCharacterWidth: 10, verticalScrollbarWidth: 10, contentFrameWidth: 500) expectStateUpdate presenter, -> presenter.setScrollLeft(300) - expect(presenter.state.content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> presenter.setContentFrameWidth(600) - expect(presenter.state.content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> presenter.setVerticalScrollbarWidth(5) - expect(presenter.state.content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth expectStateUpdate presenter, -> editor.getBuffer().delete([[6, 0], [6, Infinity]]) - expect(presenter.state.content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth + expect(presenter.getState().content.scrollLeft).toBe presenter.scrollWidth - presenter.clientWidth # Scroll top only gets smaller when needed as dimensions change, never bigger - scrollLeftBefore = presenter.state.content.scrollLeft + scrollLeftBefore = presenter.getState().content.scrollLeft expectStateUpdate presenter, -> editor.getBuffer().insert([6, 0], new Array(100).join('x')) - expect(presenter.state.content.scrollLeft).toBe scrollLeftBefore + expect(presenter.getState().content.scrollLeft).toBe scrollLeftBefore it "never goes negative", -> presenter = buildPresenter(scrollLeft: 10, verticalScrollbarWidth: 10, contentFrameWidth: 500) expectStateUpdate presenter, -> presenter.setScrollLeft(-300) - expect(presenter.state.content.scrollLeft).toBe 0 + expect(presenter.getState().content.scrollLeft).toBe 0 describe ".indentGuidesVisible", -> it "is initialized based on the editor.showIndentGuide config setting", -> presenter = buildPresenter() - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false atom.config.set('editor.showIndentGuide', true) presenter = buildPresenter() - expect(presenter.state.content.indentGuidesVisible).toBe true + expect(presenter.getState().content.indentGuidesVisible).toBe true it "updates when the editor.showIndentGuide config setting changes", -> presenter = buildPresenter() - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false expectStateUpdate presenter, -> atom.config.set('editor.showIndentGuide', true) - expect(presenter.state.content.indentGuidesVisible).toBe true + expect(presenter.getState().content.indentGuidesVisible).toBe true expectStateUpdate presenter, -> atom.config.set('editor.showIndentGuide', false) - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false it "updates when the editor's grammar changes", -> atom.config.set('editor.showIndentGuide', true, scopeSelector: ".source.js") presenter = buildPresenter() - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false stateUpdated = false - presenter.onDidUpdateState -> stateUpdated = true + presenter.onNeedsUpdate -> stateUpdated = true waitsForPromise -> atom.packages.activatePackage('language-javascript') runs -> expect(stateUpdated).toBe true - expect(presenter.state.content.indentGuidesVisible).toBe true + expect(presenter.getState().content.indentGuidesVisible).toBe true expectStateUpdate presenter, -> editor.setGrammar(atom.grammars.selectGrammar('.txt')) - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false it "is always false when the editor is mini", -> atom.config.set('editor.showIndentGuide', true) editor.setMini(true) presenter = buildPresenter() - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false editor.setMini(false) - expect(presenter.state.content.indentGuidesVisible).toBe true + expect(presenter.getState().content.indentGuidesVisible).toBe true editor.setMini(true) - expect(presenter.state.content.indentGuidesVisible).toBe false + expect(presenter.getState().content.indentGuidesVisible).toBe false describe ".backgroundColor", -> it "is assigned to ::backgroundColor unless the editor is mini", -> presenter = buildPresenter(backgroundColor: 'rgba(255, 0, 0, 0)') - expect(presenter.state.content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' + expect(presenter.getState().content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' editor.setMini(true) presenter = buildPresenter(backgroundColor: 'rgba(255, 0, 0, 0)') - expect(presenter.state.content.backgroundColor).toBeNull() + expect(presenter.getState().content.backgroundColor).toBeNull() it "updates when ::backgroundColor changes", -> presenter = buildPresenter(backgroundColor: 'rgba(255, 0, 0, 0)') - expect(presenter.state.content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' + expect(presenter.getState().content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' expectStateUpdate presenter, -> presenter.setBackgroundColor('rgba(0, 0, 255, 0)') - expect(presenter.state.content.backgroundColor).toBe 'rgba(0, 0, 255, 0)' + expect(presenter.getState().content.backgroundColor).toBe 'rgba(0, 0, 255, 0)' it "updates when ::mini changes", -> presenter = buildPresenter(backgroundColor: 'rgba(255, 0, 0, 0)') - expect(presenter.state.content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' + expect(presenter.getState().content.backgroundColor).toBe 'rgba(255, 0, 0, 0)' expectStateUpdate presenter, -> editor.setMini(true) - expect(presenter.state.content.backgroundColor).toBeNull() + expect(presenter.getState().content.backgroundColor).toBeNull() describe ".placeholderText", -> it "is present when the editor has no text", -> editor.setPlaceholderText("the-placeholder-text") presenter = buildPresenter() - expect(presenter.state.content.placeholderText).toBeNull() + expect(presenter.getState().content.placeholderText).toBeNull() expectStateUpdate presenter, -> editor.setText("") - expect(presenter.state.content.placeholderText).toBe "the-placeholder-text" + expect(presenter.getState().content.placeholderText).toBe "the-placeholder-text" expectStateUpdate presenter, -> editor.setPlaceholderText("new-placeholder-text") - expect(presenter.state.content.placeholderText).toBe "new-placeholder-text" + expect(presenter.getState().content.placeholderText).toBe "new-placeholder-text" describe ".lines", -> lineStateForScreenRow = (presenter, screenRow) -> - presenter.state.content.lines[presenter.model.tokenizedLineForScreenRow(screenRow).id] + presenter.getState().content.lines[presenter.model.tokenizedLineForScreenRow(screenRow).id] it "contains states for lines that are visible on screen, plus and minus the overdraw margin", -> presenter = buildPresenter(explicitHeight: 15, scrollTop: 50, lineHeight: 10, lineOverdrawMargin: 1) @@ -720,16 +716,16 @@ describe "TextEditorPresenter", -> it "is empty until all of the required measurements are assigned", -> presenter = buildPresenter(explicitHeight: null, lineHeight: null, scrollTop: null) - expect(presenter.state.content.lines).toEqual({}) + expect(presenter.getState().content.lines).toEqual({}) presenter.setExplicitHeight(25) - expect(presenter.state.content.lines).toEqual({}) + expect(presenter.getState().content.lines).toEqual({}) presenter.setLineHeight(10) - expect(presenter.state.content.lines).toEqual({}) + expect(presenter.getState().content.lines).toEqual({}) presenter.setScrollTop(0) - expect(presenter.state.content.lines).not.toEqual({}) + expect(presenter.getState().content.lines).not.toEqual({}) it "updates when ::scrollTop changes", -> presenter = buildPresenter(explicitHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 1) @@ -836,8 +832,8 @@ describe "TextEditorPresenter", -> expectStateUpdate presenter, -> editor.getBuffer().insert([3, Infinity], 'xyz') newLine3 = editor.tokenizedLineForScreenRow(3) - expect(presenter.state.content.lines[oldLine3.id]).toBeUndefined() - expect(presenter.state.content.lines[newLine3.id]).toBeDefined() + expect(presenter.getState().content.lines[oldLine3.id]).toBeUndefined() + expect(presenter.getState().content.lines[newLine3.id]).toBeDefined() it "does not attempt to preserve lines corresponding to ::mouseWheelScreenRow if they have been deleted", -> presenter = buildPresenter(explicitHeight: 25, scrollTop: 0, lineHeight: 10, lineOverdrawMargin: 1, stoppedScrollingDelay: 200) @@ -984,7 +980,7 @@ describe "TextEditorPresenter", -> describe ".cursors", -> stateForCursor = (presenter, cursorIndex) -> - presenter.state.content.cursors[presenter.model.getCursors()[cursorIndex].id] + presenter.getState().content.cursors[presenter.model.getCursors()[cursorIndex].id] it "contains pixelRects for empty selections that are visible on screen", -> editor.setSelectedBufferRanges([ @@ -1004,22 +1000,22 @@ describe "TextEditorPresenter", -> it "is empty until all of the required measurements are assigned", -> presenter = buildPresenter(explicitHeight: null, lineHeight: null, scrollTop: null, baseCharacterWidth: null, horizontalScrollbarHeight: null) - expect(presenter.state.content.cursors).toEqual({}) + expect(presenter.getState().content.cursors).toEqual({}) presenter.setExplicitHeight(25) - expect(presenter.state.content.cursors).toEqual({}) + expect(presenter.getState().content.cursors).toEqual({}) presenter.setLineHeight(10) - expect(presenter.state.content.cursors).toEqual({}) + expect(presenter.getState().content.cursors).toEqual({}) presenter.setScrollTop(0) - expect(presenter.state.content.cursors).toEqual({}) + expect(presenter.getState().content.cursors).toEqual({}) presenter.setBaseCharacterWidth(8) - expect(presenter.state.content.cursors).toEqual({}) + expect(presenter.getState().content.cursors).toEqual({}) presenter.setHorizontalScrollbarHeight(10) - expect(presenter.state.content.cursors).not.toEqual({}) + expect(presenter.getState().content.cursors).not.toEqual({}) it "updates when ::scrollTop changes", -> editor.setSelectedBufferRanges([ @@ -1128,7 +1124,7 @@ describe "TextEditorPresenter", -> # destroying destroyedCursor = editor.getCursors()[2] expectStateUpdate presenter, -> destroyedCursor.destroy() - expect(presenter.state.content.cursors[destroyedCursor.id]).toBeUndefined() + expect(presenter.getState().content.cursors[destroyedCursor.id]).toBeUndefined() it "makes cursors as wide as the ::baseCharacterWidth if they're at the end of a line", -> editor.setCursorBufferPosition([1, Infinity]) @@ -1141,61 +1137,61 @@ describe "TextEditorPresenter", -> cursorBlinkResumeDelay = 200 presenter = buildPresenter({cursorBlinkPeriod, cursorBlinkResumeDelay, focused: true}) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> presenter.setFocused(false) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> presenter.setFocused(true) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false it "stops alternating for ::cursorBlinkResumeDelay when a cursor moves or a cursor is added", -> cursorBlinkPeriod = 100 cursorBlinkResumeDelay = 200 presenter = buildPresenter({cursorBlinkPeriod, cursorBlinkResumeDelay, focused: true}) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> editor.moveRight() - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkResumeDelay) advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false expectStateUpdate presenter, -> editor.addCursorAtBufferPosition([1, 0]) - expect(presenter.state.content.cursorsVisible).toBe true + expect(presenter.getState().content.cursorsVisible).toBe true expectStateUpdate presenter, -> advanceClock(cursorBlinkResumeDelay) advanceClock(cursorBlinkPeriod / 2) - expect(presenter.state.content.cursorsVisible).toBe false + expect(presenter.getState().content.cursorsVisible).toBe false describe ".highlights", -> stateForHighlight = (presenter, decoration) -> - presenter.state.content.highlights[decoration.id] + presenter.getState().content.highlights[decoration.id] stateForSelection = (presenter, selectionIndex) -> selection = presenter.model.getSelections()[selectionIndex] @@ -1286,19 +1282,19 @@ describe "TextEditorPresenter", -> ]) presenter = buildPresenter(explicitHeight: null, lineHeight: null, scrollTop: null, baseCharacterWidth: null) - expect(presenter.state.content.highlights).toEqual({}) + expect(presenter.getState().content.highlights).toEqual({}) presenter.setExplicitHeight(25) - expect(presenter.state.content.highlights).toEqual({}) + expect(presenter.getState().content.highlights).toEqual({}) presenter.setLineHeight(10) - expect(presenter.state.content.highlights).toEqual({}) + expect(presenter.getState().content.highlights).toEqual({}) presenter.setScrollTop(0) - expect(presenter.state.content.highlights).toEqual({}) + expect(presenter.getState().content.highlights).toEqual({}) presenter.setBaseCharacterWidth(8) - expect(presenter.state.content.highlights).not.toEqual({}) + expect(presenter.getState().content.highlights).not.toEqual({}) it "does not include highlights for invalid markers", -> marker = editor.markBufferRange([[2, 2], [2, 4]], invalidate: 'touch') @@ -1481,7 +1477,7 @@ describe "TextEditorPresenter", -> describe ".overlays", -> stateForOverlay = (presenter, decoration) -> - presenter.state.content.overlays[decoration.id] + presenter.getState().content.overlays[decoration.id] it "contains state for overlay decorations both initially and when their markers move", -> item = {} @@ -1583,114 +1579,114 @@ describe "TextEditorPresenter", -> decoration = editor.decorateMarker(marker, {type: 'overlay', position: 'tail', item}) presenter = buildPresenter(baseCharacterWidth: null, lineHeight: null) - expect(presenter.state.content.overlays).toEqual({}) + expect(presenter.getState().content.overlays).toEqual({}) presenter.setBaseCharacterWidth(10) - expect(presenter.state.content.overlays).toEqual({}) + expect(presenter.getState().content.overlays).toEqual({}) presenter.setLineHeight(10) - expect(presenter.state.content.overlays).not.toEqual({}) + expect(presenter.getState().content.overlays).not.toEqual({}) describe ".gutter", -> describe ".scrollHeight", -> it "is initialized based on ::lineHeight, the number of lines, and ::explicitHeight", -> presenter = buildPresenter() - expect(presenter.state.gutter.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().gutter.scrollHeight).toBe editor.getScreenLineCount() * 10 presenter = buildPresenter(explicitHeight: 500) - expect(presenter.state.gutter.scrollHeight).toBe 500 + expect(presenter.getState().gutter.scrollHeight).toBe 500 it "updates when the ::lineHeight changes", -> presenter = buildPresenter() expectStateUpdate presenter, -> presenter.setLineHeight(20) - expect(presenter.state.gutter.scrollHeight).toBe editor.getScreenLineCount() * 20 + expect(presenter.getState().gutter.scrollHeight).toBe editor.getScreenLineCount() * 20 it "updates when the line count changes", -> presenter = buildPresenter() expectStateUpdate presenter, -> editor.getBuffer().append("\n\n\n") - expect(presenter.state.gutter.scrollHeight).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().gutter.scrollHeight).toBe editor.getScreenLineCount() * 10 it "updates when ::explicitHeight changes", -> presenter = buildPresenter() expectStateUpdate presenter, -> presenter.setExplicitHeight(500) - expect(presenter.state.gutter.scrollHeight).toBe 500 + expect(presenter.getState().gutter.scrollHeight).toBe 500 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.gutter.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().gutter.scrollHeight).toBe presenter.contentHeight expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", true) - expect(presenter.state.gutter.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) + expect(presenter.getState().gutter.scrollHeight).toBe presenter.contentHeight + presenter.clientHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.gutter.scrollHeight).toBe presenter.contentHeight + expect(presenter.getState().gutter.scrollHeight).toBe presenter.contentHeight describe ".scrollTop", -> it "tracks the value of ::scrollTop", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 20) - expect(presenter.state.gutter.scrollTop).toBe 10 + expect(presenter.getState().gutter.scrollTop).toBe 10 expectStateUpdate presenter, -> presenter.setScrollTop(50) - expect(presenter.state.gutter.scrollTop).toBe 50 + expect(presenter.getState().gutter.scrollTop).toBe 50 it "never exceeds the computed scrollHeight minus the computed clientHeight", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(100) - expect(presenter.state.gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setExplicitHeight(60) - expect(presenter.state.gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> presenter.setHorizontalScrollbarHeight(5) - expect(presenter.state.gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight expectStateUpdate presenter, -> editor.getBuffer().delete([[8, 0], [12, 0]]) - expect(presenter.state.gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.scrollHeight - presenter.clientHeight # Scroll top only gets smaller when needed as dimensions change, never bigger - scrollTopBefore = presenter.state.verticalScrollbar.scrollTop + scrollTopBefore = presenter.getState().verticalScrollbar.scrollTop expectStateUpdate presenter, -> editor.getBuffer().insert([9, Infinity], '\n\n\n') - expect(presenter.state.gutter.scrollTop).toBe scrollTopBefore + expect(presenter.getState().gutter.scrollTop).toBe scrollTopBefore it "never goes negative", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(-100) - expect(presenter.state.gutter.scrollTop).toBe 0 + expect(presenter.getState().gutter.scrollTop).toBe 0 it "adds the computed clientHeight to the computed scrollHeight if editor.scrollPastEnd is true", -> presenter = buildPresenter(scrollTop: 10, explicitHeight: 50, horizontalScrollbarHeight: 10) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.gutter.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.contentHeight - presenter.clientHeight atom.config.set("editor.scrollPastEnd", true) expectStateUpdate presenter, -> presenter.setScrollTop(300) - expect(presenter.state.gutter.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) + expect(presenter.getState().gutter.scrollTop).toBe presenter.contentHeight - (presenter.lineHeight * 3) expectStateUpdate presenter, -> atom.config.set("editor.scrollPastEnd", false) - expect(presenter.state.gutter.scrollTop).toBe presenter.contentHeight - presenter.clientHeight + expect(presenter.getState().gutter.scrollTop).toBe presenter.contentHeight - presenter.clientHeight describe ".backgroundColor", -> it "is assigned to ::gutterBackgroundColor if present, and to ::backgroundColor otherwise", -> presenter = buildPresenter(backgroundColor: "rgba(255, 0, 0, 0)", gutterBackgroundColor: "rgba(0, 255, 0, 0)") - expect(presenter.state.gutter.backgroundColor).toBe "rgba(0, 255, 0, 0)" + expect(presenter.getState().gutter.backgroundColor).toBe "rgba(0, 255, 0, 0)" expectStateUpdate presenter, -> presenter.setGutterBackgroundColor("rgba(0, 0, 255, 0)") - expect(presenter.state.gutter.backgroundColor).toBe "rgba(0, 0, 255, 0)" + expect(presenter.getState().gutter.backgroundColor).toBe "rgba(0, 0, 255, 0)" expectStateUpdate presenter, -> presenter.setGutterBackgroundColor("rgba(0, 0, 0, 0)") - expect(presenter.state.gutter.backgroundColor).toBe "rgba(255, 0, 0, 0)" + expect(presenter.getState().gutter.backgroundColor).toBe "rgba(255, 0, 0, 0)" expectStateUpdate presenter, -> presenter.setBackgroundColor("rgba(0, 0, 255, 0)") - expect(presenter.state.gutter.backgroundColor).toBe "rgba(0, 0, 255, 0)" + expect(presenter.getState().gutter.backgroundColor).toBe "rgba(0, 0, 255, 0)" describe ".maxLineNumberDigits", -> it "is set to the number of digits used by the greatest line number", -> presenter = buildPresenter() expect(editor.getLastBufferRow()).toBe 12 - expect(presenter.state.gutter.maxLineNumberDigits).toBe 2 + expect(presenter.getState().gutter.maxLineNumberDigits).toBe 2 editor.setText("1\n2\n3") - expect(presenter.state.gutter.maxLineNumberDigits).toBe 1 + expect(presenter.getState().gutter.maxLineNumberDigits).toBe 1 describe ".lineNumbers", -> lineNumberStateForScreenRow = (presenter, screenRow) -> @@ -1702,7 +1698,7 @@ describe "TextEditorPresenter", -> else key = bufferRow - presenter.state.gutter.lineNumbers[key] + presenter.getState().gutter.lineNumbers[key] it "contains states for line numbers that are visible on screen, plus and minus the overdraw margin", -> editor.foldBufferRow(4) @@ -1994,62 +1990,62 @@ describe "TextEditorPresenter", -> presenter = buildPresenter() expect(editor.isGutterVisible()).toBe true - expect(presenter.state.gutter.visible).toBe true + expect(presenter.getState().gutter.visible).toBe true expectStateUpdate presenter, -> editor.setMini(true) - expect(presenter.state.gutter.visible).toBe false + expect(presenter.getState().gutter.visible).toBe false expectStateUpdate presenter, -> editor.setMini(false) - expect(presenter.state.gutter.visible).toBe true + expect(presenter.getState().gutter.visible).toBe true expectStateUpdate presenter, -> editor.setGutterVisible(false) - expect(presenter.state.gutter.visible).toBe false + expect(presenter.getState().gutter.visible).toBe false expectStateUpdate presenter, -> editor.setGutterVisible(true) - expect(presenter.state.gutter.visible).toBe true + expect(presenter.getState().gutter.visible).toBe true expectStateUpdate presenter, -> atom.config.set('editor.showLineNumbers', false) - expect(presenter.state.gutter.visible).toBe false + expect(presenter.getState().gutter.visible).toBe false it "updates when the editor's grammar changes", -> presenter = buildPresenter() atom.config.set('editor.showLineNumbers', false, scopeSelector: '.source.js') - expect(presenter.state.gutter.visible).toBe true + expect(presenter.getState().gutter.visible).toBe true stateUpdated = false - presenter.onDidUpdateState -> stateUpdated = true + presenter.onNeedsUpdate -> stateUpdated = true waitsForPromise -> atom.packages.activatePackage('language-javascript') runs -> expect(stateUpdated).toBe true - expect(presenter.state.gutter.visible).toBe false + expect(presenter.getState().gutter.visible).toBe false describe ".height", -> it "tracks the computed content height if ::autoHeight is true so the editor auto-expands vertically", -> presenter = buildPresenter(explicitHeight: null, autoHeight: true) - expect(presenter.state.height).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().height).toBe editor.getScreenLineCount() * 10 expectStateUpdate presenter, -> presenter.setAutoHeight(false) - expect(presenter.state.height).toBe null + expect(presenter.getState().height).toBe null expectStateUpdate presenter, -> presenter.setAutoHeight(true) - expect(presenter.state.height).toBe editor.getScreenLineCount() * 10 + expect(presenter.getState().height).toBe editor.getScreenLineCount() * 10 expectStateUpdate presenter, -> presenter.setLineHeight(20) - expect(presenter.state.height).toBe editor.getScreenLineCount() * 20 + expect(presenter.getState().height).toBe editor.getScreenLineCount() * 20 expectStateUpdate presenter, -> editor.getBuffer().append("\n\n\n") - expect(presenter.state.height).toBe editor.getScreenLineCount() * 20 + expect(presenter.getState().height).toBe editor.getScreenLineCount() * 20 describe ".focused", -> it "tracks the value of ::focused", -> presenter = buildPresenter(focused: false) - expect(presenter.state.focused).toBe false + expect(presenter.getState().focused).toBe false expectStateUpdate presenter, -> presenter.setFocused(true) - expect(presenter.state.focused).toBe true + expect(presenter.getState().focused).toBe true expectStateUpdate presenter, -> presenter.setFocused(false) - expect(presenter.state.focused).toBe false + expect(presenter.getState().focused).toBe false # disabled until we fix an issue with display buffer markers not updating when # they are moved on screen but not in the buffer @@ -2106,7 +2102,7 @@ describe "TextEditorPresenter", -> expectValidState = -> presenterParams.scrollTop = presenter.scrollTop presenterParams.scrollLeft = presenter.scrollLeft - actualState = presenter.state + actualState = presenter.getState() expectedState = new TextEditorPresenter(presenterParams).state delete actualState.content.scrollingVertically delete expectedState.content.scrollingVertically diff --git a/src/cursors-component.coffee b/src/cursors-component.coffee index ae844bfe0..f4f5d749f 100644 --- a/src/cursors-component.coffee +++ b/src/cursors-component.coffee @@ -2,14 +2,13 @@ module.exports = class CursorsComponent oldState: null - constructor: (@presenter) -> + constructor: -> @cursorNodesById = {} @domNode = document.createElement('div') @domNode.classList.add('cursors') - @updateSync() - updateSync: -> - newState = @presenter.state.content + updateSync: (state) -> + newState = state.content @oldState ?= {cursors: {}} # update blink class diff --git a/src/gutter-component.coffee b/src/gutter-component.coffee index 3209fe806..182a187b0 100644 --- a/src/gutter-component.coffee +++ b/src/gutter-component.coffee @@ -18,10 +18,8 @@ class GutterComponent @domNode.addEventListener 'click', @onClick @domNode.addEventListener 'mousedown', @onMouseDown - @updateSync() - - updateSync: -> - @newState = @presenter.state.gutter + updateSync: (state) -> + @newState = state.gutter @oldState ?= {lineNumbers: {}} @appendDummyLineNumber() unless @dummyLineNumberNode? diff --git a/src/highlights-component.coffee b/src/highlights-component.coffee index 48d2cc70e..3bd5197fe 100644 --- a/src/highlights-component.coffee +++ b/src/highlights-component.coffee @@ -5,7 +5,7 @@ module.exports = class HighlightsComponent oldState: null - constructor: (@presenter) -> + constructor: -> @highlightNodesById = {} @regionNodesByHighlightId = {} @@ -17,8 +17,8 @@ class HighlightsComponent insertionPoint.setAttribute('select', '.underlayer') @domNode.appendChild(insertionPoint) - updateSync: -> - newState = @presenter.state.content.highlights + updateSync: (state) -> + newState = state.content.highlights @oldState ?= {} # remove highlights diff --git a/src/input-component.coffee b/src/input-component.coffee index 2037fbe48..f6f8917f6 100644 --- a/src/input-component.coffee +++ b/src/input-component.coffee @@ -1,16 +1,15 @@ module.exports = class InputComponent - constructor: (@presenter) -> + constructor: -> @domNode = document.createElement('input') @domNode.classList.add('hidden-input') @domNode.setAttribute('data-react-skip-selection-restoration', true) @domNode.style['-webkit-transform'] = 'translateZ(0)' @domNode.addEventListener 'paste', (event) -> event.preventDefault() - @updateSync() - updateSync: -> + updateSync: (state) -> @oldState ?= {} - newState = @presenter.state.hiddenInput + newState = state.hiddenInput if newState.top isnt @oldState.top @domNode.style.top = newState.top + 'px' diff --git a/src/lines-component.coffee b/src/lines-component.coffee index 9619a175c..fa4ab23b0 100644 --- a/src/lines-component.coffee +++ b/src/lines-component.coffee @@ -42,15 +42,13 @@ class LinesComponent insertionPoint = document.createElement('content') insertionPoint.setAttribute('select', 'atom-overlay') - @overlayManager = new OverlayManager(@hostElement) + @overlayManager = new OverlayManager(@presenter, @hostElement) @domNode.appendChild(insertionPoint) else - @overlayManager = new OverlayManager(@domNode) + @overlayManager = new OverlayManager(@presenter, @domNode) - @updateSync(visible) - - updateSync: -> - @newState = @presenter.state.content + updateSync: (state) -> + @newState = state.content @oldState ?= {lines: {}} if @newState.scrollHeight isnt @oldState.scrollHeight @@ -81,10 +79,10 @@ class LinesComponent @domNode.style.width = @newState.scrollWidth + 'px' @oldState.scrollWidth = @newState.scrollWidth - @cursorsComponent.updateSync() - @highlightsComponent.updateSync() + @cursorsComponent.updateSync(state) + @highlightsComponent.updateSync(state) - @overlayManager?.render(@presenter) + @overlayManager?.render(state) @oldState.indentGuidesVisible = @newState.indentGuidesVisible @oldState.scrollWidth = @newState.scrollWidth diff --git a/src/overlay-manager.coffee b/src/overlay-manager.coffee index 7d9c9d95d..c8b5da0e8 100644 --- a/src/overlay-manager.coffee +++ b/src/overlay-manager.coffee @@ -1,20 +1,20 @@ module.exports = class OverlayManager - constructor: (@container) -> + constructor: (@presenter, @container) -> @overlayNodesById = {} - render: (presenter) -> - for decorationId, {pixelPosition, item} of presenter.state.content.overlays - @renderOverlay(presenter, decorationId, item, pixelPosition) + render: (state) -> + for decorationId, {pixelPosition, item} of state.content.overlays + @renderOverlay(state, decorationId, item, pixelPosition) for id, overlayNode of @overlayNodesById - unless presenter.state.content.overlays.hasOwnProperty(id) + unless state.content.overlays.hasOwnProperty(id) delete @overlayNodesById[id] overlayNode.remove() return - renderOverlay: (presenter, decorationId, item, pixelPosition) -> + renderOverlay: (state, decorationId, item, pixelPosition) -> item = atom.views.getView(item) unless overlayNode = @overlayNodesById[decorationId] overlayNode = @overlayNodesById[decorationId] = document.createElement('atom-overlay') @@ -25,15 +25,15 @@ class OverlayManager itemHeight = item.offsetHeight - {scrollTop, scrollLeft} = presenter.state.content + {scrollTop, scrollLeft} = state.content left = pixelPosition.left - if left + itemWidth - scrollLeft > presenter.contentFrameWidth and left - itemWidth >= scrollLeft + if left + itemWidth - scrollLeft > @presenter.contentFrameWidth and left - itemWidth >= scrollLeft left -= itemWidth - top = pixelPosition.top + presenter.lineHeight - if top + itemHeight - scrollTop > presenter.height and top - itemHeight - presenter.lineHeight >= scrollTop - top -= itemHeight + presenter.lineHeight + top = pixelPosition.top + @presenter.lineHeight + if top + itemHeight - scrollTop > @presenter.height and top - itemHeight - @presenter.lineHeight >= scrollTop + top -= itemHeight + @presenter.lineHeight overlayNode.style.top = top + 'px' overlayNode.style.left = left + 'px' diff --git a/src/scrollbar-component.coffee b/src/scrollbar-component.coffee index 3e94a0708..3a63a33ed 100644 --- a/src/scrollbar-component.coffee +++ b/src/scrollbar-component.coffee @@ -1,6 +1,6 @@ module.exports = class ScrollbarComponent - constructor: ({@presenter, @orientation, @onScroll}) -> + constructor: ({@orientation, @onScroll}) -> @domNode = document.createElement('div') @domNode.classList.add "#{@orientation}-scrollbar" @domNode.style['-webkit-transform'] = 'translateZ(0)' # See atom/atom#3559 @@ -12,16 +12,14 @@ class ScrollbarComponent @domNode.addEventListener 'scroll', @onScrollCallback - @updateSync() - - updateSync: -> + updateSync: (state) -> @oldState ?= {} switch @orientation when 'vertical' - @newState = @presenter.state.verticalScrollbar + @newState = state.verticalScrollbar @updateVertical() when 'horizontal' - @newState = @presenter.state.horizontalScrollbar + @newState = state.horizontalScrollbar @updateHorizontal() if @newState.visible isnt @oldState.visible diff --git a/src/scrollbar-corner-component.coffee b/src/scrollbar-corner-component.coffee index 1a266afc5..c0fbdfd60 100644 --- a/src/scrollbar-corner-component.coffee +++ b/src/scrollbar-corner-component.coffee @@ -1,20 +1,18 @@ module.exports = class ScrollbarCornerComponent - constructor: (@presenter) -> + constructor: () -> @domNode = document.createElement('div') @domNode.classList.add('scrollbar-corner') @contentNode = document.createElement('div') @domNode.appendChild(@contentNode) - @updateSync() - - updateSync: -> + updateSync: (state) -> @oldState ?= {} @newState ?= {} - newHorizontalState = @presenter.state.horizontalScrollbar - newVerticalState = @presenter.state.verticalScrollbar + newHorizontalState = state.horizontalScrollbar + newVerticalState = state.verticalScrollbar @newState.visible = newHorizontalState.visible and newVerticalState.visible @newState.height = newHorizontalState.height @newState.width = newVerticalState.width diff --git a/src/text-editor-component.coffee b/src/text-editor-component.coffee index 5e597a3fb..4c01cde56 100644 --- a/src/text-editor-component.coffee +++ b/src/text-editor-component.coffee @@ -64,21 +64,21 @@ class TextEditorComponent @scrollViewNode.classList.add('scroll-view') @domNode.appendChild(@scrollViewNode) - @mountGutterComponent() if @presenter.state.gutter.visible + @mountGutterComponent() if @presenter.getState().gutter.visible - @hiddenInputComponent = new InputComponent(@presenter) + @hiddenInputComponent = new InputComponent @scrollViewNode.appendChild(@hiddenInputComponent.domNode) @linesComponent = new LinesComponent({@presenter, @hostElement, @useShadowDOM}) @scrollViewNode.appendChild(@linesComponent.domNode) - @horizontalScrollbarComponent = new ScrollbarComponent({@presenter, orientation: 'horizontal', onScroll: @onHorizontalScroll}) + @horizontalScrollbarComponent = new ScrollbarComponent({orientation: 'horizontal', onScroll: @onHorizontalScroll}) @scrollViewNode.appendChild(@horizontalScrollbarComponent.domNode) - @verticalScrollbarComponent = new ScrollbarComponent({@presenter, orientation: 'vertical', onScroll: @onVerticalScroll}) + @verticalScrollbarComponent = new ScrollbarComponent({orientation: 'vertical', onScroll: @onVerticalScroll}) @domNode.appendChild(@verticalScrollbarComponent.domNode) - @scrollbarCornerComponent = new ScrollbarCornerComponent(@presenter) + @scrollbarCornerComponent = new ScrollbarCornerComponent @domNode.appendChild(@scrollbarCornerComponent.domNode) @observeEditor() @@ -103,10 +103,8 @@ class TextEditorComponent window.removeEventListener 'resize', @requestHeightAndWidthMeasurement updateSync: -> - @presenter.update() - @oldState ?= {} - @newState = @presenter.state + @newState = @presenter.getState() cursorMoved = @cursorMoved selectionChanged = @selectionChanged @@ -130,18 +128,18 @@ class TextEditorComponent else @domNode.style.height = '' - if @presenter.state.gutter.visible + if @newState.gutter.visible @mountGutterComponent() unless @gutterComponent? - @gutterComponent.updateSync() + @gutterComponent.updateSync(@newState) else @gutterComponent?.domNode?.remove() @gutterComponent = null - @hiddenInputComponent.updateSync() - @linesComponent.updateSync() - @horizontalScrollbarComponent.updateSync() - @verticalScrollbarComponent.updateSync() - @scrollbarCornerComponent.updateSync() + @hiddenInputComponent.updateSync(@newState) + @linesComponent.updateSync(@newState) + @horizontalScrollbarComponent.updateSync(@newState) + @verticalScrollbarComponent.updateSync(@newState) + @scrollbarCornerComponent.updateSync(@newState) if @editor.isAlive() @updateParentViewFocusedClassIfNeeded() @@ -154,7 +152,7 @@ class TextEditorComponent @linesComponent.measureCharactersInNewLines() if @isVisible() and not @newState.content.scrollingVertically mountGutterComponent: -> - @gutterComponent = new GutterComponent({@presenter, @editor, onMouseDown: @onGutterMouseDown}) + @gutterComponent = new GutterComponent({@editor, onMouseDown: @onGutterMouseDown}) @domNode.insertBefore(@gutterComponent.domNode, @domNode.firstChild) becameVisible: -> diff --git a/src/text-editor-presenter.coffee b/src/text-editor-presenter.coffee index 6e4c8e928..b7ba41419 100644 --- a/src/text-editor-presenter.coffee +++ b/src/text-editor-presenter.coffee @@ -53,8 +53,7 @@ class TextEditorPresenter isBatching: -> @updating == false - # Updates the state, applying only those changes that occurred between this call and a previous call to this method. - update: -> + getState: -> @updating = true @updateFocusedState() if @shouldUpdateFocusedState @@ -87,6 +86,8 @@ class TextEditorPresenter @updating = false + @state + observeModel: -> @disposables.add @model.onDidChange => @updateContentDimensions()