sets the active scene by scene ID
184177
def set_scene_active(self, scene_id):
        """"""
        if self.state.activeSceneId != scene_id: # do nothing if scene has not changed
            self._deactivate_scene()
            sequence_number = self.zmq_publisher.publish_active_scene(scene_id)
            self.state.activeSceneId = scene_id
            if self.state.mainswitch is True: # activate scene only if we are switched on
                self._activate_scene()
            logging.debug("Set scene {sceneNum} as active scene".format(sceneNum=scene_id))
            return (True, sequence_number, "OK")
        else:
            logging.debug("Scene {sceneNum} already is active scene".format(sceneNum=scene_id))
            return (False, 0, "This already is the activated scene.")
488614
private void updateCursorsInScene(GVRScene scene, boolean add) {
        synchronized (mCursors) {
            for (Cursor cursor : mCursors) {
                if (cursor.isActive()) {
                    if (add) {
                        addCursorToScene(cursor);
                    } else {
                        removeCursorFromScene(cursor);
                    }
                }
            }
        }
    }
588539
def setSceneRect( self, *args ):
        
        super(XChartScene, self).setSceneRect(*args)
        self._dirty = True
555927
def set_active_window_from_pane_id(self, pane_id):
        
        assert isinstance(pane_id, int)

        for w in self.windows:
            for p in w.panes:
                if p.pane_id == pane_id:
                    self.set_active_window(w)
667933
def _set_scene_transform(self, tr):
        
        # todo: check whether transform has changed, connect to
        # transform.changed event
        pre_tr = self.pre_transform
        if pre_tr is None:
            self._scene_transform = tr
        else:
            self._transform_cache.roll()
            self._scene_transform = self._transform_cache.get([pre_tr, tr])

        # Mark the transform dynamic so that it will not be collapsed with
        # others 
        self._scene_transform.dynamic = True
        
        # Update scene
        self._viewbox.scene.transform = self._scene_transform
        self._viewbox.update()

        # Apply same state to linked cameras, but prevent that camera
        # to return the favor
        for cam in self._linked_cameras:
            if cam is self._linked_cameras_no_update:
                continue
            try:
                cam._linked_cameras_no_update = self
                cam.set_state(self.get_state())
            finally:
                cam._linked_cameras_no_update = None
212032
function(context) {
      this._context = context;
      if (this.scenes) {
        _.each(this.scenes, function(scene) {
          scene.setContext(context);
        });
      }
    }
1115194
public void setScene(GVRScene scene)
    {
        for (GVRCursorController controller : controllers)
        {
            controller.setScene(scene);
            controller.invalidate();
        }
    }
1089153
def set_active(self, active):
        """"""
        url = CONST.AUTOMATION_EDIT_URL
        url = url.replace(
            '$AUTOMATIONID$', self.automation_id)

        self._automation['is_active'] = str(int(active))

        response = self._abode.send_request(
            method="put", url=url, data=self._automation)

        response_object = json.loads(response.text)

        if isinstance(response_object, (tuple, list)):
            response_object = response_object[0]

        if (str(response_object['id']) != str(self._automation['id']) or
                response_object['is_active'] != self._automation['is_active']):
            raise AbodeException((ERROR.INVALID_AUTOMATION_EDIT_RESPONSE))

        self.update(response_object)

        return True
1225709
def set_scene_config(self, scene_id, config):
        """"""
        if not scene_id in self.state.scenes: # does that scene_id exist?
            err_msg = "Requested to reconfigure scene {sceneNum}, which does not exist".format(sceneNum=scene_id)
            logging.info(err_msg)
            return(False, 0, err_msg)
        if scene_id == self.state.activeSceneId:
            pass  # TODO: maybe calculate next frame, esp. if static scene
        self.state.scenes[scene_id] = self.state.scenes[scene_id]._replace(config=config)
        sequence_number = self.zmq_publisher.publish_scene_config(scene_id, config)
        logging.debug("Reconfigured scene {sceneNum}".format(sceneNum=scene_id))
        return (True, sequence_number, "OK")
115035
async def add_shade_to_scene(self, shade_id, scene_id, position=None):
        """"""
        if position is None:
            _shade = await self.get_shade(shade_id)
            position = await _shade.get_current_position()

        await (SceneMembers(self.request)).create_scene_member(
            position, scene_id, shade_id
        )
817926
def setWorkingPlayAreaSize(self, sizeX, sizeZ):
        """"""

        fn = self.function_table.setWorkingPlayAreaSize
        fn(sizeX, sizeZ)
259592
function setActive() {
      for (var i = 0; i < this._n.length; i++) {
        this.addClass(this._n[i].children);
      }
    }
1066682
protected function set_active_styles() {
		$style = null;
		if ( ! empty( $this->struct['base_color'] ) ) {
			$style .= '.' . $this->id() . ' > .uix-control-input > .switch.active {background: ' . $this->struct['base_color'] . ';}';
		}

		if ( ! empty( $this->struct['off_color'] ) ) {
			$style .= '.' . $this->id() . '> .uix-control-input > .switch { background: ' . $this->struct['off_color'] . ';}';
		}

		uix_share()->set_active_styles( $style );

	}
1304312
def switch_to_frame_with_id(self, frame):
    """"""
    elem = world.browser.find_element_by_id(frame)
    world.browser.switch_to.frame(elem)
564629
def setSceneRect( self, *args ):
        
        h = self.height()
        super(XCalendarScene, self).setSceneRect(*args)
        if ( self.currentMode() != XCalendarScene.Mode.Month ):
            rect = self.sceneRect()
            rect.setHeight(h)
            super(XCalendarScene, self).setSceneRect(rect)
        
        self.markForRebuild()
1099233
public void setActive(boolean active) {
        if (this.active != active) {
            this.active = active;
            inviteListener.setActive(active);
            acceptListener.setActive(active);
            participants.clear();
            participants.add(self);
            participantListener.setActive(active);
        }
    }
103245
def add(self, scene):
        """"""
        if not isinstance(scene, Scene):
            raise TypeError()
        for i, j in enumerate(self.__scenes):
            if j.scene_id == scene.scene_id:
                self.__scenes[i] = scene
                return
        self.__scenes.append(scene)