Activates the list of active tools
340946
def _set_active_tools(self, plot):
        ""
        for tool in self.active_tools:
            if isinstance(tool, util.basestring):
                tool_type = TOOL_TYPES[tool]
                matching = [t for t in plot.toolbar.tools
                            if isinstance(t, tool_type)]
                if not matching:
                    self.param.warning('Tool of type %r could not be found '
                                       'and could not be activated by default.'
                                       % tool)
                    continue
                tool = matching[0]
            if isinstance(tool, tools.Drag):
                plot.toolbar.active_drag = tool
            if isinstance(tool, tools.Scroll):
                plot.toolbar.active_scroll = tool
            if isinstance(tool, tools.Tap):
                plot.toolbar.active_tap = tool
            if isinstance(tool, tools.Inspection):
                plot.toolbar.active_inspect.append(tool)
20480
def activate_script(self):
        """"""

        # must be rethought
        # ./scripts
        # deploydir/./scripts
        self._add_scope("script")
        self.scripts = {}
        self.script_files = [
            "./scripts/script_*.txt", "~/.cloudmesh/scripts/script_*.txt"]
        self._load_scripts(self.script_files)
982875
def set_active(self, ind):
        
        DEBUG_MSG("set_active()", 1, self)
        self._ind = ind
        if ind != None:
            self._active = [ self._axes[i] for i in self._ind ]
        else:
            self._active = []
        # Now update button text wit active axes
        self._menu.updateButtonText(ind)
1051041
function () {
		options.menu = !fabricator.dom.root.classList.contains('f-menu-active');
		fabricator.dom.root.classList.toggle('f-menu-active');

		if (fabricator.test.sessionStorage) {
			sessionStorage.setItem('fabricator', JSON.stringify(options));
		}
	}
1221908
def activated(self, item):
        """"""
        itemdata = self.data.get(id(self.currentItem()))
        if itemdata is not None:
            filename, lineno, colno = itemdata
            self.sig_edit_goto.emit(filename, lineno, self.search_text)
1225544
def activateAndRaise(self):
        
        logger.debug("Activate and raising window: {}".format(self.windowNumber))
        self.activateWindow()
        self.raise_()
190283
public function actionDeactivateAll()
    {
        if (isset($_POST['items'])) {
            foreach ($_POST['items'] as $id) {
                if ($model = $this->findModel($id)) {
                    $model->status = ActiveRecord::STATUS_INACTIVE;
                    $model->save(false);
                }
            }
        }
    }
853790
public function activate()
    {
        if ($this->menu->config->activeElement == 'item') {
            $this->setToActive();
        } else {
            if ($this->link) {
                $this->link->activate();
            }
        }

        // If parent activation is enabled:
        if ($this->menu->config->activateParents) {
            // Moving up through the parent nodes, activating them as well.
            if ($this->parent) {
                $this->parent->activate();
            }
        }
    }
967440
public void activate() {
        GuiceBridge.getGuiceBridge().initializeGuiceBridge(locator);
        final GuiceIntoHK2Bridge guiceBridge = locator.getService(GuiceIntoHK2Bridge.class);
        guiceBridge.bridgeGuiceInjector(injector);
    }
1124063
public function actionActivateAll()
    {
        if (isset($_POST['items'])) {
            foreach ($_POST['items'] as $id) {
                if ($model = $this->findModel($id)) {
                    $model->status = ActiveRecord::STATUS_ACTIVE;
                    $model->save(false);
                }
            }
        }
    }
1189156
public void setActive(boolean active) {
		if (active == this.active)
			return;

		this.active = active;
		if (rayHandler == null)
			return;
		
		if (active) {
			rayHandler.lightList.add(this);
			rayHandler.disabledLights.removeValue(this, true);
		} else {
			rayHandler.disabledLights.add(this);
			rayHandler.lightList.removeValue(this, true);
		}
	}
41117
private boolean activateSelectedItems(final MotionEvent event, final MapView mapView,
			final ActiveItem task) {
		final int eventX = Math.round(event.getX());
		final int eventY = Math.round(event.getY());
		for (int i = 0; i < this.mItemList.size(); ++i) {
			if (isEventOnItem(getItem(i), eventX, eventY, mapView)) {
				if (task.run(i)) {
					return true;
				}
			}
		}
		return false;
	}
1281862
def register_actions(self, shortcut_manager):
        
        shortcut_manager.add_callback_for_action("delete", self.trans_list_ctrl.remove_action_callback)
        shortcut_manager.add_callback_for_action("add", self.trans_list_ctrl.add_action_callback)
1355893
def activate(self):
        

        raise NotImplementedError("{0} | '{1}' must be implemented by '{2}' subclasses!".format(
            self.__class__.__name__, self.activate.__name__, self.__class__.__name__))
247599
function() {
        if(this.strategies) {
            var strategy, i, len;
            for(i=0, len=this.strategies.length; i<len; i++) {
                strategy = this.strategies[i];
                if(strategy.autoActivate) {
                    strategy.activate();
                }
            }
        }
    }
250682
public void activate() {
        if (appender instanceof OptionHandler) {
            ((OptionHandler) appender).activateOptions();
            if (LoggingLogger.ROOT_LOGGER.isDebugEnabled()) {
                LoggingLogger.ROOT_LOGGER.debugf("Invoking OptionHandler.activateOptions() on appender %s (%s)", appender.getName(), appender.getClass().getCanonicalName());
            }
        }
    }
1141862
public void activate() {
        // if no handlers are currently running, start one now
        if (this.numHandlersInFlight.getInt() == 0) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Activating result handler: " + this.completionPort);
            }
            startHandler();
        }
    }