_ = require 'underscore-plus'

path = require 'path'

Serializable = require 'serializable'

Delegator = require 'delegato'

{includeDeprecatedAPIs, deprecate} = require 'grim'

{CompositeDisposable, Emitter} = require 'event-kit'

{Point, Range} = TextBuffer = require 'text-buffer'

LanguageMode = require './language-mode'

DisplayBuffer = require './display-buffer'

Cursor = require './cursor'

Model = require './model'

Selection = require './selection'

TextMateScopeSelector = require('first-mate').ScopeSelector

{Directory} = require "pathwatcher"

GutterContainer = require './gutter-container'

# Public: This class represents all essential editing state for a single

# {TextBuffer}, including cursor and selection positions, folds, and soft wraps.

# If you're manipulating the state of an editor, use this class. If you're

# interested in the visual appearance of editors, use {TextEditorView} instead.

#

# A single {TextBuffer} can belong to multiple editors. For example, if the

# same file is open in two different panes, Atom creates a separate editor for

# each pane. If the buffer is manipulated the changes are reflected in both

# editors, but each maintains its own cursor position, folded lines, etc.

#

# ## Accessing TextEditor Instances

#

# The easiest way to get hold of `TextEditor` objects is by registering a callback

# with `::observeTextEditors` on the `atom.workspace` global. Your callback will

# then be called with all current editor instances and also when any editor is

# created in the future.

#

# ```coffee

# atom.workspace.observeTextEditors (editor) ->

# editor.insertText('Hello World')

# ```

#

# ## Buffer vs. Screen Coordinates

#

# Because editors support folds and soft-wrapping, the lines on screen don't

# always match the lines in the buffer. For example, a long line that soft wraps

# twice renders as three lines on screen, but only represents one line in the

# buffer. Similarly, if rows 5-10 are folded, then row 6 on screen corresponds

# to row 11 in the buffer.

#

# Your choice of coordinates systems will depend on what you're trying to

# achieve. For example, if you're writing a command that jumps the cursor up or

# down by 10 lines, you'll want to use screen coordinates because the user

# probably wants to skip lines *on screen*. However, if you're writing a package

# that jumps between method definitions, you'll want to work in buffer

# coordinates.

#

# **When in doubt, just default to buffer coordinates**, then experiment with

# soft wraps and folds to ensure your code interacts with them correctly.

module.exports =

class TextEditor extends Model

Serializable.includeInto(this)

atom.deserializers.add(this)

Delegator.includeInto(this)

deserializing: false

callDisplayBufferCreatedHook: false

registerEditor: false

buffer: null

languageMode: null

cursors: null

selections: null

suppressSelectionMerging: false

updateBatchDepth: 0

selectionFlashDuration: 500

gutterContainer: null

@delegatesMethods 'suggestedIndentForBufferRow', 'autoIndentBufferRow', 'autoIndentBufferRows',

'autoDecreaseIndentForBufferRow', 'toggleLineCommentForBufferRow', 'toggleLineCommentsForBufferRows',

toProperty: 'languageMode'

constructor: ({@softTabs, initialLine, initialColumn, tabLength, softWrapped, @displayBuffer, buffer, registerEditor, suppressCursorCreation, @mini, @placeholderText, lineNumberGutterVisible, largeFileMode}={}) ->

super

@emitter = new Emitter

@disposables = new CompositeDisposable

@cursors = []

@selections = []

buffer ?= new TextBuffer

@displayBuffer ?= new DisplayBuffer({buffer, tabLength, softWrapped, ignoreInvisibles: @mini, largeFileMode})

@buffer = @displayBuffer.buffer

@softTabs = @usesSoftTabs() ? @softTabs ? atom.config.get('editor.softTabs') ? true

for marker in @findMarkers(@getSelectionMarkerAttributes())

marker.setProperties(preserveFolds: true)

@addSelection(marker)

@subscribeToBuffer()

@subscribeToDisplayBuffer()

if @getCursors().length is 0 and not suppressCursorCreation

initialLine = Math.max(parseInt(initialLine) or 0, 0)

initialColumn = Math.max(parseInt(initialColumn) or 0, 0)

@addCursorAtBufferPosition([initialLine, initialColumn])

@languageMode = new LanguageMode(this)

@setEncoding(atom.config.get('core.fileEncoding', scope: @getRootScopeDescriptor()))

@disposables.add @displayBuffer.onDidChangeScrollTop (scrollTop) =>

@emit 'scroll-top-changed', scrollTop if includeDeprecatedAPIs

@emitter.emit 'did-change-scroll-top', scrollTop

@disposables.add @displayBuffer.onDidChangeScrollLeft (scrollLeft) =>

@emit 'scroll-left-changed', scrollLeft if includeDeprecatedAPIs

@emitter.emit 'did-change-scroll-left', scrollLeft

@gutterContainer = new GutterContainer(this)

@lineNumberGutter = @gutterContainer.addGutter

name: 'line-number'

priority: 0

visible: lineNumberGutterVisible

atom.workspace?.editorAdded(this) if registerEditor

serializeParams: ->

id: @id

softTabs: @softTabs

scrollTop: @scrollTop

scrollLeft: @scrollLeft

displayBuffer: @displayBuffer.serialize()

deserializeParams: (params) ->

try

displayBuffer = DisplayBuffer.deserialize(params.displayBuffer)

catch error

if error.syscall is 'read'

return # Error reading the file, don't deserialize an editor for it

else

throw error

params.displayBuffer = displayBuffer

params.registerEditor = true

params

subscribeToBuffer: ->

@buffer.retain()

@disposables.add @buffer.onDidChangePath =>

unless atom.project.getPaths().length > 0

atom.project.setPaths([path.dirname(@getPath())])

@emit "title-changed" if includeDeprecatedAPIs

@emitter.emit 'did-change-title', @getTitle()

@emit "path-changed" if includeDeprecatedAPIs

@emitter.emit 'did-change-path', @getPath()

@disposables.add @buffer.onDidChangeEncoding =>

@emitter.emit 'did-change-encoding', @getEncoding()

@disposables.add @buffer.onDidDestroy => @destroy()

# TODO: remove these when we remove the deprecations. They are old events.

if includeDeprecatedAPIs

@subscribe @buffer.onDidStopChanging => @emit "contents-modified"

@subscribe @buffer.onDidConflict => @emit "contents-conflicted"

@subscribe @buffer.onDidChangeModified => @emit "modified-status-changed"

@preserveCursorPositionOnBufferReload()

subscribeToDisplayBuffer: ->

@disposables.add @displayBuffer.onDidCreateMarker @handleMarkerCreated

@disposables.add @displayBuffer.onDidChangeGrammar => @handleGrammarChange()

@disposables.add @displayBuffer.onDidTokenize => @handleTokenization()

@disposables.add @displayBuffer.onDidChange (e) =>

@mergeIntersectingSelections()

@emit 'screen-lines-changed', e if includeDeprecatedAPIs

@emitter.emit 'did-change', e

# TODO: remove these when we remove the deprecations. Though, no one is likely using them

if includeDeprecatedAPIs

@subscribe @displayBuffer.onDidChangeSoftWrapped (softWrapped) => @emit 'soft-wrap-changed', softWrapped

@subscribe @displayBuffer.onDidAddDecoration (decoration) => @emit 'decoration-added', decoration

@subscribe @displayBuffer.onDidRemoveDecoration (decoration) => @emit 'decoration-removed', decoration

destroyed: ->

@unsubscribe() if includeDeprecatedAPIs

@disposables.dispose()

selection.destroy() for selection in @getSelections()

@buffer.release()

@displayBuffer.destroy()

@languageMode.destroy()

@gutterContainer.destroy()

@emitter.emit 'did-destroy'

###

Section: Event Subscription

###

# Essential: Calls your `callback` when the buffer's title has changed.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeTitle: (callback) ->

@emitter.on 'did-change-title', callback

# Essential: Calls your `callback` when the buffer's path, and therefore title, has changed.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangePath: (callback) ->

@emitter.on 'did-change-path', callback

# Essential: Invoke the given callback synchronously when the content of the

# buffer changes.

#

# Because observers are invoked synchronously, it's important not to perform

# any expensive operations via this method. Consider {::onDidStopChanging} to

# delay expensive operations until after changes stop occurring.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChange: (callback) ->

@emitter.on 'did-change', callback

# Essential: Invoke `callback` when the buffer's contents change. It is

# emit asynchronously 300ms after the last buffer change. This is a good place

# to handle changes to the buffer without compromising typing performance.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidStopChanging: (callback) ->

@getBuffer().onDidStopChanging(callback)

# Essential: Calls your `callback` when a {Cursor} is moved. If there are

# multiple cursors, your callback will be called for each cursor.

#

# * `callback` {Function}

# * `event` {Object}

# * `oldBufferPosition` {Point}

# * `oldScreenPosition` {Point}

# * `newBufferPosition` {Point}

# * `newScreenPosition` {Point}

# * `textChanged` {Boolean}

# * `cursor` {Cursor} that triggered the event

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeCursorPosition: (callback) ->

@emitter.on 'did-change-cursor-position', callback

# Essential: Calls your `callback` when a selection's screen range changes.

#

# * `callback` {Function}

# * `event` {Object}

# * `oldBufferRange` {Range}

# * `oldScreenRange` {Range}

# * `newBufferRange` {Range}

# * `newScreenRange` {Range}

# * `selection` {Selection} that triggered the event

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeSelectionRange: (callback) ->

@emitter.on 'did-change-selection-range', callback

# Extended: Calls your `callback` when soft wrap was enabled or disabled.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeSoftWrapped: (callback) ->

@displayBuffer.onDidChangeSoftWrapped(callback)

# Extended: Calls your `callback` when the buffer's encoding has changed.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeEncoding: (callback) ->

@emitter.on 'did-change-encoding', callback

# Extended: Calls your `callback` when the grammar that interprets and

# colorizes the text has been changed. Immediately calls your callback with

# the current grammar.

#

# * `callback` {Function}

# * `grammar` {Grammar}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

observeGrammar: (callback) ->

callback(@getGrammar())

@onDidChangeGrammar(callback)

# Extended: Calls your `callback` when the grammar that interprets and

# colorizes the text has been changed.

#

# * `callback` {Function}

# * `grammar` {Grammar}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeGrammar: (callback) ->

@emitter.on 'did-change-grammar', callback

# Extended: Calls your `callback` when the result of {::isModified} changes.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangeModified: (callback) ->

@getBuffer().onDidChangeModified(callback)

# Extended: Calls your `callback` when the buffer's underlying file changes on

# disk at a moment when the result of {::isModified} is true.

#

# * `callback` {Function}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidConflict: (callback) ->

@getBuffer().onDidConflict(callback)

# Extended: Calls your `callback` before text has been inserted.

#

# * `callback` {Function}

# * `event` event {Object}

# * `text` {String} text to be inserted

# * `cancel` {Function} Call to prevent the text from being inserted

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onWillInsertText: (callback) ->

@emitter.on 'will-insert-text', callback

# Extended: Calls your `callback` after text has been inserted.

#

# * `callback` {Function}

# * `event` event {Object}

# * `text` {String} text to be inserted

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidInsertText: (callback) ->

@emitter.on 'did-insert-text', callback

# Public: Invoke the given callback after the buffer is saved to disk.

#

# * `callback` {Function} to be called after the buffer is saved.

# * `event` {Object} with the following keys:

# * `path` The path to which the buffer was saved.

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidSave: (callback) ->

@getBuffer().onDidSave(callback)

# Public: Invoke the given callback when the editor is destroyed.

#

# * `callback` {Function} to be called when the editor is destroyed.

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidDestroy: (callback) ->

@emitter.on 'did-destroy', callback

# Extended: Calls your `callback` when a {Cursor} is added to the editor.

# Immediately calls your callback for each existing cursor.

#

# * `callback` {Function}

# * `cursor` {Cursor} that was added

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

observeCursors: (callback) ->

callback(cursor) for cursor in @getCursors()

@onDidAddCursor(callback)

# Extended: Calls your `callback` when a {Cursor} is added to the editor.

#

# * `callback` {Function}

# * `cursor` {Cursor} that was added

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidAddCursor: (callback) ->

@emitter.on 'did-add-cursor', callback

# Extended: Calls your `callback` when a {Cursor} is removed from the editor.

#

# * `callback` {Function}

# * `cursor` {Cursor} that was removed

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidRemoveCursor: (callback) ->

@emitter.on 'did-remove-cursor', callback

# Extended: Calls your `callback` when a {Selection} is added to the editor.

# Immediately calls your callback for each existing selection.

#

# * `callback` {Function}

# * `selection` {Selection} that was added

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

observeSelections: (callback) ->

callback(selection) for selection in @getSelections()

@onDidAddSelection(callback)

# Extended: Calls your `callback` when a {Selection} is added to the editor.

#

# * `callback` {Function}

# * `selection` {Selection} that was added

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidAddSelection: (callback) ->

@emitter.on 'did-add-selection', callback

# Extended: Calls your `callback` when a {Selection} is removed from the editor.

#

# * `callback` {Function}

# * `selection` {Selection} that was removed

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidRemoveSelection: (callback) ->

@emitter.on 'did-remove-selection', callback

# Extended: Calls your `callback` with each {Decoration} added to the editor.

# Calls your `callback` immediately for any existing decorations.

#

# * `callback` {Function}

# * `decoration` {Decoration}

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

observeDecorations: (callback) ->

@displayBuffer.observeDecorations(callback)

# Extended: Calls your `callback` when a {Decoration} is added to the editor.

#

# * `callback` {Function}

# * `decoration` {Decoration} that was added

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidAddDecoration: (callback) ->

@displayBuffer.onDidAddDecoration(callback)

# Extended: Calls your `callback` when a {Decoration} is removed from the editor.

#

# * `callback` {Function}

# * `decoration` {Decoration} that was removed

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidRemoveDecoration: (callback) ->

@displayBuffer.onDidRemoveDecoration(callback)

# Extended: Calls your `callback` when the placeholder text is changed.

#

# * `callback` {Function}

# * `placeholderText` {String} new text

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidChangePlaceholderText: (callback) ->

@emitter.on 'did-change-placeholder-text', callback

onDidChangeCharacterWidths: (callback) ->

@displayBuffer.onDidChangeCharacterWidths(callback)

onDidChangeScrollTop: (callback) ->

@emitter.on 'did-change-scroll-top', callback

onDidChangeScrollLeft: (callback) ->

@emitter.on 'did-change-scroll-left', callback

# TODO Remove once the tabs package no longer uses .on subscriptions

onDidChangeIcon: (callback) ->

@emitter.on 'did-change-icon', callback

onDidUpdateMarkers: (callback) ->

@displayBuffer.onDidUpdateMarkers(callback)

# Public: Retrieves the current {TextBuffer}.

getBuffer: -> @buffer

# Retrieves the current buffer's URI.

getURI: -> @buffer.getUri()

# Create an {TextEditor} with its initial state based on this object

copy: ->

displayBuffer = @displayBuffer.copy()

softTabs = @getSoftTabs()

newEditor = new TextEditor({@buffer, displayBuffer, @tabLength, softTabs, suppressCursorCreation: true, registerEditor: true})

for marker in @findMarkers(editorId: @id)

marker.copy(editorId: newEditor.id, preserveFolds: true)

newEditor

# Controls visibility based on the given {Boolean}.

setVisible: (visible) -> @displayBuffer.setVisible(visible)

setMini: (mini) ->

if mini isnt @mini

@mini = mini

@displayBuffer.setIgnoreInvisibles(@mini)

@emitter.emit 'did-change-mini', @mini

@mini

isMini: -> @mini

onDidChangeMini: (callback) ->

@emitter.on 'did-change-mini', callback

setLineNumberGutterVisible: (lineNumberGutterVisible) ->

unless lineNumberGutterVisible is @lineNumberGutter.isVisible()

if lineNumberGutterVisible

@lineNumberGutter.show()

else

@lineNumberGutter.hide()

@emitter.emit 'did-change-line-number-gutter-visible', @lineNumberGutter.isVisible()

@lineNumberGutter.isVisible()

isLineNumberGutterVisible: -> @lineNumberGutter.isVisible()

onDidChangeLineNumberGutterVisible: (callback) ->

@emitter.on 'did-change-line-number-gutter-visible', callback

# Public: Creates and returns a {Gutter}.

# See {GutterContainer::addGutter} for more details.

addGutter: (options) ->

@gutterContainer.addGutter(options)

# Public: Returns the {Array} of all gutters on this editor.

getGutters: ->

@gutterContainer.getGutters()

# Public: Returns the {Gutter} with the given name, or null if it doesn't exist.

gutterWithName: (name) ->

@gutterContainer.gutterWithName(name)

# Calls your `callback` when a {Gutter} is added to the editor.

# Immediately calls your callback for each existing gutter.

#

# * `callback` {Function}

# * `gutter` {Gutter} that currently exists/was added.

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

observeGutters: (callback) ->

@gutterContainer.observeGutters callback

# Calls your `callback` when a {Gutter} is added to the editor.

#

# * `callback` {Function}

# * `gutter` {Gutter} that was added.

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidAddGutter: (callback) ->

@gutterContainer.onDidAddGutter callback

# Calls your `callback` when a {Gutter} is removed from the editor.

#

# * `callback` {Function}

# * `name` The name of the {Gutter} that was removed.

#

# Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.

onDidRemoveGutter: (callback) ->

@gutterContainer.onDidRemoveGutter callback

# Set the number of characters that can be displayed horizontally in the

# editor.

#

# * `editorWidthInChars` A {Number} representing the width of the {TextEditorView}

# in characters.

setEditorWidthInChars: (editorWidthInChars) ->

@displayBuffer.setEditorWidthInChars(editorWidthInChars)

###

Section: File Details

###

# Essential: Get the editor's title for display in other parts of the

# UI such as the tabs.

#

# If the editor's buffer is saved, its title is the file name. If it is

# unsaved, its title is "untitled".

#

# Returns a {String}.

getTitle: ->

if sessionPath = @getPath()

path.basename(sessionPath)

else

'untitled'

# Essential: Get the editor's long title for display in other parts of the UI

# such as the window title.

#

# If the editor's buffer is saved, its long title is formatted as

# "<filename> - <directory>". If it is unsaved, its title is "untitled"

#

# Returns a {String}.

getLongTitle: ->

if sessionPath = @getPath()

fileName = path.basename(sessionPath)

directory = atom.project.relativize(path.dirname(sessionPath))

directory = if directory.length > 0 then directory else path.basename(path.dirname(sessionPath))

"#{fileName} - #{directory}"

else

'untitled'

# Essential: Returns the {String} path of this editor's text buffer.

getPath: -> @buffer.getPath()

# Extended: Returns the {String} character set encoding of this editor's text

# buffer.

getEncoding: -> @buffer.getEncoding()

# Extended: Set the character set encoding to use in this editor's text

# buffer.

#

# * `encoding` The {String} character set encoding name such as 'utf8'

setEncoding: (encoding) -> @buffer.setEncoding(encoding)

# Essential: Returns {Boolean} `true` if this editor has been modified.

isModified: -> @buffer.isModified()

# Essential: Returns {Boolean} `true` if this editor has no content.

isEmpty: -> @buffer.isEmpty()

# Copies the current file path to the native clipboard.

copyPathToClipboard: ->

if filePath = @getPath()

atom.clipboard.write(filePath)

###

Section: File Operations

###

# Essential: Saves the editor's text buffer.

#

# See {TextBuffer::save} for more details.

save: -> @buffer.save()

# Public: Saves the editor's text buffer as the given path.

#

# See {TextBuffer::saveAs} for more details.

#

# * `filePath` A {String} path.

saveAs: (filePath) -> @buffer.saveAs(filePath)

# Determine whether the user should be prompted to save before closing

# this editor.

shouldPromptToSave: ({windowCloseRequested}={}) ->

if windowCloseRequested

@isModified()

else

@isModified() and not @buffer.hasMultipleEditors()

# Returns an {Object} to configure dialog shown when this editor is saved

# via {Pane::saveItemAs}.

getSaveDialogOptions: -> {}

checkoutHeadRevision: ->

if filePath = this.getPath()

atom.project.repositoryForDirectory(new Directory(path.dirname(filePath)))

.then (repository) =>

repository?.checkoutHeadForEditor(this)

else

Promise.resolve(false)

###

Section: Reading Text

###

# Essential: Returns a {String} representing the entire contents of the editor.

getText: -> @buffer.getText()

# Essential: Get the text in the given {Range} in buffer coordinates.

#

# * `range` A {Range} or range-compatible {Array}.

#

# Returns a {String}.

getTextInBufferRange: (range) ->

@buffer.getTextInRange(range)

# Essential: Returns a {Number} representing the number of lines in the buffer.

getLineCount: -> @buffer.getLineCount()

# Essential: Returns a {Number} representing the number of screen lines in the

# editor. This accounts for folds.

getScreenLineCount: -> @displayBuffer.getLineCount()

# Essential: Returns a {Number} representing the last zero-indexed buffer row

# number of the editor.

getLastBufferRow: -> @buffer.getLastRow()

# Essential: Returns a {Number} representing the last zero-indexed screen row

# number of the editor.

getLastScreenRow: -> @displayBuffer.getLastRow()

# Essential: Returns a {String} representing the contents of the line at the

# given buffer row.

#

# * `bufferRow` A {Number} representing a zero-indexed buffer row.

lineTextForBufferRow: (bufferRow) -> @buffer.lineForRow(bufferRow)

# Essential: Returns a {String} representing the contents of the line at the

# given screen row.

#

# * `screenRow` A {Number} representing a zero-indexed screen row.

lineTextForScreenRow: (screenRow) -> @displayBuffer.tokenizedLineForScreenRow(screenRow)?.text

# Gets the screen line for the given screen row.

#

# * `screenRow` - A {Number} indicating the screen row.

#

# Returns {TokenizedLine}

tokenizedLineForScreenRow: (screenRow) -> @displayBuffer.tokenizedLineForScreenRow(screenRow)

# {Delegates to: DisplayBuffer.tokenizedLinesForScreenRows}

tokenizedLinesForScreenRows: (start, end) -> @displayBuffer.tokenizedLinesForScreenRows(start, end)

bufferRowForScreenRow: (row) -> @displayBuffer.bufferRowForScreenRow(row)

# {Delegates to: DisplayBuffer.bufferRowsForScreenRows}

bufferRowsForScreenRows: (startRow, endRow) -> @displayBuffer.bufferRowsForScreenRows(startRow, endRow)

screenRowForBufferRow: (row) -> @displayBuffer.screenRowForBufferRow(row)

# {Delegates to: DisplayBuffer.getMaxLineLength}

getMaxScreenLineLength: -> @displayBuffer.getMaxLineLength()

getLongestScreenRow: -> @displayBuffer.getLongestScreenRow()

# Returns the range for the given buffer row.

#

# * `row` A row {Number}.

# * `options` (optional) An options hash with an `includeNewline` key.

#

# Returns a {Range}.

bufferRangeForBufferRow: (row, {includeNewline}={}) -> @buffer.rangeForRow(row, includeNewline)

# Get the text in the given {Range}.

#

# Returns a {String}.

getTextInRange: (range) -> @buffer.getTextInRange(range)

# {Delegates to: TextBuffer.isRowBlank}

isBufferRowBlank: (bufferRow) -> @buffer.isRowBlank(bufferRow)

# {Delegates to: TextBuffer.nextNonBlankRow}

nextNonBlankBufferRow: (bufferRow) -> @buffer.nextNonBlankRow(bufferRow)

# {Delegates to: TextBuffer.getEndPosition}

getEofBufferPosition: -> @buffer.getEndPosition()

# Public: Get the {Range} of the paragraph surrounding the most recently added

# cursor.

#

# Returns a {Range}.

getCurrentParagraphBufferRange: ->

@getLastCursor().getCurrentParagraphBufferRange()

###

Section: Mutating Text

###

# Essential: Replaces the entire contents of the buffer with the given {String}.

#

# * `text` A {String} to replace with

setText: (text) -> @buffer.setText(text)

# Essential: Set the text in the given {Range} in buffer coordinates.

#

# * `range` A {Range} or range-compatible {Array}.

# * `text` A {String}

# * `options` (optional) {Object}

# * `normalizeLineEndings` (optional) {Boolean} (default: true)

# * `undo` (optional) {String} 'skip' will skip the undo system

#

# Returns the {Range} of the newly-inserted text.

setTextInBufferRange: (range, text, options) -> @getBuffer().setTextInRange(range, text, options)

# Essential: For each selection, replace the selected text with the given text.

#

# * `text` A {String} representing the text to insert.

# * `options` (optional) See {Selection::insertText}.

#

# Returns a {Range} when the text has been inserted

# Returns a {Boolean} false when the text has not been inserted

insertText: (text, options={}) ->

return false unless @emitWillInsertTextEvent(text)

groupingInterval = if options.groupUndo

atom.config.get('editor.undoGroupingInterval')

else

0

options.autoIndentNewline ?= @shouldAutoIndent()

options.autoDecreaseIndent ?= @shouldAutoIndent()

@mutateSelectedText(

(selection) =>

range = selection.insertText(text, options)

didInsertEvent = {text, range}

@emit('did-insert-text', didInsertEvent) if includeDeprecatedAPIs

@emitter.emit 'did-insert-text', didInsertEvent

range

, groupingInterval

)

# Essential: For each selection, replace the selected text with a newline.

insertNewline: ->

@insertText('\n')

# Essential: For each selection, if the selection is empty, delete the character

# following the cursor. Otherwise delete the selected text.

delete: ->

@mutateSelectedText (selection) -> selection.delete()

# Essential: For each selection, if the selection is empty, delete the character

# preceding the cursor. Otherwise delete the selected text.

backspace: ->

@mutateSelectedText (selection) -> selection.backspace()

# Extended: Mutate the text of all the selections in a single transaction.

#

# All the changes made inside the given {Function} can be reverted with a

# single call to {::undo}.

#

# * `fn` A {Function} that will be called once for each {Selection}. The first

# argument will be a {Selection} and the second argument will be the

# {Number} index of that selection.

mutateSelectedText: (fn, groupingInterval=0) ->

@mergeIntersectingSelections =>

@transact groupingInterval, =>

fn(selection, index) for selection, index in @getSelectionsOrderedByBufferPosition()

# Move lines intersection the most recent selection up by one row in screen

# coordinates.

moveLineUp: ->

selection = @getSelectedBufferRange()

return if selection.start.row is 0

lastRow = @buffer.getLastRow()

return if selection.isEmpty() and selection.start.row is lastRow and @buffer.getLastLine() is ''

@transact =>

foldedRows = []

rows = [selection.start.row..selection.end.row]

if selection.start.row isnt selection.end.row and selection.end.column is 0

rows.pop() unless @isFoldedAtBufferRow(selection.end.row)

# Move line around the fold that is directly above the selection

precedingScreenRow = @screenPositionForBufferPosition([selection.start.row]).translate([-1])

precedingBufferRow = @bufferPositionForScreenPosition(precedingScreenRow).row

if fold = @largestFoldContainingBufferRow(precedingBufferRow)

insertDelta = fold.getBufferRange().getRowCount()

else

insertDelta = 1

for row in rows

if fold = @displayBuffer.largestFoldStartingAtBufferRow(row)

bufferRange = fold.getBufferRange()

startRow = bufferRange.start.row

endRow = bufferRange.end.row

foldedRows.push(startRow - insertDelta)

else

startRow = row

endRow = row

insertPosition = Point.fromObject([startRow - insertDelta])

endPosition = Point.min([endRow + 1], @buffer.getEndPosition())

lines = @buffer.getTextInRange([[startRow], endPosition])

if endPosition.row is lastRow and endPosition.column > 0 and not @buffer.lineEndingForRow(endPosition.row)

lines = "#{lines}\n"

@buffer.deleteRows(startRow, endRow)

# Make sure the inserted text doesn't go into an existing fold

if fold = @displayBuffer.largestFoldStartingAtBufferRow(insertPosition.row)

@unfoldBufferRow(insertPosition.row)

foldedRows.push(insertPosition.row + endRow - startRow + fold.getBufferRange().getRowCount())

@buffer.insert(insertPosition, lines)

# Restore folds that existed before the lines were moved

for foldedRow in foldedRows when 0 <= foldedRow <= @getLastBufferRow()

@foldBufferRow(foldedRow)

@setSelectedBufferRange(selection.translate([-insertDelta]), preserveFolds: true, autoscroll: true)

# Move lines intersecting the most recent selection down by one row in screen

# coordinates.

moveLineDown: ->

selection = @getSelectedBufferRange()

lastRow = @buffer.getLastRow()

return if selection.end.row is lastRow

return if selection.end.row is lastRow - 1 and @buffer.getLastLine() is ''

@transact =>

foldedRows = []

rows = [selection.end.row..selection.start.row]

if selection.start.row isnt selection.end.row and selection.end.column is 0

rows.shift() unless @isFoldedAtBufferRow(selection.end.row)

# Move line around the fold that is directly below the selection

followingScreenRow = @screenPositionForBufferPosition([selection.end.row]).translate([1])

followingBufferRow = @bufferPositionForScreenPosition(followingScreenRow).row

if fold = @largestFoldContainingBufferRow(followingBufferRow)

insertDelta = fold.getBufferRange().getRowCount()

else

insertDelta = 1

for row in rows

if fold = @displayBuffer.largestFoldStartingAtBufferRow(row)

bufferRange = fold.getBufferRange()

startRow = bufferRange.start.row

endRow = bufferRange.end.row

foldedRows.push(endRow + insertDelta)

else

startRow = row

endRow = row

if endRow + 1 is lastRow

endPosition = [endRow, @buffer.lineLengthForRow(endRow)]

else

endPosition = [endRow + 1]

lines = @buffer.getTextInRange([[startRow], endPosition])

@buffer.deleteRows(startRow, endRow)

insertPosition = Point.min([startRow + insertDelta], @buffer.getEndPosition())

if insertPosition.row is @buffer.getLastRow() and insertPosition.column > 0

lines = "\n#{lines}"

# Make sure the inserted text doesn't go into an existing fold

if fold = @displayBuffer.largestFoldStartingAtBufferRow(insertPosition.row)

@unfoldBufferRow(insertPosition.row)

foldedRows.push(insertPosition.row + fold.getBufferRange().getRowCount())

@buffer.insert(insertPosition, lines)

# Restore folds that existed before the lines were moved

for foldedRow in foldedRows when 0 <= foldedRow <= @getLastBufferRow()

@foldBufferRow(foldedRow)

@setSelectedBufferRange(selection.translate([insertDelta]), preserveFolds: true, autoscroll: true)

# Duplicate the most recent cursor's current line.

duplicateLines: ->

@transact =>

for selection in @getSelectionsOrderedByBufferPosition().reverse()

selectedBufferRange = selection.getBufferRange()

if selection.isEmpty()

{start} = selection.getScreenRange()

selection.selectToScreenPosition([start.row + 1, 0])

[startRow, endRow] = selection.getBufferRowRange()

endRow++

foldedRowRanges =

@outermostFoldsInBufferRowRange(startRow, endRow)

.map (fold) -> fold.getBufferRowRange()

rangeToDuplicate = [[startRow, 0], [endRow, 0]]

textToDuplicate = @getTextInBufferRange(rangeToDuplicate)

textToDuplicate = '\n' + textToDuplicate if endRow > @getLastBufferRow()

@buffer.insert([endRow, 0], textToDuplicate)

delta = endRow - startRow

selection.setBufferRange(selectedBufferRange.translate([delta, 0]))

for [foldStartRow, foldEndRow] in foldedRowRanges

@createFold(foldStartRow + delta, foldEndRow + delta)

return

replaceSelectedText: (options={}, fn) ->

{selectWordIfEmpty} = options

@mutateSelectedText (selection) ->

range = selection.getBufferRange()

if selectWordIfEmpty and selection.isEmpty()

selection.selectWord()

text = selection.getText()

selection.deleteSelectedText()

selection.insertText(fn(text))

selection.setBufferRange(range)

# Split multi-line selections into one selection per line.

#

# Operates on all selections. This method breaks apart all multi-line

# selections to create multiple single-line selections that cumulatively cover

# the same original area.

splitSelectionsIntoLines: ->

@mergeIntersectingSelections =>

for selection in @getSelections()

range = selection.getBufferRange()

continue if range.isSingleLine()

selection.destroy()

{start, end} = range

@addSelectionForBufferRange([start, [start.row, Infinity]])

{row} = start

while ++row < end.row

@addSelectionForBufferRange([[row, 0], [row, Infinity]])

@addSelectionForBufferRange([[end.row, 0], [end.row, end.column]]) unless end.column is 0

return

# Extended: For each selection, transpose the selected text.

#

# If the selection is empty, the characters preceding and following the cursor

# are swapped. Otherwise, the selected characters are reversed.

transpose: ->

@mutateSelectedText (selection) ->

if selection.isEmpty()

selection.selectRight()

text = selection.getText()

selection.delete()

selection.cursor.moveLeft()

selection.insertText text

else