// // ISDL12KeyboardInputDevice::resume // // Sets the internal state to enable all input for this device. // // NOTE: SDL_EventState clears the SDL event queue so only call this after all // SDL events have been processed in all SDL input device instances. // void ISDL12KeyboardInputDevice::resume() { mActive = true; reset(); SDL_EventState(SDL_KEYDOWN, SDL_ENABLE); SDL_EventState(SDL_KEYUP, SDL_ENABLE); }
// // ISDL12InputSubsystem::ISDL12InputSubsystem // ISDL12InputSubsystem::ISDL12InputSubsystem() : IInputSubsystem(), mInputGrabbed(false) { // Initialize the joystick subsystem and open a joystick if use_joystick is enabled. -- Hyper_Eye SDL_InitSubSystem(SDL_INIT_JOYSTICK); // Tell SDL to ignore events from the input devices // IInputDevice constructors will enable these events when they're initialized. SDL_EventState(SDL_KEYDOWN, SDL_IGNORE); SDL_EventState(SDL_KEYUP, SDL_IGNORE); SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); SDL_EventState(SDL_JOYAXISMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYBALLMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYHATMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_JOYBUTTONUP, SDL_IGNORE); SDL_ShowCursor(false); grabInput(); }
int stick_init( int device_index ) { int cnt = 0; /* Initialize SDL with joystick support and event support (through video) */ if (SDL_Init(SDL_INIT_JOYSTICK|SDL_INIT_VIDEO) < 0) { printf("Could not initialize SDL: %s.\n", SDL_GetError()); exit(-1); } //Quit SDL at exit atexit(SDL_Quit); //Start the event handler, disable all but joystick events and quit handler SDL_EventState(SDL_ACTIVEEVENT,SDL_IGNORE); SDL_EventState(SDL_KEYDOWN,SDL_IGNORE); SDL_EventState(SDL_KEYUP,SDL_IGNORE); SDL_EventState(SDL_MOUSEMOTION,SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONDOWN,SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP,SDL_IGNORE); //SDL_EventState(SDL_JOYAXISMOTION,SDL_IGNORE); //SDL_EventState(SDL_JOYBALLMOTION,SDL_IGNORE); //SDL_EventState(SDL_JOYHATMOTION,SDL_IGNORE); //SDL_EventState(SDL_JOYBUTTONDOWN,SDL_IGNORE); //SDL_EventState(SDL_JOYBUTTONUP,SDL_IGNORE); SDL_EventState(SDL_VIDEORESIZE,SDL_IGNORE); SDL_EventState(SDL_VIDEOEXPOSE,SDL_IGNORE); //SDL_EventState(SDL_QUIT,SDL_IGNORE); SDL_EventState(SDL_USEREVENT,SDL_IGNORE); SDL_EventState(SDL_SYSWMEVENT,SDL_IGNORE); //Check there are actually joysticks attached if (!SDL_NumJoysticks()) { fprintf(stderr,"Error: No joysticks attached!\n"); SDL_Quit(); return(1); } /* test device_index, else look for a suitable device */ if (init_sdl_device(device_index) != 0) { printf("Failed to open joystick at SDL device index %d, attempting to find a suitable joystick...\n",device_index); for (cnt = 0; cnt < STICK_INPUT_DEV_MAX; cnt++) { if (init_sdl_device(cnt) == 0) break; } printf("Found an alternative device!\n"); } /* return 1 if no device found */ if (cnt == STICK_INPUT_DEV_MAX) { fprintf(stderr,"ERROR: no suitable joystick found [%s:%d]\n", __FILE__,__LINE__); SDL_Quit(); return(1); } return 0; }
Index::Index() { /** random **/ srand(time(0)); /** SDL **/ SDL_Init(SDL_INIT_VIDEO); SDL_WM_SetCaption("Snake by Ceytix",NULL); screen = SDL_SetVideoMode(750, 810, 32, SDL_HWSURFACE|SDL_DOUBLEBUF); indexPicture = IMG_Load("files/pictures/index.png"); levelChoicePicture = IMG_Load("files/pictures/levelchoice.png"); creditsPicture = IMG_Load("files/pictures/credits.png"); pos.x = 0; pos.y = 0; /** SDL Events **/ SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); SDL_EventState(SDL_KEYUP, SDL_IGNORE); /** Snake **/ game = new Snake(); }
/* * Turn off controller events */ int SDL_GameControllerEventState(int state) { #if SDL_EVENTS_DISABLED return SDL_IGNORE; #else const Uint32 event_list[] = { SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_CONTROLLERDEVICEREMAPPED, }; unsigned int i; switch (state) { case SDL_QUERY: state = SDL_IGNORE; for (i = 0; i < SDL_arraysize(event_list); ++i) { state = SDL_EventState(event_list[i], SDL_QUERY); if (state == SDL_ENABLE) { break; } } break; default: for (i = 0; i < SDL_arraysize(event_list); ++i) { SDL_EventState(event_list[i], state); } break; } return (state); #endif /* SDL_EVENTS_DISABLED */ }
static void initSDL(void) { //SDL initialisation if (SDL_Init(SDL_INIT_JOYSTICK) < 0 ) { printf("Could not initialize SDL(%s)\n", SDL_GetError()); fe_exit(); } atexit(SDL_Quit); keyssnes = SDL_GetKeyState(NULL); SDL_SetVideoMode(0, 0, 16, SDL_SWSURFACE); SDL_EventState(SDL_ACTIVEEVENT,SDL_IGNORE); SDL_EventState(SDL_SYSWMEVENT,SDL_IGNORE); SDL_EventState(SDL_VIDEORESIZE,SDL_IGNORE); SDL_EventState(SDL_USEREVENT,SDL_IGNORE); SDL_ShowCursor(SDL_DISABLE); joy[0] = SDL_JoystickOpen(0); if(joy[0]) { if(SDL_JoystickEventState(SDL_ENABLE) != SDL_ENABLE) { printf("Could not set joystick event state: %s\n", SDL_GetError()); fe_exit(); } } }
int SDL_JoystickEventState(int state) { #if SDL_EVENTS_DISABLED return SDL_DISABLE; #else const Uint32 event_list[] = { SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED }; unsigned int i; switch (state) { case SDL_QUERY: state = SDL_DISABLE; for (i = 0; i < SDL_arraysize(event_list); ++i) { state = SDL_EventState(event_list[i], SDL_QUERY); if (state == SDL_ENABLE) { break; } } break; default: for (i = 0; i < SDL_arraysize(event_list); ++i) { SDL_EventState(event_list[i], state); } break; } return (state); #endif /* SDL_EVENTS_DISABLED */ }
int main(int argc, char **argv) { int i, rc; SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER); SDL_EventState(SDL_KEYDOWN, SDL_ENABLE); SDL_EventState(SDL_QUIT, SDL_ENABLE); for (i = 1; i < argc; i++) { if (argv[i][0] == '-') { switch (argv[i][1]) { case 'h': usage(argc, argv); return 0; default: usage(argc, argv); return 1; } continue; } rc = mng_read(argv[i], argv[i], mng_callback); if (rc < 0) fprintf(stderr, "reading '%s' returned %d\n", argv[i], rc); } return 0; }
int SDL_JoystickEventState(int state) { #ifdef DISABLE_EVENTS return SDL_IGNORE; #else const Uint8 event_list[] = { SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, }; int i; switch (state) { case SDL_QUERY: state = SDL_IGNORE; for ( i=0; i<SDL_TABLESIZE(event_list); ++i ) { state = SDL_EventState(event_list[i],SDL_QUERY); if ( state == SDL_ENABLE ) { break; } } break; default: for ( i=0; i<SDL_TABLESIZE(event_list); ++i ) { SDL_EventState(event_list[i], state); } break; } return(state); #endif /* DISABLE_EVENTS */ }
int vo_sdl_init(void) { reinit = 0; if (!SDL_WasInit(SDL_INIT_VIDEO)) { // Unfortunately SDL_WINDOWID must be set at SDL_Init // and is ignored afterwards, thus it cannot work per-file. // Also, a value of 0 does not work for selecting the root window. if (WinID > 0) { char envstr[20]; snprintf(envstr, sizeof(envstr), "0x%"PRIx64, WinID); setenv("SDL_WINDOWID", envstr, 1); } if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) < 0) return 0; } // Setup Keyrepeats (500/30 are defaults) SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, 100 /*SDL_DEFAULT_REPEAT_INTERVAL*/); // Easiest way to get uppercase characters SDL_EnableUNICODE(1); // We don't want those in our event queue. SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE); SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE); SDL_EventState(SDL_USEREVENT, SDL_IGNORE); // Try to get a sensible default for fullscreen. get_screensize(); return 1; }
void MainMenu::optionsBackButtonClicked(Button* ) { getConfig()->save(); if( getConfig()->videoX != SDL_GetVideoSurface()->w || getConfig()->videoY != SDL_GetVideoSurface()->h) { if( getConfig()->restartOnChangeScreen ) { quitState = RESTART; running = false; } else { //SDL_IGNORE to avoid forth and back jumping resolution SDL_EventState(SDL_VIDEORESIZE, SDL_IGNORE); initVideo( getConfig()->videoX, getConfig()->videoY); currentMenu->resize(getConfig()->videoX, getConfig()->videoY); SDL_EventState(SDL_VIDEORESIZE, SDL_ENABLE); gotoMainMenu(); } } else if( currentLanguage != getConfig()->language ) { unsetenv("LINCITY_LANG"); quitState = RESTART; running = false; } else { gotoMainMenu(); } }
int init_SDL(void) { joy[0]=0; joy[1]=0; joy[2]=0; joy[3]=0; if (SDL_Init(SDL_INIT_JOYSTICK) < 0) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); return(0); } sdlscreen = SDL_SetVideoMode(0,0, 16, SDL_SWSURFACE); //We handle up to four joysticks if(SDL_NumJoysticks()) { int i; SDL_JoystickEventState(SDL_ENABLE); for(i=0;i<SDL_NumJoysticks();i++) { joy[i]=SDL_JoystickOpen(i); //Check for valid joystick, some keyboards //aren't SDL compatible if(joy[i]) { if (SDL_JoystickNumAxes(joy[i]) > 28) { SDL_JoystickClose(joy[i]); joy[i]=0; logoutput("Error detected invalid joystick/keyboard\n"); } else joyCount++; } } if(joy[0]) logoutput("Found %d joysticks\n",joyCount); } else joyCount=1; //sq frig number of players for keyboard //joyCount=2; SDL_EventState(SDL_ACTIVEEVENT,SDL_IGNORE); SDL_EventState(SDL_SYSWMEVENT,SDL_IGNORE); SDL_EventState(SDL_VIDEORESIZE,SDL_IGNORE); SDL_EventState(SDL_USEREVENT,SDL_IGNORE); SDL_ShowCursor(SDL_DISABLE); //Initialise dispmanx bcm_host_init(); //Clean exits, hopefully! atexit(exitfunc); return(1); }
Direction TBFE::runEngine() { frame_++; bool checkOnce=false; while(logic_.pollEvent() || !checkOnce) { SDL_Event currentSdlEvent=logic_.getEvent(); checkEvents(); //Normal KeyBoard Events if (currentSdlEvent.type==SDL_KEYDOWN && logic_.isEventNew()) { if (logic_.checkKeyDown(27)) { quit_=true; }; }; checkOnce=true; }; PositionI mapDimensions=Current_Map.getDimensions(); if (keyControl_==true) { logic_.playerMovement(Main_Player); }; renderWindow_.finalRender(true); if (frameRate_.GetTicks() > 1000) { frameRate_.Start(); time_++; int Minutes=time_-(time_/100)*100; if (Minutes>=60) { time_+=100-Minutes; }; if (time_>2400) { time_=0; }; frame_=0; if (!showMouse_ && (mousePosition_.X!=screenDimensions_.X/2 || mousePosition_.Y!=screenDimensions_.Y/2)) { SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_WarpMouse(mouseCenter_.X,mouseCenter_.Y); SDL_WM_GrabInput( SDL_GRAB_ON ); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); }; return SECOND; }; gameSpeed_=60/(frame_*1000/frameRate_.GetTicks()); if (gameSpeed_>3) { gameSpeed_=3; }; if (quit_==true) { return QUIT; }; return NORMAL; };
// // ISDL12MouseInputDevice::pause // // Sets the internal state to ignore all input for this device. // // NOTE: SDL_EventState clears the SDL event queue so only call this after all // SDL events have been processed in all SDL input device instances. // void ISDL12MouseInputDevice::pause() { mActive = false; SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); SDL_ShowCursor(true); }
void initkeyb(void) { SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_IGNORE); SDL_SetEventFilter(Handler); }
void CCursorHandler::centerCursor() { this->xpos = (screen->w / 2.) - (currentCursor->pos.w / 2.); this->ypos = (screen->h / 2.) - (currentCursor->pos.h / 2.); SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_WarpMouse(this->xpos, this->ypos); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); }
// // ISDL12MouseInputDevice::resume // // Sets the internal state to enable all input for this device. // // NOTE: SDL_EventState clears the SDL event queue so only call this after all // SDL events have been processed in all SDL input device instances. // void ISDL12MouseInputDevice::resume() { mActive = true; SDL_ShowCursor(false); reset(); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_ENABLE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_ENABLE); }
bool SDL2Window::initializeFramework() { arx_assert(s_mainWindow == NULL, "SDL only supports one window"); // TODO it supports multiple windows now! arx_assert(m_displayModes.empty()); const char * headerVersion = ARX_STR(SDL_MAJOR_VERSION) "." ARX_STR(SDL_MINOR_VERSION) "." ARX_STR(SDL_PATCHLEVEL); CrashHandler::setVariable("SDL version (headers)", headerVersion); if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) { LogError << "Failed to initialize SDL: " << SDL_GetError(); return false; } #ifdef ARX_DEBUG // No SDL, this is more annoying than helpful! #if defined(SIGINT) signal(SIGINT, SIG_DFL); #endif #if defined(SIGTERM) signal(SIGTERM, SIG_DFL); #endif #endif SDL_version ver; SDL_GetVersion(&ver); std::ostringstream runtimeVersion; runtimeVersion << int(ver.major) << '.' << int(ver.minor) << '.' << int(ver.patch); CrashHandler::setVariable("SDL version (runtime)", runtimeVersion.str()); LogInfo << "Using SDL " << runtimeVersion.str(); int ndisplays = SDL_GetNumVideoDisplays(); for(int display = 0; display < ndisplays; display++) { int modes = SDL_GetNumDisplayModes(display); for(int i = 0; i < modes; i++) { SDL_DisplayMode mode; if(SDL_GetDisplayMode(display, i, &mode) >= 0) { m_displayModes.push_back(Vec2i(mode.w, mode.h)); } } } std::sort(m_displayModes.begin(), m_displayModes.end()); m_displayModes.erase(std::unique(m_displayModes.begin(), m_displayModes.end()), m_displayModes.end()); s_mainWindow = this; SDL_SetEventFilter(eventFilter, NULL); SDL_EventState(SDL_WINDOWEVENT, SDL_ENABLE); SDL_EventState(SDL_QUIT, SDL_ENABLE); SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE); SDL_EventState(SDL_USEREVENT, SDL_IGNORE); return true; }
void CCursorHandler::centerCursor() { SDL_Surface *cursor = this->cursors[mode]->ourImages[number].bitmap; this->xpos = (screen->w / 2.) - (cursor->w / 2.); this->ypos = (screen->h / 2.) - (cursor->h / 2.); SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_WarpMouse(this->xpos, this->ypos); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); }
// // ISDL12JoystickInputDevice::pause // // Sets the internal state to ignore all input for this device. // // NOTE: SDL_EventState clears the SDL event queue so only call this after all // SDL events have been processed in all SDL input device instances. // void ISDL12JoystickInputDevice::pause() { mActive = false; SDL_EventState(SDL_JOYAXISMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYBALLMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYHATMOTION, SDL_IGNORE); SDL_EventState(SDL_JOYBUTTONDOWN, SDL_IGNORE); SDL_EventState(SDL_JOYBUTTONUP, SDL_IGNORE); }
int main(int argc, char *argv[]) { int i; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); SDL_assert(SDL_arraysize(cursorNames) == SDL_NUM_SYSTEM_CURSORS); /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { consumed = -1; } if (consumed < 0) { SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } if (!SDLTest_CommonInit(state)) { quit(2); } SDL_EventState(SDL_DROPFILE, SDL_ENABLE); SDL_EventState(SDL_DROPTEXT, SDL_ENABLE); for (i = 0; i < state->num_windows; ++i) { SDL_Renderer *renderer = state->renderers[i]; SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); } /* Main render loop */ done = 0; #ifdef __EMSCRIPTEN__ emscripten_set_main_loop(loop, 0, 1); #else while (!done) { loop(); } #endif SDL_FreeCursor(cursor); quit(0); /* keep the compiler happy ... */ return(0); }
// // ISDL12JoystickInputDevice::resume // // Sets the internal state to enable all input for this device. // // NOTE: SDL_EventState clears the SDL event queue so only call this after all // SDL events have been processed in all SDL input device instances. // void ISDL12JoystickInputDevice::resume() { mActive = true; reset(); SDL_EventState(SDL_JOYAXISMOTION, SDL_ENABLE); SDL_EventState(SDL_JOYBALLMOTION, SDL_ENABLE); SDL_EventState(SDL_JOYHATMOTION, SDL_ENABLE); SDL_EventState(SDL_JOYBUTTONDOWN, SDL_ENABLE); SDL_EventState(SDL_JOYBUTTONUP, SDL_ENABLE); }
void event_state_mouse(int state) { SDL_EventState(SDL_MOUSEMOTION, state); SDL_EventState(SDL_MOUSEBUTTONDOWN, state); SDL_EventState(SDL_MOUSEBUTTONUP, state); SDL_EventState(SDL_APPMOUSEFOCUS, state); if (state == SDL_IGNORE) SDL_ShowCursor(SDL_DISABLE); else SDL_ShowCursor(SDL_ENABLE); }
/** * \brief Global initializations. Must be called at the begining of your * program. */ void bear::input::system::initialize() { if ( !SDL_WasInit(SDL_INIT_VIDEO) ) if ( SDL_InitSubSystem(SDL_INIT_VIDEO) != 0 ) throw claw::exception( SDL_GetError() ); if ( SDL_InitSubSystem(SDL_INIT_JOYSTICK) != 0 ) throw claw::exception( SDL_GetError() ); #ifndef __ANDROID__ // Disable keyboard events on Android because SDL_TEXTINPUT makes the keyboard // visible. SDL_EventState( SDL_TEXTINPUT, SDL_ENABLE ); SDL_EventState( SDL_KEYDOWN, SDL_ENABLE ); #endif SDL_EventState( SDL_MOUSEBUTTONDOWN, SDL_ENABLE ); SDL_EventState( SDL_MOUSEBUTTONUP, SDL_ENABLE ); SDL_EventState( SDL_MOUSEWHEEL, SDL_ENABLE ); SDL_EventState( SDL_FINGERDOWN, SDL_ENABLE ); SDL_EventState( SDL_FINGERUP, SDL_ENABLE ); SDL_EventState( SDL_FINGERMOTION, SDL_ENABLE ); // force the creation of the instance get_instance().refresh(); } // system::initialize()
void Screen_Init(void) { SDL_ShowCursor(SDL_DISABLE); change_vidmode (); cursor = IMG_Load("cursor.png"); /* Configure some SDL stuff: */ SDL_WM_SetCaption(PROG_NAME, "Frontier"); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); SDL_EventState(SDL_MOUSEBUTTONDOWN, SDL_ENABLE); SDL_EventState(SDL_MOUSEBUTTONUP, SDL_ENABLE); }
void init_video_32(void) { /***************** DISPLAY INITIALISATION ******************/ if (SDL_Init (SDL_INIT_VIDEO) < 0) { fprintf (stderr, "SDL Init failed : %s\n", SDL_GetError ()); exit (1); } printf("SDL init Ok\n"); screen = SDL_SetVideoMode (resx, resy, 32, SCREENFLAG); if (screen == NULL) { fprintf (stderr, "Graphic mode is not available: %s\n", SDL_GetError ()); exit (1); } printf("SDL Setvideo mode Ok\n"); SDL_ShowCursor(0); SDL_EventState (SDL_ACTIVEEVENT, SDL_IGNORE); SDL_EventState (SDL_MOUSEMOTION, SDL_IGNORE); printf("SDL Event State Ok\n"); /***************************************************************/ /******************* COLOR COMPUTATION ********************/ /* random_palette(); */ /* printf("SDL set color Ok\n"); */ /****************** INDEX *************************************/ pitch = screen->pitch; printf ("Pitch : %i\n", pitch); pixel = ((unsigned char *) screen->pixels); #ifdef DEBUG printf("Screen address: %p\n", pixel); #endif bpp = screen->format->BytesPerPixel; #ifdef DEBUG printf ("Bytes per pixels: %i\n", bpp); #endif }
/** * Handle moving over the minimap. * Will change the camera center when mouse moved in mouse-moving mode * @param action Pointer to an action. * @param state State that the action handlers belong to. */ void MiniMapView::mouseOver(Action *action, State *state) { InteractiveSurface::mouseOver(action, state); if (isMouseScrolling && action->getDetails()->type == SDL_MOUSEMOTION) { isMouseScrolled = true; // Set the mouse cursor back SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE); SDL_WarpMouse(xBeforeMouseScrolling, yBeforeMouseScrolling); SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE); // Check the threshold if (!mouseMovedOverThreshold) { absMouseMoveX += action->getDetails()->motion.xrel; absMouseMoveY += action->getDetails()->motion.yrel; mouseMovedOverThreshold = ((std::abs(absMouseMoveX) > _battleGame->getScrollButtonPixelTolerancy()) || (std::abs(absMouseMoveY) > _battleGame->getScrollButtonPixelTolerancy())); } // Calculate the move mouseScrollX += action->getDetails()->motion.xrel * _battleGame->getScrollButtonInvertMode(); mouseScrollY += action->getDetails()->motion.yrel * _battleGame->getScrollButtonInvertMode(); int newX = posBeforeMouseScrolling.x + mouseScrollX / 3; int newY = posBeforeMouseScrolling.y + mouseScrollY / 3; // Keep the limits... if (newX < -1 || _camera->getMapLength() < newX) { mouseScrollX -= action->getDetails()->motion.xrel * _battleGame->getScrollButtonInvertMode(); newX = posBeforeMouseScrolling.x + mouseScrollX / 3; } if (newY < -1 || _camera->getMapWidth() < newY) { mouseScrollY -= action->getDetails()->motion.yrel * _battleGame->getScrollButtonInvertMode(); newY = posBeforeMouseScrolling.y + mouseScrollY / 3; } // Scrolling _camera->centerOnPosition(Position(newX,newY,_camera->getViewHeight())); _redraw = true; // We don't want to look the mouse-cursor jumping :) action->getDetails()->motion.x=xBeforeMouseScrolling; action->getDetails()->motion.y=yBeforeMouseScrolling; _game->getCursor()->handle(action); } }
void SDLVideo::doRender() { pictureFormat.res = VIDEO_RESOLUTION; pictureFormat.format = YUV420P; window = SDL_CreateWindow("Signals SDLVideo renderer", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, pictureFormat.res.width, pictureFormat.res.height, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); if (!window) throw error(format("Couldn't set create window: %s", SDL_GetError())); renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if (!renderer) { SDL_DestroyWindow(window); throw error(format("Couldn't set create renderer: %s", SDL_GetError())); } m_dataQueue.push(nullptr); //unlock the constructor createTexture(); SDL_EventState(SDL_KEYUP, SDL_IGNORE); //ignore key up events, they don't even get filtered m_NumFrames = 0; for(;;) { auto data = m_dataQueue.pop(); if(!data) break; if (!processOneFrame(data)) break; } SDL_DestroyTexture(texture); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); }
INLINE BOOL Input::Initialize() { Log(TAG "Initializing..."); BOOL r = this->Reset(); #if defined(WIN32) && defined(DEBUG) SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE); #endif MEMSET(parJoy, '\0', sizeof(parJoy)); SDL_InitSubSystem(SDL_INIT_JOYSTICK); iJoystickCount = SDL_NumJoysticks(); if (iJoystickCount) { SDL_JoystickEventState(SDL_ENABLE); Log(TAG "Joystick(s): "); for (u32 i = 0; i < iJoystickCount; i++) { parJoy[i] = SDL_JoystickOpen(i); if (parJoy[i]) { Log("Opened Joystick %d:", i); Log(TAG "\tName: %s", SDL_JoystickName(i)); Log(TAG "\t\tAxes: %d", SDL_JoystickNumAxes(parJoy[i])); Log(TAG "\t\tButtons: %d", SDL_JoystickNumButtons(parJoy[i])); Log(TAG "\t\tHats: %d", SDL_JoystickNumHats(parJoy[i])); Log(TAG "\t\tBalls: %d", SDL_JoystickNumBalls(parJoy[i])); } } } Log(TAG "Initialization completed."); return r; }
static mrb_value mrb_sdl2_input_event_state(mrb_state *mrb, mrb_value self) { mrb_int type, state; mrb_get_args(mrb, "ii", &type, &state); return mrb_fixnum_value(SDL_EventState(type, state)); }