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


/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProAnalysis.h>
#include <ProModelitem.h>
#include <ProMessage.h>
#include <ProArray.h>
#include <ProPoint.h>
#include <ProDtmPnt.h>
#include <ProUtil.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "TestAnalysis.h"
#include "TestDimension.h"

#include "UtilMath.h"

/*====================================================================*\
FUNCTION : ProTestCurveUiAction()
PURPOSE  : Callback for UI action of analysis feature
\*====================================================================*/
ProError ProTestCurveUiAction (
    ProAnalysis analysis)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;
    ProSelection *sel;
    int n_sel;
    ProFeature feature;
    ProCurve curve;
    ProVector origin, x, y;

    TEST_CALL_REPORT ("ProAnalysisUiAction()", 
        "ProTestCurveUiAction()", err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Ask the user to select a curve. 
\*--------------------------------------------------------------------*/
    ProMessageDisplay (msgfil, (char *)"USER Select a curve");

    while (1)
    {
        if (ProSelect ((char *)"feature", 1, NULL, NULL, NULL, NULL, &sel, &n_sel) 
            != PRO_TK_NO_ERROR || n_sel < 0)
            return (PRO_TK_USER_ABORT);

        err = ProSelectionModelitemGet(sel[0], &feature);
        TEST_CALL_REPORT ("ProSelectionModelitemGet()", 
            "ProTestCurveUiAction()", err, err != PRO_TK_NO_ERROR);

        if (!ProTestCurvePlaneGet(&feature, origin, x, y))
            ProMessageDisplay (msgfil,
                (char *)"USER That is not a sketched curve. Select again");
        else
            break;
    }
/*--------------------------------------------------------------------*\
    Get the pointer to the data stored for this analysis feature,
    and set the datum point in it.
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveUiAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_USER_ABORT);

    memcpy (&data->curve, &feature, sizeof (ProFeature));

    ProMessageDisplay (msgfil, (char *)"USER Enter the Z offset distance|||0.0"); 
    err = ProMessageDoubleRead(NULL, &data->offset);

    if (err == PRO_TK_MSG_USER_QUIT)
        return(PRO_TK_USER_ABORT);
    if (err != PRO_TK_NO_ERROR)
        data->offset = 0.0;

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveDimsAction()
PURPOSE  : Create dimentions
\*====================================================================*/
ProError ProTestCurveDimsAction(
    ProAnalysis analysis,
    double **dims)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;

    TEST_CALL_REPORT ("ProAnalysisDimsAction()", 
        "ProTestCurveDimsAction()", err, err != PRO_TK_NO_ERROR);

    err = ProAnalysisInfoGet(analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveDimsAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

    err = ProArrayObjectAdd ((ProArray*)dims, PRO_VALUE_UNUSED, 1, 
        &data->offset);
    TEST_CALL_REPORT ("ProArrayObjectAdd()", 
        "ProTestCurveDimsAction()", err, err != PRO_TK_NO_ERROR);
    
    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveInfoallocAction()
PURPOSE  : Callback to allocate application data needed to describe
		the analysis feature
\*====================================================================*/
ProError ProTestCurveInfoallocAction(
    ProAnalysis analysis)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;

    TEST_CALL_REPORT ("ProAnalysisInfoallocAction()", 
        "ProTestCurveInfoallocAction()", err, err != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
    Allocate a data structure
\*--------------------------------------------------------------------*/
    data = (Curvedata_t*)calloc(1, sizeof(Curvedata_t));
    if (data == NULL)
        return PRO_TK_USER_ABORT;

/*--------------------------------------------------------------------*\
    Put the data pointer into the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoSet(analysis, data);
    TEST_CALL_REPORT ("ProAnalysisInfoSet()", 
        "ProTestCurveInfoallocAction()", err, err != PRO_TK_NO_ERROR);

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveInfofreeAction()
PURPOSE  : Callback to free the application data
\*====================================================================*/
ProError ProTestCurveInfofreeAction(
    ProAnalysis analysis)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;

    TEST_CALL_REPORT ("ProAnalysisInfofreeAction()", 
        "ProTestCurveInfofreeAction()", err, err != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
    Get the data pointer from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveInfofreeAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
        return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Free the data
\*--------------------------------------------------------------------*/
    free (data);

/*--------------------------------------------------------------------*\
    Set the data pointer in the analysis to NULL
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoSet (analysis, NULL);
    TEST_CALL_REPORT ("ProAnalysisInfoSet()", 
        "ProTestCurveInfofreeAction()", err, err != PRO_TK_NO_ERROR);

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveCompcheckAction()
PURPOSE  : Callback to tell Pro/E whether computation can be performed
		in this analysis feature
\*====================================================================*/
ProError ProTestCurveCompcheckAction(
    ProAnalysis analysis)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;
    ProCurve curve;
    ProEnttype type;

    TEST_CALL_REPORT ("ProAnalysisComputecheckAction()", 
        "ProTestCurveCompcheckAction()", err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Get the analysis data
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveCompcheckAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
        return(PRO_TK_GENERAL_ERROR);

    err = ProFeatureTypeGet (&data->curve, (int*)&type);
    TEST_CALL_REPORT ("ProFeatureTypeGet()",
        "ProTestCurveCompcheckAction()", err, err != PRO_TK_NO_ERROR);
    if (type != PRO_FEAT_CURVE)
        return (PRO_TK_USER_ABORT);

    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveComputeAction()
PURPOSE  : Callback to perform the analysis feature computation
\*====================================================================*/
ProError ProTestCurveComputeAction(
    ProAnalysis analysis)
{
    ProError err = PRO_TK_NO_ERROR;
    ProGeomitem *curves;
    ProGeomitemdata *gdata;
    double *par_arr, double1, double2, double3;
    ProPoint3d *pnt_arr, point1, point2;
    ProVector *tan_arr, vector1, vector2;
    ProBoolean is_inactive;
    int c, p, n_curves, n_pnt;
    Curvedata_t *data;
    ProCurvedata p_curve_data;

    TEST_CALL_REPORT ("ProAnalysisComputeAction()", 
        "ProTestCurveComputeAction()", err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Get the application data from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveComputeAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Get the location of the datum point
\*--------------------------------------------------------------------*/
    err = ProUtilCollectFeatureGeomitems (&data->curve, PRO_CURVE, &curves);
    if (err != PRO_TK_NO_ERROR)
        return PRO_TK_USER_ABORT;

    ProArraySizeGet (curves, &n_curves);
    err = ProArrayAlloc (0, sizeof(ProCurvedata), 1, 
        (ProArray*)&data->p_curve_data);
    for (c = 0; c < n_curves; c++)
    {
        err = ProGeomitemIsInactive (&curves[c], &is_inactive);
        TEST_CALL_REPORT ("ProGeomitemIsInactive()",
            "ProTestCurvewrapComputeAction()", err, err != PRO_TK_NO_ERROR);
        if (is_inactive == PRO_B_TRUE)
            continue;

        err = ProGeomitemdataGet(&curves[c], &gdata);
        TEST_CALL_REPORT ("ProGeomitemdataGet()", 
            "ProTestCurvewrapComputeAction()", err, err != PRO_TK_NO_ERROR);

        switch(gdata->data.p_curve_data->line.type)
        {
	case PRO_ENT_LINE :
            err = ProLinedataGet (gdata->data.p_curve_data, point1, point2);
            point1[2] += data->offset;
            point2[2] += data->offset;
            err = ProLinedataInit (point1, point2, &p_curve_data);
            break;
        case PRO_ENT_ARC :
            err = ProArcdataGet (gdata->data.p_curve_data, vector1, vector2, 
                point1, &double1, &double2, &double3);
            point1[2] += data->offset;
            err = ProArcdataInit (vector1, vector2, point1, double1, 
                double2, double3, &p_curve_data);
            break;
        case PRO_ENT_SPLINE :
            err = ProSplinedataGet (gdata->data.p_curve_data, &par_arr,
                &pnt_arr, &tan_arr, &n_pnt);
            for (p = 0; p < n_pnt; p++)
                pnt_arr[p][2] += data->offset;
            err = ProSplinedataInit (par_arr, pnt_arr, tan_arr, n_pnt,
                &p_curve_data);
            break;
        default : continue;
        }
        err = ProArrayObjectAdd ((ProArray*)&data->p_curve_data,
            PRO_VALUE_UNUSED, 1, &p_curve_data);

        err = ProGeomitemdataFree(&gdata);
        TEST_CALL_REPORT ("ProGeomitemdataFree()",
            "ProTestCurvewrapComputeAction()",
            err, err != PRO_TK_NO_ERROR);
    }   

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveDisplayAction()
PURPOSE  : Callback to display the results of the analysis computation
\*====================================================================*/
ProError ProTestCurveDisplayAction(
    ProAnalysis analysis)
{
    Curvedata_t *data;
    ProVector pos;
    ProError err = PRO_TK_NO_ERROR;
    ProEnttype type;
    int i, num, n_pnt;
    double *par_arr, double1, double2, double3;
    ProPoint3d *pnt_arr, point1, point2;
    ProVector *tan_arr, vector1, vector2;

    TEST_CALL_REPORT ("ProAnalysisDisplayAction()", 
        "ProTestCurveDisplayAction()", err, err != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
    Get the application data from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveDisplayAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

    err = ProArraySizeGet (data->p_curve_data, &num);
    TEST_CALL_REPORT ("ProArraySizeGet()", 
        "ProTestCurveDisplayAction()", err, err != PRO_TK_NO_ERROR);
    for (i = 0; i < num; i++)
    {
        err = ProCurvedataTypeGet (&data->p_curve_data[i], &type);
        TEST_CALL_REPORT ("ProCurvedataTypeGet()", 
            "ProTestCurveDisplayAction()", err, err != PRO_TK_NO_ERROR);
        switch (type)
        {
            case PRO_ENT_LINE :
            err = ProLinedataGet (&data->p_curve_data[i], point1, point2);
            ProGraphicsPenPosition(point1);
            ProGraphicsLineDraw(point2);
            break;
            case PRO_ENT_ARC :
            err = ProArcdataGet (&data->p_curve_data[i], vector1, vector2, 
                point1, &double1, &double2, &double3);
            ProGraphicsArcDraw (point1, double3, vector1, vector2);
            break;
            case PRO_ENT_SPLINE :
            err = ProSplinedataGet (&data->p_curve_data[i], &par_arr,
                &pnt_arr, &tan_arr, &n_pnt);
            ProGraphicsPolylineDraw (pnt_arr, n_pnt);
            break;
            default : continue; 
	}
    }

   return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveOutputAction()
PURPOSE  : Callback to write textual information about the result of
		the computation
\*====================================================================*/
ProError ProTestCurveOutputAction(
    ProAnalysis analysis,
    ProLine **lines)
{
    Curvedata_t *data;
    ProError err = PRO_TK_NO_ERROR;
    ProCharLine buff;
    ProLine ll[4];

    TEST_CALL_REPORT ("ProAnalysisOutputAction()", 
        "ProTestCurveOutputAction()", err, err != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
    Get the application dara from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveOutputAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Write the origin of the csys
\*--------------------------------------------------------------------*/
    ProTKSprintf(buff,"Curve offset = %0.2f",
	    data->offset);
    ProStringToWstring(ll[0], buff);

    err = ProArrayObjectAdd ((ProArray*)lines, PRO_VALUE_UNUSED, 1, ll);
    TEST_CALL_REPORT ("ProArrayObjectAdd()", 
        "ProTestCurveOutputAction()", err, err != PRO_TK_NO_ERROR);

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveSavecheckAction()
PURPOSE  : Callback to tell Pro/E whether the analysis application
		data can be saved
\*====================================================================*/
ProError ProTestCurveSavecheckAction(
    ProAnalysis analysis)
{
    ProError err = PRO_TK_NO_ERROR;
    
    TEST_CALL_REPORT ("ProAnalysisSavecheckAction()", 
        "ProTestCurveSavecheckAction()", err, err != PRO_TK_NO_ERROR);

    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveInfosaveAction()
PURPOSE  : Callback to tell Pro/E what element references are required
		by the analysis feature
\*====================================================================*/
ProError ProTestCurveInfosaveAction(
    ProAnalysis analysis,
    ProFeature  *feature,
    ProSelection **references)
{
    ProError err = PRO_TK_NO_ERROR;
    Curvedata_t *data;
    ProSelection sel;

    TEST_CALL_REPORT ("ProAnalysisInfosaveAction()", 
        "ProTestCurveInfosaveAction()", err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Get the application data from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveInfosaveAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
        return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Output the reference to the datum point
\*--------------------------------------------------------------------*/
    err = ProSelectionAlloc (NULL, &data->curve, &sel);
    TEST_CALL_REPORT ("ProSelectionAlloc()", 
        "ProTestCurveInfosaveAction()", err, err != PRO_TK_NO_ERROR);

    err = ProArrayObjectAdd((ProArray*)references, PRO_VALUE_UNUSED, 1, &sel);
    TEST_CALL_REPORT ("ProArrayObjectAdd()", 
        "ProTestCurveInfosaveAction()", err, err != PRO_TK_NO_ERROR);


    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveInforetrieveAction()
PURPOSE  : Callback to get the references Pro/E has stored with the
		analysis feature
\*====================================================================*/
ProError ProTestCurveInforetrieveAction(
    ProAnalysis analysis,
    ProFeature *feature,
    ProSelection *references)
{
    Curvedata_t *data;
    int n_dims;
    ProDimension *p_dims;
    ProError err = PRO_TK_NO_ERROR;

    TEST_CALL_REPORT ("ProAnalysisInforetrieveAction()", 
        "ProTestCurveInforetrieveAction()", 
        err, err != PRO_TK_NO_ERROR);

    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveInforetrieveAction()", 
        err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Copy the first reference to the application as the datum point
\*--------------------------------------------------------------------*/
    err = ProSelectionModelitemGet(references[0], &data->curve);
    TEST_CALL_REPORT ("ProSelectionModelitemGet()", 
        "ProTestCurveInforetrieveAction()", 
        err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    If the feature has a dimension, take its value as the offset
\*--------------------------------------------------------------------*/
    err = ProTestFeatureDimensionsCollect (feature, &p_dims);
    err = ProArraySizeGet ((ProArray)p_dims, &n_dims);

    if(n_dims > 0)
    {
        double dim_value;
        err = ProDimensionValueGet(&p_dims[0], &dim_value);
        data->offset = dim_value;
    }

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveInfocopyAction()
PURPOSE  : 
\*====================================================================*/
ProError ProTestCurveInfocopyAction(
    ProAnalysis from,
    ProAnalysis to)
{
    Curvedata_t *fdata, *tdata;
    ProError err = PRO_TK_NO_ERROR;

    TEST_CALL_REPORT ("ProAnalysisInfocopyAction()", 
        "ProTestCurveInfocopyAction()", 
        err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Get the application data from the analyses
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (from, (ProAppData*)&fdata);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveInfocopyAction()", 
        err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);
    
    err = ProAnalysisInfoGet (to,   (ProAppData*)&tdata);
     TEST_CALL_REPORT ("ProAnalysisInfoGet()", 
        "ProTestCurveInfocopyAction()", 
        err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

/*--------------------------------------------------------------------*\
    Copy the application-specific data (everything except references)
\*--------------------------------------------------------------------*/
    memcpy (&tdata->curve, &fdata->curve, sizeof (ProFeature));
    tdata->offset = fdata->offset;
    
    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestCurveResultAction()
PURPOSE  : Callback to give Pro/E the feature parameters and geometry
		that the analysis feature must contain
\*====================================================================*/
ProError ProTestCurveResultAction(
    ProAnalysis analysis,
    ProBoolean names_only,
    ProAnalysisParameter **parameters,
    ProAnalysisGeomitem  **geometry)
{
    Curvedata_t *data;
    ProAnalysisGeomitem geomitem;
    ProAnalysisParameter param;
    ProError err = PRO_TK_NO_ERROR;
    int num, i, n_pnt, s;
    double *par_arr, double1, double2, double3;
    ProPoint3d *pnt_arr, point1, point2;
    ProVector *tan_arr, vector1, vector2;

    TEST_CALL_REPORT ("ProAnalysisResultAction()", 
        "ProTestCurveResultAction()", 
        err, err != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Get the application data from the analysis
\*--------------------------------------------------------------------*/
    err = ProAnalysisInfoGet (analysis, (ProAppData*)&data);
    TEST_CALL_REPORT ("ProAnalysisInfoGet()",
        "ProTestCurveResultAction()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	return(PRO_TK_GENERAL_ERROR);

/*  CURVE */

    ProStringToWstring (geomitem.name,(char *)"DTM_CURVE");
    geomitem.create = PRO_B_TRUE;
    geomitem.type = PRO_ANALYSIS_CURVE;

    if (!names_only)
    {
        ProArraySizeGet (data->p_curve_data, &num);
        ProArrayAlloc (num, sizeof(ProAnalysisEntity), 1, 
            (ProArray*)&geomitem.shapes);
        for (i = 0; i < num; i++)
	{
            err = ProCurvedataAlloc (&geomitem.shapes[i].curve);
            TEST_CALL_REPORT ("ProCurvedataAlloc()",
                "ProTestCurveResultAction()", err, 
                err != PRO_TK_NO_ERROR);
            switch (data->p_curve_data[i].line.type)
	    {
      	    case PRO_ENT_LINE :
                err = ProLinedataGet (&data->p_curve_data[i], point1, 
                    point2);               
                err = ProLinedataInit (point1, point2, 
                    geomitem.shapes[i].curve);
                break;
            case PRO_ENT_ARC :
                err = ProArcdataGet (&data->p_curve_data[i], vector1, 
                    vector2, point1, &double1, &double2, &double3);
                err = ProArcdataInit (vector1, vector2, point1, double1, 
                    double2, double3, geomitem.shapes[i].curve);
                break;
            case PRO_ENT_SPLINE :
                err = ProSplinedataGet (&data->p_curve_data[i], &par_arr,
                    &pnt_arr, &tan_arr, &n_pnt);
                TEST_CALL_REPORT ("ProSplinedataGet()",
                    "ProTestCurveResultAction()", err, 
                    err != PRO_TK_NO_ERROR);
                err = ProSplinedataInit (par_arr, pnt_arr, tan_arr, n_pnt,
                    geomitem.shapes[i].curve);
                TEST_CALL_REPORT ("ProSplinedataInit()",
                    "ProTestCurveResultAction()", err, 
                    err != PRO_TK_NO_ERROR);
                break;
	    default:
                break;
	    }
        }
    }
    err = ProArrayObjectAdd((ProArray*)geometry, PRO_VALUE_UNUSED, 
        1, &geomitem);
    TEST_CALL_REPORT ("ProArrayObjectAdd()",
        "ProTestCurveResultAction()", err, err != PRO_TK_NO_ERROR);

    return(PRO_TK_NO_ERROR);
}