Pauses the target.
All scheduled selectors/update for a given target won't be 'ticked' until the target is resumed.
If the target is not present, nothing happens.
507582
function (target) {
        var element = this.hashForMethods[target.id]
        if (element) {
            element.paused = true
        }

        var elementUpdate = this.hashForUpdates[target.id]
        if (elementUpdate) {
            elementUpdate.paused = true
        }
    }
1051109
public void pauseJobs (final GroupMatcher <JobKey> groupMatcher) throws SchedulerException
  {
    validateState ();

    final ICommonsCollection <String> pausedGroups = m_aResources.getJobStore ()
                                                                 .pauseJobs (_getOrDefault (groupMatcher));
    notifySchedulerThread (0L);
    for (final String pausedGroup : pausedGroups)
    {
      notifySchedulerListenersPausedJobs (pausedGroup);
    }
  }
34529
public void pauseJob (final JobKey jobKey) throws SchedulerException
  {
    validateState ();

    m_aResources.getJobStore ().pauseJob (jobKey);
    notifySchedulerThread (0L);
    notifySchedulerListenersPausedJob (jobKey);
  }
83781
def pause(jid, state_id=None, duration=None):
    '''
    
    '''
    minion = salt.minion.MasterMinion(__opts__)
    minion.functions['state.pause'](jid, state_id, duration)
1238647
public ReturnCode pause(String targetArg) {
        StringBuilder commandBuilder = new StringBuilder(PAUSE_COMMAND);

        char sep = DELIM;
        if (targetArg != null) {
            commandBuilder.append(sep).append(targetArg);
        }

        return write(commandBuilder.toString(),
                     ReturnCode.SERVER_INACTIVE_STATUS,
                     ReturnCode.ERROR_SERVER_PAUSE);
    }
1338865
public void pauseAll(T jedis) throws JobPersistenceException {
        for (String triggerGroupSet : jedis.smembers(redisSchema.triggerGroupsSet())) {
            pauseTriggers(GroupMatcher.triggerGroupEquals(redisSchema.triggerGroup(triggerGroupSet)), jedis);
        }
    }
28918
public static function pause()
    {
        if (!self::$output) {
            return;
        }

        self::$output->writeln("<info>The execution has been paused. Press ENTER to continue</info>");

        if (trim(fgets(STDIN)) != chr(13)) {
            return;
        }
    }
446430
private void blockingRefresh() {
        try {
            if (blockingRefreshLock
                    .tryLock(BLOCKING_REFRESH_MAX_WAIT_IN_SECONDS, TimeUnit.SECONDS)) {
                try {
                    // Return if successful refresh occurred while waiting for the lock
                    if (!shouldDoBlockingRefresh()) {
                        return;
                    } else {
                        // Otherwise do a synchronous refresh if the last lock holder was unable to
                        // refresh the value
                        refreshValue();
                        return;
                    }
                } finally {
                    blockingRefreshLock.unlock();
                }
            }
        } catch (InterruptedException ex) {
            handleInterruptedException("Interrupted waiting to refresh the value.", ex);
        }
        // Couldn't acquire the lock. Just try a synchronous refresh
        refreshValue();
    }
1242044
def pause(self):
		
		if self.status == RUNNING:
			self.status = PAUSED
			self.previous_intervals.append(time.time() - self.interval_start)
			self.current_interval_duration = 0.0
		elif self.status == PAUSED:
			self.interval_start = time.time()
			self.status = RUNNING
917489
function (target) {
        var element = this.hashForMethods[target.id]
        if (element) {
            element.paused = false
        }

        var elementUpdate = this.hashForUpdates[target.id]
        //console.log('foo', target.id, elementUpdate)
        if (elementUpdate) {
            elementUpdate.paused = false
        }
    }
1042435
def on_bind_target(self, target, ctx=None):
        

        _on_bind_target = getattr(self, Annotation._ON_BIND_TARGET, None)

        if _on_bind_target is not None:
            _on_bind_target(self, target=target, ctx=ctx)
152354
function(target, date) {
		var inst = this._getInst(target);
		if (inst) {
			this._setDate(inst, date);
			this._updateDatepicker(inst);
			this._updateAlternate(inst);
		}
	}
477628
private void update(long delay) {
        if (willUpdate) {
            return; // Already a pending update scheduled
        }

        if (!observing) { return; }

        willUpdate = true;

        query.getDatabase().scheduleOnQueryExecutor(new Runnable() {
            @Override
            public void run() {
                update();
            }
        }, delay);
    }
142814
def resume(self, trigger_duration=0):
        """"""
        if trigger_duration != 0:
            self._mq.send("t%d" % trigger_duration, True, type=1)
        else:
            self._mq.send("r", True, type=1)
        self._paused = False
654828
public static void pause() {
        SiftImpl localInstance = instance;
        if (localInstance != null) {
            localInstance.save();
        }

        AppStateCollector localAppStateCollector = appStateCollector;
        if (localAppStateCollector != null) {
            localAppStateCollector.disconnectLocationServices();
        }
    }
606422
def on_timer(self, event=None):
        
        # Smoothly update center and magnification properties of the transform
        k = np.clip(100. / self.mag.mag, 10, 100)
        s = 10**(-k * event.dt)
            
        c = np.array(self.mag.center)
        c1 = c * s + self.mouse_pos * (1-s)
        
        m = self.mag.mag * s + self.mag_target * (1-s)
        
        # If changes are very small, then it is safe to stop the timer.
        if (np.all(np.abs((c - c1) / c1) < 1e-5) and 
                (np.abs(np.log(m / self.mag.mag)) < 1e-3)):
            self.timer.stop()
            
        self.mag.center = c1
        self.mag.mag = m
            
        self._update_transform()
1241832
public void unpause ()
    {
        // Don't unpause the timer if it wasn't paused to begin with
        if (_lastUpdate == Long.MIN_VALUE || _start == Long.MIN_VALUE) {
            return;
        }

        // Adjust the starting time when the timer next ticks
        _processUnpause = true;

        // Start things running again
        _running = true;
    }