utiltree.c

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

   double char_length;

   err = ProTextAttributesCurrentGet(&attribute);
   TEST_CALL_REPORT("ProTextAttributesCurrentGet","ProUtilDisp",
                                        err, err!=PRO_TK_NO_ERROR);

   new_attribute = attribute;
   new_attribute.height = 15;
   new_attribute.width_factor = 0.75;

#if 0

   err = ProTextHeightCurrentSet(new_attribute.height);
          TEST_CALL_REPORT("ProTextHeightCurrentSet","ProUtilDisp",
                                        err, err!=PRO_TK_NO_ERROR);
   err =  ProTextWidthFactorCurrentSet(new_attribute.width_factor);
          TEST_CALL_REPORT("ProTextWidthFactorCurrentSet","ProUtilDisp",
                                        err, err!=PRO_TK_NO_ERROR);
#endif
   ProStringToWstring(w_str, text);
   err = ProGraphicsTextDisplay(win_data.point, w_str);
   TEST_CALL_REPORT("ProGraphicsTextDisplay","ProUtilDisp",
                                       err, err!=PRO_TK_NO_ERROR);
#if 0
   err = ProTextHeightCurrentSet(attribute.height);
          TEST_CALL_REPORT("ProTextHeightCurrentSet","ProUtilDisp",
                                        err, err!=PRO_TK_NO_ERROR);
   err = ProTextWidthFactorCurrentSet(attribute.width_factor);
          TEST_CALL_REPORT("ProTextWidthFactorCurrentSet","ProUtilDisp",
                                        err, err!=PRO_TK_NO_ERROR);
#endif

   if (move_carret == PRO_B_TRUE)
     {
       char_length = new_attribute.height * new_attribute.width_factor;
       win_data.point[0] += 2 * char_length * (double)strlen(text);
     }

   return err;
}


/*====================================================================*\
FUNCTION : ProUtilElemtreeInGrWindow
PURPOSE  :
\*====================================================================*/
static ProError ProUtilElemtreeInGrWindow(
   ProElement  elem_tree,
   ProElempath elem_path,
   ProUtilElemtreePrintOpts *options,
   int *p_win_id)
{
   ProError err = PRO_TK_NO_ERROR;
#ifndef PT_PRODUCTS_BUILD
   ProName obj_name;
   ProType obj_type = PRO_PART;
   ProSolid tree_obj;
   int cur_id, newwin_id;
   ProMatrix transform;
   UtilTreeprintWindow window = PRO_TEST_GRAPHICS_WINDOW;

   ProStringToWstring(obj_name, "feature_tree");

   err = ProSolidCreate(obj_name, obj_type, &tree_obj);
   TEST_CALL_REPORT("ProSolidCreate()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   if (err != PRO_TK_NO_ERROR)
     {
       err = ProMdlInit(obj_name, (ProMdlType)obj_type, (ProMdl *)&tree_obj);
       TEST_CALL_REPORT("ProMdlInit()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);
     }

    if (err != PRO_TK_NO_ERROR)
     {
       err = ProMdlRetrieve(obj_name, (ProMdlType)obj_type, (ProMdl *)&tree_obj);
       TEST_CALL_REPORT("ProMdlRetrieve()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);
     }

   err = ProWindowCurrentGet(&cur_id);
   TEST_CALL_REPORT("ProWindowCurrentGet()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   err = ProObjectwindowCreate(obj_name, obj_type, &newwin_id);
   TEST_CALL_REPORT("ProObjectwindowCreate()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   err = ProWindowCurrentSet(newwin_id);
   TEST_CALL_REPORT("ProWindowCurrentSet()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   err = ProSolidDisplay(tree_obj);
   TEST_CALL_REPORT("ProSolidDisplay()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);


   err = ProViewMatrixGet((ProMdl) tree_obj, NULL, transform);
   TEST_CALL_REPORT("ProViewMatrixGet", "ProUtilElemtreeInGrWindow", err,
                                                err != PRO_TK_NO_ERROR);

   err = ProDisplist2dDelete(5);
   TEST_CALL_REPORT("ProDisplist2dDelete()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   win_data.point[0] = 0.0;
   win_data.point[1] = 800;
   win_data.decrease = 35;

   err = ProDisplist2dCreate(5, transform, 
        (ProDisplistCallback)ProUtilElemtreePPrint,
        (void *)elem_tree, (void *)elem_path, (void *)options, (void *)&window);
   TEST_CALL_REPORT("ProDisplist3dCreate", "ProUtilElemtreeInGrWindow", err,
                                                err != PRO_TK_NO_ERROR);

   err = ProWindowRefresh( newwin_id );
   TEST_CALL_REPORT("ProWindowRefresh()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);


   err = ProDisplist2dDisplay(5, transform);
   TEST_CALL_REPORT("ProDisplist2dDisplay()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   err = ProWindowCurrentSet(cur_id);
   TEST_CALL_REPORT("ProWindowCurrentSet()", "ProUtilElemtreeInGrWindow",
                                             err, err != PRO_TK_NO_ERROR);

   if(p_win_id != NULL)
     *p_win_id = newwin_id;
#endif
   return err;
}

/*====================================================================*\
    FUNCTION :	ProUtilShowTreeInInfo()
    PURPOSE  :	show tree
\*====================================================================*/
ProError ProUtilShowTreeInInfo(
    ProElement elem_tree )
{
    return (ProUtilElementtreePrint(elem_tree,PRO_TEST_INFO_WINDOW,NULL));
}


/*====================================================================*\
    FUNCTION :	ProUtilElemWithSelectionFilter()
    PURPOSE  :	Finf Elements with selection data
\*====================================================================*/
ProError ProUtilElemWithSelectionFilter(
    ProElement elem_tree,
    ProElement elem,
    ProElempath elempath)
{
    ProError err;
    ProBoolean is_comp, is_multi, has_sel = PRO_B_FALSE;
    ProValue value, *p_values;
    ProValueData val_data;
    int i, n_val;

    err = ProElementIsArray(elem, NULL, &is_comp);
    TEST_CALL_REPORT("ProElementIsArray()", 
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);

    
    if (is_comp == PRO_B_FALSE)
    {
	err = ProElementIsCompound(elem, NULL, &is_comp);
	TEST_CALL_REPORT("ProElementIsCompound()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
    }

    if (is_comp == PRO_B_TRUE)
	return (PRO_TK_CONTINUE);

    err = ProElementIsMultival(elem, NULL, &is_multi);
    TEST_CALL_REPORT("ProElementIsMultival()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);

    if (is_multi)
    {
	err = ProArrayAlloc(0, sizeof(ProValue*), 1, (ProArray*)&p_values);
	TEST_CALL_REPORT("ProArrayAlloc()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
	err = ProElementValuesGet(elem, &p_values);
	TEST_CALL_REPORT("ProElementValuesGet()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
	err = ProArraySizeGet((ProArray)p_values, &n_val);
	TEST_CALL_REPORT("ProArraySizeGet()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
	for (i=0; i<n_val; i++)
	{
	    err = ProValueDataGet(p_values[i], &val_data);
	    TEST_CALL_REPORT("ProValueDataGet()",
		"ProUtilElemWithSelectionFilter()", 
						err, err != PRO_TK_NO_ERROR);
	    if (val_data.type == PRO_VALUE_TYPE_SELECTION)
	    {
		has_sel = PRO_B_TRUE;
		break;
	    }
	}
	err = ProArrayFree((ProArray*)&p_values);
	TEST_CALL_REPORT("ProArrayFree()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
    }
    else
    {
	err = ProElementValueGet(elem, &value);
	TEST_CALL_REPORT("ProElementValueGet()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
	err = ProValueDataGet(value, &val_data);
	TEST_CALL_REPORT("ProValueDataGet()",
	    "ProUtilElemWithSelectionFilter()", err, err != PRO_TK_NO_ERROR);
	if (val_data.type == PRO_VALUE_TYPE_SELECTION)
	    has_sel = PRO_B_TRUE;
    }

    return (has_sel == PRO_B_TRUE ? PRO_TK_NO_ERROR : PRO_TK_CONTINUE);
}

/*====================================================================*\
FUNCTION : ProUtilSelectionChangeAsmcomppath
PURPOSE  : Move selection from part and subassembly refs to the root 
	   assembly level 
\*====================================================================*/
ProError ProUtilSelectionChangeAsmcomppath(
    ProSelection old_sel,
    ProSelection *p_new_sel,
    ProAppData p_asmcomppath)
{
    ProAsmcomppath *p_fpath = ((ProAsmcomppath *)p_asmcomppath);
    ProAsmcomppath  ref_path, path;
    ProModelitem    modelitem;
    ProMdl	    mdl;
    ProError	    err;
    int i;

    /* Model and feature must be on the one branch from the root assy
       Model path must be less that feature path */	
    err = ProSelectionAsmcomppathGet(old_sel, &ref_path);
    TEST_CALL_REPORT("ProSelectionAsmcomppathGet()",
	    "ProUtilSelectionChangeAsmcomppath()", err, err != PRO_TK_NO_ERROR);
    if (ref_path.table_num >= p_fpath->table_num)
	return (PRO_TK_E_NOT_FOUND);

    err = ProSelectionModelitemGet(old_sel, &modelitem);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
	    "ProUtilSelectionChangeAsmcomppath()", err, err != PRO_TK_NO_ERROR);

    if (ref_path.table_num == 0)
	ref_path.owner = (ProSolid)modelitem.owner;

    for (i=0; i< p_fpath->table_num - ref_path.table_num; i++)   
    {
	err = ProAsmcomppathInit(p_fpath->owner, p_fpath->comp_id_table, i+1,
	    &path);
	TEST_CALL_REPORT("ProAsmcomppathInit()",
	    "ProUtilSelectionChangeAsmcomppath()", err, err != PRO_TK_NO_ERROR);

	err = ProAsmcomppathMdlGet(&path, &mdl);
	TEST_CALL_REPORT("ProAsmcomppathMdlGet()",
	    "ProUtilSelectionChangeAsmcomppath()", err, err != PRO_TK_NO_ERROR);

	/* Owner found on same branch as feature */
	if (mdl == (ProMdl)ref_path.owner)
	    break;
    }
    if (i >= p_fpath->table_num - ref_path.table_num)
	return (PRO_TK_E_NOT_FOUND);

    /* build new ref path */
    memcpy(path.comp_id_table + i + 1, ref_path.comp_id_table, 
	(ref_path.table_num+1) * sizeof(path.comp_id_table[0]));
    path.table_num = i + 1 + ref_path.table_num;

    err = ProSelectionAlloc(&path, &modelitem, p_new_sel);
    TEST_CALL_REPORT("ProSelectionAlloc()",
	    "ProUtilSelectionChangeAsmcomppath()", err, err != PRO_TK_NO_ERROR);

    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProUtilOriginalGeomSelection
PURPOSE  : Changes selection to 'internal' surfaces to original geometry
\*====================================================================*/
ProError ProUtilOriginalGeomSelection(
    ProSelection old_sel,
    ProSelection *p_new_sel,
    ProAppData dummy)
{
    ProValueData int_data;
    ProValue value;
    ProError err, er1;
    ProElempath path;
    ProModelitem modelitem;
    ProFeature feature;
    ProFeattype feat_type;
    ProBoolean replace = PRO_B_FALSE, is_vis;
    int i;
    ProElempathItem constr_type[3]; 
    ProElempathItem constr_ref[3]; 

    constr_type[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
    constr_type[0].path_item.elem_id = PRO_E_DTMPLN_CONSTRAINTS;
    constr_type[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
    constr_type[1].path_item.elem_id = 0;
    constr_type[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
    constr_type[2].path_item.elem_id = PRO_E_DTMPLN_CONSTR_TYPE;

    constr_ref[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
    constr_ref[0].path_item.elem_id = PRO_E_DTMPLN_CONSTRAINTS;
    constr_ref[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
    constr_ref[1].path_item.elem_id = 0;
    constr_ref[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
    constr_ref[2].path_item.elem_id = PRO_E_DTMPLN_CONSTR_REF;

    err = ProSelectionModelitemGet(old_sel, &modelitem);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

    /* Do any wotk only if selection is surface on internal datum plane */
    if (modelitem.type != PRO_SURFACE)
	return (PRO_TK_E_NOT_FOUND);

    err = ProGeomitemFeatureGet((ProGeomitem*)&modelitem, &feature);
    TEST_CALL_REPORT("ProGeomitemFeatureGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

    err = ProFeatureVisibilityGet(&feature, &is_vis);
    TEST_CALL_REPORT("ProFeatureVisibilityGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR || is_vis != PRO_B_FALSE)
	return (PRO_TK_E_NOT_FOUND);

    err = ProFeatureTypeGet(&feature, &feat_type);
    TEST_CALL_REPORT("ProFeatureTypeGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

    if (err != PRO_TK_NO_ERROR || feat_type != PRO_FEAT_DATUM)
	return (PRO_TK_E_NOT_FOUND);

    /* internal datum plane found - create elemtree and check constarins*/
    for (i=0; i<2; i++)
    {
	err = ProElempathAlloc(&path);
	TEST_CALL_REPORT("ProElempathAlloc()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	constr_type[1].path_item.elem_index = i;
	err = ProElempathDataSet(path, constr_type, 3);