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();
}

int
main( 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 thread
void 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();
	}
}