void TestRollover(CuTest *tc) {
START_KEY_CAPTURE;
CuAssertIntEquals(tc, 0, active_layer);
SHOULDNOT_SEND;
key_press(5);//F or layer 1
VERIFY_DIDNOT_SEND;
CuAssertIntEquals(tc, 1, active_layer);
key_press(6);//0 or 1 depending on layer
EXPECT_SENT(3);
CuAssertIntEquals(tc, 0, active_layer);//layer already reset
key_release(5);
CuAssertIntEquals(tc, 0, active_layer);
key_release(6);
EXPECT_SENT(4);
VERIFY KEY(F);
THEN NOKEYS;
THEN KEY(0);
THEN NOKEYS;
}
void TestLayerLock(CuTest* tc)
{
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(7);//toggle layer to 1
CuAssertIntEquals(tc, 1, active_layer);
key_release(7);
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
key_press(6);//0 or 1 depending on layer
key_release(6);
SHOULDNOT_SEND;
key_press(7);//toggle layer to 0
CuAssertIntEquals(tc, 0, active_layer);
key_release(7);
CuAssertIntEquals(tc, 0, active_layer);
VERIFY_DIDNOT_SEND;
key_press(6);//0 or 1 depending on layer
key_release(6);
VERIFY KEY(1);
THEN NOKEYS;
THEN KEY(0);
THEN NOKEYS;
}
void TestLayerLockActsAsLayerShift(CuTest *tc) {
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(7);//;layer 1
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
make_dualrole_modifier_possible();//pretend enough time has passed
key_press(6);//0 or 1 depending on layer
key_release(6);
SHOULDNOT_SEND;
key_release(7);
CuAssertIntEquals(tc, 0, active_layer);
VERIFY_DIDNOT_SEND;
key_press(6);//0 or 1 depending on layer
key_release(6);
VERIFY KEY(1);
THEN NOKEYS;
THEN KEY(0);
THEN NOKEYS;
}
Input InputManager::get_input(){
static bool exit = false;
frame_text.resize(0);
SDL_Event evnt;
SDL_StartTextInput();
//Will keep looping until there are no more events to process
while (SDL_PollEvent(&evnt)) {
switch (evnt.type) {
case SDL_QUIT:
return Input::EXIT_REQUEST;
break;
case SDL_MOUSEMOTION:
set_mouse_coords((F32)evnt.motion.x, (F32)evnt.motion.y);
break;
case SDL_TEXTINPUT:
frame_text += evnt.text.text;
break;
case SDL_KEYDOWN:
key_press(evnt.key.keysym.sym , KEYBOARD);
break;
case SDL_KEYUP:
key_release(evnt.key.keysym.sym , KEYBOARD);
break;
case SDL_MOUSEBUTTONDOWN:
key_press(evnt.button.button , MOUSE);
break;
case SDL_MOUSEBUTTONUP:
key_release(evnt.button.button , MOUSE);
break;
case SDL_JOYBUTTONDOWN: /* Handle Joystick Button Presses */
key_press(evnt.jbutton.button , CONTROLLER);
break;
case SDL_JOYBUTTONUP: /* Handle Joystick Button Presses */
key_release(evnt.jbutton.button , CONTROLLER);
break;
case SDL_JOYAXISMOTION:
switch (evnt.jaxis.axis){
case 0: set_controller_axis_coord(&m_controller_LX_coords.x, evnt.jaxis.value); break;
case 1: set_controller_axis_coord(&m_controller_LX_coords.y, evnt.jaxis.value); break;
case 2: set_controller_axis_coord(&m_controller_RX_coords.x, evnt.jaxis.value); break;
case 3: set_controller_axis_coord(&m_controller_RX_coords.y, evnt.jaxis.value); break;
}
}
}
SDL_StopTextInput();
if (is_key_pressed(SDLK_ESCAPE,KEYBOARD))exit = !exit;
if(!exit)SDL_WarpMouseInWindow(m_window, WINDOW_WIDTH / 2.0f, WINDOW_HEIGHT / 2.0f);
return Input::OK;
}
void TestComplicated(CuTest *tc) {
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(5);//F or layer 1
VERIFY_DIDNOT_SEND;
CuAssertIntEquals(tc, 1, active_layer);
make_dualrole_modifier_possible();//pretend enough time has passed
key_press(0);//LSFT of LBRACKET
key_release(0);
CuAssertIntEquals(tc, 1, active_layer);
SHOULDNOT_SEND;
key_release(5);
VERIFY_DIDNOT_SEND;
CuAssertIntEquals(tc, 0, active_layer);
EXPECT_SENT(4);
VERIFY NOKEYS WITH(LSFT);
THEN NOKEYS NOMODS;
THEN KEY(LBRACKET);
THEN NOKEYS;
}
int main(void) {
init();
self_test();
restore_state();
while(1) {
key_press(&key1_lock, &PINA, KEY1, minus);
key_press(&key2_lock, &PINB, KEY2, plus);
render_leds();
};
};
void TestModifierTapRelease(CuTest *tc) {
START_KEY_CAPTURE;
key_press(4);//lshift or z
make_dualrole_modifier_possible();//pretend enough time has passed
key_press(0);
key_release(4);
key_release(0);
VERIFY NOKEYS WITH(LSFT);
THEN KEY(A) WITH(LSFT);
THEN KEY(A) NOMODS;
THEN NOKEYS NOMODS;
}
int main(void) {
uint8_t row, col, key_id;
init();
for(;;) {
_delay_ms(5); // Debouncing
for(col=0; col<NCOL; col++) {
*col_port[col] &= ~col_bit[col];
_delay_us(1);
for(row=0; row<NROW; row++) {
key_id = col*NROW+row;
if(!(*row_port[row] & row_bit[row])) {
if(!pressed[key_id])
key_press(key_id);
}
else if(pressed[key_id])
key_release(key_id);
}
*col_port[col] |= col_bit[col];
}
// OCR1B++; OCR1C++;
// TODO fixed keyboard leds. I disabled as I cannot test them
//PORTB = (PORTB & 0b00111111) | ((keyboard_leds << 5) & 0b11000000);
//DDRB = (DDRB & 0b00111111) | ((keyboard_leds << 5) & 0b11000000);
}
}
int main( int argc, char** argv )
{
kvs::glut::Application app( argc, argv );
kvs::glut::Screen screen( &app );
screen.show();
//Image読み込み
ReadBDML::BDMLData bdml(argv[1]);
ReadIPLab::IPLabList ipl_list;
ipl_list.read( argv[2] );
int tindex =30; //time指定
ReadIPLab::IPLab ipl = ipl_list.load( tindex );
int sindex =30; //z指定
kvs::ImageObject* image = GetImageObject( ipl, sindex );
kvs::ImageObject* object = GetImageObjectWithEdge( image, bdml, sindex, tindex );
delete image;
screen.registerObject( object );
// キーボード処理イベントを定義しスクリーンに登録する。【追加】
KeyPress key_press( ipl_list, ipl, bdml, tindex, sindex );
screen.addEvent( &key_press );
kvs::glut::Label label( &screen );
label.setTextColor( kvs::RGBColor::White() );
label.show();
PaintEvent paint_event( label, bdml, tindex, sindex );
screen.addEvent( &paint_event );
//screen.show();
return app.run();
}
void TestKey(CuTest* tc)
{
START_KEY_CAPTURE;
key_press(0);//A
key_release(0);
key_press(0);//A
key_release(0);
EXPECT_SENT(4);
VERIFY KEY(A);
THEN NOKEYS;
THEN KEY(A);
THEN NOKEYS;
}
int key_press_hook(int keycode, t_env *e)
{
key_press(&e->key, keycode);
if (keycode == KEY_ESC)
exit(EXIT_SUCCESS);
if (keycode == KEY_SPACEBAR)
e->hud[0].c++;
return (0);
}
void HistoryComboBox::focusOutEvent(QFocusEvent *e)
{
QKeyEvent key_press(QKeyEvent::KeyPress, Qt::Key_Return, Qt::NoModifier, QString(), false, 0 );
QApplication::sendEvent(this, &key_press);
QKeyEvent key_release(QKeyEvent::KeyRelease, Qt::Key_Return, Qt::NoModifier, QString(), false, 0 );
QApplication::sendEvent(this, &key_release);
QComboBox::focusOutEvent(e);
}
/** Process gui events and deliver them as required.
\todo This should probably limit how frequently it calls draw
render thread
*/
void sdl_master::process_events()
{
bool done = false;
SDL_MouseMotionEvent mouse_position;
mouse_position.state = 0;
mouse_position.x = 0;
mouse_position.y = 0;
add_draw_timer(50); //20 fps
SDL_Event event;
while(!done)
{
if (SDL_WaitEvent(&event))
{ //wait on an event
switch(event.type)
{ //Check event type
case SDL_USEREVENT:
switch (event.user.code)
{
case 0:
draw();
break;
default:
break;
}
break;
case SDL_MOUSEMOTION:
mouse_move(&mouse_position, &event.motion);
mouse_position = event.motion;
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mouse_click(&event.button);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
key_press(&event.key);
break;
case SDL_QUIT:
quit_request();
break;
case SDL_VIDEORESIZE: //User resized window
display = SDL_SetVideoMode(event.resize.w, event.resize.h, 16,
SDL_HWSURFACE | SDL_DOUBLEBUF); // Create new window
break;
}
}
done = check_users(done);
}
// int status;
// if (game_client[0] != 0)
// SDL_WaitThread(game_client[0], &status);
}
any_event make_key_press_event(QObject*, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* e = (QKeyEvent*) event;
// if (e->isAutoRepeat() && !auto_repeat_)
// return any_event();
return key_press(qt_key_to_dige_key(e->key()), e->isAutoRepeat());
}
return any_event();
}
void TestCancel(CuTest *tc) {
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(5);//F or layer 1
VERIFY_DIDNOT_SEND;
make_dualrole_tap_impossible();//pretend too much time has passed
SHOULDNOT_SEND;
key_release(5);
VERIFY_DIDNOT_SEND;
}
void TestModifierOrKeyCanMod(CuTest *tc) {
START_KEY_CAPTURE;
key_press(4);//shift or Z
make_dualrole_modifier_possible();//pretend enough time has passed
key_press(0);//A
key_release(0);
key_release(4);
key_press(0);//A
key_release(0);
EXPECT_SENT(6);
VERIFY NOKEYS WITH(LSFT);
THEN KEY(A) WITH(LSFT);
THEN NOKEYS WITH(LSFT);
THEN NOKEYS NOMODS;
THEN KEY(A) NOMODS;
THEN NOKEYS NOMODS;
}
void TestKeyModded(CuTest* tc)
{
START_KEY_CAPTURE;
key_press(3);//sD
key_release(3);
EXPECT_SENT(3);
VERIFY NOKEYS WITH(LSFT);
THEN KEY(D) WITH(LSFT);
THEN NOKEYS;
}
void TestLayerShiftOrKeyCanTap(CuTest *tc) {
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(5);//F or layer 1
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
key_release(5);
CuAssertIntEquals(tc, 0, active_layer);
key_press(0);
key_release(0);
CuAssertIntEquals(tc, 0, active_layer);
VERIFY KEY(F);
THEN NOKEYS;
THEN KEY(A);
THEN NOKEYS;
}
void TestModifierOrKeyCanTap(CuTest *tc) {
START_KEY_CAPTURE;
key_press(4);//shift or Z
key_release(4);
EXPECT_SENT(4);
VERIFY NOKEYS WITH(LSFT);
THEN NOKEYS NOMODS;
THEN KEY(Z) NOMODS;
THEN NOKEYS NOMODS;
}
void TestModifierTapModded(CuTest *tc) {
START_KEY_CAPTURE;
key_press(2);//rshift or )
key_release(2);
EXPECT_SENT(5);
VERIFY NOKEYS WITH(RSFT);
THEN NOKEYS NOMODS;
THEN NOKEYS WITH(LSFT);
THEN KEY(9) WITH(LSFT);
THEN NOKEYS NOMODS;
}
void TestSpaceFn(CuTest *tc) {
START_KEY_CAPTURE;
key_press(3);
key_release(3);
SHOULDNOT_SEND;
key_press(16*8+6);//SPACE
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
key_release(16*8+6);//SPACE
CuAssertIntEquals(tc, 0, active_layer);
SHOULDNOT_SEND;
key_press(16*8+6);//SPACE
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
make_dualrole_modifier_possible();//pretend enough time has passed
key_press(11*8+3);//K or down
key_release(11*8+3);
SHOULDNOT_SEND;
key_release(16*8+6);//SPACE
CuAssertIntEquals(tc, 0, active_layer);
VERIFY_DIDNOT_SEND;
VERIFY NOKEYS WITH(RGUI);
THEN NOKEYS NOMODS;
THEN KEY(SPACE) NOMODS;
THEN NOKEYS NOMODS;
THEN KEY(DOWN);
THEN NOKEYS;
}
void TestModModded(CuTest* tc)
{
START_KEY_CAPTURE;
SHOULDNOT_SEND;
key_press(7);//toggle layer to 1
CuAssertIntEquals(tc, 1, active_layer);
key_release(7);
CuAssertIntEquals(tc, 1, active_layer);
VERIFY_DIDNOT_SEND;
key_press(2);//sLALT
key_release(2);//sLALT
SHOULDNOT_SEND;
key_press(7);//toggle layer to 0
CuAssertIntEquals(tc, 0, active_layer);
key_release(7);
CuAssertIntEquals(tc, 0, active_layer);
VERIFY_DIDNOT_SEND;
VERIFY NOKEYS WITH(LSFT|LALT);
THEN NOKEYS;
}
void scan() {
for (ic = 0; ic < COLS_COUNT; ic += 1) {
digitalWrite(cols_pins[ic], HIGH);
for (ir = 0; ir < ROWS_COUNT; ir += 1) {
if (!keymap[ir][ic])
continue;
if (digitalRead(rows_pins[ir]))
key_press(keymap[ir][ic]);
else
key_release(keymap[ir][ic]);
}
digitalWrite(cols_pins[ic], LOW);
}
}
void replay_keypresses(void)
{
uint8_t i, k;
clear_pressed();
// Go through all keys in the replay buf. We can determine whether
// a command is a key press or release based on whether the key
// is already pressed.
for (i = 0; i < replay_buf_len; ++i) {
k = replay_buf[i];
if (!key[k].pressed) {
key_press(k);
} else {
key_release(k);
}
}
}
int main()
{
init_led();
init_beep();
init_key();
led_off_all();
int i;
while(1)
{
if(i= key_press()){
led_on(i);
beep_on();
}else{
led_off_all();
beep_off();
}
}
return 0;
}
int ft_key_press(int keycode, t_frac *frac)
{
if (keycode == E || keycode == Q || keycode == W || keycode == R)
key_press(keycode, frac);
if (keycode == SPACE)
switch_color(frac);
if (keycode == PLUS)
it_pp(frac);
if (keycode == MOIN)
it_mm(frac);
if (keycode == ESC)
exit(0);
if (keycode == FORWARD)
forward(frac);
if (keycode == BACKWARD)
backward(frac);
if (keycode == LEFT)
left(frac);
if (keycode == RIGHT)
right(frac);
draw_tt(&frac->img, frac);
return (0);
}
void poll() {
uint8_t row, col, key_id;
for (row=0; row<ROWS; row++) { // scan rows
*row_port[row] &= ~row_bit[row];
_delay_us(1);
for (col=0; col<COLS; col++) { // read columns
key_id = col*ROWS+row;
if (! (*col_pin[col] & col_bit[col])) { // press key
if (! pressed[key_id]) {
key_press(key_id);
}
} else if (pressed[key_id]) { // release key
key_release(key_id);
}
}
*row_port[row] |= row_bit[row];
}
if (caps_lock_led != (keyboard_leds & LED_CAPS_LOCK)) { // change layout
caps_lock_change_layer();
}
//if (keyboard_leds) LED_ON; else LED_OFF;
repeat_tick();
_delay_ms(5);
}
int input(t_display *display, t_map *map)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
g_keep_running = false;
break;
case SDL_MOUSEBUTTONDOWN:
display->_click_x = display->_horiz + (size_t)event.button.x
/ (display->_shape_size + 1);
display->_click_y = display->_verti + (size_t)event.button.y
/ (display->_shape_size2 + 1);
break;
case SDL_KEYDOWN:
key_press(&event, map, display);
break;
}
}
return (0);
}
void menu::handle_event(const SDL_Event& event)
{
scrollarea::handle_event(event);
if (height()==0 || hidden())
return;
if(event.type == SDL_KEYDOWN) {
// Only pass key events if we have the focus
if (focus(&event))
key_press(event.key.keysym.sym);
} else if(!mouse_locked() && ((event.type == SDL_MOUSEBUTTONDOWN &&
(event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) ||
event.type == DOUBLE_CLICK_EVENT)) {
int x = 0;
int y = 0;
if(event.type == SDL_MOUSEBUTTONDOWN) {
x = event.button.x;
y = event.button.y;
} else {
x = reinterpret_cast<long>(event.user.data1);
y = reinterpret_cast<long>(event.user.data2);
}
const int item = hit(x,y);
if(item != -1) {
set_focus(true);
move_selection_to(item);
if(click_selects_) {
show_result_ = true;
}
if(event.type == DOUBLE_CLICK_EVENT) {
if (ignore_next_doubleclick_) {
ignore_next_doubleclick_ = false;
} else {
double_clicked_ = true;
last_was_doubleclick_ = true;
if(!silent_) {
sound::play_UI_sound(game_config::sounds::button_press);
}
}
} else if (last_was_doubleclick_) {
// If we have a double click as the next event, it means
// this double click was generated from a click that
// already has helped in generating a double click.
SDL_Event ev;
SDL_PeepEvents(&ev, 1, SDL_PEEKEVENT,
SDL_EVENTMASK(DOUBLE_CLICK_EVENT));
if (ev.type == DOUBLE_CLICK_EVENT) {
ignore_next_doubleclick_ = true;
}
last_was_doubleclick_ = false;
}
}
if(sorter_ != NULL) {
const int heading = hit_heading(x,y);
if(heading >= 0 && sorter_->column_sortable(heading)) {
sort_by(heading);
}
}
} else if(!mouse_locked() && event.type == SDL_MOUSEMOTION) {
if(click_selects_) {
const int item = hit(event.motion.x,event.motion.y);
const bool out = (item == -1);
if (out_ != out) {
out_ = out;
invalidate_row_pos(selected_);
}
if (item != -1) {
move_selection_to(item);
}
}
const int heading_item = hit_heading(event.motion.x,event.motion.y);
if(heading_item != highlight_heading_) {
highlight_heading_ = heading_item;
invalidate_heading();
}
}
}
// ================================ START Menu ================================
int GUI::play( )
{
Table t; // choi tren Table nay
srand(time(NULL)); //Sinh so ngau nhien
double timeDelay = 1000 - level * 100 ; //thoi gian de roi
double tempTimeDelay = timeDelay;
int IDBrick, IDNextBrick; //So thu tu cua gach
score = 0; //Diem ban dau
lines = 0; //So hang da an duoc ban dau
system( "cls" );
//Tao 2 khoi gach dau tien
IDBrick = createIDBrick();
IDNextBrick = createIDBrick();
//In ra background, level, line va score ban dau
printBackground( );
gotoxy( 12, 4 );
std::cout << level;
gotoxy( 12, 6 );
std::cout << score;
gotoxy( 12, 8 );
std::cout << lines;
do
{
t.create( IDBrick ); //tao khoi moi
while ( t.checkEmpty( -1, 0 ) )
{
//In ra vien gach tiep theo va mau cua no
setTextColor( IDNextBrick + 7 );
t.printNextBrick( IDNextBrick );
Sleep( ( tempTimeDelay ) );
int count = 5; //So lan xoay toi da trong timeDelay
while (--count && kbhit() ) //doi phim an
{
KEY = key_press( );
if ( KEY == KEY_LEFT ) // dich trai neu nhap phim trai
t.moveLeft( );
else if ( KEY == KEY_RIGHT ) // dich phai neu nhap phim phai
t.moveRight( );
else if ( KEY == KEY_DOWN ) // roi luon neu nhap phim xuong
tempTimeDelay /= 10;
else if ( KEY == KEY_UP ) // xoay neu nhap phim len
t.rotate( );
else if ( KEY == PAUSE || KEY == ESCAPE ) // tam dung pause
while ( 1 ) //man hinh pause
{
system( "cls" ); //xoa man hinh, chong gian lan
//In ra tuy chon o man hinh pause
setTextColor( COLOR );
gotoxy( 20, 9 );
std::cout << " _____PAUSE_____ ";
gotoxy( 20, 12 );
std::cout << " RESUME ";
gotoxy( 20, 14 );
std::cout << " RESTART ";
gotoxy( 20, 16 );
std::cout << " MAIN MENU ";
int chosenMenu = cursor( 12, 16, 1 );
//Thuc hien lenh tuy theo toa do con tro tuy chon
if(chosenMenu == 1 ) //tiep tuc
{
//In ra nen game, level, lines va score hien tai va tiep tuc game
printBackground( );
gotoxy( 12, 4 );
std::cout << level;
gotoxy( 12, 6 );
std::cout << score;
gotoxy( 12, 8 );
std::cout << lines;
break;
}
else if(chosenMenu == 2 && confirm("RESTART") ) //choi lai ( can xac nhan )
return play( );
else if(chosenMenu == 3 && confirm("BACK TO MAIN MENU") ) //quay ve
return -1;
//return restart( );
}
}
t.moveDown( ); // dich xuong
}
t.setBrickNum( IDBrick + 7 );
t.getFullRows( ); //Lay diem
//Tinh diem hien tai
score = score + level + level * level * t.getDeletedLines() * t.getDeletedLines();
lines += t.getDeletedLines();
//In ra level, lines va score hien tai
setTextColor ( COLOR );
gotoxy( 12, 4 );
std::cout << level;
gotoxy( 12, 6 );
std::cout << score;
gotoxy( 12, 8 );
std::cout << lines;
IDBrick = IDNextBrick; //Gan khoi cu thanh khoi moi
IDNextBrick = createIDBrick(); //Tao khoi gach tiep theo
tempTimeDelay = timeDelay *= 0.99;
level = ( 1000 - timeDelay ) / 100;
} while ( t.checkGameOver() == 0 );
return score; //lay diem
}
