utilcable.c

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

    *param_num = error;
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorParametersSet
  Purpose  : Sets parameter of specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorParametersSet (
    ProCblConnector *p_connector,  /* In : connector's handle*/
    ProCblParameterInfo *p_param,  /* In : handles of parameter's*/
    int n_param)                   /* In : parameter's number */
{
    int error;

    if (p_connector == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_set_connector_params ((Prohandle)p_connector->owner,
        p_connector->table_num, p_connector->comp_id_table, n_param, p_param);
    TEST_CALL_REPORT("procbl_set_connector_params ", 
          "ProCblConnectorParametersSet",(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 : ProCblConnectorFromLogical
  Purpose  : Returns list of imported, but not designated connectors
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorFromLogical (
    ProAssembly asm_mdl,        /* In : The cabling  assembly's handle */
    ProName    **p_w_name,      /* Out: list of log. con. ProArray, 
                                        to free call ProArrayFree */
    int *con_num)               /* Out: number of connectores */
{
    ProError status;
    int error, i;
    PRODEV_Name *con_names;

    if (asm_mdl == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_connectors_from_logical ((Prohandle)asm_mdl,
        &con_names);
    TEST_CALL_REPORT("procbl_get_connectors_from_logical", 
                   "ProCblConnectorFromLogical",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    *con_num = error;
    status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_w_name);
    for (i = 0; i < *con_num; i++)
        status = ProArrayObjectAdd ((ProArray*)p_w_name, PRO_VALUE_UNUSED,
            1, con_names[i]);
    status = ProArrayFree ((ProArray*)&con_names);

    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblAssemblyConnectorsGet
  Purpose  : Collect all designated connectors 
\*---------------------------------------------------------------------------*/
ProError ProCblAssemblyConnectorsGet (
    ProAssembly       assy,    /* In: The handle of cabling's assembly. */
    ProCblConnector **p_cons,  /* Out: ProArray of connectors if successfull,
                                       to free call ProArrayFree */
    int              *num_cons)/* Out: Number of retrieved connectors*/
{
    int error, i, j, **p_ids_tab_array, *p_nums_array;

    if (assy == NULL || p_cons == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_assy_connectors ((Prohandle)assy,
        &p_ids_tab_array, &p_nums_array, num_cons);
    TEST_CALL_REPORT("procbl_get_assy_connectors ", 
                   "ProCblAssemblyConnectorsGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    ProArrayAlloc( *num_cons, sizeof(ProCblConnector), 1,
       (ProArray*)p_cons);

    for( i=0; i<*num_cons; i++)
    {
        (*p_cons)[i].owner = assy;
        (*p_cons)[i].table_num = p_nums_array[i];

        for( j=0; j<p_nums_array[i]; j++)
            (*p_cons)[i].comp_id_table[j] = p_ids_tab_array[i][j]; 
    }
    error = pro_release_memb_id_tab (p_ids_tab_array);
    TEST_CALL_REPORT("pro_release_memb_id_tab()", 
                   "ProCblAssemblyConnectorsGet()",(ProError)error, 0);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorDesignate
  Purpose  : Designate specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorDesignate (
    ProCblConnector  *p_connector,    /* In: connector to designate */
    ProName          name)            /* In: The reference designator 
                                         of the logical connector,
                                         can be NULL */
{
    int error;

    if (p_connector == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_designate_connector ((Prohandle)p_connector->owner,
        p_connector->comp_id_table, p_connector->table_num, name);
    TEST_CALL_REPORT("procbl_designate_connector", 
             "ProCblConnectorDesignate",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorUndesignate
  Purpose  : Undesignate specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorUndesignate (
    ProCblConnector  *p_connector)    /* In: connector to undesignate */
{
    int error;

    if (p_connector == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_undesignate_connector ((Prohandle)p_connector->owner,
        p_connector->comp_id_table, p_connector->table_num);
    TEST_CALL_REPORT("procbl_undesignate_connector", 
             "ProCblConnectorUndesignate",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblConnectorEntryPortsGet
  Purpose  : Retrieves the entry ports for the specified connector
\*---------------------------------------------------------------------------*/
ProError ProCblConnectorEntryPortsGet (
    ProCblConnector     *p_connector,      /* In: connector handle */
    int                 **p_csys_id_array, /* Out: ProArray of Csys ids */
    int                 *p_num_csys)       /* Out: csys number */
{
    int error;
    int *p_id_array, i;

    if (p_connector == NULL || p_csys_id_array == NULL || p_num_csys == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_connector_entry_ports ((Prohandle)p_connector->owner,
        p_connector->comp_id_table, p_connector->table_num, &p_id_array,
        p_num_csys);
    TEST_CALL_REPORT("procbl_get_connector_entry_ports", 
               "ProCblConnectorEntryPortsGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    ProArrayAlloc (*p_num_csys, sizeof (int), 1, (ProArray*)p_csys_id_array);
    for (i = 0; i <*p_num_csys; i++)
        (*p_csys_id_array)[i] = p_id_array[i];

    return (PRO_TK_NO_ERROR);
}


/*---------------------------------------------------------------------------*\
    Functions to manage harnesses.
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
  Function : ProCblAssemblyHarnessesGet
  Purpose  : Retrive harnesses
\*---------------------------------------------------------------------------*/
ProError ProCblAssemblyHarnessesGet (
    ProAssembly     asm_mdl,       /* In : assembly's handle */
    ProCblHarness **p_harness,     /* Out: array of harness handles to fill.
                                           User must free this with
                                           ProArrayFree */
    int            *num_harness)   /* Out: Number of harness*/
{
    int error, i;
    ProError status;
    ProName name;
    Prohandle *p_handles;
  
    if (asm_mdl == NULL || p_harness == NULL || num_harness == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_assy_harnesses ((Prohandle)asm_mdl,
        (Prohandle**)&p_handles, num_harness);
    TEST_CALL_REPORT("procbl_get_assy_harnesses", 
          "ProCblAssemblyHarnessesGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    status = ProArrayAlloc (*num_harness, sizeof(ProCblHarness), 1,
        (ProArray*)p_harness);

    for( i=0; i<*num_harness; i++)
    {
        ProMdlNameGet ((ProMdl)p_handles[i], name);
        status = ProCblHarnessInit ((ProPart)p_handles[i], name,
            asm_mdl, &(*p_harness)[i]);
    }

    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblHarnessInit
  Purpose  : Initialize harness structure
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessInit (
    ProPart        harness_mdl,  /* In: harness part */
    ProName        name,         /* In: harness name */
    ProAssembly    asm_mdl,      /* In: harness owner */
    ProCblHarness  *p_harness)   /* Out: handle of harness to init */
{
    if (p_harness == NULL)
        return (PRO_TK_BAD_INPUTS);
    p_harness->harness = harness_mdl;
    ProUtilWstrcpy (p_harness->name, name);
    p_harness->owner = asm_mdl;

    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblHarnessCreate
  Purpose  : Creates new harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessCreate (
    ProAssembly asm_mdl,         /* In : assembly's handle */
    ProName w_name,              /* In : harness name */
    ProCblHarness *p_harness)    /* Out: handle of harness to fill */
{
    ProError status;
    int error;
    ProPart harness_part;
    
    if (asm_mdl == NULL || p_harness == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_create_harness ((Prohandle)asm_mdl, w_name, 
        (Prohandle*)&harness_part);
    TEST_CALL_REPORT("procbl_create_harness", 
             "ProCblHarnessCreate",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    status = ProCblHarnessInit (harness_part, w_name, asm_mdl, p_harness); 
    return (status);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblHarnessNameGet
  Purpose  : Retrive the name of harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessNameGet (
    ProCblHarness *p_harness,    /* In : harness*/
    ProName       w_name)        /* Out: harness name*/
{
    if (p_harness == NULL)
        return (PRO_TK_BAD_INPUTS);
    ProUtilWstrcpy (w_name, p_harness->name);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblHarnessCablesGet 
  Purpose  : Get cables from specified harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessCablesGet (
    ProCblHarness *p_harness,    /* In : harness*/
    ProCblCable   **p_cables,    /* Out: ProArray of cables, (user must call
                                         ProArrayFree)*/
    int           *p_n_cables)     /* Out: number of cables */
{
    int error, i, cable_id;
    PRODEV_Name *p_cables_names;

    if (p_harness == NULL || p_cables == NULL || p_n_cables == NULL)
        return (PRO_TK_BAD_INPUTS);

    error = procbl_get_harness_cables ((Prohandle)p_harness->harness,
        &p_cables_names, p_n_cables);
    TEST_CALL_REPORT("procbl_get_harness_cables", 
              "ProCblHarnessCablesGet",(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_cables_names[i], &cable_id);
        TEST_CALL_REPORT("procbl_get_cable_id", 
            "ProCblHarnessCablesGet",(ProError)error, 0);
        if (error != PRODEV_NO_ERROR)
            break;
        ProCblCableInit (cable_id, p_cables_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 : ProCblHarnessLocationsGet
  Purpose  : Finds the locations for the specified harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessLocationsGet (
    ProCblHarness   *p_harness,      /* In: harness handle */
    int **p_location_array,          /* Out: ProArray of locations */
    int  *n_locations)               /* Out: locations number */ 
{
    int error, i;
    int *p_locations;

    if (p_harness == NULL || p_location_array == NULL || n_locations == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_harness_locations ((Prohandle)p_harness->owner,
        (Prohandle)p_harness->harness, &p_locations,
        n_locations);
    TEST_CALL_REPORT("procbl_get_harness_locations", 
              "ProCblHarnessLocationsGet",(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 : ProCblHarnessLocationTypeGet
  Purpose  : Retrieve location type of specified harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessLocationTypeGet (
    ProCblHarness    *p_harness,        /* In: harness handle */
    int              location_id,       /* In: location id */
    ProCblLocationType  *type)          /*Out: location type */ 
{
    int error;
    
    if (p_harness == NULL || type == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_location_type ((Prohandle)p_harness->harness, 
        location_id, type);
    TEST_CALL_REPORT("procbl_get_location_type", 
       "ProCblHarnessLocationTypeGet",(ProError)error, 0);  
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblHarnessLocationPntGet
  Purpose  : Retrieve location point of specified harness
\*---------------------------------------------------------------------------*/
ProError ProCblHarnessLocationPntGet (
    ProCblHarness    *p_harness,        /* In: harness handle */
    int              location_id,       /* In: location id */
    ProCblLocationPnt  *pnt)            /*Out: location point */
{
    int error;
    
    if (p_harness == NULL || pnt == NULL)