Pause component timer for current instance
@param type - of component
545832
public static void pauseTimer(final String type) {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return;
    }

    instance.components.get(type).pauseTimer();
  }
407267
public <H extends EventHandler> void removeHandler(GwtEvent.Type<H> type, final H handler) {
		this.eventBus.superDoRemove(type, null, handler);
	}
255109
public void pause()
    {
        if (mAudioListener != null)
        {
            int sourceId = getSourceId();
            if (sourceId != GvrAudioEngine.INVALID_ID)
            {
                mAudioListener.getAudioEngine().pauseSound(sourceId);
            }
        }
    }
304790
protected void deactivate(ComponentContext compcontext) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Deactivating " + this);
        }
        INSTANCE.compareAndSet(this, null);
    }
620148
@Override
    public IPromise<T> onTimeout(Consumer timeoutHandler) {
        return then( (r,e) -> {
            if ( e == Timeout.INSTANCE ) {
                timeoutHandler.accept(e);
            }
        });
    }
1098015
public void pause() {
        checkState();
        if (mState == STATE_PLAYING) {
            PlaybackService.pause(getContext(), mClientKey);
            mState = STATE_PAUSED;
        }
    }
1351249
@Override
    public void setMaxInactiveInterval(int time) {
        this.maxInactiveTimeSetting = time;
        if (time < 0) {
            this.maxInactiveTime = NO_TIMEOUT;
        } else {
            this.maxInactiveTime = (time * 1000L);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "max-inactive time: " + this.maxInactiveTimeSetting);
        }
    }
712826
public static Timer timer(Metrics metrics, String component, String methodName) {
    if (metrics != null) {
      return metrics.getTimer(component, methodName);
    } else {
      return null;
    }
  }
1101477
public void onTimeout(ResponseType responseType) throws DispatcherException
	{
		if(!proxy.getAckReceived()) {
			this.cancel();
			if(responseType == ResponseType.FINAL) {
				cancel1xxTimer();
			}
			this.timedOut = true;
			if(originalRequest != null) {
				List<ProxyBranchListener> proxyBranchListeners = originalRequest.getSipSession().getSipApplicationSession().getSipContext().getListeners().getProxyBranchListeners();
				if(proxyBranchListeners != null) {
					for (ProxyBranchListener proxyBranchListener : proxyBranchListeners) {
						proxyBranchListener.onProxyBranchResponseTimeout(responseType, this);
					}
				}
			}
			// Just do a timeout response
			proxy.onBranchTimeOut(this);
			logger.warn("Proxy branch has timed out");
		} else {
			logger.debug("ACKed proxybranch has timeout");
		}
	}
583453
function pause () {
        triggerEvent('pause');
        stopLoop(animationId);
        pausedAfter = startTime - performance.now();
        startTime = undefined;
        return self;
      }
535069
private void setType(UIComponent component, String type) {
		Method method;
		try {
			method = component.getClass().getMethod("getType");
			if (null != method) {
				Object invoke = method.invoke(component);
				if (invoke != null) {
					// is it an PrimeFaces component?
					if (component.getClass().getName().equals("org.primefaces.component.inputtext.InputText")) {
						if (!"text".equals(invoke)) {
							// the programmer has explicitly assigned a type
							return;
						}
					}
					else return;
				}
			}
			
			method = component.getClass().getMethod("setType", String.class);
			if (null != method) {
				method.invoke(component, type);
				return;
			}
		} catch (ReflectiveOperationException e) {
			// catch block required by compiler, can't happen in reality
		}
		if (null == component.getAttributes().get("type") && null == component.getPassThroughAttributes().get("type")) {
			component.getPassThroughAttributes().put("type", type);
		}
	}
941560
function( time, type ) {
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
		type = type || "fx";

		return this.queue( type, function() {
			var elem = this;
			setTimeout(function() {
				jQuery.dequeue( elem, type );
			}, time );
		});
	}
887199
protected void handleEvents(final String EVENT_TYPE) {
        super.handleEvents(EVENT_TYPE);
         if ("FINISHED".equals(EVENT_TYPE)) {
            if ( gauge.isHighlightSections() ) {
                redraw();
            }
        } else if ("ANGLE".equals(EVENT_TYPE)) {
            double currentValue = (needleRotate.getAngle() + START_ANGLE - 180) / angleStep + gauge.getMinValue();
            lcdText.setText((String.format(locale, formatString, currentValue)));
            if (gauge.isLcdVisible()) {
                lcdText.setAlignment(Pos.CENTER_RIGHT);
                lcdText.setTranslateX((width - lcdText.getPrefWidth()) * 0.5);
            } else {
                lcdText.setAlignment(Pos.CENTER);
                lcdText.setTranslateX((width - lcdText.getLayoutBounds().getWidth()) * 0.5);
            }
        } else if ("VISIBILITY".equals(EVENT_TYPE)) {
            enableNode(ledCanvas, gauge.isLedVisible());
            enableNode(titleText, !gauge.getTitle().isEmpty());
            enableNode(unitText, !gauge.getUnit().isEmpty());
            enableNode(lcd,gauge.isLcdVisible());
            enableNode(lcdText,gauge.isValueVisible());
            enableNode(threshold, gauge.isThresholdVisible());
            enableNode(average, gauge.isAverageVisible());
            boolean markersVisible = gauge.getMarkersVisible();
            for (Shape shape : markerMap.values()) { Helper.enableNode(shape, markersVisible); }
            resize();
            redraw();
        } else if ("LED".equals(EVENT_TYPE)) {
            if (gauge.isLedVisible()) { drawLed(led); }
        } else if ("LCD".equals(EVENT_TYPE)) {
            if (gauge.isLcdVisible()) redraw();
        } else if ("RECALC".equals(EVENT_TYPE)) {
            angleStep = gauge.getAngleStep();
            if (gauge.getValue() < gauge.getMinValue()) {
                oldValue = gauge.getMinValue();
            }
            if (gauge.getValue() > gauge.getMaxValue()) {
                oldValue = gauge.getMaxValue();
            }
            redraw();
            rotateNeedle();
        }
    }
952717
def pause(self):
        """"""
        self._mq.send("p", True, type=1)
        self._paused = True
497802
function enableCompileTimer () {
		if (!waitingToCompile) {
			waitingToCompile = true;
			waitTimerStarted = getNow();
			frameCounter = 0;

			window.setTimeout(onWaitTimerTick, shine.jit.COMPILE_INTERVAL);
			window.requestAnimationFrame(onAnimationFrame);
		}
	}
786426
public void pause() {
        switch (status) {
            case PAUSED:
            case STOPPED:
                return;

            case PLAYING:
                status = Status.PAUSED;

                // Remove all callbacks
                slideHandler.removeCallbacksAndMessages(null);
        }
    }
539375
function debouncebundle (time) {
  let timer = postcssify.timer
  if (timer) { clearTimeout(timer) }
  postcssify.timer = setTimeout(() => {
    postcssify.timer = null
    bundle()
  }, time)
}