/*
	Copyright (c) 2019 PTC Inc. and/or Its Subsidiary Companies. All Rights Reserved.
*/


/*--------------------------------------------------------------------*\
Pro/Toolkit includes -- include this first
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProArray.h>
#include <ProAsmcomp.h>
#include <ProFeatType.h>
#include <ProFeature.h>
#include <ProMdl.h>
#include <ProMenu.h>
#include <ProMessage.h>
#include <ProModelitem.h>
#include <ProNote.h>
#include <ProObjects.h>
#include <ProSelection.h>
#include <ProSizeConst.h>
#include <ProUtil.h>
#include <ProTKRunTime.h>
#include <PTApplsUnicodeUtils.h>
#include <UtilFiles.h>
#include <ProAnnotation.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "TestSetup.h"
#include "UtilMessage.h"
#include "UtilString.h"
#include "TestFiletypes.h"
#include "UtilTypes.h"
#include "UtilCollect.h"
#include "UtilMath.h"
#include "UtilMatrix.h"

/*--------------------------------------------------------------------*\
Application macros
\*--------------------------------------------------------------------*/
#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#define ADD_NOTE        0 
#define DELETE_NOTE     1
#define SHOW_NOTE       2
#define TEXT_STYLE	3
#define DISPLAY_NOTE	4
#define EREASE_NOTE	5

#define MODIFY_HEIGHT	10
#define MODIFY_WIDTH	11
#define MODIFY_ANGLE	12
#define MODIFY_THIKNESS	13
#define MODIFY_MIRROR	14
#define MODIFY_UNDERLINE	16
#define MODIFY_FONTANGLE	18

#define MAX_NUM_LINES   120

#define	GET_NAME	1
#define	SET_NAME	2

/*====================================================================*\
FUNCTION : ProTestSetupMnu
PURPOSE  : Top level menu for the Setup Menu testing.
\*====================================================================*/
int ProTestSetupMnu(ProMdl *model)
{
  ProMdlType model_type;
  int ProTestNoteMnu(ProMdl model);
  ProError TestGtolMainMenu();
  ProError status;
  int id;

    status = ProMdlTypeGet(*model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestSetupMnu()", status,
						status != PRO_TK_NO_ERROR);
    
	status = ProMenuFileRegister((char*)"TkSetup", (char*)"tksetup.mnu", &id);
        TEST_CALL_REPORT("ProMenuFileRegister()", "ProTestSetupMnu()", status,
		     status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkSetup", (char*)"TkSetup",
	                        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkSetup", (char*)"Names", 
	                        (ProMenubuttonAction)ProTestSetupNameMnu, *model, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);
           
	status = ProMenubuttonActionSet((char*)"TkSetup", (char*)"-Notes", 
	                        (ProMenubuttonAction)ProTestNoteMnu, *model, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);


	status = ProMenubuttonActionSet((char*)"TkSetup", (char*)"-Gtol", 
	                        (ProMenubuttonAction)TestGtolMainMenu, NULL, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);

           
	status = ProMenubuttonActionSet((char*)"TkSetup", (char*)"-Done/Return",
	                        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);

	status = ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkSetup", &id);
        TEST_CALL_REPORT("ProMenuCreate()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenuProcess((char*)"TkSetup", &id);
        TEST_CALL_REPORT("ProMenuProcess()", "ProTestSetupMnu()",
           status, status != PRO_TK_NO_ERROR);

	return (0);
}

/*====================================================================*\
FUNCTION : ProTestFeatMnu
PURPOSE  : Top level menu for the Note testing.
\*====================================================================*/
int ProTestNoteMnu(ProMdl model)
{
#ifndef PT_PRODUCTS_BUILD
  ProMdlType model_type;
  int ProTestNote(ProMdl model, int action);
  ProError status;
  int id;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestNoteMnu()", status,
						status != PRO_TK_NO_ERROR);

	status = ProMenuFileRegister((char*)"TkNote", (char*)"tknote.mnu", &id);
        TEST_CALL_REPORT("ProMenuFileRegister()", "ProTestNoteMnu()", status,
		     status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkNote", (char*)"TkNote",
	                        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Add Note", 
	                        (ProMenubuttonAction)ProTestNote, model, ADD_NOTE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Delete Note", 
	                        (ProMenubuttonAction)ProTestNote, model, DELETE_NOTE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Show Note", 
	                        (ProMenubuttonAction)ProTestNote, model, SHOW_NOTE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
        status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Display notes", 
	                        (ProMenubuttonAction)ProTestNote, model, DISPLAY_NOTE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
        status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Erease notes", 
	                        (ProMenubuttonAction)ProTestNote, model, EREASE_NOTE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
        status = ProMenubuttonActionSet((char*)"TkNote", (char*)"-Text style", 
	                        (ProMenubuttonAction)ProTestNote, model, TEXT_STYLE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);

	status = ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkNote", &id);
        TEST_CALL_REPORT("ProMenuCreate()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);
	status = ProMenuProcess((char*)"TkNote", &id);
        TEST_CALL_REPORT("ProMenuProcess()", "ProTestNoteMnu()",
           status, status != PRO_TK_NO_ERROR);

#endif /* #ifndef PT_PRODUCTS_BUILD */
	return (0);

}

#ifndef PT_PRODUCTS_BUILD
/*====================================================================*\
    FUNCTION :	ProTestSelectAttr()
    PURPOSE  :  Action function for selecting attach attrs.
\*====================================================================*/
int ProTestSelectAttr(
    ProMdl model,
    int action)
{
    ProMenuDeleteWithStatus (action);
    return (0);
} 

/*====================================================================*\
    FUNCTION :	ProTestNote()
    PURPOSE  :  General action function for the Note testing.
\*====================================================================*/
int ProTestNote(
    ProMdl model,
    int action)
{
  ProError status;
  ProModelitem note_item, *notes;
  wchar_t** p_text;
  int i, j, n_lines=0, p_size=0, n_notes=0, num_note = 0;
  wchar_t w_line[PRO_LINE_SIZE];
  char str[PRO_LINE_SIZE];
  int id, attrib;
  FILE *note_fp;
  char filename[] = "note_test.inf";
  wchar_t wfilename[PRO_LINE_SIZE];
  char opt[] = "edge";
  int max_count = -1, num_attach;
  ProSelection *sel_attach, *sel_note , *note_plane;
  ProNoteAttach note_attach;
  wchar_t  wstr_url [500];
  ProTextStyle text_style;
  ProMouseButton mouse_button;
  ProPoint3d free_point, note_point, outline[2];
  double text_double;
  int text_int;
  ProMatrix matrix, inv_matrix;
  ProMatrix def_matrix = {{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}};
  ProDrawMode draw_mode = PRO_DRAW_NO_MODE;
  ProModelitem note_owner;
  int length;
  wchar_t* tmp_wchar_ptr;
  wchar_t *getUrl = NULL;
  ProVector annotPlaneUnit = {1.00,1.00,1.00};
  ProAnnotationPlane annotPlane;
  

    switch(action)
    {
    case ADD_NOTE :

        status = ProArrayAlloc(1, sizeof(wchar_t*), 1, (ProArray*)&p_text);
        TEST_CALL_REPORT("ProArrayAlloc()", "ProTestNote()",
                          status, status != PRO_TK_NO_ERROR);

            /* Get several lines of text */
        while(n_lines < MAX_NUM_LINES)
        {
            ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Enter note text [QUIT]:");
            if(ProUtilStringGet(w_line, NULL, PRO_LINE_SIZE) == 0)
        	    break;

	    ProWstringLengthGet (w_line, &length);

            if(n_lines == 0)
	    {
	        p_text [0] = (wchar_t*) calloc (length + 1, sizeof (wchar_t));
	    }
	    else
	    {
		tmp_wchar_ptr =  (wchar_t*) calloc (length + 1, sizeof (wchar_t));
                status = ProArrayObjectAdd ((ProArray*)&p_text, -1, 1, &tmp_wchar_ptr);
                TEST_CALL_REPORT("ProArrayObjectAdd()", "ProTestNote()",
                                  status, status != PRO_TK_NO_ERROR);
            }
	    ProWstringCopy (w_line, p_text [n_lines], PRO_VALUE_UNUSED);
            n_lines++;
        }

        if(n_lines == 0)
            return(0);
/*--------------------------------------------------------------------------*\
        Creates a note (test ProSolidNoteCreate) 
\*--------------------------------------------------------------------------*/
        status = ProSolidNoteCreate(model, NULL, p_text, &note_item);
        TEST_CALL_REPORT("ProSolidNoteCreate()", "ProTestNote()",
                          status, status != PRO_TK_NO_ERROR);

	for (i = 0; i < n_lines; i++)
	{
	    free (p_text [i]);
	}

        ProArrayFree((ProArray*)&p_text);
        
/*--------------------------------------------------------------------------*\
        Sets URL (test ProNoteURLSet, ProNoteURLGet)
\*--------------------------------------------------------------------------*/
        ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Enter URL [QUIT]:");
        status = ProMessageStringRead (500, (wchar_t*)wstr_url);
        if (status == PRO_TK_NO_ERROR)
        {
            status = ProNoteURLWstringSet (&note_item, wstr_url);
            TEST_CALL_REPORT("ProNoteURLWstringSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
        }
        
/*--------------------------------------------------------------------------*\
        Menu for attachment attributes
\*--------------------------------------------------------------------------*/
        status = ProMenuFileRegister((char*)"Attach attr",(char*)"tkattr.mnu",&id);
        TEST_CALL_REPORT("ProMenuFileRegister()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"Attach attr",(char*)"-None",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            PRO_NOTE_ATT_NONE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"Attach attr",(char*)"-Normal",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            PRO_NOTE_ATT_NORMAL);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
	status = ProMenubuttonActionSet((char*)"Attach attr",(char*)"-Tangent",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            PRO_NOTE_ATT_TANGENT);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"Attach attr",(char*)"Attach attr",
		     (ProMenubuttonAction)ProMenuDelete,NULL,0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenuCreate(PROMENUTYPE_MAIN,(char*)"Attach attr",&id);
        TEST_CALL_REPORT("ProMenuCreate()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
        status = ProMenuProcess((char*)"",&attrib);
        TEST_CALL_REPORT("ProMenuProcess()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	
/*--------------------------------------------------------------------------*\
        Select leaders for attachment
\*--------------------------------------------------------------------------*/	    
        status = ProSelect (opt, max_count, NULL, NULL, NULL, NULL, 
            &sel_attach, &num_attach);
        if (status != PRO_TK_NO_ERROR || num_attach < 1)
        	return (0);
/*--------------------------------------------------------------------------*\
        Allocate memory for note attachment (test ProNoteAttachAlloc)
\*--------------------------------------------------------------------------*/
        status = ProNoteAttachAlloc (&note_attach);
        TEST_CALL_REPORT("ProNoteAttachAlloc()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
        for (i = 0; i < num_attach; i++)
        {
/*--------------------------------------------------------------------------*\
            Add leader to attachment

\*--------------------------------------------------------------------------*/
       status = ProNoteAttachAddend(note_attach, sel_attach[i],    
                 (ProNoteAttachAttr)attrib);
       TEST_CALL_REPORT("ProNoteAttachAddend()",
            "ProTestNote()", status, status != PRO_TK_NO_ERROR);
        }
/*--------------------------------------------------------------------------*\
		Assign annotation plane
\*--------------------------------------------------------------------------*/
		  ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select annotation plane for note");

		status = ProSelect("datum",1,NULL,NULL,NULL,NULL,&note_plane,&num_attach);
		TEST_CALL_REPORT("ProSelect()",
            "ProTestNote()", status, status != PRO_TK_NO_ERROR);
		
		status = ProAnnotationplaneCreate(note_plane[0],annotPlaneUnit,&annotPlane);
			TEST_CALL_REPORT("ProAnnotationplaneCreate()",
            "ProTestNote()", status, status != PRO_TK_NO_ERROR);
		status = ProNoteAttachPlaneSet(note_attach,&annotPlane);
		TEST_CALL_REPORT("ProNoteAttachPlaneSet()",
            "ProTestNote()", status, status != PRO_TK_NO_ERROR);


/*--------------------------------------------------------------------------*\
        Select location for note and translate screen coordinates in params
\*--------------------------------------------------------------------------*/
        ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select location for note");
        status = ProMousePickGet (PRO_LEFT_BUTTON, &mouse_button, free_point);
        TEST_CALL_REPORT("ProMousePickGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	ProViewMatrixGet (model, NULL, matrix);
	ProUtilMatrixInvert (matrix, inv_matrix);
	ProUtilPointTrans (inv_matrix, free_point, note_point);
	ProSolidDispoutlineGet ((ProSolid)model, def_matrix, outline);
/*--------------------------------------------------------------------------*\
        Sets location for note text (test PtoNoteAttachFreeSet, 
        ProNoteAttachFreeGet)
\*--------------------------------------------------------------------------*/
        note_point[0] = (note_point[0]-outline[0][0])/(outline[1][0]-outline[0][0]);
        note_point[1] = (note_point[1]-outline[0][1])/(outline[1][1]-outline[0][1]);
        note_point[2] = (note_point[2]-outline[0][2])/(outline[1][2]-outline[0][2]);
        status = ProNoteAttachFreeSet (note_attach, 
            note_point[0], note_point[1], note_point[2]);
        TEST_CALL_REPORT("ProNoteAttachFreeSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------------*\
        Sets placement for note (test ProNotePlacementSet, ProNotePlacementGet)
\*--------------------------------------------------------------------------*/		    		    
        status = ProNotePlacementSet (&note_item, note_attach);
        TEST_CALL_REPORT("ProNotePlacementSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
    
/*--------------------------------------------------------------------------*\
        Display note (test ProNoteDisplay)
\*--------------------------------------------------------------------------*/		
	status = ProAnnotationShow (&note_item,NULL , NULL);
	TEST_CALL_REPORT("ProAnnotationShow()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
		    
/*--------------------------------------------------------------------------*\
        Release attachment (test ProNoteAttachRelease)
\*--------------------------------------------------------------------------*/			    	    
        status = ProNoteAttachRelease (&note_attach);
        TEST_CALL_REPORT("ProNoteAttachRelease()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
        
        break;


    case DELETE_NOTE :
        ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select note for delete");

        status = ProSelect ((char*)"note_3d" ,1 , NULL, NULL, NULL, NULL,
            &sel_note, &num_note);
        if (status != PRO_TK_NO_ERROR || num_note != 1)
            return (0);
        
        status = ProSelectionModelitemGet (sel_note[0], &note_item);
        TEST_CALL_REPORT("ProSelectionModelitemGet()",
	  	    "ProTestNote()",
                    status, status != PRO_TK_NO_ERROR);
	if (status != PRO_TK_NO_ERROR)
	    break;
            
        status = ProNoteDelete(&note_item);
        TEST_CALL_REPORT("ProNoteDelete()", "ProTestNote()", status,
                                                    status != PRO_TK_NO_ERROR);

        break;



    case SHOW_NOTE :
        ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select note for show");

        status = ProSelect ((char*)"note_3d" ,1 , NULL, NULL, NULL, NULL,
            &sel_note, &num_note);
        if (status != PRO_TK_NO_ERROR || num_note != 1)
            return (0);
        
        status = ProSelectionModelitemGet (sel_note[0], &note_item);
        

        status = ProNoteTextGet(&note_item, PRODISPMODE_SYMBOLIC, &p_text);
        TEST_CALL_REPORT("ProNoteTextGet()", "ProTestNote()", status,
            status != PRO_TK_NO_ERROR);

        status = ProArraySizeGet((ProArray*)p_text, &p_size);

/* Set obtained notes only to test this function */
	status = ProNoteTextSet(&note_item, p_text );
        TEST_CALL_REPORT( "ProNoteTextSet()", "ProTestNote()", 
	    status, status != PRO_TK_NO_ERROR);
	    
        if ( (note_fp = PTApplsUnicodeFopen(filename,"w")) == NULL)
        {
            ProTKFprintf(stderr,(char*)"Error opening file for writing\n");
            return -1;
        }
        for(j= 0; j< p_size; j++)
       	    ProTKFprintf(note_fp,(char*)"%s\n", ProWstringToString(str, p_text[j]) );

	ProWstringproarrayFree (p_text);
                	
		
        status = ProNoteURLWstringGet (&note_item, &getUrl);
        TEST_CALL_REPORT("ProNoteURLWstringGet()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR); 
	status = ProNoteOwnerGet (&note_item, &note_owner);
	TEST_CALL_REPORT("ProNoteOwnerGet()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR); 
	
	ProTKFprintf (note_fp, (char*)"URL: %s\n", ProWstringToString (str, getUrl));
	/*status = ProModelitemNameGet (&note_owner, wstr_url);
	TEST_CALL_REPORT("ProModelitemNameGet()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR);
	if (status == PRO_TK_E_NOT_FOUND)
	    fprintf (note_fp, "Owner does not have a name");
	else if (status == PRO_TK_NO_ERROR)
	    fprintf (note_fp, "Owner: %s\n", 
	        ProWstringToString (str, wstr_url));*/
	        
	status = ProTextStyleAlloc (&text_style);
	TEST_CALL_REPORT("ProTextStyleAlloc()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR);
	status =  ProAnnotationTextstyleGet (&note_item,NULL,NULL,NULL, &text_style);
	TEST_CALL_REPORT("ProAnnotationTextstyleGet()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR);
	status = ProTextStyleHeightGet (text_style, &text_double);
     	TEST_CALL_REPORT("ProTextStyleHeightGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR && 
            status != PRO_TK_GENERAL_ERROR); 
       	if (status == -1)
	    ProTKFprintf (note_fp, (char*)"Height DEFAULT\n");
        else if (status == PRO_TK_NO_ERROR)
            ProTKFprintf (note_fp, (char*)"Height %f\n", text_double);  
        status = ProTextStyleWidthGet (text_style, &text_double);
     	TEST_CALL_REPORT("ProTextStyleWidthGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR &&
            status != PRO_TK_GENERAL_ERROR); 
       	if (status == -1)
	    ProTKFprintf (note_fp, (char*)"Width DEFAULT\n");
        else if (status == PRO_TK_NO_ERROR)
            ProTKFprintf (note_fp, (char*)"Width %f\n", text_double);  
        status = ProTextStyleAngleGet (text_style, &text_double);
     	TEST_CALL_REPORT("ProTextStyleAngleGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR); 
       	ProTKFprintf (note_fp, (char*)"Angle %f\n", text_double);
       	status = ProTextStyleSlantAngleGet (text_style, &text_double);
     	TEST_CALL_REPORT("ProTextStyleSlantAngleGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR); 
       	ProTKFprintf (note_fp, (char*)"Slant angle %f\n", text_double);
       	status = ProTextStyleThicknessGet (text_style, &text_double);
     	TEST_CALL_REPORT("ProTextStyleThicknessGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR &&
            status != PRO_TK_GENERAL_ERROR); 
       	if (status == -1)
	    ProTKFprintf (note_fp, (char*)"Thickness DEFAULT\n");
        else if (status == PRO_TK_NO_ERROR)
            ProTKFprintf (note_fp, (char*)"Thickness %f\n", text_double);
        status = ProTextStyleMirrorGet (text_style, &text_int);
     	TEST_CALL_REPORT("ProTextStyleMirrorGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR); 
       	ProTKFprintf (note_fp, (char*)"Mirror %s\n", text_int ? "On" : "Off");
       	status = ProTextStyleUnderlineGet (text_style, &text_int);
     	TEST_CALL_REPORT("ProTextStyleUnderlineGet()",
       	    "ProTestNote()",
 	    status, status != PRO_TK_NO_ERROR); 
       	ProTKFprintf (note_fp, (char*)"Underline %s\n", text_int ? "On" : "Off");
	status = ProTextStyleFree (&text_style);
	TEST_CALL_REPORT("ProTextStyleFree()",
  	    "ProTestNote()",
	    status, status != PRO_TK_NO_ERROR);
               
        fclose(note_fp);
        ProInfoWindowDisplay (ProStringToWstring(wfilename, filename),
            NULL, NULL);


        break;
        
    case DISPLAY_NOTE:
        draw_mode = PRO_DRAW_SET_MODE;
        break;
    case EREASE_NOTE:
        status = ProUtilCollectModelNotes(model, &notes);
	if (status != PRO_TK_NO_ERROR)
	    break;
        status = ProArraySizeGet((ProArray*)notes, &n_notes);
        for(i= 0; i< n_notes; i++)
        {
            status = ProNoteDisplay (&(notes[i]), draw_mode);
            TEST_CALL_REPORT("ProNoteDelete()", "ProTestNote()", status,
                                                    status != PRO_TK_NO_ERROR);
        }
        
        ProArrayFree((ProArray*)&notes);
   
        break;
        
    case TEXT_STYLE:
    
/*--------------------------------------------------------------------------*\
        Menu for text style operations
\*--------------------------------------------------------------------------*/
        status = ProMenuFileRegister((char*)"-Text style",(char*)"tktextstyle.mnu",&id);
        TEST_CALL_REPORT("ProMenuFileRegister()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Height",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_HEIGHT);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Width",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_WIDTH);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
	status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Angle",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_ANGLE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
	status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Slant angle",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_FONTANGLE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	
	status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Thikness",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_THIKNESS);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
	status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Mirror",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_MIRROR);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
	status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Underline",
                    (ProMenubuttonAction)ProTestSelectAttr,NULL, 
	            MODIFY_UNDERLINE);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenubuttonActionSet((char*)"-Text style",(char*)"-Text style",
		     (ProMenubuttonAction)ProMenuDelete,NULL,0);
        TEST_CALL_REPORT("ProMenubuttonActionSet()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
		    
        status = ProMenuCreate(PROMENUTYPE_MAIN,(char*)"-Text style",&id);
        TEST_CALL_REPORT("ProMenuCreate()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
        status = ProMenuProcess((char*)"",&attrib);
        TEST_CALL_REPORT("ProMenuProcess()",
		    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);

        ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select note for change text style.");

        status = ProSelect ((char*)"note_3d" ,1 , NULL, NULL, NULL, NULL,
            &sel_note, &num_note);
        if (status != PRO_TK_NO_ERROR || num_note != 1)
            return (0);
        
        status = ProSelectionModelitemGet (sel_note[0], &note_item);
        
      	status = ProTextStyleAlloc (&text_style);
	TEST_CALL_REPORT("ProTextStyleAlloc()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	status = ProAnnotationTextstyleGet (&note_item,NULL,NULL,NULL, &text_style);
	TEST_CALL_REPORT("ProAnnotationTextstyleGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR); 	    
	switch (attrib)
	{
	
        case MODIFY_HEIGHT:
            status = ProTextStyleHeightGet (text_style, &text_double);
            TEST_CALL_REPORT("ProTextStyleHeightGet()",
        	    "ProTestNote()",
	 	    status, status != PRO_TK_NO_ERROR &&
                    status != PRO_TK_GENERAL_ERROR); 
            if (status == -1)
	        ProTKSprintf (str, (char*)"Enter height [DEFAULT]:");
            else if (status == PRO_TK_NO_ERROR)
	        ProTKSprintf (str, (char*)"Enter height [%f]", text_double);
	    else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilDoubleGet(NULL, NULL, &text_double) == 0)
                break;
	    status = ProTextStyleHeightSet (text_style, text_double);
	    TEST_CALL_REPORT("ProTextStyleHeightSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);

	    break;
	    
	case MODIFY_WIDTH:
            status = ProTextStyleWidthGet (text_style, &text_double);
            TEST_CALL_REPORT("ProTextStyleWidthGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR &&
                    status != PRO_TK_GENERAL_ERROR); 
	    if (status == -1)
	        ProTKSprintf (str, (char*)"Enter width [DEFAULT]");
            else if (status == PRO_TK_NO_ERROR)
	        ProTKSprintf (str, (char*)"Enter width [%f]", text_double);
	    else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilDoubleGet(NULL, NULL, &text_double) == 0)
                break;
            status = ProTextStyleWidthSet (text_style, text_double);
            TEST_CALL_REPORT("ProTextStyleWidthSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	    
	case MODIFY_ANGLE:	    
            status = ProTextStyleAngleGet (text_style, &text_double);
            TEST_CALL_REPORT("ProTextStyleAngleGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR); 
            if (status == PRO_TK_NO_ERROR)
                ProTKSprintf (str, (char*)"Enter angle [%f]", text_double);
            else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilDoubleGet(NULL, NULL, &text_double) == 0)
                break;
	    status = ProTextStyleAngleSet (text_style, text_double);
	    TEST_CALL_REPORT("ProTextStyleAngleSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	    
	case MODIFY_FONTANGLE:	    
            status = ProTextStyleSlantAngleGet (text_style, &text_double);
            TEST_CALL_REPORT("ProTextStyleSlantAngleGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR); 
            if (status == PRO_TK_NO_ERROR)
                ProTKSprintf (str, (char*)"Enter slant angle [%f]", text_double);
            else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilDoubleGet(NULL, NULL, &text_double) == 0)
                break;
	    status = ProTextStyleSlantAngleSet (text_style, text_double);
	    TEST_CALL_REPORT("ProTextStyleSlantAngleSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	    
        case MODIFY_THIKNESS:
	    status = ProTextStyleThicknessGet (text_style, &text_double);
            TEST_CALL_REPORT("ProTextStyleThicknessGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR &&
                    status != PRO_TK_GENERAL_ERROR); 
	    if (status == -1)
	        ProTKSprintf (str, (char*)"Enter thickness [DEFAULT]");
	    else if (status == PRO_TK_NO_ERROR)
	        ProTKSprintf (str, (char*)"Enter thickness [%f]", text_double);
	    else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilDoubleGet(NULL, NULL, &text_double) == 0)
                break;
	    status = ProTextStyleThicknessSet (text_style, text_double);
	    TEST_CALL_REPORT("ProTextStyleThicknessSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	    
	case MODIFY_MIRROR:
	    status = ProTextStyleMirrorGet (text_style, &text_int);
	    TEST_CALL_REPORT("ProTextStyleMirrorGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR); 
	    if (status == PRO_TK_NO_ERROR)
	        ProTKSprintf (str, (char*)"Mirror on(1)/off(0) [%s]", text_int ? "on" : "off");
            else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilIntGet(NULL, NULL, &text_int) == 0)
                break;
            status = ProTextStyleMirrorSet (text_style, text_int);
	    TEST_CALL_REPORT("ProTextStyleMirrorSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	    
	case MODIFY_UNDERLINE:
            status = ProTextStyleUnderlineGet (text_style, &text_int);
            TEST_CALL_REPORT("ProTextStyleUnderlineGet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR); 
	    if (status == PRO_TK_NO_ERROR)
	        ProTKSprintf (str, (char*)"Underline on(1)/off(0) [%s]", text_int ? "on" : "off");
	    else 
	        return (0);
	    ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", str);
	    if(ProUtilIntGet(NULL, NULL, &text_int) == 0)
                break;
	    status = ProTextStyleUnderlineSet (text_style, text_int);
	    TEST_CALL_REPORT("ProTextStyleUnderlineSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	    break;
	}
	
/*      calls ProNoteTextStyleSet for test */
	status = ProAnnotationTextstyleSet (&note_item,NULL,NULL,NULL, text_style);
	TEST_CALL_REPORT("ProAnnotationTextstyleSet()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);
	status = ProTextStyleFree (&text_style);
	TEST_CALL_REPORT("ProTextStyleFree()",
	  	    "ProTestNote()",
		    status, status != PRO_TK_NO_ERROR);

        break;

    }

  return(0);
}

#endif /* #ifndef PT_PRODUCTS_BUILD */

/*====================================================================*\
FUNCTION : ProTestSetupNameMnu
PURPOSE  : Top level menu for the Name Setup testing.
\*====================================================================*/
int ProTestSetupNameMnu(ProMdl model)
{
    ProError	status;
    ProMdlType	model_type;
    int	id;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestSetupNameMnu()", status,
		     status != PRO_TK_NO_ERROR);

    status = ProMenuFileRegister((char*)"TkSetupName", (char*)"tksetupnm.mnu", &id);
    TEST_CALL_REPORT("ProMenuFileRegister()", "ProTestSetupNameMnu()", status,
		     status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet((char*)"TkSetupName", (char*)"Feature",
		      (ProMenubuttonAction)ProTestNameMnu, model, PRO_FEATURE);
    TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupNameMnu()",
       status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet((char*)"TkSetupName", (char*)"Others",
		      (ProMenubuttonAction)ProTestNameMnu, model, -1);
    TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupNameMnu()",
       status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet((char*)"TkSetupName", (char*)"List Names",
		      (ProMenubuttonAction)ProTestListAllNames, model, 0);
    TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupNameMnu()",
       status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet((char*)"TkSetupName", (char*)"TkSetupName",
		      (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestSetupNameMnu()",
       status, status != PRO_TK_NO_ERROR);
    status = ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkSetupName", &id);
    TEST_CALL_REPORT("ProMenuCreate()", "ProTestSetupNameMnu()",
           status, status != PRO_TK_NO_ERROR);
    status = ProMenuProcess((char*)"TkSetupName", &id);
    TEST_CALL_REPORT("ProMenuProcess()", "ProTestSetupNameMnu()",
           status, status != PRO_TK_NO_ERROR);

    return(0);

}   /* End of ProTestSetupNameMnu() */

/*====================================================================*\
FUNCTION : ProTestNameMnu
PURPOSE  : Top level menu for the Name testing.
\*====================================================================*/
int ProTestNameMnu(ProMdl model, int item_type)
{
    ProError	status;
    ProMdlType	model_type;
    int id;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestNameMnu()", status,
		     status != PRO_TK_NO_ERROR);

    status = ProMenuFileRegister((char*)"TkName", (char*)"tkname.mnu", &id);
    TEST_CALL_REPORT ("ProMenuFileRegister", "ProTestNameMnu",
        status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonGenactionSet((char*)"TkName", (char*)"Get Name",
	(ProMenubuttonGenaction)ProTestSetupName, model, 
      (ProAppData)item_type, (ProAppData)GET_NAME,  NULL, NULL, NULL);
    TEST_CALL_REPORT("ProMenubuttonGenactionSet()", "ProTestNameMnu()",
           status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonGenactionSet((char*)"TkName", (char*)"Set Name",
	(ProMenubuttonGenaction)ProTestSetupName, model, 
	(ProAppData)item_type, (ProAppData)SET_NAME, NULL, NULL, NULL);
    TEST_CALL_REPORT("ProMenubuttonGenactionSet()", "ProTestNameMnu()",
           status, status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet((char*)"TkName", (char*)"TkName",
		      (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestNameMnu()", status,
		     status != PRO_TK_NO_ERROR);
    status = ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkName", &id);
    TEST_CALL_REPORT("ProMenuCreate()", "ProTestNameMnu()",
           status, status != PRO_TK_NO_ERROR);
    status = ProMenuProcess((char*)"TkName", &id);
    TEST_CALL_REPORT("ProMenuProcess()", "ProTestNameMnu()",
           status, status != PRO_TK_NO_ERROR);

    return(0);

}   /* End of ProTestNameMnu() */

/*====================================================================*\
   FUNCTION :  ProTestSetupName()
   PURPOSE  :  General action function for the Name Setup testing.
\*====================================================================*/
int ProTestSetupName(ProMdl model, int item_type, int action)

{
    ProError	status;
    ProMdlType	model_type;
    char	*msg, *options;
    ProSelection *sel_list;
    int		n_sels, ret, cont = 1;
    ProModelitem sel_item;
    ProName	o_name, n_name, d_name;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestSetupName()", status,
		     status != PRO_TK_NO_ERROR);

    if (item_type == PRO_FEATURE)
    {
	msg = (char*)"Select a feature.";
	options = (char*)"feature";
    }
    else
    {
	msg = (char*)"Select an item.";
	options = (char*)"edge,csys,axis,point,curve,dtmqlt,surface";
    }

    while ( cont )
    {
	ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", msg);
	status = ProSelect(options, 1, NULL, NULL, NULL, NULL,
			   &sel_list, &n_sels);
	TEST_CALL_REPORT("ProSelect()", "ProTestSetupName()", status,
			 status == PRO_TK_COMM_ERROR);
	if (status != PRO_TK_NO_ERROR)
	    return(-1);

	status = ProSelectionModelitemGet(sel_list[0], &sel_item);
	TEST_CALL_REPORT("ProSelectionModelitemGet()", "ProTestSetupName()",
			 status, status != PRO_TK_NO_ERROR);

	status = ProModelitemNameGet(&sel_item, o_name);
	TEST_CALL_REPORT("ProModelitemNameGet()", "ProTestSetupName()", status,
			 status != PRO_TK_NO_ERROR &&
                         status != PRO_TK_E_NOT_FOUND);

	ret = 0;
	switch (action)
	{
	case GET_NAME:
	    if (o_name[0] == NULL_WCHAR)
		ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s",
				"The selected item does not have a name.");
	    else
		ProUtilMsgPrint((char*)"gen", (char*)"TEST The selected item's name is : %0w",
				o_name);
	break;
	case SET_NAME:
	    if (o_name[0] == NULL_WCHAR)
		ProStringToWstring(d_name, (char*)"QUIT");
	    else
		ProUtilWstrcpy(d_name, o_name);

	    ProUtilMsgPrint((char*)"gen", (char*)"TEST Enter the new name [%0w] : ",
				d_name);

            status = ProMessageStringRead(PRO_NAME_SIZE, n_name);
	    if (status != PRO_TK_NO_ERROR)
		ret = -1;
	    else if ( ProUtilWstrCmp(n_name, o_name) != 0 )
	    {
		status = ProModelitemNameSet(&sel_item, n_name);
		TEST_CALL_REPORT("ProModelitemNameSet()", "ProTestSetupName()",
		                  status, status != PRO_TK_NO_ERROR);
	    }
	break;
	}

	status = ProSelectionUnhighlight(sel_list[0]);
	TEST_CALL_REPORT("ProSelectionUnhighlight()", "ProTestSetupName()",
				      status, status != PRO_TK_NO_ERROR);
    }

    return(ret);

}   /* End of ProTestSetupName() */

/*====================================================================*\
   FUNCTION :  ProTestListAllNames()
   PURPOSE  :  General action function for the Name Listing.
\*====================================================================*/
    int
ProTestListAllNames(ProMdl model)

{
    int		status;
    ProMdlType	model_type;
    ProCharName	filename;
    ProName	wfilename;
    FILE	*fp;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestListAllNames()", (ProError)status,
		     status != PRO_TK_NO_ERROR);

    ProTestQcrName(&model, (char*)NAMES, filename);
    fp = PTApplsUnicodeFopen(filename, "w");

    status = ProTestListNames(( ProSolid )model, fp);

    fclose(fp);

    status = ProInfoWindowDisplay( ProStringToWstring(wfilename, filename),
				   NULL, NULL );
    TEST_CALL_REPORT("ProInfoWindowDisplay()", "ProTestListAllNames()",
    				(ProError)status, status != PRO_TK_NO_ERROR);

    return(0);

}   /* End of ProTestListAllNames() */

/*====================================================================*\
    FUNCTION :  ProTestListName()
    PURPOSE  :  Generalized action function for visiting notes.
\*====================================================================*/
    int
ProTestListNames(ProMdl model, FILE *fp)

{
    int		status;
    ProMdlType	model_type;
    ProMdlName	model_name;
    ProFeature *features;
    int features_num, i;

    status = ProMdlTypeGet(model, &model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestListAllNames()", (ProError)status,
		     status != PRO_TK_NO_ERROR);

    status = ProMdlMdlnameGet(model, model_name);
    TEST_CALL_REPORT("ProMdlMdlnameGet()", "ProTestListNames()", (ProError)status,
		     status != PRO_TK_NO_ERROR);

    ProTKFprintf(fp, (char*)"\n********************************************************\n");
    ProTKFprintf(fp, (char*)"MODEL NAME: %S, MODEL TYPE: %d\n\n", model_name, model_type);
    ProTKFprintf(fp, (char*)"  ID TYPE               NAME\n");
    ProTKFprintf(fp, (char*)"==== ================== ================================\n");
    
    status = ProUtilCollectSolidFeatures ((ProSolid)model, &features);
    if (status == PRO_TK_NO_ERROR)
    {
        status = ProArraySizeGet ((ProArray)features, &features_num);
        TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestListNames()", 
            (ProError)status, status != PRO_TK_NO_ERROR );
        for (i = 0; i < features_num; i++)
        {
            status = ProTestListNameAction (features+i,
                PRO_TK_NO_ERROR, (ProAppData)fp);
        }
        status = ProArrayFree ((ProArray*)&features);
        TEST_CALL_REPORT( "ProArrayFree()", "ProTestListNames()", 
            (ProError)status, status != PRO_TK_NO_ERROR );
    }

    return( PRO_TK_NO_ERROR );

}   /* End of ProTestListNames() */

/*====================================================================*\
    FUNCTION :  ProTestListNameAction()
    PURPOSE  :  Generalized action function for visiting notes.
\*====================================================================*/
    ProError
ProTestListNameAction(ProFeature *p_feat, ProError stat, ProAppData app_data)

{
    int		status, feat_type;
    ProCharName	type_str;
    FILE	*fp;
    ProMdl	model;
    ProName	feat_name;
    ProGeomitem *geomitems;
    int geomitems_num, i;

    status = ProFeatureTypeGet(p_feat, &feat_type);
    if (status != PRO_TK_NO_ERROR)
	return((ProError)status);

    fp = ( FILE * )app_data;

    if (feat_type == PRO_FEAT_COMPONENT)
    {
	status = ProAsmcompMdlGet(( ProAsmcomp * )p_feat, &model);
	TEST_CALL_REPORT("ProAsmcompMdlGet()", "ProTestListNameAction()",
			 (ProError)status, status != PRO_TK_NO_ERROR);

	status = ProTestListNames(( ProSolid )model, fp);
	TEST_CALL_REPORT("ProTestListNames()", "ProTestListNameAction()",
			 (ProError)status, status != PRO_TK_NO_ERROR);
	return( PRO_TK_NO_ERROR );
    }

    status = ProModelitemNameGet(p_feat, feat_name);
    TEST_CALL_REPORT("ProModelitemNameGet()", "ProTestListNameAction()", (ProError)status,
		     status != PRO_TK_NO_ERROR);

    if (feat_name[0] != NULL_WCHAR)
    {
	status = ProUtilFeattypeStr(feat_type, type_str);
	TEST_CALL_REPORT("ProUtilFeattypeStr()", "ProTestListNameAction()",
			 (ProError)status, status != PRO_TK_NO_ERROR);
	ProTKFprintf(fp, (char*)"%4d %-18s %-32S\n", p_feat->id, type_str, feat_name);
    }

    status = ProUtilCollectFeatureGeomitems (p_feat, PRO_TYPE_UNUSED, &geomitems);
    if (status == PRO_TK_NO_ERROR)
    {
        status = ProArraySizeGet ((ProArray)geomitems, &geomitems_num);
        TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestListNameAction()", 
            (ProError)status, status != PRO_TK_NO_ERROR );
        for (i = 0; i < geomitems_num; i++)
        {
            status = ProTestListGeomAction (geomitems+i,
	        PRO_TK_NO_ERROR, (ProAppData)fp);
        }
        status = ProArrayFree ((ProArray*)&geomitems);
        TEST_CALL_REPORT( "ProArrayFree()", "ProTestListNameAction()", 
            (ProError)status, status != PRO_TK_NO_ERROR );
    }

    return( PRO_TK_NO_ERROR );

}   /* End of ProTestListNameAction() */

/*====================================================================*\
    FUNCTION :  ProTestListNameAction()
    PURPOSE  :  Generalized action function for visiting notes.
\*====================================================================*/
    ProError
ProTestListGeomAction(ProModelitem *p_item, ProError stat, ProAppData app_data)

{
    int		status;
    ProName	item_name;
    ProCharName	type_str;
    FILE	*fp;

    status = ProModelitemNameGet(p_item, item_name);
    TEST_CALL_REPORT("ProModelitemNameGet()", "ProTestListGeomAction()", (ProError)status,
		     status != PRO_TK_NO_ERROR);

    if (item_name[0] != NULL_WCHAR)
    {
	status = ProUtilObjtypeStr(p_item->type, type_str);
	TEST_CALL_REPORT("ProUtilObjtypeStr()", "ProTestListGeomAction()",
			 (ProError)status, status != PRO_TK_NO_ERROR);
	fp = ( FILE * )app_data;
	ProTKFprintf(fp, (char*)"%4d %-18s %-32S\n", p_item->id, type_str, item_name);
    }

    return( PRO_TK_NO_ERROR );

}   /* End of ProTestListGeomAction() */