/*============================================================================*\
FILE    : TestDrawingView.c
PURPOSE : Test ProDrawingView functionality 

HISTORY..
DATE      BUILD     AUTHOR    MODIFICATIONS
15-Oct-99 I-03-20   akh       $$1   First version
\*============================================================================*/

/*----------------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*----------------------------------------------------------------------------*/
#include "ProSelection.h"
#include "ProMessage.h"
#include "ProMenu.h"
#include "ProMdl.h"
#include "ProDrawing.h"
#include "ProUtil.h"
#include "ProWindows.h"
#include "ProCsys.h"
#include "ProDwgtable.h"

/*----------------------------------------------------------------------------*\
Application includes
\*----------------------------------------------------------------------------*/
#include "UtilMessage.h"
#include "UtilMenu.h"
#include "UtilFiles.h"

/*----------------------------------------------------------------------------*\
Pro/DEVELOP includes
\*----------------------------------------------------------------------------*/
#include "pd_prototype.h"

/*----------------------------------------------------------------------------*\
Application macros
\*----------------------------------------------------------------------------*/
#define    SET_SCALE	    1
#define    MOVE		    2
#define    DELETE	    3
#define    DISPLAY_STATUS   4

#define    VIEW_PROJECTION   0
#define    VIEW_GENERAL      1

#define    DISPLAY_STYLE    0
#define    QUILT_HRL        1
#define    TAN_DISPLAY      2
#define    CABLE_DISPLAY    3
#define    CONCEPT_MODEL    4
#define    WELD_XSEC        5

#define DRAWING_VIEWS	    ".dvw"

/*===========================================================================*\
  Function : ProTestDrawingView
  Purpose  : 
\*===========================================================================*/
int ProTestDrawingView(ProMdl *mod)
{
    int menu_id;
    ProDrawing drawing;
    ProError err;
    int ProTestDwgInfo();
    int ProTestDwgViewModify();
    int ProTestViewCreate();
    if (mod == NULL)
        err = ProMdlCurrentGet ((ProMdl*)&drawing);
    else
        drawing = (ProDrawing)*mod;
        
    err = ProMenuFileRegister("DrawView","tkdrwview.mnu", &menu_id);
    err = ProMenubuttonActionSet("DrawView","Info", 
		(ProMenubuttonAction)ProTestDwgInfo, drawing, 0);
    err = ProMenubuttonActionSet("DrawView","Set Scale", 
		(ProMenubuttonAction)ProTestDwgViewModify, drawing, SET_SCALE);
    err = ProMenubuttonActionSet("DrawView","Move", 
		(ProMenubuttonAction)ProTestDwgViewModify, drawing, MOVE);
    err = ProMenubuttonActionSet("DrawView","Delete", 
		(ProMenubuttonAction)ProTestDwgViewModify, drawing, DELETE);
    err = ProMenubuttonActionSet("DrawView","SetDisplay", 
		(ProMenubuttonAction)ProTestDwgViewModify, drawing, DISPLAY_STATUS);
    err = ProMenubuttonActionSet("DrawView","Create",  
                (ProMenubuttonAction)ProTestViewCreate, drawing, 0);
    err = ProMenubuttonActionSet("DrawView","DrawView", 
		(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenuCreate(PROMENUTYPE_MAIN, "DrawView",&menu_id);
    err = ProMenuProcess("", &menu_id);

    return (0);
}

/*===========================================================================*\
  Function :   ProTestDwgInfo
  Purpose  :   
\*===========================================================================*/
int ProTestDwgInfo(ProDrawing drawing)
{
    ProCharLine  fname; 
    ProName  wfname;
    FILE *fp_dview;
    ProError err;
    int n_views = 0, i;
    ProView *views = NULL;

    fp_dview = ProUtilGenFilePtr((ProMdl)drawing, DRAWING_VIEWS, fname, "w");
    if (fp_dview == NULL)
        return (-1);
    
    /* Bug in function ProDrawingViewsCollect in the pipe mode */
    fprintf(fp_dview, "File name : %s\n", fname);
    err = ProDrawingViewsCollect(drawing, &views);
    TEST_CALL_REPORT ("ProDrawingViewsCollect()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR 
        && err != PRO_TK_E_NOT_FOUND);
    if (err == PRO_TK_NO_ERROR)
    {
        err = ProArraySizeGet(views, &n_views);
        TEST_CALL_REPORT ("ProArraySizeGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
        
        for(i = 0; i < n_views; i++)
        {
            fprintf(fp_dview, "\nView(%d) ", i);
            ProTestViewInfoPrint (drawing, views[i], fp_dview);
        }
    }
    err = ProArrayFree ((ProArray*)&views);
    fclose(fp_dview);
    ProStringToWstring(wfname, fname);
    err = ProInfoWindowDisplay(wfname, NULL, NULL);
    
    return (0);
}

/*===========================================================================*\
  Function : ProTestViewInfoPrint
  Purpose  : 
\*===========================================================================*/
int ProTestViewInfoPrint (ProDrawing drawing, ProView view,  FILE *fp_dview)
{
    ProSolid solid;
    ProError err;
    ProPoint3d out_line[2];
    ProMdldata data;
    ProBoolean overlay;
    ProName name;
    ProCharLine  model_name, type;
    double scale = 0.0;
    ProDrawingViewDisplay disp_status;
    
    char* ProTesDisplayStyleToStr(ProDisplayStyle );
    char* ProTestTanedgeDisplayToStr(ProTanedgeDisplay );
    char* ProTestCableDisplayToStr(ProCableDisplay );
    
    err = ProDrawingViewSolidGet(drawing, view, &solid);
    TEST_CALL_REPORT ("ProDrawingViewSolidGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
    err = ProMdlDataGet(ProSolidToMdl(solid), &data);
    ProWstringToString(model_name, data.name);
    ProWstringToString(type, data.type);
    fprintf(fp_dview, "Model displayed in a view:\t%s.%s\t\n", 
        model_name, type);
    err = ProDrawingViewNameGet (drawing, view, name);
    TEST_CALL_REPORT ("ProDrawingViewNameGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
    fprintf(fp_dview, "View name: %s\n", 
        ProWstringToString (model_name, name));
    
    err = ProDrawingViewScaleGet(drawing, view, &scale);
    TEST_CALL_REPORT ("ProDrawingViewScaleGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
    
    err = ProDrawingViewDisplayGet (drawing, view, &disp_status);
    TEST_CALL_REPORT ("ProDrawingViewDisplayGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
    fprintf(fp_dview, "Display Style: %s\n", 
        ProTesDisplayStyleToStr (disp_status.style));
    fprintf(fp_dview, "Tanedge Display: %s\n", 
        ProTestTanedgeDisplayToStr (disp_status.tangent_edge_display));
    fprintf(fp_dview, "Cable Display: %s\n",
        ProTestCableDisplayToStr (disp_status.cable_display));
    fprintf(fp_dview, "Quilt Hlr: %s\n", 
        disp_status.quilt_hlr ? "TRUE" : "FALSE" );
    fprintf(fp_dview, "Concept Model: %s\n", 
        disp_status.concept_model ? "TRUE" : "FALSE" );
    fprintf(fp_dview, "Weld Xsec: %s\n", 
        disp_status.weld_xsec ? "TRUE" : "FALSE" );
        
    err = ProDrawingViewOutlineGet (drawing, view, out_line);
    TEST_CALL_REPORT ("ProDrawingViewOutlineGet()",
        "ProTestDwgInfo()", err, err != PRO_TK_NO_ERROR);
    fprintf(fp_dview, "Out line: x_pnt[1] = %6.1f x_pnt[2] = %6.1f "
        "x_pnt[3] = %6.1f\n", out_line[0][0], out_line[0][1], 
        out_line[0][2]);
    fprintf(fp_dview, "Out line: y_pnt[1] = %6.1f y_pnt[2] = %6.1f "
        "y_pnt[3] = %6.1f\n", out_line[1][0], out_line[1][1], 
        out_line[1][2]);
        
    return(0);
} 

/*===========================================================================*\
  Function :  ProTestDwgViewModify 
  Purpose  :   
\*===========================================================================*/
int ProTestDwgViewModify(ProDrawing drawing, int arg)
{
    double scale;
    ProCharLine message, astr;
    ProModelitem sel_item;
    ProBoolean delete_children;
    ProSelection *sel;
    ProView view;
    ProError err;
    ProSolid solid;
    int n_sel, view_id = 0;
    ProPoint3d pnt, to_pnt, sel_pnt;
    ProVector tvec;
    ProMatrix trans;
    ProMouseButton btn;
    ProDrawingViewDisplay disp_status;
        
    /* Pick the view */
    ProUtilMsgPrint("gen", "TEST %0s", "Select a feature to identify a view");
    err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
    if (n_sel <= 0 || err!=PRO_TK_NO_ERROR)
        return (0);

    err = ProSelectionViewGet(sel[0], &view);
    TEST_CALL_REPORT ("ProSelectionViewGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
    err = ProSelectionPoint3dGet (sel[0], pnt);
    TEST_CALL_REPORT ("ProSelectionViewGet()",
        "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
    err = ProSelectionModelitemGet (sel[0], &sel_item);
    TEST_CALL_REPORT ("ProSelectionViewGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
    view_id = prodb_view_ptr_to_id((Prohandle)view);
    pro_transform_to_draw(pnt, (Prohandle)drawing, view_id, sel_pnt);

    /* Bug in function ProDrawingViewTransformGet() */
#if 0
    err = ProDrawingViewTransformGet (drawing, view, PRO_B_TRUE, trans);
    TEST_CALL_REPORT ("ProDrawingViewTransformGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
#endif         
    switch (arg)
    {
    case SET_SCALE :            /* Set the view scale  */
         /* Get the current scale to use as a default */
	 err = ProDrawingViewScaleGet(drawing, view, &scale);
         TEST_CALL_REPORT ("ProDrawingViewScaleGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
         sprintf(message,"scale [%5.2f] ",scale);
	 sprintf(astr, "Enter  %s: ", message);
         ProUtilMsgPrint("gen", "TEST %0s", astr);
         if(ProMessageDoubleRead(NULL, &scale) != PRO_TK_NO_ERROR)
             return (0);
	 err = ProDrawingViewScaleSet(drawing, view, scale);
         TEST_CALL_REPORT ("ProDrawingViewScaleSet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);

         break;
    case MOVE :            /* Translate the view   */
         ProUtilMsgPrint("gen", "TEST %0s", "Select the new position: ");
	 err = ProMousePickGet(PRO_LEFT_BUTTON, &btn, to_pnt);
         TEST_CALL_REPORT ("ProMousePickGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
                     
         tvec[0] = to_pnt[0] - sel_pnt[0];
         tvec[1] = to_pnt[1] - sel_pnt[1];
         tvec[2] = to_pnt[2] - sel_pnt[2];
	 err = ProDrawingViewMove(drawing, view, tvec);
         TEST_CALL_REPORT ("ProDrawingViewMove()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);

         break;
    case DELETE :
         ProUtilMsgPrint("gen", "TEST %0s", "Delete children too [N] ?");
         delete_children = (ProBoolean)ProUtilYesnoGet("No");
         
         err = ProDrawingViewSolidGet (drawing, view, &solid);
         TEST_CALL_REPORT ("ProDrawingViewSolidGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
                              
	 err = ProDrawingViewDelete(drawing, view, delete_children);
         TEST_CALL_REPORT ("ProDrawingViewDelete()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
                     
         break;
    case DISPLAY_STATUS :
         err = ProDrawingViewDisplayGet (drawing, view, &disp_status);
         TEST_CALL_REPORT ("ProDrawingViewDisplayGet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
        
         ProTesViewDispChoise (&disp_status);
         
         err = ProDrawingViewDisplaySet (drawing, view, &disp_status);
         TEST_CALL_REPORT ("ProDrawingViewDisplaySet()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
                                          
         break;
    default:
         break;
    }
    
    err = ProWindowRepaint (PRO_VALUE_UNUSED);
    TEST_CALL_REPORT ("ProWindowRepaint()",
                     "ProTestDwgViewModify()", err, err != PRO_TK_NO_ERROR);
                     
    return (0);
}

/*===========================================================================*\
  Function : ProTesViewDispChoise
  Purpose  : 
\*===========================================================================*/
int ProTesViewDispChoise (ProDrawingViewDisplay *disp_status)
{
    ProError err;
    int menu_id;
    void ProTesViewDispSet (ProDrawingViewDisplay *, int );
    
    err = ProMenuFileRegister("ViewDisplay","tkviewdisp.mnu", &menu_id);
    err = ProMenubuttonActionSet("ViewDisplay","ViewDisplay", 
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("ViewDisplay","DispStyle", 
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, DISPLAY_STYLE);
    err = ProMenubuttonActionSet("ViewDisplay","QuiltHrl", 
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, QUILT_HRL);
    err = ProMenubuttonActionSet("ViewDisplay","TanDisplay", 
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, TAN_DISPLAY);
    err = ProMenubuttonActionSet("ViewDisplay","CableDisplay", 
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, CABLE_DISPLAY);
    err = ProMenubuttonActionSet("ViewDisplay","ConceptModel",  
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, CONCEPT_MODEL);
    err = ProMenubuttonActionSet("ViewDisplay","WeldXsec",  
        (ProMenubuttonAction)ProTesViewDispSet, disp_status, WELD_XSEC);
    err = ProMenubuttonActionSet("ViewDisplay","Done", 
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenuCreate(PROMENUTYPE_MAIN, "ViewDisplay",&menu_id);
    err = ProMenuProcess("ViewDisplay", &menu_id);
    
    return (0);
    
}

/*===========================================================================*\
  Function : ProTesViewDispSet
  Purpose  : 
\*===========================================================================*/
void ProTesViewDispSet (ProDrawingViewDisplay *disp_status, int action)
{
    ProError err;
    
    static ProUtilMenuButtons disp_style[] = { 
        {"DisplayStyle", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Default", PRO_DISPSTYLE_DEFAULT, 0},
        {"Wireframe", PRO_DISPSTYLE_WIREFRAME, 0},
        {"HiddenLine", PRO_DISPSTYLE_HIDDEN_LINE, 0},
        {"NoHidden", PRO_DISPSTYLE_NO_HIDDEN, 0},
        {"Shared", PRO_DISPSTYLE_SHADED, 0},
        {"",0,0}
    };
    static ProUtilMenuButtons cab_disp[] = { 
        {"CableDisplay", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Default", PRO_CABLEDISP_DEFAULT, 0},
        {"Centerline", PRO_CABLEDISP_CENTERLINE, 0},
        {"Thick", PRO_CABLEDISP_THICK, 0},
        {"",0,0}
    };
    static ProUtilMenuButtons tang_disp[] = { 
        {"TanedgeDisplay", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Default", PRO_TANEDGE_DEFAULT, 0},
        {"None", PRO_TANEDGE_NONE, 0},
        {"Centerline", PRO_TANEDGE_CENTERLINE, 0},
        {"Phantom", PRO_TANEDGE_PHANTOM, 0},
        {"Dimmed", PRO_TANEDGE_DIMMED, 0},
        {"Solid", PRO_TANEDGE_SOLID, 0},
        {"",0,0}
    };
        
    switch (action)
    {
    case DISPLAY_STYLE:
        err = ProUtilMenuIntValueSelect(disp_style, 
            (int*)&disp_status->style);
             
        break;
    case QUILT_HRL:
        ProUtilMsgPrint("gen", "TEST %0s", "Quilt hrl (Yes/No)? [N]:"); 
            disp_status->quilt_hlr = (ProBoolean)ProUtilYesnoGet ("No");
        
        break;
    case TAN_DISPLAY:
        err = ProUtilMenuIntValueSelect(tang_disp, 
            (int*)&disp_status->tangent_edge_display);
        
        break;
    case CABLE_DISPLAY:
        err = ProUtilMenuIntValueSelect(cab_disp, 
            (int*)&disp_status->cable_display);
            
        break;
    case CONCEPT_MODEL:
        ProUtilMsgPrint("gen", "TEST %0s", "Concept Model (Yes/No)? [N]:"); 
            disp_status->concept_model = (ProBoolean)ProUtilYesnoGet ("No");
        
        break;
    case WELD_XSEC:
        ProUtilMsgPrint("gen", "TEST %0s", "Weld Xsec (Yes/No)? [N]:"); 
            disp_status->weld_xsec = (ProBoolean)ProUtilYesnoGet ("No");
        
        break;
    default: break;
    }
}

/*===========================================================================*\
  Function : ProTestViewCreate
  Purpose  : 
\*===========================================================================*/
int ProTestViewCreate(ProDrawing drawing)
{
    ProError err;
    ProSolid solid;
    ProModelitem sel_item;
    ProSelection *sel;
    int n_sheet = 0, view_type = 0, n_sel = 0, win_id, old_win_id;
    ProBoolean exploded = PRO_B_FALSE;
    ProPoint3d sel_pnt;
    double     scale = 0.0;
    ProView    view, parent_view;
    ProCharLine sel_path, line;
    ProPath current_dir, ch_dir, def_path;
    ProType type;
    ProName w_name, w_type;
    ProMouseButton btn;
    ProCsys csys;
    ProMatrix orientation;
    ProMatrix  def_matrix = 
    {
        { 0.921061,    0.000000,    0.389418,    0.000000}, 
        {-0.305042,    0.621610,    0.721492,    0.000000}, 
        {-0.242066,   -0.783327,    0.572541,    0.000000}, 
        { 0.000000,    0.000000,    0.000000,    1.000000} 
    };
    static ProUtilMenuButtons create_opt[] = { 
        {"CreateOpt", 0, TEST_CALL_PRO_MENU_DELETE},
        {"General", VIEW_GENERAL, 0},
        {"Projection", VIEW_PROJECTION, 0},
        {"",0,0}
    };
    err = ProUtilMenuIntValueSelect(create_opt, &view_type);
    err = ProDrawingCurrentSheetGet (drawing, &n_sheet);
    TEST_CALL_REPORT ("ProDrawingCurrentSheetGet()",
          "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
          
    if (view_type)
    {
        err = ProUtilFileOpen ("*.*", sel_path);
        if (err != PRO_TK_NO_ERROR)
            return (0);
        err = ProDirectoryCurrentGet(current_dir);
        ProStringToWstring (ch_dir, sel_path);
        err = ProFilenameParse(ch_dir, def_path, w_name, w_type, NULL);
        err = ProDirectoryChange(def_path);
        err = ProPathCreate(NULL, w_name, w_type, PRO_VALUE_UNUSED, def_path);
        ProWstringToString(line, def_path);
        if(ProUtilConfirmNameType(line, sel_path, &type) != PRO_TK_BAD_INPUTS)
        {
            err = ProMdlRetrieve(w_name, (ProMdlType)type, (ProMdl*)&solid);
            TEST_CALL_REPORT ("ProMdlRetrieve()",
                "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
        }
        err = ProDirectoryChange(current_dir);
        err = ProDrawingSolidAdd(drawing, solid);
        TEST_CALL_REPORT ("ProDrawingSolidAdd()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR &&
             err != PRO_TK_E_IN_USE);
        
        if (type ==  PRO_ASSEMBLY)
        {
            ProUtilMsgPrint("gen", "TEST %0s", "Create exploded view? [N]:"); 
            exploded = (ProBoolean)ProUtilYesnoGet ("No");
        }
        ProUtilMsgPrint("gen", "TEST %0s", "Pick point for view");
        while(ProMousePickGet(PRO_LEFT_BUTTON, &btn, sel_pnt) !=
            PRO_TK_NO_ERROR);
        sel_pnt[2] = 0;
        ProUtilMsgPrint("gen", "TEST %0s", "Enter view scale factor");
        if (ProMessageDoubleRead(NULL, &scale) != PRO_TK_NO_ERROR)
            return (0);
        
        err = ProWindowCurrentGet(&old_win_id);
        err = ProAccessorywindowCreate (w_name, type, &win_id);
        err = ProMdlDisplay(solid);
        err = ProWindowCurrentSet(win_id);
        
        ProUtilMsgPrint("gen", "TEST %0s", "Select csys");
        err = ProSelect("csys", 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
        if (err != PRO_TK_NO_ERROR || n_sel < 1)
             ProUtilMatrixCopy (def_matrix, orientation);
        else 
        {
            ProUtilMatrixCopy (NULL, orientation);
            err = ProSelectionModelitemGet (sel[0], &sel_item);
            err = ProCsysInit (solid, sel_item.id, &csys);
            prodb_unpack_csys((Prohandle)csys, orientation[0], orientation[1],
                orientation[2], orientation[3]);
            orientation[3][0] = orientation[3][1] = orientation[3][2] = 0.0;
        }
        ProWindowCurrentSet(old_win_id);
        ProWindowDelete(win_id);
        err = ProDrawingGeneralviewCreate (drawing, solid, n_sheet, exploded, 
            sel_pnt, scale, orientation, &view);
        TEST_CALL_REPORT ("ProDrawingGeneralviewCreate()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
    }
    else
    {
        ProUtilMsgPrint("gen", "TEST %0s", "Select a parent view.");
        err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
        if (err != PRO_TK_NO_ERROR || n_sel < 1)
            return (0);
        err = ProSelectionViewGet(sel[0], &parent_view);
        TEST_CALL_REPORT ("ProSelectionViewGet()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
        err = ProSelectionModelitemGet (sel[0], &sel_item);
        TEST_CALL_REPORT ("ProSelectionModelitemGet()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
        err = ProMdlTypeGet (sel_item.owner, (ProMdlType*)&type);
        TEST_CALL_REPORT ("ProMdlTypeGet()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
        if (type == PRO_ASSEMBLY)
        {
            ProUtilMsgPrint("gen", "TEST %0s", "Create exploded view? [N]:"); 
            exploded = (ProBoolean)ProUtilYesnoGet ("No");
        }
        ProUtilMsgPrint("gen", "TEST %0s", "Pick point for view");
        while (ProMousePickGet(PRO_LEFT_BUTTON, &btn, sel_pnt) != 
            PRO_TK_NO_ERROR);
        err = ProDrawingProjectedviewCreate (drawing, parent_view, exploded, 
            sel_pnt, &view); 
        TEST_CALL_REPORT ("ProDrawingProjectedviewCreate()",
            "ProTestViewCreate()", err, err != PRO_TK_NO_ERROR);
    }
    
    return (0);    
}

/*===========================================================================*\
  Function : ProTesDisplayStyleToStr
  Purpose  : 
\*===========================================================================*/
char* ProTesDisplayStyleToStr(
    ProDisplayStyle type
)
{
    switch (type)
    {
    case PRO_DISPSTYLE_DEFAULT : return "DEFAULT";
    case PRO_DISPSTYLE_WIREFRAME  : return "WIREFRAME";
    case PRO_DISPSTYLE_HIDDEN_LINE  : return "HIDDEN_LINE";
    case PRO_DISPSTYLE_NO_HIDDEN: return "NO_HIDDEN";
    case PRO_DISPSTYLE_SHADED  : return "SHADED";
    default : return "INVALID";
    }
}

/*===========================================================================*\
  Function : ProTestTanedgeDisplayToStr
  Purpose  : 
\*===========================================================================*/
char* ProTestTanedgeDisplayToStr(
    ProTanedgeDisplay type
)
{
    switch (type)
    {
    case PRO_TANEDGE_DEFAULT : return "DEFAULT";
    case PRO_TANEDGE_NONE  : return "NONE";
    case PRO_TANEDGE_CENTERLINE  : return "CENTERLINE";
    case PRO_TANEDGE_PHANTOM: return "PHANTOM";
    case PRO_TANEDGE_DIMMED  : return "DIMMED";
    case PRO_TANEDGE_SOLID  : return "SOLID";
    default : return "INVALID";
    }
}

/*===========================================================================*\
  Function : ProTesDisplayStyleToStr
  Purpose  : 
\*===========================================================================*/
char* ProTestCableDisplayToStr(
    ProCableDisplay type
)
{
    switch (type)
    {
    case PRO_CABLEDISP_DEFAULT : return "DEFAULT";
    case PRO_CABLEDISP_CENTERLINE  : return "CENTERLINE";
    case PRO_CABLEDISP_THICK: return "THICK";
    default : return "INVALID";
    }
}