void device_io()
{
   if ( render_audio() && --scanDC == 0 )
   {
      scanDC = bufsPerScan;               // reload downcounter to next scan

      /* scan keys */

      if ( curKey >= 0 )
      {
         if ( ! readKey( curKey ) )
         {
            console.postKeyUp( curKey, 0 );
            scanKeys();
         }
      }
      else
          scanKeys();

      /* scan buttons */

      for ( byte i = 0; i < NumButs; i++ )
         scanBut(i);

      /* read next pot */

      readPot( nextPot );
      if ( ++nextPot >= NumPots )
         nextPot = 0;
   }
}

int main(void)
{
	videoSetMode(MODE_5_2D);	
	consoleDemoInit();
	scanKeys();
	int c = keysHeld();
	Sfondo();
	CreaPG();
	while(true) 
	{
		swiWaitForVBlank();			
		if(c!=0)
		{
			KeysPress(c);
			//iprintf("-key:%i\n",c);
			c = 0;
		}
		else 
		{//Nessun tasto premuto
			scanKeys();
			c = keysHeld();
		}
	}
	return 0;	
}

int main(void)  {

   consoleDemoInit();

   Keyboard *kbd = 	keyboardDemoInit();

   kbd->OnKeyPressed = OnKeyPressed;

   while(1) {
      char myName[256];

      iprintf("What is your name?\n");

      scanf("%s", myName);

      iprintf("\nHello %s", myName);

      scanKeys();
      while(!keysDown())scanKeys();

      swiWaitForVBlank();
      consoleClear();
   }

   return 0;
}

void waitfor(int keys)
{
	scanKeys();
	while((keysDown() & keys) == 0)
	{
		swiWaitForVBlank();
		scanKeys();
	}
}

void Menu::NX(int sock)
{
    int volume = 77;

    while(1) {
        consoleClear();
        iprintf("\n netxmms-nds\n ___________\n\n"
                " A     - PLAY\n"
                " B     - PAUSE\n"
                " Y     - STOP\n"
                " R     - NEXT\n"
                " L     - PREVIOUS\n"
                " <     - VOLUME-\n"
                " >     - VOLUME+\n\n"
                " VOLUME: %d%%", volume);

        while(1) {
            swiWaitForVBlank();

            scanKeys();

            int pressed = keysDown();
            int held = keysHeld();

            if(pressed & KEY_A) NX::Play(sock);
            if(pressed & KEY_B) NX::Pause(sock);
            if(pressed & KEY_Y) NX::Stop(sock);
            if(pressed & KEY_R) NX::Next(sock);
            if(pressed & KEY_L) NX::Previous(sock);
            if(pressed & KEY_LID) {
                int s = REG_POWERCNT;
                REG_POWERCNT = 0;

                while(1) {
                    scanKeys();
                    if(keysUp() & KEY_LID) {
                        REG_POWERCNT = s;
                        break;
                    }
                }
            }

            if(held & KEY_LEFT && volume > 0) {
                volume--;
                NX::Volume(sock, volume);
                break;
            }
            else if(held & KEY_RIGHT && volume < 100) {
                volume++;
                NX::Volume(sock, volume);
                break;
            }
        }
    }
}

	void Update()
	{
		//@NOTE: scanKeys() and keysDown() must only be called once per frame, never more

		scanKeys();

		gKeysPressed = gRawKeysPressed = keysDown();
		gKeysHeld = keysHeld();

		if (gKeysPressed & PauseKey)
		{
			gIsPaused = !gIsPaused;
		}

		gUnpauseOneFrame = false;
		if (gKeysPressed & UnpauseOneFrameKey)
		{
			gUnpauseOneFrame = true;
		}
		
		// Pause key only queryable via IsPaused()
		gKeysPressed &= (~PauseKey & ~UnpauseOneFrameKey);

		// When paused, for debugging purposes, it's useful to consider
		// held keys as pressed keys
		if (gIsPaused)
		{
			gKeysPressed |= gKeysHeld;
		}
	}

void input(){		//Fonction de test des touches
	touchPosition touchXY;
	do{
		scanKeys();
		if(keysHeld() & KEY_A)
			iprintf("\x1b[4;0HAppui A");		//Bouton A
		else if(keysHeld() & KEY_B)
			iprintf("\x1b[5;0HAppui B");		//Bouton B
		else if(keysHeld() & KEY_X)
			iprintf("\x1b[6;0HAppui X");		//Bouton X
		else if(keysHeld() & KEY_Y)
			iprintf("\x1b[7;0HAppui Y");		//Bouton Y
		else if(keysHeld() & KEY_L)
			iprintf("\x1b[8;0HAppui L");		//Bouton L
		else if(keysHeld() & KEY_R)
			iprintf("\x1b[9;0HAppui R");		//Bouton R
		else if(keysHeld() & KEY_START)
			iprintf("\x1b[10;0HAppui START");	//Bouton START
		else if(keysHeld() & KEY_SELECT)
			iprintf("\x1b[11;0HAppui SELECT");	//Bouton SELECT
		else{
			int i;					//Effaçage zone
			for(i=4;i<=11;i++){
				iprintf("\x1b[%u;0H            ",i);
			}
		}
		touchRead(&touchXY);
	}while((touchXY.px>=0x00)&&(touchXY.py>=0x00)&&(touchXY.py<0xB4)&&(touchXY.py<0xFF));
}

void updateInput(touchPosition * touch) {
    // Update the key registers with current values.
    scanKeys();

    // Update the touch screen values.
    touchRead(touch);
}

void Menu::Main()
{
    consoleClear();
    printf("\n netxmms-nds\n ___________\n\n"
           " A     - CONNECT\n"
           " B     - CONFIGURE\n\n"
           " START - INFORMATION");

    while(1) {
        swiWaitForVBlank();

        scanKeys();
        u32 entry = keysDown();

        if(entry & KEY_A) {
            Menu::ConnectWifi();
            return;
        }
        else if(entry & KEY_B) {
            Menu::Configuration();
            return;
        }
        else if(entry & KEY_START) {
            Menu::Information();
            return;
        }
    }
}

LevelId LevelSelector::select_level() {
	touchPosition stylus;

	level.set_current_level(level.get_level(selected_button).id);
	level.load();
	draw();

	while (true) {
		scanKeys();
		touchRead(&stylus);

		if (button_ok.update(stylus) == BUTTON_CLICKED) {
			return level.get_level(selected_button).id;
		}

		for (u8 current_button = 0; current_button < num_buttons; current_button++) {
			if (buttons[current_button]->update(stylus) == BUTTON_CLICKED) {
				u8 last_selected_button = selected_button;

				set_selected_level(level.get_level(current_button).id);

				buttons[last_selected_button]->draw();
				buttons[selected_button]->draw();

				level.set_current_level(level.get_level(selected_button).id);
				level.load();
				level.draw(LEVEL_X, LEVEL_Y);
			}
		}

		swiWaitForVBlank();
	}
}

void NDS_PumpEvents(_THIS)
{
	scanKeys();
	int i;
	SDL_keysym keysym;
	keysym.mod=KMOD_NONE;
	for(i=0;i<NDS_NUMKEYS;i++)
	{
		keysym.scancode=i;
		keysym.sym=keymap[i];
		if(keysHeld()&(1<<i) && !keymem[i])
		{
			keymem[i]=1;
			//printf("key released %d\n",i);
			SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
		}
		if(!(keysHeld()&(1<<i)) && keymem[i])
		{
			keymem[i]=0;
			//printf("key pressed %d\n",i);
			SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
		}
	}
	//touchPosition touch;
	//touch=touchReadXY();
	//if (touch.px!=0 || touch.py!=0)
	//	SDL_PrivateMouseMotion(SDL_PRESSED, 0, touch.px, touch.py);
}

//-----------------------------------------------------------------
// process input
//-----------------------------------------------------------------
void processInput( void )
//-----------------------------------------------------------------
{
	scanKeys();

	int keysh = keysHeld();
	// process user input
	if( keysh & KEY_UP )	  // check if UP is pressed
	{
		if ( g_ball.y == c_platform_level )
			g_ball.yvel = -y_tweak;
		else if ( (g_ball.yvel < 0) && (g_ball.y < 4 + c_platform_level) )
			g_ball.yvel -= y_tweak/14;
		
	}
	if( keysh & KEY_DOWN )	// check if DOWN is pressed
	{
		// tweak y velocity of ball
		g_ball.yvel += y_tweak;
	}
	if( keysh & KEY_LEFT )	// check if LEFT is pressed
	{
		// tweak x velocity
		g_ball.xvel -= x_tweak;
	}
	if( keysh & KEY_RIGHT )   // check if RIGHT is pressed
	{
		// tweak y velocity
		g_ball.xvel += x_tweak;
	}

}

/*
	DS_VBlank_IRQ

	Vertical blank interrupt callback.
*/
LOCALPROC DS_VBlank_IRQ(void)
{
	scanKeys();

	KeysHeld = keysHeld();

	if (++VBlankCounter == 60) {
		VBlankCounter = 0;
	}

	/*
		TODO:
		Rewrite this at some point, I'm not sure I like it.
	*/
	if (0 != (KeysHeld & KEY_LEFT)) {
		--CursorX;
	} else if (0 != (KeysHeld & KEY_RIGHT)) {
		++CursorX;
	}

	if (0 != (KeysHeld & KEY_UP)) {
		--CursorY;
	} else if (0 != (KeysHeld & KEY_DOWN)) {
		++CursorY;
	}

	CursorX = CursorX < 0 ? 0 : CursorX;
	CursorX = CursorX > vMacScreenWidth ? vMacScreenWidth : CursorX;

	CursorY = CursorY < 0 ? 0 : CursorY;
	CursorY = CursorY > vMacScreenHeight ? vMacScreenHeight : CursorY;

	DS_ScrollBackground();
	bgUpdate();
}

//---------------------------------------------------------------------------------
int main(void) {
//---------------------------------------------------------------------------------
	consoleDemoInit();  //setup the sub screen for printing

	keyboardDemoInit();

	keyboardShow();

	while(1) {
		
		int key = keyboardUpdate();

		if(key > 0)
			iprintf("%c", key);

		swiWaitForVBlank();
		scanKeys();

		int pressed = keysDown();

		if(pressed & KEY_START) break;
	}

	return 0;
}

/* Try to connect to given AP and get an IP via DHCP */
int connect_ap(Wifi_AccessPoint * ap)
{
	int ret;
	int status = ASSOCSTATUS_DISCONNECTED;

	clear_main();

	/* Ask for DHCP */
	Wifi_SetIP(0, 0, 0, 0, 0);
	ret = Wifi_ConnectAP(ap, WEPMODE_NONE, 0, NULL);
	if (ret) {
		print_to_debug("error connecting");
		return ASSOCSTATUS_CANNOTCONNECT;
	}

	while (status != ASSOCSTATUS_ASSOCIATED &&
	       status != ASSOCSTATUS_CANNOTCONNECT) {
		int oldStatus = status;

		status = Wifi_AssocStatus();
		if (oldStatus != status)
			printf_to_main("\n%s",
				       (char *)ASSOCSTATUS_STRINGS[status]);
		else
			printf_to_main(".");

		scanKeys();
		if (keysDown() & KEY_B)
			break;
		swiWaitForVBlank();
	}

	return status;
}

//---------------------------------------------------------------------------------
void waitButtonA() {
//---------------------------------------------------------------------------------
	while(1) {
		scanKeys();
		swiWaitForVBlank();
		if (keysDown() & KEY_A) break;
	}
}

int main() {
		
	// Setup the Main screen for 3D 
	videoSetMode(MODE_0_3D);
		
	// initialize the geometry engine
	glInit();
	
	// enable antialiasing
	glEnable(GL_ANTIALIAS);
	
	// setup the rear plane
	glClearColor(0,0,0,31); // BG must be opaque for AA to work
	glClearPolyID(63); // BG must have a unique polygon ID for AA to work
	glClearDepth(0x7FFF);
	
	// Set our viewport to be the same size as the screen
	glViewport(0,0,255,191);
	
	// setup the view
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(70, 256.0 / 192.0, 0.1, 100);
	
	
	//ds specific, several attributes can be set here	
	glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
	
	while (1) 
	{
		// Set the current matrix to be the model matrix
		glMatrixMode(GL_MODELVIEW);
		
		glColor3f(1, 1, 1);									// Set the color..not in nehe source...ds gl default will be black
		
		//Push our original Matrix onto the stack (save state)
		glPushMatrix();	

		DrawGLScene();
		
		// Pop our Matrix from the stack (restore state)
		glPopMatrix(1);

		//a handy little built in function to wait for a screen refresh
		swiWaitForVBlank();

		// flush to screen	
		glFlush(0);

		scanKeys();

		int pressed = keysDown();

		if(pressed & KEY_START) break;	
	}
	
	return 0;
}

int main()
{
//	REG_WAITCNT = 0x46d6; // lets set some cool waitstates...
	REG_WAITCNT = 0x46da; // lets set some cool waitstates...
	
	irqInit();
	irqEnable(IRQ_VBLANK);
	consoleInit(0, 4, 0, NULL, 0, 15);

	BG_COLORS[0] = RGB5(0, 0, 0);
	BG_COLORS[241] = RGB5(31, 31, 31);
	REG_DISPCNT = MODE_0 | BG0_ON;

	gbfs_init(1);
	
	pimp_sample_bank sb;
	FILE *fp = fopen("dxn-oopk.xm", "rb");
	if (!fp)
	{
		fprintf(stderr, "file not found\n");
		return 1;
	}
	pimp_module *mod = load_module_xm(fp, &sb);
	fclose(fp);
	fp = NULL;
	
	if (NULL == mod)
	{
		fprintf(stderr, "failed to load module\n");
		return 1;
	}

	pimp_gba_init(mod, sb.data);
	pimp_gba_set_callback(callback);

	irqSet(IRQ_TIMER3, timer3);
	irqEnable(IRQ_TIMER3);
	REG_TM3CNT_L = 0;
	REG_TM3CNT_H = TIMER_START | TIMER_IRQ | 2;
	
	irqSet(IRQ_VBLANK, vblank);
	irqEnable(IRQ_VBLANK);
	
	while (1)
	{
		VBlankIntrWait();
		scanKeys();
		int keys = keysDown();
		if (keys & KEY_UP)    pimp_gba_set_pos(0, pimp_gba_get_order() - 1);
		if (keys & KEY_DOWN)  pimp_gba_set_pos(0, pimp_gba_get_order() + 1);
		if (keys & KEY_RIGHT) pimp_gba_set_pos(pimp_gba_get_row() + 8, pimp_gba_get_order());
		if (keys & KEY_LEFT)  pimp_gba_set_pos(pimp_gba_get_row() - 8, pimp_gba_get_order());
		iprintf("%d %d\n", pimp_gba_get_order(), pimp_gba_get_row());
	}
	
	pimp_gba_close();
	return 0;
}

void update(){
	scanKeys();
	touchRead(&stylus);
	keyDown = keysDownRepeat();

	//Play::get_state()->run();
	
	swiWaitForVBlank();
}

void EventHandler::Update()
{
	scanKeys();

	touchRead(&m_touchPos);

	m_held = keysHeld();
	m_pressed = keysDown();
}