/*====================================================================*\
FILE    : TestInterface.c
PURPOSE : 

HISTORY..
11-Jun-97  H-03-14  Alexey $$1  Created
06-Oct-97  H-03-25  Pavel  $$2  Fix warning
18-Dec-97  H-03-35  Akula  $$3  Added ProPlotfileWrite() testing
08-Jan-98  H-03-35  aab    $$4  Fixed bug in ProTestPlotfileWrite
28-Feb-98  H-03-40  Pavel  $$5  More Updates
17-Mar-98  H-03-41  Pavel  $$6  Update with slice files export
11-May-98  I-01-07  CHI    $$7 fix include
29-Oct-98  I-01-25  Alexey $$8  Added export to Raster and VRML formats
06-Oct-98  I-01-25  Alexey $$9  Fix menu names.
02-Jun-99  I-03-12  mka    $$10 Delete unused variable
\*====================================================================*/

/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProIntfData.h>
#include <ProGeomitemdata.h>
#include <ProMessage.h>
#include <ProMenu.h>
#include <ProSelection.h>
#include <ProSolid.h>
#include <ProUtil.h>
#include <ProMode.h>

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

#include "TestError.h"
#include "UtilMenu.h"
#include "UtilMessage.h"
#include "UtilMatrix.h"

/*--------------------------------------------------------------------*\
C System includes
\*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*\
Application macros
\*--------------------------------------------------------------------*/
#define DEFAULT_ANGLE_CONTROL	0.5	
#define DEFAULT_CHORD_HEIGHT	0.05

#define CHORD_HEIGHT 0
#define ANGLE_CONTROL 1

/*--------------------------------------------------------------------*\
Application data types
\*--------------------------------------------------------------------*/
typedef struct slice_types {
    ProImportExportFile type;
    char *button_name;
    char *file_extension;
} SliceTypes;

typedef struct raster_settings {
    ProRasterDepth depth;
    ProRasterType type;
    ProDotsPerInch inch;
    double  size[2];
} RasterSettings;


/*--------------------------------------------------------------------*\
Application global/external data
\*--------------------------------------------------------------------*/


int ProTestImport();
int ProTestExport();
int ProTestExportSlice();
int ProTestExportFileTypeSet();
ProError ProTestSelectExportType( ProImportExportFile *p_type );
ProError ProTestSelectImportType( ProImportExportFile *p_type );
int ProTestPlotfileWrite ( ProAppData p_appdata);
int ProTestExportVRML (ProAppData p_appdata);
int ProTestRasterMenu();

static SliceTypes sl_types[] =
{
    {PRO_SLA_ASCII_FILE, "STL ASCII", "stl"},
    {PRO_SLA_BINARY_FILE, "STL Binary", "stl"},
    {PRO_RENDER_FILE, "Render", "slp"},
    {PRO_INVENTOR_FILE, "Inventor", "iv"},
    {PRO_CATIA_FILE, "Catia Facets", "cat"}
};

/*============================================================================*\
 Function:	ProTestInterface
 Purpose:       
\*============================================================================*/
int ProTestInterface(
    ProAppData		p_appdata)
{
    ProError		status;
    int			menu_id;
    int 		action;
    int                 ProTestImportfeat(), ProTestRedefImpfeat();

    status = ProMenuPush();
    TEST_CALL_REPORT( "ProMenuPush()", "ProTestInterface()",
        status,  status != PRO_TK_NO_ERROR );

    status = ProMenuFileRegister( "TkInterface", "tkinterface.mnu", 
	&menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestInterface()",
    	status,  status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkInterface", "Import",
        (ProMenubuttonAction)ProTestImport, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Export",
        (ProMenubuttonAction)ProTestExport, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Export PS",
        (ProMenubuttonAction)ProTestPlotfileWrite, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Export Slice",
        (ProMenubuttonAction)ProTestExportSlice, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Import feat",
        (ProMenubuttonAction)ProTestImportfeat, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Redef Impfeat",
        (ProMenubuttonAction)ProTestRedefImpfeat, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Export VRML",
        (ProMenubuttonAction)ProTestExportVRML, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "Export Raster",
        (ProMenubuttonAction)ProTestRasterMenu, NULL,  0 );
    ProMenubuttonActionSet( "TkInterface", "TkInterface Done",
        (ProMenubuttonAction)ProMenuDelete, p_appdata,  0 );
    ProMenubuttonActionSet( "TkInterface", "TkInterface",
    	(ProMenubuttonAction)ProMenuDelete, p_appdata,  0 );

    status = ProMenuCreate( PROMENUTYPE_MAIN, "TkInterface", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestInterface()",
        status,  status != PRO_TK_NO_ERROR );

    if( status == PRO_TK_NO_ERROR )
    {
    	status = ProMenuProcess( "TkInterface", &action );
    	TEST_CALL_REPORT( "ProMenuProcess()", "ProTestInterface()",
            status,  status != PRO_TK_NO_ERROR );
    }

    status = ProMenuPop();
    TEST_CALL_REPORT( "ProMenuPop()", "ProTestInterface()",
        status,  status != PRO_TK_NO_ERROR );


    return 0;
}



/*============================================================================*\
 Function:      ProTestImport
 Purpose:       Import current model to the foreign format 
\*============================================================================*/
int ProTestImport(
    ProAppData          p_appdata)
{
    ProError            status;
    ProMdl		p_model;
    ProName             wfilename;
    ProMode		mode;
    ProImportExportFile import_type;


    p_model = *((ProMdl*)p_appdata);    

    /* Get Pro/E mode */
    status = ProModeCurrentGet( &mode );
    TEST_CALL_REPORT( "ProModeCurrentGet()", "ProTestImport()",
    	status,  status != PRO_TK_NO_ERROR );

    ProTestSelectImportType( &import_type );

    switch( import_type )
    {
      case PRO_DWG_SETUP_FILE:
        if( mode != PRO_MODE_DRAWING )
	{
            status = PRO_TK_GENERAL_ERROR;
            ProUtilMsgPrint( "gen", "TEST %0s", "Drawing mode is required" );
        }
	break;

      /*
      case PRO_RELATION_FILE:
      case PRO_PROGRAM_FILE:
      case PRO_IGES_SECTION:
      */
    }

    if( status == PRO_TK_NO_ERROR )
    {
        ProUtilMsgPrint( "gen", "TEST %0s", "Enter import file name [QUIT]:" ); 
    	status = ProMessageStringRead( PRO_NAME_SIZE, wfilename );
    	TEST_CALL_REPORT( "ProMessageStringRead()", "ProTestImport()",
        	status,  status != PRO_TK_NO_ERROR );
    	if( status != PRO_TK_NO_ERROR )	
	    return -1;

    	status = ProInputFileRead( p_model, wfilename, import_type, NULL,
		NULL, NULL, NULL );
    	TEST_CALL_REPORT( "ProInputFileRead()", "ProTestImport()",
        	status,  status != PRO_TK_NO_ERROR );

	status = ProSolidRegenerate( p_model, PRO_B_FALSE );
        TEST_CALL_REPORT( "ProSolidRegenerate()", "ProTestImport()",
                status,  status != PRO_TK_NO_ERROR );
    }
    else
    {
	ProUtilMsgPrint( "gen", "TEST %0s", "Invalid import type" );
    }


    return 0;
}



/*============================================================================*\
 Function:      ProTestSelectImportType
 Purpose:       Select the type of file to import
\*============================================================================*/
ProError ProTestSelectImportType(
    ProImportExportFile	*p_type
)
{
    ProError		status;
    int			menu_id;
    int			action;
 

    if( p_type == NULL )
	return PRO_TK_BAD_INPUTS;

    *p_type = -1;

    status = ProMenuFileRegister( "TkImport", "tkimport.mnu",
        &menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestSelectImportType()",
        status,  status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkImport", "RELATION_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
	p_type, PRO_RELATION_FILE );
    ProMenubuttonActionSet( "TkImport", "IGES_SECTION",
        (ProMenubuttonAction)ProTestExportFileTypeSet,
        p_type, PRO_IGES_SECTION );
    ProMenubuttonActionSet( "TkImport", "PROGRAM_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_PROGRAM_FILE );
    ProMenubuttonActionSet( "TkImport", "CONFIG_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_CONFIG_FILE );
    ProMenubuttonActionSet( "TkImport", "DWG_SETUP_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_DWG_SETUP_FILE );
    ProMenubuttonActionSet( "TkImport", "SPOOL_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet,
        p_type, PRO_SPOOL_FILE );
    ProMenubuttonActionSet( "TkImport" , "TkImport",
        (ProMenubuttonAction)ProMenuDelete, 
	p_type, -1 );

    status = ProMenuCreate( PROMENUTYPE_MAIN, "TkImport", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestSelectImportType()",
        status,  status != PRO_TK_NO_ERROR );

    if( status == PRO_TK_NO_ERROR )
    {
        status = ProMenuProcess( "TkImport", &action );
        TEST_CALL_REPORT( "ProMenuProcess()", "ProTestSelectImportType()",
            status,  status != PRO_TK_NO_ERROR );
    }

    if( *p_type == -1 )
	status = PRO_TK_GENERAL_ERROR;


    return status;
}


    
/*============================================================================*\
 Function:      ProTestExport
 Purpose:       Export current model from the foreign format
\*============================================================================*/
int ProTestExport(
    ProAppData          p_appdata)
{
    ProError            status;
    ProMdl		p_model;
    ProName             wfilename;
    ProMode		mode;
    ProAppData		p_arg2;
    ProAppData		p_arg3;
    ProFeature		feature;
    ProSelection	*p_sel;
    int			n_sel;
    ProImportExportFile export_type;
    double              quality[ 2 ];
    int			cgm_option_1;
    int                 cgm_option_2;


    p_model = *((ProMdl*)p_appdata);    

    /* User's input must be here */
    ProStringToWstring( wfilename, "output" );

    /* Get Pro/E mode */
    status = ProModeCurrentGet( &mode );
    TEST_CALL_REPORT( "ProModeCurrentGet()", "ProTestExport()",
    	status,  status != PRO_TK_NO_ERROR );

    ProTestSelectExportType( &export_type );

    p_arg2 = NULL;
    p_arg3 = NULL;

    switch( export_type )
    {
      case PRO_IGES_FILE:
      case PRO_DXF_FILE:
      case PRO_DWG_SETUP_FILE:
        if( mode != PRO_MODE_DRAWING )
	{
            status = PRO_TK_GENERAL_ERROR;
            ProUtilMsgPrint( "gen", "TEST %0s", "Drawing mode is required" );
        }
	break;

      case PRO_RENDER_FILE:
      case PRO_SLA_ASCII_FILE:
      case PRO_SLA_BINARY_FILE:
      case PRO_INVENTOR_FILE:
	quality[0] = DEFAULT_CHORD_HEIGHT;
	quality[1] = DEFAULT_ANGLE_CONTROL;
	p_arg3 = (ProAppData)quality;
        break;

      case PRO_FEAT_INFO:
      case PRO_FEATURE_INFO:
	ProUtilMsgPrint( "gen", "TEST %0s", "Select the feature" );
	status = ProSelect( "feature", 1, NULL, NULL, NULL, NULL, 
		&p_sel, &n_sel ); 
     	if( (status != PRO_TK_NO_ERROR) || (n_sel < 1) )
            break;

	status = ProSelectionModelitemGet( p_sel[0], &feature );
    	TEST_CALL_REPORT( "ProSelectionModelitemGet()", "ProTestExport()",
        	status,  status != PRO_TK_NO_ERROR );

	p_arg2 = (ProAppData)&(feature.id);
	break;

      case PRO_MFG_OPER_CL:
      case PRO_MFG_FEAT_CL:
        if( mode != PRO_MODE_MANUFACTURE )
	{
            status = PRO_TK_GENERAL_ERROR;
            ProUtilMsgPrint( "gen", "TEST %0s", 
		"Manufacturing mode is required" );
	    break;
	}

        ProUtilMsgPrint( "gen", "TEST %0s", "Select the feature" );
        status = ProSelect( "feature", 1, NULL, NULL, NULL, NULL,
                &p_sel, &n_sel );
        if( (status != PRO_TK_NO_ERROR) || (n_sel < 1) )
            break;

        status = ProSelectionModelitemGet( p_sel[0], &feature );
        TEST_CALL_REPORT( "ProSelectionModelitemGet()", "ProTestExport()",
                status,  status != PRO_TK_NO_ERROR );

        p_arg2 = (ProAppData)&(feature.id);
	break;

      case PRO_CGM_FILE:
	cgm_option_1 = PRO_EXPORT_CGM_CLEAR_TEXT;
	cgm_option_2 = PRO_EXPORT_CGM_ABSTRACT;
        p_arg2 = &cgm_option_1;
	p_arg3 = &cgm_option_2;
	break;
    }

    if( status == PRO_TK_NO_ERROR )
    {
        ProUtilMsgPrint( "gen", "TEST %0s", "Enter export file name [QUIT]:" );
    	status = ProMessageStringRead( PRO_NAME_SIZE, wfilename );
    	TEST_CALL_REPORT( "ProMessageStringRead()", "ProTestImport()",
        	status,  status != PRO_TK_NO_ERROR );
    	if( status != PRO_TK_NO_ERROR )	
	    return -1;

    	status = ProOutputFileWrite( p_model, wfilename, export_type, NULL,
		p_arg2, p_arg3, NULL );
    	TEST_CALL_REPORT( "ProOutputFileWrite()", "ProTestExport()",
        	status,  status != PRO_TK_NO_ERROR );
    }
    else
    {
	ProUtilMsgPrint( "gen", "TEST %0s", "Invalid export type" );
    }

    return 0;
}

/*============================================================================*\
 Function:      ProUtilSliceParamInput
 Purpose:       Input Slice export param
\*============================================================================*/
int ProUtilSliceParamInput(
    double *dptr,
    int	    action)
{
    ProCharLine line;
    double drange[2], d;
    ProError err;

    d = dptr[0];
    if (action == CHORD_HEIGHT)
    {
	sprintf(line, "Enter maximum hord height [%.4f]:", d);
	drange[0] = 0.0001;
	drange[1] = 100.0;
    }    
    else
    {
	sprintf(line, "Enter angle control factor ( 0.0 - 1.0 ) [%.4f]:", d);
	drange[0] = 0.0;
	drange[1] = 1.0;
    }

    ProUtilMsgPrint("gen", "TEST %0s", line);
    err = ProMessageDoubleRead(drange, &d);
    if (err == PRO_TK_NO_ERROR)
    {
	dptr[0] = d;
    }
    return (0);
}

/*============================================================================*\
 Function:      ProUtilSliceSelectCsys
 Purpose:       Select Slice export Csys matr
\*============================================================================*/
int ProUtilSliceSelectCsys(
    ProMatrix matr)
{
    ProSelection *p_sel;
    int n_sel;
    ProError err;
    ProModelitem modelitem;
    ProAsmcomppath path;
    ProMatrix asm_matr, prod_matr;
    ProGeomitemdata *p_data;

    ProUtilMsgPrint("gen", "TEST %0s", "Select coordinate system.");
    err = ProSelect("csys", 1, NULL, NULL, NULL, NULL, &p_sel, &n_sel ); 
    if (err != PRO_TK_NO_ERROR || n_sel != 1)
	return (0);

    err = ProSelectionModelitemGet(p_sel[0], &modelitem);
    TEST_CALL_REPORT( "ProSelectionModelitemGet()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
    err = ProGeomitemdataGet((ProGeomitem*)&modelitem, &p_data);
    TEST_CALL_REPORT( "ProGeomitemdataGet()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
    err = ProMatrixInit(p_data->data.p_csys_data->x_vector,
	p_data->data.p_csys_data->y_vector, p_data->data.p_csys_data->z_vector,
	p_data->data.p_csys_data->origin, matr);
    TEST_CALL_REPORT( "ProMatrixInit()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
    err = ProGeomitemdataFree(&p_data);
    TEST_CALL_REPORT( "ProGeomitemdataFree()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
    err = ProSelectionAsmcomppathGet(p_sel[0], &path);
    TEST_CALL_REPORT( "ProSelectionAsmcomppathGet()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
    if (err == PRO_TK_NO_ERROR)
    {
	/* Csys from an assembly component, produce transformation matrix from
	   csys matrix and component matrix */ 
	err = ProAsmcomppathTrfGet(&path, PRO_B_FALSE, asm_matr);
	TEST_CALL_REPORT( "ProAsmcomppathTrfGet()",
			"ProTestExport()", err,  err != PRO_TK_NO_ERROR );
	ProUtilMatrixProduct(asm_matr, matr, prod_matr);
	ProUtilMatrixCopy(prod_matr, matr);
    }

    err = ProMenuDeleteWithStatus(0);
    
    return(PRO_TK_NO_ERROR);
}

/*============================================================================*\
 Function:      ProUtilSliceParamInput
 Purpose:       Make Slice export Csys matr
\*============================================================================*/
int ProUtilSliceCsysGet(
    ProMatrix matr)
{
    int action;
    ProError err;

    ProUtilMsgPrint("gen", "TEST %0s", "Create or select coordinate system.");
    ProMenuFileRegister( "TkGet Csys", "tkgetcsys.mnu", NULL );
    ProMenubuttonActionSet( "TkGet Csys", "Select", 
	(ProMenubuttonAction)ProUtilSliceSelectCsys, matr, 0);
    ProMenubuttonActionSet( "TkGet Csys", "Default", 
	(ProMenubuttonAction)ProUtilMenubuttonDeleteWithStatus, NULL, 0);
    ProMenubuttonActionSet( "TkGet Csys", "Quit", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    ProMenubuttonActionSet( "TkGet Csys", "TkGet Csys", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);

    ProMenuCreate(PROMENUTYPE_MAIN, "TkGet Csys", NULL);

    err = ProMenuProcess("TkGet Csys", &action);
    if (err == PRO_TK_NO_ERROR)
    {
	ProMenuDeleteWithStatus(0);
	ProMenuDeleteWithStatus(0);
    }
    return (0);
}

/*============================================================================*\
 Function:      ProUtilSliceCompSelect
 Purpose:       Select an assembly component
\*============================================================================*/
int ProUtilSliceCompSelect(
    ProAsmcomppath **p_path)
{
    ProSelection *p_sel;
    int n_sel;
    ProError err;
    ProAsmcomppath path;

    err = ProSelect("prt_or_asm", 1, NULL, NULL, NULL, NULL, &p_sel, &n_sel );
    if (err == PRO_TK_NO_ERROR && n_sel == 1)
    {
	ProUtilMsgPrint("gen", "TEST %0s", "Select an assembly component.");
	err = ProSelectionAsmcomppathGet(p_sel[0], &path);
	TEST_CALL_REPORT("ProSelectionAsmcomppathGet()",
		    "ProUtilSliceCompSelect()", err, err != PRO_TK_NO_ERROR);
	if (err == PRO_TK_NO_ERROR)
	{
	    if (*p_path == NULL)
		*p_path = (ProAsmcomppath*)calloc(1, sizeof(ProAsmcomppath));
	    p_path[0][0] = path;
	}
	ProUtilMenubuttonActivate("TkExportSliceComp", "Include", 0);
    }
    return (0);
}

/*============================================================================*\
 Function:      ProTestExportSlice
 Purpose:       Export current model to the one of slice formats
\*============================================================================*/
int ProTestExportSlice(
    ProAppData          p_appdata)
{
    ProMdl		p_model;
    ProName             w_name;
    ProFileName		w_file_name;
    ProCharName		name;
    ProCharLine		line;
    char		file_name[PRO_FILE_NAME_SIZE];
    ProMatrix		matrix;
    ProAsmcomppath	*p_path = NULL;
    ProError		err;
    ProMdlType		mdl_type;
    int			i, n_menus, action;
    ProImportExportFile	type;
    char *compound[] = {"TkExportSlice", "TkExportSliceComp",  ""};
    static double quality[ 2 ] ={DEFAULT_CHORD_HEIGHT, DEFAULT_ANGLE_CONTROL};

    p_model = *((ProMdl*)p_appdata);    
    err = ProMdlTypeGet(p_model, &mdl_type);

    ProMenuFileRegister( "TkSlice Type", "tkslicetype.mnu", NULL );
    for (i=0; i<sizeof(sl_types)/sizeof(sl_types[0]); i++)
    {
	ProMenubuttonActionSet( "TkSlice Type", sl_types[i].button_name, 
	    (ProMenubuttonAction)ProUtilMenubuttonDeleteWithStatus, NULL,
	    sl_types[i].type);
    }
    ProMenubuttonActionSet( "TkSlice Type", "TkSlice Type", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    ProMenuCreate(PROMENUTYPE_MAIN, "TkSlice Type", NULL);

    err = ProMenuProcess("TkSlice Type", (int*)&type);
    if (err != PRO_TK_NO_ERROR)
	return (-1);

    ProUtilMatrixCopy(NULL, matrix);

    ProMenuFileRegister( "TkExportSlice", "tkexportsl.mnu", NULL);
    ProMenubuttonActionSet( "TkExportSlice", "Chord Height",
        (ProMenubuttonAction)ProUtilSliceParamInput, &quality[0], CHORD_HEIGHT);
    ProMenubuttonActionSet( "TkExportSlice", "Angle Control",
        (ProMenubuttonAction)ProUtilSliceParamInput, &quality[1], ANGLE_CONTROL);
    ProMenubuttonActionSet( "TkExportSlice", "Output",
        (ProMenubuttonAction)ProUtilSliceCsysGet, matrix, 0);
    ProMenubuttonActionSet( "TkExportSlice", "TkExportSlice",
        (ProMenubuttonAction)ProUtilMenuKill, NULL, 2);

    ProMenuFileRegister( "TkExportSliceComp", "tkexportslc.mnu",  NULL);
    ProMenubuttonActionSet( "TkExportSliceComp", "Include",
        (ProMenubuttonAction)ProUtilSliceCompSelect, &p_path, 0);
    ProMenubuttonActionSet( "TkExportSliceComp", "TkExportSliceComp",
        (ProMenubuttonAction)ProUtilMenuKill, NULL, 2);
    
    err = ProCompoundmenuCreate(compound, &n_menus);
    TEST_CALL_REPORT("ProCompoundmenuCreate()",
			"ProTestExportSlice()", err, err != PRO_TK_NO_ERROR);

    ProUtilMenubuttonActivate("TkExportSliceComp", "Include", 
	mdl_type != PRO_MDL_PART);

    err = ProMenuProcess("TkExportSlice", &action);
    if (err != PRO_TK_NO_ERROR)
	return (0);

    err = ProMdlNameGet(p_model, w_name);
    ProWstringToString(name, w_name);

    sprintf(line, "Enter output file name [%s] : ", name);
    ProUtilMsgPrint("gen", "TEST %0s", line);
    err = ProMessageStringRead(PRO_NAME_SIZE, w_file_name);
    if (err != PRO_TK_NO_ERROR)
	ProStringToWstring(w_file_name, name);
    ProWstringToString(file_name, w_file_name);
    strcat(file_name, ".");
    for (i=0; i<sizeof(sl_types)/sizeof(sl_types[0]); i++)
    {
	if (sl_types[i].type == type)
	{
	    strcat(file_name, sl_types[i].file_extension);
	    break;
	}
    }
    ProStringToWstring(w_file_name, file_name);

    err = ProIntfSliceFileExport(p_model, w_file_name, type, quality, matrix, 
	p_path);
    TEST_CALL_REPORT( "ProIntfSliceFileExport()", 
		    "ProTestExportSlice()", err,  err != PRO_TK_NO_ERROR );

    if (err == PRO_TK_NO_ERROR)
    {
	sprintf(line, "File %s has written successfully.", file_name);
	ProUtilMsgPrint( "gen", "TEST %0s", line);
	
    }

    if (p_path != NULL)
	free(p_path);
    return 0;
}


/*============================================================================*\
 Function:      ProTestSelectExportType
 Purpose:       Select file format to export
\*============================================================================*/
ProError ProTestSelectExportType(
    ProImportExportFile	*p_type
)
{
    ProError		status;
    int			menu_id;
    int			action;
 

    if( p_type == NULL )
	return PRO_TK_BAD_INPUTS;

    *p_type = -1;

    status = ProMenuFileRegister( "TkExport", "tkexport.mnu",
        &menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestSelectExportType()",
        status,  status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkExport", "RELATION_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
	p_type, PRO_RELATION_FILE );
    ProMenubuttonActionSet( "TkExport", "MODEL_INFO",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_MODEL_INFO );
    ProMenubuttonActionSet( "TkExport", "PROGRAM_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_PROGRAM_FILE );
    ProMenubuttonActionSet( "TkExport", "IGES_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_IGES_FILE );
    ProMenubuttonActionSet( "TkExport", "DXF_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_DXF_FILE );
    ProMenubuttonActionSet( "TkExport", "RENDER_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_RENDER_FILE );
    ProMenubuttonActionSet( "TkExport", "SLA_ASCII_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_SLA_ASCII_FILE );
    ProMenubuttonActionSet( "TkExport", "SLA_BINARY_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_SLA_BINARY_FILE );
    ProMenubuttonActionSet( "TkExport", "BOM_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_BOM_FILE );
    ProMenubuttonActionSet( "TkExport", "DWG_SETUP_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_DWG_SETUP_FILE );
    ProMenubuttonActionSet( "TkExport", "FEAT_INFO",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_FEAT_INFO );
    ProMenubuttonActionSet( "TkExport", "MFG_OPER_CL",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_MFG_OPER_CL );
    ProMenubuttonActionSet( "TkExport", "MFG_FEAT_CL",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_MFG_FEAT_CL );
    ProMenubuttonActionSet( "TkExport", "MATERIAL_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_MATERIAL_FILE );
    ProMenubuttonActionSet( "TkExport", "IGES_3D_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_IGES_3D_FILE );
    ProMenubuttonActionSet( "TkExport", "STEP_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_STEP_FILE );
    ProMenubuttonActionSet( "TkExport", "VDA_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_VDA_FILE );
    ProMenubuttonActionSet( "TkExport", "SET_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_SET_FILE );
    ProMenubuttonActionSet( "TkExport", "CGM_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet, 
        p_type, PRO_CGM_FILE );
    ProMenubuttonActionSet( "TkExport", "INVENTOR_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet,
        p_type, PRO_INVENTOR_FILE );
    ProMenubuttonActionSet( "TkExport", "FIAT_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet,
        p_type, PRO_FIAT_FILE );
    ProMenubuttonActionSet( "TkExport", "CATIA_FILE",
        (ProMenubuttonAction)ProTestExportFileTypeSet,
        p_type, PRO_CATIA_FILE );
    ProMenubuttonActionSet( "TkExport" , "TkExport",
        (ProMenubuttonAction)ProMenuDelete, 
	p_type, -1 );

    status = ProMenuCreate( PROMENUTYPE_MAIN, "TkExport", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestSelectExportType()",
        status,  status != PRO_TK_NO_ERROR );

    if( status == PRO_TK_NO_ERROR )
    {
        status = ProMenuProcess( "TkExport", &action );
        TEST_CALL_REPORT( "ProMenuProcess()", "ProTestSelectExportType()",
            status,  status != PRO_TK_NO_ERROR );
    }

    if( *p_type == -1 )
	status = PRO_TK_GENERAL_ERROR;


    return status;
}


    
/*============================================================================*\
 Function:      ProTestExportFileTypeSet
 Purpose:       
\*============================================================================*/
int ProTestExportFileTypeSet(
    ProImportExportFile	*p_type,
    ProImportExportFile	type_value
)
{
    ProError		status;


    *p_type = type_value;

    status = ProMenuDelete();
    TEST_CALL_REPORT( "ProMenuDelete()", "ProTestExportFileTypeSet()",
        status,  status != PRO_TK_NO_ERROR );


    return 0;
}

#define PRO_YES_TYPE 1
#define PRO_NO_TYPE 0
/*============================================================================*\
 Function:      ProTestPlotfileWrite
 Purpose:       
\*============================================================================*/
int ProTestPlotfileWrite (
    ProAppData          p_appdata)
{
    static ProPlotOptions poPlotOpt = 
    {
	"postscript",	/* plotter name */
	A4_SIZE_PLOT,	/* paper size, not used really */
	{0,0},		/* not used */
	3,              /* ouput quality */
	1,              /* user scale */
	1,              /* Pen Slew */
	{0,0},		/* Pen Velocity */
	2,		/* Current page */
	{0,0},		/* not used */
	PRO_NO_TYPE,	/* Segmented output */
	PRO_YES_TYPE,	/* Label */
	PRO_NO_TYPE     /* not used */
    };
 
    ProError		status;
    ProName             wfilename;

    ProUtilMsgPrint( "gen", "TEST %0s", "Enter export file name [QUIT]:" );
    status = ProMessageStringRead( PRO_NAME_SIZE, wfilename );
    TEST_CALL_REPORT( "ProMessageStringRead()", "ProTestPlotfileWrite()",
		      status,  status != PRO_TK_NO_ERROR );
    if( status != PRO_TK_NO_ERROR )	
	    return -1;
    status = ProPlotfileWrite(*((ProMdl*)p_appdata), wfilename, &poPlotOpt);
    TEST_CALL_REPORT( "ProPlotfileWrite()", "ProTestPlotfileWrite()",
		      status,  status != PRO_TK_NO_ERROR );
    return (0);
    
}
/*============================================================================*\
 Function: ProTestExportVRML     
 Purpose:  Export to VRML format     
\*============================================================================*/
int ProTestExportVRML(
     ProAppData          p_appdata)
{
    ProError err;
    ProBoolean direct = PRO_B_FALSE;
    ProPath input_file;
    ProPath output_path;
    int     act = 0;
    char file_name[PRO_PATH_SIZE];
    static ProUtilMenuButtons export_act[] = { 
        {"VRML", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Current",0 , 0},
        {"Input file",1 ,0},
        {"",0,0}
    };
    ProError ProUtilFileOpen();
    
    err = ProUtilMenuIntValueSelect(export_act, &act);
    TEST_CALL_REPORT("ProUtilMenuIntValueSelect()","ProTestExportVRML()",
        err, err != PRO_TK_NO_ERROR);

    if(act)
    {
        direct = PRO_B_TRUE;
        err = ProUtilFileOpen("*.*", file_name);
        TEST_CALL_REPORT(" ProUtilFileOpen()","ProTestExport()",
            err, err != PRO_TK_NO_ERROR);
        if (err != PRO_TK_NO_ERROR)
        {
            ProUtilMsgPrint("gen", "TEST %0s", "Unable open file.");
            return -1;
        }   
    
    }
    ProStringToWstring(input_file, file_name);    
    ProUtilMsgPrint("gen", "TEST %0s", "Enter output path :");
    if( !ProUtilStringGet((wchar_t*)&output_path, NULL, PRO_LINE_SIZE))
        return -1;
        
    err = ProExportVRML(direct, *((ProMdl*)p_appdata), input_file, output_path);
    TEST_CALL_REPORT ("ProExportVRML()", "ProTestExport()",
        err, err != PRO_TK_NO_ERROR);

    return(0);
}
/*============================================================================*\
 Function: ProTestRasterMenu     
 Purpose:  Setup compound menu for choice export options     
\*============================================================================*/
int ProTestRasterMenu()
{
    RasterSettings set;
    ProError err;
    int menu_id;
    static char  *menu[]={"Raster","Type","Inch","Size", "ExportRaster",""};
    int ProTestDepthOpt();
    int ProTestTypeOpt();
    int ProTestInchOpt();
    int ProTestSizeOpt();
    int ProTestExportRaster();
    
    /* default settings */
    set.depth = PRORASTERDEPTH_8;
    set.type = PRORASTERTYPE_TIFF;
    set.inch = PRORASTERDPI_100;
    set.size[0] = 4;
    set.size[1] = 5;
    
    err = ProMenuFileRegister("Raster", "tkraster.mnu", &menu_id);
    err = ProMenubuttonActionSet("Raster", "Raster",
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("Raster", "DEPTH_8",
        (ProMenubuttonAction)ProTestDepthOpt, &set, PRORASTERDEPTH_8);
    err = ProMenubuttonActionSet("Raster", "DEPTH_24",
        (ProMenubuttonAction)ProTestDepthOpt, &set, PRORASTERDEPTH_24); 
   
    err = ProMenuFileRegister("Type", "tktype.mnu", &menu_id);
    err = ProMenubuttonActionSet("Type", "Type",
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("Type", "TYPE_BMP",
        (ProMenubuttonAction)ProTestTypeOpt, &set, PRORASTERTYPE_BMP);
    err = ProMenubuttonActionSet("Type", "TYPE_TIFF",
        (ProMenubuttonAction)ProTestTypeOpt, &set, PRORASTERTYPE_TIFF); 
    err = ProMenubuttonActionSet("Type", "TYPE_EPS",
        (ProMenubuttonAction)ProTestTypeOpt, &set, PRORASTERTYPE_EPS); 
    err = ProMenubuttonActionSet("Type", "TYPE_JPEG",
        (ProMenubuttonAction)ProTestTypeOpt, &set, PRORASTERTYPE_JPEG); 

    err = ProMenuFileRegister("Inch", "tkinch.mnu", &menu_id);
    err = ProMenubuttonActionSet("Inch", "Inch",
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("Inch", "DPI_100",
        (ProMenubuttonAction)ProTestInchOpt, &set, PRORASTERDPI_100);
    err = ProMenubuttonActionSet("Inch", "DPI_200",
        (ProMenubuttonAction)ProTestInchOpt, &set, PRORASTERDPI_200); 
    err = ProMenubuttonActionSet("Inch", "DPI_300",
        (ProMenubuttonAction)ProTestInchOpt, &set, PRORASTERDPI_300); 
    err = ProMenubuttonActionSet("Inch", "DPI_400",
        (ProMenubuttonAction)ProTestInchOpt, &set, PRORASTERDPI_400);
        
    err = ProMenuFileRegister("Size", "tksize.mnu", &menu_id);
    err = ProMenubuttonActionSet("Size", "Size",
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("Size", "A",
        (ProMenubuttonAction)ProTestSizeOpt, &set, A_SIZE_PLOT);
    err = ProMenubuttonActionSet("Size", "B",
        (ProMenubuttonAction)ProTestSizeOpt, &set, B_SIZE_PLOT); 
    err = ProMenubuttonActionSet("Size", "C",
        (ProMenubuttonAction)ProTestSizeOpt, &set, C_SIZE_PLOT); 
    err = ProMenubuttonActionSet("Size", "D",
        (ProMenubuttonAction)ProTestSizeOpt, &set, D_SIZE_PLOT);
    err = ProMenubuttonActionSet("Size", "E",
        (ProMenubuttonAction)ProTestSizeOpt, &set, E_SIZE_PLOT);
    err = ProMenubuttonActionSet("Size", "VARIABLE",
        (ProMenubuttonAction)ProTestSizeOpt, &set, VARIABLE_SIZE_PLOT); 
         
    err = ProMenuFileRegister("ExportRaster", "tkexportraster.mnu", &menu_id);
    err = ProMenubuttonActionSet("ExportRaster", "ExportRaster", 
        (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonGenactionSet("ExportRaster", "Export",   
        (ProMenubuttonGenaction)ProTestExportRaster, &set, NULL, NULL,
        NULL, NULL, NULL);
         
    err = ProCompoundmenuCreate(menu, &menu_id);
    
    ProMenubuttonHighlight("Type", "TYPE_BMP");
    ProMenubuttonHighlight("Raster", "DEPTH_8");
    ProMenubuttonHighlight("Inch", "DPI_100");
    ProMenubuttonHighlight("Size", "A");
    
    err = ProMenuProcess(menu[0], &menu_id);
    
    return(0);
}

/*============================================================================*\
 Function: ProTestTypeOpt     
 Purpose:  Get type options     
\*============================================================================*/
int ProTestTypeOpt(RasterSettings *set, int opt)
{
    set->type = opt;
    return(0);    
}

/*============================================================================*\
 Function: ProTestDepthOpt     
 Purpose:  Get depth options     
\*============================================================================*/
int ProTestDepthOpt(RasterSettings *set, int opt)
{
    set->depth = opt;
    return(0);
}

/*============================================================================*\
 Function: ProTestInchOpt     
 Purpose:  Get inch options     
\*============================================================================*/
int ProTestInchOpt(RasterSettings *set, int opt)
{
    set->inch = opt;
    return(0);
}

/*============================================================================*\
 Function: ProTestSizeOpt     
 Purpose:  Get size options     
\*============================================================================*/
int ProTestSizeOpt(RasterSettings *set, int opt)
{
    ProError err;
    
    switch(opt)
    {
    case A_SIZE_PLOT :
        set->size[0] = 1.7;
        set->size[1] = 2.2;
        break;
    case B_SIZE_PLOT :
        set->size[0] = 2.2;
        set->size[1] = 3.4;
        break;
    case C_SIZE_PLOT :
        set->size[0] = 3.4;
        set->size[1] = 4.4;
        break;
     case D_SIZE_PLOT :
        set->size[0] = 4.4;
        set->size[1] = 6.8;
        break;
    case E_SIZE_PLOT :
        set->size[0] = 6.8;
        set->size[1] = 8.8;
        break;
    case F_SIZE_PLOT :
        set->size[0] = 5.6;
        set->size[1] = 8;
        break;
    case VARIABLE_SIZE_PLOT :
        ProUtilMsgPrint("gen", "TEST %0s", "Enter width:");
        err = ProMessageDoubleRead (NULL, &(set->size[0]));
        if(err != PRO_TK_NO_ERROR)
            return -1;
            
        ProUtilMsgPrint("gen", "TEST %0s", "Enter height:");
        err = ProMessageDoubleRead (NULL, &(set->size[1]));
        if(err != PRO_TK_NO_ERROR)
            return -1;
        break;  
    }
    return(0);
}

/*============================================================================*\
 Function: ProTestExportRaster     
 Purpose:  Export to raster formats     
\*============================================================================*/
int ProTestExportRaster(RasterSettings *set)
{
    ProError err;
    int            window_id;
    ProPath        output_file;
    
    ProUtilMsgPrint("gen", "TEST %0s", "Enter output filename:");
    if( !ProUtilStringGet((wchar_t*)&output_file, NULL, PRO_LINE_SIZE)) 
        return -1;   
 
    err = ProWindowCurrentGet(&window_id);
    TEST_CALL_REPORT("ProWindowCurrentGet()","ProTestPrint()",
        err, err != PRO_TK_NO_ERROR);
            
    err = ProRasterFileWrite(window_id, set->depth, set->size[0], set->size[1],
        set->inch, set->type, output_file);
    TEST_CALL_REPORT ("ProRasterFileWrite()", "ProTestExport()",
        err, err != PRO_TK_NO_ERROR);

    return(0);
}