/*====================================================================*\ FILE : GearDesign.c PURPOSE : Gear Design Application Demo HISTORY: DATE BUILD AUTHOR MODIFICATIONS 26-Oct-98 I-01-24 Pavel $$1 Created 03-Nov-98 I-01-25 Pavel $$2 Fixed for the pipe mode. Fixed for C++ compiler 30-Mar-01 J-01-31 Shirish $$3 Fixed for changes in hole element tree 09-Apr-01 J-01-31 Milind Added parameter Pressure angle \*====================================================================*/ /*--------------------------------------------------------------------*\ Pro/TOOLKIT includes \*--------------------------------------------------------------------*/ #include "ProToolkit.h" #include "ProDtmPln.h" #include "ProElement.h" #include "ProElempath.h" #include "ProExtrude.h" #include "ProFeature.h" #include "ProFeatForm.h" #include "ProFeatType.h" #include "ProGroup.h" #include "ProHole.h" #include "ProLayer.h" #include "ProMdl.h" #include "ProMenu.h" #include "ProMessage.h" #include "ProModelitem.h" #include "ProModFeat.h" #include "ProParameter.h" #include "ProParamval.h" #include "ProPattern.h" #include "ProSecdim.h" #include "ProSelection.h" #include "ProSolid.h" #include "ProSurface.h" #include "ProStdSection.h" #include "ProUtil.h" /*--------------------------------------------------------------------*\ Pro/DEVELOP includes \*--------------------------------------------------------------------*/ #include "prodevelop.h" #include "pro_unit.h" #include "select3d.h" /*--------------------------------------------------------------------*\ C System includes \*--------------------------------------------------------------------*/ #include #include /*--------------------------------------------------------------------*\ Application includes \*--------------------------------------------------------------------*/ #include "TestError.h" #include "UtilMessage.h" #include "UtilString.h" #include "UtilMath.h" #include "UtilMenu.h" #include "UtilTree.h" #include "UtilCollect.h" /*--------------------------------------------------------------------*\ Macros \*--------------------------------------------------------------------*/ #ifdef MSGFIL #undef MSGFIL #endif #define MSGFIL msgfil #define SECTION_MAX_PARAMS 8 #define SIZEOFARR(a) (sizeof(a)/sizeof(a[0])) #define DTMPLN_CREATE "Datum Planes" #define GEARDISK_CREATE "Gear Disk" #define GEARHOLE_CREATE "Gear Hole" #define TOOTHSURF_CREATE "Tooth Surf" #define TOOTH_CREATE "Gear Tooth" #define TEETH_CREATE "N Teeth" #define HUB_CREATE "Gear Hub" #define BACKPLATE_CREATE "Back Plate" #define KEYWAY_CREATE "Keyway" #define KEY_CREATE "Key" #define BACKNOTCH_CREATE "Back Notch" #define STR_PARAM 0 #define INT_PARAM 1 #define DOUB_PARAM 2 #define TAB_PARAM 3 #define SPUR_GEAR 0 #define RING_GEAR 1 #define sqr(a) ((a)*(a)) /*--------------------------------------------------------------------*\ Data types \*--------------------------------------------------------------------*/ typedef struct gear_param_struct { ProPart model; /* Parameters */ char name[PRO_NAME_SIZE]; int units; char material[PRO_NAME_SIZE]; int gear_type; /* 0 - spur,1 - ring */ double gear_diam; double gear_depth; double backplate_diam; double backplate_depth; double hub_out_diam; double hub_depth; int n_of_teeth; double tooth_par1; /* normal module */ double tooth_par2; double tooth_par3; double inner_diam; double keyway_in_width; double keyway_in_height; double keyway_out_width; double keyway_out_height; double backnotch_rad; int front_surface_id; int side_surface_id; int bottom_surface_id; int disk_front_surf_id; int disk_side_surf_id; int hole_side_surf_id; int hub_front_surf_id; int hub_side_surf_id; int backplate_back_surf_id; int backplate_side_surf_id; int tooth_surf_side_surf_id; int datum_created, disk_created, hole_created, tooth_created, teeth_created; int hub_created, backplate_created, keyway_created, backnotch_created; int key_created, tooth_surf_created; double Pressure_angle; } GearParam; typedef struct tableraw { char *string_val; int int_val; } TableRaw; typedef struct param { int type; /* 0 - string, 1 - int, 2 - double, 3 - table */ int length; /* for string - max lenght */ char *param_name; ProBool required; /* 1 - required, 0 - optional */ TableRaw *table; /* for table only */ int tablesize; /* for table only */ ProBool set; void *value; } Param; typedef union { int i; double d; void *p; ProSelection r; } Parameter; typedef struct feature_def { ElemTreeData *tree; int sizeof_tree; Parameter params[SECTION_MAX_PARAMS]; ProError (*section_create_func)(ProSection section, Parameter *params); char *feat_name; } FeatureDef; typedef struct feat_by_name { char *name; int id; } FeatByName; typedef struct feat_by_name_find { FeatByName *feats; int num_feats; } FeatByNameFind; /*--------------------------------------------------------------------*\ Application global/external data \*--------------------------------------------------------------------*/ ProFileName msgfil; static TableRaw Length_unit[] = { {"cm", UNIT_CM}, {"foot", UNIT_FOOT}, {"inch", UNIT_INCH}, {"m", UNIT_M}, {"mm", UNIT_MM}}; static TableRaw Yes_no_tab[] = { {"no", 0}, {"yes", 1}}; static TableRaw GearType [] = { {"spur", SPUR_GEAR}, {"ring", RING_GEAR}}; static Param param_def[] = { {STR_PARAM, PRO_NAME_SIZE, "Name_of_model", 1}, {TAB_PARAM, 0, "Units", 1, Length_unit, SIZEOFARR(Length_unit)}, {STR_PARAM, PRO_NAME_SIZE, "Material", 0}, {TAB_PARAM, 0, "GearType", 0, GearType, SIZEOFARR(GearType)}, {DOUB_PARAM, 0, "Gear_Outer_Diameter", 1}, {DOUB_PARAM, 0, "Gear_Disk_Depth", 1}, {DOUB_PARAM, 0, "Outer_Plate_Diameter", 0}, {DOUB_PARAM, 0, "Outer_Plate_Depth", 0}, {DOUB_PARAM, 0, "Support_Hub_Outer_Diameter", 0}, {DOUB_PARAM, 0, "Support_Hub_Depth", 0}, {DOUB_PARAM, 0, "Inner_Diameter", 1}, {INT_PARAM, 0, "Number_of_teeth", 1}, {DOUB_PARAM, 0, "Keyway_inner_width", 0}, {DOUB_PARAM, 0, "Keyway_inner_height", 0}, {DOUB_PARAM, 0, "Key_outer_width", 0}, {DOUB_PARAM, 0, "Key_outer_height", 0}, {DOUB_PARAM, 0, "GearTooth_param1", 1}, {DOUB_PARAM, 0, "GearTooth_param2", 0}, {DOUB_PARAM, 0, "GearTooth_param3", 0}, {DOUB_PARAM, 0, "Backnotch_Radius", 0}, {DOUB_PARAM, 0, "Pressure_angle", 1}, }; /*---------------------------------------------------------------------*\ Functions declaration \*---------------------------------------------------------------------*/ int ProUserNewgearMenu(); int ProUserNewgearCreateMenu(GearParam *g_ptr); int ProUserDeleteDesign(GearParam *g_ptr); int ProUserModifyDesign(GearParam *g_ptr); int ProUserRegenerate(GearParam *g_ptr); int ProUserMaterial(GearParam *g_ptr); int ProUserViews(GearParam *g_ptr); int ProUserCreateDatum(GearParam *g_ptr); int ProUserCreateDisk(GearParam *g_ptr); int ProUserCreateHole(GearParam *g_ptr); int ProUserCreateTooth(GearParam *g_ptr); int ProUserCreateTeeth(GearParam *g_ptr); int ProUserCreateToothSurf(GearParam *g_ptr); int ProUserCreateHub(GearParam *g_ptr); int ProUserCreateBackPlate(GearParam *g_ptr); int ProUserCreateKeyway(GearParam *g_ptr); int ProUserCreateKey(GearParam *g_ptr); int ProUserCreateBackNotch(GearParam *g_ptr); int ProUserSelectView(GearParam *g_ptr); int ProUserCreateViewAuto(GearParam *g_ptr); int ProUserCreateViewManual(GearParam *g_ptr); ProError ProUserCheckFeatures(GearParam *g_ptr); int ProUserFeatsReorder(GearParam *g_ptr); int ProUserReadParamFile(char *, GearParam *g_ptr); void ProUserFeatErrsPrint(char *, ProError,ProElement,ProErrorlist *); ProError ProUtilCreateSketchedFeature(GearParam *, FeatureDef *, ProFeature *); ProError ProUtilModelitemNameSet(ProModelitem *modelitem, char *name); ProError ProUtilFeatsByName(ProSolid model, FeatByName *p_feat, int); ProError ProUtilSelectionFromSurfaceId(ProMdl, int s_id, ProSelection *); ProError ProUtilCreateCircleSection(ProSection section, Parameter *params); ProError ProUtilCreateToothSection(ProSection section, Parameter *params); ProError ProUtilCreateKeySection(ProSection section, Parameter *params); ProError ProUtilCreateNotchSection(ProSection section, Parameter *params); ProError ProUtilTwoCircleIntersection(Pro2dCircledef *, Pro2dCircledef *, Pro2dPnt p1, Pro2dPnt p2); ProError ProUtilGeometryAtPointFind(ProPart part, Pro3dPnt point, ProModelitem *); ProError ProUtilFeatFirstGeomitem(ProFeature *datum_plane, ProType, int *); /*=============================================================*\ Function: ProUserNewgearMenu Purpose: display "New Gear" Menu \*=============================================================*/ int ProUserNewgearMenu() { GearParam *g_ptr; int m_id, action, first=0; ProMdl model; ProError err; ProName name; static int mode=0; ProLine w_ext; char line[PRO_PATH_SIZE]; ProParameter param; ProParamvalue parvalue; ProModelitem modelitem; ProPath *w_path_arr, w_def_path, w_sel_path; ProName *w_path_lab_arr; /*-----------------------------------------------------------------*\ Check Gear Design \*-----------------------------------------------------------------*/ err = ProMdlCurrentGet(&model); if (err != PRO_TK_NO_ERROR) return (-1); ProMdlToModelitem(model, &modelitem); ProStringToWstring(name, "Gear_Design"); err = ProParameterInit(&modelitem, name, ¶m); if (err == PRO_TK_NO_ERROR) { ProParameterValueGet(¶m, &parvalue); ProWstringToString(line, parvalue.value.s_val); } else { ProMessageDisplay(MSGFIL, "USER Select a parameter file"); ProStringToWstring(w_def_path, "."); ProStringToWstring(w_ext, "*.txt"); /* No default dirs */ err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&w_path_arr); err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&w_path_lab_arr); /* Open file */ err = ProFileOpen(NULL, w_ext, w_path_arr, w_path_lab_arr, w_def_path, NULL, w_sel_path); ProArrayFree((ProArray*)&w_path_arr); ProArrayFree((ProArray*)&w_path_lab_arr); ProWstringToString(line, w_sel_path); first = 1; } g_ptr = (GearParam*)calloc(1, sizeof(GearParam)); g_ptr->model = (ProPart)model; if (ProUserReadParamFile(line ,g_ptr)!=0) { free(g_ptr); return (-1); } if (first) { ProParamvalueSet(&parvalue, (void *)w_sel_path, PRO_PARAM_STRING); ProParameterCreate(&modelitem, name, &parvalue, ¶m); ProStringToWstring(name, g_ptr->name); ProMdlRename(model, name); ProStringToWstring(name, g_ptr->material); ProPartMaterialSet((ProPart)model, name); prodb_set_model_units((Prohandle)model, LENGTH_UNIT, g_ptr->units, NULL, 1); } /*-----------------------------------------------------------------*\ Collect information about created features \*-----------------------------------------------------------------*/ if (ProUserCheckFeatures(g_ptr)!=PRO_TK_NO_ERROR) { ProMessageDisplay(MSGFIL, "USER Error while check Gear Design"); return (-1); } /*-----------------------------------------------------------------*\ Create all user's menus \*-----------------------------------------------------------------*/ ProMenuFileRegister("New Gear", "new_gear.mnu", &m_id); ProMenubuttonActionSet("New Gear", "Create", (ProMenubuttonAction)ProUserNewgearCreateMenu, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Delete", (ProMenubuttonAction)ProUserDeleteDesign, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Regenerate", (ProMenubuttonAction)ProUserRegenerate, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Modify", (ProMenubuttonAction)ProUserModifyDesign, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Material", (ProMenubuttonAction)ProUserMaterial, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Named Views", (ProMenubuttonAction)ProUserViews,(ProAppData)g_ptr, 0); ProMenubuttonActionSet("New Gear", "Done/Return", (ProMenubuttonAction)ProMenuDelete, NULL, 0); ProMenubuttonActionSet("New Gear", "New Gear", (ProMenubuttonAction)ProMenuDelete, NULL, 0); ProMenuFileRegister("Create Gear", "create_gear.mnu", &m_id); ProMenubuttonActionSet("Create Gear", DTMPLN_CREATE, (ProMenubuttonAction)ProUserCreateDatum, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", GEARDISK_CREATE, (ProMenubuttonAction)ProUserCreateDisk, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", GEARHOLE_CREATE, (ProMenubuttonAction)ProUserCreateHole, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", TOOTHSURF_CREATE, (ProMenubuttonAction)ProUserCreateToothSurf, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", TOOTH_CREATE, (ProMenubuttonAction)ProUserCreateTooth, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", TEETH_CREATE, (ProMenubuttonAction)ProUserCreateTeeth, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", HUB_CREATE, (ProMenubuttonAction)ProUserCreateHub, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", BACKPLATE_CREATE, (ProMenubuttonAction)ProUserCreateBackPlate, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", KEYWAY_CREATE, (ProMenubuttonAction)ProUserCreateKeyway, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", KEY_CREATE, (ProMenubuttonAction)ProUserCreateKey, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", BACKNOTCH_CREATE, (ProMenubuttonAction)ProUserCreateBackNotch, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Create Gear", "Done Create", (ProMenubuttonAction)ProMenuDelete, NULL, 0); ProMenubuttonActionSet("Create Gear", "Create Gear", (ProMenubuttonAction)ProMenuDelete, NULL, 0); ProMenuFileRegister("Gear Views", "views_gear.mnu", &m_id); ProMenubuttonActionSet("Gear Views", "Select", (ProMenubuttonAction)ProUserSelectView, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Gear Views", "Create Auto", (ProMenubuttonAction)ProUserCreateViewAuto, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Gear Views", "Create Manual", (ProMenubuttonAction)ProUserCreateViewManual, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Gear Views", "Done/Return", (ProMenubuttonAction)ProMenuDelete, (ProAppData)g_ptr, 0); ProMenubuttonActionSet("Gear Views", "Gear Views", (ProMenubuttonAction)ProMenuDelete, (ProAppData)g_ptr, 0); ProMenubuttonVisibilitySet("Create Gear", TOOTHSURF_CREATE, g_ptr->gear_type == RING_GEAR ? PRO_B_TRUE : PRO_B_FALSE); ProMenuCreate(PROMENUTYPE_MAIN, "New Gear", &m_id); ProMenuProcess("New Gear", &action); free(g_ptr); return (0); } /*=============================================================*\ Function: UserSetCreateMenubutton Purpose: enable/disable "Create Gear" menu buttons \*=============================================================*/ static void UserSetCreateMenubutton(GearParam *g_ptr) { ProUtilMenubuttonActivate("Create Gear", DTMPLN_CREATE, !g_ptr->datum_created); ProUtilMenubuttonActivate("Create Gear", GEARDISK_CREATE, g_ptr->datum_created && (!g_ptr->disk_created) && g_ptr->gear_diam>0 && g_ptr->gear_depth>0); ProUtilMenubuttonActivate("Create Gear", BACKPLATE_CREATE, g_ptr->datum_created && (!g_ptr->backplate_created) && g_ptr->backplate_diam>0 && g_ptr->backplate_depth); ProUtilMenubuttonActivate("Create Gear", GEARHOLE_CREATE, ((g_ptr->gear_type == SPUR_GEAR && g_ptr->disk_created) || (g_ptr->gear_type == RING_GEAR && g_ptr->backplate_created)) && (!g_ptr->hole_created) && g_ptr->inner_diam>0); ProUtilMenubuttonActivate("Create Gear", TOOTHSURF_CREATE, g_ptr->disk_created && g_ptr->gear_type == RING_GEAR && (!g_ptr->tooth_surf_created)); ProUtilMenubuttonActivate("Create Gear", TOOTH_CREATE, (g_ptr->gear_type == SPUR_GEAR ? g_ptr->disk_created : g_ptr->tooth_surf_created) && (!g_ptr->tooth_created) && (g_ptr->hub_created)&& (g_ptr->backnotch_created) && (g_ptr->hole_created)); ProUtilMenubuttonActivate("Create Gear", TEETH_CREATE, g_ptr->tooth_created && (!g_ptr->teeth_created)); ProUtilMenubuttonActivate("Create Gear", HUB_CREATE, ((g_ptr->gear_type == SPUR_GEAR && g_ptr->disk_created) || (g_ptr->gear_type == RING_GEAR && g_ptr->backplate_created)) && (!g_ptr->hub_created)); ProUtilMenubuttonActivate("Create Gear", KEYWAY_CREATE, g_ptr->hole_created && (!g_ptr->keyway_created) && g_ptr->keyway_in_width>0 && g_ptr->keyway_in_height>0); ProUtilMenubuttonActivate("Create Gear", KEY_CREATE, g_ptr->hub_created && (!g_ptr->key_created) && g_ptr->keyway_out_width>0 && g_ptr->keyway_out_height>0); ProUtilMenubuttonActivate("Create Gear", BACKNOTCH_CREATE, g_ptr->backplate_created && (!g_ptr->backnotch_created) && g_ptr->backnotch_rad >0); ProTreetoolRefresh(g_ptr->model); } /*=============================================================*\ Function: ProUserNewgearMenu Purpose: display "Create Gear" Menu \*=============================================================*/ int ProUserNewgearCreateMenu(GearParam *g_ptr) { int m_id, action; ProMenuCreate(PROMENUTYPE_MAIN, "Create Gear", &m_id); UserSetCreateMenubutton(g_ptr); ProMenuProcess("Create Gear", &action); return (0); } /*=============================================================*\ Function: ProUserDeleteDesign Purpose: delete current design \*=============================================================*/ int ProUserDeleteDesign(GearParam *g_ptr) { int n_sel, *feat_ids, i; ProSelection *p_sel; ProFeatureDeleteOptions opt[]= {PRO_FEAT_DELETE_CLIP}; ProModelitem modelitem; ProError err; ProMessageDisplay(MSGFIL , "USER Select feature(s) to be deleted"); err = ProSelect("feature", -1, NULL, NULL, NULL, NULL, &p_sel, &n_sel); if (err != PRO_TK_NO_ERROR || n_sel<=0) return 0; feat_ids = (int *)calloc(n_sel, sizeof(int)); for (i=0; imodel, feat_ids, n_sel, opt, 1); ProTreetoolRefresh(g_ptr->model); ProSolidDisplay((ProSolid)g_ptr->model); return (0); } /*=============================================================*\ Function: ProUserModifyDesign Purpose: modify current design \*=============================================================*/ int ProUserModifyDesign(GearParam *g_ptr) { int dim_id; Select3d *p_sel; int err, brk=0; double value, drange[2]; PRODIMENSION dimension; do { ProMessageDisplay(MSGFIL , "USER Select feature or dimension"); if (pro_select("dimension,feature", 1, &p_sel, NULL, NULL) < 1) return 0; if (p_sel[0].sel_type == SEL_3D_FEAT) { prodb_show_feat_params(p_sel, PRO_DIM_PARAM); } else { dim_id = p_sel->selected_id; prodim_get_dimension((Prohandle)g_ptr->model, dim_id, PRO_DIM_PARAM, &dimension); ProMessageDisplay(MSGFIL , "USER Enter new value for dimension [%0f]", &dimension.value); drange[0] = 0; drange[1] = 1e10; if (ProMessageDoubleRead(drange, &value)==PRO_TK_NO_ERROR) { dimension.value = value; err = prodim_set_and_display_dim((Prohandle)g_ptr->model, dim_id, &dimension); if (err!=1) prodim_reset_dim((Prohandle)g_ptr->model, dim_id); } } } while (!brk); } /*=============================================================*\ Function: ProUserRegenerate Purpose: regenerate model \*=============================================================*/ int ProUserRegenerate(GearParam *g_ptr) { if (g_ptr->model != NULL) ProSolidRegenerate((ProSolid)g_ptr->model, PRO_B_FALSE); ProSolidDisplay((ProSolid)g_ptr->model); return (0); } /*=============================================================*\ Function: ProUserMaterial Purpose: change material for gear \*=============================================================*/ int ProUserMaterial(GearParam *g_ptr) { ProName name; ProError err; err = ProPartMaterialNameGet((ProPart)g_ptr->model, name); if (err != PRO_TK_NO_ERROR) ProStringToWstring(name, ""); do { err = PRO_TK_NO_ERROR; ProMessageDisplay(MSGFIL, "USER Enter material name [%0w]", name); if (ProMessageStringRead(PRO_NAME_SIZE, name) == PRO_TK_NO_ERROR) { err = ProPartMaterialSet((ProPart)g_ptr->model, name); if (err != PRO_TK_NO_ERROR) ProMessageDisplay(MSGFIL, "USER Unable assign material %0w", name); else ProMessageDisplay(MSGFIL, "USER Material %0w was assigned to part", name); } } while (err!=PRO_TK_NO_ERROR); return (0); } /*=============================================================*\ Function: ProUserViews Purpose: display "Gear Views" menu \*=============================================================*/ int ProUserViews(GearParam *g_ptr) { int m_id, action; ProMenuCreate(PROMENUTYPE_MAIN, "Gear Views", &m_id); ProMenuProcess("Gear Views", &action); return (0); } /*=============================================================*\ Function: ProUserSelectView Purpose: retrieve a saved view \*=============================================================*/ int ProUserSelectView(GearParam *g_ptr) { ProError err; ProName *names, menu_title; wchar_t **w_strings; int num_views, i, n_sel; ProView view; err = ProViewNamesGet(g_ptr->model, &names, NULL, &num_views); if (err != PRO_TK_NO_ERROR || num_views<=0) { ProMessageDisplay(MSGFIL, "USER No view has been stored!"); return(0); } /*-----------------------------------------------------------------*\ Setup select menu for view names \*-----------------------------------------------------------------*/ ProUtilMenuStringsAlloc(&w_strings); for (i = 0; i < num_views; i++) ProUtilMenuStringsWstrAdd(&w_strings, names[i]); ProStringToWstring(menu_title, "VIEW NAMES"); err = ProUtilMenuStringsIntValueSelect("VIEW NAMES", w_strings, &n_sel); if (err != PRO_TK_NO_ERROR || n_sel < 0) return(0); err = ProViewRetrieve(g_ptr->model, w_strings[n_sel], &view); /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProUtilMenuStringsFree(&w_strings); err = ProArrayFree((ProArray*)&names); return (0); } /*=============================================================*\ Function: ProUserCreateViewAuto Purpose: Create "FRONT", "SIDE" and "BOTTOM" views \*=============================================================*/ int ProUserCreateViewAuto(GearParam *g_ptr) { ProView view; ProName name; int i; static char *names[]={"FRONT", "SIDE", "BOTTOM"}; ProMatrix ident={{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}}; double m[4]; for (i=0; i<3; i++) { ProStringToWstring(name, names[i]); ProViewStore(g_ptr->model, name, &view); ProViewMatrixSet(g_ptr->model, view, ident); memcpy(m, ident[0], 3*sizeof(double)); memcpy(ident[0], ident[1], 3*sizeof(double)); memcpy(ident[1], ident[2], 3*sizeof(double)); memcpy(ident[2], m, 3*sizeof(double)); } return (0); } /*=============================================================*\ Function: ProUserCreateViewManual Purpose: Create an user defined view \*=============================================================*/ int ProUserCreateViewManual(GearParam *g_ptr) { ProView view; ProName name; ProError err; ProMessageDisplay(MSGFIL, "USER Enter a view name"); err = ProMessageStringRead(PRO_NAME_SIZE, name); if (err == PRO_TK_NO_ERROR) { err = ProViewStore(g_ptr->model, name, &view); } return (err); } /*=============================================================*\ Function: ProUserCreateDatum Purpose: create "FRONT", "SIDE", "BOTTOM" datum planes \*=============================================================*/ int ProUserCreateDatum(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_DATUM}}, {1, PRO_E_DTMPLN_CONSTRAINTS, {(ProValueDataType)-1}}, {2, PRO_E_DTMPLN_CONSTRAINT, {(ProValueDataType)-1}}, {3, PRO_E_DTMPLN_CONSTR_TYPE, {PRO_VALUE_TYPE_INT, PRO_DTMPLN_DEF_X}} }; int axes[3] = { PRO_DTMPLN_DEF_X, PRO_DTMPLN_DEF_Y, PRO_DTMPLN_DEF_Z }; char *names[]={"SIDE","BOTTOM","FRONT"}; int i, *id[3]; ProSelection featsel; ProModelitem modelitem; ProFeature f; ProErrorlist errs; ProError err; ProElement elem_tree; id[0] = &g_ptr->side_surface_id; id[1] = &g_ptr->bottom_surface_id; id[2] = &g_ptr->front_surface_id; for (i=0; i<3; i++) { /*-----------------------------------------------------------------*\ Create Element Tree \*-----------------------------------------------------------------*/ tree[4].data.v.i = axes[i]; err = ProUtilElemtreeCreate(tree, SIZEOFARR(tree), NULL, &elem_tree); /*-----------------------------------------------------------------*\ Create Feature \*-----------------------------------------------------------------*/ err = ProMdlToModelitem(g_ptr->model, &modelitem); err = ProSelectionAlloc(NULL, &modelitem, &featsel); err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &f, &errs); if (err != PRO_TK_NO_ERROR) { ProUserFeatErrsPrint("ProFeatureCreate", err, elem_tree, &errs); return (-1); } ProSelectionFree(&featsel); /*-----------------------------------------------------------------*\ Set datum plane name \*-----------------------------------------------------------------*/ err = ProUtilModelitemNameSet((ProModelitem*)&f, names[i]); if (err != PRO_TK_NO_ERROR) return (-1); /*-----------------------------------------------------------------*\ Find surface ID for datum plane feature \*-----------------------------------------------------------------*/ ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, id[i]); } /*-----------------------------------------------------------------*\ Unable/Disable Create menu buttons \*-----------------------------------------------------------------*/ g_ptr->datum_created = 1; UserSetCreateMenubutton(g_ptr); return (0); } /*=============================================================*\ Function: ProUserCreateDisk Purpose: create gear disk \*=============================================================*/ int ProUserCreateDisk(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_PROTRUSION}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_ONE}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_BLIND}}, {3, PRO_E_EXT_DEPTH_FROM_VALUE, {PRO_VALUE_TYPE_DOUBLE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NONE}}, }; ProElempathItem depth_path[] = { {PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_STD_EXT_DEPTH}, {PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_EXT_DEPTH_FROM}, {PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_EXT_DEPTH_FROM_VALUE} }; ProError err; FeatureDef feat_def; ProFeature feature; ProModelitem modelitem; Pro3dPnt pnt; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); err =ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); err = ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); tree[13].data.v.d = g_ptr->gear_depth; feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->gear_diam; feat_def.params[1].r = tree[9].data.v.r; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateCircleSection; feat_def.feat_name = "Gear_Disk"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->disk_created = 1; UserSetCreateMenubutton(g_ptr); /*-----------------------------------------------------------------*\ Find and name required surfaces \*-----------------------------------------------------------------*/ pnt[0] = 0.0; pnt[1] = 0.0; pnt[2] = g_ptr->gear_depth; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->disk_front_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "DISK_FRONT"); pnt[0] = 0.0; pnt[1] = g_ptr->gear_diam/2; pnt[2] = g_ptr->gear_depth/2; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->disk_side_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "DISK_SIDE"); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserCreateHole Purpose: create gear hole \*=============================================================*/ int ProUserCreateHole(GearParam *g_ptr) { /* New Hole Element Tree : as of Release 2000i2 PRO_E_FEATURE_TREE | |--PRO_E_FEATURE_TYPE | |--PRO_E_HLE_COM | |--PRO_E_HLE_TYPE_NEW | |--PRO_E_HLE_STAN_TYPE | |--PRO_E_HLE_THRDSERIE | |--PRO_E_HLE_FITTYPE | |--PRO_E_HLE_SCREWSIZE | |--PRO_E_HLE_ADD_THREAD | |--PRO_E_HLE_ADD_CBORE | |--PRO_E_HLE_ADD_CSINK | |--PRO_E_DIAMETER | |--PRO_E_STD_EXT_DEPTH | |--PRO_E_EXT_DEPTH_FROM_TYPE | |--PRO_E_EXT_DEPTH_FROM_VALUE | |--PRO_E_EXT_DEPTH_FROM_REF | |--PRO_E_EXT_DEPTH_TO_TYPE | |--PRO_E_EXT_DEPTH_TO_VALUE | |--PRO_E_EXT_DEPTH_TO_REF | |--PRO_E_HLE_HOLEDIAM |--PRO_E_HLE_DRILLANGLE |--PRO_E_HLE_CSINKANGLE |--PRO_E_HLE_CBOREDEPTH |--PRO_E_HLE_CBOREDIAM |--PRO_E_HLE_CSINKDIAM |--PRO_E_HLE_THRDDEPTH |--PRO_E_HLE_DRILLDEPTH |--PRO_E_HLE_THRD_DEPTH |--PRO_E_HLE_DEPTH |--PRO_E_HLE_SKETCHER | |--PRO_E_HLE_PLACEMENT | |--PRO_E_HLE_PRIM_REF | |--PRO_E_HLE_PL_TYPE | |--PRO_E_HLE_DIM_REF1 | |--PRO_E_HLE_DIM_DIST1 | |--PRO_E_HLE_DIM_REF2 | |--PRO_E_HLE_DIM_DIST2 | |--PRO_E_HLE_AXIS | |--PRO_E_HLE_REF_PLANE | |--PRO_E_HLE_REF_ANG | |--PRO_E_HLE_DIM_TYPE | |--PRO_E_HLE_DIM_DIA | |--PRO_E_HLE_DIM_RAD | |--PRO_E_HLE_DIM_LIN | |--PRO_E_HLE_NORM_PLA | |--PRO_E_HLE_NORM_OFFST | |--PRO_E_HLE_PLCMNT_PLANE | |--PRO_E_HLE_REF_PLANE_1 | |--PRO_E_HLE_REF_ANG_1 | |--PRO_E_INT_PARTS | |--PRO_E_PATTERN ### */ static ElemTreeData tree[]={ /* 0*/ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, /* 1*/ {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_HOLE}}, /* 2*/ {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, /* 3*/ {1, PRO_E_HLE_COM, {(ProValueDataType)-1}}, /* 4*/ {2, PRO_E_HLE_TYPE_NEW, {PRO_VALUE_TYPE_INT, 16}}, /* 5*/ {2, PRO_E_DIAMETER, {PRO_VALUE_TYPE_DOUBLE, 4}}, /* 6*/ {2, PRO_E_HOLE_STD_DEPTH, {(ProValueDataType)-1}}, /* 7*/ {3, PRO_E_HOLE_DEPTH_TO, {(ProValueDataType)-1}}, /* 8*/ {4, PRO_E_HOLE_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, 3}}, /* 9*/ {3, PRO_E_HOLE_DEPTH_FROM, {(ProValueDataType)-1}}, /* 10*/ {4, PRO_E_HOLE_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, 3}}, /* 11*/ {1, PRO_E_HLE_PLACEMENT, {(ProValueDataType)-1}}, /* 12*/ {2, PRO_E_HLE_PRIM_REF, {PRO_VALUE_TYPE_SELECTION}}, /* 13*/ {2, PRO_E_HLE_PL_TYPE, {PRO_VALUE_TYPE_INT, 5}}, /* 14*/ {2, PRO_E_HLE_PLCMNT_PLANE, {PRO_VALUE_TYPE_SELECTION}}, }; ProError err; int axis_id; ProFeature feature, f; ProErrorlist errs; Pro3dPnt pnt; ProModelitem modelitem; ProElement elem_tree; ProSelection featsel; static FeatByName feat_disk[] = { {"GEAR_DISK"} }; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ err = ProUtilFeatsByName(g_ptr->model, feat_disk, 1); if (err != PRO_TK_NO_ERROR || feat_disk[0].id == -1) return (err); ProFeatureInit(g_ptr->model, feat_disk[0].id, &feature); err = ProUtilFeatFirstGeomitem(&feature, PRO_AXIS, &axis_id); if (err != PRO_TK_NO_ERROR) return (err); err=ProModelitemInit(g_ptr->model, axis_id, PRO_AXIS, &modelitem); if (err!=PRO_TK_NO_ERROR) return (err); ProSelectionAlloc(NULL, &modelitem, &tree[12].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[14].data.v.r); tree[5].data.v.d = g_ptr->inner_diam; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilElemtreeCreate(tree, SIZEOFARR(tree), NULL, &elem_tree); err = ProMdlToModelitem(g_ptr->model, &modelitem); err = ProSelectionAlloc(NULL, &modelitem, &featsel); err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &f, &errs); ProSelectionFree(&featsel); if (err != PRO_TK_NO_ERROR) { ProUserFeatErrsPrint("ProFeatureCreate", err, elem_tree, &errs); return (-1); } else { /*-----------------------------------------------------------------*\ Set feature name \*-----------------------------------------------------------------*/ err = ProUtilModelitemNameSet((ProModelitem*)&f, "GEAR_HOLE"); if (err != PRO_TK_NO_ERROR) return (-1); g_ptr->hole_created = 1; UserSetCreateMenubutton(g_ptr); /*-----------------------------------------------------------------*\ Find and name required surfaces \*-----------------------------------------------------------------*/ pnt[0] = 0.0; pnt[1] = g_ptr->inner_diam/2; /* point on surface */ if (g_ptr->gear_type == SPUR_GEAR) pnt[2] = g_ptr->gear_depth/2; else pnt[2] =-g_ptr->backplate_depth/2; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->hole_side_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "HOLE_SIDE"); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[12].data.v.r); ProSelectionFree(&tree[14].data.v.r); return (err); } /*=============================================================*\ Function: ProUserCreateToothSurf Purpose: create all gear teeth \*=============================================================*/ int ProUserCreateToothSurf(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_SLOT}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_TWO}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NONE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NEXT}} }; ProError err; FeatureDef feat_def; ProFeature feature; Pro3dPnt pnt; ProModelitem modelitem; double diam; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); diam = (g_ptr->n_of_teeth - 2) * g_ptr->tooth_par1; feat_def.params[0].d = diam; feat_def.params[1].r = tree[9].data.v.r; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateCircleSection; feat_def.feat_name = "Tooth_Surf"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->tooth_surf_created = 1; UserSetCreateMenubutton(g_ptr); /*-----------------------------------------------------------------*\ Find and name required surfaces \*-----------------------------------------------------------------*/ pnt[0] = 0.0; pnt[1] = diam/2; /* point on surface */ pnt[2] = g_ptr->gear_depth/2; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->tooth_surf_side_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "TOOTH_SURF_SIDE"); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (0); } /*=============================================================*\ Function: ProUserCreateTooth Purpose: create first gear tooth \*=============================================================*/ int ProUserCreateTooth(GearParam *g_ptr) { static ElemTreeData dtm_tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_DATUM}}, {1, PRO_E_DTMPLN_CONSTRAINTS, {(ProValueDataType)-1}}, {2, PRO_E_DTMPLN_CONSTRAINT, {(ProValueDataType)-1}}, {3, PRO_E_DTMPLN_CONSTR_TYPE, {PRO_VALUE_TYPE_INT, PRO_DTMPLN_THRU}}, {3, PRO_E_DTMPLN_CONSTR_REF, {PRO_VALUE_TYPE_SELECTION}}, {2, PRO_E_DTMPLN_CONSTRAINT, {(ProValueDataType)-1}}, {3, PRO_E_DTMPLN_CONSTR_TYPE, {PRO_VALUE_TYPE_INT, PRO_DTMPLN_ANG}}, {3, PRO_E_DTMPLN_CONSTR_REF, {PRO_VALUE_TYPE_SELECTION}}, {3, PRO_E_DTMPLN_CONSTR_REF_ANGLE, {PRO_VALUE_TYPE_DOUBLE}}, }; static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_CUT}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_TWO}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {2, PRO_E_STD_MATRLSIDE, {PRO_VALUE_TYPE_INT, PRO_MAT_SIDE_TWO}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NONE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NEXT}} }; static FeatByName feat_disk[] = { {"GEAR_DISK"} }; ProError err; FeatureDef feat_def; ProFeature feature, feat_tooth; ProModelitem modelitem; int axis_id, surface_id, *feats_ids, ret, n_dims, *p_dim_ids; ProErrorlist errs; ProElement elem_tree; ProSelection featsel; ProLayer layer; ProLayerItem layer_item; ProGroup group; ProName w_name; PRODIMENSION dim; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ err = ProUtilFeatsByName(g_ptr->model, feat_disk, 1); if (err != PRO_TK_NO_ERROR || feat_disk[0].id == -1) return (err); ProFeatureInit(g_ptr->model, feat_disk[0].id, &feature); err = ProUtilFeatFirstGeomitem(&feature, PRO_AXIS, &axis_id); if (err != PRO_TK_NO_ERROR) return (err); err=ProModelitemInit(g_ptr->model, axis_id, PRO_AXIS, &modelitem); if (err!=PRO_TK_NO_ERROR) return (err); ProSelectionAlloc(NULL, &modelitem, &dtm_tree[5].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &dtm_tree[8].data.v.r); memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->tooth_par1; feat_def.params[1].i = g_ptr->n_of_teeth; feat_def.params[2].d = g_ptr->Pressure_angle; feat_def.params[3].d = g_ptr->tooth_par2; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->gear_type ? g_ptr->tooth_surf_side_surf_id : g_ptr->disk_side_surf_id, &feat_def.params[4].r); feat_def.params[5].r = tree[9].data.v.r; feat_def.section_create_func = ProUtilCreateToothSection; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*\ Create Datum Plane first \*-----------------------------------------------------------------*/ dtm_tree[9].data.v.d = 0; err = ProUtilElemtreeCreate(dtm_tree, SIZEOFARR(dtm_tree), NULL, &elem_tree); err = ProMdlToModelitem(g_ptr->model, &modelitem); err = ProSelectionAlloc(NULL, &modelitem, &featsel); err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &feature, &errs); if (err != PRO_TK_NO_ERROR) { ProUserFeatErrsPrint("ProFeatureCreate", err, elem_tree, &errs); return (-1); } ProSelectionFree(&featsel); /*-----------------------------------------------------------------*\ Set datum plane name \*-----------------------------------------------------------------*/ err = ProUtilModelitemNameSet((ProModelitem*)&feature, "DTM_TOOTH_1"); if (err != PRO_TK_NO_ERROR) return (-1); /*-----------------------------------------------------------------------*\ Make trik - rename last dimension, to use in pattern \*-----------------------------------------------------------------------*/ n_dims = prodim_get_dim_ids((Prohandle)g_ptr->model, PRO_DIM_PARAM, -1, &p_dim_ids); ret = prodim_get_dimension((Prohandle)g_ptr->model, p_dim_ids[n_dims-1], PRO_DIM_PARAM, &dim); ProStringToWstring(dim.symbol, "tooth_angle"); ret = prodim_set_dim((Prohandle)g_ptr->model, p_dim_ids[n_dims-1], &dim); /*-----------------------------------------------------------------*\ Create a hidden layer and add datim plane to the layer \*-----------------------------------------------------------------*/ ProStringToWstring(w_name, "BLANK"); err = ProLayerCreate(g_ptr->model, w_name, &layer); err = ProLayerDisplaystatusSet(&layer, PRO_LAYER_TYPE_BLANK); err = ProLayerDisplaystatusSave(g_ptr->model); err = ProLayerItemInit(PRO_LAYER_FEAT, feature.id, g_ptr->model, &layer_item); err = ProLayerItemAdd(&layer, &layer_item); err = ProUtilFeatFirstGeomitem(&feature, PRO_SURFACE, &surface_id); if (err != PRO_TK_NO_ERROR) return (-1); ProUtilSelectionFromSurfaceId(g_ptr->model, surface_id, &tree[9].data.v.r); feat_def.feat_name = "TOOTH_1"; feat_def.params[3].d = 0; err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feat_tooth); if (err!=PRO_TK_NO_ERROR) return (-1); ProSelectionFree(&tree[9].data.v.r); /*-----------------------------------------------------------------------*\ Create Local Group \*-----------------------------------------------------------------------*/ ProStringToWstring(w_name, "TOOTH"); ProArrayAlloc(0, sizeof(int), 2, (ProArray*)&feats_ids); ProArrayObjectAdd((ProArray*)&feats_ids, -1, 1, &feature.id); ProArrayObjectAdd((ProArray*)&feats_ids, -1, 1, &feat_tooth.id); err = ProLocalGroupCreate(g_ptr->model, feats_ids, 2, w_name, &group); ProArrayFree((ProArray*)&feats_ids); if (err == PRO_TK_NO_ERROR) { g_ptr->tooth_created = 1; UserSetCreateMenubutton(g_ptr); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&dtm_tree[5].data.v.r); ProSelectionFree(&dtm_tree[8].data.v.r); ProSelectionFree(&feat_def.params[4].r); return (0); } /*=============================================================*\ Function: ProUserCreateTeeth Purpose: create gear teeth \*=============================================================*/ int ProUserCreateTeeth(GearParam *g_ptr) { static FeatByName tooth_datum[] = { {"DTM_TOOTH_1"}, }; static ElemTreeData tree[]={ {0, PRO_E_PATTERN_ROOT, {(ProValueDataType)-1}}, {1, PRO_E_PAT_TYPE, {PRO_VALUE_TYPE_INT, PRO_PAT_DIM_DRIVEN}}, {1, PRO_E_PAT_FIRST_DIR, {(ProValueDataType)-1}}, {2, PRO_E_PAT_DIR_DIM_COMPOUND, {(ProValueDataType)-1}}, {3, PRO_E_PAT_DIR_DIMENSION, {PRO_VALUE_TYPE_SELECTION}}, {3, PRO_E_PAT_DIR_VAR_TYPE, {PRO_VALUE_TYPE_INT, PRO_PAT_VALUE_DRIVEN}}, {3, PRO_E_PAT_DIR_VAR_VALUE, {PRO_VALUE_TYPE_DOUBLE}}, {1, PRO_E_PAT_FIRST_DIR_NUM_INST, {PRO_VALUE_TYPE_INT}} }; int n_dims, ret, *p_dim_ids, *p_feat_ids, *p_tooth_ids, i, n_feats; int n_tooth_feats; PRODIMENSION dim; ProFeature feature, feat_plane, feat_tooth; ProLayerItem layer_item; ProLayer layer; ProCharName str; ProName w_str; ProElement elem_tree; ProModelitem modelitem; ProError err; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ err = ProUtilFeatsByName(g_ptr->model, tooth_datum, 1); if (err != PRO_TK_NO_ERROR || tooth_datum[0].id == -1) return (err); ProFeatureInit(g_ptr->model, tooth_datum[0].id, &feature); /*-----------------------------------------------------------------*\ Find tooth_angle dimension for reference \*-----------------------------------------------------------------*/ n_dims = prodim_get_dim_ids((Prohandle)g_ptr->model, PRO_DIM_PARAM, -1, &p_dim_ids); for (i=0; imodel, p_dim_ids[i], PRO_DIM_PARAM, &dim); if (!ProUtilStrwscmp("tooth_angle", dim.symbol)) { err = ProModelitemInit(g_ptr->model, p_dim_ids[i], PRO_DIMENSION, &modelitem); err = ProSelectionAlloc(NULL, &modelitem, &tree[4].data.v.r); break; } if (i == n_dims) return (-1); } tree[6].data.v.d = 360/g_ptr->n_of_teeth; tree[7].data.v.i = g_ptr->n_of_teeth; err = ProUtilElemtreeCreate(tree, SIZEOFARR(tree), NULL, &elem_tree); err = ProPatternCreate(&feature, PRO_GROUP_PATTERN, elem_tree); if (err == PRO_TK_NO_ERROR) { g_ptr->teeth_created = 1; UserSetCreateMenubutton(g_ptr); err = ProFeatureChildrenGet(&feature, &p_feat_ids, &n_feats); for (i=1; imodel, p_feat_ids[i], &feat_plane); /* Rename datum plane and put it into hidden layen */ sprintf(str, "DTM_TOOTH_%d", i+1); ProStringToWstring(w_str, str); err = ProModelitemNameSet((ProModelitem*)&feat_plane, w_str); ProStringToWstring(w_str, "BLANK"); err = ProMdlLayerGet(g_ptr->model, w_str, &layer); err = ProLayerItemInit(PRO_LAYER_FEAT, feat_plane.id, g_ptr->model, &layer_item); err = ProLayerItemAdd(&layer, &layer_item); err = ProFeatureChildrenGet(&feat_plane, &p_tooth_ids, &n_tooth_feats); err = ProFeatureInit((ProSolid)g_ptr->model, p_tooth_ids[0], &feat_tooth); /* Rename datum plane and put it into hidden layen */ sprintf(str, "TOOTH_%d", i+1); ProStringToWstring(w_str, str); err = ProModelitemNameSet((ProModelitem*)&feat_tooth, w_str); err = ProArrayFree((ProArray*)&p_tooth_ids); } err = ProArrayFree((ProArray*)&p_feat_ids); } err = ProSelectionFree(&tree[4].data.v.r); } /*=============================================================*\ Function: ProUserCreateHub Purpose: create inner support hub \*=============================================================*/ int ProUserCreateHub(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_PROTRUSION}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_ONE}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_BLIND}}, {3, PRO_E_EXT_DEPTH_FROM_VALUE, {PRO_VALUE_TYPE_DOUBLE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NONE}}, }; ProError err; FeatureDef feat_def; ProFeature feature; Pro3dPnt pnt; ProModelitem modelitem; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->gear_type == SPUR_GEAR ? g_ptr->disk_front_surf_id : g_ptr->backplate_back_surf_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); tree[13].data.v.d = g_ptr->hub_depth; feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->hub_out_diam; feat_def.params[1].r = tree[9].data.v.r; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateCircleSection; feat_def.feat_name = "Hub"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->hub_created = 1; UserSetCreateMenubutton(g_ptr); ProUserFeatsReorder(g_ptr); /*-----------------------------------------------------------------*\ Find and name required surfaces \*-----------------------------------------------------------------*/ pnt[0] = 0.0; pnt[1] = (g_ptr->inner_diam + g_ptr->hub_out_diam)/4; if (g_ptr->gear_type == SPUR_GEAR) pnt[2] = g_ptr->gear_depth + g_ptr->hub_depth; else pnt[2] = -g_ptr->backplate_depth - g_ptr->hub_depth; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->hub_front_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "HUB_FRONT"); pnt[0] = 0.0; pnt[1] = g_ptr->hub_out_diam/2; if (g_ptr->gear_type == SPUR_GEAR) pnt[2] = g_ptr->gear_depth + g_ptr->hub_depth/2; else pnt[2] = -g_ptr->backplate_depth - g_ptr->hub_depth/2; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->hub_side_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "HUB_SIDE"); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserCreateBackPlate Purpose: create first gear tooth \*=============================================================*/ int ProUserCreateBackPlate(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_PROTRUSION}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_TWO}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_BLIND}}, {3, PRO_E_EXT_DEPTH_FROM_VALUE, {PRO_VALUE_TYPE_DOUBLE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NONE}}, }; ProError err; FeatureDef feat_def; ProFeature feature; Pro3dPnt pnt; ProModelitem modelitem; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); tree[13].data.v.d = g_ptr->backplate_depth; feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->backplate_diam; feat_def.params[1].r = tree[9].data.v.r; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateCircleSection; feat_def.feat_name = "Back_Plate"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->backplate_created = 1; UserSetCreateMenubutton(g_ptr); ProUserFeatsReorder(g_ptr); /*-----------------------------------------------------------------*\ Find and name required surfaces \*-----------------------------------------------------------------*/ pnt[0] = (g_ptr->backplate_diam - g_ptr->inner_diam)/2; pnt[1] = 0.0; pnt[2] = -g_ptr->backplate_depth; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->backplate_back_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "BACKPLATE_BACK"); pnt[0] = 0.0; pnt[1] = g_ptr->backplate_diam/2; pnt[2] = -g_ptr->backplate_depth/2; ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem); g_ptr->backplate_side_surf_id = modelitem.id; ProUtilModelitemNameSet(&modelitem, "BACKPLATE_SIDE"); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserCreateKeyway Purpose: create keyway inner \*=============================================================*/ int ProUserCreateKeyway(GearParam *g_ptr) { static ElemTreeData tree[]= { {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_CUT}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_ONE}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_RIGHT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {2, PRO_E_STD_MATRLSIDE, {PRO_VALUE_TYPE_INT, PRO_MAT_SIDE_ONE}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_ALL}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_ALL}} }; ProError err; FeatureDef feat_def; ProFeature feature; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->keyway_in_width; feat_def.params[1].d = g_ptr->keyway_in_height; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->hole_side_surf_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateKeySection; feat_def.feat_name = "Keyway"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->keyway_created = 1; UserSetCreateMenubutton(g_ptr); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserCreateKey Purpose: create keyway outer \*=============================================================*/ int ProUserCreateKey(GearParam *g_ptr) { static ElemTreeData tree[]= { {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_PROTRUSION}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_TWO}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {2, PRO_E_STD_MATRLSIDE, {PRO_VALUE_TYPE_INT, PRO_MAT_SIDE_ONE}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NEXT}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NONE}} }; ProError err; FeatureDef feat_def; ProFeature feature; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->hub_front_surf_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); tree[8].data.v.i = g_ptr->gear_type == RING_GEAR ? PRO_SEC_ORIENT_DIR_RIGHT : PRO_SEC_ORIENT_DIR_LEFT; feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->keyway_out_width; feat_def.params[1].d = g_ptr->keyway_out_height; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->hub_side_surf_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateKeySection; feat_def.feat_name = "Key"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->key_created = 1; UserSetCreateMenubutton(g_ptr); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserCreateBackNotch Purpose: create a notch on the Back Plate \*=============================================================*/ int ProUserCreateBackNotch(GearParam *g_ptr) { static ElemTreeData tree[]={ {0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}}, {1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_CUT}}, {1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}}, {1, PRO_E_STD_SECTION, {(ProValueDataType)-1}}, {2, PRO_E_STD_SEC_SETUP, {(ProValueDataType)-1}}, {3, PRO_E_STD_SECTION_PLANE, {(ProValueDataType)-1}}, {4, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}}, {4, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_ONE}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_RIGHT}}, {4, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}}, {2, PRO_E_STD_MATRLSIDE, {PRO_VALUE_TYPE_INT, PRO_MAT_SIDE_ONE}}, {1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}}, {2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NONE}}, {2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}}, {3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NEXT}} }; ProError err; FeatureDef feat_def; ProFeature feature; /*-----------------------------------------------------------------*\ Preparation of feature data \*-----------------------------------------------------------------*/ memset(&feat_def, 0, sizeof(feat_def)); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, &tree[6].data.v.r); ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, &tree[9].data.v.r); feat_def.tree = tree; feat_def.sizeof_tree = SIZEOFARR(tree); feat_def.params[0].d = g_ptr->backplate_diam; feat_def.params[1].d = g_ptr->backnotch_rad; ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->backplate_side_surf_id, &feat_def.params[2].r); feat_def.section_create_func = ProUtilCreateNotchSection; feat_def.feat_name = "Back_Notch"; /*-----------------------------------------------------------------*\ Create new feature \*-----------------------------------------------------------------*/ err = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature); if (err == PRO_TK_NO_ERROR) { g_ptr->backnotch_created = 1; UserSetCreateMenubutton(g_ptr); } /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ ProSelectionFree(&tree[6].data.v.r); ProSelectionFree(&tree[9].data.v.r); ProSelectionFree(&feat_def.params[2].r); return (err); } /*=============================================================*\ Function: ProUserFeatsReorder Purpose: move hole and keyslot to end Return : 0 if successfull, -1 otherwise \*=============================================================*/ int ProUserFeatsReorder(GearParam *g_ptr) { ProError err; int *p_feat_id_ar, n_features, ids[2], n = 0; ProFeatStatus *p_status_ar; static FeatByName feats[] = { {"GEAR_HOLE"}, {"KEYWAY"} }; if (g_ptr->hole_created == 0) return (0); /*-----------------------------------------------------------------*\ Find "hole" and "keyway" features \*-----------------------------------------------------------------*/ err = ProUtilFeatsByName((ProSolid)g_ptr->model, feats, 2); if (err != PRO_TK_NO_ERROR) return (err); err = ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&p_feat_id_ar); err = ProArrayAlloc(0, sizeof(ProFeatStatus), 1, (ProArray*)&p_status_ar); err = ProSolidFeatstatusGet((ProSolid)g_ptr->model, &p_feat_id_ar, &p_status_ar, &n_features); if (g_ptr->hole_created) ids[n++] = feats[0].id; if (g_ptr->keyway_created) ids[n++] = feats[1].id; /*-----------------------------------------------------------------*\ Set changed order of features \*-----------------------------------------------------------------*/ if (n) err = ProFeatureReorder((ProSolid)g_ptr->model, ids, n, n_features-n+1); /*-----------------------------------------------------------------*\ Free allocated memory \*-----------------------------------------------------------------*/ err = ProArrayFree((ProArray*)&p_feat_id_ar); err = ProArrayFree((ProArray*)&p_status_ar); /*-----------------------------------------------------------------*\ Redisplay model \*-----------------------------------------------------------------*/ ProSolidDisplay((ProSolid)g_ptr->model); err = ProTreetoolRefresh(g_ptr->model); return (0); } /*=============================================================*\ Function: ProUserCheckFeatures Purpose: to check models features Return : 0 if successfull, PRO_TK_E_NOT_FOUND if no default csys or datum planes found, PRO_TK_GENERAL_ERROR otherwise \*=============================================================*/ ProError ProUserCheckFeatures(GearParam *g_ptr) { static FeatByName feats[] = { {"FRONT"}, /* 0 */ {"SIDE"}, /* 1 */ {"BOTTOM"}, /* 2 */ {"GEAR_DISK"}, /* 3 */ {"GEAR_HOLE"}, /* 4 */ {"KEYWAY"}, /* 5 */ {"TOOTH_1"}, /* 6 */ {"TOOTH_2"}, /* 7 */ {"HUB"}, /* 8 */ {"KEY"}, /* 9 */ {"BACK_PLATE"}, /* 10 */ {"BACK_NOTCH"}, /* 11 */ {"TOOTH_SURF"} /* 12 */ }; int feat_num = SIZEOFARR(feats), b; ProFeature f, feature; ProGeomitem geomitem; ProSolid solid = (ProSolid)g_ptr->model; ProError err; ProName w_name; ProUtilFeatsByName(solid, feats, feat_num); b =(feats[0].id!=-1) || (feats[1].id!=-1) || (feats[2].id!=-1); if (b) { if (!g_ptr->datum_created) { /*-----------------------------------------------------------------*\ Find datum planes surfaces \*-----------------------------------------------------------------*/ ProFeatureInit(solid, feats[0].id, &f); err = ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, &g_ptr->front_surface_id); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProFeatureInit(solid, feats[1].id, &f); err = ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, &g_ptr->side_surface_id); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); ProFeatureInit(solid, feats[2].id, &f); err =ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, &g_ptr->bottom_surface_id); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); } } g_ptr->datum_created = b; if ((feats[3].id!=-1) && (g_ptr->disk_created==0)) { /*-----------------------------------------------------------------*\ Find gear disk surfaces \*-----------------------------------------------------------------*/ err = ProFeatureInit(solid, feats[3].id, &feature); ProStringToWstring(w_name, "DISK_FRONT"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->disk_front_surf_id = geomitem.id; ProStringToWstring(w_name, "DISK_SIDE"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->disk_side_surf_id = geomitem.id; } g_ptr->disk_created = feats[3].id!=-1; if ((feats[4].id!=-1) && (g_ptr->hole_created==0)) { /*-----------------------------------------------------------------*\ Find hole surfaces \*-----------------------------------------------------------------*/ err = ProFeatureInit(solid, feats[4].id, &feature); ProStringToWstring(w_name, "HOLE_SIDE"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->hole_side_surf_id = geomitem.id; } g_ptr->hole_created = feats[4].id!=-1; g_ptr->keyway_created = feats[5].id!=-1; g_ptr->tooth_created = feats[6].id!=-1; g_ptr->teeth_created = feats[7].id!=-1; if ((feats[8].id!=-1) && (g_ptr->hub_created==0)) { /*-----------------------------------------------------------------*\ Find hub surfaces \*-----------------------------------------------------------------*/ err = ProFeatureInit(solid, feats[8].id, &feature); ProStringToWstring(w_name, "HUB_FRONT"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->hub_front_surf_id = geomitem.id; ProStringToWstring(w_name, "HUB_SIDE"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->hub_side_surf_id = geomitem.id; } g_ptr->hub_created = feats[8].id!=-1; g_ptr->key_created = feats[9].id!=-1; if ((feats[10].id!=-1) && (g_ptr->backplate_created==0)) { /*-----------------------------------------------------------------*\ Find backplate surfaces \*-----------------------------------------------------------------*/ err = ProFeatureInit(solid, feats[10].id, &feature); ProStringToWstring(w_name, "BACKPLATE_SIDE"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->backplate_side_surf_id = geomitem.id; ProStringToWstring(w_name, "BACKPLATE_BACK"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->backplate_back_surf_id = geomitem.id; } g_ptr->backplate_created = feats[10].id!=-1; g_ptr->backnotch_created = feats[11].id!=-1; if ((feats[12].id!=-1) && (g_ptr->tooth_surf_created==0)) { /*-----------------------------------------------------------------*\ Find gear disk surfaces \*-----------------------------------------------------------------*/ err = ProFeatureInit(solid, feats[12].id, &feature); ProStringToWstring(w_name, "TOOTH_SURF_SIDE"); err = ProUtilFindFeatureGeomitemByName(&feature, PRO_SURFACE, w_name, &geomitem); if (err != PRO_TK_NO_ERROR) return (PRO_TK_GENERAL_ERROR); g_ptr->tooth_surf_side_surf_id = geomitem.id; } g_ptr->tooth_surf_created = feats[12].id!=-1; return (PRO_TK_NO_ERROR); } /*=============================================================*\ Function: ProUserReadParamFile Purpose: read gear parameter file Return : 0 if successfull, -1 otherwise \*=============================================================*/ int ProUserReadParamFile(char *filename, GearParam *g_ptr) { ProCharLine line, str1, str2; FILE *fp; int i=0, j, table_size=SIZEOFARR(param_def); ProParameter param; ProParamvalue parvalue; ProModelitem modelitem; ProName w_name; ProError err; param_def[i++].value = g_ptr->name; param_def[i++].value = &g_ptr->units; param_def[i++].value = g_ptr->material; param_def[i++].value = &g_ptr->gear_type; param_def[i++].value = &g_ptr->gear_diam; param_def[i++].value = &g_ptr->gear_depth; param_def[i++].value = &g_ptr->backplate_diam; param_def[i++].value = &g_ptr->backplate_depth; param_def[i++].value = &g_ptr->hub_out_diam; param_def[i++].value = &g_ptr->hub_depth; param_def[i++].value = &g_ptr->inner_diam; param_def[i++].value = &g_ptr->n_of_teeth; param_def[i++].value = &g_ptr->keyway_in_width; param_def[i++].value = &g_ptr->keyway_in_height; param_def[i++].value = &g_ptr->keyway_out_width; param_def[i++].value = &g_ptr->keyway_out_height; param_def[i++].value = &g_ptr->tooth_par1; param_def[i++].value = &g_ptr->tooth_par2; param_def[i++].value = &g_ptr->tooth_par3; param_def[i++].value = &g_ptr->backnotch_rad; param_def[i++].value = &g_ptr->Pressure_angle; if (i!=table_size) { ProMessageDisplay(MSGFIL, "USER %0s", "Error in func ProUserReadParamFile"); return (-1); } fp = fopen(filename, "r"); if (fp == NULL) { ProMessageDisplay(MSGFIL, "USER Unable to open parameter file %0s", filename); return (-1); } for (i=0; imodel, &modelitem); ProStringToWstring(w_name, str1); err = ProParameterInit(&modelitem, w_name, ¶m); if (err != PRO_TK_NO_ERROR) { err = ProParameterCreate(&modelitem, w_name, &parvalue, ¶m); } else { err = ProParameterValueSet(¶m, &parvalue); } } break; } } if (i == table_size) { ProMessageDisplay(MSGFIL, "USER Unknown parameter %0s", str1); } } fclose (fp); /*-----------------------------------------------------------------*\ Check all required parameters \*-----------------------------------------------------------------*/ for (i=0; iradius; m = params[0].d; z = params[1].i; d = params[0].d * z; /* The Pitch circle radius */ ring_gear = r < d/2; angle = params[2].d*PI/180; r_t = d/2 * sin(angle); r_base = d/2 * cos(angle); /* The base-circle diam */ if (ring_gear) { add_circle.radius = r; ded_circle.radius = d/2+1.2*m; angle = PI/2 + angle - PI/(z*2); } else { add_circle.radius = r; ded_circle.radius = d/2-1.2*m; angle = PI/2 - angle - PI/(z*2); } add_circle.center[0] = add_circle.center[1] = ded_circle.center[0] = ded_circle.center[1] = 0.0; t_circle.center[0] = r_base * cos(angle); t_circle.center[1] = r_base * sin(angle); t_circle.radius = r_t; ProUtilTwoCircleIntersection(&add_circle, &t_circle, p1, p2); if (ring_gear) { if (p1[0]p2[0]) memcpy(p1, p2, sizeof(p1)); } ProUtilTwoCircleIntersection(&ded_circle, &t_circle, p2, p3); if (ring_gear) { if (p2[0]p3[0]) memcpy(p2, p3, sizeof(p1)); } /*----------------------------------------------------------*\ Create entities \*----------------------------------------------------------*/ line.type = PRO_2D_CENTER_LINE; line.end1[0] = 0.0; line.end1[1] = 0.0; line.end2[0] = 0.0; line.end2[1] = r; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&line, &d_id); arc.type = PRO_2D_ARC; memcpy(arc.center, t_circle.center, sizeof(arc.center)); arc.start_angle = atan2(p1[1]-arc.center[1], p1[0]-arc.center[0]); arc.end_angle = atan2(p2[1]-arc.center[1], p2[0]-arc.center[0]); arc.radius = r_t; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&arc, &arc1_id); an = PI - arc.start_angle; arc.start_angle = PI - arc.end_angle; arc.end_angle = an; arc.center[0] = - arc.center[0]; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&arc, &arc2_id); memcpy(arc.center, ded_circle.center, sizeof(arc.center)); arc.start_angle = atan2( p2[1], p2[0]); arc.end_angle = PI - arc.start_angle; arc.radius = ded_circle.radius; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&arc, &ded_id); /*----------------------------------------------------------*\ Add dimensions \*----------------------------------------------------------*/ point[0] = 0.0; point[1] = t_circle.center[1] + 1; pnt_types[0] = PRO_ENT_CENTER; pnt_types[1] = PRO_ENT_CENTER; dims[0] = arc1_id; dims[1] = arc2_id; err = ProSecdimCreate(section, dims, pnt_types, 2, PRO_TK_DIM_PNT_PNT_HORIZ, point, &d_id); point[0] = 1.2 * t_circle.center[0]; point[1] = t_circle.center[1]/2; dims[1] = circle_id; err = ProSecdimCreate(section, dims, pnt_types, 2, PRO_TK_DIM_PNT_PNT_VERT, point, &d_id); point[0] = 0; if (ring_gear) point[1] = 1.2 * ded_circle.radius; else point[1] = 0.8 * ded_circle.radius; pnt_types[0] = PRO_ENT_WHOLE; err = ProSecdimCreate(section, &ded_id, pnt_types, 1, PRO_TK_DIM_RAD, point, &d_id); point[0] = p1[0] * 1.2; point[1] = p1[1] * 1.2; err = ProSecdimCreate(section, &arc1_id, pnt_types, 1, PRO_TK_DIM_RAD, point, &d_id); /*----------------------------------------------------------*\ Solve section \*----------------------------------------------------------*/ err = ProSecerrorAlloc(&errors); err = ProSectionSolve(section, &errors); if (err != PRO_TK_NO_ERROR) break; err = ProSecerrorFree(&errors); } while (brk); return (err); } /*=============================================================*\ Function: ProUtilCreateKeySection Purpose: Full creating of open section with tree lines Return : \*=============================================================*/ ProError ProUtilCreateKeySection( ProSection section, /*In : the section */ Parameter *params) /*In : params [0] - section width */ /* params [1] - section height */ /* params [2] - cyl surface */ { Pro2dLinedef line; Pro2dPnt point; Pro2dCircledef *p_circle; int dims[2], brk=0; int left_id, right_id, top_id, width_id, height_id, circle_id; ProSectionPointType pnt_types[2]; ProError err; ProWSecerror errors; double y, r; do /* Used for exit from the middle of block */ { err = ProSectionEntityFromProjection(section, params[2].r, &circle_id); err = ProSectionEntityGet(section, circle_id, (Pro2dEntdef**)&p_circle); r = p_circle->radius; y = sqrt(r*r - params[0].d*params[0].d/4); /*----------------------------------------------------------*\ Create entities \*----------------------------------------------------------*/ line.type = PRO_2D_LINE; line.end1[0] = line.end2[0] = -params[0].d/2; line.end1[1] = y; line.end2[1] = r + params[1].d; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&line, &left_id); line.end1[0] = line.end2[0] = -line.end1[0]; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&line, &right_id); line.end1[0] = -line.end1[0]; line.end1[1] = line.end2[1]; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&line, &top_id); /*----------------------------------------------------------*\ Add dimensions \*----------------------------------------------------------*/ point[0] = 0.0; point[1] = r + params[1].d+1; pnt_types[0] = PRO_ENT_WHOLE; err =ProSecdimCreate(section, &top_id, pnt_types, 1, PRO_TK_DIM_LINE, point, &width_id); point[0] = params[0].d/2+1; point[1] = (y + point[1])/2; pnt_types[0] = pnt_types[1] = PRO_ENT_WHOLE; dims[0] = top_id; dims[1] = circle_id; err = ProSecdimCreate(section, dims, pnt_types, 2, PRO_TK_DIM_LINE_AOC, point, &height_id); /*----------------------------------------------------------*\ Solve section \*----------------------------------------------------------*/ err = ProSecerrorAlloc(&errors); err = ProSectionSolve(section, &errors); if (err != PRO_TK_NO_ERROR) break; err = ProSecerrorFree(&errors); } while (brk); return (err); } /*=============================================================*\ Function: ProUtilCreateKeySection Purpose: Full creating of open section with tree lines Return : \*=============================================================*/ ProError ProUtilCreateNotchSection( ProSection section, /*In : the section */ Parameter *params) /*In : params [0] - circle diameter */ /* params [1] - notch radius */ /* params [2] - backplate surface */ { Pro2dArcdef arc; Pro2dPnt point; int dims[2], brk=0; int circle_id, arc_id, hor_id, vert_id, rad_id; ProSectionPointType pnt_types[2]; ProError err; ProWSecerror errors; double y, x; do /* Used for exit from the middle of block */ { y = ((params[0].d*params[0].d)/2-params[1].d*params[1].d)/params[0].d; x = sqrt((params[0].d*params[0].d)/4-y*y); /*----------------------------------------------------------*\ Create entities \*----------------------------------------------------------*/ arc.type = PRO_2D_ARC; arc.center[0] = 0; arc.center[1] = params[0].d/2; arc.radius = params[1].d; arc.start_angle = atan2(y-params[0].d/2, -x)+PI*2; arc.end_angle = 3*PI - arc.start_angle; err = ProSectionEntityAdd(section, (Pro2dEntdef*)&arc, &arc_id); err = ProSectionEntityFromProjection(section, params[2].r, &circle_id); /*----------------------------------------------------------*\ Add dimensions \*----------------------------------------------------------*/ point[0] = 0.0; point[1] = params[0].d/2 ; pnt_types[0] = PRO_ENT_WHOLE; err =ProSecdimCreate(section, &arc_id, pnt_types, 1, PRO_TK_DIM_RAD, point, &rad_id); point[0] = 0; point[1] = params[0].d/4; pnt_types[0] = PRO_ENT_CENTER; pnt_types[1] = PRO_ENT_CENTER; dims[0] = circle_id; dims[1] = arc_id; err = ProSecdimCreate(section, dims, pnt_types, 2, PRO_TK_DIM_PNT_PNT_HORIZ, point, &hor_id); point[0] = 1.0; point[1] = params[0].d/4; pnt_types[0] = PRO_ENT_CENTER; pnt_types[1] = PRO_ENT_CENTER; dims[0] = circle_id; dims[1] = arc_id; vert_id = -1; printf( "point=(%f %f)\n", point[0], point[1] ); err = ProSecdimCreate(section, dims, pnt_types, 2, PRO_TK_DIM_AOC_AOC_TAN_VERT, point, &vert_id); /*----------------------------------------------------------*\ Solve section \*----------------------------------------------------------*/ err = ProSecerrorAlloc(&errors); err = ProSectionSolve(section, &errors); if (err != PRO_TK_NO_ERROR) break; err = ProSecerrorFree(&errors); } while (brk); return (err); } /*=============================================================*\ Function: ProUtilCreateSketchedFeature Purpose: create a new feature Return : PRO_TK_NO_ERROR if succsessfull, an error otherwise \*=============================================================*/ ProError ProUtilCreateSketchedFeature( GearParam *g_ptr, /* In : */ FeatureDef *feat_def, /* In : Feature definition */ ProFeature *feature) /* Out: created feature */ { static ElemTreeData sketch[]={ {1, PRO_E_SKETCHER, {PRO_VALUE_TYPE_POINTER}} }; static ProElempathItem path_items[] = { {PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_STD_SECTION}, {PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_SKETCHER} }; ProElement elem_tree, elem_sec; ProError err; ProModelitem model_item; ProSelection model_sel; ProFeatureCreateOptions opts[1]; ProErrorlist errs; ProElempath path; ProValue value; ProValueData value_data; ProSection section; int brk = 0; do /* Used for exit from middle of block */ { /*----------------------------------------------------------*\ Create Element Tree \*----------------------------------------------------------*/ err = ProUtilElemtreeCreate(feat_def->tree, feat_def->sizeof_tree, NULL, &elem_tree); if (err != PRO_TK_NO_ERROR) break; /*----------------------------------------------------------*\ Create the incomplete protrusion in the current model \*----------------------------------------------------------*/ err = ProMdlToModelitem(g_ptr->model, &model_item); err = ProSelectionAlloc(NULL, &model_item, &model_sel); opts[0] = PRO_FEAT_CR_INCOMPLETE_FEAT; err = ProFeatureCreate(model_sel, elem_tree, opts, 1, feature, &errs); if (err != PRO_TK_NO_ERROR) { ProUserFeatErrsPrint("ProFeatureCreate", err, elem_tree, &errs); break; } err = ProSelectionFree(&model_sel); /*----------------------------------------------------------*\ Get the initialized section element from the database \*----------------------------------------------------------*/ err = ProElempathAlloc(&path); err = ProElempathDataSet(path, path_items, 2); err = ProFeatureElemValueGet(feature, path, &value); err = ProValueDataGet(value, &value_data); section = (ProSection)value_data.v.p; err = ProElempathFree(&path); /*----------------------------------------------------------*\ Create a section \*----------------------------------------------------------*/ err = feat_def->section_create_func(section, feat_def->params); if (err != PRO_TK_NO_ERROR) break; /*----------------------------------------------------------*\ Add all others element to the element tree \*----------------------------------------------------------*/ sketch[0].data.v.p = (void*)section; err = ProElempathAlloc(&path); err = ProElempathDataSet(path, path_items, 1); err = ProElemtreeElementGet(elem_tree, path, &elem_sec); err = ProElempathFree(&path); err = ProUtilElemtreeCreate(sketch, 1, elem_sec, &elem_sec); /*----------------------------------------------------------*\ Redefine the protrusion and complete feature creation \*----------------------------------------------------------*/ opts[0] = PRO_FEAT_CR_DEFINE_MISS_ELEMS; err = ProFeatureRedefine(NULL, feature, elem_tree, opts, 1, &errs); if (err != PRO_TK_NO_ERROR) { ProUserFeatErrsPrint("ProFeatureRedefine", err, elem_tree, &errs); break; } err = ProElementFree(&elem_tree); /*----------------------------------------------------------*\ Set feature name \*----------------------------------------------------------*/ ProUtilModelitemNameSet(feature, feat_def->feat_name); } while (brk); return (err); } /*=============================================================*\ Function: ProUtilModelitemNameSet Purpose: Set new name for the model item Return : as ProModelitemNameSet \*=============================================================*/ ProError ProUtilModelitemNameSet(ProModelitem *modelitem, char *name) { ProName w_name; ProError status; ProStringToWstring(w_name, name); status = ProModelitemNameSet(modelitem, w_name); return (status); } /*=============================================================*\ Function: ProUtilFeatByNameVisit Purpose: visiting fucntion for ProSolidFeatVisit Return : 1 if feature with required name found, 0 otherwise \*=============================================================*/ static ProError ProUtilModelitemByNameVisit( ProModelitem *modelitem, ProError status, ProAppData app_data) { FeatByNameFind *feat_by_name = (FeatByNameFind *)app_data; ProName name; int i; ProBoolean vis; if (modelitem->type == PRO_FEATURE) { status = ProFeatureVisibilityGet((ProFeature*)modelitem, &vis); if (status!=PRO_TK_NO_ERROR || vis == PRO_B_FALSE) return (PRO_TK_NO_ERROR); } status = ProModelitemNameGet(modelitem, name); if (status != PRO_TK_NO_ERROR) return (PRO_TK_NO_ERROR); for (i=0; inum_feats; i++) { if (ProUtilStrwscmp(feat_by_name->feats[i].name, name)==0) feat_by_name->feats[i].id = modelitem->id; } return (PRO_TK_NO_ERROR); } /*=============================================================*\ Function: ProUtilFeatsByName Purpose: to find solid features by name Return : PRO_TK_NO_ERROR if successfull, \*=============================================================*/ ProError ProUtilFeatsByName( ProSolid model, FeatByName *feats, int num_feats) { FeatByNameFind feat_by_name; ProError status; int i; feat_by_name.feats = feats; feat_by_name.num_feats = num_feats; for (i=0; icenter[0]-c2->center[0]) + sqr(c1->center[1]-c2->center[1])); if ((dc1->radius + c2->radius) || (d + c1->radius < c2->radius) || (d + c2->radius < c1->radius)) return (PRO_TK_GENERAL_ERROR); y1 = (sqr(c1->radius) + sqr(d) - sqr(c2->radius)) / 2 /d; x1 = sqrt(sqr(c1->radius) - sqr(y1)); sa = (c2->center[0]-c1->center[0]) / d; ca = (c2->center[1]-c1->center[1]) / d; p1[0] = y1 * sa + x1 * ca + c1->center[0]; p1[1] = y1 * ca - x1 * sa + c1->center[1]; p2[0] = y1 * sa - x1 * ca + c1->center[0]; p2[1] = y1 * ca + x1 * sa + c1->center[1]; return (PRO_TK_NO_ERROR); } /*=============================================================*\ Function: ProUserFeatErrsPrint Purpose: Debug function. Print elem tree and errors af feature creation or redefenition failed *=============================================================*/ void ProUserFeatErrsPrint( char *function, ProError err, ProElement tree, ProErrorlist *err_list) { fprintf(stderr, "Function %s returned %d\n", function, err); ProUtilElementtreePrint(tree, (UtilTreeprintWindow)2, 0); ProUtilFeatErrsPrint(err_list); } /*=============================================================*\ Function: user_initialize Purpose: To initiate the user's options \*=============================================================*/ int user_initialize( int argc, /* Inp: Pro/E arg count */ char *argv[], /* Inp: Pro/E args */ char *version, /* Inp: Pro/E version */ char *build, /* Inp: Pro/E build date code */ wchar_t errbuf[80]) /* Out: error message (opt) */ { /* Declare external functions */ int m_id, wchar_size; ProError status; int ProUserNewgearMenu(); ProStringToWstring(msgfil, "usermsg.txt"); if (ProWcharSizeVerify(sizeof (wchar_t), &wchar_size)!=PRO_TK_NO_ERROR) { ProMessageDisplay(MSGFIL, "USER %0s", "Incorrect size of 'wchar_t'."); return(-1); } status = ProMenuFileRegister("part", "part.mnu", &m_id); if (status != PRO_TK_NO_ERROR) return (-1); status = ProMenuAuxfileRegister("part", "part.aux", &m_id); if (status != PRO_TK_NO_ERROR) return (-1); status=ProMenubuttonActionSet("part","New Gear", (ProMenubuttonAction)ProUserNewgearMenu,NULL,0); if (status != PRO_TK_NO_ERROR) return (-1); return (0); } /*=============================================================*\ Function: user_terminate Purpose: To handle any termination actions \*=============================================================*/ void user_terminate() { printf("\tEnd of Application\n"); }