utilcable.c

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

        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_location_pnt ((Prohandle)p_harness->harness, 
        location_id, pnt);
    TEST_CALL_REPORT("procbl_get_location_pnt", 
       "ProCblHarnessLocationPntGet",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

    

/*---------------------------------------------------------------------------*\
    Functions to manage spools.
\*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*\
  Function : ProCblAssemblySpoolsGet
  Purpose  : Collect spools in specified assembly
\*---------------------------------------------------------------------------*/
ProError ProCblAssemblySpoolsGet (
    ProAssembly    asm_mdl,     /* In : assembly's handle*/
    ProCblSpool    **p_spool,   /* Out: pointer on array of spool's handle's
                                       to init.Function allocate memory for
                                       this argument, use ProArrayFree to free
                                       it.*/
    int            *num_spools) /* Out: number of retrieved spools*/
{
    int error, i;
    ProError status;
    PRODEV_Name *spool_names;

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

    error = procbl_get_assy_spools ((Prohandle)asm_mdl, &spool_names);
    TEST_CALL_REPORT("procbl_get_assy_spools", 
           "ProCblAssemblySpoolsGe",(ProError)error, 0);
    if(error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if(error == PRODEV_GENERAL_ERROR)
       return (PRO_TK_BAD_INPUTS);

    if (num_spools)    
        *num_spools = error;

    status = ProArrayAlloc (error, sizeof(ProCblSpool), 1,
        (ProArray*)p_spool); 

    for( i=0; i<error; i++)
    {
        status = ProCblSpoolInit (asm_mdl,spool_names[i], &(*p_spool)[i]);
    }

    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblSpoolInit
  Purpose  : Initializes spool structure
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolInit (
    ProAssembly    asm_mdl,     /* In : assembly's handle*/
    ProName        w_name,      /* In : spool name*/
    ProCblSpool    *p_spool)    /* Out: handle of spool to init*/
{
    if (asm_mdl == NULL || p_spool == NULL)
        return (PRO_TK_BAD_INPUTS);
    p_spool->owner = asm_mdl;
    ProUtilWstrcpy (p_spool->name, w_name);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblSpoolNameGet
  Purpose  : returns spool name
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolNameGet (
    ProCblSpool    *p_spool,    /* In: handle of spool to init*/
    ProName        w_name)      /* Out: spool name*/
{
    ProUtilWstrcpy(w_name, p_spool->name);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblSpoolCreate
  Purpose  : Creates new spool
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolCreate (
    ProAssembly assy,                  /* In : assembly's handle*/
    ProName     w_name,                /* In : harness name*/
    Procbl_cable_type cable_type,      /* In : cable type */
    Procbl_sheath_type sheath_type,    /* In : bundle type */
    ProCblSpool  *p_spool)             /* Out :user's memory */
{
    ProError status;
    int error;

    if (assy == NULL || p_spool == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_create_spool ((Prohandle)assy, w_name, cable_type, 
        sheath_type);
    TEST_CALL_REPORT("procbl_create_spool", 
             "ProCblSpoolCreate",(ProError)error, 0);
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    status = ProCblSpoolInit (assy, w_name, p_spool);
    if (status != PRO_TK_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblSpoolParametersGet
  Purpose  : Retrieves parameters of specified spool
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolParametersGet (
    ProCblSpool *p_spool,             /* In : spool's handle*/
    ProCblParameterInfo **p_param,    /* Out: ProArray */
    int *param_num)                   /* Out: params num */
{
    int error;

    if (p_spool == NULL || p_param == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_spool_params ((Prohandle)p_spool->owner,
        p_spool->name, p_param);
    TEST_CALL_REPORT("procbl_get_spool_params", 
          "ProCblSpoolParametersGet",(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 : ProCblSpoolParameterGet
  Purpose  : Retrieves one parameter of specified spool
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolParameterGet (
    ProCblSpool *p_spool,            /* In : spool's handle*/
    ProName w_param_name,            /* In : parametr name */
    ProCblParameterInfo *p_param)    /* Out: user's memory */
{
    int error;

    if (p_spool == NULL || p_param == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_spool_param ((Prohandle)p_spool->owner,
        p_spool->name, w_param_name, p_param);
    TEST_CALL_REPORT("procbl_get_spool_param ", 
            "ProCblSpoolParameterGet",(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 : ProCblSpoolParametersSet
  Purpose  : Set parameters for specified spool
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolParametersSet (
    ProCblSpool         *p_spool,/* In : spool*/
    ProCblParameterInfo *p_param,/* In : the array of parameters*/
    int                  n_param)/* In : the number of parameters*/
{
    int error;

    if (p_spool == NULL || p_param == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_set_spool_params ((Prohandle)p_spool->owner,
        p_spool->name, n_param, p_param);
    TEST_CALL_REPORT("procbl_set_spool_params", 
            "ProCblSpoolParametersSet",(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 : ProCblSpoolParameterDelete
  Purpose  : Deletes parameter in specified spool
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolParameterDelete (
    ProCblSpool *p_spool,       /* In : spool*/
    ProName   param_name)       /* In : param name*/
{
    int error;

    if (p_spool == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_delete_spool_param ((Prohandle)p_spool->owner,
        p_spool->name, param_name);
    TEST_CALL_REPORT("procbl_delete_spool_param", 
          "ProCblSpoolParameterDelete",(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 : ProCblSpoolFromLogicalGet
  Purpose  : Return list of imported, but not created spools
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolFromLogicalGet (
    ProAssembly assy,             /* In: assemlbly */
    ProName     **p_w_name,       /* Out:  ProArray of spool names*/
    int         *num_spool)       /* Out: number of spools */
{
    ProError status;
    int error, i;
    PRODEV_Name *p_spool_names;

    if (assy == NULL || num_spool == NULL || p_w_name == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_get_spools_from_logical ((Prohandle)assy,
        &p_spool_names);
    TEST_CALL_REPORT("procbl_get_spools_from_logical", 
                "ProCblSpoolFromLogicalGet",(ProError)error, 0);                               
    if (error == PRODEV_INVALID_INPUT)
        return (PRO_TK_E_NOT_FOUND);
    if (error == PRODEV_GENERAL_ERROR)
        return (PRO_TK_GENERAL_ERROR);

    *num_spool = error;
    status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_w_name);
    if (status != PRO_TK_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    for (i = 0; i < *num_spool; i++)
        status = ProArrayObjectAdd ((ProArray*)p_w_name, PRO_VALUE_UNUSED,
            1, p_spool_names[i]);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblSpoolFromLogicalCreate
  Purpose  : creates spools from logical
\*---------------------------------------------------------------------------*/
ProError ProCblSpoolFromLogicalCreate (
    ProAssembly assy,                /* In: assembly's hndle*/
    ProName    *p_w_name,            /* In: spool_names */
    int        spool_num,            /* In: spool num */
    ProCblSpool   **p_spools)        /* Out: ProArray of spools
                                        user must free memory by ProArrayFree*/
{
    PRODEV_Name *p_spool_names;
    int error, i;
    ProError status;
  
    if (assy == NULL || p_w_name == NULL || p_spools == NULL)
        return (PRO_TK_BAD_INPUTS);
    status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1, 
        (ProArray*)&p_spool_names);
    if (status != PRO_TK_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    for (i = 0; i < spool_num; i++)
        status = ProArrayObjectAdd ((ProArray*)&p_spool_names, 
            PRO_VALUE_UNUSED, 1, p_w_name[i]);
    error = procbl_create_spools_from_logical ((Prohandle)assy,
        spool_num, p_spool_names);
    TEST_CALL_REPORT("procbl_create_spools_from_logical", 
                "ProCblSpoolFromLogicalCreate",(ProError)error, 0);
    status = ProArrayFree ((ProArray*)&p_spool_names);

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

    status = ProArrayAlloc (spool_num, sizeof (ProCblSpool), 1,
        (ProArray*)p_spools);
    for (i = 0; i < spool_num; i++)
    {
        status = ProCblSpoolInit (assy, p_w_name[i], &(*p_spools)[i]);
    }
    
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
    Functions to route cables.
\*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*\
  Function : ProCblRoutingStart
  Purpose  : Initializes routing procedure
\*---------------------------------------------------------------------------*/
ProError ProCblRoutingStart (
    ProCblCable    *p_cables,       /* In: ProArray of cables to route */
    void      **p_cable_route_data) /* Out: The cable routing data required for
                          subsequent function calls to route cables
                          through locations. The function allocates
                          the space for this argument. */
{
    int error;
    PRODEV_Name *cable_names;
    int cable_num, i;

    if (p_cables == NULL || p_cable_route_data == NULL)
        return (PRO_TK_BAD_INPUTS);
    ProArraySizeGet ((ProArray)p_cables, &cable_num);
    ProArrayAlloc (cable_num, sizeof (PRODEV_Name), 1, (ProArray*)&cable_names);
    for (i = 0; i < cable_num; i++)
        ProCblCableNameGet (&p_cables[i], cable_names[i]);
    
    error = procbl_routing_start ((Prohandle)p_cables[0].p_owner->owner,
        (Prohandle)p_cables[0].p_owner->harness, cable_names, cable_num,
        p_cable_route_data);
    TEST_CALL_REPORT("procbl_routing_start", 
             "ProCblRoutingStart",(ProError)error, 0);
    ProArrayFree ((ProArray*)&cable_names);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblRouteThruLocation
  Purpose  : Finds or creates the location, and routes cables through it
\*---------------------------------------------------------------------------*/
ProError ProCblRouteThruLocation (
    void      *p_cable_route_data, /* In: routing data */
    ProCblLocRef  *ref,            /* In: referances */
    int **r_location_ids,          /* Out: The location identifiers.
                                      The function allocates the space for
                                      this argument, and reuse it*/
    int *num_locs)                 /* Out: The number of locations. */
{
    int error;

    if (p_cable_route_data == NULL || ref == NULL || r_location_ids == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_route_thru_location (p_cable_route_data, ref,
        r_location_ids, num_locs);
    TEST_CALL_REPORT("procbl_route_thru_location", 
              "ProCblRouteThruLocation",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}

/*---------------------------------------------------------------------------*\
  Function : ProCblRoutingEnd
  Purpose  : Ends the cable routing
\*---------------------------------------------------------------------------*/
ProError ProCblRoutingEnd (
    void      **p_cable_route_data)   /* In: The address of the cable 
                                         routing data */
{
    int error;
    
    if (p_cable_route_data == NULL)
        return (PRO_TK_BAD_INPUTS);
    error = procbl_routing_end (p_cable_route_data);
    TEST_CALL_REPORT("procbl_routing_end", 
             "ProCblRoutingEnd",(ProError)error, 0);
    if (error != PRODEV_NO_ERROR)
        return (PRO_TK_GENERAL_ERROR);
    return (PRO_TK_NO_ERROR);
}