TypeScript ITimeoutService.default方法代码示例

      let displayTooltip = function (newValue, showDelayed?) {
        if (showTooltipPromise) {
          $timeout.cancel(showTooltipPromise)
        }

        let taskTooltips = $scope.task.model.tooltips
        let rowTooltips = $scope.task.row.model.tooltips

        if (typeof(taskTooltips) === 'boolean') {
          taskTooltips = {enabled: taskTooltips}
        }

        if (typeof(rowTooltips) === 'boolean') {
          rowTooltips = {enabled: rowTooltips}
        }

        let enabled = ganttUtils.firstProperty([taskTooltips, rowTooltips], 'enabled', $scope.pluginScope.enabled)
        if (enabled && !visible && mouseEnterX !== undefined && newValue) {
          let content = ganttUtils.firstProperty([taskTooltips, rowTooltips], 'content', $scope.pluginScope.content)
          $scope.content = content

          if (showDelayed) {
            showTooltipPromise = $timeout(function () {
              showTooltip(mouseEnterX)
            }, $scope.pluginScope.delay, false)
          } else {
            showTooltip(mouseEnterX)
          }
        } else if (!newValue) {
          if (!$scope.task.active) {
            hideTooltip()
          }
        }
      }

          onOpen: function ($event) {
            if (scope.config.disabled) {
              $event.prevent();
              return;
            }

            if (hasBeenOpened === false) {
              hasBeenOpened = true;
            }
            filterOptions();

            $document.on('keyup', onEscPressed);

            domDropDownMenu.style.visibility = 'hidden';
            $timeout(function () {
              adjustHeight();
              domDropDownMenu.style.visibility = 'visible';

              if (scope.config.filter.active) {
                // use timeout to open dropdown first and then set the focus,
                // otherwise focus won't be set because iElement is not visible
                $timeout(function () {
                  iElement[0].querySelector('.dropdown-menu input').focus();
                });
              }
            });
            jqWindow.on('resize', adjustHeight);

            if (angular.isFunction(scope.config.dropdown.onOpen)) {
              (scope.config.dropdown.onOpen as any)();
            }
          },

    $element.bind('scroll', ganttDebounce(function () {
      let el = $element[0]
      let currentScrollLeft = el.scrollLeft
      let direction
      let date

      $scope.gantt.scroll.cachedScrollLeft = currentScrollLeft
      $scope.gantt.columnsManager.updateVisibleColumns()
      $scope.gantt.rowsManager.updateVisibleObjects()

      if (currentScrollLeft < lastScrollLeft && currentScrollLeft === 0) {
        direction = 'left'
        date = $scope.gantt.columnsManager.from
      } else if (currentScrollLeft > lastScrollLeft && el.offsetWidth + currentScrollLeft >= el.scrollWidth - 1) {
        direction = 'right'
        date = $scope.gantt.columnsManager.to
      }

      lastScrollLeft = currentScrollLeft

      if (date !== undefined) {
        if (autoExpandTimer) {
          $timeout.cancel(autoExpandTimer)
        }

        autoExpandTimer = $timeout(function () {
          autoExpandColumns(el, date, direction)
        }, 300)
      } else {
        $scope.gantt.api.scroll.raise.scroll(currentScrollLeft)
      }
    }, 5))

 const handler = (event) => {
   if (!element[0].contains(event.target)) {
     // This fixes an event ordering bug in Safari that can cause closed dialogs to reopen
     $timeout(() => {
       scope.$apply(attr.dimClickAnywhereButHere);
     }, 150);
   }
 };

    link: function link(scope) {
      function clickHandler() {
        dimActivityTrackerService.track();
      }

      function visibilityHandler() {
        if ($document[0].hidden === false) {
          dimActivityTrackerService.track();
          refreshAccountData();
        }
      }

      $document.on('click', clickHandler);
      $document.on('visibilitychange', visibilityHandler);
      $document.on('online', refreshAccountData);

      const ONE_MINUTE = 60 * 1000;
      const FIVE_MINUTES = 5 * 60 * 1000;
      const ONE_HOUR = 60 * 60 * 1000;

      const refresh = _.throttle(() => {
        // Individual pages should listen to this event and decide what to refresh,
        // and their services should decide how to cache/dedup refreshes.
        // This event should *NOT* be listened to by services!
        // TODO: replace this with an observable?
        $rootScope.$broadcast('dim-refresh');
      }, ONE_MINUTE, { trailing: false });

      const activeWithinLastHour = dimActivityTrackerService.activeWithinTimespan
        .bind(dimActivityTrackerService, ONE_HOUR);

      function refreshAccountData() {
        const dimHasNoActivePromises = !loadingTracker.active();
        const userWasActiveInTheLastHour = activeWithinLastHour();
        const isDimVisible = !$document.hidden;
        const isOnline = navigator.onLine;

        if (dimHasNoActivePromises && userWasActiveInTheLastHour && isDimVisible && isOnline) {
          refresh();
        }
      }

      let refreshAccountDataInterval = $timeout(refreshAccountData, FIVE_MINUTES);

      scope.$on('$destroy', () => {
        $document.off('click', clickHandler);
        $document.off('visibilitychange', visibilityHandler);
        $document.off('online', refreshAccountData);
        $timeout.cancel(refreshAccountDataInterval);
      });

      // Every time we refresh for any reason, reset the timer
      scope.$on('dim-refresh', () => {
        $timeout.cancel(refreshAccountDataInterval);
        refreshAccountDataInterval = $timeout(refreshAccountData, FIVE_MINUTES);
      });
    }

 const updateMessage = _.once(() => {
   $timeout(() => {
     showInfoPopup('update-available', {
       title: $i18next.t('Help.UpdateAvailable'),
       body: $i18next.t('Help.UpdateAvailableMessage'),
       type: 'warn',
       hideable: false
     }, 0);
   });
 });

            $timeout(function () {
              adjustHeight();
              domDropDownMenu.style.visibility = 'visible';

              if (scope.config.filter.active) {
                // use timeout to open dropdown first and then set the focus,
                // otherwise focus won't be set because iElement is not visible
                $timeout(function () {
                  iElement[0].querySelector('.dropdown-menu input').focus();
                });
              }
            });

 return function () {
   let self = this
   let argz = arguments
   nthCall++
   let later = (function (version) {
     return function () {
       if (version === nthCall) {
         return fn.apply(self, argz)
       }
     }
   })(nthCall)
   return $timeout(later, timeout, invokeApply === undefined ? true : invokeApply)
 }

 // Function to download data to a file
 function download(data, filename, type) {
   const a = document.createElement("a");
   const file = new Blob([data], { type });
   const url = URL.createObjectURL(file);
   a.href = url;
   a.download = filename;
   document.body.appendChild(a);
   a.click();
   $timeout(() => {
     document.body.removeChild(a);
     window.URL.revokeObjectURL(url);
   });
 }