TypeScript Delay.setEditorTimeout函数代码示例

const startTimedUpload = function (editor, imageUploadTimerState) {
  const imageUploadTimer = Delay.setEditorTimeout(editor, function () {
    editor.editorUpload.uploadImagesAuto();
  }, editor.settings.images_upload_timeout || 30000);

  imageUploadTimerState.set(imageUploadTimer);
};

 editor.on('keypress', function (e) {
   if (KeyHandler.checkCharCode(charCodes, e)) {
     Delay.setEditorTimeout(editor, function () {
       KeyHandler.handleInlineKey(editor, patternsState.get());
     });
   }
 });

  suite.asyncTest('setEditorTimeout', function (_, done) {
    const fakeEditor = {};

    Delay.setEditorTimeout(fakeEditor, function () {
      ok(true, 'setEditorTimeout was executed.');
      done();
    });
  });

const delayedConfirm = function (editor, message, callback) {
  const rng = editor.selection.getRng();

  Delay.setEditorTimeout(editor, function () {
    editor.windowManager.confirm(message, function (state) {
      editor.selection.setRng(rng);
      callback(state);
    });
  });
};

    editor.on('paste', function (e) {
      // Getting content from the Clipboard can take some time
      const clipboardTimer = new Date().getTime();
      const clipboardContent = getClipboardContent(e);
      const clipboardDelay = new Date().getTime() - clipboardTimer;

      const isKeyBoardPaste = (new Date().getTime() - keyboardPasteTimeStamp - clipboardDelay) < 1000;
      const plainTextMode = self.pasteFormat === 'text' || keyboardPastePlainTextState;
      let internal = hasContentType(clipboardContent, InternalHtml.internalHtmlMime());

      keyboardPastePlainTextState = false;

      if (e.isDefaultPrevented() || isBrokenAndroidClipboardEvent(e)) {
        pasteBin.remove();
        return;
      }

      if (!hasHtmlOrText(clipboardContent) && pasteImageData(e, getLastRng())) {
        pasteBin.remove();
        return;
      }

      // Not a keyboard paste prevent default paste and try to grab the clipboard contents using different APIs
      if (!isKeyBoardPaste) {
        e.preventDefault();
      }

      // Try IE only method if paste isn't a keyboard paste
      if (Env.ie && (!isKeyBoardPaste || e.ieFake) && !hasContentType(clipboardContent, 'text/html')) {
        pasteBin.create();

        editor.dom.bind(pasteBin.getEl(), 'paste', function (e) {
          e.stopPropagation();
        });

        editor.getDoc().execCommand('Paste', false, null);
        clipboardContent['text/html'] = pasteBin.getHtml();
      }

      // If clipboard API has HTML then use that directly
      if (hasContentType(clipboardContent, 'text/html')) {
        e.preventDefault();

        // if clipboard lacks internal mime type, inspect html for internal markings
        if (!internal) {
          internal = InternalHtml.isMarked(clipboardContent['text/html']);
        }

        insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
      } else {
        Delay.setEditorTimeout(editor, function () {
          insertClipboardContent(clipboardContent, isKeyBoardPaste, plainTextMode, internal);
        }, 0);
      }
    });

const wait = function (editor, oldSize, times, interval, callback?) {
  Delay.setEditorTimeout(editor, function () {
    resize(editor, oldSize);

    if (times--) {
      wait(editor, oldSize, times, interval, callback);
    } else if (callback) {
      callback();
    }
  }, interval);
};

  editor.on('init', function () {
    const statusbar = editor.theme.panel && editor.theme.panel.find('#statusbar')[0];
    const debouncedUpdate = Delay.debounce(update, 300);

    if (statusbar) {
      Delay.setEditorTimeout(editor, function () {
        statusbar.insert({
          type: 'label',
          name: 'wordcount',
          text: wordsToText(editor),
          classes: 'wordcount',
          disabled: editor.settings.readonly
        }, 0);

        editor.on('setcontent beforeaddundo undo redo keyup', debouncedUpdate);
      }, 0);
    }
  });

  editor.on('drop', function (e) {
    let dropContent, rng;

    rng = getCaretRangeFromEvent(editor, e);

    if (e.isDefaultPrevented() || draggingInternallyState.get()) {
      return;
    }

    dropContent = clipboard.getDataTransferItems(e.dataTransfer);
    const internal = clipboard.hasContentType(dropContent, InternalHtml.internalHtmlMime());

    if ((!clipboard.hasHtmlOrText(dropContent) || isPlainTextFileUrl(dropContent)) && clipboard.pasteImageData(e, rng)) {
      return;
    }

    if (rng && Settings.shouldFilterDrop(editor)) {
      let content = dropContent['mce-internal'] || dropContent['text/html'] || dropContent['text/plain'];

      if (content) {
        e.preventDefault();

        // FF 45 doesn't paint a caret when dragging in text in due to focus call by execCommand
        Delay.setEditorTimeout(editor, function () {
          editor.undoManager.transact(function () {
            if (dropContent['mce-internal']) {
              editor.execCommand('Delete');
            }

            setFocusedRange(editor, rng);

            content = Utils.trimHtml(content);

            if (!dropContent['text/html']) {
              clipboard.pasteText(content);
            } else {
              clipboard.pasteHtml(content, internal);
            }
          });
        });
      }
    }
  });

  editor.on('click keyup setContent ObjectResized', function (e) {
    // Only act on partial inserts
    if (e.type === 'setcontent' && !e.selection) {
      return;
    }

    // Needs to be delayed to avoid Chrome img focus out bug
    Delay.setEditorTimeout(editor, function () {
      let match;

      match = findFrontMostMatch(editor.selection.getNode());
      if (match) {
        hideAllContextToolbars();
        showContextToolbar(match);
      } else {
        hideAllContextToolbars();
      }
    });
  });