Sets whether or not this widget is in isolation mode.  When in 
        isolation, only the selected node and its direct connections will be
        displayed.
        
        :param      state | <bool>
167830
def setIsolationMode( self, state ):
        
        self._isolationMode = state
        self.updateIsolated(force = True)
        self.update()
179009
public synchronized boolean addStateChange(ConnectionState newConnectionState)
    {
        if ( state.get() != State.STARTED )
        {
            return false;
        }

        ConnectionState previousState = currentConnectionState;
        if ( previousState == newConnectionState )
        {
            return false;
        }
        currentConnectionState = newConnectionState;

        ConnectionState localState = newConnectionState;
        boolean isNegativeMessage = ((newConnectionState == ConnectionState.LOST) || (newConnectionState == ConnectionState.SUSPENDED) || (newConnectionState == ConnectionState.READ_ONLY));
        if ( !isNegativeMessage && initialConnectMessageSent.compareAndSet(false, true) )
        {
            localState = ConnectionState.CONNECTED;
        }

        postState(localState);

        return true;
    }
1294683
def setDirty(self, state=True):
        
        self._dirty = state

        # set if this connection should be visible
        if self._inputNode and self._outputNode:
            vis = self._inputNode.isVisible() and self._outputNode.isVisible()
            self.setVisible(vis)
1156394
def updateIsolated( self, force = False ):
        
        if ( not (self.isolationMode() or force) ):
            return
        
        # make sure all nodes are not being hidden because of isolation
        if ( not self.isolationMode() ):
            for node in self.nodes():
                node.setIsolateHidden(False)
            return
        
        # make sure all the nodes are visible or hidden based on the selection
        selected_nodes  = self.selectedNodes()
        isolated_nodes  = set(selected_nodes)
        connections     = self.connections()
        for connection in connections:
            in_node  = connection.inputNode()
            out_node = connection.outputNode()
            
            if ( in_node in selected_nodes or out_node in selected_nodes ):
                isolated_nodes.add(in_node)
                isolated_nodes.add(out_node)
        
        for node in self.nodes():
            node.setIsolateHidden(not node in isolated_nodes)
647532
@Override
    public void setState(RelayState state) {

        // apply the new pin state
        switch(state) {
            case OPEN: {
                if(!isOpen()) {
                    pin.setState(openState);
                }
                break;
            }
            case CLOSED: {
                if(!isClosed()) {
                    pin.setState(closedState);
                }
                break;
            }
            default: {
                throw new UnsupportedOperationException("Cannot set power state: " + state.toString());
            }
        }
    }
764132
def show_active_only(self, state):
        
        query = self._copy()
        query.active_only = state
        return query
229358
def set_state(self, onoff, channel=None):
        """"""
        try:
            onoff = bool(onoff)
        except Exception as err:
            LOG.debug("HelperActorState.set_state: Exception %s" % (err,))
            return False

        self.writeNodeData("STATE", onoff, channel)
1166691
def set_connection_state():
    """"""
    message = create(protobuf.ProtocolMessage.SET_CONNECTION_STATE_MESSAGE)
    message.inner().state = protobuf.SetConnectionStateMessage.Connected
    return message
698502
public static void setState(ParseState state) {

    if (state == null) {
      System.err.println("Null state found");
      Environment.logInfo("Null state found");
    }

    persData.setProperty(state.filename, state.firstLine + SEPARATOR + state.offset);
  }
333498
public int setState(boolean state, boolean bDisplayOption, int iMoveMode)
    {       // Must be overidden
        if (this.getNextConverter() != null)
            return this.getNextConverter().setState(state, bDisplayOption, iMoveMode);
        else
            return super.setState(state, bDisplayOption, iMoveMode);
    }
600263
def setShadowed(self, state):
        
        self._shadowed = state
        if state:
            self._colored = False
        
        for child in self.findChildren(XToolButton):
            child.setShadowed(state)
1214719
def annotate_states(node: ast.Node) -> None:
    
    w = TreeWalker()
    w.walk(StateAnnotator(node), node)
130414
def on_state_changed(self, state):
        
        if state:
            self.editor.key_pressed.connect(self._on_key_pressed)
            if self._highlight_caret:
                self.editor.cursorPositionChanged.connect(
                    self._highlight_caret_scope)
                self._block_nbr = -1
            self.editor.new_text_set.connect(self._clear_block_deco)
        else:
            self.editor.key_pressed.disconnect(self._on_key_pressed)
            if self._highlight_caret:
                self.editor.cursorPositionChanged.disconnect(
                    self._highlight_caret_scope)
                self._block_nbr = -1
            self.editor.new_text_set.disconnect(self._clear_block_deco)
39239
def state(self, states=None):
        
        if states is None or not states:
            return self
        nodes = []
        for node in self.nodes:
            if any(state.lower() == node.state.lower() for state in states):
                nodes.append(node)
        self.nodes = nodes
        return self
238321
protected final void setState(int state) {

        String thisMethodName = "setState";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, Integer.toString(state));
        }

        _state = state;
        // 212263 - State changes promoted from debug to info

        // 227363 - Only use info for certain state changes. Other state changes
        // that are less interesting to users are kept as debug only. The rationale
        // for the split is as follows:
        // STATE_UNINITIALIZED => debug, because not interesting
        // STATE_INITIALIZING => debug, because trivial change
        // STATE_INITIALIZED => debug, limited interest
        // STATE_JOINING => debug, useful when DCS/HAM problems
        // STATE_JOINED => info, because hi-lites DCS/HAM problems
        // STATE_AUTOSTARTING => debug, not interesting
        // STATE_STARTING => info, need to know ME is trying to start
        // STATE_STARTED => info, essential knowledge
        // STATE_STOPPING => info, useful indication that ME is trying
        // STATE_STOPPING_MEMBER => info, useful cos only state on deactivate path
        // STATE_STOPPED => info, essential knowledge
        // STATE_DESTROYING => debug, limited interest
        // STATE_DESTROYED => debug, limited interest

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName);
        }
    }
303780
def set_state(self, state, speed=None):
        
        speed = speed or self.current_fan_speed()
        if state:
            desired_state = {"powered": state, "mode": speed}
        else:
            desired_state = {"powered": state}

        response = self.api_interface.set_device_state(self, {
            "desired_state": desired_state
        })

        self._update_state_from_response(response)
1348064
private void setState(FieldState state) {
        if (DEBUG)
            LOG.debug("{}:{} --> {}", _state, _fieldState, state);
        _fieldState = state;
    }