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 { getOrder } from "../util/bidi.js"
      import { ie, ie_version, webkit } from "../util/browser.js"
      import { elt, eltP, joinClasses } from "../util/dom.js"
      import { eventMixin, signal } from "../util/event.js"
      import { hasBadBidiRects, zeroWidthElement } from "../util/feature_detection.js"
      import { lst, spaceStr } from "../util/misc.js"
      
      import { getLineStyles } from "./highlight.js"
      import { attachMarkedSpans, compareCollapsedMarkers, detachMarkedSpans, lineIsHidden, visualLineContinued } from "./spans.js"
     import { getLine, lineNo, updateLineHeight } from "./utils_line.js"
     
     // LINE DATA STRUCTURE
     
     // Line objects. These hold state related to a line, including
     // highlighting info (the styles array).
     export class Line {
       constructor(text, markedSpans, estimateHeight) {
         this.text = text
         attachMarkedSpans(this, markedSpans)
         this.height = estimateHeight ? estimateHeight(this) : 1
       }
     
       lineNo() { return lineNo(this) }
     }
     eventMixin(Line)
     
     // Change the content (text, markers) of a line. Automatically
     // invalidates cached information and tries to re-estimate the
     // line's height.
     export function updateLine(line, text, markedSpans, estimateHeight) {
       line.text = text
       if (line.stateAfter) line.stateAfter = null
       if (line.styles) line.styles = null
       if (line.order != null) line.order = null
       detachMarkedSpans(line)
       attachMarkedSpans(line, markedSpans)
       let estHeight = estimateHeight ? estimateHeight(line) : 1
       if (estHeight != line.height) updateLineHeight(line, estHeight)
     }
     
     // Detach a line from the document tree and its markers.
     export function cleanUpLine(line) {
       line.parent = null
       detachMarkedSpans(line)
     }
     
     // Convert a style as returned by a mode (either null, or a string
     // containing one or more styles) to a CSS style. This is cached,
     // and also looks for line-wide styles.
     let styleToClassCache = {}, styleToClassCacheWithMode = {}
     function interpretTokenStyle(style, options) {
       if (!style || /^\s*$/.test(style)) return null
       let cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache
       return cache[style] ||
         (cache[style] = style.replace(/\S+/g, "cm-$&"))
     }
     
     // Render the DOM representation of the text of a line. Also builds
     // up a 'line map', which points at the DOM nodes that represent
     // specific stretches of text, and is used by the measuring code.
     // The returned object contains the DOM node, this map, and
     // information about line-wide styles that were set by the mode.
     export function buildLineContent(cm, lineView) {
       // The padding-right forces the element to have a 'border', which
       // is needed on Webkit to be able to get line-level bounding
       // rectangles for it (in measureChar).
       let content = eltP("span", null, null, webkit ? "padding-right: .1px" : null)
       let builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content,
                      col: 0, pos: 0, cm: cm,
                      trailingSpace: false,
                      splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}
       lineView.measure = {}
     
       // Iterate over the logical lines that make up this visual line.
       for (let i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
         let line = i ? lineView.rest[i - 1] : lineView.line, order
         builder.pos = 0
         builder.addToken = buildToken
         // Optionally wire in some hacks into the token-rendering
         // algorithm, to deal with browser quirks.
         if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction)))
           builder.addToken = buildTokenBadBidi(builder.addToken, order)
         builder.map = []
         let allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)
         insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))
         if (line.styleClasses) {
           if (line.styleClasses.bgClass)
             builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "")
           if (line.styleClasses.textClass)
             builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "")
         }
     
         // Ensure at least a single node is present, for measuring.
         if (builder.map.length == 0)
           builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure)))
     
         // Store the map and a cache object for the current logical line
         if (i == 0) {
           lineView.measure.map = builder.map
          lineView.measure.cache = {}
        } else {
          ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
          ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})
        }
      }
    
      // See issue #2901
      if (webkit) {
        let last = builder.content.lastChild
        if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
          builder.content.className = "cm-tab-wrap-hack"
      }
    
      signal(cm, "renderLine", cm, lineView.line, builder.pre)
      if (builder.pre.className)
        builder.textClass = joinClasses(builder.pre.className, builder.textClass || "")
    
      return builder
    }
    
    export function defaultSpecialCharPlaceholder(ch) {
      let token = elt("span", "\u2022", "cm-invalidchar")
      token.title = "\\u" + ch.charCodeAt(0).toString(16)
      token.setAttribute("aria-label", token.title)
      return token
    }
    
    // Build up the DOM representation for a single token, and add it to
    // the line map. Takes care to render special characters separately.
    function buildToken(builder, text, style, startStyle, endStyle, title, css) {
      if (!text) return
      let displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text
      let special = builder.cm.state.specialChars, mustWrap = false
      let content
      if (!special.test(text)) {
        builder.col += text.length
        content = document.createTextNode(displayText)
        builder.map.push(builder.pos, builder.pos + text.length, content)
        if (ie && ie_version < 9) mustWrap = true
        builder.pos += text.length
      } else {
        content = document.createDocumentFragment()
        let pos = 0
        while (true) {
          special.lastIndex = pos
          let m = special.exec(text)
          let skipped = m ? m.index - pos : text.length - pos
          if (skipped) {
            let txt = document.createTextNode(displayText.slice(pos, pos + skipped))
            if (ie && ie_version < 9) content.appendChild(elt("span", [txt]))
            else content.appendChild(txt)
            builder.map.push(builder.pos, builder.pos + skipped, txt)
            builder.col += skipped
            builder.pos += skipped
          }
          if (!m) break
          pos += skipped + 1
          let txt
          if (m[0] == "\t") {
            let tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize
            txt = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"))
            txt.setAttribute("role", "presentation")
            txt.setAttribute("cm-text", "\t")
            builder.col += tabWidth
          } else if (m[0] == "\r" || m[0] == "\n") {
            txt = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"))
            txt.setAttribute("cm-text", m[0])
            builder.col += 1
          } else {
            txt = builder.cm.options.specialCharPlaceholder(m[0])
            txt.setAttribute("cm-text", m[0])
            if (ie && ie_version < 9) content.appendChild(elt("span", [txt]))
            else content.appendChild(txt)
            builder.col += 1
          }
          builder.map.push(builder.pos, builder.pos + 1, txt)
          builder.pos++
        }
      }
      builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32
      if (style || startStyle || endStyle || mustWrap || css) {
        let fullStyle = style || ""
        if (startStyle) fullStyle += startStyle
        if (endStyle) fullStyle += endStyle
        let token = elt("span", [content], fullStyle, css)
        if (title) token.title = title
        return builder.content.appendChild(token)
      }
      builder.content.appendChild(content)
    }
    
    function splitSpaces(text, trailingBefore) {
      if (text.length > 1 && !/  /.test(text)) return text
      let spaceBefore = trailingBefore, result = ""
      for (let i = 0; i < text.length; i++) {
        let ch = text.charAt(i)
        if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
          ch = "\u00a0"
        result += ch
        spaceBefore = ch == " "
      }
      return result
    }
    
    // Work around nonsense dimensions being reported for stretches of
    // right-to-left text.
    function buildTokenBadBidi(inner, order) {
      return (builder, text, style, startStyle, endStyle, title, css) => {
        style = style ? style + " cm-force-border" : "cm-force-border"
        let start = builder.pos, end = start + text.length
        for (;;) {
          // Find the part that overlaps with the start of this text
          let part
          for (let i = 0; i < order.length; i++) {
            part = order[i]
            if (part.to > start && part.from <= start) break
          }
          if (part.to >= end) return inner(builder, text, style, startStyle, endStyle, title, css)
          inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)
          startStyle = null
          text = text.slice(part.to - start)
          start = part.to
        }
      }
    }
    
    function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
      let widget = !ignoreWidget && marker.widgetNode
      if (widget) builder.map.push(builder.pos, builder.pos + size, widget)
      if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
        if (!widget)
          widget = builder.content.appendChild(document.createElement("span"))
        widget.setAttribute("cm-marker", marker.id)
      }
      if (widget) {
        builder.cm.display.input.setUneditable(widget)
        builder.content.appendChild(widget)
      }
      builder.pos += size
      builder.trailingSpace = false
    }
    
    // Outputs a number of spans to make up a line, taking highlighting
    // and marked text into account.
    function insertLineContent(line, builder, styles) {
      let spans = line.markedSpans, allText = line.text, at = 0
      if (!spans) {
        for (let i = 1; i < styles.length; i+=2)
          builder.addToken(builder, allText.slice(at, at = styles[i]), interpretTokenStyle(styles[i+1], builder.cm.options))
        return
      }
    
      let len = allText.length, pos = 0, i = 1, text = "", style, css
      let nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed
      for (;;) {
        if (nextChange == pos) { // Update current marker set
          spanStyle = spanEndStyle = spanStartStyle = title = css = ""
          collapsed = null; nextChange = Infinity
          let foundBookmarks = [], endStyles
          for (let j = 0; j < spans.length; ++j) {
            let sp = spans[j], m = sp.marker
            if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
              foundBookmarks.push(m)
            } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
              if (sp.to != null && sp.to != pos && nextChange > sp.to) {
                nextChange = sp.to
                spanEndStyle = ""
              }
              if (m.className) spanStyle += " " + m.className
              if (m.css) css = (css ? css + ";" : "") + m.css
              if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle
              if (m.endStyle && sp.to == nextChange) (endStyles || (endStyles = [])).push(m.endStyle, sp.to)
              if (m.title && !title) title = m.title
              if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
                collapsed = sp
            } else if (sp.from > pos && nextChange > sp.from) {
              nextChange = sp.from
            }
          }
          if (endStyles) for (let j = 0; j < endStyles.length; j += 2)
            if (endStyles[j + 1] == nextChange) spanEndStyle += " " + endStyles[j]
    
          if (!collapsed || collapsed.from == pos) for (let j = 0; j < foundBookmarks.length; ++j)
            buildCollapsedSpan(builder, 0, foundBookmarks[j])
          if (collapsed && (collapsed.from || 0) == pos) {
            buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
                               collapsed.marker, collapsed.from == null)
            if (collapsed.to == null) return
            if (collapsed.to == pos) collapsed = false
          }
        }
        if (pos >= len) break
    
        let upto = Math.min(len, nextChange)
        while (true) {
          if (text) {
            let end = pos + text.length
            if (!collapsed) {
              let tokenText = end > upto ? text.slice(0, upto - pos) : text
              builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
                               spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css)
            }
            if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}
            pos = end
            spanStartStyle = ""
          }
          text = allText.slice(at, at = styles[i++])
          style = interpretTokenStyle(styles[i++], builder.cm.options)
        }
      }
    }
    
    
    // These objects are used to represent the visible (currently drawn)
    // part of the document. A LineView may correspond to multiple
    // logical lines, if those are connected by collapsed ranges.
    export function LineView(doc, line, lineN) {
      // The starting line
      this.line = line
      // Continuing lines, if any
      this.rest = visualLineContinued(line)
      // Number of logical lines in this visual line
      this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1
      this.node = this.text = null
      this.hidden = lineIsHidden(doc, line)
    }
    
    // Create a range of LineView objects for the given lines.
    export function buildViewArray(cm, from, to) {
      let array = [], nextPos
      for (let pos = from; pos < to; pos = nextPos) {
        let view = new LineView(cm.doc, getLine(cm.doc, pos), pos)
        nextPos = pos + view.size
        array.push(view)
      }
      return array
    }


Download modules/editor/codemirror/src/line/line_data.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'.