自学教程：C++ ui_update_menus函数代码示例

static UI_CALLBACK(save_resources_file){    char *filename;    ui_button_t button;    int len = 1024;#ifndef HAVE_DIRNAME    char *tmp;#endif    uilib_file_filter_enum_t filter = UILIB_FILTER_ALL;    vsync_suspend_speed_eval();    filename = lib_malloc(len + 1);    strcpy(filename, "");    filename = ui_select_file(_("File to save settings to"), NULL, 0, resources_last_dir, &filter, 1, &button, 0, NULL, UI_FC_SAVE);        if (button == UI_BUTTON_OK && filename != NULL) {        if (resources_save(filename) < 0) {            ui_error(_("Cannot save settings."));        } else {            if (w != NULL) {                ui_message(_("Settings saved successfully."));            }        }        lib_free(resources_last_dir);        util_fname_split(filename, &resources_last_dir, NULL);    }    lib_free(filename);    ui_update_menus();}

static void pet_select_keymap(ui_window_t w, int check, char *name, int sympos){    char filename[0x20];    const char *resname;    int kindex;    const char *wd;    const char *maps[6] = {"x11_buks", "x11_bukp", "x11_bgrs", "x11_bgrp", "x11_bdes", "x11_bdep"};    resources_get_int("KeymapIndex", &kindex);    strcpy(filename, maps[kindex]);    strcat(filename, name);    kindex = (kindex & ~1) + sympos;    resname = machine_keymap_res_name_list[kindex];    if (name) {        if (!check) {            resources_set_string(resname, filename);            ui_update_menus();        } else {            resources_get_string(resname, &wd);            if (!strcmp(wd, filename)) {                ui_menu_set_tick(w, 1);            } else {                ui_menu_set_tick(w, 0);            }        }    }}

static TUI_MENU_CALLBACK(radio_type_check_callback){    int drive = (int)param >> 16;    int type = (int)param & 0xffff;    int value;    int i;    int support = (is_fs(type) || drive_check_type(type, drive - 8));    if (!support) {        return "N/A";    }    if (been_activated) {        if (is_fs(type)) {            resources_set_int_sprintf("IECDevice%i", 1, drive);            resources_set_int_sprintf("FileSystemDevice%i", type, drive);        } else {            if (has_fs()) {                resources_set_int_sprintf("IECDevice%i", 0, drive);            }            resources_set_int_sprintf("Drive%iType", type, drive);        }        *become_default = 1;        ui_update_menus();    } else {        if (check_current_drive_type(type, drive)) {            *become_default = 1;        }    }}

static void load_snapshot_trap(WORD unused_addr, void *unused_data){    if (autostart_program_name && machine_read_snapshot((char *)autostart_program_name, 0) < 0)        ui_error(translate_text(IDGS_CANNOT_LOAD_SNAPSHOT_FILE));    ui_update_menus();}

/* Autostart PRG file `file_name'.  The PRG file can either be a raw CBM file   or a P00 file */int autostart_prg(const char *file_name, unsigned int runmode){	fileio_info_t *finfo;	int result;	const char *boot_file_name;	int mode;	if (event_record_active() || event_playback_active())		return -1;	/* open prg file */	finfo = fileio_open(file_name, NULL, FILEIO_FORMAT_RAW | FILEIO_FORMAT_P00, FILEIO_COMMAND_READ | FILEIO_COMMAND_FSNAME, FILEIO_TYPE_PRG);	/* can't open file */	if (finfo == NULL) {		#ifdef CELL_DEBUG		printf("ERROR: Cannot open `%s'./n", file_name);		#endif		return -1;	}	/* determine how to load file */	switch(AutostartPrgMode)	{		case AUTOSTART_PRG_MODE_VFS:			//log_message(autostart_log, "Loading PRG file `%s' with virtual FS on unit #8.", file_name);			result = autostart_prg_with_virtual_fs(file_name, finfo);			mode = AUTOSTART_HASDISK;			boot_file_name = (const char *)finfo->name;			break;		case AUTOSTART_PRG_MODE_INJECT:			//log_message(autostart_log, "Loading PRG file `%s' with direct RAM injection.", file_name);			result = autostart_prg_with_ram_injection(file_name, finfo);			mode = AUTOSTART_INJECT;			boot_file_name = NULL;			break;		case AUTOSTART_PRG_MODE_DISK:			//log_message(autostart_log, "Loading PRG file `%s' with autostart disk image.", file_name);			result = autostart_prg_with_disk_image(file_name, finfo, AutostartPrgDiskImage);			mode = AUTOSTART_HASDISK;			boot_file_name = "*";			break;		default:			//log_error(autostart_log, "Invalid PRG autostart mode: %d", AutostartPrgMode);			result = -1;			break;	}	/* Now either proceed with disk image booting or prg injection after reset */	if (result >= 0)	{		ui_update_menus();		reboot_for_autostart(boot_file_name, mode, runmode);	}	/* close prg file */	fileio_close(finfo);	return result;}

static UI_CALLBACK(attach_cartridge){    int type = vice_ptr_to_int(UI_MENU_CB_PARAM);    char *filename;    ui_button_t button;    static char *last_dir;    uilib_file_filter_enum_t filter[] = { UILIB_FILTER_VIC20CART, UILIB_FILTER_ALL };    vsync_suspend_speed_eval();    filename = ui_select_file(_("Attach cartridge image"), NULL, 0, last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 0, NULL, UI_FC_LOAD);    switch (button) {        case UI_BUTTON_OK:            if (cartridge_attach_image(type, filename) < 0) {                ui_error(_("Invalid cartridge image"));            }            lib_free(last_dir);            util_fname_split(filename, &last_dir, NULL);            ui_update_menus();            break;        default:            /* Do nothing special.  */            break;    }    lib_free(filename);}

static TUI_MENU_CALLBACK(create_disk_image_callback){    if (been_activated) {        unsigned int drive;        drive = (unsigned int)param;        if (file_name == NULL) {            tui_error("Specify a disk image name.");            return NULL;        }        if (vdrive_internal_create_format_disk_image(file_name, format_name, image_type[file_type]) < 0) {            tui_error("Could not create disk image!");            return NULL;        }        if (drive > 0) {            if (file_system_attach_disk(drive, file_name) < 0) {                tui_error("Could not attach disk image!");                return NULL;            }        }        ui_update_menus();    }    return NULL;}

static TUI_MENU_CALLBACK(attach_cartridge_callback){    const char *s;    int type = (int)param;    if (been_activated) {        char *default_item, *directory;        char *name;        s = cartridge_get_file_name(cartridge_type_to_address(type));        if (s == NULL) {            directory = default_item = NULL;        } else {            util_fname_split(s, &directory, &default_item);        }        name = tui_file_selector("Attach cartridge image", directory, "*", default_item, NULL, NULL, NULL);        if (name != NULL && (s == NULL || strcasecmp(name, s) != 0) && cartridge_attach_image(type, name) < 0) {            tui_error("Invalid cartridge image.");        }        ui_update_menus();        lib_free(name);    }    /* This is redundant if `been_activated' is nonzero, but let's stay on       the safe side.  */    s = cartridge_get_file_name(cartridge_type_to_address(type));    if (s == NULL || *s == '/0') {        return "(none)";    } else {        return s;    }}

static TUI_MENU_CALLBACK(set_joy_device_callback){    int port = (int)param >> 8;    char *resource;    switch (port) {        case 1:        default:            resource = "JoyDevice1";            break;        case 2:            resource = "JoyDevice2";            break;        case 3:            resource = "JoyDevice3";            break;        case 4:            resource = "JoyDevice4";            break;    }    if (been_activated) {        resources_set_int(resource, ((int)param & 0xff));        ui_update_menus();    } else {        int value;        resources_get_int(resource, &value);        if (value == ((int)param & 0xff)) {            *become_default = 1;        }    }    return NULL;}

static void load_snapshot_trap(WORD unused_addr, void *data){    ui_button_t button;    char *filename;    vsync_suspend_speed_eval();    if (data) {        log_debug("Quickloading file %s.", (char *)data);        filename = (char *)data;    } else {        uilib_file_filter_enum_t filter[] = { UILIB_FILTER_SNAPSHOT, UILIB_FILTER_ALL };        filename = ui_select_file(_("Load snapshot image"), NULL, 0, load_snapshot_last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 0, NULL, UI_FC_LOAD);        if (button != UI_BUTTON_OK) {            lib_free(filename);            return;        }    }    lib_free(load_snapshot_last_dir);    util_fname_split(filename, &load_snapshot_last_dir, NULL);    if (machine_read_snapshot(filename, 0) < 0) {        ui_error(_("Cannot load snapshot file/n`%s'"), filename);    }    ui_update_menus();    lib_free(filename);}

void ui_select_renderer(ui_window_t w, int check, int type, char *chip){    char r1[0x20], r2[0x20];    int renderer = 0, crt, have_scale2x, scale2x, doublesize;    strcpy(r1, chip);    strcpy(r2, chip);    strcat(r1, "Scale2x");    strcat(r2, "DoubleSize");    resources_get_int("PalEmulation", &crt);    if (resources_query_type(r1) == RES_INTEGER) {        resources_get_int(r1, &scale2x);        have_scale2x = 1;    } else {        scale2x = 0;        have_scale2x = 0;    }    resources_get_int(r2, &doublesize);    if (crt) {        renderer = 1;    } else if ((scale2x > 0) && (doublesize > 0)) {        renderer = 2;    }    if (!check) {        switch (type) {            case 0: /* unfiltered */                crt = 0;                scale2x = 0;                break;            case 1: /* CRT */                crt = 1;                scale2x = 0;                break;            case 2: /* scale 2x */                crt = 0;                scale2x = 1;                doublesize = 1;                break;        }        resources_set_int("PalEmulation", crt);        if (have_scale2x) {            resources_set_int(r1, scale2x);        }        resources_set_int(r2, doublesize);        ui_update_menus();    } else {        if (renderer == type) {            ui_menu_set_tick(w, 1);        } else {            ui_menu_set_tick(w, 0);        }    }}

static UI_CALLBACK(ui_netplay_set_port){    static char input_string[32];    char *msg_string;    ui_button_t button;    int i;    int current_port;    resources_get_int("NetworkServerPort", &current_port);    if (!*input_string) {        sprintf(input_string, "%d", current_port);    }    vsync_suspend_speed_eval();    msg_string = lib_stralloc(_("Enter port"));    button = ui_input_string(_("Netplay TCP port"), msg_string, input_string, 32);    lib_free(msg_string);    if (button == UI_BUTTON_OK) {        i = atoi(input_string);        if (i > 0 && i < 65536) {            resources_set_int("NetworkServerPort", i);            ui_update_menus();        } else {            ui_error(_("Invalid TCP port"));        }    }}

static void load_snapshot_trap(WORD unused_addr, void *data){    ui_button_t button;    char *filename;    vsync_suspend_speed_eval();    if (data) {        log_debug(_("Quickloading file %s."), (char *)data);        filename = (char *)data;    } else {        filename = ui_select_file(_("Load snapshot"), NULL, 0, 0,                                  load_snapshot_last_dir,                                  "*.vsf", &button, 0, NULL);        if (button != UI_BUTTON_OK) {            if (filename)                lib_free(filename);            return;        }    }    if (load_snapshot_last_dir)        lib_free(load_snapshot_last_dir);    util_fname_split(filename, &load_snapshot_last_dir, NULL);    if (machine_read_snapshot(filename, 0) < 0)        ui_error(_("Cannot load snapshot file/n`%s'"), filename);    ui_update_menus();    if (filename != NULL)        lib_free(filename);}

static int mem_read_rom_snapshot_module(snapshot_t *s){    BYTE major_version, minor_version;    snapshot_module_t *m;    int trapfl;    /* Main memory module.  */    m = snapshot_module_open(s, snap_rom_module_name,                             &major_version, &minor_version);    /* This module is optional.  */    if (m == NULL)        return 0;    /* disable traps before loading the ROM */    resources_get_int("VirtualDevices", &trapfl);    resources_set_int("VirtualDevices", 0);    if (major_version > SNAP_ROM_MAJOR || minor_version > SNAP_ROM_MINOR) {        log_error(c128_snapshot_log,                  "MEM: Snapshot module version (%d.%d) newer than %d.%d.",                  major_version, minor_version,                  SNAP_ROM_MAJOR, SNAP_ROM_MINOR);        goto fail;    }    if (0        || SMR_BA(m, c128memrom_kernal_rom, C128_KERNAL_ROM_SIZE) < 0        || SMR_BA(m, c128memrom_basic_rom, C128_BASIC_ROM_SIZE) < 0        || SMR_BA(m, c128memrom_basic_rom + C128_BASIC_ROM_SIZE,        C128_EDITOR_ROM_SIZE) < 0        || SMR_BA(m, mem_chargen_rom, C128_CHARGEN_ROM_SIZE) < 0)        goto fail;    log_warning(c128_snapshot_log,"Dumped Romset files and saved settings will "                "represent/nthe state before loading the snapshot!");    memcpy(c128memrom_kernal_trap_rom, c128memrom_kernal_rom,           C128_KERNAL_ROM_SIZE);    c128rom_basic_checksum();    c128rom_kernal_checksum();    /* enable traps again when necessary */    resources_set_int("VirtualDevices", trapfl);    /* to get all the checkmarks right */    ui_update_menus();    return 0; fail:    /* enable traps again when necessary */    resources_set_int("VirtualDevices", trapfl);    if (m != NULL)        snapshot_module_close(m);    return -1;}

static void load_snapshot_trap(WORD unused_addr, void *unused_data){    if (autostart_program_name        && machine_read_snapshot((char *)autostart_program_name, 0) < 0) {        snapshot_display_error();    }    ui_update_menus();}

static TUI_MENU_CALLBACK(restore_default_settings_callback){    if (been_activated) {        resources_set_defaults();        tui_message("Default settings restored.");        ui_update_menus();    }    return NULL;}

static UI_CALLBACK(radio_SidModel){    int engine, model, selected;    selected = vice_ptr_to_int(UI_MENU_CB_PARAM);    if (!CHECK_MENUS) {        engine = selected >> 8;        model = selected & 0xff;        sid_set_engine_model(engine, model);        ui_update_menus();    } else {

int c128_snapshot_read_module(snapshot_t *s){    BYTE major_version, minor_version;    snapshot_module_t *m;    WORD i;    BYTE byte;    /* Main memory module.  */    m = snapshot_module_open(s, snap_module_name,                             &major_version, &minor_version);    if (m == NULL)        return -1;    if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) {        log_error(c128_snapshot_log,                  "MEM: Snapshot module version (%d.%d) newer than %d.%d.",                  major_version, minor_version,                  SNAP_MAJOR, SNAP_MINOR);        goto fail;    }    for (i = 0; i < 11; i++) {        if (SMR_B(m, &byte) < 0)            goto fail;        mmu_store(i, byte);     /* Assuming no side-effects */    }    if (0        || SMR_BA(m, mem_ram, C128_RAM_SIZE) < 0)        goto fail;    /* pla_config_changed(); */    if (snapshot_module_close(m) < 0)        goto fail;    m = NULL;    if (mem_read_rom_snapshot_module(s) < 0)        goto fail;    if (cartridge_snapshot_read_modules(s) < 0) {        goto fail;    }    ui_update_menus();    return 0;fail:    if (m != NULL)        snapshot_module_close(m);    return -1;}

static TUI_MENU_CALLBACK(set_model_callback){    if (been_activated) {        pet_set_model(param, NULL);        ui_update_menus();    }    /* This way, the "Not Really!" item is always the default one.  */    *become_default = 0;    return NULL;}

static void load_snapshot_trap(WORD unused_addr, void *unused_data){    if (autostart_program_name        && machine_read_snapshot((char *)autostart_program_name, 0) < 0)#ifdef HAS_TRANSLATION        ui_error(translate_text(IDGS_CANNOT_LOAD_SNAPSHOT_FILE));#else        ui_error(_("Cannot load snapshot file."));#endif    ui_update_menus();}

static UI_CALLBACK(set_joystick_device_4){    int tmp;    if (!CHECK_MENUS) {        resources_set_int("JoyDevice4", vice_ptr_to_int(UI_MENU_CB_PARAM));        ui_update_menus();    } else {        resources_get_int("JoyDevice4", &tmp);        ui_menu_set_tick(w, tmp == vice_ptr_to_int(UI_MENU_CB_PARAM));    }}

/* Autostart PRG file `file_name'.  The PRG file can either be a raw CBM file   or a P00 file, and the FS-based drive emulation is set up so that its   directory becomes the current one on unit #8.  */int autostart_prg(const char *file_name, unsigned int runmode){    char *directory;    char *file;    fileio_info_t *finfo;    if (network_connected())        return -1;        finfo = fileio_open(file_name, NULL, FILEIO_FORMAT_RAW | FILEIO_FORMAT_P00,                        FILEIO_COMMAND_READ | FILEIO_COMMAND_FSNAME,                        FILEIO_TYPE_PRG);    if (finfo == NULL) {        log_error(autostart_log, "Cannot open `%s'.", file_name);        return -1;    }    /* Extract the directory path to allow FS-based drive emulation to       work.  */    util_fname_split(file_name, &directory, &file);    if (archdep_path_is_relative(directory)) {        char *tmp;        archdep_expand_path(&tmp, directory);        lib_free(directory);        directory = tmp;        /* FIXME: We should actually eat `.'s and `..'s from `directory'           instead.  */    }    /* Setup FS-based drive emulation.  */    fsdevice_set_directory(directory ? directory : ".", 8);    set_true_drive_emulation_mode(0);    orig_drive_true_emulation_state =0;    resources_set_int("VirtualDevices", 1);    resources_set_int("FSDevice8ConvertP00", 1);    file_system_detach_disk(8);    ui_update_menus();    /* Now it's the same as autostarting a disk image.  */    reboot_for_autostart((char *)(finfo->name), AUTOSTART_HASDISK, runmode);    lib_free(directory);    lib_free(file);    fileio_close(finfo);    log_message(autostart_log, "Preparing to load PRG file `%s'.",                file_name);    return 0;}

static UI_CALLBACK(toggle_pause){    static int pause = 0;    if (!CHECK_MENUS) {        pause = !pause;        ui_update_menus();        ui_pause_emulation(pause);        return;    }    ui_menu_set_tick(w, pause);}