utiltree.c

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

/*====================================================================*\
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
19-Jul-01 J-03-04 JCN      $$29 Removed return value check for ProValueFree(SPR 891469)
\*====================================================================*/

#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;
        }
    }