Blocks the signals for this widget and its sub-parts.
        
        :param      state | <bool>
499881
def blockSignals( self, state ):
        
        super(XUrlWidget, self).blockSignals(state)
        self._urlEdit.blockSignals(state)
        self._urlButton.blockSignals(state)
32348
def check_state(self, state):
        

        if state.addr == self.function.addr:
            arch = state.arch
            if self._check_arguments(arch, state):
                return True

        return False
110342
void halt (final boolean wait)
  {
    synchronized (m_aSigLock)
    {
      m_aHalted.set (true);

      if (m_bPaused)
      {
        m_aSigLock.notifyAll ();
      }
      else
      {
        signalSchedulingChange (0);
      }
    }

    if (wait)
    {
      boolean interrupted = false;
      try
      {
        while (true)
        {
          try
          {
            join ();
            break;
          }
          catch (final InterruptedException ex)
          {
            interrupted = true;
          }
        }
      }
      finally
      {
        if (interrupted)
        {
          Thread.currentThread ().interrupt ();
        }
      }
    }
  }
824340
void setState(final WidgetState.State state) {
        Log.d(TAG, "setState(%s): state is %s, setting to %s", mWidget.getName(), mState, state);
        if (state != mState) {
            final WidgetState.State nextState = getNextState(state);
            Log.d(TAG, "setState(%s): next state '%s'", mWidget.getName(), nextState);
            if (nextState != mState) {
                Log.d(TAG, "setState(%s): setting state to '%s'", mWidget.getName(), nextState);
                setCurrentState(false);
                mState = nextState;
                setCurrentState(true);
            }
        }
    }
1035229
def unblock_events(self):
        
        self._widget.blockSignals(False)
        self._widget.setUpdatesEnabled(True)
925947
def block_events(self):
        
        self._widget.blockSignals(True)
        self._widget.setUpdatesEnabled(False)
1058712
def _set_state(self, state):
        
        if state != self._association_state:
            self.__log_debug('- %s -> %s', self._association_state, state)
            self._association_state = state

        if state == self.State.ESTABLISHED:
            self.__state = 'connected'
            for channel in list(self._data_channels.values()):
                if channel.negotiated and channel.readyState != 'open':
                    channel._setReadyState('open')
            asyncio.ensure_future(self._data_channel_flush())
        elif state == self.State.CLOSED:
            self._t1_cancel()
            self._t2_cancel()
            self._t3_cancel()
            self.__state = 'closed'

            # close data channels
            for stream_id in list(self._data_channels.keys()):
                self._data_channel_closed(stream_id)

            # no more events will be emitted, so remove all event listeners
            # to facilitate garbage collection.
            self.remove_all_listeners()
677642
def block(self):
        '''
        
        '''
        st,output = _runcmd("/sbin/pfctl -aswitchyard -f -", self._rules)
        log_debug("Installing rules: {}".format(output))
313246
def blockSignal(self, signal, state):
        
        signal = nativestring(signal)
        if state:
            self._blockedSignals.setdefault(signal, 0)
            self._blockedSignals[signal] += 1
        else:
            val = self._blockedSignals.get(signal, 0)
            val -= 1
            if val > 0:
                self._blockedSignals[signal] = val
            elif val == 0:
                self._blockedSignals.pop(signal)
185373
def set_state(self, state):
        
        values = {"desired_state": {"locked": state}}
        response = self.api_interface.local_set_state(self, values)
        self._update_state_from_response(response)
497591
def block(self, *args, **kwargs):
        
        if not args and 'addr' not in kwargs:
            kwargs['addr'] = self.addr
        return self.project.factory.block(*args, backup_state=self, **kwargs)
872727
private void cancelSignals() {
        Iterator<String> keys = this.signals.keySet().iterator();
        while (keys.hasNext()) {
            cancelSignal(keys.next());
        }
    }
611026
def blockSignals(self, state):
        
        super(XRichTextEdit, self).blockSignals(state)
        self.uiEditTXT.blockSignals(state)
569492
def toggle_state(state)
      @states.select { |s, _| s == state }.each do |s, v|
        v[1] = !v[1]
        classify_state v
      end
    end
442113
def update_listen_state(state, interval = 0)
      if state == :cancel
        @listen_timer.cancel if @listen_timer
        @listen_timer = nil
        @listen_state = state
      elsif [:choose, :check, :connect, :long_poll, :wait].include?(state)
        @listen_checks = 0 if state == :check && @listen_state != :check
        @listen_state = state
        @listen_interval = interval
      else
        raise ArgumentError, "Invalid listen state: #{state.inspect}"
      end
      true
    end
670846
void addState(State<S, L> state) {
        ElementReference ref = states.referencedAdd(state);
        state.setBlockReference(ref);
        state.setBlock(this);
    }
584070
def on_connection_blocked(self, method_frame):
        
        LOGGER.warning('Connection blocked: %s', method_frame)
        self.state = self.STATE_BLOCKED
        if self.on_unavailable:
            self.on_unavailable(self)