/*====================================================================*\
FILE    : UtilTree.c
PURPOSE : Element tree related utility functions

HISTORY..
DATE      BUILD   AUTHOR   MODIFICATIONS
12-Nov-96 H-01-16 mgs      $$1 Created
22-Nov-96 H-01-18 mgs      $$2 Removed extra ProInfoWindowDisplay()
04-Dec-96 H-01-19 igor     $$3 added env var for graphical window
02-Dec-96 H-01-19 amin     $$4 Changed order of arg for ProStringToWstring
06-Dec-96 H-01-20 amin     $$5 ProCurrentTextAttributesGet -> ProTextAttributesCurrentGet
17-Dec-96 H-01-21 Igor     $$6 Bug fixed
18-Dec-96 H-01-21 amin     $$7 Removed calls to ProCurrentText
20-Jan-97 H-01-24 Alexey   $$8 Update for further testing effort
29-Jan-97 H-01-25 Igor     $$9 put a check if model exists before creating 
08-Apr-97 H-03-05 Igor     $$10 output ids for selection
15-Sep-97 H-03-22 Pavel    $$11 replace pro/D on Pro/E
05-Oct-97 H-03-25 Pavel	   $$12 Added more includes
01-Nov-97 H-03-27 Pavel	   $$13 Added ProUtilElemtreeReplaceSelection
24-Nov-97 H-03-30 Alexey   $$14 Handle default data type in ProUtilValuePrint
01-Dec-97 H-03-31 Pavel	   $$15 Added ProUtilSelectionChangeAsmcomppath
10-Dec-97 H-03-31 Alexey   $$16 Added PRO_VALUE_TYPE_TRANSFORM data type case
				to ProUtilValuePrint
20-Jan-98 H-03-37 aab      $$17 Added some type casting for c++ compiler
26-Jan-98 H-03-37 aab      $$18 Fixed bug in ProUtilElemtreePPrint
                                initialized fname, than open file
27-Jan-98 H-03-38 Pavel    $$19 Added ProUtilElemtreeCreate, 
				ProUtilElemtreeElementGet
11-Feb-98 H-03-38 ljl      $$20 Added cast for C++ compiler
14-Feb-98 H-03-39 Pavel    $$21 Added ProUtilFeatErrsPrint
24-Feb-98 H-03-40 aab	   $$22 Added ProUtilElementValueSet and fixed 
                                     ProUtilElemtreeElemPrint
01-Jul-98 I-01-13 AKH      $$23 Add support for PT/Products Toolkit
25-Aug-98 I-01-16 AKH      $$24 ProUtilElemValuePrint(): Consider the case when 
				multivalue element has no values at all.
13-Oct-98 I-01-23 aab      $$25 fixed bug in ProUtilElemtreeReplaceSelection
26-Nov-98 I-01-27 Pavel    $$26 Fixed TEST_CALL_REPORT
01-Jun-99 I-03-11 mka      $$27 Delete unused variable
13-Sep-99 J-01-18 shkulkar $$28 Added NULL checks for Hull Features
\*====================================================================*/

#ifndef lint
static char UtilTree_c [] = "@(#)UtilTree.c     1.2 11/26/96";
#endif

/*--------------------------------------------------------------------*\
Pro/Toolkit includes
\*--------------------------------------------------------------------*/
#include "ProToolkit.h"
#include "ProMdl.h"
#include "ProDisplist.h"
#include "ProFeatType.h"
#include "ProElement.h"
#include "ProElemId.h"
#include "ProElempath.h"
#include "ProDtmPln.h"

#include <string.h>
#include <stdio.h>
#include "prodevelop.h"
/*--------------------------------------------------------------------*\
Pro/Develop includes
\*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*\
Application macros
\*--------------------------------------------------------------------*/
#include "UtilTree.h"
#include "TestError.h"
#include "UtilString.h"
#include "UtilCollect.h"
/*--------------------------------------------------------------------*\
Application data types
\*--------------------------------------------------------------------*/
extern ProError ProUtilIdToStr();

/*--------------------------------------------------------------------*\
Application global/external data
\*--------------------------------------------------------------------*/
typedef enum
{
   PRO_ELEMTREE_PRINT_ALL = 1,
   PRO_ELEMTREE_PRINT_BRANCHES = 2
} ProUtilElemtreePrintOpts;


typedef struct
{
   ProUtilElemtreePrintOpts *options;
   FILE                     *f;
   int                       branches[2*PRO_ELEMTREE_MAX_LEVEL];
   UtilTreeprintWindow window;
} UtilElemtreePrintdata;

static UtilGrWindowData win_data;

static ProError ProUtilElemValuePrint ( ProElement, ProBoolean, ProBoolean, UtilElemtreePrintdata, char*);
static ProError ProUtilValuePrint ( ProValue, UtilElemtreePrintdata, char*);
static ProError ProUtilElemtreePPrint
    (ProElement, ProElempath,ProUtilElemtreePrintOpts*,UtilTreeprintWindow*);
static ProError ProUtilElemtreeElemPrint ( ProElement, ProElement, ProElempath, UtilElemtreePrintdata*);
static ProError ProUtilElemPrint ( ProElement, ProBoolean, ProBoolean, ProBoolean, ProBoolean, UtilElemtreePrintdata, char*);
static ProError ProUtilElemIdPrint ( ProElement, ProBoolean, ProBoolean, UtilElemtreePrintdata, char*);
static ProError ProUtilDisp(char*, ProBool);
static ProError ProUtilElemtreeInGrWindow( ProElement, ProElempath, ProUtilElemtreePrintOpts*s, int*);

/*====================================================================*\
FUNCTION : ProUtilElementtreePrint
PURPOSE  : Print an entire element tree
\*====================================================================*/
ProError ProUtilElementtreePrint (
   ProElement elem_tree,
   UtilTreeprintWindow window,
   int *grwin_id )
{
   ProError    status = PRO_TK_NO_ERROR;
   ProElempath path = (ProElempath)NULL;
   char *p_env_win;

    /* get empty path */
    status = ProElempathAlloc ( &path );
    TEST_CALL_REPORT("ProElempathAlloc()", "ProUtilElementtreePrint()",
                                status, (status != PRO_TK_NO_ERROR));

    if ( status == PRO_TK_NO_ERROR )
    {
        switch (window)
        {
            case PRO_TEST_INFO_WINDOW:
                status = ProUtilElemtreePPrint (elem_tree,path,NULL,&window);
                break;

            case PRO_TEST_GRAPHICS_WINDOW:
                p_env_win = getenv("GRAPH_WINDOW");

                if ((p_env_win == NULL) || (ProUtilStrcmp(p_env_win, "yes")))
                  {
                    *grwin_id = -1;
                    break;
                  }
                status = ProUtilElemtreeInGrWindow( elem_tree, path, NULL,
                                                                grwin_id);
                break;
        }
    }

    if ( path != (ProElempath)NULL )
      {
        status = ProElempathFree ( &path );
        TEST_CALL_REPORT("ProElempathFree()", "ProUtilElementtreePrint",
                                      status, status != PRO_TK_NO_ERROR);
      }

    return ( status );
}

/*====================================================================*\
FUNCTION : ProUtilElemtreePPrint
PURPOSE  : Print an element tree
\*====================================================================*/
static ProError ProUtilElemtreePPrint (
   ProElement                  elem_tree,
   ProElempath                 elem_path,
   ProUtilElemtreePrintOpts   *options,
   UtilTreeprintWindow *p_window)
{
    UtilElemtreePrintdata  data;
    ProError               status = PRO_TK_NO_ERROR;
    char                   fname[PRO_NAME_SIZE];
    wchar_t               wfname[PRO_NAME_SIZE];

    data.options = options;
    sprintf (fname, "%s", "elemtree.inf");
    data.f = fopen (fname, "w");
    if ( data.f == (FILE *)NULL )
    {
        status = PRO_TK_GENERAL_ERROR;
    }
    else
    {
        fprintf(data.f, "Element tree\n============\n\n");
        if (*p_window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp("Element tree", PRO_B_FALSE);
            win_data.point[1] = win_data.point[1] - win_data.decrease;
            ProUtilDisp("============", PRO_B_FALSE);
            win_data.point[1] = win_data.point[1] - 2 * win_data.decrease;
        }
    }

    memset(data.branches, 0, sizeof(data.branches));

    data.window = *p_window;

    if ( status == PRO_TK_NO_ERROR )
    {
        status = ProElemtreeElementVisit ( elem_tree, elem_path,
                (ProElemtreeVisitFilter)NULL,
                (ProElemtreeVisitAction)ProUtilElemtreeElemPrint,
                (ProAppData)&data );
        TEST_CALL_REPORT("ProElemtreeElementVisit()","ProUtilElemtreePPrint()",
                                        status, (status != PRO_TK_NO_ERROR));
    }

    if ( (data.f != (FILE *)NULL)&&(*p_window == PRO_TEST_INFO_WINDOW))
    {
        fclose ( data.f );
        ProInfoWindowDisplay(ProStringToWstring(wfname, fname), NULL, NULL);
    }

    return ( status );
}

/*====================================================================*\
FUNCTION : ProUtilElemtreeElemPrint
PURPOSE  : Print the element tree
\*====================================================================*/
static ProError ProUtilElemtreeElemPrint (
   ProElement     elem_tree,
   ProElement     elem,
   ProElempath    elem_path,
   UtilElemtreePrintdata   *p_data)
{
    int          i, level = -1, n_elems = -1;
    ProElemId    id;
    ProError     status = PRO_TK_NO_ERROR;
    char         indent[2*PRO_ELEMTREE_MAX_LEVEL];
    ProBoolean   is_compound = PRO_B_FALSE, is_array = PRO_B_FALSE,
                 is_multi_val = PRO_B_FALSE, are_more_items = PRO_B_FALSE;
    ProElement  *children;

    status = ProElementIdGet (elem, &id );
    TEST_CALL_REPORT("ProElementIdGet()","ProUtilElemtreeElemPrint()",
                                        status, (status != PRO_TK_NO_ERROR));
    status = ProElementIsCompound (elem_tree, elem_path, &is_compound);
    TEST_CALL_REPORT("ProElementIsCompound()","ProUtilElemtreeElemPrint()",
                                        status, (status != PRO_TK_NO_ERROR));

    if (status == PRO_TK_NO_ERROR)
    {
        status = ProElementIsArray (elem_tree, elem_path, &is_array);
        TEST_CALL_REPORT("ProElementIsArray()",
                         "ProUtilElemtreeElemPrint()",
                            status, (status != PRO_TK_NO_ERROR));
    }

    if (status == PRO_TK_NO_ERROR)
    {
        status = ProElempathSizeGet ( elem_path, &level );
        TEST_CALL_REPORT("ProElempathSizeGet()",
                         "ProUtilElemtreeElemPrint()",
                            status, (status != PRO_TK_NO_ERROR));
    }

/*--------------------------------------------------------------------*\
   Check to see if element is multivalued
\*--------------------------------------------------------------------*/
    if (status == PRO_TK_NO_ERROR)
    {
        status = ProElementIsMultival(elem_tree,elem_path, &is_multi_val);
        TEST_CALL_REPORT("ProElementIsMultival()","ProUtilElemtreeElemPrint()",
                                        status, (status != PRO_TK_NO_ERROR));
    }

/*--------------------------------------------------------------------*\
    Set the indents properly
\*--------------------------------------------------------------------*/
    if (status != PRO_TK_NO_ERROR)
        return PRO_TK_BAD_INPUTS;

    if (is_compound || is_array)
    {
        status = ProArrayAlloc(0,sizeof(ProElement),1,(ProArray*) &children);
        TEST_CALL_REPORT("ProArrayAlloc()","ProUtilElemtreeElemPrint()",
                                        status, (status != PRO_TK_NO_ERROR));

        if (status == PRO_TK_NO_ERROR)
        {
            if (is_compound)
            {
                status = ProElementChildrenGet(elem_tree, elem_path, &children);
                TEST_CALL_REPORT("ProElementChildrenGet()",
                             "ProUtilElemtreeElemPrint()",
                              status, (status != PRO_TK_NO_ERROR));
                if (status == PRO_TK_NO_ERROR)
                {
                    status = ProArraySizeGet((ProArray) children, &n_elems);
                    TEST_CALL_REPORT("ProArraySizeGet()",
                                 "ProUtilElemtreeElemPrint()",
                                  status, (status != PRO_TK_NO_ERROR));
                }
            }
            else
            {
                status = ProElementArrayGet(elem_tree, elem_path, &children);
                TEST_CALL_REPORT("ProElementArrayGet()",
                             "ProUtilElemtreeElemPrint()",
                              status, (status != PRO_TK_NO_ERROR));
		status = ProElementArrayCount(elem_tree, elem_path, &n_elems);
		TEST_CALL_REPORT("ProElementArrayCount()",
                                 "ProUtilElemtreeElemPrint()",
                                  status, (status != PRO_TK_NO_ERROR));

            }

            if (level > 0)
                (p_data->branches[level-1])--;

            if (n_elems > 0)
            {
                p_data->branches[level] = n_elems;
            }
        }

        status = ProArrayFree((ProArray*) &children);
        TEST_CALL_REPORT("ProArrayFree()","ProUtilElemtreeElemPrint()",
                                    status, (status != PRO_TK_NO_ERROR));
    }
    else
    {
        if (level == -1 )
            return PRO_TK_BAD_INPUTS;

        if (level > 0)
            (p_data->branches[level-1])--;
    }

    indent[0] = '\0';

    if ( level > 0 )
    {
        for ( i = 0; i < (level-1); i++ )
        {
            if ( p_data->branches[i] > 0 )
            {
                strcat (indent, " |   " );
            }
            else
                strcat (indent, "     " );
        }
            strcat(indent," |---");
    }

    for (i = 0; i < 20; i++)
    {
        if ( p_data->branches[i] > 0 )
        {
            are_more_items = PRO_B_TRUE;
            break;
        }
    }

    if ( status == PRO_TK_NO_ERROR )
    {
        status = ProUtilElemPrint ( elem, is_compound, is_array, is_multi_val,
                        are_more_items, *p_data, indent );
        if (status != PRO_TK_NO_ERROR)
        {
            fprintf(p_data->f, "\n");
            fprintf(stderr, "Element id %d is bad valued \n", id);
        }

    }

   return ( PRO_TK_NO_ERROR );
}

/*====================================================================*\
FUNCTION : ProUtilElemPrint
PURPOSE  : Print a single element
\*====================================================================*/
static ProError ProUtilElemPrint (
   ProElement                elem,
   ProBoolean                is_compound,
   ProBoolean                is_array,
   ProBoolean                is_multi_val,
   ProBoolean                are_more_items,
   UtilElemtreePrintdata     data,
   char                     *indent)
{
    ProError     status = PRO_TK_NO_ERROR;

    status = ProUtilElemIdPrint ( elem,is_compound,is_array,data, indent);

    if ( status == PRO_TK_NO_ERROR && !is_compound && !is_array)
    {
        status = ProUtilElemValuePrint ( elem, is_multi_val,
                                are_more_items, data, indent);
    }
    else
    {
        fprintf ( data.f, "\n");
        if (data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            win_data.point[1] = win_data.point[1] - win_data.decrease;
            win_data.point[0] = 0;
        }
    }

    return ( status );
}

/*====================================================================*\
FUNCTION : ProUtilElemIdPrint
PURPOSE  : Print the element name ( or id if it is not in the str table)
\*====================================================================*/
static ProError ProUtilElemIdPrint (
    ProElement                elem,
    ProBoolean                is_compound,
    ProBoolean                is_array,
    UtilElemtreePrintdata     data,
    char                     *indent)
{
    ProElemId    elem_id;
    ProError     status = PRO_TK_NO_ERROR;
    char elem_name[40], s[100];

   status = ProElementIdGet ( elem, &elem_id );
   TEST_CALL_REPORT("ProElementIdGet()","ProUtilElemtreePPrint()",
                                        status, (status != PRO_TK_NO_ERROR));

    if (status == PRO_TK_NO_ERROR)
    {
        status = ProUtilIdToStr(elem_id, elem_name);
    }

    if (status == PRO_TK_NO_ERROR)
    {
        sprintf ( s, "%s%s  ", indent, elem_name);
        fprintf ( data.f, s);
        if (data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp(s, PRO_B_TRUE);
        }
    }
    else if ( status == PRO_TK_E_NOT_FOUND )
    {
        sprintf(s, "%sElem Id: %3d  ", indent, elem_id );
        fprintf ( data.f, s);
        if (data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp(s, PRO_B_TRUE);
        }

        status = PRO_TK_NO_ERROR;
    }

    if ( status == PRO_TK_NO_ERROR && is_compound )
    {
        sprintf ( s, " (COMPOUND) ");
        fprintf ( data.f, s);
        if (data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp(s, PRO_B_TRUE);
        }
    }

    if ( status == PRO_TK_NO_ERROR && is_array )
    {
        sprintf ( s, " (ARRAY) ");
        fprintf ( data.f, s);
        if (data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp(s, PRO_B_TRUE);
        }
    }

    return ( status );
}

/*====================================================================*\
FUNCTION : ProUtilElemValuePrint
PURPOSE  : Print the value of an element
\*====================================================================*/
static ProError ProUtilElemValuePrint (
    ProElement                elem,
    ProBoolean                is_multi_val,
    ProBoolean                are_more_items,
    UtilElemtreePrintdata     data,
    char                     *indent)
{
    ProValue     value = (ProValue)NULL;
    ProError     status = PRO_TK_NO_ERROR;
    char s[100], *chp = indent;

    if ( is_multi_val == PRO_B_FALSE)
    {
        status = ProElementValueGet ( elem, &value);
        TEST_CALL_REPORT("ProElementValueGet()","ProUtilElemValuePrint()",
                                status, (status != PRO_TK_NO_ERROR));

        if ( status == PRO_TK_NO_ERROR )
        {
            status = ProUtilValuePrint ( value, data, NULL);
        }
        else
        {
            sprintf(s, "%sNON-STANDARD ELEMENT", indent );
            fprintf ( data.f, s);
            fprintf ( data.f, "\n" );
            if (data.window == PRO_TEST_GRAPHICS_WINDOW)
            {
                ProUtilDisp(s, PRO_B_FALSE);
                win_data.point[1] = win_data.point[1] - win_data.decrease;
                win_data.point[0] = 0;
            }
         }
    }
    else
    {
        ProValue    *p_value = (ProValue*)NULL;
        int          i, n_vals, ind_len;

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

        if (status == PRO_TK_NO_ERROR)
        {
            status = ProElementValuesGet(elem, &p_value);
            TEST_CALL_REPORT("ProElementValuesGet()","ProUtilElemValuePrint()",
                                        status, (status != PRO_TK_NO_ERROR));
        }

        if (status == PRO_TK_NO_ERROR)
        {
            status = ProArraySizeGet((ProArray)p_value, &n_vals);
            TEST_CALL_REPORT("ProArraySizeGet()", "ProUtilElemValuePrint()",
                                    status, (status != PRO_TK_NO_ERROR));


            ind_len = strlen(indent);

            if (are_more_items == PRO_B_TRUE)
            {
                *(chp+=ind_len) = '\0';
                for (i = 0; i < 3; i++)
                    *(--chp) = ' ';
            }
            else
            {
                for (i = 0; i < ind_len; i++)
                    *(chp++) = ' ';
                *(chp) = '\0';
            }

            for (i = 0 ; i < n_vals; i++)
            {
                status = ProUtilValuePrint (p_value[i], data,
                                    i == 0 ? (char*)NULL : indent );
            }

	    if( n_vals == 0 )
		fprintf ( data.f, "\n" );
        }

        if (p_value != NULL)
        {
            status = ProArrayFree((ProArray*)&p_value);
            TEST_CALL_REPORT("ProArrayFree()","ProUtilElemValuePrint()",
                                    status, (status != PRO_TK_NO_ERROR));
        }
    }

    return ( status );
}

/*====================================================================*\
FUNCTION : ProUtilValuePrint
PURPOSE  : Print out an elements value
\*====================================================================*/
static ProError ProUtilValuePrint (
    ProValue              value,
    UtilElemtreePrintdata data,
    char                 *indent)
{
    ProValueData value_data;
    ProError     status = PRO_TK_NO_ERROR;
    char temp[100], temp2[100], li[2*PRO_ELEMTREE_MAX_LEVEL];
    ProModelitem mdl_item;
    ProAsmcomppath path;
    double *d;

    int k;

    li[0] = '\0';

    if (indent != (char*) NULL)
    {
        strcat(li, indent);
        strcat(li,"                 ");
    }

    status = ProValueDataGet (value, &value_data);
    TEST_CALL_REPORT("ProValueDataGet()","ProUtilValuePrint()",
                                        status, (status != PRO_TK_NO_ERROR));

    if ( status == PRO_TK_NO_ERROR )
    {
        switch ( value_data.type )
        {
            case PRO_VALUE_TYPE_TRANSFORM:
                if ( value_data.v.t == NULL )
                {
                   sprintf (temp, "%sVALUE (TRANSFORM)", li );
                   break;
                }
                sprintf (temp, "%sVALUE (TRANSFORM)", li );
		d = (double*)value_data.v.t;		
		for (k=0; k<4; k++)
		    printf("%8.5f %8.5f %8.5f %8.5f\n", d[k*4],
			  d[k*4+1], d[k*4+2], d[k*4+3]);
                break;

            case PRO_VALUE_TYPE_INT:
                sprintf (temp, "%sVALUE (INT)       = %d",li,value_data.v.i );
                break;

            case PRO_VALUE_TYPE_DOUBLE:
                sprintf (temp, "%sVALUE (DOUBLE)    = %f",li,value_data.v.d );
                break;

            case PRO_VALUE_TYPE_STRING:
                if ( value_data.v.s == NULL )
                {
                   sprintf (temp, "%sVALUE (STRING)    = ",li);
                   break;
                }
                sprintf (temp, "%sVALUE (STRING)    = %s",li,value_data.v.s );
                break;

            case PRO_VALUE_TYPE_WSTRING:
                if ( value_data.v.w == NULL )
                {
                   sprintf (temp, "%sVALUE (WSTRING)   = ",li);
                   break;
                }
                sprintf (temp, "%sVALUE (WSTRING)   = %s",li,
                                ProWstringToString(temp2, value_data.v.w) );
                break;

            case PRO_VALUE_TYPE_SELECTION:
                if ( value_data.v.r == NULL )
                {
                   sprintf (temp, "%sVALUE (SELECTION) = ", li);
                   break;
                }
                status = ProSelectionModelitemGet(value_data.v.r, &mdl_item);
    		TEST_CALL_REPORT("ProSelectionModelitemGet()",
		    "ProUtilValuePrint()", status, status != PRO_TK_NO_ERROR);
		status = ProSelectionAsmcomppathGet(value_data.v.r, &path);
    		TEST_CALL_REPORT("ProSelectionAsmcomppathGet()",
		    "ProUtilValuePrint()", status, status != PRO_TK_NO_ERROR);
                sprintf (temp, "%sVALUE (SELECTION) Id = %d Type = %d Owner = %x",
		    li, mdl_item.id, mdl_item.type, mdl_item.owner);

		if (path.table_num>0)
		{
		    strcat(temp, " Path = ");		    
		    for(k=0; k<path.table_num; k++)
			sprintf(temp+strlen(temp), " %d", path.comp_id_table[k]);
		    sprintf(temp+strlen(temp), " Owner %x", path.owner);
		    
		}
		printf("%s\n", temp);		
                sprintf (temp, "%sVALUE (SELECTION)   id = %d", li, 
		    mdl_item.id);
		
                break;

            case PRO_VALUE_TYPE_POINTER:
		/* For QCR files */
		if (value_data.v.p != NULL)
		    sprintf(temp,  "%sPOINTER           = **", li);
		else    
		    sprintf (temp, "%sPOINTER           = %x",li, 
			     value_data.v.p );
		printf("%x\n",value_data.v.p);
		
                break;
        }

        fprintf (data.f, temp );
        fprintf (data.f, "\n");
        if(data.window == PRO_TEST_GRAPHICS_WINDOW)
        {
            ProUtilDisp(temp, PRO_B_FALSE);
            win_data.point[1] = win_data.point[1] - win_data.decrease;
            win_data.point[0] = 0;
        }
    }

    return ( status );
}


/*====================================================================*\
FUNCTION : ProUtilDisp
PURPOSE  : Display a feature tree in an information window
\*====================================================================*/
static ProError ProUtilDisp(char *text, ProBool move_carret)
{
   ProError err;
   wchar_t w_str[150];
   ProTextAttribute attribute, new_attribute;
   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);
	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, err != PRO_TK_NO_ERROR);
    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, err != PRO_TK_NO_ERROR);
    }
/*--------------------------------------------------------------------*\
    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);
}