int set_Cmiss_region_or_group(struct Parse_state *state, void *region_address_void, void *group_address_void) { Cmiss_region_id *region_address = reinterpret_cast<Cmiss_region_id*>(region_address_void); Cmiss_field_group_id *group_address = reinterpret_cast<Cmiss_field_group_id*>(group_address_void); if (!(state && region_address && *region_address && group_address && !*group_address)) return 0; const char *current_token = state->current_token; int return_code = 1; if (!current_token) { display_message(WARNING_MESSAGE, "Missing region/group path"); display_parse_state_location(state); return_code = 0; } else if (Parse_state_help_mode(state)) { display_message(INFORMATION_MESSAGE, " REGION_PATH/GROUP"); } else { char *region_path = 0; char *field_name = 0; Cmiss_region_id output_region = 0; if (Cmiss_region_get_partial_region_path(*region_address, current_token, &output_region, ®ion_path, &field_name) && output_region) { REACCESS(Cmiss_region)(region_address, output_region); if (field_name) { Cmiss_field *field = FIND_BY_IDENTIFIER_IN_MANAGER(Computed_field,name)( field_name, Cmiss_region_get_Computed_field_manager(output_region)); *group_address = Cmiss_field_cast_group(field); if (0 == *group_address) { return_code = 0; } } if (return_code) { shift_Parse_state(state, 1); } } else { return_code = 0; } if (!return_code) { display_message(ERROR_MESSAGE, "Invalid region or group path: %s", current_token); display_parse_state_location(state); } DEALLOCATE(region_path); DEALLOCATE(field_name); } return return_code; }
int set_Cmiss_region(struct Parse_state *state, void *region_address_void, void *root_region_void) { const char *current_token; int return_code; struct Cmiss_region *region, **region_address, *root_region; ENTER(set_Cmiss_region); if (state && (root_region = static_cast<struct Cmiss_region *>(root_region_void)) && (region_address = static_cast<struct Cmiss_region **>(region_address_void))) { if ((current_token = state->current_token)) { if (!Parse_state_help_mode(state)) { region = Cmiss_region_find_subregion_at_path(root_region, current_token); if (region) { //-- REACCESS(Cmiss_region)(region_address, region); return_code = shift_Parse_state(state, 1); } else { display_message(ERROR_MESSAGE, "set_Cmiss_region: Could not find subregion %s", current_token); display_parse_state_location(state); return_code = 0; } } else { display_message(INFORMATION_MESSAGE," PATH_TO_REGION"); if (*region_address) { char *path = Cmiss_region_get_path(*region_address); display_message(INFORMATION_MESSAGE, "[%s]", path); DEALLOCATE(path); } return_code = 1; } } else { display_message(ERROR_MESSAGE, "Missing region path"); display_parse_state_location(state); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_Cmiss_region. Missing state"); return_code = 0; } LEAVE; return (return_code); }
/***************************************************************************//** * Modifier function to set the region, region path and field name. * Fields must not be the same name as a child region. * * Examples: * /heart/coordinates = region path and field name * heart = region path only * coordinates = field name only * @param region_path_and_name a struct Cmiss_region_path_and_name which if * set contains an ACCESSed region and allocated path and name which caller * is required to clean up. Name may be NULL if path is fully resolved. */ static int set_region_path_and_or_field_name(struct Parse_state *state, void *region_path_and_name_void, void *root_region_void) { const char *current_token; int return_code; struct Cmiss_region_path_and_name *name_data; struct Cmiss_region *root_region; ENTER(set_region_path_and_or_field_name); if (state && (name_data = (struct Cmiss_region_path_and_name *)region_path_and_name_void) && (root_region = (struct Cmiss_region *)root_region_void)) { current_token = state->current_token; if (!current_token) { display_message(WARNING_MESSAGE, "Missing region path and/or field name"); display_parse_state_location(state); return_code = 0; } else if (Parse_state_help_mode(state)) { display_message(INFORMATION_MESSAGE, " REGION_PATH|REGION_PATH/FIELD_NAME|FIELD_NAME"); return_code = 1; } else if (Cmiss_region_get_partial_region_path(root_region, current_token, &name_data->region, &name_data->region_path, &name_data->name)) { ACCESS(Cmiss_region)(name_data->region); if (!name_data->name || (NULL == strchr(name_data->name, CMISS_REGION_PATH_SEPARATOR_CHAR))) { return_code = shift_Parse_state(state, 1); } else { display_message(ERROR_MESSAGE, "Bad region path and/or field name: %s",current_token); display_parse_state_location(state); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_region_path_and_or_field_name. Failed to get path and name"); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_region_path_and_or_field_name. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); }
/** * Executes a GFX DEFINE GLYPH command. */ int gfx_define_glyph(struct Parse_state *state, void *glyph_name_void, void *define_glyph_data_void) { int return_code = 1; Define_glyph_data *define_glyph_data = static_cast<Define_glyph_data *>(define_glyph_data_void); if ((state) && (define_glyph_data)) { if (state->current_token) { const char *glyph_name = static_cast<char *>(glyph_name_void); bool process = false; if (glyph_name) { process = true; } else { if (Parse_state_help_mode(state)) { glyph_name = "GLYPH_NAME"; Option_table *option_table = CREATE(Option_table)(); Option_table_add_entry(option_table, "GLYPH_NAME", (void *)glyph_name, define_glyph_data_void, gfx_define_glyph); return_code = Option_table_parse(option_table, state); DESTROY(Option_table)(&option_table); } else { glyph_name = state->current_token; shift_Parse_state(state, 1); process = true; } } if (process) { char *scene_path_name = 0; struct Option_table *option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The 'scene' option defines a static glyph from the named graphics " "at the region/scene path."); /* scene (graphics) */ Option_table_add_string_entry(option_table, "scene", &scene_path_name, " [/REGION_PATH.]GRAPHICS_NAME"); return_code = Option_table_multi_parse(option_table, state); if (return_code) { cmzn_graphics* graphics = 0; const char *scene_name = 0; const char *graphics_name = 0; if (scene_path_name) export_object_name_parser(scene_path_name, &scene_name, &graphics_name); cmzn_region *input_region = cmzn_region_find_subregion_at_path(define_glyph_data->root_region, scene_name); if (input_region && graphics_name) { cmzn_scene_id scene = cmzn_region_get_scene(input_region); graphics = cmzn_scene_find_graphics_by_name(scene, graphics_name); cmzn_scene_destroy(&scene); } if (!graphics) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Invalid scene region path or graphics name"); return_code = 0; } else { cmzn_glyphmodule_begin_change(define_glyph_data->glyphmodule); cmzn_glyph_id glyph = cmzn_glyphmodule_find_glyph_by_name(define_glyph_data->glyphmodule, glyph_name); if (glyph) { struct GT_object *graphics_object = cmzn_graphics_copy_graphics_object( graphics); if (!cmzn_glyph_set_graphics_object(glyph, graphics_object)) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Unable to change glyph"); return_code = 0; } DEACCESS(GT_object)(&graphics_object); } else { glyph = cmzn_glyphmodule_create_static_glyph_from_graphics(define_glyph_data->glyphmodule, graphics); if ((CMZN_OK != cmzn_glyph_set_name(glyph, glyph_name)) || (CMZN_OK != cmzn_glyph_set_managed(glyph, true))) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Failed"); return_code = 0; } } cmzn_glyph_destroy(&glyph); cmzn_glyphmodule_end_change(define_glyph_data->glyphmodule); } cmzn_graphics_destroy(&graphics); cmzn_region_destroy(&input_region); if (scene_name) DEALLOCATE(scene_name); if (graphics_name) DEALLOCATE(graphics_name); } if (scene_path_name) DEALLOCATE(scene_path_name); DESTROY(Option_table)(&option_table); } } else { display_message(ERROR_MESSAGE, "Missing glyph name"); display_parse_state_location(state); return_code=0; } } else { display_message(ERROR_MESSAGE, "gfx_define_glyph. Invalid argument(s)"); return_code = 0; } return (return_code); }
int set_Glyph(struct Parse_state *state, void *glyphAddress_void, void *glyphmodule_void) { int return_code; cmzn_glyph **glyphAddress = reinterpret_cast<cmzn_glyph **>(glyphAddress_void); cmzn_glyphmodule *glyphmodule = reinterpret_cast<cmzn_glyphmodule *>(glyphmodule_void); if (state && glyphAddress && glyphmodule) { const char *current_token = state->current_token; if (current_token) { if (!Parse_state_help_mode(state)) { if (fuzzy_string_compare(current_token, "NONE")) { if (*glyphAddress) { cmzn_glyph_destroy(glyphAddress); } return_code=1; } else { cmzn_glyph *glyph = cmzn_glyphmodule_find_glyph_by_name(glyphmodule, current_token); if (glyph) { if (*glyphAddress) { cmzn_glyph_destroy(glyphAddress); } *glyphAddress = glyph; return_code = 1; } else { display_message(ERROR_MESSAGE, "Unknown glyph : %s", current_token); return_code = 0; } } shift_Parse_state(state, 1); } else { display_message(INFORMATION_MESSAGE," GLYPH_NAME|none"); /* if possible, then write the name */ cmzn_glyph *glyph = *glyphAddress; if (glyph) { display_message(INFORMATION_MESSAGE, "[%s]", glyph->getName()); } else { display_message(INFORMATION_MESSAGE, "[none]"); } return_code = 1; } } else { display_message(WARNING_MESSAGE, "Missing glyph name"); display_parse_state_location(state); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_Glyph. Invalid argument(s)"); return_code = 0; } return (return_code); }
int set_Cmiss_region_path(struct Parse_state *state, void *path_address_void, void *root_region_void) /******************************************************************************* LAST MODIFIED : 13 January 2003 DESCRIPTION : Modifier function for entering a path to a Cmiss_region, starting at <root_region>. ==============================================================================*/ { const char *current_token; char **path_address; int return_code; struct Cmiss_region *region, *root_region; ENTER(set_Cmiss_region_path); if (state && (root_region = (struct Cmiss_region *)root_region_void)) { if ((current_token = state->current_token)) { if (!Parse_state_help_mode(state)) { region = Cmiss_region_find_subregion_at_path( root_region, current_token); if (region) { if ((path_address = (char **)path_address_void)) { if (*path_address) { DEALLOCATE(*path_address); } if ((*path_address = duplicate_string(current_token))) { return_code = shift_Parse_state(state, 1); } else { display_message(ERROR_MESSAGE, "set_Cmiss_region_path. Could not allocate memory for path"); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_Cmiss_region_path. Missing path_address"); return_code = 0; } DEACCESS(Cmiss_region)(®ion); } else { display_message(ERROR_MESSAGE, "Invalid region path: %s", current_token); display_parse_state_location(state); return_code = 0; } } else { display_message(INFORMATION_MESSAGE," PATH_TO_REGION"); if ((path_address = (char **)path_address_void) && (*path_address)) { display_message(INFORMATION_MESSAGE, "[%s]", *path_address); } return_code = 1; } } else { display_message(ERROR_MESSAGE, "Missing region path"); display_parse_state_location(state); return_code = 0; } } else { display_message(ERROR_MESSAGE, "set_Cmiss_region_path. Missing state"); return_code = 0; } LEAVE; return (return_code); } /* set_Cmiss_region_path */