static void
prefs_load_xml_text(
GMarkupParseContext * context,
const gchar * text,
gsize text_len,
gpointer user_data,
GError ** error)
{
struct prefs_parser_state * state = (struct prefs_parser_state*)user_data;
if(!state->pref_valid)
return;
if(state->tag==PREFS_TAG_VQCC_GTK_SETTINGS_PREF) {
gchar * stripped;
guint uint_read;
switch(state->pref_type) {
case PREFS_TYPE_UINT:
if(sscanf(text, "%u", &uint_read)==1) {
prefs_set(state->pref_name->str, uint_read);
} else {
g_set_error(error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Could not read value for preference \"%s\""),
state->pref_name->str);
}
break;
case PREFS_TYPE_BOOL:
stripped = g_strstrip(g_strdup(text));
if(!g_ascii_strncasecmp(text, "FALSE", sizeof("FALSE")-1)) {
prefs_set(state->pref_name->str, FALSE);
}
else if(!g_ascii_strncasecmp(text, "TRUE", sizeof("TRUE")-1)) {
prefs_set(state->pref_name->str, TRUE);
}
else {
g_set_error(error, G_MARKUP_ERROR,
G_MARKUP_ERROR_INVALID_CONTENT,
_("Could not read value for preference \"%s\""),
state->pref_name->str);
}
g_free(stripped);
break;
case PREFS_TYPE_STR:
prefs_set(state->pref_name->str, text);
break;
default:
break;
}
} else if(state->tag==PREFS_TAG_VQCC_GTK_SETTINGS_PREF_ENTRY
&& state->pref_type==PREFS_TYPE_LIST) {
/* read list data */
prefs_list_add(state->pref_name->str, text);
}
}
static void
idle_event_cb(
enum app_event_enum event,
gpointer event_ptr, gint event_int)
{
switch(event) {
case EVENT_MAIN_INIT:
idle_check_timeout = 0;
break;
case EVENT_MAIN_REGISTER_PREFS:
prefs_register(PREFS_IDLE_AUTO_AWAY, PREFS_TYPE_UINT,
_("Auto-away timeout in minutes"), idle_prefs_auto_away_validator, NULL);
prefs_register(PREFS_IDLE_AUTO_OFFLINE, PREFS_TYPE_UINT,
_("Auto-offline timeout in minutes"),
idle_prefs_auto_offline_validator, NULL);
prefs_register(PREFS_IDLE_ENABLE, PREFS_TYPE_BOOL,
_("Enter auto-away/auto-offline modes"), NULL, NULL);
prefs_add_notifier(PREFS_IDLE_ENABLE, (GHookFunc)idle_prefs_idle_enable_changed);
break;
case EVENT_MAIN_PRESET_PREFS:
prefs_set(PREFS_IDLE_AUTO_AWAY, 15);
prefs_set(PREFS_IDLE_AUTO_OFFLINE, 30);
prefs_set(PREFS_IDLE_ENABLE, TRUE);
break;
case EVENT_MAIN_START:
/* start idle check periodical timeout (timer) */
idle_mode = IDLE_NOT;
break;
case EVENT_MAIN_PRECLOSE:
/* destroy timer source */
if(idle_check_timeout>0) {
g_source_remove(idle_check_timeout);
idle_check_timeout = 0;
}
break;
default:
break; /* nothing */
}
}
static void
dlg_response(GtkDialog * dlg_w, gint response, struct netselect_dlg * dlg)
{
switch(response) {
case GTK_RESPONSE_OK:
/* set network & port */
prefs_set(PREFS_NET_TYPE, gtk_option_menu_get_history(
GTK_OPTION_MENU(dlg->net_type_option)));
prefs_set(PREFS_NET_PORT, gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(dlg->net_port_spin)));
prefs_set(PREFS_NET_USE_MULTICAST,
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dlg->net_use_multicast_w)));
prefs_set(PREFS_NET_MULTICAST_ADDR, dlg->detect_multicast_addr);
prefs_set(PREFS_NET_BROADCAST_MASK, dlg->detect_broadcast_mask);
prefs_set(PREFS_NET_IS_CONFIGURED, TRUE);
/* hide the dialog */
netselect_dlg_destroy(&main_netselect_dlg);
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
if(!prefs_bool(PREFS_NET_IS_CONFIGURED)) {
/* one cannot get away without network configured :) */
raise_event(EVENT_IFACE_EXIT, NULL, 0);
} else {
/* network is already configured, destroy the dialog and do nothing */
netselect_dlg_destroy(&main_netselect_dlg);
}
break;
}
}
static gboolean
idle_prefs_auto_offline_validator(const gchar * prefs_name, gpointer user_data)
{
guint offline_value = prefs_int(prefs_name);
if(offline_value==0 || offline_value > 240)
return FALSE;
if(prefs_int(PREFS_IDLE_AUTO_AWAY) < offline_value)
prefs_set(PREFS_IDLE_AUTO_AWAY, offline_value);
return TRUE;
}
static gboolean
idle_prefs_auto_away_validator(const gchar * prefs_name, gpointer user_data)
{
guint away_value = prefs_int(prefs_name);
if(away_value==0 || away_value > 240)
return FALSE;
if(prefs_int(PREFS_IDLE_AUTO_OFFLINE) < away_value)
prefs_set(PREFS_IDLE_AUTO_OFFLINE, away_value);
return TRUE;
}
static void
plotmodel_changed( iObject *iobject )
{
Plotmodel *plotmodel = PLOTMODEL( iobject );
#ifdef DEBUG
printf( "plotmodel_changed:\n" );
#endif /*DEBUG*/
prefs_set( "DISPLAY_STATUS",
"%s", bool_to_char( plotmodel->show_status ) );
IOBJECT_CLASS( parent_class )->changed( iobject );
}
static void
prefs_event_cb(
enum app_event_enum e,
gpointer p, gint i)
{
switch(e) {
case EVENT_MAIN_INIT:
prefs_init();
break;
case EVENT_MAIN_REGISTER_PREFS:
prefs_register(PREFS_PREFS_AUTO_SAVE, PREFS_TYPE_BOOL,
_("Save settings on exit"), NULL, NULL);
break;
case EVENT_MAIN_PRESET_PREFS:
prefs_set(PREFS_PREFS_AUTO_SAVE, TRUE);
break;
case EVENT_MAIN_LOAD_PREFS:
prefs_load();
break;
case EVENT_MAIN_CLOSE:
/* save configuration */
if(prefs_bool(PREFS_PREFS_AUTO_SAVE))
prefs_store();
prefs_free();
break;
case EVENT_IFACE_RELOAD_CONFIG:
/* force reload of config */
prefs_load();
break;
case EVENT_IFACE_STORE_CONFIG:
prefs_store();
break;
default:
break;
}
}
static void
sess_event_cb(enum app_event_enum event, gpointer p, int i)
{
session_t *sid;
gpointer event_v[2];
if(event & EVENT_NET) {
sess_net_event(event, p, i);
return;
}
switch(event) {
case EVENT_MAIN_INIT:
sess_list = NULL;
break;
case EVENT_MAIN_REGISTER_PREFS:
prefs_register(
PREFS_SESS_STAMP_CHANNEL, PREFS_TYPE_BOOL,
_("Time-stamp channel text"), NULL, NULL);
prefs_register(
PREFS_SESS_STAMP_PRIVATE, PREFS_TYPE_BOOL,
_("Time-stamp private text"), NULL, NULL);
prefs_register(
PREFS_SESS_STAMP_STATUS, PREFS_TYPE_BOOL,
_("Time-stamp status text"), NULL, NULL);
prefs_register(
PREFS_SESS_IMPORTANT_CHANNELS, PREFS_TYPE_LIST,
_("List of channels that trigger popup on new text"), NULL, NULL);
prefs_register(
PREFS_SESS_SUPPRESS_RENAME_TEXT, PREFS_TYPE_BOOL,
_("Suppress rename messages"), NULL, NULL);
prefs_register(
PREFS_SESS_SUPPRESS_MODE_TEXT, PREFS_TYPE_BOOL,
_("Suppress mode change messages"), NULL, NULL);
prefs_register(
PREFS_SESS_SUPPRESS_JOIN_LEAVE_TEXT, PREFS_TYPE_BOOL,
_("Suppress join/leave messages"), NULL, NULL);
break;
case EVENT_MAIN_PRESET_PREFS:
prefs_set(PREFS_SESS_STAMP_CHANNEL, TRUE);
prefs_set(PREFS_SESS_STAMP_PRIVATE, TRUE);
prefs_set(PREFS_SESS_STAMP_STATUS, TRUE);
break;
case EVENT_MAIN_PRECLOSE:
delete_all_sessions();
break;
case EVENT_IFACE_PAGE_SWITCH:
/* un-hilite page if hilited */
if(PSESSION_T(p)->hilited) {
gui_page_hilite(p, FALSE);
PSESSION_T(p)->hilited = FALSE;
}
break;
case EVENT_IFACE_PAGE_CLOSE:
sid = p ? (sess_id)p: sess_current();
if(PSESSION_T(sid)->closeable) {
/*
* Delete session and it's page
* only if it's closeable (by the user).
*/
sess_delete(sid);
}
break;
case EVENT_IFACE_USER_OPEN_REQ:
sess_private_open_req(p);
break;
case EVENT_IFACE_TOPIC_ENTER:
sid = EVENT_V(p, 0);
if(!SESSION_TOPIC_READONLY(sid)) {
/* here we don't care to set topic for ALL the channels in case of QChat,
* as net.c will forcefully raise EVENT_NET_MSG_TOPIC_CHANGE
*/
if(sess_set_topic(sid, (const gchar*)EVENT_V(p, 1))) {
EVENT_V(event_v, 0) = sid;
EVENT_V(event_v, 1) = EVENT_V(p, 1);
raise_event(EVENT_SESSION_TOPIC_ENTER, event_v, 0);
}
}
break;
case EVENT_IFACE_JOIN_CHANNEL:
sid = sess_find(SESSTYPE_CHANNEL, (const gchar *)p);
if(!sid)
sid = sess_new(SESSTYPE_CHANNEL, (const gchar *)p, TRUE, NULL);
sess_switch_to(sid);
break;
case EVENT_CMDPROC_SESSION_TEXT:
sess_handle_my_text((const char *)p, i);
break;
case EVENT_USER_RENAME:
handle_user_rename(EVENT_V(p, 0), EVENT_V(p, 1));
break;
case EVENT_USER_MODE_CHANGE:
handle_user_mode_change(p, (enum user_mode_enum)i);
break;
default:
break;
}
}
int main(int argc, char *argv[])
{
int c;
struct state *state = NULL;
#if TEST_BUILD
struct test_case *test_case;
#endif
prefs_init();
while(1) {
int option_index = 0;
static struct option long_options[] = {
{"cart", required_argument, 0, OPT_CART },
{"force-extreme-disasm", no_argument, 0, OPT_FORCE_EXTREME_DISASM },
{"crop-screen", no_argument, 0, OPT_CROP_SCREEN },
{"loglevels" , required_argument, 0, OPT_LOGLEVELS },
{"audio-device" , required_argument, 0, OPT_AUDIO_DEVICE },
#if TEST_BUILD
{"test-case", required_argument, 0, OPT_TEST_MODE},
#endif
{0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "a:b:c:t:s:hdpyVAMvq", long_options, &option_index);
if(c == -1) break;
switch(c) {
case 'a':
prefs_set("diskimage", optarg);
break;
case 'b':
prefs_set("diskimage2", optarg);
break;
case 'c':
prefs_set("hdimage", optarg);
break;
case 't':
prefs_set("tosimage", optarg);
break;
case 's':
prefs_set("stateimage", optarg);
break;
case OPT_CART:
prefs_set("cartimage", optarg);
break;
case OPT_FORCE_EXTREME_DISASM:
cprint_all = 1;
break;
case OPT_CROP_SCREEN:
crop_screen = 1;
break;
case OPT_LOGLEVELS:
diag_set_module_levels(optarg);
break;
case OPT_AUDIO_DEVICE:
if(!strncmp("list", optarg, 4)) {
audio_device = -1;
} else {
audio_device = atoi(optarg);
}
break;
#if TEST_BUILD
case OPT_TEST_MODE:
test_case_name = xstrdup(optarg);
test_mode = 1;
break;
#endif
case 'd':
debugger = 1;
break;
case 'p':
ppmoutput = 1;
break;
case 'y':
psgoutput = 1;
break;
case 'v':
verbosity++;
break;
case 'q':
verbosity = MAX(1, verbosity-1);
break;
case 'V':
vsync_delay = 1;
break;
case 'A':
play_audio = 1;
break;
case 'M':
monitor_sm124 = 1;
break;
case 'h':
default:
printf("Usage: %s [-AdMpqvVy] [-a diskimage1] [-b diskimage2] [-c hdimage] [-t tosimage] [-s stateimage]\n",
argv[0]);
exit(-1);
break;
}
}
/* Do not crop screen while debugging */
if(debugger) {
crop_screen = 0;
}
if((prefs.diskimage == NULL) && (argv[optind] != NULL))
prefs_set("diskimage", argv[optind]);
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_AUDIO);
#if TEST_BUILD
if(test_mode) {
test_case = test_init(test_case_name);
if(test_case) {
if(test_case->cartridge_name) {
prefs_set("cartimage", test_case->cartridge_name);
}
if(test_case->floppy_name) {
prefs_set("diskimage", test_case->floppy_name);
}
} else {
printf("DEBUG: Could not load test case %s\n", test_case_name);
exit(-3);
}
}
#endif
/* Must run before hardware module inits */
mmu_init();
/* This must also be run before hardware modules.
It gives a dummy area for some memory regions to not
cause bus errors */
mmu_fallback_init();
/* Actual hardware */
ram_init();
rom_init();
cpu_init();
if(prefs.cartimage) {
cartridge_init(prefs.cartimage);
} else {
cartridge_init(NULL);
}
psg_init();
midi_init();
acia_init();
ikbd_init();
#if INCLUDE_RTC
rtc_init();
#endif
dma_init();
fdc_init();
hdc_init(prefs.hdimage);
mfp_init();
screen_disable(0);
glue_init();
shifter_init();
if(debugger) {
debug_init();
cpu_halt_for_debug();
}
screen_init();
floppy_init(prefs.diskimage, prefs.diskimage2);
if(prefs.stateimage) {
state = state_load(prefs.stateimage);
}
if(state != NULL)
state_restore(state);
memset(&reset, 0, sizeof reset);
reset.sa_sigaction = reset_action;
sigaction(SIGHUP, &reset, NULL);
while(cpu_run(CPU_RUN));
return 0;
}
