自学教程：C++ HandleEvents函数代码示例

void PlatformDesktop::SingleLoop() {	if( mEventRecorder )		mEventRecorder->StartOfFrame( GetTime() );	HandleEvents();	poro_assert( GetApplication() );	poro_assert( mGraphics );	types::Double32 dt = mOneFrameShouldLast;	if( mFixedTimeStep == false )	{		static types::Double32 last_time_update_called = 0;		dt = (types::Double32)( GetUpTime() - last_time_update_called );		last_time_update_called = GetUpTime();	}	GetApplication()->Update( (types::Float32)(dt) );	mGraphics->BeginRendering();	GetApplication()->Draw(mGraphics);	mGraphics->EndRendering();	if( mEventRecorder )		mEventRecorder->EndOfFrame( GetTime() );}

void * CaptureUserInput(void * arg) {	int i;		GetMyDeviceType();	ReadDeviceKeyDB();		printf("sizeof(struct input_event) = %d/n", sizeof(struct input_event));	maxEventPlusOne = -1;				for (i=0; i<=MAX_INPUT_FILE_ID; i++) {				if (nKeyEntries[i] == 0) {			inputEvents[i] = -1;		} else {			inputEvents[i] = OpenInputDevice(i);			if (inputEvents[i] > maxEventPlusOne) maxEventPlusOne = inputEvents[i];		}	}	maxEventPlusOne++;			while (1) {		if (!HandleEvents()) break;	}	printf("Thread CaptureUserInput() exit./n");	for (i=0; i<=MAX_INPUT_FILE_ID; i++) {		CloseInputDevice(i);	}		return 0;}

void GameStateManager::Run(void){	Initialise();	while (m_running)	{		// If a new state is set to begin, set it now		if (m_preparedState)			InitialisePreparedState();		// Update static key states		KeyTools::UpdateStates();		// State's key press responses		m_currentState->OnKeys(SDL_GetKeyboardState(nullptr));		// Update State		m_currentState->OnUpdate(delta);		// Render State		m_currentState->OnRender();				HandleEvents();		delta = RegulateFrameRate();	}	delete this;}

 void Game::Run() {     const float TargetFps = 60.0f;     const float DelayTime = 1000.0f / TargetFps;          gameState = RUNNING;          while(gameState == RUNNING)     {         frameStart = SDL_GetTicks();                  HandleEvents();         Update();         Render();                           frameCount += 1;         frameTime = SDL_GetTicks() - frameStart;                  if(frameStart < DelayTime)         {             SDL_Delay((int)(DelayTime - frameTime));         }              }          Clean(); }

void Displayer::RenderLoop(){	InitWindow();			while (win->IsOpened() && !closed)	{		HandleEvents();					// Don't draw if disabled/minimised		if (!Displayer::drawingEnabled)			continue;				glMatrixMode(GL_PROJECTION);		glLoadIdentity();		glOrtho(0, win->GetWidth(), win->GetHeight(), 0, -1, 1);		glMatrixMode(GL_MODELVIEW);		glLoadIdentity();		glClearColor(0, 0, 0, 1);		glClear(GL_COLOR_BUFFER_BIT);		// Draw panels		controlPanel->Draw(*win, defaultFont);		DrawWorldPanel();					// Display and sleep		win->Display();		sf::Sleep(1.0f / refreshRate);	}}

void GameEngine::Start(){  int ticksPerFrame = (int)(1000.0 / FPS_TARGET + 0.5);  Uint32 nextSecond = SDL_GetTicks() + 1000;  int frames = 0;  Mix_Chunk *track = NULL;  int channel = 0;   _isRunning = true;  while (_isRunning)  {    _frameTimer.Mark();    HandleEvents();    Update();    Draw();    // If there is no music playing    if(Mix_Playing(channel) == 0)      // Play music      channel = Music(track);    if (_frameTimer.GetTicks() < ticksPerFrame)      SDL_Delay(ticksPerFrame - _frameTimer.GetTicks());    if (SDL_GetTicks() >= nextSecond)    {      nextSecond += 1000;      _currentFps = frames;      frames = 0;    }    ++frames;  }}

Word NewGameWindow(Word NewVidSize){	XSizeHints sizehints;			if (NewVidSize == VidSize)		return VidSize;		if (NewVidSize < 4) {		w = VidXs[NewVidSize];		h = VidYs[NewVidSize];		v = VidVs[NewVidSize];	} else {		fprintf(stderr, "Invalid Vid size: %d/n", NewVidSize);		exit(EXIT_FAILURE);	}	sizehints.min_width =  w;	sizehints.min_height = h;	sizehints.flags = PMinSize;	XSetWMNormalHints(dpy, win, &sizehints);	XResizeWindow(dpy, win, w, h);		SetAPalette(rBlackPal);	ClearTheScreen(BLACK);	BlastScreen();		VidSize = NewVidSize;		XSync(dpy, False);	glXWaitGL();	glXWaitX();	HandleEvents();		return VidSize;}

void GameEngine::Run(){    HandleWindowEvents();    HandleEvents();    Update();    Draw();}

intmain( int argc, char **argv ){    /* Save our program name - for error messages */	set_DeadPipe_handler(DeadPipe);    InitMyApp (CLASS_IDENT, argc, argv, NULL, NULL, 0 );	LinkAfterStepConfig();    set_signal_handler( SIGSEGV );    ConnectX( ASDefaultScr, 0 );    ConnectAfterStep (WINDOW_CONFIG_MASK |                      WINDOW_NAME_MASK |                      M_END_WINDOWLIST, 0);    Config = CreateIdentConfig ();    /* Request a list of all windows, while we load our config */    SendInfo ("Send_WindowList", 0);    LoadBaseConfig ( GetBaseOptions);	LoadColorScheme();	LoadConfig ("ident", GetOptions);    CheckConfigSanity();	ReloadASDatabase();	ReloadCategories(True);	if (MyArgs.src_window == 0)		MyArgs.src_window = get_target_window();	/* And at long last our main loop : */    HandleEvents();	return 0 ;}

void Application::Run() {    Initialize();    double tickCounter = 0;    int frames = 0;    clock_t t1 = clock();    clock_t t2;    while(!HandleEvents()) {        Update();        BeginDraw();        Draw();        EndDraw();        frames++;        t2 = clock();        clock_t diff = t2 - t1;        //Guarantee a maximum fps rate        double sleepInteval = (double)CLOCKS_PER_SEC / fps - diff;        if(sleepInteval > 0) {            usleep(1000000 * sleepInteval / CLOCKS_PER_SEC);            tickCounter += sleepInteval;        }        //Display FPS rate        tickCounter += diff;        if(tickCounter > CLOCKS_PER_SEC) {            _frameRate = frames;            tickCounter = 0;            frames = 0;        }        t1 = clock();    }}

void Sys_SendKeyEvents (void) {  // XEvent event; // bk001204 - unused  if (!screen)    return;  HandleEvents();}

void Map::Update(){	for (std::vector<Entity*>::iterator it = entities.begin(); it != entities.end();)	{		if ((*it)->active)			++it;		else {			delete *it;			it = entities.erase(it);		}	}	HandleCollision();	HandleEvents();	Entity* entity;	for (std::vector<Entity*>::iterator it = entities.begin(); it != entities.end(); ++it)	{		entity = (*it);		if (entity->OnScreen == false)			continue;		if (entity->GetLight() > 0 && ((int) entity->shape->GetCenterX() != (int) (entity->prevPos.x + entity->GetSize().x / 2.0) || (int) entity->shape->GetCenterY() != (int) (entity->prevPos.y + entity->GetSize().y / 2.0)))			lightDirty = true;	}	skyManager->Update();}

int main(int argc, char* argv[]){	SDL_Init(SDL_INIT_EVERYTHING);	atexit(SDL_Quit);	debugLogFile = fopen("stderr.txt", "wb");	{		char buffer[128];		const time_t raw(time(NULL));		const struct tm* local(localtime(&raw));		strftime(buffer, sizeof(buffer)-1, "%c/n", local);		LOG("%s", buffer);	}	if (!Initialise()) { exit(EXIT_FAILURE); }	unsigned int lastUpdate = 0;	while (!quit)	{		HandleEvents();		unsigned int now = SDL_GetTicks();		unsigned int elapsedMS = now - lastUpdate;		lastUpdate = now;		UpdateGame(elapsedMS);		RenderFrame();		Device::SwapBuffers();	}	return 0;}

void Game::Run(){	while (running)	{				//trap mouse curser in window		HWND hwnd;		hwnd = FindWindow(0,LPCWSTR("Pew"));		RECT r;		//top left coords		r.left = window.getPosition().x;		r.top = window.getPosition().y;		//bottom right coords		r.right = window.getPosition().x + window.getSize().x;		r.bottom = window.getPosition().y + window.getSize().y;		//clip mouse to window		GetWindowRect(hwnd, &r);		ClipCursor(&r);				//do the game stuff		Update();		HandleEvents();		Render();		Quit();			}}

int main(int argc, char *argv[]){  initialize();    srand(time(NULL));      SDL_Surface *screen;  screen = SDL_SetVideoMode(WIDTH, HEIGHT, DEPTH, SDL_SWSURFACE);    if ( screen == NULL )    {      fprintf(stderr, "Unable to set 640x480 video: %s/n", SDL_GetError());      exit(1);    }    //Main game loop  while(1)    {      //Check for end game conditions      if (!player.alive)	{ RenderFinal(screen, FALSE); }      else if (g_monsters == NULL)	{ RenderFinal(screen, TRUE); }	      UpdateState();      RenderState(screen);            HandleEvents();            usleep(50000);    }}

void * CaptureUserInput(void * arg) { 	int i;		__android_log_print(ANDROID_LOG_DEBUG, "Thread CaptureUserInput() ", "pre_getMyDeviceType");	GetMyDeviceType();	__android_log_print(ANDROID_LOG_DEBUG, "Thread CaptureUserInput() ", "pre_ReadDeviceKeyDB");	ReadDeviceKeyDB();		__android_log_print(ANDROID_LOG_DEBUG, "Thread CaptureUserInput() ", "post_ReadDeviceKeyDB");	printf("sizeof(struct input_event) = %d/n", sizeof(struct input_event));	maxEventPlusOne = -1;				char aLine[256];	for (i=0; i<=MAX_INPUT_FILE_ID; i++) {				sprintf(aLine, "i = %d", i);		if (nKeyEntries[i] == 0) {			inputEvents[i] = -1;		} else {			inputEvents[i] = OpenInputDevice(i);			if (inputEvents[i] > maxEventPlusOne) {				maxEventPlusOne = inputEvents[i];				sprintf(aLine, "NOT_EXPECTED: i = %d, inputEvents[i] (%d) > maxEventPlusOne = %d", 					i, inputEvents[i], maxEventPlusOne);				#ifdef TEST_INPUT				WriteUserInputLog("libpcap: b CaptureUserInput() nKeyEntries[i] != 0 ", aLine);				#endif			} 		}	}	maxEventPlusOne++;			while (1) {		if  (!HandleEvents()) { 		    #ifdef TEST_INPUT		    WriteUserInputLog("libpcap: After HandleEvents returns 0 in CaptureUserInput() ", 					"setting exitFlag = 3 and breaking from loop");		    #endif		    exitFlag = 3; 		    break; 		}		if (exitFlag == 4) { 		    #ifdef TEST_INPUT		    WriteUserInputLog("libpcap: After HandleEvents exitFlag is 4 ", 					"setting exitFlag = 3 and breaking from loop");		    #endif		    exitFlag = 3; 		    break; 		}	}	printf("Thread CaptureUserInput() exit./n");	__android_log_print(ANDROID_LOG_DEBUG, "Thread CaptureUserInput() exit", "EXIT");	printf("sizeof(struct input_event) = %d/n", sizeof(struct input_event));		for (i=0; i<=MAX_INPUT_FILE_ID; i++) {		CloseInputDevice(i);	}	CloseUserInputLog();	return 0;}

void BaseScene::RunFrame() {	FrameStart();	HandleEvents();	Update();	Render(screen);	SDL_Flip(screen);	FrameEnd();}

// internal routines, run by the posting threadvoid LinuxaioQueue::PostRequests() {    RequestPtr req;    io_event* events = new io_event[max_events_];    for ( ; ; ) // as long as thread is running    {        // might block until next request or message comes in        size_t num_currently_waiting_requests = num_waiting_requests_.wait();        // terminate if termination has been requested        if (post_thread_state_() == TERMINATING && num_currently_waiting_requests == 0)            break;        std::unique_lock<std::mutex> lock(waiting_mtx_);        if (!waiting_requests_.empty())        {            req = waiting_requests_.front();            waiting_requests_.pop_front();            lock.unlock();            // might block because too many requests are posted            num_free_events_.wait();            // polymorphic_downcast            while (!dynamic_cast<LinuxaioRequest*>(req.get())->post())            {                // post failed, so first handle events to make queues (more)                // empty, then try again.                // wait for at least one event to complete, no time limit                long num_events = syscall(SYS_io_getevents, context_, 1, max_events_, events, nullptr);                if (num_events < 0) {                    THRILL_THROW_ERRNO(IoError, "linuxaio_queue::post_requests"                                       " io_getevents() nr_events=" << num_events);                }                HandleEvents(events, num_events, false);            }            // request is finally posted            {                std::unique_lock<std::mutex> lock(posted_mtx_);                posted_requests_.push_back(req);                num_posted_requests_.signal();            }        }        else        {            lock.unlock();            // num_waiting_requests-- was premature, compensate for that            num_waiting_requests_.signal();        }    }    delete[] events;}

    int CSDL_ApplicationBase::Main(int argc, char *argv[]) {        while(m_bIsRunning) {            m_pKeystate = ::SDL_GetKeyState(NULL);            m_Modstate = ::SDL_GetModState();            HandleEvents();        }        return EXIT_SUCCESS;    }

void Game::RunGameLoop(){	while (window->isOpen())	{		HandleEvents();		Update();		Draw();	}}

void Sys_SendKeyEvents (void){#ifndef DEDICATED_ONLY	HandleEvents();#endif	// grab frame time 	sys_frame_time = Sys_Milliseconds();}

void VID_Finish (void){	vid_usevsync = vid_vsync.integer && !cls.timedemo && qglXSwapIntervalSGI;	switch(vid.renderpath)	{		case RENDERPATH_SOFT:			if(vidx11_shmevent >= 0) {				vidx11_ximage_pos = !vidx11_ximage_pos;				vid.softpixels = (unsigned int *) vidx11_ximage[vidx11_ximage_pos]->data;				DPSOFTRAST_SetRenderTargets(vid.width, vid.height, vid.softdepthpixels, vid.softpixels, NULL, NULL, NULL);				// save mouse motion so we can deal with it later				in_mouse_x = 0;				in_mouse_y = 0;				while(vidx11_shmwait)					HandleEvents();				in_mouse_x_save += in_mouse_x;				in_mouse_y_save += in_mouse_y;				in_mouse_x = 0;				in_mouse_y = 0;				++vidx11_shmwait;				XShmPutImage(vidx11_display, win, vidx11_gc, vidx11_ximage[!vidx11_ximage_pos], 0, 0, 0, 0, vid.width, vid.height, True);			} else {				// no buffer switching here, we just flush the renderer				DPSOFTRAST_Finish();				XPutImage(vidx11_display, win, vidx11_gc, vidx11_ximage[vidx11_ximage_pos], 0, 0, 0, 0, vid.width, vid.height);			}			break;		case RENDERPATH_GL11:		case RENDERPATH_GL13:		case RENDERPATH_GL20:		case RENDERPATH_GLES1:		case RENDERPATH_GLES2:			if (vid_usingvsync != vid_usevsync)			{				vid_usingvsync = vid_usevsync;				if (qglXSwapIntervalSGI && qglXSwapIntervalSGI (vid_usevsync))					Con_Print("glXSwapIntervalSGI didn't accept the vid_vsync change, it will take effect on next vid_restart (GLX_SGI_swap_control does not allow turning off vsync)/n");			}			if (!vid_hidden)			{				CHECKGLERROR				if (r_speeds.integer == 2 || gl_finish.integer)					GL_Finish();				qglXSwapBuffers(vidx11_display, win);CHECKGLERROR			}			break;		case RENDERPATH_D3D9:		case RENDERPATH_D3D10:		case RENDERPATH_D3D11:			break;	}

void InitGraphics(int argc, char *argv[]){    Dimension width, height;    XEvent event;    static String fallback_resources[] = {        "*xcheck*background: #e0e0e0",        "*xcheck*fontList: -*-helvetica-bold-r-normal--14-*-*-*-*-*-*-*",        "*xcheck*font: -*-helvetica-bold-r-normal--14-*-*-*-*-*-*-*",        "*xcheck*XmText.background:  #b0e0c0",        NULL,    };    XtSetLanguageProc(NULL,NULL,NULL);    toplevel = XtVaAppInitialize(        &app,"App-Class",        NULL,0,        &argc,argv,        fallback_resources,        NULL);    mainWidget = XtVaCreateManagedWidget("mw", xmMainWindowWidgetClass, toplevel, NULL);    dpy = XtDisplay(mainWidget);    gc = XCreateGC(dpy,DefaultRootWindow(dpy),(int)NULL,NULL);    XSetLineAttributes(dpy,gc,2,LineSolid,CapButt,JoinMiter);    colormap = CreateColorMap(mainWidget);    menubar = CreateMenuBar(mainWidget);    workwin = CreateWorkWin(mainWidget);    message = CreateMessage(mainWidget);    XtVaSetValues(mainWidget,        XmNcolormap,colormap,        XmNmenuBar,menubar,        XmNworkWindow,workwin,        XmNmessageWindow,message,        NULL);    XtRealizeWidget(toplevel);    do {        XtAppNextEvent(app,&event);        XtDispatchEvent(&event);    }    while(event.type != Expose);    XtVaGetValues(toplevel,XmNheight,&height,XmNwidth,&width,NULL);    XtVaSetValues(toplevel,        XmNwidth, width,        XmNheight, height,        XmNmaxWidth, width,        XmNmaxHeight, height,        XmNminWidth, width,        XmNminHeight, height,        XmNallowShellResize, False,        NULL);    HandleEvents();    strcpy(xval[0],"human");    strcpy(xval[1],"computer");    strcpy(xval[2],"10.0");}

int main(void){     const unsigned int serverPort = 0xC001;     DiagnosticsServerPtr server = createServer(serverPort);     if(NULL == server) {        error("Failed to create the server");}     /* Enter the eternal reactive event loop. */     for(;;){        HandleEvents();} }

void UpdateInputState(u32 port){	static char key = 0;	kcode[port]=0xFFFF;	rt[port]=0;	lt[port]=0;		HandleEvents(port);}

MainGame::MainGame(){    ConfigurationManager configManager(resourcePath() + "configuration.txt");        //if SDL fails, close program    if (SDL_Init(SDL_INIT_VIDEO)) throw std::logic_error("Failed to initialize SDL!  " + std::string(SDL_GetError()));    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);        if (configManager.GetItem<bool>("Multisampling"))    {        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, configManager.GetItem<int>("MultisampleBuffers"));        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, configManager.GetItem<int>("MultisampleSamples"));    }    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);    SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);        SDL_DisplayMode mode; SDL_GetCurrentDisplayMode(0, &mode);            Uint32 windowFlags = SDL_WINDOW_OPENGL;    size_t width = configManager.GetItem<float>("WindowWidth"), height = configManager.GetItem<float>("WindowHeight");    if (configManager.GetItem<bool>("Fullscreen"))    {//        width = mode.w; height = mode.h;        windowFlags|=SDL_WINDOW_FULLSCREEN_DESKTOP;    }            window = SDL_CreateWindow("Genetic Algorithm", 0, 0, width, height, windowFlags);    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);    SDL_GL_SetSwapInterval(1);    SDL_SetRelativeMouseMode(SDL_TRUE);    if (window==nullptr) throw std::logic_error("Window failed to be initialized");    SDL_GLContext context = SDL_GL_CreateContext(window);    if (context==nullptr) throw std::logic_error("SDL_GL could not be initialized!");        int cpuCount = SDL_GetCPUCount();            GLManager glManager(resourcePath() + "fragmentShader.glsl", resourcePath() + "vertexShader.glsl", configManager);    std::string fileLoc =resourcePath() + "performance.csv";    EvolutionSystem evolutionSystem(fileLoc, configManager, cpuCount);    Camera camera(configManager.GetItem<float>("WindowWidth"), configManager.GetItem<float>("WindowHeight"), configManager);        while (GameState!=GameState::EXIT)    {        Update(evolutionSystem);        camera.Update();        glManager.Programs[0].SetMatrix4("transformMatrix", glm::value_ptr(camera.GetTransformMatrix()));        Draw(evolutionSystem);        SDL_GL_SwapWindow(window);        HandleEvents(evolutionSystem,camera);    }}

void GameEngine::Update(MasterControl* Control){    Timer::Update();    HandleEvents(Control);    UpdateObjects();    if (CollisionTimer.IsTime()){        CollisionDetection();    }    if (RenderTimer.IsTime()){        Draw();    }}

int DoEvents(){	RSJ = 0;	if (HandleEvents()) {		if (keys[SC_B]) { /* Special */			return 'B';		}		return 1;	}	return 0;}

void Sys_SendKeyEvents (void){	XEvent event;	if (!dpy)		return;	HandleEvents();//	while (XCheckMaskEvent(dpy,KEY_MASK|MOUSE_MASK,&event))//		HandleEvent(&event);}