From c90a0364578668ae677ff5be70861c22c8dc8060 Mon Sep 17 00:00:00 2001 From: Diullei Gomes Date: Sat, 16 Feb 2013 22:37:07 -0200 Subject: [PATCH] Ace Cloud9 Editor definitions #260 --- README.md | 7 +- ace/ace-tests.ts | 453 ++++++++ ace/ace.d.ts | 2755 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 3213 insertions(+), 2 deletions(-) create mode 100644 ace/ace-tests.ts create mode 100644 ace/ace.d.ts diff --git a/README.md b/README.md index dfc5671f8..f263e56d3 100644 --- a/README.md +++ b/README.md @@ -22,12 +22,15 @@ It is very desirable each new contribution to contain tests too. Other means to get the definitions ---------------------------------- -[TypeScript definition package manager](https://github.com/Diullei/tsd) +* [TypeScript definition package manager](https://github.com/Diullei/tsd) -NuGet package(s) coming soon +* [tsdpm](http://www.tsdpm.com/) - Online search + +> NuGet package(s) coming soon List of Definitions ------------------- +* [Ace Cloud9 Editor](http://ace.ajax.org/) (by [Diullei Gomes](https://github.com/Diullei)) * [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes)) * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov)) * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov)) diff --git a/ace/ace-tests.ts b/ace/ace-tests.ts new file mode 100644 index 000000000..43556fb83 --- /dev/null +++ b/ace/ace-tests.ts @@ -0,0 +1,453 @@ +/// + +var assert: any; + +var editor = ace.edit("editor"); +editor.setTheme("ace/theme/monokai"); +editor.getSession().setMode("ace/mode/javascript"); + +editor.setTheme("ace/theme/twilight"); + +editor.getSession().setMode("ace/mode/javascript"); + +editor.setValue("the new text here"); // or session.setValue +editor.getValue(); // or session.getValue + +editor.session.getTextRange(editor.getSelectionRange()); + +editor.insert("Something cool"); + +editor.selection.getCursor(); + +editor.gotoLine(123); + +editor.session.getLength(); + +editor.getSession().setTabSize(4); + +editor.getSession().setUseSoftTabs(true); + +document.getElementById('editor').style.fontSize = '12px'; + +editor.getSession().setUseWrapMode(true); + +editor.setHighlightActiveLine(false); + +editor.setShowPrintMargin(false); + +editor.setReadOnly(true); // false to make it editable + +editor.resize() + +editor.find('needle', { + backwards: false, + wrap: false, + caseSensitive: false, + wholeWord: false, + regExp: false +}); +editor.findNext(); +editor.findPrevious(); + +editor.find('foo'); +editor.replace('bar'); + +editor.replaceAll('bar'); + +editor.getSession().on('change', function (e) { +// e.type, etc +}); + +editor.getSession().selection.on('changeSelection', function (e) { +}); + +editor.getSession().selection.on('changeCursor', function (e) { +}); + +editor.commands.addCommand({ +name: 'myCommand', +bindKey: { win: 'Ctrl-M', mac: 'Command-M' }, +exec: function (editor) { +//... +}, +readOnly: true // false if this command should not apply in readOnly mode +}); + +editor.moveCursorTo(1, 1); +editor.removeLines(); + +editor.removeLines(); + +editor.removeLines(); + +editor.removeLines(); + +editor.moveCursorTo(1, 1); +editor.getSelection().selectDown(); + +editor.removeLines(); + +editor.removeLines(); + +editor.moveCursorTo(3, 0); + +editor.removeLines(); + +editor.removeLines(); + +editor.moveCursorTo(1, 3); +editor.getSelection().selectDown(); + +editor.indent(); + +var range = editor.getSelectionRange(); + +editor.moveCursorTo(1, 0); +editor.getSelection().selectDown(); + +editor.indent(); + +editor.moveCursorTo(0, 0); +editor.onTextInput("\n"); + +editor.moveCursorTo(0, 5); +editor.getSelection().selectDown(); +editor.getSelection().selectDown(); + +editor.blockOutdent(); + +editor.moveCursorTo(1, 1); +editor.removeLines(); + +var session = new AceAjax.EditSession(["a", "b", "c", "d"].join("\n")); + +assert.equal(session.toString(), "a\nc\nd"); +assert.position(editor.getCursorPosition(), 1, 0); + +editor.removeLines(); + +assert.equal(session.toString(), "a\nd"); +assert.position(editor.getCursorPosition(), 1, 0); + +editor.removeLines(); + +assert.equal(session.toString(), "a"); +assert.position(editor.getCursorPosition(), 0, 1); + +editor.removeLines(); + +assert.equal(session.toString(), ""); +assert.position(editor.getCursorPosition(), 0, 0); + +editor.moveCursorTo(1, 1); +editor.getSelection().selectDown(); + +editor.removeLines(); +assert.equal(session.toString(), "a\nd"); +assert.position(editor.getCursorPosition(), 1, 0); + + +editor.removeLines(); + +assert.equal(session.toString(), "b\nc"); +assert.position(editor.getCursorPosition(), 0, 0); + + +editor.moveCursorTo(3, 0); + +editor.removeLines(); +assert.equal(session.toString(), "a\nb\nc"); +assert.position(editor.getCursorPosition(), 2, 1); + +editor.removeLines(); +assert.equal(session.toString(), "a\nb"); +assert.position(editor.getCursorPosition(), 1, 1); + + +editor.moveCursorTo(1, 3); +editor.getSelection().selectDown(); + +editor.indent(); + +assert.equal(["a12345", " b12345", " c12345"].join("\n"), session.toString()); + +assert.position(editor.getCursorPosition(), 2, 7); + +range = editor.getSelectionRange(); +assert.position(range.start, 1, 7); +assert.position(range.end, 2, 7); + + +editor.moveCursorTo(1, 0); +editor.getSelection().selectDown(); + +editor.indent(); +assert.equal(["a12345", " b12345", "c12345"].join("\n"), session.toString()); + + +editor.moveCursorTo(0, 0); +editor.onTextInput("\n"); +assert.equal(["", "{"].join("\n"), session.toString()); + + +editor.moveCursorTo(0, 5); +editor.getSelection().selectDown(); +editor.getSelection().selectDown(); + +editor.blockOutdent(); +assert.equal(session.toString(), [" a12345", "b12345", " c12345"].join("\n")); + +assert.position(editor.getCursorPosition(), 2, 1); + +range = editor.getSelectionRange(); +assert.position(range.start, 0, 1); +assert.position(range.end, 2, 1); + +editor.blockOutdent(); +assert.equal(session.toString(), ["a12345", "b12345", "c12345"].join("\n")); + +range = editor.getSelectionRange(); +assert.position(range.start, 0, 0); +assert.position(range.end, 2, 0); + + +editor.moveCursorTo(0, 3); +editor.blockOutdent(" "); + +assert.equal(session.toString(), " 12"); +assert.position(editor.getCursorPosition(), 0, 0); + + +editor.moveCursorTo(0, 2); +editor.getSelection().selectDown(); +editor.toggleCommentLines(); + +assert.equal(["// abc", "//cde"].join("\n"), session.toString()); + +var selection = editor.getSelectionRange(); +assert.position(selection.start, 0, 4); +assert.position(selection.end, 1, 4); + + +editor.moveCursorTo(0, 1); +editor.getSelection().selectDown(); +editor.getSelection().selectRight(); +editor.getSelection().selectRight(); + +editor.toggleCommentLines(); + +assert.equal([" abc", "cde"].join("\n"), session.toString()); +assert.range(editor.getSelectionRange(), 0, 0, 1, 1); + + +editor.moveCursorTo(0, 0); +editor.getSelection().selectDown(); +editor.getSelection().selectDown(); + +editor.toggleCommentLines(); +editor.toggleCommentLines(); + +assert.equal([" abc", "cde", "fg"].join("\n"), session.toString()); + + +editor.moveCursorTo(0, 0); +editor.getSelection().selectDown(); + +editor.toggleCommentLines(); +assert.range(editor.getSelectionRange(), 0, 2, 1, 0); + + + +editor.moveCursorTo(1, 0); +editor.getSelection().selectUp(); + +editor.toggleCommentLines(); +assert.range(editor.getSelectionRange(), 0, 2, 1, 0); + + +editor.moveCursorTo(0, 1); +editor.getSelection().selectDown(); + +editor.moveLinesDown(); +assert.equal(["33", "11", "22", "44"].join("\n"), session.toString()); +assert.position(editor.getCursorPosition(), 1, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 3, 0); +assert.position(editor.getSelection().getSelectionLead(), 1, 0); + +editor.moveLinesDown(); +assert.equal(["33", "44", "11", "22"].join("\n"), session.toString()); +assert.position(editor.getCursorPosition(), 2, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 3, 2); +assert.position(editor.getSelection().getSelectionLead(), 2, 0); + +// moving again should have no effect +editor.moveLinesDown(); +assert.equal(["33", "44", "11", "22"].join("\n"), session.toString()); +assert.position(editor.getCursorPosition(), 2, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 3, 2); +assert.position(editor.getSelection().getSelectionLead(), 2, 0); + + +editor.moveCursorTo(2, 1); +editor.getSelection().selectDown(); + +editor.moveLinesUp(); +assert.equal(session.toString(), ["11", "33", "44", "22"].join("\n")); +assert.position(editor.getCursorPosition(), 1, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 3, 0); +assert.position(editor.getSelection().getSelectionLead(), 1, 0); + +editor.moveLinesUp(); +assert.equal(session.toString(), ["33", "44", "11", "22"].join("\n")); +assert.position(editor.getCursorPosition(), 0, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 2, 0); +assert.position(editor.getSelection().getSelectionLead(), 0, 0); + + +editor.moveCursorTo(1, 1); +editor.clearSelection(); + +editor.moveLinesDown(); +assert.equal(["11", "33", "22", "44"].join("\n"), session.toString()); +assert.position(editor.getCursorPosition(), 2, 1); + +editor.clearSelection(); + +editor.moveLinesUp(); +assert.equal(["11", "22", "33", "44"].join("\n"), session.toString()); +assert.position(editor.getCursorPosition(), 1, 1); + + +editor.moveCursorTo(1, 1); +editor.getSelection().selectDown(); + +editor.copyLinesDown(); +assert.equal(["11", "22", "33", "22", "33", "44"].join("\n"), session.toString()); + +assert.position(editor.getCursorPosition(), 3, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 5, 0); +assert.position(editor.getSelection().getSelectionLead(), 3, 0); + + +editor.moveCursorTo(1, 1); +editor.getSelection().selectDown(); + +editor.copyLinesUp(); +assert.equal(["11", "22", "33", "22", "33", "44"].join("\n"), session.toString()); + +assert.position(editor.getCursorPosition(), 1, 0); +assert.position(editor.getSelection().getSelectionAnchor(), 3, 0); +assert.position(editor.getSelection().getSelectionLead(), 1, 0); + + +session.setTabSize(2); +session.setUseSoftTabs(true); + +editor.onTextInput("\t"); +assert.equal(session.toString(), " "); + +session.setTabSize(5); +editor.onTextInput("\t"); +assert.equal(session.toString(), " "); + + +session.setUseSoftTabs(false); + +editor.onTextInput("\t"); +assert.equal(session.toString(), "\t"); + +editor.removeLines(); +var step1 = session.toString(); +assert.equal(step1, "222\n333"); + +editor.removeLines(); +var step2 = session.toString(); +assert.equal(step2, "333"); + +editor.removeLines(); +var step3 = session.toString(); +assert.equal(step3, ""); + +var undoManager = new AceAjax.UndoManager(); + +undoManager.undo(); +assert.equal(session.toString(), step2); + +undoManager.undo(); +assert.equal(session.toString(), step1); + +undoManager.undo(); +assert.equal(session.toString(), ""); + +undoManager.undo(); +assert.equal(session.toString(), ""); + +editor.moveCursorTo(1, 1); +editor.remove("left"); +assert.equal(session.toString(), "123\n56"); + +editor.moveCursorTo(1, 0); +editor.remove("left"); +assert.equal(session.toString(), "123456"); + +session.setUseSoftTabs(true); +session.setTabSize(4); + +editor.moveCursorTo(1, 8); +editor.remove("left"); +assert.equal(session.toString(), "123\n 456"); + +editor.moveCursorTo(1, 0); +editor.transposeLetters(); + +assert.equal(session.getValue(), ["123", "4567", "89"].join("\n")); + +editor.moveCursorTo(1, 2); +editor.transposeLetters(); + +assert.equal(session.getValue(), ["123", "4657", "89"].join("\n")); + +editor.moveCursorTo(1, 4); +editor.transposeLetters(); + +assert.equal(session.getValue(), ["123", "4576", "89"].join("\n")); + +editor.moveCursorTo(1, 1); +editor.getSelection().selectRight(); +editor.transposeLetters(); + +assert.equal(session.getValue(), ["123", "4567", "89"].join("\n")); + +editor.moveCursorTo(1, 2); +editor.transposeLetters(); +assert.position(editor.getCursorPosition(), 1, 3); + +editor.moveCursorTo(1, 2); +editor.removeToLineEnd(); +assert.equal(session.getValue(), ["123", "45", "89"].join("\n")); + +editor.moveCursorTo(1, 4); +editor.removeToLineEnd(); +assert.position(editor.getCursorPosition(), 1, 4); +assert.equal(session.getValue(), ["123", "456789"].join("\n")); + +editor.moveCursorTo(1, 0); +editor.getSelection().selectLineEnd(); +editor.toUpperCase() +assert.equal(session.getValue(), ["ajax", "DOT", "org"].join("\n")); + +editor.moveCursorTo(1, 0); +editor.toUpperCase() +assert.equal(session.getValue(), ["ajax", "DOT", "org"].join("\n")); +assert.position(editor.getCursorPosition(), 1, 0); + +editor.moveCursorTo(1, 0); +editor.getSelection().selectLineEnd(); +editor.toLowerCase() +assert.equal(session.getValue(), ["AJAX", "dot", "ORG"].join("\n")); + +editor.moveCursorTo(1, 0); +editor.toLowerCase() +assert.equal(session.getValue(), ["AJAX", "dot", "ORG"].join("\n")); +assert.position(editor.getCursorPosition(), 1, 0); + diff --git a/ace/ace.d.ts b/ace/ace.d.ts new file mode 100644 index 000000000..e0adada66 --- /dev/null +++ b/ace/ace.d.ts @@ -0,0 +1,2755 @@ +// Type definitions for Ace Ajax.org Cloud9 Editor +// Project: http://ace.ajax.org/ +// Definitions by: Diullei Gomes +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +module AceAjax { + + interface CommandManager { + addCommand(command); + } + + interface TextMode { + getTokenizer(): any; + toggleCommentLines(state, doc, startRow, endRow); + getNextLineIndent (state, line, tab): any; + checkOutdent(state, line, input); + autoOutdent(state, doc, row); + createWorker(session); + createModeDelegates (mapping); + transformAction(state, action, editor, session, param); + } + + //////////////// + /// Ace + //////////////// + + /** + * The main class required to set up an Ace instance in the browser. + **/ + interface Ace { + + /** + * Provides access to require in packed noconflict mode + * @param moduleName + **/ + require(moduleName: string): any; + + /** + * Embeds the Ace editor into the DOM, at the element provided by `el`. + * @param el Either the id of an element, or the element itself + **/ + edit(el: string): Editor; + + /** + * Embeds the Ace editor into the DOM, at the element provided by `el`. + * @param el Either the id of an element, or the element itself + **/ + edit(el: HTMLElement): Editor; + + /** + * Creates a new [[EditSession]], and returns the associated [[Document]]. + * @param text {:textParam} + * @param mode {:modeParam} + **/ + createEditSession(text: Document, mode: TextMode): EditSession; + + /** + * Creates a new [[EditSession]], and returns the associated [[Document]]. + * @param text {:textParam} + * @param mode {:modeParam} + **/ + createEditSession(text: string, mode: TextMode): EditSession; + } + + //////////////// + /// Anchor + //////////////// + + /** + * Defines the floating pointer in the document. Whenever text is inserted or deleted before the cursor, the position of the cursor is updated. + **/ + interface Anchor { + + on(event: string, fn: (e) => any); + + /** + * Returns an object identifying the `row` and `column` position of the current anchor. + **/ + getPosition(): any; + + /** + * Returns the current document. + **/ + getDocument(): Document; + + /** + * Fires whenever the anchor position changes. + * Both of these objects have a `row` and `column` property corresponding to the position. + * Events that can trigger this function include [[Anchor.setPosition `setPosition()`]]. + * @param e An object containing information about the anchor position. It has two properties: + * - `old`: An object describing the old Anchor position + * - `value`: An object describing the new Anchor position + **/ + onChange(e: any); + + /** + * Sets the anchor position to the specified row and column. If `noClip` is `true`, the position is not clipped. + * @param row The row index to move the anchor to + * @param column The column index to move the anchor to + * @param noClip Identifies if you want the position to be clipped + **/ + setPosition(row: number, column: number, noClip: bool); + + /** + * When called, the `'change'` event listener is removed. + **/ + detach(); + } + declare var Anchor: { + /** + * Creates a new `Anchor` and associates it with a document. + * @param doc The document to associate with the anchor + * @param row The starting row position + * @param column The starting column position + **/ + new(doc: Document, row: number, column: number): Anchor; + } + + //////////////////////////////// + /// BackgroundTokenizer + //////////////////////////////// + + /** + * Tokenizes the current [[Document `Document`]] in the background, and caches the tokenized rows for future use. + * If a certain row is changed, everything below that row is re-tokenized. + **/ + interface BackgroundTokenizer { + + /** + * Sets a new tokenizer for this object. + * @param tokenizer The new tokenizer to use + **/ + setTokenizer(tokenizer: Tokenizer); + + /** + * Sets a new document to associate with this object. + * @param doc The new document to associate with + **/ + setDocument(doc: Document); + + /** + * Emits the `'update'` event. `firstRow` and `lastRow` are used to define the boundaries of the region to be updated. + * @param firstRow The starting row region + * @param lastRow The final row region + **/ + fireUpdateEvent(firstRow: number, lastRow: number); + + /** + * Starts tokenizing at the row indicated. + * @param startRow The row to start at + **/ + start(startRow: number); + + /** + * Stops tokenizing. + **/ + stop(); + + /** + * Gives list of tokens of the row. (tokens are cached) + * @param row The row to get tokens at + **/ + getTokens(row: number); + + /** + * [Returns the state of tokenization at the end of a row.]{: #BackgroundTokenizer.getState} + * @param row The row to get state at + **/ + getState(row: number); + } + declare var BackgroundTokenizer: { + /** + * Creates a new `BackgroundTokenizer` object. + * @param tokenizer The tokenizer to use + * @param editor The editor to associate with + **/ + new(tokenizer: Tokenizer, editor: Editor): BackgroundTokenizer; + } + + //////////////// + /// Document + //////////////// + + /** + * Contains the text of the document. Document can be attached to several [[EditSession `EditSession`]]s. + * At its core, `Document`s are just an array of strings, with each row in the document matching up to the array index. + **/ + interface Document { + + /** + * Replaces all the lines in the current `Document` with the value of `text`. + * @param text The text to use + **/ + setValue(text: string); + + /** + * Returns all the lines in the document as a single string, split by the new line character. + **/ + getValue(); + + /** + * Creates a new `Anchor` to define a floating point in the document. + * @param row The row number to use + * @param column The column number to use + **/ + createAnchor(row: number, column: number); + + /** + * Returns the newline character that's being used, depending on the value of `newLineMode`. + **/ + getNewLineCharacter(): string; + + /** + * [Sets the new line mode.]{: #Document.setNewLineMode.desc} + * @param newLineMode [The newline mode to use; can be either `windows`, `unix`, or `auto`]{: #Document.setNewLineMode.param} + **/ + setNewLineMode(newLineMode: string); + + /** + * [Returns the type of newlines being used; either `windows`, `unix`, or `auto`]{: #Document.getNewLineMode} + **/ + getNewLineMode(): string; + + /** + * Returns `true` if `text` is a newline character (either `\r\n`, `\r`, or `\n`). + * @param text The text to check + **/ + isNewLine(text: string); + + /** + * Returns a verbatim copy of the given line as it is in the document + * @param row The row index to retrieve + **/ + getLine(row: number); + + /** + * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`. + * @param firstRow The first row index to retrieve + * @param lastRow The final row index to retrieve + **/ + getLines(firstRow: number, lastRow: number); + + /** + * Returns all lines in the document as string array. Warning: The caller should not modify this array! + **/ + getAllLines(); + + /** + * Returns the number of rows in the document. + **/ + getLength(); + + /** + * [Given a range within the document, this function returns all the text within that range as a single string.]{: #Document.getTextRange.desc} + * @param range The range to work with + **/ + getTextRange(range: Range); + + /** + * Inserts a block of `text` and the indicated `position`. + * @param position The position to start inserting at + * @param text A chunk of text to insert + **/ + insert(position: any, text: string): any; + + /** + * Inserts the elements in `lines` into the document, starting at the row index given by `row`. This method also triggers the `'change'` event. + * @param row The index of the row to insert at + * @param lines An array of strings + **/ + insertLines(row: number, lines: Array): any; + + /** + * Inserts a new line into the document at the current row's `position`. This method also triggers the `'change'` event. + * @param position The position to insert at + **/ + insertNewLine(position: any): any; + + /** + * Inserts `text` into the `position` at the current row. This method also triggers the `'change'` event. + * @param position The position to insert at + * @param text A chunk of text + **/ + insertInLine(position: any, text: string): any; + + /** + * Removes the `range` from the document. + * @param range A specified Range to remove + **/ + remove(range: Range): any; + + /** + * Removes the specified columns from the `row`. This method also triggers the `'change'` event. + * @param row The row to remove from + * @param startColumn The column to start removing at + * @param endColumn The column to stop removing at + **/ + removeInLine(row: number, startColumn: number, endColumn: number): any; + + /** + * Removes a range of full lines. This method also triggers the `'change'` event. + * @param firstRow The first row to be removed + * @param lastRow The last row to be removed + **/ + removeLines(firstRow: number, lastRow: number): string[]; + + /** + * Removes the new line between `row` and the row immediately following it. This method also triggers the `'change'` event. + * @param row The row to check + **/ + removeNewLine(row: number); + + /** + * Replaces a range in the document with the new `text`. + * @param range A specified Range to replace + * @param text The new text to use as a replacement + **/ + replace(range: Range, text: string): any; + + /** + * Applies all the changes previously accumulated. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`. + **/ + applyDeltas(); + + /** + * Reverts any changes previously applied. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`. + **/ + revertDeltas(); + + /** + * Converts an index position in a document to a `{row, column}` object. + * Index refers to the "absolute position" of a character in the document. For example: + * ```javascript + * var x = 0; // 10 characters, plus one for newline + * var y = -1; + * ``` + * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second. + * @param index An index to convert + * @param startRow=0 The row from which to start the conversion + **/ + indexToPosition(index: number, startRow: number): any; + + /** + * Converts the `{row, column}` position in a document to the character's index. + * Index refers to the "absolute position" of a character in the document. For example: + * ```javascript + * var x = 0; // 10 characters, plus one for newline + * var y = -1; + * ``` + * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second. + * @param pos The `{row, column}` to convert + * @param startRow=0 The row from which to start the conversion + **/ + positionToIndex(pos: any, startRow: number): number; + } + declare var Document: { + /** + * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty. + * @param text The starting text + **/ + new(text?: string): Document; + /** + * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty. + * @param text The starting text + **/ + new(text?: string[]): Document; + } + + //////////////////////////////// + /// EditSession + //////////////////////////////// + + /** + * Stores all the data about [[Editor `Editor`]] state providing easy way to change editors state. + * `EditSession` can be attached to only one [[Document `Document`]]. Same `Document` can be attached to several `EditSession`s. + **/ + interface EditSession { + + on(event: string, fn: (e) => any); + + selection: Selection; + + /** + * Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`. + * @param doc The new `Document` to use + **/ + setDocument(doc: Document); + + /** + * Returns the `Document` associated with this session. + **/ + getDocument(); + + /** + * undefined + * @param row The row to work with + **/ + $resetRowCache(row: number); + + /** + * Sets the session text. + * @param text The new text to place + **/ + setValue(text: string); + + setMode(mode: string); + + /** + * Returns the current [[Document `Document`]] as a string. + **/ + getValue(): string; + + /** + * Returns the string of the current selection. + **/ + getSelection(): Selection; + + /** + * {:BackgroundTokenizer.getState} + * @param row The row to start at + **/ + getState(row: number); + + /** + * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows. + * @param row The row to start at + **/ + getTokens(row: number); + + /** + * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`. + * @param row The row number to retrieve from + * @param column The column number to retrieve from + **/ + getTokenAt(row: number, column: number); + + /** + * Sets the undo manager. + * @param undoManager The new undo manager + **/ + setUndoManager(undoManager: UndoManager); + + /** + * Returns the current undo manager. + **/ + getUndoManager(); + + /** + * Returns the current value for tabs. If the user is using soft tabs, this will be a series of spaces (defined by [[EditSession.getTabSize `getTabSize()`]]); otherwise it's simply `'\t'`. + **/ + getTabString(); + + /** + * Pass `true` to enable the use of soft tabs. Soft tabs means you're using spaces instead of the tab character (`'\t'`). + * @param useSoftTabs Value indicating whether or not to use soft tabs + **/ + setUseSoftTabs(useSoftTabs: bool); + + /** + * Returns `true` if soft tabs are being used, `false` otherwise. + **/ + getUseSoftTabs(): bool; + + /** + * Set the number of spaces that define a soft tab; for example, passing in `4` transforms the soft tabs to be equivalent to four spaces. This function also emits the `changeTabSize` event. + * @param tabSize The new tab size + **/ + setTabSize(tabSize: number); + + /** + * Returns the current tab size. + **/ + getTabSize(); + + /** + * Returns `true` if the character at the position is a soft tab. + * @param position The position to check + **/ + isTabStop(position: any); + + /** + * Pass in `true` to enable overwrites in your session, or `false` to disable. + * If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event. + * @param overwrite Defines wheter or not to set overwrites + **/ + setOverwrite(overwrite: bool); + + /** + * Returns `true` if overwrites are enabled; `false` otherwise. + **/ + getOverwrite(); + + /** + * Sets the value of overwrite to the opposite of whatever it currently is. + **/ + toggleOverwrite(); + + /** + * Adds `className` to the `row`, to be used for CSS stylings and whatnot. + * @param row The row number + * @param className The class to add + **/ + addGutterDecoration(row: number, className: string); + + /** + * Removes `className` from the `row`. + * @param row The row number + * @param className The class to add + **/ + removeGutterDecoration(row: number, className: string); + + /** + * Returns an array of numbers, indicating which rows have breakpoints. + **/ + getBreakpoints(): number[]; + + /** + * Sets a breakpoint on every row number given by `rows`. This function also emites the `'changeBreakpoint'` event. + * @param rows An array of row indices + **/ + setBreakpoints(rows: Array); + + /** + * Removes all breakpoints on the rows. This function also emites the `'changeBreakpoint'` event. + **/ + clearBreakpoints(); + + /** + * Sets a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event. + * @param row A row index + * @param className Class of the breakpoint + **/ + setBreakpoint(row: number, className: string); + + /** + * Removes a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event. + * @param row A row index + **/ + clearBreakpoint(row: number); + + /** + * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires. + * @param range Define the range of the marker + * @param clazz Set the CSS class for the marker + * @param type Identify the type of the marker + * @param inFront Set to `true` to establish a front marker + **/ + addMarker(range: Range, clazz: string, type: Function, inFront: bool); + + /** + * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires. + * @param range Define the range of the marker + * @param clazz Set the CSS class for the marker + * @param type Identify the type of the marker + * @param inFront Set to `true` to establish a front marker + **/ + addMarker(range: Range, clazz: string, type: string, inFront: bool); + + /** + * Adds a dynamic marker to the session. + * @param marker object with update method + * @param inFront Set to `true` to establish a front marker + **/ + addDynamicMarker(marker: any, inFront: bool); + + /** + * Removes the marker with the specified ID. If this marker was in front, the `'changeFrontMarker'` event is emitted. If the marker was in the back, the `'changeBackMarker'` event is emitted. + * @param markerId A number representing a marker + **/ + removeMarker(markerId: number); + + /** + * Returns an array containing the IDs of all the markers, either front or back. + * @param inFront If `true`, indicates you only want front markers; `false` indicates only back markers + **/ + getMarkers(inFront: bool): Array; + + /** + * Sets annotations for the `EditSession`. This functions emits the `'changeAnnotation'` event. + * @param annotations A list of annotations + **/ + setAnnotations(annotations: Array); + + /** + * Returns the annotations for the `EditSession`. + **/ + getAnnotations(): any; + + /** + * Clears all the annotations for this session. This function also triggers the `'changeAnnotation'` event. + **/ + clearAnnotations(); + + /** + * If `text` contains either the newline (`\n`) or carriage-return ('\r') characters, `$autoNewLine` stores that value. + * @param text A block of text + **/ + $detectNewLine(text: string); + + /** + * Given a starting row and column, this method returns the `Range` of the first word boundary it finds. + * @param row The row to start at + * @param column The column to start at + **/ + getWordRange(row: number, column: number): Range; + + /** + * Gets the range of a word, including its right whitespace. + * @param row The row number to start from + * @param column The column number to start from + **/ + getAWordRange(row: number, column: number); + + /** + * {:Document.setNewLineMode.desc} + * @param newLineMode {:Document.setNewLineMode.param} + **/ + setNewLineMode(newLineMode: string); + + /** + * Returns the current new line mode. + **/ + getNewLineMode(): string; + + /** + * Identifies if you want to use a worker for the `EditSession`. + * @param useWorker Set to `true` to use a worker + **/ + setUseWorker(useWorker: bool); + + /** + * Returns `true` if workers are being used. + **/ + getUseWorker(); + + /** + * Reloads all the tokens on the current session. This function calls [[BackgroundTokenizer.start `BackgroundTokenizer.start ()`]] to all the rows; it also emits the `'tokenizerUpdate'` event. + **/ + onReloadTokenizer(); + + /** + * Sets a new text mode for the `EditSession`. This method also emits the `'changeMode'` event. If a [[BackgroundTokenizer `BackgroundTokenizer`]] is set, the `'tokenizerUpdate'` event is also emitted. + * @param mode Set a new text mode + **/ + $mode(mode: TextMode); + + /** + * Returns the current text mode. + **/ + getMode(): TextMode; + + /** + * This function sets the scroll top value. It also emits the `'changeScrollTop'` event. + * @param scrollTop The new scroll top value + **/ + setScrollTop(scrollTop: number); + + /** + * [Returns the value of the distance between the top of the editor and the topmost part of the visible content.]{: #EditSession.getScrollTop} + **/ + getScrollTop(): number; + + /** + * [Sets the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.setScrollLeft} + **/ + setScrollLeft(); + + /** + * [Returns the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.getScrollLeft} + **/ + getScrollLeft(): number; + + /** + * Returns the width of the screen. + **/ + getScreenWidth(): number; + + /** + * Returns a verbatim copy of the given line as it is in the document + * @param row The row to retrieve from + **/ + getLine(row: number): string; + + /** + * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`. + * @param firstRow The first row index to retrieve + * @param lastRow The final row index to retrieve + **/ + getLines(firstRow: number, lastRow: number): string[]; + + /** + * Returns the number of rows in the document. + **/ + getLength(): number; + + /** + * {:Document.getTextRange.desc} + * @param range The range to work with + **/ + getTextRange(range: Range): string; + + /** + * Inserts a block of `text` and the indicated `position`. + * @param position The position {row, column} to start inserting at + * @param text A chunk of text to insert + **/ + insert(position: any, text: string): any; + + /** + * Removes the `range` from the document. + * @param range A specified Range to remove + **/ + remove(range: Range): any; + + /** + * Reverts previous changes to your document. + * @param deltas An array of previous changes + * @param dontSelect [If `true`, doesn't select the range of where the change occured]{: #dontSelect} + **/ + undoChanges(deltas: Array, dontSelect: bool): Range; + + /** + * Re-implements a previously undone change to your document. + * @param deltas An array of previous changes + * @param dontSelect {:dontSelect} + **/ + redoChanges(deltas: Array, dontSelect: bool): Range; + + /** + * Enables or disables highlighting of the range where an undo occured. + * @param enable If `true`, selects the range of the reinserted change + **/ + setUndoSelect(enable: bool); + + /** + * Replaces a range in the document with the new `text`. + * @param range A specified Range to replace + * @param text The new text to use as a replacement + **/ + replace(range: Range, text: string): any; + + /** + * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this: + * ```json + * { row: newRowLocation, column: newColumnLocation } + * ``` + * @param fromRange The range of text you want moved within the document + * @param toPosition The location (row and column) where you want to move the text to + **/ + moveText(fromRange: Range, toPosition: any): Range; + + /** + * Indents all the rows, from `startRow` to `endRow` (inclusive), by prefixing each row with the token in `indentString`. + * If `indentString` contains the `'\t'` character, it's replaced by whatever is defined by [[EditSession.getTabString `getTabString()`]]. + * @param startRow Starting row + * @param endRow Ending row + * @param indentString The indent token + **/ + indentRows(startRow: number, endRow: number, indentString: string); + + /** + * Outdents all the rows defined by the `start` and `end` properties of `range`. + * @param range A range of rows + **/ + outdentRows(range: Range); + + /** + * Shifts all the lines in the document up one, starting from `firstRow` and ending at `lastRow`. + * @param firstRow The starting row to move up + * @param lastRow The final row to move up + **/ + moveLinesUp(firstRow: number, lastRow: number): number; + + /** + * Shifts all the lines in the document down one, starting from `firstRow` and ending at `lastRow`. + * @param firstRow The starting row to move down + * @param lastRow The final row to move down + **/ + moveLinesDown(firstRow: number, lastRow: number): number; + + /** + * Duplicates all the text between `firstRow` and `lastRow`. + * @param firstRow The starting row to duplicate + * @param lastRow The final row to duplicate + **/ + duplicateLines(firstRow: number, lastRow: number): number; + + /** + * Sets whether or not line wrapping is enabled. If `useWrapMode` is different than the current value, the `'changeWrapMode'` event is emitted. + * @param useWrapMode Enable (or disable) wrap mode + **/ + setUseWrapMode(useWrapMode: bool); + + /** + * Returns `true` if wrap mode is being used; `false` otherwise. + **/ + getUseWrapMode(): bool; + + /** + * Sets the boundaries of wrap. Either value can be `null` to have an unconstrained wrap, or, they can be the same number to pin the limit. If the wrap limits for `min` or `max` are different, this method also emits the `'changeWrapMode'` event. + * @param min The minimum wrap value (the left side wrap) + * @param max The maximum wrap value (the right side wrap) + **/ + setWrapLimitRange(min: number, max: number); + + /** + * This should generally only be called by the renderer when a resize is detected. + * @param desiredLimit The new wrap limit + **/ + adjustWrapLimit(desiredLimit: number): bool; + + /** + * Returns the value of wrap limit. + **/ + getWrapLimit(): number; + + /** + * Returns an object that defines the minimum and maximum of the wrap limit; it looks something like this: + * { min: wrapLimitRange_min, max: wrapLimitRange_max } + **/ + getWrapLimitRange(): any; + + /** + * Given a string, returns an array of the display characters, including tabs and spaces. + * @param str The string to check + * @param offset The value to start at + **/ + $getDisplayTokens(str: string, offset: number); + + /** + * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen. + * @param str The string to calculate the screen width of + * @param maxScreenColumn + * @param screenColumn + **/ + $getStringScreenWidth(str: string, maxScreenColumn: number, screenColumn: number): number[]; + + /** + * Returns number of screenrows in a wrapped line. + * @param row The row number to check + **/ + getRowLength(row: number): number; + + /** + * Returns the position (on screen) for the last character in the provided screen row. + * @param screenRow The screen row to check + **/ + getScreenLastRowColumn(screenRow: number): number; + + /** + * For the given document row and column, this returns the column position of the last screen row. + * @param docRow + * @param docColumn + **/ + getDocumentLastRowColumn(docRow: number, docColumn: number); + + /** + * For the given document row and column, this returns the document position of the last row. + * @param docRow + * @param docColumn + **/ + getDocumentLastRowColumnPosition(docRow: number, docColumn: number); + + /** + * For the given row, this returns the split data. + **/ + getRowSplitData(): string; + + /** + * The distance to the next tab stop at the specified screen column. + * @param screenColumn The screen column to check + **/ + getScreenTabSize(screenColumn: number): number; + + /** + * Converts characters coordinates on the screen to characters coordinates within the document. [This takes into account code folding, word wrap, tab size, and any other visual modifications.]{: #conversionConsiderations} + * @param screenRow The screen row to check + * @param screenColumn The screen column to check + **/ + screenToDocumentPosition(screenRow: number, screenColumn: number): any; + + /** + * Converts document coordinates to screen coordinates. {:conversionConsiderations} + * @param docRow The document row to check + * @param docColumn The document column to check + **/ + documentToScreenPosition(docRow: number, docColumn: number): any; + + /** + * For the given document row and column, returns the screen column. + * @param row + * @param docColumn + **/ + documentToScreenColumn(row: number, docColumn: number): number; + + /** + * For the given document row and column, returns the screen row. + * @param docRow + * @param docColumn + **/ + documentToScreenRow(docRow: number, docColumn: number); + + /** + * Returns the length of the screen. + **/ + getScreenLength(): number; + } + declare var EditSession: { + /** + * Sets up a new `EditSession` and associates it with the given `Document` and `TextMode`. + * @param text [If `text` is a `Document`, it associates the `EditSession` with it. Otherwise, a new `Document` is created, with the initial text]{: #textParam} + * @param mode [The inital language mode to use for the document]{: #modeParam} + **/ + new(text: string, mode?: TextMode): EditSession; + + new(text: string[]): EditSession; + } + + //////////////////////////////// + /// Editor + //////////////////////////////// + + /** + * The main entry point into the Ace functionality. + * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen. + * Event sessions dealing with the mouse and keyboard are bubbled up from `Document` to the `Editor`, which decides what to do with them. + **/ + interface Editor { + + onTextInput(text: string); + + onCommandKey(e, hashId, keyCode); + + commands: CommandManager; + + session: EditSession; + + selection: Selection; + + /** + * Sets a new key handler, such as "vim" or "windows". + * @param keyboardHandler The new key handler + **/ + setKeyboardHandler(keyboardHandler: string); + + /** + * Returns the keyboard handler, such as "vim" or "windows". + **/ + getKeyboardHandler(): string; + + /** + * Sets a new editsession to use. This method also emits the `'changeSession'` event. + * @param session The new session to use + **/ + setSession(session: EditSession); + + /** + * Returns the current session being used. + **/ + getSession(): EditSession; + + /** + * Sets the current document to `val`. + * @param val The new value to set for the document + * @param cursorPos Where to set the new value. `undefined` or 0 is selectAll, -1 is at the document start, and 1 is at the end + **/ + setValue(val: string, cursorPos?: number): string; + + /** + * Returns the current session's content. + **/ + getValue(): string; + + /** + * Returns the currently highlighted selection. + **/ + getSelection(): Selection; + + /** + * {:VirtualRenderer.onResize} + * @param force If `true`, recomputes the size, even if the height and width haven't changed + **/ + resize(force?: bool); + + /** + * {:VirtualRenderer.setTheme} + * @param theme The path to a theme + **/ + setTheme(theme: string); + + /** + * {:VirtualRenderer.getTheme} + **/ + getTheme(): string; + + /** + * {:VirtualRenderer.setStyle} + * @param style A class name + **/ + setStyle(style: string); + + /** + * {:VirtualRenderer.unsetStyle} + **/ + unsetStyle(); + + /** + * Set a new font size (in pixels) for the editor text. + * @param size A font size ( _e.g._ "12px") + **/ + setFontSize(size: string); + + /** + * Brings the current `textInput` into focus. + **/ + focus(); + + /** + * Returns `true` if the current `textInput` is in focus. + **/ + isFocused(); + + /** + * Blurs the current `textInput`. + **/ + blur(); + + /** + * Emitted once the editor comes into focus. + **/ + onFocus(); + + /** + * Emitted once the editor has been blurred. + **/ + onBlur(); + + /** + * Emitted whenever the document is changed. + * @param e Contains a single property, `data`, which has the delta of changes + **/ + onDocumentChange(e: any); + + /** + * Emitted when the selection changes. + **/ + onCursorChange(); + + /** + * Returns the string of text currently highlighted. + **/ + getCopyText(): string; + + /** + * Called whenever a text "copy" happens. + **/ + onCopy(); + + /** + * Called whenever a text "cut" happens. + **/ + onCut(); + + /** + * Called whenever a text "paste" happens. + * @param text The pasted text + **/ + onPaste(text: string); + + /** + * Inserts `text` into wherever the cursor is pointing. + * @param text The new text to add + **/ + insert(text: string); + + /** + * Pass in `true` to enable overwrites in your session, or `false` to disable. If overwrites is enabled, any text you enter will type over any text after it. If the value of `overwrite` changes, this function also emites the `changeOverwrite` event. + * @param overwrite Defines wheter or not to set overwrites + **/ + setOverwrite(overwrite: bool); + + /** + * Returns `true` if overwrites are enabled; `false` otherwise. + **/ + getOverwrite(): bool; + + /** + * Sets the value of overwrite to the opposite of whatever it currently is. + **/ + toggleOverwrite(); + + /** + * Sets how fast the mouse scrolling should do. + * @param speed A value indicating the new speed (in milliseconds) + **/ + setScrollSpeed(speed: number); + + /** + * Returns the value indicating how fast the mouse scroll speed is (in milliseconds). + **/ + getScrollSpeed(): number; + + /** + * Sets the delay (in milliseconds) of the mouse drag. + * @param dragDelay A value indicating the new delay + **/ + setDragDelay(dragDelay: number); + + /** + * Returns the current mouse drag delay. + **/ + getDragDelay(): number; + + /** + * Indicates how selections should occur. + * By default, selections are set to "line". There are no other styles at the moment, + * although this code change in the future. + * This function also emits the `'changeSelectionStyle'` event. + * @param style The new selection style + **/ + setSelectionStyle(style: string); + + /** + * Returns the current selection style. + **/ + getSelectionStyle(): string; + + /** + * Determines whether or not the current line should be highlighted. + * @param shouldHighlight Set to `true` to highlight the current line + **/ + setHighlightActiveLine(shouldHighlight: bool); + + /** + * Returns `true` if current lines are always highlighted. + **/ + getHighlightActiveLine(); + + /** + * Determines if the currently selected word should be highlighted. + * @param shouldHighlight Set to `true` to highlight the currently selected word + **/ + setHighlightSelectedWord(shouldHighlight: bool); + + /** + * Returns `true` if currently highlighted words are to be highlighted. + **/ + getHighlightSelectedWord(): bool; + + /** + * If `showInvisibiles` is set to `true`, invisible characters—like spaces or new lines—are show in the editor. + * @param showInvisibles Specifies whether or not to show invisible characters + **/ + setShowInvisibles(showInvisibles: bool); + + /** + * Returns `true` if invisible characters are being shown. + **/ + getShowInvisibles(): bool; + + /** + * If `showPrintMargin` is set to `true`, the print margin is shown in the editor. + * @param showPrintMargin Specifies whether or not to show the print margin + **/ + setShowPrintMargin(showPrintMargin: bool); + + /** + * Returns `true` if the print margin is being shown. + **/ + getShowPrintMargin(): bool; + + /** + * Sets the column defining where the print margin should be. + * @param showPrintMargin Specifies the new print margin + **/ + setPrintMarginColumn(showPrintMargin: number); + + /** + * Returns the column number of where the print margin is. + **/ + getPrintMarginColumn(): number; + + /** + * If `readOnly` is true, then the editor is set to read-only mode, and none of the content can change. + * @param readOnly Specifies whether the editor can be modified or not + **/ + setReadOnly(readOnly: bool); + + /** + * Returns `true` if the editor is set to read-only mode. + **/ + getReadOnly(): bool; + + /** + * Specifies whether to use behaviors or not. ["Behaviors" in this case is the auto-pairing of special characters, like quotation marks, parenthesis, or brackets.]{: #BehaviorsDef} + * @param enabled Enables or disables behaviors + **/ + setBehavioursEnabled(enabled: bool); + + /** + * Returns `true` if the behaviors are currently enabled. {:BehaviorsDef} + **/ + getBehavioursEnabled(): bool; + + /** + * Specifies whether to use wrapping behaviors or not, i.e. automatically wrapping the selection with characters such as brackets + * when such a character is typed in. + * @param enabled Enables or disables wrapping behaviors + **/ + setWrapBehavioursEnabled(enabled: bool); + + /** + * Returns `true` if the wrapping behaviors are currently enabled. + **/ + getWrapBehavioursEnabled(); + + /** + * Indicates whether the fold widgets are shown or not. + * @param show Specifies whether the fold widgets are shown + **/ + setShowFoldWidgets(show: bool); + + /** + * Returns `true` if the fold widgets are shown. + **/ + getShowFoldWidgets(); + + /** + * Removes words of text from the editor. A "word" is defined as a string of characters bookended by whitespace. + * @param dir The direction of the deletion to occur, either "left" or "right" + **/ + remove(dir: string); + + /** + * Removes the word directly to the right of the current selection. + **/ + removeWordRight(); + + /** + * Removes the word directly to the left of the current selection. + **/ + removeWordLeft(); + + /** + * Removes all the words to the left of the current selection, until the start of the line. + **/ + removeToLineStart(); + + /** + * Removes all the words to the right of the current selection, until the end of the line. + **/ + removeToLineEnd(); + + /** + * Splits the line at the current selection (by inserting an `'\n'`). + **/ + splitLine(); + + /** + * Transposes current line. + **/ + transposeLetters(); + + /** + * Converts the current selection entirely into lowercase. + **/ + toLowerCase(); + + /** + * Converts the current selection entirely into uppercase. + **/ + toUpperCase(); + + /** + * Inserts an indentation into the current cursor position or indents the selected lines. + **/ + indent(); + + /** + * Indents the current line. + **/ + blockIndent(); + + /** + * Outdents the current line. + **/ + blockOutdent(arg?: string); + + /** + * Given the currently selected range, this function either comments all the lines, or uncomments all of them. + **/ + toggleCommentLines(); + + /** + * Works like [[EditSession.getTokenAt]], except it returns a number. + **/ + getNumberAt(): number; + + /** + * If the character before the cursor is a number, this functions changes its value by `amount`. + * @param amount The value to change the numeral by (can be negative to decrease value) + **/ + modifyNumber(amount: number); + + /** + * Removes all the lines in the current selection + **/ + removeLines(); + + /** + * Shifts all the selected lines down one row. + **/ + moveLinesDown(): number; + + /** + * Shifts all the selected lines up one row. + **/ + moveLinesUp(): number; + + /** + * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this: + * ```json + * { row: newRowLocation, column: newColumnLocation } + * ``` + * @param fromRange The range of text you want moved within the document + * @param toPosition The location (row and column) where you want to move the text to + **/ + moveText(fromRange: Range, toPosition: any): Range; + + /** + * Copies all the selected lines up one row. + **/ + copyLinesUp(): number; + + /** + * Copies all the selected lines down one row. + **/ + copyLinesDown(): number; + + /** + * {:VirtualRenderer.getFirstVisibleRow} + **/ + getFirstVisibleRow(): number; + + /** + * {:VirtualRenderer.getLastVisibleRow} + **/ + getLastVisibleRow(): number; + + /** + * Indicates if the row is currently visible on the screen. + * @param row The row to check + **/ + isRowVisible(row: number): bool; + + /** + * Indicates if the entire row is currently visible on the screen. + * @param row The row to check + **/ + isRowFullyVisible(row: number): bool; + + /** + * Selects the text from the current position of the document until where a "page down" finishes. + **/ + selectPageDown(); + + /** + * Selects the text from the current position of the document until where a "page up" finishes. + **/ + selectPageUp(); + + /** + * Shifts the document to wherever "page down" is, as well as moving the cursor position. + **/ + gotoPageDown(); + + /** + * Shifts the document to wherever "page up" is, as well as moving the cursor position. + **/ + gotoPageUp(); + + /** + * Scrolls the document to wherever "page down" is, without changing the cursor position. + **/ + scrollPageDown(); + + /** + * Scrolls the document to wherever "page up" is, without changing the cursor position. + **/ + scrollPageUp(); + + /** + * Moves the editor to the specified row. + **/ + scrollToRow(); + + /** + * Scrolls to a line. If `center` is `true`, it puts the line in middle of screen (or attempts to). + * @param line The line to scroll to + * @param center If `true` + * @param animate If `true` animates scrolling + * @param callback Function to be called when the animation has finished + **/ + scrollToLine(line: number, center: bool, animate: bool, callback: Function); + + /** + * Attempts to center the current selection on the screen. + **/ + centerSelection(); + + /** + * Gets the current position of the cursor. + **/ + getCursorPosition(): any; + + /** + * Returns the screen position of the cursor. + **/ + getCursorPositionScreen(): number; + + /** + * {:Selection.getRange} + **/ + getSelectionRange(): Range; + + /** + * Selects all the text in editor. + **/ + selectAll(); + + /** + * {:Selection.clearSelection} + **/ + clearSelection(); + + /** + * Moves the cursor to the specified row and column. Note that this does not de-select the current selection. + * @param row The new row number + * @param column The new column number + **/ + moveCursorTo(row: number, column: number); + + /** + * Moves the cursor to the position indicated by `pos.row` and `pos.column`. + * @param pos An object with two properties, row and column + **/ + moveCursorToPosition(pos: any); + + /** + * Moves the cursor's row and column to the next matching bracket. + **/ + jumpToMatching(); + + /** + * Moves the cursor to the specified line number, and also into the indiciated column. + * @param lineNumber The line number to go to + * @param column A column number to go to + * @param animate If `true` animates scolling + **/ + gotoLine(lineNumber: number, column?: number, animate?: bool); + + /** + * Moves the cursor to the specified row and column. Note that this does de-select the current selection. + * @param row The new row number + * @param column The new column number + **/ + navigateTo(row: number, column: number); + + /** + * Moves the cursor up in the document the specified number of times. Note that this does de-select the current selection. + * @param times The number of times to change navigation + **/ + navigateUp(times: number); + + /** + * Moves the cursor down in the document the specified number of times. Note that this does de-select the current selection. + * @param times The number of times to change navigation + **/ + navigateDown(times: number); + + /** + * Moves the cursor left in the document the specified number of times. Note that this does de-select the current selection. + * @param times The number of times to change navigation + **/ + navigateLeft(times: number); + + /** + * Moves the cursor right in the document the specified number of times. Note that this does de-select the current selection. + * @param times The number of times to change navigation + **/ + navigateRight(times: number); + + /** + * Moves the cursor to the start of the current line. Note that this does de-select the current selection. + **/ + navigateLineStart(); + + /** + * Moves the cursor to the end of the current line. Note that this does de-select the current selection. + **/ + navigateLineEnd(); + + /** + * Moves the cursor to the end of the current file. Note that this does de-select the current selection. + **/ + navigateFileEnd(); + + /** + * Moves the cursor to the start of the current file. Note that this does de-select the current selection. + **/ + navigateFileStart(); + + /** + * Moves the cursor to the word immediately to the right of the current position. Note that this does de-select the current selection. + **/ + navigateWordRight(); + + /** + * Moves the cursor to the word immediately to the left of the current position. Note that this does de-select the current selection. + **/ + navigateWordLeft(); + + /** + * Replaces the first occurance of `options.needle` with the value in `replacement`. + * @param replacement The text to replace with + * @param options The [[Search `Search`]] options to use + **/ + replace(replacement: string, options?: any); + + /** + * Replaces all occurances of `options.needle` with the value in `replacement`. + * @param replacement The text to replace with + * @param options The [[Search `Search`]] options to use + **/ + replaceAll(replacement: string, options?: any); + + /** + * {:Search.getOptions} For more information on `options`, see [[Search `Search`]]. + **/ + getLastSearchOptions(): any; + + /** + * Attempts to find `needle` within the document. For more information on `options`, see [[Search `Search`]]. + * @param needle The text to search for (optional) + * @param options An object defining various search properties + * @param animate If `true` animate scrolling + **/ + find(needle: string, options?: any, animate?: bool); + + /** + * Performs another search for `needle` in the document. For more information on `options`, see [[Search `Search`]]. + * @param options search options + * @param animate If `true` animate scrolling + **/ + findNext(options?: any, animate?: bool); + + /** + * Performs a search for `needle` backwards. For more information on `options`, see [[Search `Search`]]. + * @param options search options + * @param animate If `true` animate scrolling + **/ + findPrevious(options?: any, animate?: bool); + + /** + * {:UndoManager.undo} + **/ + undo(); + + /** + * {:UndoManager.redo} + **/ + redo(); + + /** + * Cleans up the entire editor. + **/ + destroy(); + + } + + declare var Editor: { + /** + * Creates a new `Editor` object. + * @param renderer Associated `VirtualRenderer` that draws everything + * @param session The `EditSession` to refer to + **/ + new(renderer: VirtualRenderer, session: EditSession): Editor; + } + + //////////////////////////////// + /// PlaceHolder + //////////////////////////////// + + interface PlaceHolder { + + /** + * PlaceHolder.setup() + * TODO + **/ + setup(); + + /** + * PlaceHolder.showOtherMarkers() + * TODO + **/ + showOtherMarkers(); + + /** + * PlaceHolder.hideOtherMarkers() + * Hides all over markers in the [[EditSession `EditSession`]] that are not the currently selected one. + **/ + hideOtherMarkers(); + + /** + * PlaceHolder@onUpdate(e) + * Emitted when the place holder updates. + **/ + onUpdate(); + + /** + * PlaceHolder@onCursorChange(e) + * Emitted when the cursor changes. + **/ + onCursorChange(); + + /** + * PlaceHolder.detach() + * TODO + **/ + detach(); + + /** + * PlaceHolder.cancel() + * TODO + **/ + cancel(); + } + declare var PlaceHolder: { + /** + * - session (Document): The document to associate with the anchor + * - length (Number): The starting row position + * - pos (Number): The starting column position + * - others (String): + * - mainClass (String): + * - othersClass (String): + **/ + new(): PlaceHolder; + } + + //////////////// + /// Range + //////////////// + + /** + * This object is used in various places to indicate a region within the editor. To better visualize how this works, imagine a rectangle. Each quadrant of the rectangle is analogus to a range, as ranges contain a starting row and starting column, and an ending row, and ending column. + **/ + interface Range { + + start: number; + + end: number; + + /** + * Returns `true` if and only if the starting row and column, and ending row and column, are equivalent to those given by `range`. + * @param range A range to check against + **/ + isEqual(range: Range); + + /** + * Returns a string containing the range's row and column information, given like this: + * ``` + * [start.row/start.column] -> [end.row/end.column] + * ``` + **/ + toString(); + + /** + * Returns `true` if the `row` and `column` provided are within the given range. This can better be expressed as returning `true` if: + * ```javascript + * this.start.row <= row <= this.end.row && + * this.start.column <= column <= this.end.column + * ``` + * @param row A row to check for + * @param column A column to check for + **/ + contains(row: number, column: number): bool; + + /** + * Compares `this` range (A) with another range (B). + * @param range A range to compare with + **/ + compareRange(range: Range): number; + + /** + * Checks the row and column points of `p` with the row and column points of the calling range. + * @param p A point to compare with + **/ + comparePoint(p: Range): number; + + /** + * Checks the start and end points of `range` and compares them to the calling range. Returns `true` if the `range` is contained within the caller's range. + * @param range A range to compare with + **/ + containsRange(range: Range): bool; + + /** + * Returns `true` if passed in `range` intersects with the one calling this method. + * @param range A range to compare with + **/ + intersects(range: Range): bool; + + /** + * Returns `true` if the caller's ending row point is the same as `row`, and if the caller's ending column is the same as `column`. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + isEnd(row: number, column: number): bool; + + /** + * Returns `true` if the caller's starting row point is the same as `row`, and if the caller's starting column is the same as `column`. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + isStart(row: number, column: number): bool; + + /** + * Sets the starting row and column for the range. + * @param row A row point to set + * @param column A column point to set + **/ + setStart(row: number, column: number); + + /** + * Sets the starting row and column for the range. + * @param row A row point to set + * @param column A column point to set + **/ + setEnd(row: number, column: number); + + /** + * Returns `true` if the `row` and `column` are within the given range. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + inside(row: number, column: number): bool; + + /** + * Returns `true` if the `row` and `column` are within the given range's starting points. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + insideStart(row: number, column: number): bool; + + /** + * Returns `true` if the `row` and `column` are within the given range's ending points. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + insideEnd(row: number, column: number): bool; + + /** + * Checks the row and column points with the row and column points of the calling range. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + compare(row: number, column: number): number; + + /** + * Checks the row and column points with the row and column points of the calling range. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + compareStart(row: number, column: number): number; + + /** + * Checks the row and column points with the row and column points of the calling range. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + compareEnd(row: number, column: number): number; + + /** + * Checks the row and column points with the row and column points of the calling range. + * @param row A row point to compare with + * @param column A column point to compare with + **/ + compareInside(row: number, column: number): number; + + /** + * Returns the part of the current `Range` that occurs within the boundaries of `firstRow` and `lastRow` as a new `Range` object. + * @param firstRow The starting row + * @param lastRow The ending row + **/ + clipRows(firstRow: number, lastRow: number): Range; + + /** + * Changes the row and column points for the calling range for both the starting and ending points. + * @param row A new row to extend to + * @param column A new column to extend to + **/ + extend(row: number, column: number): Range; + + /** + * Returns `true` if the range spans across multiple lines. + **/ + isMultiLine(): bool; + + /** + * Returns a duplicate of the calling range. + **/ + clone(): Range; + + /** + * Returns a range containing the starting and ending rows of the original range, but with a column value of `0`. + **/ + collapseRows(): Range; + + /** + * Given the current `Range`, this function converts those starting and ending points into screen positions, and then returns a new `Range` object. + * @param session The `EditSession` to retrieve coordinates from + **/ + toScreenRange(session: EditSession): Range; + + /** + * Creates and returns a new `Range` based on the row and column of the given parameters. + * @param start A starting point to use + * @param end An ending point to use + **/ + fromPoints(start: Range, end: Range): Range; + + } + /** + * Creates a new `Range` object with the given starting and ending row and column points. + * @param startRow The starting row + * @param startColumn The starting column + * @param endRow The ending row + * @param endColumn The ending column + **/ + declare var Range: { + new(startRow: number, startColumn: number, endRow: number, endColumn: number): Range; + } + + //////////////// + /// RenderLoop + //////////////// + + interface RenderLoop { } + declare var RenderLoop: { + new(): RenderLoop; + } + + //////////////// + /// ScrollBar + //////////////// + + /** + * A set of methods for setting and retrieving the editor's scrollbar. + **/ + interface ScrollBar { + + /** + * Emitted when the scroll bar, well, scrolls. + * @param e Contains one property, `"data"`, which indicates the current scroll top position + **/ + onScroll(e: any); + + /** + * Returns the width of the scroll bar. + **/ + getWidth(): number; + + /** + * Sets the height of the scroll bar, in pixels. + * @param height The new height + **/ + setHeight(height: number); + + /** + * Sets the inner height of the scroll bar, in pixels. + * @param height The new inner height + **/ + setInnerHeight(height: number); + + /** + * Sets the scroll top of the scroll bar. + * @param scrollTop The new scroll top + **/ + setScrollTop(scrollTop: number); + } + declare var ScrollBar: { + /** + * Creates a new `ScrollBar`. `parent` is the owner of the scroll bar. + * @param parent A DOM element + **/ + new(parent: HTMLElement): ScrollBar; + } + + //////////////// + /// Search + //////////////// + + /** + * A class designed to handle all sorts of text searches within a [[Document `Document`]]. + **/ + interface Search { + + /** + * Sets the search options via the `options` parameter. + * @param options An object containing all the new search properties + **/ + set(options: any): Search; + + /** + * [Returns an object containing all the search options.]{: #Search.getOptions} + **/ + getOptions(): any; + + /** + * Sets the search options via the `options` parameter. + * @param An object containing all the search propertie + **/ + setOptions(An: any); + + /** + * Searches for `options.needle`. If found, this method returns the [[Range `Range`]] where the text first occurs. If `options.backwards` is `true`, the search goes backwards in the session. + * @param session The session to search with + **/ + find(session: EditSession): Range; + + /** + * Searches for all occurances `options.needle`. If found, this method returns an array of [[Range `Range`s]] where the text first occurs. If `options.backwards` is `true`, the search goes backwards in the session. + * @param session The session to search with + **/ + findAll(session: EditSession): Range[]; + + /** + * Searches for `options.needle` in `input`, and, if found, replaces it with `replacement`. + * @param input The text to search in + * @param replacement The replacing text + * + (String): If `options.regExp` is `true`, this function returns `input` with the replacement already made. Otherwise, this function just returns `replacement`.
+ * If `options.needle` was not found, this function returns `null`. + **/ + replace(input: string, replacement: string): string; + } + declare var Search: { + /** + * Creates a new `Search` object. The following search options are avaliable: + * - `needle`: The string or regular expression you're looking for + * - `backwards`: Whether to search backwards from where cursor currently is. Defaults to `false`. + * - `wrap`: Whether to wrap the search back to the beginning when it hits the end. Defaults to `false`. + * - `caseSensitive`: Whether the search ought to be case-sensitive. Defaults to `false`. + * - `wholeWord`: Whether the search matches only on whole words. Defaults to `false`. + * - `range`: The [[Range]] to search within. Set this to `null` for the whole document + * - `regExp`: Whether the search is a regular expression or not. Defaults to `false`. + * - `start`: The starting [[Range]] or cursor position to begin the search + * - `skipCurrent`: Whether or not to include the current line in the search. Default to `false`. + **/ + new(): Search; + } + + //////////////// + /// Search + //////////////// + + /** + * Contains the cursor position and the text selection of an edit session. + * The row/columns used in the selection are in document coordinates representing ths coordinates as thez appear in the document before applying soft wrap and folding. + **/ + interface Selection { + + on(event: string, fn: (e) => any); + + /** + * Returns `true` if the selection is empty. + **/ + isEmpty(): bool; + + /** + * Returns `true` if the selection is a multi-line. + **/ + isMultiLine(): bool; + + /** + * Gets the current position of the cursor. + **/ + getCursor(): number; + + /** + * Sets the row and column position of the anchor. This function also emits the `'changeSelection'` event. + * @param row The new row + * @param column The new column + **/ + setSelectionAnchor(row: number, column: number); + + /** + * Returns an object containing the `row` and `column` of the calling selection anchor. + **/ + getSelectionAnchor(): any; + + /** + * Returns an object containing the `row` and `column` of the calling selection lead. + **/ + getSelectionLead(): any; + + /** + * Shifts the selection up (or down, if [[Selection.isBackwards `isBackwards()`]] is true) the given number of columns. + * @param columns The number of columns to shift by + **/ + shiftSelection(columns: number); + + /** + * Returns `true` if the selection is going backwards in the document. + **/ + isBackwards(): bool; + + /** + * [Returns the [[Range]] for the selected text.]{: #Selection.getRange} + **/ + getRange(): Range; + + /** + * [Empties the selection (by de-selecting it). This function also emits the `'changeSelection'` event.]{: #Selection.clearSelection} + **/ + clearSelection(); + + /** + * Selects all the text in the document. + **/ + selectAll(); + + /** + * Sets the selection to the provided range. + * @param range The range of text to select + * @param reverse Indicates if the range should go backwards (`true`) or not + **/ + setRange(range: Range, reverse: bool); + + /** + * Moves the selection cursor to the indicated row and column. + * @param row The row to select to + * @param column The column to select to + **/ + selectTo(row: number, column: number); + + /** + * Moves the selection cursor to the row and column indicated by `pos`. + * @param pos An object containing the row and column + **/ + selectToPosition(pos: any); + + /** + * Moves the selection up one row. + **/ + selectUp(); + + /** + * Moves the selection down one row. + **/ + selectDown(); + + /** + * Moves the selection right one column. + **/ + selectRight(); + + /** + * Moves the selection left one column. + **/ + selectLeft(); + + /** + * Moves the selection to the beginning of the current line. + **/ + selectLineStart(); + + /** + * Moves the selection to the end of the current line. + **/ + selectLineEnd(); + + /** + * Moves the selection to the end of the file. + **/ + selectFileEnd(); + + /** + * Moves the selection to the start of the file. + **/ + selectFileStart(); + + /** + * Moves the selection to the first word on the right. + **/ + selectWordRight(); + + /** + * Moves the selection to the first word on the left. + **/ + selectWordLeft(); + + /** + * Moves the selection to highlight the entire word. + **/ + getWordRange(); + + /** + * Selects an entire word boundary. + **/ + selectWord(); + + /** + * Selects a word, including its right whitespace. + **/ + selectAWord(); + + /** + * Selects the entire line. + **/ + selectLine(); + + /** + * Moves the cursor up one row. + **/ + moveCursorUp(); + + /** + * Moves the cursor down one row. + **/ + moveCursorDown(); + + /** + * Moves the cursor left one column. + **/ + moveCursorLeft(); + + /** + * Moves the cursor right one column. + **/ + moveCursorRight(); + + /** + * Moves the cursor to the start of the line. + **/ + moveCursorLineStart(); + + /** + * Moves the cursor to the end of the line. + **/ + moveCursorLineEnd(); + + /** + * Moves the cursor to the end of the file. + **/ + moveCursorFileEnd(); + + /** + * Moves the cursor to the start of the file. + **/ + moveCursorFileStart(); + + /** + * Moves the cursor to the word on the right. + **/ + moveCursorLongWordRight(); + + /** + * Moves the cursor to the word on the left. + **/ + moveCursorLongWordLeft(); + + /** + * Moves the cursor to position indicated by the parameters. Negative numbers move the cursor backwards in the document. + * @param rows The number of rows to move by + * @param chars The number of characters to move by + **/ + moveCursorBy(rows: number, chars: number); + + /** + * Moves the selection to the position indicated by its `row` and `column`. + * @param position The position to move to + **/ + moveCursorToPosition(position: any); + + /** + * Moves the cursor to the row and column provided. [If `preventUpdateDesiredColumn` is `true`, then the cursor stays in the same column position as its original point.]{: #preventUpdateBoolDesc} + * @param row The row to move to + * @param column The column to move to + * @param keepDesiredColumn [If `true`, the cursor move does not respect the previous column]{: #preventUpdateBool} + **/ + moveCursorTo(row: number, column: number, keepDesiredColumn: bool); + + /** + * Moves the cursor to the screen position indicated by row and column. {:preventUpdateBoolDesc} + * @param row The row to move to + * @param column The column to move to + * @param keepDesiredColumn {:preventUpdateBool} + **/ + moveCursorToScreen(row: number, column: number, keepDesiredColumn: bool); + } + declare var Selection: { + /** + * Creates a new `Selection` object. + * @param session The session to use + **/ + new(session: EditSession): Selection; + } + + //////////////// + /// Split + //////////////// + + interface Split { + + /** + * Returns the number of splits. + **/ + getSplits(): number; + + /** + * Returns the editor identified by the index `idx`. + * @param idx The index of the editor you want + **/ + getEditor(idx: number); + + /** + * Returns the current editor. + **/ + getCurrentEditor(): Editor; + + /** + * Focuses the current editor. + **/ + focus(); + + /** + * Blurs the current editor. + **/ + blur(); + + /** + * Sets a theme for each of the available editors. + * @param theme The name of the theme to set + **/ + setTheme(theme: string); + + /** + * Sets the keyboard handler for the editor. + * @param keybinding + **/ + setKeyboardHandler(keybinding: string); + + /** + * Executes `callback` on all of the available editors. + * @param callback A callback function to execute + * @param scope The default scope for the callback + **/ + forEach(callback: Function, scope: string); + + /** + * Sets the font size, in pixels, for all the available editors. + * @param size The new font size + **/ + setFontSize(size: number); + + /** + * Sets a new [[EditSession `EditSession`]] for the indicated editor. + * @param session The new edit session + * @param idx The editor's index you're interested in + **/ + setSession(session: EditSession, idx: number); + + /** + * Returns the orientation. + **/ + getOrientation(): number; + + /** + * Sets the orientation. + * @param orientation The new orientation value + **/ + setOrientation(orientation: number); + + /** + * Resizes the editor. + **/ + resize(); + } + declare var Split: { + new(): Split; + } + + ////////////////// + /// TokenIterator + ////////////////// + + /** + * This class provides an essay way to treat the document as a stream of tokens, and provides methods to iterate over these tokens. + **/ + interface TokenIterator { + + /** + * Tokenizes all the items from the current point to the row prior in the document. + **/ + stepBackward(): string[]; + + /** + * Tokenizes all the items from the current point until the next row in the document. If the current point is at the end of the file, this function returns `null`. Otherwise, it returns the tokenized string. + **/ + stepForward(): string; + + /** + * Returns the current tokenized string. + **/ + getCurrentToken(): string; + + /** + * Returns the current row. + **/ + getCurrentTokenRow(): number; + + /** + * Returns the current column. + **/ + getCurrentTokenColumn(): number; + } + declare var TokenIterator: { + /** + * Creates a new token iterator object. The inital token index is set to the provided row and column coordinates. + * @param session The session to associate with + * @param initialRow The row to start the tokenizing at + * @param initialColumn The column to start the tokenizing at + **/ + new(session: EditSession, initialRow: number, initialColumn: number): TokenIterator; + } + + ////////////////// + /// Tokenizer + ////////////////// + + + /** + * This class takes a set of highlighting rules, and creates a tokenizer out of them. For more information, see [the wiki on extending highlighters](https://github.com/ajaxorg/ace/wiki/Creating-or-Extending-an-Edit-Mode#wiki-extendingTheHighlighter). + **/ + interface Tokenizer { + + /** + * Returns an object containing two properties: `tokens`, which contains all the tokens; and `state`, the current state. + **/ + getLineTokens(): any; + } + declare var Tokenizer: { + /** + * Constructs a new tokenizer based on the given rules and flags. + * @param rules The highlighting rules + * @param flag Any additional regular expression flags to pass (like "i" for case insensitive) + **/ + new(rules: any, flag: string): Tokenizer; + } + + ////////////////// + /// UndoManager + ////////////////// + + /** + * This object maintains the undo stack for an [[EditSession `EditSession`]]. + **/ + interface UndoManager { + + /** + * Provides a means for implementing your own undo manager. `options` has one property, `args`, an [[Array `Array`]], with two elements: + * - `args[0]` is an array of deltas + * - `args[1]` is the document to associate with + * @param options Contains additional properties + **/ + execute(options: any); + + /** + * [Perform an undo operation on the document, reverting the last change.]{: #UndoManager.undo} + * @param dontSelect {:dontSelect} + **/ + undo(dontSelect?: bool): Range; + + /** + * [Perform a redo operation on the document, reimplementing the last change.]{: #UndoManager.redo} + * @param dontSelect {:dontSelect} + **/ + redo(dontSelect: bool); + + /** + * Destroys the stack of undo and redo redo operations. + **/ + reset(); + + /** + * Returns `true` if there are undo operations left to perform. + **/ + hasUndo(): bool; + + /** + * Returns `true` if there are redo operations left to perform. + **/ + hasRedo(): bool; + + } + declare var UndoManager: { + /** + * Resets the current undo state and creates a new `UndoManager`. + **/ + new(): UndoManager; + } + + //////////////////// + /// VirtualRenderer + //////////////////// + + /** + * The class that is responsible for drawing everything you see on the screen! + **/ + interface VirtualRenderer { + + /** + * Associates the renderer with an [[EditSession `EditSession`]]. + **/ + setSession(); + + /** + * Triggers a partial update of the text, from the range given by the two parameters. + * @param firstRow The first row to update + * @param lastRow The last row to update + **/ + updateLines(firstRow: number, lastRow: number); + + /** + * Triggers a full update of the text, for all the rows. + **/ + updateText(); + + /** + * Triggers a full update of all the layers, for all the rows. + * @param force If `true`, forces the changes through + **/ + updateFull(force: bool); + + /** + * Updates the font size. + **/ + updateFontSize(); + + /** + * [Triggers a resize of the editor.]{: #VirtualRenderer.onResize} + * @param force If `true`, recomputes the size, even if the height and width haven't changed + * @param gutterWidth The width of the gutter in pixels + * @param width The width of the editor in pixels + * @param height The hiehgt of the editor, in pixels + **/ + onResize(force: bool, gutterWidth: number, width: number, height: number); + + /** + * Adjusts the wrap limit, which is the number of characters that can fit within the width of the edit area on screen. + **/ + adjustWrapLimit(); + + /** + * Identifies whether you want to have an animated scroll or not. + * @param shouldAnimate Set to `true` to show animated scrolls + **/ + setAnimatedScroll(shouldAnimate: bool); + + /** + * Returns whether an animated scroll happens or not. + **/ + getAnimatedScroll(): bool; + + /** + * Identifies whether you want to show invisible characters or not. + * @param showInvisibles Set to `true` to show invisibles + **/ + setShowInvisibles(showInvisibles: bool); + + /** + * Returns whether invisible characters are being shown or not. + **/ + getShowInvisibles(): bool; + + /** + * Identifies whether you want to show the print margin or not. + * @param showPrintMargin Set to `true` to show the print margin + **/ + setShowPrintMargin(showPrintMargin: bool); + + /** + * Returns whether the print margin is being shown or not. + **/ + getShowPrintMargin(): bool; + + /** + * Identifies whether you want to show the print margin column or not. + * @param showPrintMargin Set to `true` to show the print margin column + **/ + setPrintMarginColumn(showPrintMargin: bool); + + /** + * Returns whether the print margin column is being shown or not. + **/ + getPrintMarginColumn(): bool; + + /** + * Returns `true` if the gutter is being shown. + **/ + getShowGutter(): bool; + + /** + * Identifies whether you want to show the gutter or not. + * @param show Set to `true` to show the gutter + **/ + setShowGutter(show: bool); + + /** + * Returns the root element containing this renderer. + **/ + getContainerElement(): HTMLElement; + + /** + * Returns the element that the mouse events are attached to + **/ + getMouseEventTarget(): HTMLElement; + + /** + * Returns the element to which the hidden text area is added. + **/ + getTextAreaContainer(): HTMLElement; + + /** + * [Returns the index of the first visible row.]{: #VirtualRenderer.getFirstVisibleRow} + **/ + getFirstVisibleRow(): number; + + /** + * Returns the index of the first fully visible row. "Fully" here means that the characters in the row are not truncated; that the top and the bottom of the row are on the screen. + **/ + getFirstFullyVisibleRow(): number; + + /** + * Returns the index of the last fully visible row. "Fully" here means that the characters in the row are not truncated; that the top and the bottom of the row are on the screen. + **/ + getLastFullyVisibleRow(): number; + + /** + * [Returns the index of the last visible row.]{: #VirtualRenderer.getLastVisibleRow} + **/ + getLastVisibleRow(): number; + + /** + * Sets the padding for all the layers. + * @param padding A new padding value (in pixels) + **/ + setPadding(padding: number); + + /** + * Returns whether the horizontal scrollbar is set to be always visible. + **/ + getHScrollBarAlwaysVisible(): bool; + + /** + * Identifies whether you want to show the horizontal scrollbar or not. + * @param alwaysVisible Set to `true` to make the horizontal scroll bar visible + **/ + setHScrollBarAlwaysVisible(alwaysVisible: bool); + + /** + * Schedules an update to all the front markers in the document. + **/ + updateFrontMarkers(); + + /** + * Schedules an update to all the back markers in the document. + **/ + updateBackMarkers(); + + /** + * Deprecated; (moved to [[EditSession]]) + **/ + addGutterDecoration(); + + /** + * Deprecated; (moved to [[EditSession]]) + **/ + removeGutterDecoration(); + + /** + * Redraw breakpoints. + **/ + updateBreakpoints(); + + /** + * Sets annotations for the gutter. + * @param annotations An array containing annotations + **/ + setAnnotations(annotations: Array); + + /** + * Updates the cursor icon. + **/ + updateCursor(); + + /** + * Hides the cursor icon. + **/ + hideCursor(); + + /** + * Shows the cursor icon. + **/ + showCursor(); + + /** + * Scrolls the cursor into the first visibile area of the editor + **/ + scrollCursorIntoView(); + + /** + * {:EditSession.getScrollTop} + **/ + getScrollTop(): number; + + /** + * {:EditSession.getScrollLeft} + **/ + getScrollLeft(): number; + + /** + * Returns the first visible row, regardless of whether it's fully visible or not. + **/ + getScrollTopRow(): number; + + /** + * Returns the last visible row, regardless of whether it's fully visible or not. + **/ + getScrollBottomRow(): number; + + /** + * Gracefully scrolls from the top of the editor to the row indicated. + * @param row A row id + **/ + scrollToRow(row: number); + + /** + * Gracefully scrolls the editor to the row indicated. + * @param line A line number + * @param center If `true`, centers the editor the to indicated line + * @param animate If `true` animates scrolling + * @param callback Function to be called after the animation has finished + **/ + scrollToLine(line: number, center: bool, animate: bool, callback: Function); + + /** + * Scrolls the editor to the y pixel indicated. + * @param scrollTop The position to scroll to + **/ + scrollToY(scrollTop: number): number; + + /** + * Scrolls the editor across the x-axis to the pixel indicated. + * @param scrollLeft The position to scroll to + **/ + scrollToX(scrollLeft: number): number; + + /** + * Scrolls the editor across both x- and y-axes. + * @param deltaX The x value to scroll by + * @param deltaY The y value to scroll by + **/ + scrollBy(deltaX: number, deltaY: number); + + /** + * Returns `true` if you can still scroll by either parameter; in other words, you haven't reached the end of the file or line. + * @param deltaX The x value to scroll by + * @param deltaY The y value to scroll by + **/ + isScrollableBy(deltaX: number, deltaY: number): bool; + + /** + * Returns an object containing the `pageX` and `pageY` coordinates of the document position. + * @param row The document row position + * @param column The document column position + **/ + textToScreenCoordinates(row: number, column: number): any; + + /** + * Focuses the current container. + **/ + visualizeFocus(); + + /** + * Blurs the current container. + **/ + visualizeBlur(); + + /** + * undefined + * @param position + **/ + showComposition(position: number); + + /** + * Sets the inner text of the current composition to `text`. + * @param text A string of text to use + **/ + setCompositionText(text: string); + + /** + * Hides the current composition. + **/ + hideComposition(); + + /** + * [Sets a new theme for the editor. `theme` should exist, and be a directory path, like `ace/theme/textmate`.]{: #VirtualRenderer.setTheme} + * @param theme The path to a theme + **/ + setTheme(theme: string); + + /** + * [Returns the path of the current theme.]{: #VirtualRenderer.getTheme} + **/ + getTheme(): string; + + /** + * [Adds a new class, `style`, to the editor.]{: #VirtualRenderer.setStyle} + * @param style A class name + **/ + setStyle(style: string); + + /** + * [Removes the class `style` from the editor.]{: #VirtualRenderer.unsetStyle} + * @param style A class name + **/ + unsetStyle(style: string); + + /** + * Destroys the text and cursor layers for this renderer. + **/ + destroy(); + + } + declare var VirtualRenderer: { + /** + * Constructs a new `VirtualRenderer` within the `container` specified, applying the given `theme`. + * @param container The root element of the editor + * @param theme The starting theme + **/ + new(container: HTMLElement, theme: string): VirtualRenderer; + } +} + +declare var ace: AceAjax.Ace; \ No newline at end of file