C++ setState函数代码示例

static void
setReadState (tr_handshake * handshake, handshake_state_t state)
{
  setState (handshake, state);
}

void StateChanger::onOff() {
  setState(1);
  sleep(1);
  setState(0);
  sleep(1);
}

void PlayField::placeBoat()
{
  setState(BOAT);
}

void UpdateStateRow::onDownloading(qint64 ready, qint64 total) {
	setState(State::Download);
	setDownloadProgress(ready, total);
}

void DetailsWidget::setExpanded(bool expanded)
{
    setState(expanded ? Expanded : Collapsed);
}

/*!
* Handle changes in RProperty values of keylock state and battery status.
* @param uid Category uid of the changed property.
* @param key Integer key of the changed property.
* @param value New value of the changed property.
*/
void CxuiApplicationFrameworkMonitorPrivate::handlePropertyEvent(long int uid, unsigned long int key, QVariant value)
{
    CX_DEBUG_ENTER_FUNCTION();

    if (uid == KPSUidAvkonDomain.iUid && key == KAknKeyguardStatus) {
        CX_DEBUG(("CxuiApplicationFrameworkMonitor - keylock status changed: %d -> %d", mKeyLockState, value.toInt()));

        // Check if the keylock value has actually changed
        const int newKeyLockState = value.toInt();
        if (newKeyLockState != mKeyLockState) {
            mKeyLockState = newKeyLockState;
            // Set foreground state based on keylock status and focused application info.
            setState(getCurrentState());
        }
    } else if (uid == KPSUidHWRMPowerState.iUid && key == KHWRMBatteryStatus ) {
        CX_DEBUG(("CxuiApplicationFrameworkMonitor - battery status changed: %d -> %d", mBatteryStatus, value.toInt() ));

        // If status changed, check if battery is going empty.
        const int newBatteryStatus = value.toInt();
        if (newBatteryStatus != mBatteryStatus) {
            mBatteryStatus = newBatteryStatus;

            // Notify that battery is almost empty,
            // need to stop any recordings etc.
            if(mBatteryStatus == EBatteryStatusEmpty) {
                emit q->batteryEmpty();
            }
        }
    } else if (uid == KPSUidUsbWatcher.iUid && key == KUsbWatcherSelectedPersonality) {
        CX_DEBUG(("CxuiApplicationFrameworkMonitor - usb personality changed: %d -> %d", mUsbPersonality, value.toInt()));

        const int newUsbPersonality(value.toInt());
        if (newUsbPersonality != mUsbPersonality) {
            // Check before saving the new state if mass memory mode was active,
            // so we know when to emit the unactivated signal.
            const bool wasUsbMassMemoryModeActive(isUsbMassMemoryModeActive());
            // Store new state.
            mUsbPersonality = newUsbPersonality;

            // Save state to log.
            if (mEventLog) {
                mEventLog->append(EVENT_USB, QString::number(mUsbPersonality));
            }

            // Check if mass memory mode activity changed.
            if (wasUsbMassMemoryModeActive != isUsbMassMemoryModeActive()) {

                // If the massmemory mode switched from on to off,
                // the signal is emitted immediately.
                // If the switch is from off to on, we need to use a timer
                // as a workaround because  plugging in the USB charger
                // sends a mass memory mode change event.
                if (wasUsbMassMemoryModeActive) {
                    emit q->usbMassMemoryModeToggled(isUsbMassMemoryModeActive());
                } else {
                    // (Re)starting the timer
                    mUsbModeCheckTimer.stop();
                    mUsbModeCheckTimer.start();
                }

            }
        }
    } else if (uid == TsProperty::KCategory.iUid && key == TsProperty::KVisibilityKey) {
        CX_DEBUG(("CxuiApplicationFrameworkMonitor - Task Manager visibility: %d -> %d", mTaskManagerVisibility, value.toBool()));
        const bool newTsVisibility(value.toBool());

        // If the task switcher state is changed, then emit signal to inform client(s).
        if (mTaskManagerVisibility != newTsVisibility) {
            mTaskManagerVisibility = newTsVisibility;
            emit q->taskSwitcherStateChanged(mTaskManagerVisibility);
        }
    }

    CX_DEBUG_EXIT_FUNCTION();
}

 inline void bind() { setState(STATE_GRAPHICS_BOUND); }

static int
readIA (tr_handshake    * handshake,
        struct evbuffer * inbuf)
{
  const size_t needlen = handshake->ia_len;
  struct evbuffer * outbuf;
  uint32_t crypto_select;

  dbgmsg (handshake, "reading IA... have %zu, need %zu",
          evbuffer_get_length (inbuf), needlen);
  if (evbuffer_get_length (inbuf) < needlen)
    return READ_LATER;

  /**
  ***  B->A: ENCRYPT (VC, crypto_select, len (padD), padD), ENCRYPT2 (Payload Stream)
  **/

  tr_cryptoEncryptInit (handshake->crypto);
  outbuf = evbuffer_new ();

  {
    /* send VC */
    uint8_t vc[VC_LENGTH];
    memset (vc, 0, VC_LENGTH);
    evbuffer_add (outbuf, vc, VC_LENGTH);
    dbgmsg (handshake, "sending vc");
  }

  /* send crypto_select */
  crypto_select = getCryptoSelect (handshake, handshake->crypto_provide);
  if (crypto_select)
    {
      dbgmsg (handshake, "selecting crypto mode '%d'", (int)crypto_select);
      evbuffer_add_uint32 (outbuf, crypto_select);
    }
  else
    {
      dbgmsg (handshake, "peer didn't offer an encryption mode we like.");
      evbuffer_free (outbuf);
      return tr_handshakeDone (handshake, false);
    }

  dbgmsg (handshake, "sending pad d");
  /* ENCRYPT (VC, crypto_provide, len (PadD), PadD
   * PadD is reserved for future extensions to the handshake...
   * standard practice at this time is for it to be zero-length */
  {
    const uint16_t len = 0;
    evbuffer_add_uint16 (outbuf, len);
  }

  /* maybe de-encrypt our connection */
  if (crypto_select == CRYPTO_PROVIDE_PLAINTEXT)
    {
      tr_peerIoWriteBuf (handshake->io, outbuf, false);
      tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_NONE);
    }

  dbgmsg (handshake, "sending handshake");
  /* send our handshake */
  {
    uint8_t msg[HANDSHAKE_SIZE];
    if (!buildHandshakeMessage (handshake, msg))
      return tr_handshakeDone (handshake, false);

    evbuffer_add (outbuf, msg, sizeof (msg));
    handshake->haveSentBitTorrentHandshake = 1;
  }

  /* send it out */
  tr_peerIoWriteBuf (handshake->io, outbuf, false);
  evbuffer_free (outbuf);

  /* now await the handshake */
  setState (handshake, AWAITING_PAYLOAD_STREAM);
  return READ_NOW;
}

void VtolBrakeFSM::Activate()
{
    memset(mBrakeData, 0, sizeof(VtolBrakeFSMData_T));
    mBrakeData->currentState = BRAKE_STATE_INACTIVE;
    setState(BRAKE_STATE_BRAKE, FSMBRAKESTATUS_STATEEXITREASON_NONE);
}

static int
readCryptoProvide (tr_handshake    * handshake,
                   struct evbuffer * inbuf)
{
  /* HASH ('req2', SKEY) xor HASH ('req3', S), ENCRYPT (VC, crypto_provide, len (PadC)) */

  int i;
  uint8_t vc_in[VC_LENGTH];
  uint8_t req2[SHA_DIGEST_LENGTH];
  uint8_t req3[SHA_DIGEST_LENGTH];
  uint8_t obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
  uint16_t padc_len = 0;
  uint32_t crypto_provide = 0;
  tr_torrent * tor;
  const size_t needlen = SHA_DIGEST_LENGTH /* HASH ('req1',s) */
                       + SHA_DIGEST_LENGTH /* HASH ('req2', SKEY) xor HASH ('req3', S) */
                       + VC_LENGTH
                       + sizeof (crypto_provide)
                       + sizeof (padc_len);

  if (evbuffer_get_length (inbuf) < needlen)
    return READ_LATER;

  /* TODO: confirm they sent HASH ('req1',S) here? */
  evbuffer_drain (inbuf, SHA_DIGEST_LENGTH);

  /* This next piece is HASH ('req2', SKEY) xor HASH ('req3', S) ...
   * we can get the first half of that (the obufscatedTorrentHash)
   * by building the latter and xor'ing it with what the peer sent us */
  dbgmsg (handshake, "reading obfuscated torrent hash...");
  evbuffer_remove (inbuf, req2, SHA_DIGEST_LENGTH);
  tr_sha1 (req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL);
  for (i=0; i<SHA_DIGEST_LENGTH; ++i)
    obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
  if ((tor = tr_torrentFindFromObfuscatedHash (handshake->session, obfuscatedTorrentHash)))
    {
      const bool clientIsSeed = tr_torrentIsSeed (tor);
      const bool peerIsSeed = tr_peerMgrPeerIsSeed (tor, tr_peerIoGetAddress (handshake->io, NULL));
      dbgmsg (handshake, "got INCOMING connection's encrypted handshake for torrent [%s]", tr_torrentName (tor));
      tr_peerIoSetTorrentHash (handshake->io, tor->info.hash);

      if (clientIsSeed && peerIsSeed)
        {
          dbgmsg (handshake, "another seed tried to reconnect to us!");
          return tr_handshakeDone (handshake, false);
        }
    }
  else
    {
      dbgmsg (handshake, "can't find that torrent...");
      return tr_handshakeDone (handshake, false);
    }

  /* next part: ENCRYPT (VC, crypto_provide, len (PadC), */

  tr_cryptoDecryptInit (handshake->crypto);

  tr_peerIoReadBytes (handshake->io, inbuf, vc_in, VC_LENGTH);

  tr_peerIoReadUint32 (handshake->io, inbuf, &crypto_provide);
  handshake->crypto_provide = crypto_provide;
  dbgmsg (handshake, "crypto_provide is %d", (int)crypto_provide);

  tr_peerIoReadUint16 (handshake->io, inbuf, &padc_len);
  dbgmsg (handshake, "padc is %d", (int)padc_len);
  handshake->pad_c_len = padc_len;
  setState (handshake, AWAITING_PAD_C);
  return READ_NOW;
}

static int
readHandshake (tr_handshake    * handshake,
               struct evbuffer * inbuf)
{
  uint8_t pstrlen;
  uint8_t pstr[20];
  uint8_t reserved[HANDSHAKE_FLAGS_LEN];
  uint8_t hash[SHA_DIGEST_LENGTH];

  dbgmsg (handshake, "payload: need %d, got %zu",
          INCOMING_HANDSHAKE_LEN, evbuffer_get_length (inbuf));

  if (evbuffer_get_length (inbuf) < INCOMING_HANDSHAKE_LEN)
    return READ_LATER;

  handshake->haveReadAnythingFromPeer = true;

  pstrlen = evbuffer_pullup (inbuf, 1)[0]; /* peek, don't read. We may be
                                              handing inbuf to AWAITING_YA */

  if (pstrlen == 19) /* unencrypted */
    {
      tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_NONE);

      if (handshake->encryptionMode == TR_ENCRYPTION_REQUIRED)
        {
          dbgmsg (handshake, "peer is unencrypted, and we're disallowing that");
          return tr_handshakeDone (handshake, false);
        }
    }
  else /* encrypted or corrupt */
    {
      tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_RC4);

      if (tr_peerIoIsIncoming (handshake->io))
        {
          dbgmsg (handshake, "I think peer is sending us an encrypted handshake...");
          setState (handshake, AWAITING_YA);
          return READ_NOW;
        }

      tr_cryptoDecrypt (handshake->crypto, 1, &pstrlen, &pstrlen);

      if (pstrlen != 19)
        {
          dbgmsg (handshake, "I think peer has sent us a corrupt handshake...");
          return tr_handshakeDone (handshake, false);
        }
    }

  evbuffer_drain (inbuf, 1);

  /* pstr (BitTorrent) */
  assert (pstrlen == 19);
  tr_peerIoReadBytes (handshake->io, inbuf, pstr, pstrlen);
  pstr[pstrlen] = '\0';
  if (memcmp (pstr, "BitTorrent protocol", 19))
    return tr_handshakeDone (handshake, false);

  /* reserved bytes */
  tr_peerIoReadBytes (handshake->io, inbuf, reserved, sizeof (reserved));

  /**
  *** Extensions
  **/

  tr_peerIoEnableDHT  (handshake->io, HANDSHAKE_HAS_DHT     (reserved));
  tr_peerIoEnableLTEP (handshake->io, HANDSHAKE_HAS_LTEP    (reserved));
  tr_peerIoEnableFEXT (handshake->io, HANDSHAKE_HAS_FASTEXT (reserved));

  /* torrent hash */
  tr_peerIoReadBytes (handshake->io, inbuf, hash, sizeof (hash));
  if (tr_peerIoIsIncoming (handshake->io))
    {
      if (!tr_torrentExists (handshake->session, hash))
        {
          dbgmsg (handshake, "peer is trying to connect to us for a torrent we don't have.");
          return tr_handshakeDone (handshake, false);
        }
      else
        {
          assert (!tr_peerIoHasTorrentHash (handshake->io));
          tr_peerIoSetTorrentHash (handshake->io, hash);
        }
    }
  else /* outgoing */
    {
      assert (tr_peerIoHasTorrentHash (handshake->io));

      if (memcmp (hash, tr_peerIoGetTorrentHash (handshake->io), SHA_DIGEST_LENGTH))
        {
          dbgmsg (handshake, "peer returned the wrong hash. wtf?");
          return tr_handshakeDone (handshake, false);
        }
    }

  /**
  ***  If it's an incoming message, we need to send a response handshake
  **/

//.........这里部分代码省略.........

static int
readYb (tr_handshake * handshake, struct evbuffer * inbuf)
{
  int isEncrypted;
  const uint8_t * secret;
  uint8_t yb[KEY_LEN];
  struct evbuffer * outbuf;
  size_t needlen = HANDSHAKE_NAME_LEN;

  if (evbuffer_get_length (inbuf) < needlen)
    return READ_LATER;

  isEncrypted = memcmp (evbuffer_pullup (inbuf, HANDSHAKE_NAME_LEN), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN);
  if (isEncrypted)
    {
      needlen = KEY_LEN;

      if (evbuffer_get_length (inbuf) < needlen)
        return READ_LATER;
    }

  dbgmsg (handshake, "got an %s handshake", (isEncrypted ? "encrypted" : "plain"));

  tr_peerIoSetEncryption (handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
                                                     : PEER_ENCRYPTION_NONE);
  if (!isEncrypted)
    {
      setState (handshake, AWAITING_HANDSHAKE);
      return READ_NOW;
    }

  handshake->haveReadAnythingFromPeer = true;

  /* compute the secret */
  evbuffer_remove (inbuf, yb, KEY_LEN);
  secret = tr_cryptoComputeSecret (handshake->crypto, yb);
  memcpy (handshake->mySecret, secret, KEY_LEN);

  /* now send these: HASH ('req1', S), HASH ('req2', SKEY) xor HASH ('req3', S),
   * ENCRYPT (VC, crypto_provide, len (PadC), PadC, len (IA)), ENCRYPT (IA) */
  outbuf = evbuffer_new ();

  /* HASH ('req1', S) */
  {
    uint8_t req1[SHA_DIGEST_LENGTH];
    tr_sha1 (req1, "req1", 4, secret, KEY_LEN, NULL);
    evbuffer_add (outbuf, req1, SHA_DIGEST_LENGTH);
  }

  /* HASH ('req2', SKEY) xor HASH ('req3', S) */
  {
    int i;
    uint8_t req2[SHA_DIGEST_LENGTH];
    uint8_t req3[SHA_DIGEST_LENGTH];
    uint8_t buf[SHA_DIGEST_LENGTH];

    tr_sha1 (req2, "req2", 4, tr_cryptoGetTorrentHash (handshake->crypto), SHA_DIGEST_LENGTH, NULL);
    tr_sha1 (req3, "req3", 4, secret, KEY_LEN, NULL);

    for (i=0; i<SHA_DIGEST_LENGTH; ++i)
      buf[i] = req2[i] ^ req3[i];

    evbuffer_add (outbuf, buf, SHA_DIGEST_LENGTH);
  }

  /* ENCRYPT (VC, crypto_provide, len (PadC), PadC
   * PadC is reserved for future extensions to the handshake...
   * standard practice at this time is for it to be zero-length */
  {
    uint8_t vc[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };

    tr_peerIoWriteBuf (handshake->io, outbuf, false);
    tr_cryptoEncryptInit (handshake->crypto);
    tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_RC4);

    evbuffer_add        (outbuf, vc, VC_LENGTH);
    evbuffer_add_uint32 (outbuf, getCryptoProvide (handshake));
    evbuffer_add_uint16 (outbuf, 0);
  }

  /* ENCRYPT len (IA)), ENCRYPT (IA) */
  {
    uint8_t msg[HANDSHAKE_SIZE];
    if (!buildHandshakeMessage (handshake, msg))
      return tr_handshakeDone (handshake, false);

    evbuffer_add_uint16 (outbuf, sizeof (msg));
    evbuffer_add        (outbuf, msg, sizeof (msg));

    handshake->haveSentBitTorrentHandshake = 1;
  }

  /* send it */
  tr_cryptoDecryptInit (handshake->crypto);
  setReadState (handshake, AWAITING_VC);
  tr_peerIoWriteBuf (handshake->io, outbuf, false);

  /* cleanup */
  evbuffer_free (outbuf);
  return READ_LATER;
//.........这里部分代码省略.........

	void Button::updateButtonState()
	{
		if (mIsStateCheck) {
			if (!mEnabled) { if (!setState("disabled_checked")) setState("disabled"); }
			else if (mIsMousePressed) { if (!setState("pushed_checked")) setState("pushed"); }
			else if (mIsMouseFocus) { if (!setState("highlighted_checked")) setState("pushed"); }
			else setState("normal_checked");
		}
		else {
			if (!mEnabled) setState("disabled");
			else if (mIsMousePressed) setState("pushed");
			else if (mIsMouseFocus) setState("highlighted");
			else setState("normal");
		}
	}

 inline void connect() { setState(STATE_CUDA_MAPPED); }

	void Player::logic(Room *room)
	{
		//std::cout << "HP:" << getHealth() << " MP:" << getMana() << "/" << getMaximumMana() << " Couter:" << mRegenerateManaCounter << std::endl;
		mStateCounter++;		

		if (mInvincibleCounter > 0) {
			mInvincibleCounter--;
		}

		if (getState() == DEAD) {
			return;
		}

		regenerateMana();
		
		const KeyState &keys = room->getKeyState();
		TileMap *tileMap = room->getTileMap();

		bool onIce = isOnIce(tileMap);

		int acceleration = AIR_ACCELERATION;
		if (getState() == GROUND) {
			if (onIce) {
				acceleration = ICE_ACCELERATION;
			} else {
				acceleration = GROUND_ACCELERATION;
			}
		}

		if (keys.isLeftHeld() && !keys.isRightHeld() && !mHurt) {
			mDX -= acceleration;
			if (mDX < -RUN_SPEED) {
				mDX = -RUN_SPEED;
			}
			mRunFrame += onIce && mDX > -20 ? 3 : 2;
			mFacingLeft = true;
			mRunning = true;
		} else if (!keys.isLeftHeld() && keys.isRightHeld() && !mHurt) {
			mDX += acceleration;
			if (mDX > RUN_SPEED) {
				mDX = RUN_SPEED;
			}
			mRunFrame += onIce && mDX < 20 ? 3 : 2;
			mFacingLeft = false;
			mRunning = true;
		} else if (mDX > 0 && !mHurt) {
			mDX -= onIce ? 1 : 4;
			if (mDX < 0) {
				mDX = 0;
			}
			mRunning = false;
		} else if (mDX < 0 && !mHurt) {
			mDX += onIce ? 1 : 4;
			if (mDX > 0) {
				mDX = 0;
			}
			mRunning = false;
		} else {
			mRunning = false;
		}

		// Crouching
		if (!mRunning && keys.isDownHeld() && getState() == GROUND) {
			if (!mCrouching) {
				mCrouching = true;
				mY += CROUCH_SHRINK;
				mH -= CROUCH_SHRINK;
			}
		} else if (mCrouching) {
			mCrouching = false;
			mY -= CROUCH_SHRINK;
			mH += CROUCH_SHRINK;
		}
		

		if (mDX == 0 || getState() != GROUND) {
			mRunFrame = 0;
		}

		// Interrupting jumping
		if (!keys.isJumpHeld() && getState() == AIR_UP && mDY > JUMP_CONTROL && !mHurt) {
			mDY = JUMP_CONTROL;
		}

		if (!keys.isJumpHeld() && (getState() == AIR_UP || getState() == AIR_DOWN)) {
			mJumpKeyHeld = false;
		}

		// Jumping
		if (keys.isJumpPressed() && getState() == GROUND && !keys.isDownHeld()) {
			mDY = JUMP_STRENGTH;
			setState(AIR_UP);
			mJumpKeyHeld = true;
			mJumpY = getCenterY();
		}
		// Drop off platform
		if (keys.isJumpPressed() && mOnPlatform && keys.isDownHeld()) {
			mDY = 1;
			mY++;
			setState(AIR_DOWN);
//.........这里部分代码省略.........