geardesign.c

Pro.TOOLKIT.Wildfire插件设计.配套光盘-141M.zip

	{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;

    if (g_ptr->backnotch_rad == 0.0 || g_ptr->backplate_diam == 0.0)
      return 1;

/*-----------------------------------------------------------------*\
    Preparation of feature data
\*-----------------------------------------------------------------*/
    memset(&feat_def, 0, sizeof(feat_def));
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, 
	&tree[7].data.v.r);
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, 
	&tree[10].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;
    }
/*-----------------------------------------------------------------*\
    Free allocated memory
\*-----------------------------------------------------------------*/
    ProSelectionFree(&tree[7].data.v.r);
    ProSelectionFree(&tree[10].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[2];

    feats [0].name = "GEAR_HOLE";
    feats [1].name = "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); 
/*-----------------------------------------------------------------*\
    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);
}

typedef struct
{
  double*  value;
  int find_index;
  int index;
} ProUserDimensionFinddata;


/*=============================================================*\
  Function: 	ProUserGetDimensionValue
  Purpose:	find first dimension; store value 
\*=============================================================*/
ProError   ProUserGetDimensionValue (ProDimension* dim, 
				 ProError status, 
				 ProAppData data)
{
  ProUserDimensionFinddata* find_data = (ProUserDimensionFinddata*) data;

  ProDimensionValueGet (dim, find_data->value);

  return PRO_TK_ABORT;
}

/*=============================================================*\
  Function: 	ProUserFindDiameterDimension
  Purpose:	find diameter dimension
\*=============================================================*/
ProError   ProUserFindDiameterDimension (ProDimension* dim, 
				 ProAppData data)
{
  ProDimensiontype type;

  ProDimensionTypeGet (dim, &type);

  if (type == PRODIMTYPE_DIAMETER)
    return PRO_TK_NO_ERROR;
  else
    return PRO_TK_CONTINUE;
}

/*=============================================================*\
  Function: 	ProUserFindDiameterDimension
  Purpose:	find non-diameter dimension
\*=============================================================*/
ProError   ProUserFindNondiameterDimension (ProDimension* dim, 
				 ProAppData data)
{
  ProDimensiontype type;
  double value;

  ProDimensionTypeGet (dim, &type);

  if (type == PRODIMTYPE_DIAMETER || type == PRODIMTYPE_UNKNOWN)
    return PRO_TK_CONTINUE;
  else
    return PRO_TK_NO_ERROR;
}

/*=============================================================*\
  Function: 	ProUserFindDiameterDimension
  Purpose:	find nth dimension in the visit
\*=============================================================*/
ProError   ProUserFindDimensionByIndex (ProDimension* dim, 
					ProAppData data)
{
   ProUserDimensionFinddata* find_data = (ProUserDimensionFinddata*) data;

   ProDimensiontype type;
   ProDimensionTypeGet (dim, &type);
   if (type == PRODIMTYPE_UNKNOWN)
     return PRO_TK_CONTINUE;

   find_data->index ++;
   
   if (find_data->index == find_data->find_index)
     return PRO_TK_NO_ERROR;
   else
     return PRO_TK_CONTINUE;
}

/*=============================================================*\
  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[] = {
	{"GD_FRONT"},		/*  0 */
	{"GD_SIDE"},		/*  1 */
	{"GD_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;
    ProUserDimensionFinddata find_data;

    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);
	    
	    find_data.value = &g_ptr->datum_z_offset;
	    err = ProFeatureDimensionVisit (&f, ProUserGetDimensionValue, 
					    NULL, 
					    (ProAppData)&find_data);
	    

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

	    find_data.value = &g_ptr->datum_x_offset;
	    err = ProFeatureDimensionVisit (&f, ProUserGetDimensionValue,
					    NULL, 
					    (ProAppData)&find_data);

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

	    find_data.value = &g_ptr->datum_y_offset;
	    err = ProFeatureDimensionVisit (&f, ProUserGetDimensionValue, 
					    NULL, 
					    (ProAppData)&find_data);
	}
    }
    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;

	find_data.value = &g_ptr->gear_diam;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindDiameterDimension, 
					(ProAppData)&find_data);

	find_data.value = &g_ptr->gear_depth;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindNondiameterDimension, 
					(ProAppData)&find_data);
    }
    g_ptr->disk_created = feats[3].id!=-1;	    
    if ((feats[4].id!=-1) && (g_ptr->hole_created==0)) 
    {
      g_ptr->hole_created = 1;
/*-----------------------------------------------------------------*\
    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;

	find_data.value = &g_ptr->inner_diam;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindDiameterDimension, 
					(ProAppData)&find_data);
    }    
    if (g_ptr->keyway_created = (feats[5].id!=-1))
      {
	 err = ProFeatureInit(solid, feats[5].id, &feature);
	find_data.value = &g_ptr->keyway_out_width;
	find_data.find_index = 1;
	find_data.index = 0;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindDimensionByIndex, 
					(ProAppData)&find_data);

	find_data.value = &g_ptr->keyway_out_height;
	find_data.find_index = 2;
	find_data.index = 0;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindDimensionByIndex, 
					(ProAppData)&find_data);
      }
    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)) 
    {
      g_ptr->hub_created = 1;
/*-----------------------------------------------------------------*\
    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;

	find_data.value = &g_ptr->hub_out_diam;
	err = ProFeatureDimensionVisit (&feature, ProUserGetDimensionValue, 
					ProUserFindDiameterDimension, 
					(ProAppData)&find_data);

	find_data.value = &g_ptr->hub_depth;