Method: activate
Activates the control.

Returns:
{Boolean} The control was effectively activated.
190828
function () {
        if (!this.active) {
            if(this.layers) {
                this.map.addLayer(this.layer);
            }
            this.handlers.feature.activate();
            if(this.box && this.handlers.box) {
                this.handlers.box.activate();
            }
        }
        return OpenLayers.Control.prototype.activate.apply(
            this, arguments
        );
    }
123724
function() {
        var activated = false;
        if(OpenLayers.Control.prototype.activate.apply(this, arguments)) {
            this.dragControl.activate();
            this.layer.addFeatures([this.box]);
            this.rotate && this.layer.addFeatures(this.rotationHandles);
            this.layer.addFeatures(this.handles);        
            activated = true;
        }
        return activated;
    }
504061
public function activate()
    {
        $this->isActive            = true;
        $this->attributes['class'] = Utils::addHtmlClass(
            array_get($this->attributes, 'class', ''),
            $this->activeClass
        );

        return $this;
    }
239021
def triggered(self):
        
        if self.stop is not None and not self.stop_reached:
            return False

        if self.limit is not None and not self.limit_reached:
            return False

        return True
811130
function() {
        if (OpenLayers.Control.prototype.activate.apply(this, arguments)) {
            this.map.events.register('mousemove', this, this.redraw);
            this.map.events.register('mouseout', this, this.reset);
            this.redraw();
            return true;
        } else {
            return false;
        }
    }
365078
@Override
    public void activate() throws InterruptedException, CouldNotPerformException {
        manageLock.lockWrite(this);
        try {
            validateInitialization();
            logger.debug("Activate AbstractControllerServer for: " + this);
            setAvailabilityState(ACTIVATING);
            assert serverWatchDog != null;
            assert informerWatchDog != null;
            serverWatchDog.activate();
            informerWatchDog.activate();
        } finally {
            manageLock.unlockWrite(this);
        }
    }
1268756
void activate() {
        nodes().flatMap(e -> e.allKeysRecursively())
                .distinct()
                .forEach(key -> {
                    activate(key);
                });
    }
1355893
def activate(self):
        

        raise NotImplementedError("{0} | '{1}' must be implemented by '{2}' subclasses!".format(
            self.__class__.__name__, self.activate.__name__, self.__class__.__name__))
545548
def activate(self, engine):
        

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

        self.__engine = engine
        self.__settings = self.__engine.settings
        self.__settings_section = self.name

        self.activated = True
        return True
1191710
function() {
        if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
            this.map.events.unregister('mousemove', this, this.redraw);
            this.map.events.unregister('mouseout', this, this.reset);
            this.element.innerHTML = "";
            return true;
        } else {
            return false;
        }
    }
1182894
function() {
        var deactivated = false;
        if(this.map) {
            if(OpenLayers.Control.prototype.deactivate.apply(this)) {
                for(var type in this.listeners) {
                    this.map.events.unregister(
                        type, this, this.listeners[type]
                    );
                }
                if(this.clearOnDeactivate) {
                    this.clear();
                }
                deactivated = true;
            }
        }
        return deactivated;
    }
315379
function() {
        if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
            this.observeElement = this.observeElement || document;
            for (var i=0, len=this.KEY_EVENTS.length; i<len; i++) {
                OpenLayers.Event.observe(
                    this.observeElement, this.KEY_EVENTS[i], this.eventListener);
            }
            return true;
        } else {
            return false;
        }
    }
549458
def activate(self):
        
        payload = {
            'id': 'lu_action',
            'action': 'RunScene',
            'serviceId': self.scene_service
        }
        result = self.vera_request(**payload)
        logger.debug("activate: "
                  "result of vera_request with payload %s: %s",
                  payload, result.text)

        self._active = True
133831
function() {
        if(this.active) {
            return false;
        }
        // register for event handlers defined on this class.
        var events = OpenLayers.Events.prototype.BROWSER_EVENTS;
        for (var i=0, len=events.length; i<len; i++) {
            if (this[events[i]]) {
                this.register(events[i], this[events[i]]); 
            }
        } 
        this.active = true;
        return true;
    }
876317
def activate_user(self, user):
        
        if not user.active:
            user.active = True
            return True
        return False
914811
public void onActivate() {
		menu = new Menu();
		menu.addItem(new CancelMeasuringAction(this));
		Layer selectedLayer = mapWidget.getMapModel().getSelectedLayer();
		if (selectedLayer instanceof VectorLayer) {
			menu.addItem(new ToggleSnappingAction((VectorLayer) selectedLayer, this));
		}
		mapWidget.setContextMenu(menu);
	}
151261
def activate(self, engine):
        

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

        self.__ui_resources_directory = os.path.join(os.path.dirname(__file__), self.__ui_resources_directory)
        self.__engine = engine

        self.__settings = self.__engine.settings

        self.activated = True
        return True