/** Start a new game after users and teams are selected. */ void misc_callback_start_game(void) { #ifdef DEBUG printf("misc_callback_start_game\n"); #endif gint i; GtkToggleButton *radio_load = GTK_TOGGLE_BUTTON(lookup_widget(window.startup, "radiobutton_team_def_load")); GtkToggleButton *radio_names = GTK_TOGGLE_BUTTON(lookup_widget(window.startup, "radiobutton_team_def_names")); GtkToggleButton *checkbutton_randomise_teams = GTK_TOGGLE_BUTTON(lookup_widget(window.startup, "checkbutton_randomise_teams")); stat0 = STATUS_MAIN; /* option_add(&options, "int_opt_load_defs", 1, NULL); */ /* option_add(&options, "int_opt_randomise_teams", 0, NULL); */ if(gtk_toggle_button_get_active(checkbutton_randomise_teams)) opt_set_int("int_opt_randomise_teams", 1); if(gtk_toggle_button_get_active(radio_load)) opt_set_int("int_opt_load_defs", 1); else if(gtk_toggle_button_get_active(radio_names)) opt_set_int("int_opt_load_defs", 2); else opt_set_int("int_opt_load_defs", 0); start_new_game(); window_destroy(&window.startup); file_store_text_in_saves("last_country", country.sid); if(!opt_int("int_opt_calodds")) { for(i=0;i<users->len;i++) user_set_up_team_new_game(&usr(i)); window_create(WINDOW_MAIN); game_gui_show_main(); if(statp != NULL) { debug_action((gchar*)statp); g_free(statp); statp = NULL; } } else { free_users(TRUE); debug_calibrate_betting_odds(opt_int("int_opt_calodds_skilldiffmax"), opt_int("int_opt_calodds_matches")); main_exit_program(EXIT_OK, NULL); } }
G_MODULE_EXPORT void on_button_debug_apply_clicked (GtkButton *button, gpointer user_data) { #ifdef DEBUG printf("on_button_debug_apply_clicked\n"); #endif GtkEntry *entry_debug = GTK_ENTRY(lookup_widget(window.wdebug, "entry_debug")); const gchar *entry_text = gtk_entry_get_text(entry_debug); debug_action(entry_text); gtk_entry_set_text(entry_debug, ""); }
/** \brief Take a key event (key press or key release) and processes it. * * FIXME: Needs documentation. */ void process_record(keyrecord_t *record) { if (IS_NOEVENT(record->event)) { return; } if(!process_record_quantum(record)) return; action_t action = store_or_get_action(record->event.pressed, record->event.key); dprint("ACTION: "); debug_action(action); #ifndef NO_ACTION_LAYER dprint(" layer_state: "); layer_debug(); dprint(" default_layer_state: "); default_layer_debug(); #endif dprintln(); process_action(record, action); }
void process_action(keyrecord_t *record) { keyevent_t event = record->event; #ifndef NO_ACTION_TAPPING uint8_t tap_count = record->tap.count; #endif if (IS_NOEVENT(event)) { return; } action_t action = layer_switch_get_action(event.key); dprint("ACTION: "); debug_action(action); #ifndef NO_ACTION_LAYER dprint(" layer_state: "); layer_debug(); dprint(" default_layer_state: "); default_layer_debug(); #endif dprintln(); switch (action.kind.id) { /* Key and Mods */ case ACT_LMODS: case ACT_RMODS: { uint8_t mods = (action.kind.id == ACT_LMODS) ? action.key.mods : action.key.mods<<4; if (event.pressed) { if (mods) { add_weak_mods(mods); send_keyboard_report(); } register_code(action.key.code); } else { unregister_code(action.key.code); if (mods) { del_weak_mods(mods); send_keyboard_report(); } } } break; #ifndef NO_ACTION_TAPPING case ACT_LMODS_TAP: case ACT_RMODS_TAP: { uint8_t mods = (action.kind.id == ACT_LMODS_TAP) ? action.key.mods : action.key.mods<<4; switch (action.layer_tap.code) { #ifndef NO_ACTION_ONESHOT case MODS_ONESHOT: // Oneshot modifier if (event.pressed) { if (tap_count == 0) { register_mods(mods); } else if (tap_count == 1) { dprint("MODS_TAP: Oneshot: start\n"); set_oneshot_mods(mods); } else { register_mods(mods); } } else { if (tap_count == 0) { clear_oneshot_mods(); unregister_mods(mods); } else if (tap_count == 1) { // Retain Oneshot mods } else { clear_oneshot_mods(); unregister_mods(mods); } } break; #endif case MODS_TAP_TOGGLE: if (event.pressed) { if (tap_count <= TAPPING_TOGGLE) { register_mods(mods); } } else { if (tap_count < TAPPING_TOGGLE) { unregister_mods(mods); } } break; default: if (event.pressed) { if (tap_count > 0) { if (record->tap.interrupted) { dprint("MODS_TAP: Tap: Cancel: add_mods\n"); // ad hoc: set 0 to cancel tap record->tap.count = 0; register_mods(mods); } else { dprint("MODS_TAP: Tap: register_code\n"); register_code(action.key.code); } } else { dprint("MODS_TAP: No tap: add_mods\n"); register_mods(mods); } } else { if (tap_count > 0) { dprint("MODS_TAP: Tap: unregister_code\n"); unregister_code(action.key.code); } else { dprint("MODS_TAP: No tap: add_mods\n"); unregister_mods(mods); } } break; } } break; #endif #ifdef EXTRAKEY_ENABLE /* other HID usage */ case ACT_USAGE: switch (action.usage.page) { case PAGE_SYSTEM: if (event.pressed) { host_system_send(action.usage.code); } else { host_system_send(0); } break; case PAGE_CONSUMER: if (event.pressed) { host_consumer_send(action.usage.code); } else { host_consumer_send(0); } break; } break; #endif #ifdef MOUSEKEY_ENABLE /* Mouse key */ case ACT_MOUSEKEY: if (event.pressed) { mousekey_on(action.key.code); mousekey_send(); } else { mousekey_off(action.key.code); mousekey_send(); } break; #endif #ifndef NO_ACTION_LAYER case ACT_LAYER: if (action.layer_bitop.on == 0) { /* Default Layer Bitwise Operation */ if (!event.pressed) { uint8_t shift = action.layer_bitop.part*4; uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift; uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0; switch (action.layer_bitop.op) { case OP_BIT_AND: default_layer_and(bits | mask); break; case OP_BIT_OR: default_layer_or(bits | mask); break; case OP_BIT_XOR: default_layer_xor(bits | mask); break; case OP_BIT_SET: default_layer_and(mask); default_layer_or(bits); break; } } } else { /* Layer Bitwise Operation */ if (event.pressed ? (action.layer_bitop.on & ON_PRESS) : (action.layer_bitop.on & ON_RELEASE)) { uint8_t shift = action.layer_bitop.part*4; uint32_t bits = ((uint32_t)action.layer_bitop.bits)<<shift; uint32_t mask = (action.layer_bitop.xbit) ? ~(((uint32_t)0xf)<<shift) : 0; switch (action.layer_bitop.op) { case OP_BIT_AND: layer_and(bits | mask); break; case OP_BIT_OR: layer_or(bits | mask); break; case OP_BIT_XOR: layer_xor(bits | mask); break; case OP_BIT_SET: layer_and(mask); layer_or(bits); break; } } } break; #ifndef NO_ACTION_TAPPING case ACT_LAYER_TAP: case ACT_LAYER_TAP_EXT: switch (action.layer_tap.code) { case 0xe0 ... 0xef: /* layer On/Off with modifiers(left only) */ if (event.pressed) { layer_on(action.layer_tap.val); register_mods(action.layer_tap.code & 0x0f); } else { layer_off(action.layer_tap.val); unregister_mods(action.layer_tap.code & 0x0f); } break; case OP_TAP_TOGGLE: /* tap toggle */ if (event.pressed) { if (tap_count < TAPPING_TOGGLE) { layer_invert(action.layer_tap.val); } } else { if (tap_count <= TAPPING_TOGGLE) { layer_invert(action.layer_tap.val); } } break; case OP_ON_OFF: event.pressed ? layer_on(action.layer_tap.val) : layer_off(action.layer_tap.val); break; case OP_OFF_ON: event.pressed ? layer_off(action.layer_tap.val) : layer_on(action.layer_tap.val); break; case OP_SET_CLEAR: event.pressed ? layer_move(action.layer_tap.val) : layer_clear(); break; default: /* tap key */ if (event.pressed) { if (tap_count > 0) { dprint("KEYMAP_TAP_KEY: Tap: register_code\n"); register_code(action.layer_tap.code); } else { dprint("KEYMAP_TAP_KEY: No tap: On on press\n"); layer_on(action.layer_tap.val); } } else { if (tap_count > 0) { dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n"); unregister_code(action.layer_tap.code); } else { dprint("KEYMAP_TAP_KEY: No tap: Off on release\n"); layer_off(action.layer_tap.val); } } break; } break; #endif #endif /* Extentions */ #ifndef NO_ACTION_MACRO case ACT_MACRO: action_macro_play(action_get_macro(record, action.func.id, action.func.opt)); break; #endif #ifdef BACKLIGHT_ENABLE case ACT_BACKLIGHT: if (!event.pressed) { switch (action.backlight.opt) { case BACKLIGHT_INCREASE: backlight_increase(); break; case BACKLIGHT_DECREASE: backlight_decrease(); break; case BACKLIGHT_TOGGLE: backlight_toggle(); break; case BACKLIGHT_STEP: backlight_step(); break; case BACKLIGHT_LEVEL: backlight_level(action.backlight.level); break; } } break; #endif case ACT_COMMAND: break; #ifndef NO_ACTION_FUNCTION case ACT_FUNCTION: action_function(record, action.func.id, action.func.opt); break; #endif default: break; } }
static void handle_msg( mol_dgram_t *dg ) { cmd_entry_t *ce = sv.cmd_root; int i, val; switch( dg->what ) { case kMDG_connect: printm("Debugger attached\n"); sv.dbg_attached = 1; send_dgram( sv.sock, kMDG_connect ); send_mregs(); send_dgram( sv.sock, kMDG_refresh_debugger ); /* send debugger commands */ for( ce=sv.cmd_root; ce; ce=ce->next ) { int s = strlen( ce->cmdname ) + 1; int t = strlen( ce->help ) + 1; char *b = malloc( s + t ); strcpy( b, ce->cmdname ); strcpy( b+s, ce->help ); send_dgram_buf2( sv.sock, kMDG_dbg_cmd, b, s+t, s, -1 /*dummy*/ ); free( b ); } break; case kMDG_disconnect: sv.dbg_attached = 0; close_sock(); printm("Debugger detached\n"); break; case kMDG_mregs: send_mregs(); break; case kMDG_write_mregs: receive_mregs( (mac_regs_t*)dg->data ); break; case kMDG_read_dpage: { /* ea, context, data_access */ char buf[0x2000]; dg->p0 &= ~0xfff; restore_breakpoints(); for( i=0; i<2; i++ ) { char *lvptr; if( ea_to_lvptr( dg->p0 + i*0x1000, dg->p1, &lvptr, dg->p2 ) ) memset( buf+i*0x1000, 0xDE, 0x1000 ); else memcpy( buf+i*0x1000, lvptr, 0x1000 ); } setup_breakpoints(); send_dgram_buf( sv.sock, kMDG_dpage_data, buf, 0x2000 ); break; } case kMDG_in_ppc_mode: /* flag */ sv.in_ppc_mode = dg->p0; break; case kMDG_debug_action: /* action (go, single-step, etc.) */ debug_action( dg->p0 ); break; case kMDG_add_breakpoint: /* addr, flags, data */ add_breakpoint( dg->p0, dg->p1, dg->p2 ); break; case kMDG_is_breakpoint: { /* mvptr */ char breakbuf[ BREAK_BUF_SIZE ]; for(i=0; i<BREAK_BUF_SIZE; i++ ){ if( !is_breakpoint( dg->p0 + i*4, &breakbuf[i] ) ) breakbuf[i] = 0; } send_dgram_buf1( sv.sock, kMDG_is_breakpoint, breakbuf, BREAK_BUF_SIZE, dg->p0 ); break; } case kMDG_dbg_cmd: val = do_dbg_cmd( (remote_cmd_t*)dg->data ); send_dgram1( sv.sock, kMDG_result, val ); break; default: printm("Unknown dbg-message %d received\n", dg->what ); break; } }