Last commit: Tue May 22 22:39:53 2018 +0200	Jan Dankert	Fix für PHP 7.2: 'Object' darf nun nicht mehr als Klassennamen verwendet werden. AUCH NICHT IN EINEM NAMESPACE! WTF, wozu habe ich das in einen verfickten Namespace gepackt? Wozu soll der sonst da sein??? Amateure. Daher nun notgedrungen unbenannt in 'BaseObject'.


      import CodeMirror from "../edit/CodeMirror.js"
      import { docMethodOp } from "../display/operations.js"
      import { Line } from "../line/line_data.js"
      import { clipPos, clipPosArray, Pos } from "../line/pos.js"
      import { visualLine } from "../line/spans.js"
      import { getBetween, getLine, getLines, isLine, lineNo } from "../line/utils_line.js"
      import { classTest } from "../util/dom.js"
      import { splitLinesAuto } from "../util/feature_detection.js"
      import { createObj, map, isEmpty, sel_dontScroll } from "../util/misc.js"
     import { ensureCursorVisible, scrollToCoords } from "../display/scrolling.js"
     
     import { changeLine, makeChange, makeChangeFromHistory, replaceRange } from "./changes.js"
     import { computeReplacedSel } from "./change_measurement.js"
     import { BranchChunk, LeafChunk } from "./chunk.js"
     import { directionChanged, linkedDocs, updateDoc } from "./document_data.js"
     import { copyHistoryArray, History } from "./history.js"
     import { addLineWidget } from "./line_widget.js"
     import { copySharedMarkers, detachSharedMarkers, findSharedMarkers, markText } from "./mark_text.js"
     import { normalizeSelection, Range, simpleSelection } from "./selection.js"
     import { extendSelection, extendSelections, setSelection, setSelectionReplaceHistory, setSimpleSelection } from "./selection_updates.js"
     
     let nextDocId = 0
     let Doc = function(text, mode, firstLine, lineSep, direction) {
       if (!(this instanceof Doc)) return new Doc(text, mode, firstLine, lineSep, direction)
       if (firstLine == null) firstLine = 0
     
       BranchChunk.call(this, [new LeafChunk([new Line("", null)])])
       this.first = firstLine
       this.scrollTop = this.scrollLeft = 0
       this.cantEdit = false
       this.cleanGeneration = 1
       this.modeFrontier = this.highlightFrontier = firstLine
       let start = Pos(firstLine, 0)
       this.sel = simpleSelection(start)
       this.history = new History(null)
       this.id = ++nextDocId
       this.modeOption = mode
       this.lineSep = lineSep
       this.direction = (direction == "rtl") ? "rtl" : "ltr"
       this.extend = false
     
       if (typeof text == "string") text = this.splitLines(text)
       updateDoc(this, {from: start, to: start, text: text})
       setSelection(this, simpleSelection(start), sel_dontScroll)
     }
     
     Doc.prototype = createObj(BranchChunk.prototype, {
       constructor: Doc,
       // Iterate over the document. Supports two forms -- with only one
       // argument, it calls that for each line in the document. With
       // three, it iterates over the range given by the first two (with
       // the second being non-inclusive).
       iter: function(from, to, op) {
         if (op) this.iterN(from - this.first, to - from, op)
         else this.iterN(this.first, this.first + this.size, from)
       },
     
       // Non-public interface for adding and removing lines.
       insert: function(at, lines) {
         let height = 0
         for (let i = 0; i < lines.length; ++i) height += lines[i].height
         this.insertInner(at - this.first, lines, height)
       },
       remove: function(at, n) { this.removeInner(at - this.first, n) },
     
       // From here, the methods are part of the public interface. Most
       // are also available from CodeMirror (editor) instances.
     
       getValue: function(lineSep) {
         let lines = getLines(this, this.first, this.first + this.size)
         if (lineSep === false) return lines
         return lines.join(lineSep || this.lineSeparator())
       },
       setValue: docMethodOp(function(code) {
         let top = Pos(this.first, 0), last = this.first + this.size - 1
         makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
                           text: this.splitLines(code), origin: "setValue", full: true}, true)
         if (this.cm) scrollToCoords(this.cm, 0, 0)
         setSelection(this, simpleSelection(top), sel_dontScroll)
       }),
       replaceRange: function(code, from, to, origin) {
         from = clipPos(this, from)
         to = to ? clipPos(this, to) : from
         replaceRange(this, code, from, to, origin)
       },
       getRange: function(from, to, lineSep) {
         let lines = getBetween(this, clipPos(this, from), clipPos(this, to))
         if (lineSep === false) return lines
         return lines.join(lineSep || this.lineSeparator())
       },
     
       getLine: function(line) {let l = this.getLineHandle(line); return l && l.text},
     
       getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line)},
       getLineNumber: function(line) {return lineNo(line)},
     
       getLineHandleVisualStart: function(line) {
         if (typeof line == "number") line = getLine(this, line)
         return visualLine(line)
      },
    
      lineCount: function() {return this.size},
      firstLine: function() {return this.first},
      lastLine: function() {return this.first + this.size - 1},
    
      clipPos: function(pos) {return clipPos(this, pos)},
    
      getCursor: function(start) {
        let range = this.sel.primary(), pos
        if (start == null || start == "head") pos = range.head
        else if (start == "anchor") pos = range.anchor
        else if (start == "end" || start == "to" || start === false) pos = range.to()
        else pos = range.from()
        return pos
      },
      listSelections: function() { return this.sel.ranges },
      somethingSelected: function() {return this.sel.somethingSelected()},
    
      setCursor: docMethodOp(function(line, ch, options) {
        setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options)
      }),
      setSelection: docMethodOp(function(anchor, head, options) {
        setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)
      }),
      extendSelection: docMethodOp(function(head, other, options) {
        extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)
      }),
      extendSelections: docMethodOp(function(heads, options) {
        extendSelections(this, clipPosArray(this, heads), options)
      }),
      extendSelectionsBy: docMethodOp(function(f, options) {
        let heads = map(this.sel.ranges, f)
        extendSelections(this, clipPosArray(this, heads), options)
      }),
      setSelections: docMethodOp(function(ranges, primary, options) {
        if (!ranges.length) return
        let out = []
        for (let i = 0; i < ranges.length; i++)
          out[i] = new Range(clipPos(this, ranges[i].anchor),
                             clipPos(this, ranges[i].head))
        if (primary == null) primary = Math.min(ranges.length - 1, this.sel.primIndex)
        setSelection(this, normalizeSelection(out, primary), options)
      }),
      addSelection: docMethodOp(function(anchor, head, options) {
        let ranges = this.sel.ranges.slice(0)
        ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))
        setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)
      }),
    
      getSelection: function(lineSep) {
        let ranges = this.sel.ranges, lines
        for (let i = 0; i < ranges.length; i++) {
          let sel = getBetween(this, ranges[i].from(), ranges[i].to())
          lines = lines ? lines.concat(sel) : sel
        }
        if (lineSep === false) return lines
        else return lines.join(lineSep || this.lineSeparator())
      },
      getSelections: function(lineSep) {
        let parts = [], ranges = this.sel.ranges
        for (let i = 0; i < ranges.length; i++) {
          let sel = getBetween(this, ranges[i].from(), ranges[i].to())
          if (lineSep !== false) sel = sel.join(lineSep || this.lineSeparator())
          parts[i] = sel
        }
        return parts
      },
      replaceSelection: function(code, collapse, origin) {
        let dup = []
        for (let i = 0; i < this.sel.ranges.length; i++)
          dup[i] = code
        this.replaceSelections(dup, collapse, origin || "+input")
      },
      replaceSelections: docMethodOp(function(code, collapse, origin) {
        let changes = [], sel = this.sel
        for (let i = 0; i < sel.ranges.length; i++) {
          let range = sel.ranges[i]
          changes[i] = {from: range.from(), to: range.to(), text: this.splitLines(code[i]), origin: origin}
        }
        let newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse)
        for (let i = changes.length - 1; i >= 0; i--)
          makeChange(this, changes[i])
        if (newSel) setSelectionReplaceHistory(this, newSel)
        else if (this.cm) ensureCursorVisible(this.cm)
      }),
      undo: docMethodOp(function() {makeChangeFromHistory(this, "undo")}),
      redo: docMethodOp(function() {makeChangeFromHistory(this, "redo")}),
      undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true)}),
      redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true)}),
    
      setExtending: function(val) {this.extend = val},
      getExtending: function() {return this.extend},
    
      historySize: function() {
        let hist = this.history, done = 0, undone = 0
        for (let i = 0; i < hist.done.length; i++) if (!hist.done[i].ranges) ++done
        for (let i = 0; i < hist.undone.length; i++) if (!hist.undone[i].ranges) ++undone
        return {undo: done, redo: undone}
      },
      clearHistory: function() {this.history = new History(this.history.maxGeneration)},
    
      markClean: function() {
        this.cleanGeneration = this.changeGeneration(true)
      },
      changeGeneration: function(forceSplit) {
        if (forceSplit)
          this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null
        return this.history.generation
      },
      isClean: function (gen) {
        return this.history.generation == (gen || this.cleanGeneration)
      },
    
      getHistory: function() {
        return {done: copyHistoryArray(this.history.done),
                undone: copyHistoryArray(this.history.undone)}
      },
      setHistory: function(histData) {
        let hist = this.history = new History(this.history.maxGeneration)
        hist.done = copyHistoryArray(histData.done.slice(0), null, true)
        hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)
      },
    
      setGutterMarker: docMethodOp(function(line, gutterID, value) {
        return changeLine(this, line, "gutter", line => {
          let markers = line.gutterMarkers || (line.gutterMarkers = {})
          markers[gutterID] = value
          if (!value && isEmpty(markers)) line.gutterMarkers = null
          return true
        })
      }),
    
      clearGutter: docMethodOp(function(gutterID) {
        this.iter(line => {
          if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
            changeLine(this, line, "gutter", () => {
              line.gutterMarkers[gutterID] = null
              if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null
              return true
            })
          }
        })
      }),
    
      lineInfo: function(line) {
        let n
        if (typeof line == "number") {
          if (!isLine(this, line)) return null
          n = line
          line = getLine(this, line)
          if (!line) return null
        } else {
          n = lineNo(line)
          if (n == null) return null
        }
        return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
                textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
                widgets: line.widgets}
      },
    
      addLineClass: docMethodOp(function(handle, where, cls) {
        return changeLine(this, handle, where == "gutter" ? "gutter" : "class", line => {
          let prop = where == "text" ? "textClass"
                   : where == "background" ? "bgClass"
                   : where == "gutter" ? "gutterClass" : "wrapClass"
          if (!line[prop]) line[prop] = cls
          else if (classTest(cls).test(line[prop])) return false
          else line[prop] += " " + cls
          return true
        })
      }),
      removeLineClass: docMethodOp(function(handle, where, cls) {
        return changeLine(this, handle, where == "gutter" ? "gutter" : "class", line => {
          let prop = where == "text" ? "textClass"
                   : where == "background" ? "bgClass"
                   : where == "gutter" ? "gutterClass" : "wrapClass"
          let cur = line[prop]
          if (!cur) return false
          else if (cls == null) line[prop] = null
          else {
            let found = cur.match(classTest(cls))
            if (!found) return false
            let end = found.index + found[0].length
            line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null
          }
          return true
        })
      }),
    
      addLineWidget: docMethodOp(function(handle, node, options) {
        return addLineWidget(this, handle, node, options)
      }),
      removeLineWidget: function(widget) { widget.clear() },
    
      markText: function(from, to, options) {
        return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range")
      },
      setBookmark: function(pos, options) {
        let realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
                        insertLeft: options && options.insertLeft,
                        clearWhenEmpty: false, shared: options && options.shared,
                        handleMouseEvents: options && options.handleMouseEvents}
        pos = clipPos(this, pos)
        return markText(this, pos, pos, realOpts, "bookmark")
      },
      findMarksAt: function(pos) {
        pos = clipPos(this, pos)
        let markers = [], spans = getLine(this, pos.line).markedSpans
        if (spans) for (let i = 0; i < spans.length; ++i) {
          let span = spans[i]
          if ((span.from == null || span.from <= pos.ch) &&
              (span.to == null || span.to >= pos.ch))
            markers.push(span.marker.parent || span.marker)
        }
        return markers
      },
      findMarks: function(from, to, filter) {
        from = clipPos(this, from); to = clipPos(this, to)
        let found = [], lineNo = from.line
        this.iter(from.line, to.line + 1, line => {
          let spans = line.markedSpans
          if (spans) for (let i = 0; i < spans.length; i++) {
            let span = spans[i]
            if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||
                  span.from == null && lineNo != from.line ||
                  span.from != null && lineNo == to.line && span.from >= to.ch) &&
                (!filter || filter(span.marker)))
              found.push(span.marker.parent || span.marker)
          }
          ++lineNo
        })
        return found
      },
      getAllMarks: function() {
        let markers = []
        this.iter(line => {
          let sps = line.markedSpans
          if (sps) for (let i = 0; i < sps.length; ++i)
            if (sps[i].from != null) markers.push(sps[i].marker)
        })
        return markers
      },
    
      posFromIndex: function(off) {
        let ch, lineNo = this.first, sepSize = this.lineSeparator().length
        this.iter(line => {
          let sz = line.text.length + sepSize
          if (sz > off) { ch = off; return true }
          off -= sz
          ++lineNo
        })
        return clipPos(this, Pos(lineNo, ch))
      },
      indexFromPos: function (coords) {
        coords = clipPos(this, coords)
        let index = coords.ch
        if (coords.line < this.first || coords.ch < 0) return 0
        let sepSize = this.lineSeparator().length
        this.iter(this.first, coords.line, line => { // iter aborts when callback returns a truthy value
          index += line.text.length + sepSize
        })
        return index
      },
    
      copy: function(copyHistory) {
        let doc = new Doc(getLines(this, this.first, this.first + this.size),
                          this.modeOption, this.first, this.lineSep, this.direction)
        doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft
        doc.sel = this.sel
        doc.extend = false
        if (copyHistory) {
          doc.history.undoDepth = this.history.undoDepth
          doc.setHistory(this.getHistory())
        }
        return doc
      },
    
      linkedDoc: function(options) {
        if (!options) options = {}
        let from = this.first, to = this.first + this.size
        if (options.from != null && options.from > from) from = options.from
        if (options.to != null && options.to < to) to = options.to
        let copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction)
        if (options.sharedHist) copy.history = this.history
        ;(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})
        copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]
        copySharedMarkers(copy, findSharedMarkers(this))
        return copy
      },
      unlinkDoc: function(other) {
        if (other instanceof CodeMirror) other = other.doc
        if (this.linked) for (let i = 0; i < this.linked.length; ++i) {
          let link = this.linked[i]
          if (link.doc != other) continue
          this.linked.splice(i, 1)
          other.unlinkDoc(this)
          detachSharedMarkers(findSharedMarkers(this))
          break
        }
        // If the histories were shared, split them again
        if (other.history == this.history) {
          let splitIds = [other.id]
          linkedDocs(other, doc => splitIds.push(doc.id), true)
          other.history = new History(null)
          other.history.done = copyHistoryArray(this.history.done, splitIds)
          other.history.undone = copyHistoryArray(this.history.undone, splitIds)
        }
      },
      iterLinkedDocs: function(f) {linkedDocs(this, f)},
    
      getMode: function() {return this.mode},
      getEditor: function() {return this.cm},
    
      splitLines: function(str) {
        if (this.lineSep) return str.split(this.lineSep)
        return splitLinesAuto(str)
      },
      lineSeparator: function() { return this.lineSep || "\n" },
    
      setDirection: docMethodOp(function (dir) {
        if (dir != "rtl") dir = "ltr"
        if (dir == this.direction) return
        this.direction = dir
        this.iter(line => line.order = null)
        if (this.cm) directionChanged(this.cm)
      })
    })
    
    // Public alias.
    Doc.prototype.eachLine = Doc.prototype.iter
    
    export default Doc


Download modules/editor/codemirror/src/model/Doc.min.js

History
Tue, 22 May 2018 22:39:53 +0200	Jan Dankert	Fix für PHP 7.2: 'Object' darf nun nicht mehr als Klassennamen verwendet werden. AUCH NICHT IN EINEM NAMESPACE! WTF, wozu habe ich das in einen verfickten Namespace gepackt? Wozu soll der sonst da sein??? Amateure. Daher nun notgedrungen unbenannt in 'BaseObject'.