deactivates all previously scheduled actions
2796
function() {

		var actions = this._actions,
			nActions = this._nActiveActions,
			bindings = this._bindings,
			nBindings = this._nActiveBindings;

		this._nActiveActions = 0;
		this._nActiveBindings = 0;

		for ( var i = 0; i !== nActions; ++ i ) {

			actions[ i ].reset();

		}

		for ( var i = 0; i !== nBindings; ++ i ) {

			bindings[ i ].useCount = 0;

		}

		return this;

	}
828662
def unschedule(event)
            @critical.synchronize {
                # Only call delete and update the timer when required
                if @schedules.include?(event)
                    @schedules.delete(event)
                    remove(event)
                    check_timer
                end
            }
        end
512717
public void clearAllControls() {
        schedule.setValue("");
        duration.setValue("");
        timeZone.setValue(getClientTimeZone());
        scheduleTranslator.setValue(i18n.getMessage(CRON_VALIDATION_ERROR));
    }
1230608
final void deactivateNow() {
      isActive = false;
      stats.deactivate();
      availableQueue.clear();
      reopenExecutor.getQueue().clear();
      for(ConnectionPoolConnection conn : connections) {
         conn.forceRealClose();
         conn.state.set(ConnectionPoolConnection.STATE_DISCONNECTED);
      }
   }
268907
def disable(self, name=None):
        """"""
        if name is None:
            for name in self._actions_dict:
                self.disable(name)
            return
        self._actions_dict[name].qaction.setEnabled(False)
242562
def __remove_actions(self):
        

        LOGGER.debug("> Removing '{0}' Component actions.".format(self.__class__.__name__))

        remove_project_action = "Actions|Umbra|Components|factory.script_editor|&File|Remove Project"
        self.__script_editor.command_menu.removeAction(self.__engine.actions_manager.get_action(remove_project_action))
        self.__engine.actions_manager.unregister_action(remove_project_action)
515242
def process_remove_action(processors, action, argument):
    """"""
    for processor in processors:
        processor(action, argument)
    db.session.commit()
1110491
def run(self, scheduler_schedule_id, **kwargs):
        
        log = self.get_logger(**kwargs)

        self.scheduler.update_schedule(scheduler_schedule_id, {"active": False})
        log.info(
            "Deactivated schedule %s in the scheduler service", scheduler_schedule_id
        )
971708
def unschedule(obj)
      if @occurrences.has_key? obj
        last_priority = @occurrences.min_priority
        obj, time = @occurrences.delete obj
        if parent && @occurrences.min_priority != last_priority
          if @occurrences.min_priority
            parent.schedule([:clock, self], unscale_time(@occurrences.min_priority))
          else
            parent.unschedule([:clock, self])
          end
        end
        unscale_time(time)
      else
        relative_time = @children.first_non_nil { |clock| clock.unschedule(obj) }
        unscale_relative_time(relative_time) if relative_time
      end
    end
1294382
def schedule_deleted(sender, instance, **kwargs):
    
    from contentstore.tasks import deactivate_schedule

    deactivate_schedule.delay(str(instance.scheduler_schedule_id))
941507
public synchronized void deactivate() {
        // Allow garbage collection of all slots reserved by this component.
        // Clean up all the metadata used by the slots.
        for (MetaDataSlotImpl slot : slots) {
            MetaDataManager<?, ?> manager = (MetaDataManager<?, ?>) slot.getManager();
            manager.destroyMetaDataSlot(slot);
        }
        slots = null;
    }
945148
public void clearAllSchedulingData(T jedis) throws JobPersistenceException, ClassNotFoundException {
        // delete triggers
        for (String jobHashKey : jedis.smembers(redisSchema.jobsSet())) {
            removeJob(redisSchema.jobKey(jobHashKey), jedis);
        }

        // delete remaining jobs
        for (String triggerHashKey : jedis.smembers(redisSchema.triggersSet())) {
            removeTrigger(redisSchema.triggerKey(triggerHashKey), jedis);
        }

        // remove calendars
        for (String calendarHashKey : jedis.smembers(redisSchema.calendarsSet())) {
            removeCalendar(redisSchema.calendarName(calendarHashKey), jedis);
        }
    }
589099
@Trivial
    private final void purgeFutures() {
        for (Iterator<ScheduledFuture<?>> it = futures.iterator(); it.hasNext();)
            if (it.next().isDone())
                it.remove();
    }
1121511
def reset(self):
        # pylint: disable=not-context-manager
        
        logger.info("Scheduling loop reset")
        with self.waiting_results.mutex:
            self.waiting_results.queue.clear()
        self.checks.clear()
        self.actions.clear()
212940
function disableEventListeners() {
  if (this.state.eventsEnabled) {
    if (window.cancelAnimationFrame) {
      cancelAnimationFrame(this.scheduleUpdate);
    }
    this.state = removeEventListeners(this.reference, this.state);
  }
}
1295223
def deactivate(self):
        
        if not self._optional:
            self._optional = True

        self._activated = False
967685
public function delete()
    {
        $this->getLogger()->info('Deleting scheduled event ID ' . $this->eventId);
        $this->doDelete('/schedule/' . $this->eventId);

        return true;
    }