C++ Keyboard类代码示例

void Pointer::setFocus(Surface *surface, const QPointF &position)
{
    if (m_focusResource && m_focus != surface) {
        uint32_t serial = wl_display_next_serial(m_compositor->wl_display());
        send_leave(m_focusResource->handle, serial, m_focus->resource()->handle);
        wl_list_remove(&m_focusDestroyListener.listener.link);
        wl_list_init(&m_focusDestroyListener.listener.link);
    }

    Resource *resource = surface ? resourceMap().value(surface->resource()->client()) : 0;

    if (resource && (m_focus != surface || resource != m_focusResource)) {
        uint32_t serial = wl_display_next_serial(m_compositor->wl_display());
        Keyboard *keyboard = m_seat->keyboardDevice();
        if (keyboard) {
            wl_keyboard::Resource *kr = keyboard->resourceMap().value(surface->resource()->client());
            if (kr)
                keyboard->sendKeyModifiers(kr, serial);
        }
        send_enter(resource->handle, serial, surface->resource()->handle,
                   wl_fixed_from_double(position.x()), wl_fixed_from_double(position.y()));

        wl_signal_add(&surface->resource()->handle->destroy_signal, &m_focusDestroyListener.listener);
    }

    m_focusResource = resource;
    m_focus = surface;
}

void DisplayStateConfiguration( const Keyboard & keyboard )
{
  char orthogonalRegion = 'a';

  for ( Keyboard::state_iterator pLeafState = keyboard.state_begin();
    pLeafState != keyboard.state_end(); ++pLeafState )
  {
    std::cout << "Orthogonal region " << orthogonalRegion << ": ";

    const Keyboard::state_base_type * pState = &*pLeafState;

    while ( pState != 0 )
    {
      if ( pState != &*pLeafState )
      {
        std::cout << " -> ";
      }

      #ifdef BOOST_STATECHART_USE_NATIVE_RTTI
      std::cout << std::setw( 15 ) << typeid( *pState ).name();
      #else
      std::cout << std::setw( 15 ) <<
        pState->custom_dynamic_type_ptr< char >();
      #endif
      pState = pState->outer_state_ptr();
    }

    std::cout << "\n";
    ++orthogonalRegion;
  }

  std::cout << "\n";
}

/*----------------------------------------------------------------------------------------------*/
void *Keyboard_Thread(void *_arg)
{

	Keyboard *aKeyboard = pKeyboard;
	int32 key;

	while(grun)
	{
		key = getchar();

		fprintf(stderr,"%c\n",(char)key);

		if((char)key == 'Q')
		{
			grun = 0x0;
		}

		usleep(1000);

		aKeyboard->IncExecTic();
	}

	pthread_exit(0);

}

	virtual void onKeyDown(const Keyboard& k)
	{
		/* Recalling existing presets will show the changes in the html GUI */
		if (k.isNumber()) { // Recall preset
			presetHandler.recallPreset(k.keyAsNumber());
		}
	}

void main(){
	Keyboard k;
	clrscr();
	int key = k.GetKeyCode();
	switch(key){
		case ARROW_UP:
			cout<<"Up Arrow key";
			break;
		case ARROW_DOWN:
			cout<<"Down Arrow key";
			break;
		case ARROW_LEFT:
			cout<<"Left Arrow key";
			break;
		case ARROW_RIGHT:
			cout<<"Right Arrow key";
			break;
		case ALT_F4:
			cout<<"Alt + F4";
			break;
		default:
			cout<<"Code: "<<key<<"\nNot Arrow key";
			break;
	}
	if(k.IsSpecialKey())
		cout<<"\nSpecial Key!";
	else
		cout<<"\nNot a special key!";
	getch();
}

//-----------------------------------------------------------------------------------------------
void DeveloperConsole::CheckForLogHistoryMovement( const Keyboard& keyboard )
{
	if( keyboard.IsKeyPressedDownAndWasNotBefore( KEY_UP_ARROW ) )
	{
		if( m_consoleTextEntryPosition > 0 )
		{
			--m_consoleTextEntryPosition;
			m_commandPromptLine = m_consoleLogHistoryLines[ m_consoleTextEntryPosition ];
			m_cursorPosition = m_commandPromptLine.m_text.size();
		}
	}

	if( keyboard.IsKeyPressedDownAndWasNotBefore( KEY_DOWN_ARROW ) )
	{
		if( m_consoleTextEntryPosition < m_consoleLogHistoryLines.size() )
		{
			++m_consoleTextEntryPosition;

			if( m_consoleTextEntryPosition == m_consoleLogHistoryLines.size() )
			{
				m_commandPromptLine.m_text = "";
				m_cursorPosition = 0;
			}
			else
			{
				m_commandPromptLine = m_consoleLogHistoryLines[ m_consoleTextEntryPosition ];
				m_cursorPosition = m_commandPromptLine.m_text.size();
			}
		}
	}
}

		void InputProcessor::Enable(bool enable)
		{
			if (IsEnabled() == enable)
				return;

			Keyboard *keyboard = m_gameApp->GetKeyboard();
			Mouse *mouse = m_gameApp->GetMouse();
			Touchscreen *touchscreen = m_gameApp->GetTouchscreen();

			if (enable)
			{
				if (keyboard != NULL)
					keyboard->RegisterListener(this);
				if (mouse != NULL)
					mouse->RegisterListener(this);
				if (touchscreen != NULL)
					touchscreen->RegisterListener(this);
			}
			else
			{
				if (keyboard != NULL)
					keyboard->UnregisterListener(this);
				if (mouse != NULL)
					mouse->UnregisterListener(this);
				if (touchscreen != NULL)
					touchscreen->UnregisterListener(this);
			}

			m_enabled = enable;
		}

bool Application::OnUpdate()
{
	//System Update
	m_pMouse->Update();
	m_pKeyboard->Update();
	m_pCamera->Update();
	m_pGameTime->Update();

	//m_fRot += PI * GameTime::GetTimeElapsed();
	//m_pScene->SetRotateY(m_fRot);

	m_pScene->Update();

	if(m_pKeyboard->IsKeyPressed(KEY_1))
	{
		m_pParent->DetachChild(m_pChild);
	}
	else if(m_pKeyboard->IsKeyPressed(KEY_2))
	{
		m_pParent->AttachChild(m_pChild);
	}

	m_pChild->Update();

	DX11Camera::FreeLookCamera(m_pCamera,10.0f);
	//m_pCamera->LookAt(D3DXVECTOR3(0,0,0));

	

	//Window Update
	return m_pWindow->Tick();
}

void guessWords(Password* fh)
{
   Keyboard* kb = Keyboard::getKeyboard();
   int numLeft = fh->getNumberOfPasswordsLeft();
   while (numLeft > 1)  //terminate if the password has been identified, or there is no valid password (user entry error)
   {
      int best_guess_index = fh->bestGuess();

      String* best_guess_word = fh->getOriginalWord(best_guess_index);
      cout << "You should guess \"";
      best_guess_word->displayString();
      cout << "\" at index " << best_guess_index;
      cout << endl << endl;

      String* guess_str = kb->readString("Index of word in the original word list to guess (1-based): ");
      int guess = guess_str->a_to_i();
      delete guess_str;

      String* match_str = kb->readString("Number of character matches: ");
      int match = match_str->a_to_i();
      delete match_str;
      cout << endl;

      fh->guess(guess, match);  //1-based index of the guessed word and the number of character matches
      fh->displayViableWords();

      numLeft = fh->getNumberOfPasswordsLeft();
   }
}

		void sendkey(int32_t keycode, bool pressed)
		{
			if (focusedtextfield)
			{
				Keyboard::Keymapping mapping = keyboard.gettextmapping(keycode);

				switch (mapping.type)
				{
				case Keyboard::KT_ACTION:
					focusedtextfield->sendkey(Keyboard::KT_ACTION, mapping.action, pressed);
					break;
				case Keyboard::KT_LETTER:
					if (!pressed)
					{
						int8_t letter;
						if (keydown[keyboard.getshiftkeycode()])
							letter = static_cast<int8_t>(mapping.action);
						else
							letter = static_cast<int8_t>(mapping.action + 32);

						focusedtextfield->sendkey(Keyboard::KT_LETTER, letter, pressed);
					}
					break;
				case Keyboard::KT_NUMBER:
					focusedtextfield->sendkey(Keyboard::KT_NUMBER, mapping.action, pressed);
					break;
				}
			}
			else if (gamekeysenabled)
			{
				const Keyboard::Keymapping* mapping = keyboard.getmapping(keycode);

				if (!mapping)
					return;

				Keyboard::Keytype type = mapping->type;
				int32_t action = mapping->action;

				switch (type)
				{
				case Keyboard::KT_MENU:
					if (pressed)
					{
						addelementbykey(action);
					}
					break;
				case Keyboard::KT_ACTION:
				case Keyboard::KT_FACE:
				case Keyboard::KT_ITEM:
				case Keyboard::KT_SKILL:
					Gameplay::Stage::sendkey(type, action, pressed);
					break;
				}
			}

			keydown[keycode] = pressed;
		}

	virtual bool onKeyUp(const Keyboard &k) {
        if (k.ctrl() || k.alt() || k.meta()) {
			return true;
		}
//		if (!mApp->mPresetKeyboardActive) {
//			return true;
//		}
		switch(k.key()){
		case '1': mApp->release(0); return false;
		case '2': mApp->release(1); return false;
		case '3': mApp->release(2); return false;
		case '4': mApp->release(3); return false;
		case '5': mApp->release(4); return false;
		case '6': mApp->release(5); return false;
		case '7': mApp->release(6); return false;
		case '8': mApp->release(7); return false;
		case '9': mApp->release(8); return false;
		case '0': mApp->release(9); return false;
		case 'q': mApp->release(10); return false;
		case 'w': mApp->release(11); return false;
		case 'e': mApp->release(12); return false;
		case 'r': mApp->release(13); return false;
		case 't': mApp->release(14); return false;
		case 'y': mApp->release(15); return false;
		case 'u': mApp->release(16); return false;
		case 'i': mApp->release(17); return false;
		case 'o': mApp->release(18); return false;
		case 'p': mApp->release(19); return false;
		case 'a': mApp->release(20); return false;
		case 's': mApp->release(21); return false;
		case 'd': mApp->release(22); return false;
		case 'f': mApp->release(23); return false;
		case 'g': mApp->release(24); return false;
		case 'h': mApp->release(25); return false;
		case 'j': mApp->release(26); return false;
		case 'k': mApp->release(27); return false;
		case 'l': mApp->release(28); return false;
		case ';': mApp->release(29); return false;
		case 'z': mApp->release(30); return false;
		case 'x': mApp->release(31); return false;
		case 'c': mApp->release(32); return false;
		case 'v': mApp->release(33); return false;
		case 'b': mApp->release(34); return false;
		case 'n': mApp->release(35); return false;
		case 'm': mApp->release(36); return false;
		case ',': mApp->release(37); return false;
		case '.': mApp->release(38); return false;
		case '/': mApp->release(39); return false;
		default: break;
		}
		return true;
	}

void CALLBACK charPressed(wchar_t nChar, void* userContext)
{
	Keyboard *kb = Environment::instance()->getKeyboard(0);
	if (kb!=NULL)
	{
		int mods = getKeyMods();
		if (mods==Keyboard::KEYMOD_NONE && gLastKeyDown!=nChar)
		{
			kb->fireKeyDownEvent((wchar_t)nChar,Keyboard::KEY_UNKNOWN,(Keyboard::Modifiers)mods);
		}
	}
//	envDebugLog("charPressed: nChar=0x%x (%c)\n",nChar,nChar);
}

Keyboard *Seat::createKeyboard(QObject *parent)
{
    Q_ASSERT(isValid());
    Q_ASSERT(d->capabilityKeyboard);
    Keyboard *k = new Keyboard(parent);
    connect(this, &Seat::interfaceAboutToBeReleased, k, &Keyboard::release);
    connect(this, &Seat::interfaceAboutToBeDestroyed, k, &Keyboard::destroy);
    auto w = wl_seat_get_keyboard(d->seat);
    if (d->queue) {
        d->queue->addProxy(w);
    }
    k->setup(w);
    return k;
}

void Player::handleInput(Keyboard input)
{
    if (input.isDown(SDLK_w) && input.isDown(SDLK_s)) {
        this->mov_stop();
    } else
    if (input.isDown(SDLK_w)) {
        this->mov_forward();
    } else
    if (input.isDown(SDLK_s)) {
        this->mov_backward();
    } else {
        this->mov_stop();
    }

    if (input.isDown(SDLK_a) && input.isDown(SDLK_d)) {
        this->rot_stop();
    } else
    if (input.isDown(SDLK_a)) {
        this->rot_left();
    } else
    if (input.isDown(SDLK_d)) {
        this->rot_right();
    } else {
        this->rot_stop();
    }
}

VOID Simulator::run(VOID *arg)
{
   LOG_ENTERFN();

   m_pScn = Scenario::getInstance();
   m_pScn->init(Config::getInstance()->getScnFile());

   // Initialing the Display task to display session statistics on terminal
   Display *pDisp = Display::getInstance();
   pDisp->init();

   /* Creates UDP sockets for listing of gtp messages */
   LOG_DEBUG("Initializing Transport connections");
   if (ROK != initTransport())
   {
      LOG_FATAL("Initializing Transport connections");
      LOG_EXITVOID();
   }

   // Initialing the Keyboard to process user inputs
   Keyboard *pKb = Keyboard::getInstance();
   pKb->init();

   if (SCN_TYPE_INITIATING == m_pScn->getScnType())
   {
      TrafficTask *pTTask = new TrafficTask;
      if (pTTask == NULL)
      {
         LOG_ERROR("Traffic Task Init");
      }

      /* peer information is maintianed to managing sequence numbers
       * and ordering of message
       */
      IPEndPoint peer;
      peer.ipAddr = Config::getInstance()->getRemoteIpAddr();
      peer.port = Config::getInstance()->getRemoteGtpcPort();
      addPeerData(peer);
   }

   LOG_DEBUG("Generating Signalling traffic");
   startScheduler();

   pKb->abort();
   TaskMgr::deleteAllTasks();
   deletePeerTable();

   LOG_EXITVOID();
}