TypeScript sugar.Focus類代碼示例

 transaction(function () {
   // If we don't blur before focusing the content, a previous focus in something like a statebutton
   // which represents the chosen font colour can stop the keyboard from appearing. Therefore, we blur
   // first.
   Focus.active().each(Focus.blur);
   Focus.focus(iBody);
 });

const resume = function (cWin, frame) {
  Focus.active().each(function (active) {
    // INVESTIGATE: This predicate may not be required. The purpose of it is to ensure
    // that the content window's frame element is not unnecessarily blurred before giving
    // it focus.
    if (! Compare.eq(active, frame)) {
      Focus.blur(active);
    }
  });
  // Required when transferring from another input area.
  cWin.focus();

  Focus.focus(Element.fromDom(cWin.document.body));
  CursorRefresh.refresh(cWin);
};

 const hasRangeInUi = function () {
   return Focus.active(outerDoc).filter(function (input) {
     return Node.name(input) === 'input';
   }).exists(function (input) {
     return input.dom().selectionStart !== input.dom().selectionEnd;
   });
 };

      Step.sync(function () {
        const active = Focus.active().getOrDie();
        // The buttons are next and previous siblings
        const prev = Traverse.parent(active).bind(Traverse.prevSibling).getOrDie('Could not find button to left');
        const next = Traverse.parent(active).bind(Traverse.nextSibling).getOrDie('Could not find button to right');

        const assertNavButton = function (buttonLabel, expected, button) {
          Assertions.assertStructure(
            'Checking ' + buttonLabel + ' button should be enabled = ' + expected,
            ApproxStructure.build(function (s, str, arr) {
              return s.element('span', {
                attr: {
                  role: str.is('button')
                },
                classes: [
                  (expected ? arr.not : arr.has)('tinymce-mobile-toolbar-navigation-disabled')
                ]
              });
            }),
            button
          );
        };

        assertNavButton('previous', prevEnabled, prev);
        assertNavButton('next', nextEnabled, next);
      })

 Focus.active().each(function (active) {
   // INVESTIGATE: This predicate may not be required. The purpose of it is to ensure
   // that the content window's frame element is not unnecessarily blurred before giving
   // it focus.
   if (! Compare.eq(active, frame)) {
     Focus.blur(active);
   }
 });

 InlineView.getContent(comp).each((oldContents) => {
   stack.set(stack.get().concat([
     {
       bar: oldContents,
       // TODO: Not working
       focus: Focus.active()
     }
   ]));
 });

    editor.on('NodeChange', (e) => {
      Focus.search(contextbar.element()).fold(
        () => {
          resetTimer(
            Delay.setEditorTimeout(editor, launchContextToolbar, 0)
          );
        },
        (_) => {

        }
      );
    });

const input = function (parent, operation) {
  // to capture focus allowing the keyboard to remain open with no 'real' selection
  const input = Element.fromTag('input');
  Css.setAll(input, {
    opacity: '0',
    position: 'absolute',
    top: '-1000px',
    left: '-1000px'
  });
  Insert.append(parent, input);

  Focus.focus(input);
  operation(input);
  Remove.remove(input);
};

const setSelectionAtTouch = function (editorApi, touchEvent) {
  // shortTextFix, when text is short body height is short too, tapping at the bottom of the editor
  // should set a selection. We don't set body height to 100% because of side effects, so we resort
  // to a mousedown on the iDoc, it is a clean place, and very specific to this issue. On a vanilla
  // CE, with body height 100%, event sequence: touchstart, touchend, mousemove, mousedown, FOCUS,
  // mouseup, click. This is why we fire focus on mousedown, to match the natural sequence.
  Focus.focus(editorApi.body());

  // then set the selection to the end, last cursor position
  // Note: the reason why there is a flicker when we touch the bottom, is because of the native scroll
  // cursor into view, in this case it wants to scroll down so the text is centered on the screen,
  // we have to live with this until we control selection
  const touch = touchEvent.raw().changedTouches[0];
  WindowSelection.getAtPoint(editorApi.win(), touch.pageX, touch.pageY).each(function (raw) {
    editorApi.setSelection(raw.start(), raw.soffset(), raw.finish(), raw.foffset());
  });
};

const resume = function (cWin) {
  cWin.focus();
  const iBody = Element.fromDom(cWin.document.body);

  const inInput = Focus.active().exists(function (elem) {
    return Arr.contains([ 'input', 'textarea' ], Node.name(elem));
  });

  const transaction = inInput ? autocompleteHack() : Fun.apply;

  transaction(function () {
    // If we don't blur before focusing the content, a previous focus in something like a statebutton
    // which represents the chosen font colour can stop the keyboard from appearing. Therefore, we blur
    // first.
    Focus.active().each(Focus.blur);
    Focus.focus(iBody);
  });
};