/** 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;
}
}