utilcable.c

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

    (ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    *param_num = error;

    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCableParametersSet
  Purpose  : Sets parameters for the specified cable
\*---------------------------------------------------------------------------*/
ProError ProCblCableParametersSet (
    ProCblCable         *p_cable,       /* In: cable's handle*/
    ProCblParameterInfo *p_params_info, /* In: array of parameters */
    int                  param_num)     /* In: parameter's number*/
{
    int error;

    if (p_cable == NULL)
        return (PRO_TK_BAD_INPUTS);

    error = procbl_set_cable_params ((Prohandle)((p_cable->p_owner)->owner),
        (Prohandle)((p_cable->p_owner)->harness), p_cable->name, param_num,
        (Pro_parameter_info*) p_params_info);
    TEST_CALL_REPORT("procbl_set_cable_params", "ProCblCableParametersSet",
    (ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);


    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCableLogicalEndsGet
  Purpose  : Retrieves logical ends of specified cable
\*---------------------------------------------------------------------------*/
ProError ProCblCableLogicalEndsGet (
    ProCblCable    *p_cable,        /* In: cable's handle*/
    Select3d	   ends[2])        /* Out: The entry ports 
                                    (user must allocate memory) */
{
    ProError status;
    int error;
    Select3d e_select_3d[2];

    if (p_cable == NULL)
        return (PRO_TK_BAD_INPUTS);

    error = procbl_get_cable_logical_ends (
        (Prohandle)((p_cable->p_owner)->owner),
        (Prohandle)((p_cable->p_owner)->harness), p_cable->name, e_select_3d);
    TEST_CALL_REPORT("procbl_get_cable_logical_ends", 
               "ProCblCableLogicalEndsGet",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR); 

    ends[0] =  e_select_3d[0];
    ends[1] =  e_select_3d[1];


    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCablesFromLogicalCreate
  Purpose  : Creates cables from logical
             If corresponding spools are not created they are also created by
             this func.
\*---------------------------------------------------------------------------*/
ProError ProCblCablesFromLogicalCreate (
    ProCblHarness  *p_harness,      /* In: harness's handle*/
    int            cable_num,       /* In: the number of cables to create */
    ProName        *p_cable_names)  /* In: cables names */
{
    ProError status;
    int error, i; 
    PRODEV_Name *prodev_names;

    if (p_harness == NULL || p_cable_names == NULL)
        return (PRO_TK_BAD_INPUTS);
    status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1, 
        (ProArray*)&prodev_names);
    for (i = 0; i < cable_num; i++)
        status = ProArrayObjectAdd ((ProArray*)&prodev_names, 
            PRO_VALUE_UNUSED, 1, p_cable_names[i]);
    error = procbl_create_cables_from_logical (
        (Prohandle)(p_harness->owner),
        (Prohandle)(p_harness->harness), cable_num, prodev_names);
    TEST_CALL_REPORT("procbl_create_cables_from_logical", 
               "ProCblCablesFromLogicalCreate",(ProError)error, 0);
    status = ProArrayFree ((ProArray*)&prodev_names);

    if (error == PRODEV_INVALID_INPUT)
       return (PRO_TK_E_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    return (PRO_TK_NO_ERROR); 
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCablesFromLogicalGet
  Purpose  : Returns list of imported but not created cables
\*---------------------------------------------------------------------------*/
ProError ProCblCablesFromLogicalGet (
    ProAssembly    asm_mdl,         /* In: assembly's handle*/
    ProName        **p_cable_names, /* Out: ProArray of cable names */
    int *cable_num)                 /* Out: cables number */
{
    ProError status;
    int error, i;
    PRODEV_Name *prodev_names;

    if (asm_mdl == NULL)
        return (PRO_TK_BAD_INPUTS);

    error = procbl_get_cables_from_logical ((Prohandle)asm_mdl, 
        &prodev_names);
    TEST_CALL_REPORT("procbl_get_cables_from_logical", 
               "ProCblCablesFromLogicalGet",(ProError)error, 0);
    if( error == PRODEV_INVALID_INPUT )
	return (PRO_TK_E_NOT_FOUND);
    if ( error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    *cable_num = error;
    status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_cable_names);
    if (status != PRO_TK_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    for (i = 0; i < *cable_num; i++)
        status = ProArrayObjectAdd ((ProArray*)p_cable_names, 
            PRO_VALUE_UNUSED, 1, prodev_names[i]);
/*    status = ProArrayFree ((ProArray*)&prodev_names); */
    
    return (status);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCableLocationsGet
  Purpose  : Finds the locations for the specified cable or wire
\*---------------------------------------------------------------------------*/
ProError ProCblCableLocationsGet (
    ProCblCable  *p_cable,             /* In: cable handle */
    int          **p_location_array,   /* Out: ProArray of locations ids */
    int          *n_locations)         /* Out: Locations number */
{
    int error, i;
    int *p_locations;
    
    if (p_cable == NULL || p_location_array == NULL || n_locations == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_cable_locations ((Prohandle)(p_cable->p_owner)->owner,
        (Prohandle)(p_cable->p_owner)->harness, p_cable->name, &p_locations,
        n_locations);
    TEST_CALL_REPORT("procbl_get_cable_locations", 
               "ProCblCableLocationsGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    ProArrayAlloc (*n_locations, sizeof (int), 1, (ProArray*)p_location_array);
    for (i = 0; i < *n_locations; i++)
        (*p_location_array)[i] = p_locations[i];
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblLocationCablesGet
  Purpose  : Find cables at the specified location
\*---------------------------------------------------------------------------*/
ProError ProCblLocationCablesGet (
    ProCblHarness  *p_harness,             /* In: harness handle */
    int            loc_id,                 /* In: location id */
    ProCblCable    **p_cables,             /* Out: ProArray of cables handles*/
    int            *p_n_cables)            /* Out: cables num */
{
    int error, i, cable_id;
    PRODEV_Name *p_cable_names;

    if (p_cables == NULL || p_harness == NULL || p_n_cables == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_location_cables ((Prohandle)p_harness->harness,
        loc_id, &p_cable_names, p_n_cables);
    TEST_CALL_REPORT("procbl_get_location_cables", 
               "ProCblLocationCablesGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    ProArrayAlloc (*p_n_cables, sizeof (ProCblCable), 1, 
        (ProArray*)p_cables);
    for (i = 0; i < *p_n_cables; i++)
    {
        error = procbl_get_cable_id ((Prohandle)p_harness->harness,
            p_cable_names[i], &cable_id);
        TEST_CALL_REPORT("procbl_get_cable_id", 
            "ProCblLocationCablesGet",(ProError)error, 0);
        if (error != PRODEV_NO_ERROR)
            break;
        ProCblCableInit (cable_id, p_cable_names[i], p_harness,
            &(*p_cables)[i]);
    }
    if (error != PRODEV_NO_ERROR)
    {
        ProArrayFree ((ProArray*)p_cables);
        return (PRO_TK_GENERAL_ERROR);
    }
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCableGeomGet
  Purpose  : Retrieves cable geometry
\*---------------------------------------------------------------------------*/
ProError ProCblCableGeomGet (
    ProCblCable    *p_cable,           /* In: cable handle */
    ProCblCableGeom  **p_geom)     /* Out: cable geom */
                                       /* The function allocates the memory for
                     this argument, and reuses it on subsequent calls.
                     You should not free the memory or keep a pointer to it.*/
{
    int error;

    if (p_cable == NULL || p_geom ==  NULL)
        return (PRO_TK_BAD_INPUTS);

    error = procbl_get_cable_geom ((Prohandle)(p_cable->p_owner)->harness,
        p_cable->name, p_geom);
    TEST_CALL_REPORT("procbl_get_cable_geom ", 
               "ProCblCableGeomGet",(ProError)error, 0);
    if (error != 0)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblCableClearance
  Purpose  : Determines the clearance of the specified cable, and reports if
             interference was found
\*---------------------------------------------------------------------------*/
ProError ProCblCableClearance (
    ProSelection      sel1,        /* In: first selection */
    ProSelection      sel2,        /* In: second selection */
    ProBoolean   *interference,    /* Out: interference */
    ProPoint3d      pnt_arr[2])    /* Out: The coordinates of the closest 
                                      points*/
{
    int error;
    int interf;

    if (interference == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_cable_clearance (sel1, sel2, &interf, pnt_arr);
    TEST_CALL_REPORT("procbl_cable_clearance", 
               "ProCblCableClearance",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    if (interf == 1)
        *interference = PRO_B_FALSE;
    else
        *interference = PRO_B_TRUE;
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
    Functions to manage connectors
\*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorInit
  Purpose  : Initializes connector structure
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorInit (
    ProAsmcomppath  *path,	     /* In : Assembly component path */
    ProCblConnector   *p_connector)  /* Out: pointer to connector
                                        structure to initialize */
{
    int i, j, ierr, **p_comp_id_tab, *p_table_num, num_connectors = 0;

    if (!path)
        return (PRO_TK_BAD_INPUTS);
    *p_connector = *(ProCblConnector*)path;
    
    ierr = procbl_get_assy_connectors((Prohandle)path->owner, &p_comp_id_tab,
	&p_table_num, &num_connectors);
    TEST_CALL_REPORT("procbl_get_assy_connectors", 
		"ProCblConnectorInit", (ProError)ierr, 0);
    if (ierr != PRODEV_NO_ERROR)
	return (PRO_TK_E_NOT_FOUND);
    for (i=0; i<num_connectors; i++)
    {
	for (j=0; j<p_table_num[i]; j++)
	    if (path->comp_id_table[j] != p_comp_id_tab[i][j])
		break;
	if (j>=p_table_num[i])	
	    break;
    }
    ierr = pro_release_memb_id_tab(p_comp_id_tab);
    TEST_CALL_REPORT("pro_release_memb_id_tab", 
		"ProCblConnectorInit", (ProError)ierr, 0);
    if (i<num_connectors)
	return (PRO_TK_NO_ERROR);
    else
	return (PRO_TK_E_NOT_FOUND);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorParameterGet
  Purpose  : Gets connector parameter
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorParameterGet (
    ProCblConnector     *p_connector, /* In : Connector's handle */
    ProName              w_param_name,/* In : Parameter's name */
    ProCblParameterInfo *p_param)     /* Out: Parameter's handle */
{
    int error;

    if (p_connector == NULL || p_param == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_connector_param ((Prohandle)p_connector->owner,
        p_connector->table_num, p_connector->comp_id_table, w_param_name,
        p_param);
    TEST_CALL_REPORT("procbl_get_connector_param", 
          "ProCblConnectorParameterGet",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_BAD_INPUTS);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorParameterDelete
  Purpose  : Deletes parameter of specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorParameterDelete (
    ProCblConnector   *p_connector,     /* In : Connector's handle*/
    ProName            w_param_name)    /* In : Parameter name */
{
    int error;

    if (p_connector == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_delete_connector_param ((Prohandle)p_connector->owner,
        p_connector->table_num, p_connector->comp_id_table, w_param_name);
    TEST_CALL_REPORT("procbl_delete_connector_param ", 
          "ProCblConnectorParameterDelete",(ProError)error, 0);
   if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
   if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorParametersGet
  Purpose  : Retrives parameters of specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorParametersGet (
    ProCblConnector      *p_connector,/* In : connector's handle*/
    ProCblParameterInfo **p_param,    /* Out: ProArray of params*/
    int                  *param_num)  /* Out: Number of parameters */
{
    int error;

    if (p_connector == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_connector_params ((Prohandle)p_connector->owner,
        p_connector->table_num, p_connector->comp_id_table, p_param);
    TEST_CALL_REPORT("procbl_get_connector_params", 
          "ProCblConnectorParametersGet",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT || error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);