utiltree.c

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

    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;