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

static UI_CALLBACK(set_refresh_rate){    int current_refresh_rate;    resources_get_int("RefreshRate", &current_refresh_rate);    if (!CHECK_MENUS) {        if (current_refresh_rate != vice_ptr_to_int(UI_MENU_CB_PARAM)) {            resources_set_int("RefreshRate", vice_ptr_to_int(UI_MENU_CB_PARAM));            ui_update_menus();        }    } else {        if (vice_ptr_to_int(UI_MENU_CB_PARAM) == current_refresh_rate) {            ui_menu_set_tick(w, 1);        } else {            ui_menu_set_tick(w, 0);        }        if (UI_MENU_CB_PARAM == 0) {            int speed;            resources_get_int("Speed", &speed);            if (speed == 0) {                /* Cannot enable the `automatic' setting if a speed limit is                   not specified. */                ui_menu_set_sensitive(w, 0);            } else {                ui_menu_set_sensitive(w, 1);            }        }    }}

static UI_MENU_CALLBACK(custom_memory_callback){    int blocks, value;    if (activated) {        blocks = vice_ptr_to_int(param);        resources_set_int("RAMBlock0", blocks & BLOCK_0 ? 1 : 0);        resources_set_int("RAMBlock1", blocks & BLOCK_1 ? 1 : 0);        resources_set_int("RAMBlock2", blocks & BLOCK_2 ? 1 : 0);        resources_set_int("RAMBlock3", blocks & BLOCK_3 ? 1 : 0);        resources_set_int("RAMBlock5", blocks & BLOCK_5 ? 1 : 0);    } else {        resources_get_int("RAMBlock0", &value);        blocks = value;        resources_get_int("RAMBlock1", &value);        blocks |= (value << 1);        resources_get_int("RAMBlock2", &value);        blocks |= (value << 2);        resources_get_int("RAMBlock3", &value);        blocks |= (value << 3);        resources_get_int("RAMBlock5", &value);        blocks |= (value << 5);        if (blocks == vice_ptr_to_int(param)) {            return sdl_menu_text_tick;        }    }    return NULL;}

static int set_fsdevice_hide_cbm_files(int val, void *param){    if (val && !fsdevice_convert_p00_enabled[vice_ptr_to_int(param) - 8]) {        return -1;    }    fsdevice_hide_cbm_files_enabled[vice_ptr_to_int(param) - 8] = val;    return 0;}

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));    }}

/* unused ? */static UI_CALLBACK(set_joystick_device){    vsync_suspend_speed_eval();    if (!CHECK_MENUS) {        resources_set_int("JoyDevice1", vice_ptr_to_int(UI_MENU_CB_PARAM));        ui_update_menus();    } else {        int tmp;        resources_get_int("JoyDevice1", &tmp);        ui_menu_set_tick(w, tmp == vice_ptr_to_int(UI_MENU_CB_PARAM));    }}

void _ui_menu_radio_helper(Widget w, ui_callback_data_t client_data, ui_callback_data_t call_data, const char *resource_name){    int current_value;    resources_get_int(resource_name, &current_value);    if (!call_data) {        if (current_value != vice_ptr_to_int(client_data)) {            resources_set_int(resource_name, vice_ptr_to_int(client_data));            ui_update_menus();        }    } else {        ui_menu_set_tick(w, current_value == vice_ptr_to_int(client_data));    }}

static UI_CALLBACK(select_user_keymap){    char *filename;    const char *resname;    ui_button_t button;    int kindex;    static char *last_dir;    uilib_file_filter_enum_t filter[] = { UILIB_FILTER_KEYMAP, UILIB_FILTER_ALL };    resources_get_int("KeymapIndex", &kindex);    kindex = (kindex & ~1) + vice_ptr_to_int(UI_MENU_CB_PARAM);    resname = machine_keymap_res_name_list[kindex];    vsync_suspend_speed_eval();    filename = ui_select_file(_("Read Keymap File"), NULL, 0, last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 0, NULL, UI_FC_LOAD);    switch (button) {        case UI_BUTTON_OK:            resources_set_string(resname, filename);            lib_free(last_dir);            util_fname_split(filename, &last_dir, NULL);            break;        default:            /* Do nothing special.  */            break;    }    lib_free(filename);}

static int set_joy(int v, void *param){    const int i = vice_ptr_to_int(param);    joy[i >> 5].direction[i & 0xf] = (int)v;    return 0;}

static int set_joystick_fire(int value, void *param){    ULONG portstate;    int port_idx = vice_ptr_to_int(param);    int joy_dev = joystick_port_map[port_idx];    joy_arch_init();    if (joy_dev != JOYDEV_NONE) {        if (joy_dev >= JOYDEV_JOY0 && joy_dev <= JOYDEV_JOY3) {            portstate = ReadJoyPort(joy_dev - JOYDEV_JOY0);            if ((portstate & JP_TYPE_MASK) != JP_TYPE_GAMECTLR) {                if (value != JPF_BUTTON_RED) {                    ui_error(translate_text(IDMES_DEVICE_NOT_GAMEPAD));                    value = JPF_BUTTON_RED;                }            }        } else {            ui_error(translate_text(IDMES_NOT_MAPPED_TO_AMIGA_PORT));            return -1;        }    } else {        if (value != JPF_BUTTON_RED) {            ui_error(translate_text(IDMES_NOT_MAPPED_TO_AMIGA_PORT));            return -1;        }    }    joystick_fire[port_idx] = value;    return 0;}

static int set_keyset(int v, void *param){    const int i = vice_ptr_to_int(param);    keyset[i >> 5][i & 0xf] = (int)v;    return 0;}

static int set_video_standard(const char *param, void *extra_param){    int value = vice_ptr_to_int(extra_param);    int vicii_model;    switch (machine_class) {        case VICE_MACHINE_C64SC:            resources_get_int("VICIIModel", &vicii_model);            switch (value) {                case MACHINE_SYNC_PAL:                default:                    if (vicii_model == VICII_MODEL_8562 || vicii_model == VICII_MODEL_8565) {                        return resources_set_int("VICIIModel", VICII_MODEL_8565);                    } else if (vicii_model == VICII_MODEL_6567R56A) {                        return resources_set_int("VICIIModel", VICII_MODEL_6569R1);                    } else {                        return resources_set_int("VICIIModel", VICII_MODEL_6569);                    }                    break;                case MACHINE_SYNC_NTSC:                    if (vicii_model == VICII_MODEL_8562 || vicii_model == VICII_MODEL_8565) {                        return resources_set_int("VICIIModel", VICII_MODEL_8562);                    } else {                        return resources_set_int("VICIIModel", VICII_MODEL_6567);                    }                    break;                case MACHINE_SYNC_NTSCOLD:                        return resources_set_int("VICIIModel", VICII_MODEL_6567R56A);                case MACHINE_SYNC_PALN:                        return resources_set_int("VICIIModel", VICII_MODEL_6572);            }        default:            return resources_set_int("MachineVideoStandard", value);    }}

static UI_CALLBACK(load_save_fliplist){    char *filename, *title;    int what = vice_ptr_to_int(UI_MENU_CB_PARAM);    ui_button_t button;    uilib_file_filter_enum_t filter[] = { UILIB_FILTER_FLIPLIST, UILIB_FILTER_ALL };    vsync_suspend_speed_eval();    title = util_concat(what ? _("Load ") : _("Save"), _("Flip list file"), NULL);    filename = ui_select_file(title, NULL, 0, load_save_fliplist_last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 1, NULL, what ? UI_FC_LOAD : UI_FC_SAVE);    lib_free(title);    switch (button) {        case UI_BUTTON_OK:            if (what) {                if (fliplist_load_list(FLIPLIST_ALL_UNITS, filename, 0) == 0) {                    ui_message(_("Successfully read `%s'."), filename);                } else {                    ui_error(_("Error reading `%s'."), filename);                }            } else {                if (fliplist_save_list(FLIPLIST_ALL_UNITS, filename) == 0) {                    ui_message(_("Successfully wrote `%s'"), filename);                } else {                    ui_error(_("Error writing `%s'."), filename);                }            }            lib_free(load_save_fliplist_last_dir);            util_fname_split(filename, &load_save_fliplist_last_dir, NULL);            break;        default:            break;    }}

static UI_MENU_CALLBACK(vsidui_tune_callback){    int command_or_tune = vice_ptr_to_int(param);    if (activated) {        int tune = sdl_vsid_current_tune;        if (command_or_tune == SDLUI_VSID_CMD_NEXT) {            ++tune;        } else if (command_or_tune == SDLUI_VSID_CMD_PREV) {            --tune;        } else {            tune = command_or_tune;        }        if ((tune < 1) || (tune > sdl_vsid_tunes)) {            return NULL;        }        if (tune != sdl_vsid_current_tune) {            sdl_vsid_current_tune = tune;            sdl_ui_menu_radio_helper(1, (ui_callback_data_t)int_to_void_ptr(tune), "PSIDTune");        }    } else {        if (command_or_tune == sdl_vsid_current_tune) {            return sdl_menu_text_tick;        } else if (command_or_tune > sdl_vsid_tunes && !(command_or_tune & SDLUI_VSID_CMD_MASK)) {            return "(N/A)";        }    }    return NULL;}

static UI_CALLBACK(datasette_settings){    int what = vice_ptr_to_int(UI_MENU_CB_PARAM);    char *prompt, *title, *resource;    char buf[50];    ui_button_t button;    int current;    long res;    if (what) {        prompt = title = _("Datasette speed tuning");        resource = "DatasetteSpeedTuning";    } else {        prompt = title = _("Datasette zero gap delay");        resource = "DatasetteZeroGapDelay";    }    resources_get_int(resource, &current);    sprintf(buf, "%d", current);    button = ui_input_string(title, prompt, buf, 50);    switch (button) {        case UI_BUTTON_OK:            if (util_string_to_long(buf, NULL, 10, &res) != 0) {                ui_error(_("Invalid value: %s"), buf);                return;            }            resources_set_int(resource, (int)res);            break;        default:            break;    }}

static int set_printer_device(int prn_dev, void *param){    if (prn_dev < 0 || prn_dev > 2) {        return -1;    }    printer_device[vice_ptr_to_int(param)] = (unsigned int)prn_dev;    return 0;}

static UI_MENU_CALLBACK(detach_cart_callback){    int m;    m = vice_ptr_to_int(param);    if (activated) {        cartridge_detach_image(m);    }    return NULL;}

static UI_MENU_CALLBACK(attach_cart_callback){    char *title;    char *name = NULL;    if (activated) {        switch (vice_ptr_to_int(param)) {        case CARTRIDGE_VIC20_FP:            title = "Select " CARTRIDGE_VIC20_NAME_FP " image";            break;        case CARTRIDGE_VIC20_MEGACART:            title = "Select " CARTRIDGE_VIC20_NAME_MEGACART " image";            break;        case CARTRIDGE_VIC20_FINAL_EXPANSION:            title = "Select " CARTRIDGE_VIC20_NAME_FP " image";            break;        case CARTRIDGE_VIC20_DETECT:        case CARTRIDGE_VIC20_GENERIC:            title = "Select cartridge image";            break;        case CARTRIDGE_VIC20_16KB_2000:        case CARTRIDGE_VIC20_16KB_4000:        case CARTRIDGE_VIC20_16KB_6000:            title = "Select 4/8/16kB image";            break;        case CARTRIDGE_VIC20_8KB_A000:            title = "Select 4/8kB image";            break;        case CARTRIDGE_VIC20_4KB_B000:        default:            title = "Select 4kB image";            break;        }        name = sdl_ui_file_selection_dialog(title, FILEREQ_MODE_CHOOSE_FILE);        if (name != NULL) {            if (cartridge_attach_image(vice_ptr_to_int(param), name) < 0) {                ui_error("Cannot load cartridge image.");            }            lib_free(name);        }    }    return NULL;}

static UI_MENU_CALLBACK(select_cbm2_model_callback){    int model;    model = vice_ptr_to_int(param);    if (activated) {        cbm2model_set(model);    }    return NULL;}

int set_joyB_autoCal(const char *value, void *extra_param){    joy[1].autocal = vice_ptr_to_int(extra_param);    if (joy[1].autocal) {        joy[1].start = TRUE;    }    return FALSE;}

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 cart_attach_cmdline(const char *param, void *extra_param){    int type = vice_ptr_to_int(extra_param);    /* NULL param is used for +cart */    if (!param) {        cartridge_detach_image(-1);        return 0;    }    return cartridge_attach_image(type, param);}

static UI_MENU_CALLBACK(c64_cart_flush_callback){    if (activated) {        int cartid = vice_ptr_to_int(param);        if (cartridge_flush_image(cartid) < 0) {            ui_error("Cannot save cartridge image.");        }    }    return NULL;}

static UI_MENU_CALLBACK(custom_SidModel_callback){    int engine, model, selected;    selected = vice_ptr_to_int(param);    if (activated) {        engine = selected >> 8;        model = selected & 0xff;        sid_set_engine_model(engine, model);    } else {

static gboolean joys_draw(GtkWidget *w, GdkEvent *event, gpointer data){    int i;    int joystick_number = vice_ptr_to_int(data);    int num_app_shells = get_num_shells();    for (i = 0; i < num_app_shells; i++) {        joystick_status_widget *ds = &app_shells[i].joystick_status[joystick_number];        set_joy(ds->colors, i, joystick_number);    }    return 0;}

static int set_joystick_device(int val, void *param){    int port_idx = vice_ptr_to_int(param);    if (joy_arch_set_device(port_idx, val) < 0) {        return -1;    }    joystick_port_map[port_idx] = val;    return 0;}

static int set_printer_driver(const char *name, void *param){    driver_select_list_t *list;    list = driver_select_list;    if (list == NULL)        return -1;    do {        if (!strcmp(list->driver_select.drv_name, name)) {            util_string_set(&printer_driver[vice_ptr_to_int(param)], name);            memcpy(&driver_select[vice_ptr_to_int(param)], &(list->driver_select),                   sizeof(driver_select_t));            return 0;        }        list = list->next;    } while (list != NULL);    return -1;}

static int set_drive_extend_image_policy(int val, void *param){    switch (val) {        case DRIVE_EXTEND_NEVER:        case DRIVE_EXTEND_ASK:        case DRIVE_EXTEND_ACCESS:            drive_context[vice_ptr_to_int(param)]->drive->extend_image_policy = val;            return 0;        default:            return -1;    }}