Hallo msch,
Ich habe, alledings in in einem anderen Zusammenhang, die Erfahrung
machen müssen, daß innerhalb des APIs ein Unterschied zwischen der
alten und der neuen UDF-Methode gemacht wird. Für die neue Methode
würde ich an Deiner Stelle einmal dieses Beispiel austesten.
Ich habe es zwar noch nicht getestet, wünsche Dir aber viel Glück.
Gruß Michael
Date: 14-NOV-2002
Subject: Sample API
program to create instantiated udf
Source: UG/Answer
/*HEAD CREATE_INSTANTIATED_UDF CCC UFUN */
#include <stdio.h>
#include <string.h>
#include <uf.h>
#include <uf_ui.h>
#include <uf_object_types.h>
#include <uf_part.h>
#include <uf_modl.h>
#include <uf_disp.h>
#include <uf_obj.h>
#include <uf_assem.h>
#include <uf_cfi.h>
#define UF_CALL(X) (report_error( __FILE__, __LINE__, #X, (X)))
static int report_error( char *file, int line, char *call, int irc)
{
if (irc)
{
char err[133],
msg[133];
sprintf(msg, "*** ERROR code %d at line %d in %s:\n+++ ",
irc, line, file);
UF_get_fail_message(irc, err);
/* NOTE: UF_print_syslog is new in V18 */
UF_print_syslog(msg, FALSE);
UF_print_syslog(err, FALSE);
UF_print_syslog("\n", FALSE);
UF_print_syslog(call, FALSE);
UF_print_syslog(";\n", FALSE);
if (!UF_UI_open_listing_window())
{
UF_UI_write_listing_window(msg);
UF_UI_write_listing_window(err);
UF_UI_write_listing_window("\n");
UF_UI_write_listing_window(call);
UF_UI_write_listing_window(";\n");
}
}
return(irc);
}
static tag_t ask_next_feature_of_type(tag_t part, char *type, tag_t feat)
{
char
*this_type;
while (!UF_CALL(UF_OBJ_cycle_objs_in_part(part, UF_feature_type, &feat))
&& (feat != NULL_TAG))
{
if (UF_OBJ_ask_status(feat) == UF_OBJ_ALIVE)
{
UF_CALL(UF_MODL_ask_feat_type(feat, &this_type));
if (!strcmp(this_type, type))
{
UF_free(this_type);
return feat;
}
UF_free(this_type);
}
}
return NULL_TAG;
}
static void report_load_status(UF_PART_load_status_t *status)
{
char
msg[133];
int
ii;
for (ii=0; ii<status->n_parts; ii++)
{
UF_get_fail_message(status->statuses[ii], msg);
printf(" %s - %s\n", status->file_names[ii], msg);
}
if (status->n_parts > 0)
{
UF_free(status->statuses);
UF_free_string_array(status->n_parts, status->file_names);
}
}
static void combine_directory_and_wildcard(char *dir, char *fltr, char *spec)
{
if (!strcmp(dir, ""))
strcpy(spec, fltr);
else
{
UF_CALL(uc4575(dir, 0, "junk.xxx", spec));
strcpy(strstr(spec, "junk.xxx"), fltr);
}
}
static logical prompt_for_part_name(char *prompt, char *fspec)
{
int
resp;
char
filter[MAX_FSPEC_SIZE+1],
*p_dir,
*p_ext;
UF_CALL(UF_UI_ask_dialog_directory(UF_UI_PART_DIR, &p_dir));
UF_CALL(UF_UI_ask_dialog_filter(UF_UI_PART_OPEN_FLTR, &p_ext));
combine_directory_and_wildcard(p_dir, p_ext, filter);
UF_free(p_dir);
UF_free(p_ext);
if (!UF_CALL(UF_UI_create_filebox(prompt, "Part Name", filter, "", fspec,
&resp)) && (resp != UF_UI_CANCEL)) return TRUE;
else return FALSE;
}
static logical prompt_for_text(char *prompt, char *text)
{
int
n,
resp;
resp = uc1600(prompt, text, &n);
if (resp == 3 | | resp == 5) return TRUE;
return FALSE;
}
static int allocate_string_array(int n_elements, int n_chars, void ***where)
{
int
ii,
resp;
*where = UF_allocate_memory(n_elements * sizeof(char *), &resp);
for (ii = 0; ii < n_elements; ii++)
{
(*where)[ii] = UF_allocate_memory(n_chars * sizeof(char), &resp);
if (resp) return resp;
}
return 0;
}
/*ARGSUSED*/
static int mask_add_faces_and_edges(UF_UI_selection_p_t select, void *type)
{
UF_UI_mask_t
mask[2] = { { UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_FACE },
{ UF_solid_type, 0, UF_UI_SEL_FEATURE_ANY_EDGE } };
if (!UF_CALL(UF_UI_set_sel_mask(select,
UF_UI_SEL_MASK_ENABLE_SPECIFIC, 2, mask)))
return (UF_UI_SEL_SUCCESS);
else
return (UF_UI_SEL_FAILURE);
}
static tag_t select_anything(char *prompt)
{
double
cp[3];
int
resp;
tag_t
object,
view;
UF_CALL(UF_UI_set_cursor_view(0));
UF_CALL(UF_UI_select_with_single_dialog( "Select an object", prompt,
UF_UI_SEL_SCOPE_WORK_PART, mask_add_faces_and_edges, NULL, &resp,
&object, cp, &view));
UF_CALL(UF_UI_set_cursor_view(1));
if (resp == UF_UI_OBJECT_SELECTED | | resp == UF_UI_OBJECT_SELECTED_BY_NAME)
{
UF_CALL(UF_DISP_set_highlight(object, 0));
return object;
}
else return NULL_TAG;
}
static void do_it(void)
{
int
error,
ii,
num_parents,
num_expression;
tag_t
*expression = NULL,
exp,
feature = NULL_TAG,
*new_parents = NULL,
new_udf_feature,
*parents = NULL,
part,
prev_work_part;
char
**exp_rhs,
**expression_prompt = NULL,
*lhs,
**parents_prompt = NULL,
*rhs,
*string,
udf_part[MAX_FSPEC_SIZE+1] = { "" },
udf_cgm[MAX_FSPEC_SIZE+1];
UF_PART_load_status_t
error_status;
if (!prompt_for_part_name("UDF part", udf_part)) return;
strcpy(udf_cgm, udf_part);
strcpy(strstr(udf_cgm, ".prt"), ".cgm");
UF_CALL(UF_PART_open_quiet(udf_part, &part, &error_status));
if (error_status.n_parts > 0) report_load_status(&error_status);
UF_CALL(UF_ASSEM_set_work_part_quietly(part, &prev_work_part));
feature = ask_next_feature_of_type(part, "UDF_DEF", feature);
UF_CALL(UF_MODL_ask_udf_definition(feature, &parents, &parents_prompt,
&num_parents, &expression, &expression_prompt, &num_expression));
UF_CALL(UF_ASSEM_set_work_part_quietly(prev_work_part, &part));
new_parents = (tag_t *)UF_allocate_memory(sizeof(tag_t)*num_parents,
&error);
for (ii = 0; ii < num_parents; ii++)
new_parents[ii] = select_anything(parents_prompt[ii]);
UF_CALL(allocate_string_array(num_expression, UF_MAX_EXP_LENGTH,
(void ***)&exp_rhs));
for (ii = 0; ii < num_expression; ii++)
{
UF_CALL(UF_MODL_ask_exp_tag_string(expression[ii], &string));
UF_CALL(UF_MODL_dissect_exp_string(string, &lhs, &rhs, &exp));
strcpy(exp_rhs[ii], rhs);
UF_free(lhs);
UF_free(rhs);
UF_free(string);
prompt_for_text(expression_prompt[ii], exp_rhs[ii]);
}
UF_CALL(UF_MODL_register_rpo_routine(UF_MODL_udf_rpo_menu));
UF_CALL(UF_MODL_create_instantiated_udf(feature, udf_cgm, parents,
new_parents, num_parents, expression, exp_rhs, num_expression,
&new_udf_feature));
UF_CALL(UF_MODL_unregister_rpo_routine());
UF_free(parents);
UF_free(new_parents);
UF_free_string_array(num_parents, parents_prompt) ;
UF_free(expression);
UF_free_string_array(num_expression, expression_prompt);
UF_free_string_array(num_expression, exp_rhs);
UF_CALL(UF_PART_close(part, 0, 1));
}
/*ARGSUSED*/
void ufusr(char *param, int *retcode, int paramLen)
{
if (UF_CALL(UF_initialize())) return;
do_it();
UF_terminate();
}
int ufusr_ask_unload(void)
{
/* Note: can NOT be unloaded - calls UF_MODL_register_rpo_routine. */
return (UF_UNLOAD_UG_TERMINATE);
}
------------------
Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP
Foren auf CAD.de (alle Foren)
| 
