コード例 #1
0
// 处理过程
BOOL CSDMdlSpecAsmImplicitCheck::DoAction(void *pData, const CheckData &checkData)
{
	ProMdl pMdl = (ProMdl)pData;
	if (NULL == pMdl)
		return FALSE;

	int nCount = (int)checkData.checkResult.arrErrorItems.GetCount();
	ProModelitem mdlitem;
	mdlitem.owner = pMdl;
	mdlitem.type = PRO_FEATURE;

	int* parrFeatID = NULL;
	ProFeatureResumeOptions* parrOpt = NULL;
	ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&parrFeatID);
	ProArrayAlloc(0, sizeof(ProFeatureResumeOptions), 1, (ProArray*)&parrOpt);

	int nID = -1;
	ProFeatureResumeOptions opt = PRO_FEAT_RESUME_NO_OPTS;
	for (int i=0; i<nCount; i++)
	{
		nID = checkData.checkResult.arrErrorItems[i].nID;
		ProArrayObjectAdd((ProArray*)&parrFeatID, PRO_VALUE_UNUSED, 1, &nID);
		ProArrayObjectAdd((ProArray*)&parrOpt, PRO_VALUE_UNUSED, 1, &opt);
	}

	ProFeatureResume(ProMdlToSolid(pMdl), parrFeatID, nCount, parrOpt, nCount);

	ProArrayFree((ProArray *)&parrFeatID);
	ProArrayFree((ProArray *)&parrOpt);

	return TRUE;
}
コード例 #2
0
ファイル: UtilMenu.cpp プロジェクト: dyao-vu/meta-core
/*============================================================================*\
 Function:	ProUtilMenuStringsAlloc
 Purpose:       Alloc memory for array of wchar_t* used in ProMenu functions
\*============================================================================*/
ProError ProUtilMenuStringsAlloc(
    wchar_t ***w_ptr)
{
    ProError err;
    static wchar_t  w_epmty[] = {'\0'};
    wchar_t *w_p = w_epmty;

    err = ProArrayAlloc(0, sizeof(wchar_t*), 1, (ProArray*)w_ptr);
    if (err == PRO_TK_NO_ERROR)
	err = ProArrayObjectAdd((ProArray*)w_ptr, 0, 1, &w_p);
    return (err);
}
コード例 #3
0
ファイル: UtilMenu.cpp プロジェクト: dyao-vu/meta-core
/*============================================================================*\
 Function:	ProUtilMenuStringsWstrAdd
 Purpose:       Alloc memory and add string to MenuStrings array
\*============================================================================*/
ProError ProUtilMenuStringsWstrAdd(
    wchar_t ***w_ptr,
    wchar_t *w_str)
{
    ProError err;
    wchar_t *w_p;
    int len, n_str;

    len = ProUtilWstrLen(w_str);
    w_p = (wchar_t*)calloc(len + 1, sizeof(wchar_t));
    if (w_p == NULL)
	return (PRO_TK_GENERAL_ERROR);
    ProUtilWstrcpy(w_p, w_str); 

    err = ProArraySizeGet((ProArray)*w_ptr, &n_str);
    err = ProArrayObjectAdd((ProArray*)w_ptr, n_str-1, 1, &w_p);
    return (err);
}
コード例 #4
0
ファイル: UtilMenu.cpp プロジェクト: dyao-vu/meta-core
/*============================================================================*\
 Function:	ProUtilMenuStringsStrAdd
 Purpose:       Alloc memory and add string to MenuStrings array
\*============================================================================*/
ProError ProUtilMenuStringsStrAdd(
    wchar_t ***w_ptr,
    char *str)
{
    ProError err;
    wchar_t *w_p;
    int n_str;

    int len = static_cast<int>(strlen(str));
    w_p = (wchar_t*)calloc(len + 1, sizeof(wchar_t));
    if (w_p == NULL)
	return (PRO_TK_GENERAL_ERROR);
    ProStringToWstring(w_p, str); 

    err = ProArraySizeGet((ProArray)*w_ptr, &n_str);
    err = ProArrayObjectAdd((ProArray*)w_ptr, n_str-1, 1, &w_p);
    return (err);
}
コード例 #5
0
ファイル: MenuHandler.cpp プロジェクト: ZuDame/Smart3DCoating
// 环边裁剪
void OnTrimByEdgeActFn()
{
	/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
		return;*/

	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	DestroyAllDialog();
	CancelSelectDialog();
	Sleep(50);

	// 第1步:检查当前模型环境
	ProMdl pMdl = GetCurrentMdl();
	if (pMdl == NULL)
	{
		MessageBox(NULL, L"当前环境未发现模型!", L"提示", MB_OK|MB_ICONWARNING);
		return;
	}
	// 第2步:选择要裁剪的面
	ShowMessageTip(L"Tips.选择需要裁剪的面...");
	vector<ProSelection> arrSelSrf;
	ProSelection selSrf = NULL;
	while (SelectObject(arrSelSrf, "dtmqlt"))
	{
		ProSelectionCopy(arrSelSrf[0], &selSrf);
		// 第3步:暂时隐藏选择的面,选取完成后恢复显示
		ProModelitem itemQuilt;
		ProSelectionModelitemGet(arrSelSrf[0], &itemQuilt);
		ProModelitemHide(&itemQuilt);

		// 第4步:选择面上的环(先选取环的一条边)
		int nEdgeDir = PRO_EDGE_SAME_DIRECTION;
		ProSelection *pArrSelInit = NULL;
		ProArrayAlloc(0, sizeof(ProSelection), 1, (ProArray*)&pArrSelInit);
		vector<ProSelection> arrSelEdge;
		while (SelectObject(arrSelEdge, "sldedge"))
		{
			// 第5步:获取边所在环的全部边
			vector<ProSelection> arrSelContourEdges;
			if (GetContourByEdge(arrSelEdge[0], arrSelContourEdges, nEdgeDir))
			{
				for (int i=0; i<arrSelContourEdges.size(); i++)
				{
					ProArrayObjectAdd((ProArray*)&pArrSelInit, 0, 1, &arrSelContourEdges[i]);
				}
				break;
			}
			else
			{
				int nMsgResult = MessageBox(NULL, L"选取的边不是完整环的组成边,是否手动选取?\n是:手动选取;否:重新选取; 取消:退出", L"提示", MB_YESNOCANCEL|MB_ICONWARNING);
				if (nMsgResult == IDYES)	// 手动选择
				{
					ProArrayObjectAdd((ProArray*)&pArrSelInit, 0, 1, &arrSelEdge[0]);
					break;
				}
				else if (nMsgResult == IDCANCEL)	// 退出
				{
					ProModelitemUnhide(&itemQuilt);
					InvalidateDrawing();
					return;
				}
			}
		}
		// 第6步:自动选中对应完整环的全部边
		arrSelEdge.clear();
		if (SelectObject(arrSelEdge, "edge", MAX_SELECTION, pArrSelInit))
		{
			// 判断面的方向
			/*ProQuilt quilt;
			BOOL bSurfDirOut = FALSE;
			ProGeomitemToQuilt(&itemQuilt, &quilt);
			vector<ProSurface> arrSurfaces;
			ProQuiltSurfaceVisit(quilt, QuiltSurfacesGetAction, NULL, &arrSurfaces);
			ProGeomitemdata* psrfdata;
			ProSurfaceDataGet(arrSurfaces[0], &psrfdata);
			if (psrfdata->data.p_surface_data->orient == PRO_SURF_ORIENT_OUT)
				bSurfDirOut = TRUE;
			ProGeomitemdataFree(&psrfdata);*/
			
			// 第7步:修剪曲面
			int nFeatID = TrimQuiltByEdgeGroup(pMdl, selSrf, arrSelEdge, nEdgeDir);
			ProModelitemUnhide(&itemQuilt);
			SAFE_DELETE_PROARRAY(pArrSelInit);
			if (nFeatID > 0)
			{
				// 第8步:提示是否反向或继续修剪
				CDlgConfirm dlg;
				while (1)
				{
					int nResult = (int)dlg.DoModal();
					if (nResult == IDOK)
					{
						break;
					}
					else if (nResult == IDRETRY) 
					{
						// 修改裁剪方向
						ProFeature feat;
						feat.id = nFeatID;
						feat.type = PRO_FEATURE;
						feat.owner = pMdl;
						ReverseTrimDirection(feat);
					}
					else
					{
						InvalidateDrawing();
						ProMessageClear();
						return;
					}
				}
			}
			else if (MessageBox(NULL, L"裁剪失败,详见模型特征树。是否继续?", L"提示", MB_YESNO) == IDNO)
			{
				break;
			}
		}
		else
		{
			// 恢复显示
			ProModelitemUnhide(&itemQuilt);
			break;
		}
	}
	
	InvalidateDrawing();
	ProMessageClear();
}
コード例 #6
0
ファイル: MenuHandler.cpp プロジェクト: ZuDame/Smart3DCoating
// 加载包覆对象
void OnLoadSolidActFn()
{
	/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
		return;*/

	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	DestroyAllDialog();
	CancelSelectDialog();
	Sleep(50);

	// 选择一个本地的待包覆模型
	ProPath pathSelModel;
	if (ProFileOpen(L"选择待包覆模型", L"*.prt,*.asm,*.stp,*.stl", NULL, NULL, NULL, NULL, pathSelModel) == PRO_TK_NO_ERROR)
	{
		ProPath pathFolder;
		ProName nameModel, nameExt;
		int nVersion;
		ProFilenameParse(pathSelModel, pathFolder, nameModel, nameExt, &nVersion);

		ProMdl pMdlToCoating;
		if (CString(nameExt).CompareNoCase(L"stp") == 0 || CString(nameExt).CompareNoCase(L"step") == 0)
		{
			LoadStep(CString(pathSelModel), pMdlToCoating);
		}
		else
		{
			ProMdlLoad(pathSelModel, PRO_MDL_UNUSED, PRO_B_FALSE, &pMdlToCoating);
		}


		// 创建一个装配体
		CString strSolidName;
		strSolidName = nameModel;

		strSolidName.Format(L"%s_3DCoat", strSolidName);

		ProName nameSolid;
		wcsncpy_s(nameSolid, PRO_NAME_SIZE, strSolidName, _TRUNCATE);

		ProSolid solid;
		ProSolidCreate(nameSolid, PRO_ASSEMBLY, &solid);

		// 创建默认坐标系
		ProError status;
		ProElement elemTree = NULL;
		ProElementAlloc(PRO_E_FEATURE_TREE, &elemTree);
		{
			// 特征类型PRO_E_FEATURE_TYPE
			ProElement elemType;
			status = ProElementAlloc(PRO_E_FEATURE_TYPE, &elemType);
			status = ProElemtreeElementAdd(elemTree, NULL, elemType);
			ProValueData valdataType;
			valdataType.type = PRO_VALUE_TYPE_INT;
			valdataType.v.i = PRO_FEAT_CSYS;
			ProValue valueType = NULL;
			status = ProValueAlloc(&valueType);
			status = ProValueDataSet(valueType, &valdataType);
			status = ProElementValueSet(elemType, valueType);
		}
		ProModelitem itemAssmble;
		ProMdlToModelitem(ProAssemblyToMdl(solid), &itemAssmble);
		ProSelection selAssmble;
		ProSelectionAlloc(NULL, &itemAssmble, &selAssmble);

		ProErrorlist errorsList;
		ProFeatureCreateOptions opts[1] = {PRO_FEAT_CR_NO_OPTS};
		ProFeature feat;
		status = ProFeatureCreate(selAssmble, elemTree, opts, 1, &feat, &errorsList);


		// 将选择的待装配模型装配到装配体下
		ProMatrix initPos = {
			{1.0, 0.0, 0.0, 0.0},
			{0.0, 1.0, 0.0, 0.0},
			{0.0, 0.0, 1.0, 0.0},
			{0.0, 0.0, 0.0, 1.0}
		};
		ProAsmcomp comp;
		ProAsmcompAssemble(ProAssembly(solid), ProMdlToSolid(pMdlToCoating), initPos, &comp);
		ProAsmcompconstraint compConstr;
		ProAsmcompconstraintAlloc(&compConstr);
		ProAsmcompconstraintTypeSet(compConstr, PRO_ASM_DEF_PLACEMENT);
		ProAsmcompconstraint* compConstrs;
		ProArrayAlloc (0, sizeof (ProAsmcompconstraint), 1, (ProArray*)&compConstrs);
		status = ProArrayObjectAdd ((ProArray*)&compConstrs, -1, 1, &compConstr);
		ProAsmcompConstraintsSet(NULL, &comp, compConstrs);

		ProMdlDisplay(solid);
		int nWnd;
		ProWindowCurrentGet(&nWnd);
		ProWindowActivate(nWnd);
	}

	InvalidateDrawing();
	ProMessageClear();
}
コード例 #7
0
ファイル: UtilMenu.cpp プロジェクト: dyao-vu/meta-core
/*============================================================================*\
 Function:	ProUtilMenuStringManySelect
 Purpose:       Select many string from menu with submenu Select All/Unsell All
\*============================================================================*/
ProError ProUtilMenuStringManySelect(
    char    *menu_name,		   /* In : Menu name */
    wchar_t **w_menu_buttons,	   /* In : Menu buttons */
    int	    **output_array,	   /* Out: ProArray of numbers of selected 
					   strings, use ProArrayFree to free
					   memory */
    int *p_n_sel)		   /* Out: Number of selected components */
{
    int i, n_but, n_sel, menu_id, action;
    ProError err, ret_status = PRO_TK_USER_ABORT;
    int *toggle_array;
    MenuToggleInfo toggle_info;
    ProCharName name;
    wchar_t **w_menus;

    for(n_but=0; w_menu_buttons[n_but][0] != '\0'; n_but++);
    err = ProArrayAlloc(n_but, sizeof(int), 1, (ProArray*)&toggle_array);
    
    toggle_info.w_menu_buttons = w_menu_buttons;
    toggle_info.button_status = toggle_array;
    toggle_info.n_buttons = n_but;
    toggle_info.menu_name = menu_name;

    err = ProMenuFromStringsRegister ( menu_name, NULL, 
	w_menu_buttons, NULL, NULL, &menu_id);
    for (i=0; i<n_but; i++)
    {
	toggle_array[i] = 0;
	ProWstringToString(name, w_menu_buttons[i]);
	err = ProMenubuttonActionSet(menu_name, name,
	    (ProMenubuttonAction)ProUtilMenuToggleOne, &toggle_info, i);
    }   
    err = ProMenubuttonActionSet(menu_name, menu_name,
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenuModeSet(menu_name, PROMENUMODE_DATA);
    err = ProMenuDatamodeSet(menu_name, PRO_B_TRUE );
    err = ProMenuCreate(PROMENUTYPE_MAIN, menu_name, &menu_id);

    err = ProUtilMenuStringsAlloc(&w_menus);
    err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Select All");
    err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Unsel All");
    err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Done Sel");
    err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Quit Sel");
    
    ProMenuFromStringsRegister ( (char *)"TkMenuUtilSelect", NULL, w_menus,
	NULL, NULL, &menu_id);
    err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Select All",
	(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, SELECT_ALL);
    err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Unsel All", 
	(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, UNSEL_ALL);
    err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Done Sel", 
	(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, DONE_SEL);
    err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Quit Sel",
	(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, QUIT_SEL);
    err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"TkMenuUtilSelect", 
	(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, QUIT_SEL);

    err = ProMenuCreate(PROMENUTYPE_SUB, (char *)"TkMenuUtilSelect", &menu_id);
    err = ProMenuProcess((char *)"TkMenuUtilSelect", &action);
    if(err == PRO_TK_NO_ERROR && action == DONE_SEL)
    {
        err = ProArrayAlloc(0, sizeof(int), 1, (ProArray*)output_array);
	n_sel = 0;
	for (i=0; i<n_but; i++)
	    if (toggle_array[i])
	    {
		ProArrayObjectAdd((ProArray*)output_array, PRO_VALUE_UNUSED,
		    1, &i);
		n_sel++;
	    }
	if (n_sel>0)
	{
	    *p_n_sel = n_sel;
	    ret_status = PRO_TK_NO_ERROR;
	}
	else
	    err = ProArrayFree((ProArray*)output_array);
    }
    err = ProArrayFree((ProArray*)&toggle_array);
    return (ret_status);
}
コード例 #8
0
ファイル: UtilFeats.cpp プロジェクト: dyao-vu/meta-core
/*====================================================================*\
    FUNCTION :	ProUtilElemPrint()
    PURPOSE  :	Visit function.
\*====================================================================*/
ProError ProUtilElemPrint( 
    ProElement elem_tree, 
    ProElement  elem,
    ProElempath elem_path, 
    FeatureElemPrintData* p_data )
{
    ProError		status;
    ProElemId		elem_id;
    int			dimension_id = -1;
    ProBoolean		is_visible;
    ProBoolean		is_incomplete;
    ProBoolean		is_compound;
    ProBoolean          is_array;
    ProBoolean          is_multival;
    ProValue*		p_values;
    ProValue            value;
    int			array_size;
    ProValueData	value_data;
    char		value_data_str[ 48 ];
    int			i;
    ProBoolean          flag = PRO_B_TRUE;             

    status = ProElementIdGet( elem, &elem_id );
    TEST_CALL_REPORT("ProElementIdGet()", 
	"ProUtilElemPrint()",
	PRO_TK_NO_ERROR, status != PRO_TK_NO_ERROR);
    ProTKFprintf( p_data->fp, "Element ID: %d\n", elem_id );

    status = ProFeatureElemIsVisible( p_data->p_feature, elem_path, 
	&is_visible );
#if 0
    TEST_CALL_REPORT("ProFeatureElemIsVisible()",
	"ProUtilElemPrint()", status,
	status != PRO_TK_NO_ERROR );
#else
/* This function return PRO_TK_E_NOT_FOUND for Element FEATURE_TYPE,
from feature PRO_FEAT_DATUM_QUILT (it's a bug)*/
    TEST_CALL_REPORT("ProFeatureElemIsVisible()",
	"ProUtilElemPrint()", status,
        0);
#endif

    status = ProFeatureElemIsIncomplete( p_data->p_feature, elem_path, 
	&is_incomplete );
#if 0
    /* spr 751801 */
    TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()", 		status, status != PRO_TK_NO_ERROR);
#else
    TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()",     	status, 0 );
#endif

    status = ProElementIsCompound( elem, NULL, &is_compound );
    TEST_CALL_REPORT("ProElementIsCompound()", "ProUtilElemPrint()",
	status, status != PRO_TK_NO_ERROR);

    status = ProElementIsArray(elem, NULL, &is_array );
    TEST_CALL_REPORT("ProElementIsArray()", "ProUtilElemPrint()",
        status, status != PRO_TK_NO_ERROR);

    ProTKFprintf( p_data->fp, is_visible == PRO_B_TRUE ? "\tVisible\n" : "\tInvisible\n" );
    ProTKFprintf( p_data->fp, is_incomplete == PRO_B_TRUE ? "\tIncomplete\n" : 
	"\tComplete\n" );

    ProTKFprintf( p_data->fp, is_compound == PRO_B_TRUE ? "\tCompound\n" : 
	                            (is_array == PRO_B_TRUE ? "\tArray\n" :
                                           "\tNeither compound nor array\n"));

    if( is_compound == PRO_B_TRUE || is_array == PRO_B_TRUE)
	return PRO_TK_NO_ERROR;

    status = ProFeatureElemDimensionIdGet( p_data->p_feature, elem_path, 
	&dimension_id );
    TEST_CALL_REPORT("ProFeatureElemDimensionIdGet()", 
	"ProUtilElemPrint()",
	status, (status != PRO_TK_NO_ERROR)&&
                (status != PRO_TK_E_NOT_FOUND));

     if (status != PRO_TK_E_NOT_FOUND)
         ProTKFprintf( p_data->fp, "\tDimension ID: %d\n", dimension_id );
     else
         ProTKFprintf( p_data->fp, "\tThis element does not contain dimension\n");

    status = ProArrayAlloc( 0, sizeof(ProValue), 1, (ProArray*)&p_values );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilElemPrint()",
			status, status != PRO_TK_NO_ERROR );

    status = ProElementIsMultival(elem, NULL, &is_multival);
    TEST_CALL_REPORT( "ProElementIsMultival", 
                       "ProUtilElemPrint", status, status != PRO_TK_NO_ERROR);

    if (is_multival == PRO_B_TRUE)
    {
       status = ProFeatureElemValuesGet( p_data->p_feature,
                                          elem_path, &p_values );
#if 0
	TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
	    status,
	    status != PRO_TK_NO_ERROR );
#else
/* ProFeatureElemValuesGet() - returns PRO_TK_E_NOT_FOUND in the PIPE mode
for Element PRO_E_STD_EDGE_CHAMF_EDGES.(bugminsk1347)*/
	TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
	    status,
	    0 );
#endif
    }
    else
    {
       status = ProElementValueGet(elem, &value);
       TEST_CALL_REPORT( "ProElementValueGet", "ProUtilElemPrint",
                                status, status != PRO_TK_NO_ERROR);
  
       status = ProArrayObjectAdd((ProArray*)&p_values, PRO_VALUE_UNUSED,
                                                                1, &value);
       TEST_CALL_REPORT( "ProArrayObjectAdd", "ProUtilElemPrint",
                                status, status != PRO_TK_NO_ERROR);
    }
    if (p_values!=NULL){
        array_size = 0;
        status = ProArraySizeGet( (ProArray)p_values, &array_size );
        TEST_CALL_REPORT( "ProArraySizeGet()", "ProUtilElemPrint()",
			status, status != PRO_TK_NO_ERROR );

        ProTKFprintf( p_data->fp, "\t%s\n",(i=1)?"Value:":"Values:" );
        for( i=0; i<array_size; i++ )
	  {
	   /*To avoid PRO_E_SKETCHER and PRO_E_PATTERN, following condition is set*/
	    if(( elem_id == 458) || (elem_id == 27))
	      flag = PRO_B_FALSE; 
	    
	    if(flag == PRO_B_TRUE)
	      {
		status = ProValueDataGet( p_values[i], &value_data );
        	TEST_CALL_REPORT( "ProValueDataGet()", "ProUtilElemPrint()",
				  status, status != PRO_TK_NO_ERROR );
		switch( value_data.type )
		  {
		  case PRO_VALUE_TYPE_INT:
	            ProTKSprintf( value_data_str, "%d", value_data.v.i );
	            break;
		    
		  case PRO_VALUE_TYPE_DOUBLE:
	            ProTKSprintf( value_data_str, "%f", value_data.v.d );
                    break;
		    
		  case PRO_VALUE_TYPE_POINTER:
	            ProTKSprintf( value_data_str, "Pointer=*", value_data.v.p );
	            break;
		    
		  case PRO_VALUE_TYPE_STRING:
		    
                    if ( value_data.v.s !=NULL)
		      ProTKSprintf( value_data_str, "%s", value_data.v.s );
		    else 
		      ProTKSprintf( value_data_str,"<NULL>" );
		    break;
		    
		  case PRO_VALUE_TYPE_WSTRING:
		    
		    /* NOTE - NULL is possible in some element trees 
		       (for example, for the element PRO_E_STD_FEATURE_NAME
		       where NULL means that feature has the default name) */
		    
                    if ( value_data.v.w !=NULL)
		      ProWstringToString( value_data_str, value_data.v.w );
                    else 
		      ProTKSprintf( value_data_str,"<NULL>" );
	            break;
		    
		  case PRO_VALUE_TYPE_SELECTION:
	            ProTKSprintf( value_data_str, "Selection" );
	            break;
		    
		  case PRO_VALUE_TYPE_TRANSFORM:
                    ProTKSprintf( value_data_str, "Transformation" );
                    break;
		    
		  default:
	            ProTKSprintf( value_data_str, "**UNKNOWN**\n" );
		  }
		
		ProTKFprintf( p_data->fp, "\t%s\n", value_data_str );
	      }
	  }
	
        status = ProArrayFree( (ProArray*)&p_values );
        TEST_CALL_REPORT( "ProArrayFree()", "ProUtilFeatureElementsDump()",
			  status, status != PRO_TK_NO_ERROR );
    }
    
    
    return PRO_TK_NO_ERROR;
}