TypeScript codemirror.on函数代码示例

 function showTooltipFor(e, content, node, state, cm) {
   var tooltip = showTooltip(e, content);
   function hide() {
     CodeMirror.off(node, "mouseout", hide);
     CodeMirror.off(node, "click", hide);
     node.className = node.className.replace(HOVER_CLASS, "");
     if (tooltip) {
       hideTooltip(tooltip);
       tooltip = null;
     }
     cm.removeKeyMap(state.keyMap);
   }
   var poll = setInterval(function() {
     if (tooltip)
       for ( var n = node;; n = n.parentNode) {
         if (n == document.body)
           return;
         if (!n) {
           hide();
           break;
         }
       }
     if (!tooltip)
       return clearInterval(poll);
   }, 400);
   CodeMirror.on(node, "mouseout", hide);
   CodeMirror.on(node, "click", hide);
   state.keyMap = {Esc: hide};
   cm.addKeyMap(state.keyMap);
   //BAS
   hidePreviousToolTip = hide;
 }

 /**
  * Construct a new editor widget.
  */
 constructor(model: IDocumentModel, context: IDocumentContext) {
   super();
   this.addClass(EDITOR_CLASS);
   let editor = this.editor;
   editor.setOption('lineNumbers', true);
   let doc = editor.getDoc();
   doc.setValue(model.toString());
   this.title.text = context.path.split('/').pop();
   loadModeByFileName(editor, context.path);
   model.stateChanged.connect((m, args) => {
     if (args.name === 'dirty') {
       if (args.newValue) {
         this.title.className += ` ${DIRTY_CLASS}`;
       } else {
         this.title.className = this.title.className.replace(DIRTY_CLASS, '');
       }
     }
   });
   context.pathChanged.connect((c, path) => {
     loadModeByFileName(editor, path);
     this.title.text = path.split('/').pop();
   });
   model.contentChanged.connect(() => {
     let old = doc.getValue();
     let text = model.toString();
     if (old !== text) {
       doc.setValue(text);
     }
   });
   CodeMirror.on(doc, 'change', (instance, change) => {
     if (change.origin !== 'setValue') {
       model.fromString(instance.getValue());
     }
   });
 }

 /**
  * Create the widget from a path.
  */
 protected createWidget(path: string): CodeMirrorWidget {
   let widget = new CodeMirrorWidget();
   widget.addClass(EDITOR_CLASS);
   CodeMirror.on(widget.editor.getDoc(), 'change', () => {
     this.setDirty(path, true);
   });
   return widget;
 }

 /**
  * Create the widget from an `IContentsModel`.
  */
 protected createWidget(model: IContentsModel): CodeMirrorWidget {
   let widget = new CodeMirrorWidget();
   widget.addClass(EDITOR_CLASS);
   CodeMirror.on(widget.editor.getDoc(), 'change', () => {
     this.setDirty(model.path);
   });
   return widget;
 }

  function optionHandler(cm, val, old) {
    if (old && old != CodeMirror.Init) {
      CodeMirror.off(cm.getWrapperElement(), "mouseover",
          cm.state.textHover.onMouseOver);
      delete cm.state.textHover;
    }

    if (val) {
      var state = cm.state.textHover = new TextHoverState(cm, parseOptions(cm,
          val));
      CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
    }
  }

 /**
  * Construct a new editor widget.
  */
 constructor(context: DocumentRegistry.Context) {
   super({
     extraKeys: {
       'Tab': 'indentMore',
       'Shift-Enter': () => { /* no-op */ }
     },
     indentUnit: 4,
     theme: DEFAULT_CODEMIRROR_THEME,
     lineNumbers: true,
     lineWrapping: true,
   });
   this.addClass(EDITOR_CLASS);
   this._context = context;
   let editor = this.editor;
   let model = context.model;
   let doc = editor.getDoc();
   // Prevent the initial loading from disk from being in the editor history.
   context.ready.then( () => {
     doc.setValue(model.toString());
     doc.clearHistory();
   });
   this.title.label = context.path.split('/').pop();
   loadModeByFileName(editor, context.path);
   model.stateChanged.connect((m, args) => {
     if (args.name === 'dirty') {
       if (args.newValue) {
         this.title.className += ` ${DIRTY_CLASS}`;
       } else {
         this.title.className = this.title.className.replace(DIRTY_CLASS, '');
       }
     }
   });
   context.pathChanged.connect((c, path) => {
     loadModeByFileName(editor, path);
     this.title.label = path.split('/').pop();
   });
   model.contentChanged.connect(() => {
     let old = doc.getValue();
     let text = model.toString();
     if (old !== text) {
       doc.setValue(text);
     }
   });
   CodeMirror.on(doc, 'change', (instance, change) => {
     if (change.origin !== 'setValue') {
       model.fromString(instance.getValue());
     }
   });
 }

 /**
  * Construct a new editor widget.
  */
 constructor(context: IDocumentContext<IDocumentModel>) {
   super();
   this.layout = new PanelLayout();
   this.addClass(EDITOR_CLASS);
   var codeMirror = new CodeMirrorWidget();
   var layout = this.layout as PanelLayout;
   let editor = codeMirror.editor;
   let model = context.model;
   this.createMenu(layout);
   layout.addChild(codeMirror);
   editor.setOption('lineNumbers', true);
   editor.setOption('theme', "material");
   let doc = editor.getDoc();
   doc.setValue(model.toString());
   this.title.text = context.path.split('/').pop();
   loadModeByFileName(editor, context.path);
   model.stateChanged.connect((m, args) => {
     if (args.name === 'dirty') {
       if (args.newValue) {
         this.title.className += ` ${DIRTY_CLASS}`;
       } else {
         this.title.className = this.title.className.replace(DIRTY_CLASS, '');
       }
     }
   });
   context.pathChanged.connect((c, path) => {
     loadModeByFileName(editor, path);
     this.title.text = path.split('/').pop();
   });
   model.contentChanged.connect(() => {
     let old = doc.getValue();
     let text = model.toString();
     if (old !== text) {
       doc.setValue(text);
     }
   });
   CodeMirror.on(doc, 'change', (instance, change) => {
     if (change.origin !== 'setValue') {
       model.fromString(instance.getValue());
     }
   });
 }

  function showTooltip(e, content) {
    var tt = document.createElement("div");
    tt.className = "CodeMirror-hover-tooltip";
    if (typeof content == "string") {
      content = document.createTextNode(content);
    }
    tt.appendChild(content);
    document.body.appendChild(tt);

    function position(e) {
      if (!tt.parentNode)
        return CodeMirror.off(document, "mousemove", position);
      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
      tt.style.left = (e.clientX + 5) + "px";
    }
    CodeMirror.on(document, "mousemove", position);
    position(e);
    if (tt.style.opacity != null)
      tt.style.opacity = "1";
    return tt;
  }

function collapseSingle(cm: CodeMirror.Editor, from: number, to: number): {mark: CodeMirror.TextMarker, clear: () => void} {
  cm.addLineClass(from, 'wrap', 'CodeMirror-merge-collapsed-line');
  var widget = document.createElement('span');
  widget.className = 'CodeMirror-merge-collapsed-widget';
  widget.title = 'Identical text collapsed. Click to expand.';
  var mark = cm.getDoc().markText(
    Pos(from, 0), Pos(to - 1),
    {
      inclusiveLeft: true,
      inclusiveRight: true,
      replacedWith: widget,
      clearOnEnter: true
    }
  );
  function clear() {
    mark.clear();
    cm.removeLineClass(from, 'wrap', 'CodeMirror-merge-collapsed-line');
  }
  CodeMirror.on(widget, 'click', clear);
  return {mark: mark, clear: clear};
}

  buildGap(): HTMLElement {
    var lock = this.lockButton = elt('div', null, 'CodeMirror-merge-scrolllock');
    lock.title = 'Toggle locked scrolling';
    var lockWrap = elt('div', [lock], 'CodeMirror-merge-scrolllock-wrap');
    var self: DiffView = this;
    CodeMirror.on(lock, 'click', function() { self.setScrollLock(!self.lockScroll); });
    var gapElts = [lockWrap];
    /*if (this.mv.options.revertButtons !== false) {
        this.copyButtons = elt('div', null, 'CodeMirror-merge-copybuttons-' + this.type);
        CodeMirror.on(this.copyButtons, 'click', function(e) {
            var node = e.target || e.srcElement;
            if (!node.chunk) return;
            if (node.className == 'CodeMirror-merge-copy-reverse') {
                copyChunk(this, this.orig, this.edit, node.chunk);
                return;
            }
            copyChunk(this, this.edit, this.orig, node.chunk);
        });
        gapElts.unshift(this.copyButtons);
    }*/

    return this.gap = elt('div', gapElts, 'CodeMirror-merge-gap');
  }