/** * @brief FilterWidget::FilterWidget * @param parent */ FilterWidget::FilterWidget(QWidget *parent) : QWidget(parent), ui(new Ui::FilterWidget) { ui->setupUi(this); ui->lineEdit->setShowMagnifier(true); ui->lineEdit->addAdditionalStyleSheet("QLineEdit { border: 1px solid rgba(0, 0, 0, 100); border-radius: 10px; }"); ui->lineEdit->setType(MyLineEdit::TypeClear); ui->lineEdit->setAttribute(Qt::WA_MacShowFocusRect, false); m_list = new QListWidget(); m_list->setWindowFlags(Qt::WindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint)); m_list->setAttribute(Qt::WA_ShowWithoutActivating); m_activeWidget = WidgetMovies; QPalette palette = m_list->palette(); palette.setColor(QPalette::Highlight, palette.color(QPalette::Highlight)); palette.setColor(QPalette::HighlightedText, palette.color(QPalette::HighlightedText)); m_list->setPalette(palette); m_list->setStyleSheet(QString("background-color: transparent; border: 1px solid rgba(255, 255, 255, 200); border-radius: 5px;")); m_list->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); m_list->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); connect(ui->lineEdit, SIGNAL(textEdited(QString)), this, SLOT(onFilterTextChanged(QString))); connect(ui->lineEdit, SIGNAL(keyDown()), this, SLOT(onKeyDown())); connect(ui->lineEdit, SIGNAL(keyUp()), this, SLOT(onKeyUp())); connect(ui->lineEdit, SIGNAL(focusOut()), m_list, SLOT(hide())); connect(ui->lineEdit, SIGNAL(focusIn()), this, SLOT(setupFilters())); connect(ui->lineEdit, SIGNAL(returnPressed()), this, SLOT(addSelectedFilter())); connect(ui->lineEdit, SIGNAL(backspaceInFront()), this, SLOT(removeLastFilter())); connect(m_list, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(addFilterFromItem(QListWidgetItem*))); initFilters(); }
void Tile::keyPressEvent(QKeyEvent *event) { if (event->key() == Qt::Key_Escape || event->key() == Qt::Key_Q) { Quit(); } else if (event->key() == Qt::Key_S) { Shuffle(); } else if (event->key() == Qt::Key_R) { Reset(); } else if (event->key() == Qt::Key_H) { Help(); } else if (event->key() == Qt::Key_O) { Solve(); } else if (event->key() == Qt::Key_Up) { //focusNextChild(); //qDebug() << qApp->focusWidget(); QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget()); if (button) { keyUp(button); } } else if (event->key() == Qt::Key_Down) { //focusPreviousChild(); //qDebug() << qApp->focusWidget(); QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget()); if (button) { keyDown(button); } } else if( event->key() == Qt::Key_Return ) { QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget()); if (button) { button->click(); } } else { return; } }
void CInputEventsTranslator::activateKeyboardTranslation() { Messages::MessageType keyDown("KEYBOARD_KEYDOWN"); Messages::MessageType keyUp("KEYBOARD_KEYUP"); Messages::MessageType updateKeyboard("UPDATE_KEYBOARD"); DynamicObjectManager *dom = DynamicObjectManager::getInstancePtr(); shared_ptr< Gnoll::DynamicObject::DynamicObject > keyboardConfig = dom->load("keyboardConfig"); /** * How often will the keyboard module get updated (millisecond) */ unsigned long int period = 300; shared_ptr< Gnoll::DynamicObject::Integer > periodFromConfig = keyboardConfig->getAttribute< Gnoll::DynamicObject::Integer >("period"); period = *periodFromConfig; CMessageModule* messageModule = CMessageModule::getInstancePtr(); Messages::Messenger* messageManager = messageModule->getMessageManager(); keyboardEventsTranslator = shared_ptr<Messages::Listener> ( new CKeyboardEventsTranslator() ); keyboardEventsTrigger = shared_ptr<Messages::Listener> ( new CKeyboardEventsTrigger(static_pointer_cast<CKeyboardEventsTranslator>(keyboardEventsTranslator) )); keyboardStateTranslator = shared_ptr<Messages::Listener> ( new CKeyboardStateTranslator() ); try { /** * Continuous keyboard messages */ messageManager->addListener ( keyboardEventsTranslator, keyDown ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener installed" ); messageManager->addListener ( keyboardEventsTranslator, keyUp ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener installed" ); messageManager->addListener ( keyboardEventsTrigger, updateKeyboard ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTrigger listener installed" ); /** * State based keyboard messages */ messageManager->addListener ( keyboardStateTranslator, keyDown ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener installed" ); messageManager->addListener ( keyboardStateTranslator, keyUp ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener installed" ); } catch(...) { throw; } CTimeModule* timeModule = CTimeModule::getInstancePtr(); m_periodData = shared_ptr<boost::any> (new boost::any(period)) ; shared_ptr<CMessage> message (new CMessage(updateKeyboard, m_periodData )); timeModule->addPeriodicEvent(0, message, period); }
void PageComponent::base_keyUp( unsigned char inASCII ){ for( int i=0; i<mComponents.size(); i++ ) { PageComponent *c = *( mComponents.getElement( i ) ); if( c->isVisible() && c->isActive() ) { c->base_keyUp( inASCII ); } } keyUp( inASCII ); }
void Keyboard::update() { struct input_event e; while(read(fd, &e, sizeof(struct input_event)) == sizeof(struct input_event)) { if(e.type == 1 && e.value == 1) keyDown(e.code); if(e.type == 1 && e.value == 2) keyDown(e.code); //Key repeated if(e.type == 1 && e.value == 0) keyUp(e.code); } }
void Tile::keyUp(QPushButton *button) { int id = button->property("id").toInt(); QPushButton *button_up; if (id < 5) { button_up = idtoButton(id+12); } else { button_up = idtoButton(id-4); } if (button_up->isHidden()) { keyUp(button_up); } else { button_up->setFocus(); } }
bool Node::treeKeyUp( KeyEvent event ) { if(!mIsVisible) return false; // test children first, from top to bottom NodeList nodes(mChildren); NodeList::reverse_iterator itr; bool handled = false; for(itr=nodes.rbegin(); itr!=nodes.rend()&&!handled; ++itr) handled = (*itr)->treeKeyUp(event); // if not handled, test this node if(!handled) handled = keyUp(event); return handled; }
void processEvent(sf::Event& event) { switch(event.type) { case sf::Event::Closed: { window->close(); break; } case sf::Event::KeyPressed: { keyDown(event.key.code); break; } case sf::Event::KeyReleased: { keyUp(event.key.code); break; } } }
void processEvents() { static int lastMouseX = 0; static int lastMouseY = 0; SDL_Event event; SDL_Surface *screen; int videoFlags = DEFAULT_FLAGS; /* route all events to specific event handlers */ while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: quit(); break; case SDL_VIDEORESIZE: screen = SDL_SetVideoMode( event.resize.w, event.resize.h, DEFAULT_DEPTH, videoFlags ); eventReshape(screen->w, screen->h); break; case SDL_KEYDOWN: keyDown(event.key.keysym.sym); break; case SDL_KEYUP: keyUp(event.key.keysym.sym); break; case SDL_MOUSEBUTTONDOWN: mouseDown(event.button.button, 1, lastMouseX, lastMouseY); break; case SDL_MOUSEBUTTONUP: mouseDown(event.button.button, 0, lastMouseX, lastMouseY); break; case SDL_MOUSEMOTION: lastMouseX = event.motion.x; lastMouseY = event.motion.y; mouseMove(lastMouseX, lastMouseY); break; default: break; } } }
void event_sdl_keyup(int keysym, int keymod) { if (keysym == ConfigGetParamInt(g_CoreConfig, kbdStop)) { return; } else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdForward)) { main_set_fastforward(0); } else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdGameshark)) { KbdGamesharkPressed = 0; } else keyUp(keymod, keysym); }
void ArrowLineEdit::keyPressEvent( QKeyEvent * e ) { switch(e->key()){ case Key_Up: keyUp(e); return; case Key_Down: keyDown(e); return; case Key_Enter: case Key_Return: keyEnter(e); return; default: QLineEdit::keyPressEvent(e); } }
void Tile::keyPressEvent(QKeyEvent *event) { if (event->key() == Qt::Key_Escape || event->key() == Qt::Key_Q) { Quit(); } else if (event->key() == Qt::Key_Up) { //focusNextChild(); //qDebug() << qApp->focusWidget(); QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget()); keyUp(button); } else if (event->key() == Qt::Key_Down) { //focusPreviousChild(); //qDebug() << qApp->focusWidget(); QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget()); keyDown(button); } else { return; } }
void RawInputSystem::update(float delta) { PROFILE; MSG msg; while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); switch (msg.message) // RAW INPUT { case WM_INPUT: handleRawInput(msg); break; case WM_KEYDOWN: if (!(msg.lParam & 0x40000000)) // check the repeat count bit. keyDown(msg); break; case WM_KEYUP: keyUp(msg); break; } } POINT cursorPos; RECT windowRect; GetCursorPos(&cursorPos); GetWindowRect(windowHandle, &windowRect); int x = (int)cursorPos.x - windowRect.left; int y = (int)cursorPos.y - windowRect.top; if (lastX != x || lastY != y) { inputSystem->axisMove(MOUSE, float(x), float(y)); inputSystem->setCursorPositon(math::Vec2(float(x), float(y))); lastX = x; lastY = y; } }
/** * Handles application input. */ void BaseGame::pEvents() { SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_ESCAPE) { running = false; break; } keyDown(event.key.keysym.sym); break; case SDL_KEYUP: keyUp(event.key.keysym.sym); break; case SDL_QUIT: running = false; break; case SDL_VIDEORESIZE: screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, flags); resize(event.resize.w, event.resize.h); break; case SDL_MOUSEMOTION: mouseMotion(event.button.button, event.motion.x, event.motion.y); break; case SDL_MOUSEBUTTONUP: mouseBtnUp(event.button.button, event.motion.x, event.motion.y); break; case SDL_MOUSEBUTTONDOWN: mouseBtnDown(event.button.button, event.motion.x, event.motion.y); break; } } }
void CInputEventsTranslator::deactivateKeyboardTranslation() { Messages::MessageType keyDown("KEYBOARD_KEYDOWN"); Messages::MessageType keyUp("KEYBOARD_KEYUP"); Messages::MessageType updateKeyboard("UPDATE_KEYBOARD"); CMessageModule* messageModule = CMessageModule::getInstancePtr(); Messages::Messenger* messageManager = messageModule->getMessageManager(); try { /** * Continuous keybord messages */ messageManager->delListener ( keyboardEventsTranslator, keyDown ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener removed" ); messageManager->delListener ( keyboardEventsTranslator, keyUp ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener removed" ); messageManager->delListener ( keyboardEventsTrigger, updateKeyboard ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTrigger listener removed" ); /** * State based keyboard messages */ messageManager->delListener ( keyboardStateTranslator, keyDown ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener removed" ); messageManager->delListener ( keyboardStateTranslator, keyUp ); Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener removed" ); } catch(...) { throw; } CTimeModule* timeModule = CTimeModule::getInstancePtr(); shared_ptr<CMessage> message (new CMessage(updateKeyboard, m_periodData )); timeModule->delPeriodicEvent(0, message, boost::any_cast<unsigned long int> (*m_periodData) ); }
bool SliderKeyBind::saveXML(QDomDocument* doc, QDomElement* vc_root) { QDomElement root; QDomElement tag; QDomText text; QString str; Q_ASSERT(doc != NULL); Q_ASSERT(vc_root != NULL); /* SliderKeyBind entry */ root = doc->createElement(KXMLQLCSliderKeyBind); vc_root->appendChild(root); /* Up */ tag = doc->createElement(KXMLQLCSliderKeyBindKey); tag.setAttribute(KXMLQLCSliderKeyBindAction, KXMLQLCSliderKeyBindUp); root.appendChild(tag); /* Mod */ str.setNum(modUp()); tag.setAttribute(KXMLQLCSliderKeyBindModifier, str); /* Key */ str.setNum(keyUp()); text = doc->createTextNode(str); tag.appendChild(text); /* Down */ tag = doc->createElement(KXMLQLCSliderKeyBindKey); tag.setAttribute(KXMLQLCSliderKeyBindAction, KXMLQLCSliderKeyBindDown); /* Mod */ str.setNum(modDown()); tag.setAttribute(KXMLQLCSliderKeyBindModifier, str); /* Key */ str.setNum(keyDown()); text = doc->createTextNode(str); tag.appendChild(text); return true; }
void Display::receiveEvents() { SDL_Event event; while(SDL_PollEvent(&event)) { switch(event.type) { case SDL_KEYDOWN: keyDown(event.key.keysym.sym); break; case SDL_KEYUP: keyUp(event.key.keysym.sym); break; case SDL_QUIT: quit = true; break; } } }
void GameEngine::run(){ const int tickInterval = 1000/FPS; Uint32 nextTick; int delay; bool quit = false; while (!quit) { SDL_Event event; nextTick = SDL_GetTicks() + tickInterval; while( SDL_PollEvent( &event ) ){ switch( event.type ){ case SDL_QUIT: quit = true; break; case SDL_KEYDOWN: keyDown(event);break; case SDL_KEYUP: keyUp(event); break; } } SDL_FillRect(GE.screen,NULL,0X000000); for( unsigned int i=0; i<comps.size(); i++ ){ Komponent* other = comps[i]; for( unsigned int x=0; x<comps.size(); x++ ){ if(comps[x] != other){ if( comps[x]->getRect().overlaps(other->getRect() ) ) comps[x]->handleCollision(other); } } comps[i]->draw(); comps[i]->move(); //out of bounds grej //if(comps[i]->getRect().x<0-comps[i]->getRect().w || comps[i]->getRect().x>GE.screen->w+comps[i]->getRect().w ||comps[i]->getRect().y<0-comps[i]->getRect().h || comps[i]->getRect().y>GE.screen->h+comps[i]->getRect().h){ // comps.erase(comps.begin() + i); //} } delay = nextTick - SDL_GetTicks(); if( delay > 0 ) SDL_Delay( delay ); SDL_Flip(GE.screen); } }
LRESULT CALLBACK InputClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam) { switch (umsg) { case WM_KEYDOWN: keyDown(wparam); if (wparam == VK_ESCAPE) PostQuitMessage(0); break; case WM_KEYUP: keyUp(wparam); if (wparam == VK_ESCAPE) PostQuitMessage(0); default: { return DefWindowProc(hwnd, umsg, wparam, lparam); } } }
void processEvent(sf::Event& event) { switch(event.type) { case sf::Event::Closed: { window->close(); break; } case sf::Event::KeyPressed: { keyDown(event.key.code); break; } case sf::Event::KeyReleased: { keyUp(event.key.code); break; } case sf::Event::MouseButtonPressed: { mousePress(event.mouseButton.button, event.mouseButton.x, event.mouseButton.y); break; } } }
static int filter(const SDL_Event *event) { switch (event->type) { case SDL_KEYDOWN: switch (event->key.keysym.sym) { case SDLK_F5: savestates_job |= SAVESTATE; break; case SDLK_F7: savestates_job |= LOADSTATE; break; case SDLK_ESCAPE: stop_it(); break; case SDLK_F1: changeWindow(); break; default: keyDown(0, event->key.keysym.sym); } return 0; break; case SDL_KEYUP: switch (event->key.keysym.sym) { case SDLK_ESCAPE: break; case SDLK_F1: break; default: keyUp(0, event->key.keysym.sym); } return 0; break; default: return 1; } }
bool Input::keyPress(DWORD key) { //check for keydown if (keyDown(key)) { m_keyPressState[key] = 1; } //check for key reaching the keydown state if (m_keyPressState[key] == 1) { //check for key release if (keyUp(key)) m_keyPressState[key] = 2; } //check if key has been pressed and released if (m_keyPressState[key] == 2) { //reset the key status m_keyPressState[key] = 0; return true; } return false; }
LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) { switch(msg) { case WM_SIZE: swidth=LOWORD(lParam); sheight=HIWORD(lParam); resize(LOWORD(lParam),HIWORD(lParam)); releaseDIB(dibDC); initDIB(dibDC,LOWORD(lParam),HIWORD(lParam)); InvalidateRect(hWnd,NULL,FALSE); break; case WM_KEYDOWN: keyDown(wParam); break; case WM_KEYUP: keyUp(wParam); break; case WM_DESTROY: PostQuitMessage(0); break; case WM_QUERYNEWPALETTE: if(!hPalette) break; SelectPalette(hdc,hPalette,FALSE); RealizePalette(hdc); InvalidateRect(hWnd,NULL,FALSE); break; case WM_PALETTECHANGED: if(!hPalette||(HWND)wParam==hWnd) break; SelectPalette(hdc,hPalette,FALSE); RealizePalette(hdc); UpdateColors(hdc); break; default: return DefWindowProc(hWnd,msg,wParam,lParam); } return 0; }
int SDLApplication::run() { bool quit = false; SDL_Event event; m_totalTime = SDL_GetTicks(); while (!quit) { while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) quit = true; else if (event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_w) keyDown(KEY_MOVE_FORWARD); else if (event.key.keysym.sym == SDLK_DOWN || event.key.keysym.sym == SDLK_s) keyDown(KEY_MOVE_BACKWARD); else if (event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_a) keyDown(KEY_MOVE_LEFT); else if (event.key.keysym.sym == SDLK_RIGHT || event.key.keysym.sym == SDLK_d) keyDown(KEY_MOVE_RIGHT); else if (event.key.keysym.sym == SDLK_SPACE) keyDown(KEY_CONTINUE); break; case SDL_KEYUP: if (event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q) quit = true; else if (event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_w) keyUp(KEY_MOVE_FORWARD); else if (event.key.keysym.sym == SDLK_DOWN || event.key.keysym.sym == SDLK_s) keyUp(KEY_MOVE_BACKWARD); else if (event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_a) keyUp(KEY_MOVE_LEFT); else if (event.key.keysym.sym == SDLK_RIGHT || event.key.keysym.sym == SDLK_d) keyUp(KEY_MOVE_RIGHT); else if (event.key.keysym.sym == SDLK_RETURN) keyUp(KEY_RESET_1); else if (event.key.keysym.sym == SDLK_c) keyUp(KEY_RESET_2); else if (event.key.keysym.sym == SDLK_h) keyUp(KEY_HELP); else if (event.key.keysym.sym == SDLK_SPACE) keyUp(KEY_CONTINUE); break; case SDL_MOUSEBUTTONDOWN: // this is to avoid a "jump" of the mouse delta after the first movement after a mouse click SDL_WarpMouse(m_width/2, m_height/2); break; case SDL_MOUSEMOTION: if (event.button.button == SDL_BUTTON_LEFT) { int middleX = int(m_width/2); int middleY = int(m_height/2); if (middleX != event.motion.x || middleY != event.motion.y) { mouse(KEY_MOUSE_LEFT, middleX - event.motion.x, middleY - event.motion.y); SDL_WarpMouse(middleX, middleY); } } break; case SDL_VIDEORESIZE: { Uint8 bpp = m_surface->format->BitsPerPixel; Uint32 flags = m_surface->flags; SDL_FreeSurface(m_surface); m_surface = SDL_SetVideoMode(event.resize.w, event.resize.h, bpp, flags); window_resized(event.resize.w, event.resize.h); } break; case SDL_QUIT: quit = true; break; } } int currentTime = SDL_GetTicks(); float dt = float(currentTime - m_totalTime); if (!m_fixedTimeStep || dt >= m_targetElapsedTime * 1000) { m_totalTime = currentTime; if (dt > 0) update(dt); } draw(); SDL_GL_SwapBuffers(); } SDL_Quit(); return 0; }
ServerProxy::EResult ServerProxy::parseMessage(const UInt8* code) { if (memcmp(code, kMsgDMouseMove, 4) == 0) { mouseMove(); } else if (memcmp(code, kMsgDMouseRelMove, 4) == 0) { mouseRelativeMove(); } else if (memcmp(code, kMsgDMouseWheel, 4) == 0) { mouseWheel(); } else if (memcmp(code, kMsgDKeyDown, 4) == 0) { keyDown(); } else if (memcmp(code, kMsgDKeyUp, 4) == 0) { keyUp(); } else if (memcmp(code, kMsgDMouseDown, 4) == 0) { mouseDown(); } else if (memcmp(code, kMsgDMouseUp, 4) == 0) { mouseUp(); } else if (memcmp(code, kMsgDKeyRepeat, 4) == 0) { keyRepeat(); } else if (memcmp(code, kMsgCKeepAlive, 4) == 0) { // echo keep alives and reset alarm ProtocolUtil::writef(m_stream, kMsgCKeepAlive); resetKeepAliveAlarm(); } else if (memcmp(code, kMsgCNoop, 4) == 0) { // accept and discard no-op } else if (memcmp(code, kMsgCEnter, 4) == 0) { enter(); } else if (memcmp(code, kMsgCLeave, 4) == 0) { leave(); } else if (memcmp(code, kMsgCClipboard, 4) == 0) { grabClipboard(); } else if (memcmp(code, kMsgCScreenSaver, 4) == 0) { screensaver(); } else if (memcmp(code, kMsgQInfo, 4) == 0) { queryInfo(); } else if (memcmp(code, kMsgCInfoAck, 4) == 0) { infoAcknowledgment(); } else if (memcmp(code, kMsgDClipboard, 4) == 0) { setClipboard(); } else if (memcmp(code, kMsgCResetOptions, 4) == 0) { resetOptions(); } else if (memcmp(code, kMsgDSetOptions, 4) == 0) { setOptions(); } else if (memcmp(code, kMsgDFileTransfer, 4) == 0) { fileChunkReceived(); } else if (memcmp(code, kMsgDDragInfo, 4) == 0) { dragInfoReceived(); } else if (memcmp(code, kMsgCClose, 4) == 0) { // server wants us to hangup LOG((CLOG_DEBUG1 "recv close")); m_client->disconnect(NULL); return kDisconnect; } else if (memcmp(code, kMsgEBad, 4) == 0) { LOG((CLOG_ERR "server disconnected due to a protocol error")); m_client->disconnect("server reported a protocol error"); return kDisconnect; } else { return kUnknown; } // send a reply. this is intended to work around a delay when // running a linux server and an OS X (any BSD?) client. the // client waits to send an ACK (if the system control flag // net.inet.tcp.delayed_ack is 1) in hopes of piggybacking it // on a data packet. we provide that packet here. i don't // know why a delayed ACK should cause the server to wait since // TCP_NODELAY is enabled. ProtocolUtil::writef(m_stream, kMsgCNoop); return kOkay; }
// // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_ABOUT: DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About); break; case IDM_EXIT: DestroyWindow(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_CREATE: break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); { RECT cr; GetClientRect(hWnd, &cr); int width = cr.right - cr.left; int height = cr.bottom - cr.top; HDC bufDC; HBITMAP bufBMP; bufDC = CreateCompatibleDC(hdc); bufBMP = CreateCompatibleBitmap(hdc, width, height); SelectObject(bufDC, bufBMP); setPaintDC(bufDC); RECT r = {0}; r.right = width; r.bottom = height; FillRect(bufDC, &r, GetStockBrush(WHITE_BRUSH)); paint(); setPaintDC(NULL); BitBlt(hdc, 0, 0, width, height, bufDC, 0, 0, SRCCOPY); DeleteObject(bufBMP); DeleteDC(bufDC); } EndPaint(hWnd, &ps); break; case WM_MOUSEMOVE: { int x = GET_X_LPARAM(lParam); int y = GET_Y_LPARAM(lParam); mouseMove(x, y); } break; case WM_LBUTTONDOWN: SetCapture(hWnd); mouseDown(); break; case WM_LBUTTONUP: ReleaseCapture(); mouseUp(); break; case WM_KEYDOWN: { int vk = wParam; char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR); keyDown(ch, vk); } break; case WM_KEYUP: { int vk = wParam; char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR); keyUp(ch, vk); } break; case WM_TIMER: switch(wParam) { case IDT_TIMER0: timerTick(); break; } break; case WM_DESTROY: finalize(); PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; }
key AnalogKeypad::checkKeys() //returns the pressed key. { int keyValue = analogRead(KeyPin); if(keyValue > minDimUp && keyValue < maxDimUp) { bDimUp = true; keyDown(); } else { if(bDimUp) { bDimUp = false; if(iLongPress > 50) { returnValue = DimMax; } else { returnValue = DimUp; } keyUp(); return returnValue; } } if(keyValue > minDimDown && keyValue < maxDimDown) { bDimDown = true; keyDown(); } else { if(bDimDown) { bDimDown = false; if(iLongPress > 50) { returnValue = DimMin; } else { returnValue = DimDown; } keyUp(); return returnValue; } } if(keyValue > minOnOff && keyValue < maxOnOff) { bOnOff = true; keyDown(); } else { if(bOnOff) { bOnOff = false; if(iLongPress > 50) { returnValue = Debug; } else { returnValue = OnOff; } keyUp(); return returnValue; } } if(keyValue > minNext && keyValue < maxNext) { bNext = true; keyDown(); } else { if(bNext) { bNext = false; keyUp(); return Next; } } if(keyValue > minFaster && keyValue < maxFaster) { bFaster = true; keyDown(); } else { if(bFaster) { bFaster = false; if(iLongPress > 50) { returnValue = Fastest; } else { returnValue = Faster; } keyUp(); return returnValue; } } if(keyValue > minSlower && keyValue < maxSlower) { bSlower = true; keyDown(); } else { if(bSlower) { bSlower = false; if(iLongPress > 50) { returnValue = Slowest; } else returnValue = Slower; keyUp(); return returnValue; } } return None; }
void InputHandler::mouseUp(Uint8 btn, Uint16 /*x*/, Uint16 /*y*/) { keyUp(SDLKey(SDLK_LAST + btn)); }
void Util::processInput(bool scroll) { Common::Event event; Common::EventManager *eventMan = g_system->getEventManager(); int16 x = 0, y = 0; bool hasMove = false; _vm->_vidPlayer->updateLive(); while (eventMan->pollEvent(event)) { switch (event.type) { case Common::EVENT_MOUSEMOVE: hasMove = true; x = event.mouse.x; y = event.mouse.y; break; case Common::EVENT_LBUTTONDOWN: _mouseButtons = (MouseButtons) (((uint32) _mouseButtons) | ((uint32) kMouseButtonsLeft)); break; case Common::EVENT_RBUTTONDOWN: _mouseButtons = (MouseButtons) (((uint32) _mouseButtons) | ((uint32) kMouseButtonsRight)); break; case Common::EVENT_LBUTTONUP: _mouseButtons = (MouseButtons) (((uint32) _mouseButtons) & ~((uint32) kMouseButtonsLeft)); break; case Common::EVENT_RBUTTONUP: _mouseButtons = (MouseButtons) (((uint32) _mouseButtons) & ~((uint32) kMouseButtonsRight)); break; case Common::EVENT_KEYDOWN: keyDown(event); if (event.kbd.hasFlags(Common::KBD_CTRL)) { if (event.kbd.keycode == Common::KEYCODE_f) _fastMode ^= 1; else if (event.kbd.keycode == Common::KEYCODE_g) _fastMode ^= 2; else if (event.kbd.keycode == Common::KEYCODE_p) _vm->pauseGame(); else if (event.kbd.keycode == Common::KEYCODE_d) { _vm->getDebugger()->attach(); _vm->getDebugger()->onFrame(); } break; } addKeyToBuffer(event.kbd); break; case Common::EVENT_KEYUP: keyUp(event); break; default: break; } } _vm->_global->_speedFactor = MIN(_fastMode + 1, 3); if (hasMove && scroll) { x = CLIP(x, _vm->_global->_mouseMinX, _vm->_global->_mouseMaxX); y = CLIP(y, _vm->_global->_mouseMinY, _vm->_global->_mouseMaxY); x -= _vm->_video->_screenDeltaX; y -= _vm->_video->_screenDeltaY; _vm->_util->setMousePos(x, y); _vm->_game->wantScroll(x, y); // WORKAROUND: // Force a check of the mouse in order to fix the sofa bug. This apply only for Gob3, and only // in the impacted TOT file so that the second screen animation is not broken. if ((_vm->getGameType() == kGameTypeGob3) && _vm->isCurrentTot("EMAP1008.TOT")) _vm->_game->evaluateScroll(); } }
int main(int argc, char **argv) { ////////////////////////////////////////////////////////////////////// // check joystick ////////////////////////////////////////////////////////////////////// std::string commandNoJoystick = std::string(argv[0]) + " --no-joystick "; Herve::utilInfo("to disable joystick, use : ", commandNoJoystick.c_str() , __FILE__, __LINE__); if (argc == 2 and std::string(argv[1]) == "--no-joystick") gEnableJoystick = false; ////////////////////////////////////////////////////////////////////// // init ////////////////////////////////////////////////////////////////////// // display device gUptrDisplayDevice.reset(new HerveOvr::DisplayDeviceStereoOvr(1024, 1024)); if (not gUptrDisplayDevice->initDevice()) { gUptrDisplayDevice.reset(new Herve::DisplayDeviceMono()); //gUptrDisplayDevice.reset(new Herve::DisplayDeviceStereoFake(1024, 1024)); gUptrDisplayDevice->initDevice(); } // SDL if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 ) Herve::utilError("SDL_Init", "", __FILE__, __LINE__); const SDL_VideoInfo* info = SDL_GetVideoInfo(); int maxWidth = info->current_w; int maxHeight = info->current_h; SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); gPtrSurface = SDL_SetVideoMode( gUptrDisplayDevice->getWidth(), gUptrDisplayDevice->getHeight(), 24, SDL_OPENGL|SDL_RESIZABLE ); if( gPtrSurface == NULL ) Herve::utilError("SDL_SetVideoMode", "", __FILE__, __LINE__); atexit(SDL_Quit); SDL_EnableUNICODE( SDL_TRUE ); SDL_WM_SetCaption( "DemoSdl1", NULL ); // joysticks int nbJoysticks = SDL_NumJoysticks(); for(int i=0; i<nbJoysticks; i++) { SDL_Joystick * stick = SDL_JoystickOpen( i ); if( stick ) { Herve::utilInfo("joystick = ", SDL_JoystickName(i), __FILE__, __LINE__); } } // scene data gUptrDisplayDevice->initDisplay(maxWidth, maxHeight); gScene.init(gUptrDisplayDevice.get()); gFpsCounter.start(); Herve::utilInfo("width = ", std::to_string(gUptrDisplayDevice->getWidth()).c_str(), __FILE__, __LINE__); Herve::utilInfo("height = ", std::to_string(gUptrDisplayDevice->getHeight()).c_str(), __FILE__, __LINE__); Herve::utilInfo("maxWidth = ", std::to_string(gUptrDisplayDevice->getMaxWidth()).c_str(), __FILE__, __LINE__); Herve::utilInfo("maxHeight = ", std::to_string(gUptrDisplayDevice->getMaxHeight()).c_str(), __FILE__, __LINE__); ////////////////////////////////////////////////////////////////////// // main loop ////////////////////////////////////////////////////////////////////// SDL_Event event; while (true) { // handle events while( SDL_PollEvent( &event ) ) { switch(event.type) { case SDL_QUIT: exit(0); break; case SDL_KEYDOWN: keyDown(event.key); break; case SDL_KEYUP: keyUp(event.key); break; case SDL_MOUSEBUTTONUP : mouseUp(event.button); break; case SDL_MOUSEBUTTONDOWN : mouseDown(event.button); break; case SDL_MOUSEMOTION : mouseMotion(event.motion); break; case SDL_VIDEORESIZE : resize(event.resize); break; case SDL_JOYAXISMOTION : joyMotion(event.jaxis); break; } } updateCamera(); render(); } return 0; }