utiltree.c

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

	TEST_CALL_REPORT("ProElempathDataSet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	err = ProFeatureElemValueGet(&feature, path, &value);
	TEST_CALL_REPORT("ProFeatureElemValueGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	er1 = ProElempathFree(&path);
	TEST_CALL_REPORT("ProElempathFree()",
		"ProUtilOriginalGeomSelection()", er1, er1 != PRO_TK_NO_ERROR);

	if (err != PRO_TK_NO_ERROR)
	    continue;

	err = ProValueDataGet(value, &int_data);
	TEST_CALL_REPORT("ProValueDataGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR || int_data.type != PRO_VALUE_TYPE_INT ||
	    int_data.v.i != PRO_DTMPLN_THRU)
	    continue;

	err = ProElempathAlloc(&path);
	TEST_CALL_REPORT("ProElempathAlloc()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	constr_ref[1].path_item.elem_index = i;
	err = ProElempathDataSet(path, constr_ref, 3);
	TEST_CALL_REPORT("ProElempathDataSet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	err = ProFeatureElemValueGet(&feature, path, &value);
	TEST_CALL_REPORT("ProFeatureElemValueGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	er1 = ProElempathFree(&path);
	TEST_CALL_REPORT("ProElempathFree()",
		"ProUtilOriginalGeomSelection()", er1, er1 != PRO_TK_NO_ERROR);

	if (err != PRO_TK_NO_ERROR)
	    continue;

	err = ProValueDataGet(value, &int_data);
	TEST_CALL_REPORT("ProValueDataGet()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR || 
	    int_data.type != PRO_VALUE_TYPE_SELECTION)
	    continue;

	/* Original Selection found. Replace old one */
	err = ProSelectionCopy(int_data.v.r, p_new_sel);
	TEST_CALL_REPORT("ProSelectionCopy()",
		"ProUtilOriginalGeomSelection()", err, err != PRO_TK_NO_ERROR);

	replace = PRO_B_TRUE;
	break;
    }

    return (replace == PRO_B_TRUE ? PRO_TK_NO_ERROR : PRO_TK_E_NOT_FOUND);
}


/*====================================================================*\
FUNCTION : ProUtilValueReplaceSelection
PURPOSE  : Replace selection in value
\*====================================================================*/
ProError ProUtilValueReplaceSelection(
    ProValue *p_value,
    ProUtilChahgeSelection user_func,
    ProAppData	appdata)
{
    ProSelection new_sel;
    ProValueData val_data,new_data;
    ProError err;

    err = ProValueDataGet(*p_value, &val_data);
    TEST_CALL_REPORT("ProValueDataGet()",
		"ProUtilValueReplaceSelection()", err, err != PRO_TK_NO_ERROR);
    
    if (err != PRO_TK_NO_ERROR || val_data.type != PRO_VALUE_TYPE_SELECTION)
	return (PRO_TK_E_NOT_FOUND);

        
    err = user_func(val_data.v.r, &new_sel, appdata);
    if (err != PRO_TK_NO_ERROR)
	return err;

    /* Original Selection found. Replace old one */
    err = ProValueFree(*p_value);
    TEST_CALL_REPORT("ProValueFree()", 
	      "ProUtilValueReplaceSelection()", err, 0);
    err = ProValueAlloc(p_value);
    TEST_CALL_REPORT("ProValueAlloc()",
	      "ProUtilValueReplaceSelection()", err, err != PRO_TK_NO_ERROR);
    new_data.type = PRO_VALUE_TYPE_SELECTION;

    new_data.type = PRO_VALUE_TYPE_SELECTION;
    new_data.v.r = new_sel;

    err = ProValueDataSet(*p_value, &new_data);
    TEST_CALL_REPORT("ProValueDataSet()",
	    "ProUtilValueReplaceSelection()", err, err != PRO_TK_NO_ERROR);

    return (err);
}

/*====================================================================*\
FUNCTION : ProUtilElemtreeReplaceSelection
PURPOSE  : Replace selection for elemtree
\*====================================================================*/
ProError ProUtilElemtreeReplaceSelection(
    ProElement elem_tree,
    ProUtilChahgeSelection user_func,
    ProAppData	appdata)
{
    ProError err;
    ElemtreeElement *p_elems;
    int i, j, n_elems, n_val;
    ProValue value, *p_values;
    ProBoolean  replace, is_multi;

    err = ProUtilCollectElemtreeElements(elem_tree, NULL, &p_elems);
    if (err != PRO_TK_NO_ERROR)
	return (err);
    
    err = ProArraySizeGet((ProArray)p_elems, &n_elems);
    TEST_CALL_REPORT("ProArraySizeGet()",
	    "ProUtilElemtreeReplaceSelection()", err, err != PRO_TK_NO_ERROR);
    for(i=0; i<n_elems; i++)
    {
	if (ProUtilElemWithSelectionFilter(elem_tree, p_elems[i].p_element,
	    p_elems[i].p_elempath) != PRO_TK_NO_ERROR)
	    continue;
	
	err = ProElementIsMultival(p_elems[i].p_element, NULL, &is_multi);
	TEST_CALL_REPORT("ProElementIsMultival()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);

	replace =PRO_B_FALSE;

	if (is_multi)
	{
	    err = ProArrayAlloc(0, sizeof(ProValue*), 1, (ProArray*)&p_values);
	    TEST_CALL_REPORT("ProArrayAlloc()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);
	    err = ProElementValuesGet(p_elems[i].p_element, &p_values);
	    TEST_CALL_REPORT("ProElementValuesGet()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);
	    err = ProArraySizeGet((ProArray)p_values, &n_val);
	    TEST_CALL_REPORT("ProArraySizeGet()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);

	    for (j=0; j<n_val; j++)
	    {
		err = ProUtilValueReplaceSelection(p_values + j, user_func, 
		    appdata);
		if (err == PRO_TK_NO_ERROR)
		    replace = PRO_B_TRUE;
	    }
	    
	    if (replace == PRO_B_TRUE)
	    {
		err = ProElementValuesSet(p_elems[i].p_element, p_values, 
		    n_val);
		TEST_CALL_REPORT("ProElementValuesSet()",
		    "ProUtilElemtreeReplaceSelection()", 
	    		    			err, err != PRO_TK_NO_ERROR);
	    }
	    err = ProArrayFree((ProArray*)&p_values);
	    TEST_CALL_REPORT("ProArraySizeGet()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);
	}
	else
	{
	    err = ProElementValueGet(p_elems[i].p_element, &value);
	    TEST_CALL_REPORT("ProElementValueGet()",
		"ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);
	
	    err = ProUtilValueReplaceSelection(&value, user_func, appdata);
	    if (err == PRO_TK_NO_ERROR)
	    {
		err = ProElementValueSet(p_elems[i].p_element, value);
		TEST_CALL_REPORT("ProElementValueGet()",
		    "ProUtilElemtreeReplaceSelection()", 
						err, err != PRO_TK_NO_ERROR);
	    }

	}
    }	
    err = ProUtilElemtreeElementArrayFree(&p_elems);
    return (err);
}

/*=============================================================*\
  Function: 	ProUtilElemtreeCreate
  Purpose:	Create element tree by the ElemTreeData structure
  Return :      PRO_TK_NO_ERROR if successfull,
\*=============================================================*/
ProError ProUtilElemtreeCreate(
    ElemTreeData *elemarr,	    /* In : The array of ElemTreeData */
    int n_elem,			    /* In : number of ElemTreeData in elemarr */
    ProElement base_tree,	    /* In : the base tree */
    ProElement *elem_tree)	    /* Out : element tree */
{
    ProElement elem_level[10], elem;
    ProValue value;
    int i;
    ProError err;

    if (base_tree!=NULL)
	elem_level[0] = base_tree;

    for (i=0; i<n_elem; i++)
    {
	err = ProElementAlloc((ProElemId)elemarr[i].elem_id, &elem);
	TEST_CALL_REPORT("ProElementAlloc()", 
		 "ProUtilElemtreeCreate()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    return (err);
	if (elemarr[i].data.type != -1)
	{
/*----------------------------------------------------------*\
    Add Element value
\*----------------------------------------------------------*/
	    err = ProValueAlloc(&value);
	    TEST_CALL_REPORT("ProValueAlloc()", 
		 "ProUtilElemtreeCreate()", err, err != PRO_TK_NO_ERROR);
	    if (err != PRO_TK_NO_ERROR)
		return (err);
	    err = ProValueDataSet(value, &elemarr[i].data);
	    TEST_CALL_REPORT("ProValueDataSet()", 
		 "ProUtilElemtreeCreate()", err, err != PRO_TK_NO_ERROR);
	    if (err != PRO_TK_NO_ERROR)
		return (err);
	    err = ProElementValueSet(elem, value);
	    TEST_CALL_REPORT("ProElementValueSet()", 
		 "ProUtilElemtreeCreate()", err, err != PRO_TK_NO_ERROR);
	    if (err != PRO_TK_NO_ERROR)
		return (err);
	}
/*----------------------------------------------------------*\
    Add Element to the tree
\*----------------------------------------------------------*/
	if (elemarr[i].level!=0)
	{
	    err = ProElemtreeElementAdd(elem_level[elemarr[i].level-1], NULL, 
		elem);
	    TEST_CALL_REPORT("ProElemtreeElementAdd()", 
		 "ProUtilElemtreeCreate()", err, err != PRO_TK_NO_ERROR);
	}
	elem_level[elemarr[i].level] = elem;
    }
    elem_tree[0] = elem_level[0];
    return (PRO_TK_NO_ERROR);
}

/*=============================================================*\
  Function: 	ProUtilElemtreeElementGet
  Purpose:	Find Element by array of elempathitems
\*=============================================================*/
ProError ProUtilElemtreeElementGet(
    ProElement elem_tree,
    ProElempathItem *elempath_data,
    int	path_size,
    ProElement *p_element)
{
    ProElempath path;
    ProError err, status;

    err = ProElempathAlloc(&path);
    TEST_CALL_REPORT("ProElempathAlloc()",
		"ProUtilElemtreeElementGet()", err, err != PRO_TK_NO_ERROR);

    err = ProElempathDataSet(path, elempath_data, path_size);
    TEST_CALL_REPORT("ProElempathDataSet()", 
		"ProUtilElemtreeElementGet()", err, err != PRO_TK_NO_ERROR);

    err = ProElemtreeElementGet(elem_tree, path, p_element);
    TEST_CALL_REPORT("ProElemtreeElementGet()", 
		"ProUtilElemtreeElementGet()", err, err != PRO_TK_NO_ERROR &&
		err != PRO_TK_E_NOT_FOUND);
   
    status = ProElempathFree(&path);
    TEST_CALL_REPORT("ProElempathFree()", 
	    "ProUtilElemtreeElementGet()", status, status != PRO_TK_NO_ERROR);

    return(err);
}


/*====================================================================*\
FUNCTION : ProUtilFeatErrsPrint
PURPOSE  : Prints feature errors
\*====================================================================*/
ProError ProUtilFeatErrsPrint(ProErrorlist *errs)
{
    int i;

    for (i=0; i<errs->error_number; i++)
    {
        printf("Error %d: Error ID %d, Type %d, Error %d\n",
                i+1,errs->error_list[i].err_item_id,
                errs->error_list[i].err_item_type,
                errs->error_list[i].error);
    }

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProUtilElementValueSet()
PURPOSE  : Replace an element value by new one
\*====================================================================*/
ProError ProUtilElementValueSet(
    ProElement element,
    ProValueData  *value_data)
{
    ProError err;
    ProValue value;

/*--------------------------------------------------------------------*\
    First free the previous value of element
\*--------------------------------------------------------------------*/
    err = ProElementValueGet(element, &value);
    TEST_CALL_REPORT("ProElementValueGet()", 
		    "ProUtilElementValueSet()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
    {
	err = ProValueFree(value);
	TEST_CALL_REPORT("ProValueFree()", 
		    "ProUtilElementValueSet()", err, 0);
    }
/*--------------------------------------------------------------------*\
    Set the new value
\*--------------------------------------------------------------------*/
    err = ProValueAlloc(&value);
    TEST_CALL_REPORT("ProValueAlloc()", 
		    "ProUtilElementValueSet()", err, err != PRO_TK_NO_ERROR);
    err = ProValueDataSet (value, value_data);
    TEST_CALL_REPORT("ProValueDataSet()", 
		    "ProUtilElementValueSet()", err, err != PRO_TK_NO_ERROR);
    err = ProElementValueSet (element, value);
    TEST_CALL_REPORT("ProElementValueSet()", 
		    "ProUtilElementValueSet()", err, err != PRO_TK_NO_ERROR);
    
    return(PRO_TK_NO_ERROR);
}