TypeScript Focus.active方法代码示例

      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);
      })

 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 hasRangeInUi = function () {
   return Focus.active(outerDoc).filter(function (input) {
     return Node.name(input) === 'input';
   }).exists(function (input) {
     return input.dom().selectionStart !== input.dom().selectionEnd;
   });
 };

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

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 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);
  });
};

        SelectorFind.descendant(comp.element(), '[role="tabpanel"]').each((tabview) => {
          const oldFocus = Focus.active();
          Css.set(tabview, 'visibility', 'hidden');
          const oldHeight = Css.getRaw(tabview, 'height').map((h) => parseInt(h, 10));
          Css.remove(tabview, 'height');
          const newHeight = tabview.dom().getBoundingClientRect().height;
          const hasGrown = oldHeight.forall((h) => newHeight > h);

          if (hasGrown) {
            maxTabHeight.set(Option.from(newHeight));
            updateTabviewHeight(comp.element(), tabview, maxTabHeight);
          } else {
            oldHeight.each((h) => {
              Css.set(tabview, 'height', `${h}px`);
            });
          }

          Css.remove(tabview, 'visibility');
          oldFocus.each(Focus.focus);
        });

 return Chain.op(function (editor) {
   const element = Hierarchy.follow(Element.fromDom(editor.getBody()), elementPath).getOrDie();
   Assertions.assertEq('Should have focus on the editor', true, EditorFocus.hasFocus(editor));
   Assertions.assertDomEq('Should be the expected activeElement', element, Focus.active().getOrDie());
 });

 Step.sync(() => {
   Focus.active().each((button) => {
     Class.add(button, 'cancel-button');
   });
 }),