Production Applications: NC Process Manager
Overview
The Process Manager functionality is based on the Process Table, which lists all the manufacturing process objects, such as workcells, operations, fixture setups, tooling, and NC sequences.
The Process Table lets you create new manufacturing objects and modify properties of existing ones. You can create new Holemaking and some milling steps directly in the Process Table. Steps of other types, that is, NC Sequences created outside the Process Manager, are also listed in the Process Table. You can manipulate the NC Sequences like any other steps, for example, reorder or duplicate them. However, customizations done to the toolpath outside the Process Table will be lost as a result of manipulation.
You can also define manufacturing templates based on existing Milling and Holemaking steps, and use these templates to create manufacturing steps in a different model.
You can add manufacturing templates as annotations to the reference part. This way, when you bring a reference part into a manufacturing model, the annotation can be automatically extracted into the manufacturing process to create the necessary steps, complete with tooling, parameters, and geometric references.
Accessing the Process Manager
You can access the Process Manager in Creo Parametric in the Manufacturing Mode via Creo Parametric TOOLKIT as follows:
•  When the process manager dialog box is not active.
•  When the process manager dialog box is active.
Accessing the Process Manager when the Dialog Box is not Active
You can access and modify the contents of the process manager without opening the Process Manager User Interface or while editing a manufacturing model in Creo Parametric.
Functions Introduced:
  • ProMfgProctableEnable()
    		•
  • ProMfgProctableDisable()
    		•
    The function ProMfgProctableEnable() ensures that the process manager database is prepared for access or modification by Creo Parametric TOOLKIT functions. The application must call the function ProMfgProctableEnable() before using the process manager APIs discussed in the following sections.
    The function ProMfgProctableDisable() enables Creo Parametric to perform cleanup of data that was loaded while calling the function ProMfgProctableEnable().
    Accessing the Process Manager User Interface
    You can add new items to the Process Manager User Interface using a Creo Parametric TOOLKIT application. The Creo Parametric TOOLKIT application should register the new user interface items in Creo Parametric before you open the Process Manager dialog box. Once the dialog box is opened, Creo Parametric automatically adds the registered menu buttons and menus to the dialog box.
    Functions Introduced:
  • ProMfgproctableMenuAdd()
    		•
  • ProMfgproctablePushbuttonAdd()
    		•
  • ProMfgproctableItemAccessFunction
    		•
  • ProMfgproctableItemActionFunction
    		•
  • ProMfgproctableSelecteditemsGet()
    		•
  • ProMfgproctableSelecteditemsSet()
    		•
  • ProMfgproctableDisplayUpdate()
    		•
    The function ProMfgproctableMenuAdd() adds a new menu or submenu to an existing menu in the process manager user interface.
    The function ProMfgproctablePushbuttonAdd() adds a new button at the end of the existing menu in the Process Manager user interface. When adding a new menu button, you must supply two callback functions whose signature matches ProMfgproctableItemAccessFunction and ProMfgproctableItemActionFunction respectively.
    The function whose signature matches ProMfgproctableItemAccessFunction sets the access state for the button in the process manager dialog box. The function whose signature is similar to ProMfgproctableItemActionFunction provides the implementation for the new menu button.
    Use the functions ProMfgproctableSelecteditemsGet() and ProMfgproctableSelecteditemsSet() in the context of menu buttons added to the Process Manager. These functions provide access to the steps, operations and workcells that are currently selected by the user in the Process Manager dialog box. This information can guide the application as to which items it should modify. Select the appropriate type of table for the selected item to be able to determine the subtype of the process item.
    These functions can be used out of context of the menu addition APIs as well.
    The function ProMfgproctableDisplayUpdate() refreshes the Process Manager dialog box. It allows the application to update the contents of the process table after some changes have been made during a custom menu button action.
    Manufacturing Process Items
    This section gives you more information on the handles that are provided to enable access to process item data.
    Steps, Operations and Workcells
    An NC sequence is an assembly feature that represents a single tool path. NC sequences listed in the Process Table are called steps.
    An operation is a series of NC sequences performed in a particular workcell and using a particular coordinate system for output of Cutter Location data.
    A workcell is a machine tool definition and is stored in the assembly.
    The object ProMfgprocItem will be used for all functions that operate on steps, operations, and workcells. This item is a derivative of ProModelitem and is defined as 
    typedef struct pro_model_item
{
ProType type;
int id;
ProMdl owner;
}ProMfgprocItem;
    For all three item types, the ProType field should be PRO_NC_PROCESS_ITEM.
    Step Models
    The Step Model object represents the default properties of steps in the process manager and is a derivative of the ProModelitem and is defined as typedef struct pro_model_item. 
    {
ProType type;
int id;
ProMdl owner;
}ProMfgprocItem;
    Step objects have a step id, the Mfg owner, and the ProType field as PRO_NC_PROCESS_MODEL.
    Determining the Subtype of a Process Item
    Function Introduced:
  • ProMfgprocitemSubtypeGet()
    		•
    The function ProMfgprocitemSubtypeGet() returns the subtype of a manufacturing process item. It could be one of the following:
    •  PRO_MFGPROCITEM_STEP—Specifies if the subtype is a step.
    •  PRO_MFGPROCITEM_OPERATION—Specifies if the subtype is an operation.
    •  PRO_MFGPROCITEM_WORKCELL—Specifies if the subtype is a workcell.
    Accessing Details of Process Items
    Although a ProMfgprocItem is not a feature, it shares many properties with Creo Parametric TOOLKIT features. In fact, process items generally map one-to-one with a specified manufacturing feature. Because of this, many of the process item’s properties can be accessed via the corresponding manufacturing feature element tree. Also, new items may be created by populating the element tree for the new step, operation or workcell.
    Visiting Steps, Operations and Workcells
    Functions Introduced:
  • ProMfgProctableVisit()
    		•
  • ProMfgprocitemVisitAction()
    		•
  • ProMfgprocitemFilterAction()
    		•
    The function ProMfgProctableVisit() enables you to visit the steps, workcells, and operations in a process table. As with other Creo Parametric TOOLKIT visit functions, specify the visit action and visit filter functions. For more information on Visit Functions, refer to the section Fundamentals.
    Creating Steps, Operations, and Workcells
    Functions Introduced:
  • ProMfgprocitemCreate()
    		•
  • ProMfgprocitemFromTemplateCreate()
    		•
    Use the function ProMfgprocitemCreate() to create a new step, operation, or workcell in the process table. The input arguments of this function are:
    •  model—Specifies the manufacturing model in which to create the new item.
    •  table_type—Specifies the type of table where the item will reside. The valid values are:
    ○  PRO_MFGPROCTABLE_PROCESS—Specifies the process table.
    ○  PRO_MFGPROCTABLE_WORKCELLS—Specifies the workcell table.
    •  elem_tree—Specifies the manufacturing feature element tree used to enumerate the properties of the new manufacturing item. To create a step you must fill one of the following element trees:
    ○  Milling and Drilling—The element tree documented in header file ProNcseq.h.
    ○  Fixture—The element tree documented in header file ProFixture.h.
    ○  Assembly setup step—The element tree documented in header file ProFixture.h.
    To create an Operation you must fill out the element tree documented in header file ProMfgoper.h.
    To create a Workcell you must fill the element tree documented in header file ProWcell.h.
    •  predecessor—Specifies the step or operation immediately before the new manufacturing item in the process table. When creating workcells, this can be NULL.
    The function ProMfgprocitemCreate() returns the new manufacturing item.
    Use the function ProMfgprocitemFromTemplateCreate() to create a new manufacturing step or workcell from a predefined template. A template is an XML file containing information necessary to create the manufacturing step or workcell, such as:
    •  Resources, that is, workcells, tools, and fixtures
    •  Ordered operations
    •  Ordered steps and their reference information such as manufacturing templates and manufacturing criteria.
    •  Retract plane for a step or an operation, as a distance calculated from the step coordinate system.
    Accessing the Properties of Manufacturing Process Items
    The functions described below enable you to access the properties of process items.
    Functions Introduced:
  • ProMfgprocitemFeatureGet()
    		•
  • ProMfgprocitemElemtreeGet()
    		•
  • ProMfgprocitemElemtreeFree()
    		•
  • ProMfgprocitemAnnotationGet()
    		•
  • ProMfgprocitemReorderlimitsGet()
    		•
  • ProMfgprocitemNextitemGet()
    		•
  • ProMfgprocitemPreviousitemGet()
    		•
  • ProMfgprocitemHolesetdepthGet()
    		•
  • ProMfgprocitemHolesetdepthtypeGet()
    		•
  • ProMfgprocitemHolesetdepthSet()
    		•
  • ProMfgprocitemDefaultfixturesetupstepGet()
    		•
    The function ProMfgprocitemFeatureGet() returns the feature referenced by the process item. If the item is related to an actual manufacturing feature, some of the access functions that follow will not be supported. The properties of the item can be obtained by reading the feature’s properties and element tree.
    The function ProMfgprocitemElemtreeGet() obtains the element tree for a manufacturing item. This tree should be freed using ProMfgprocitemElemtreeFree().
    The function ProMfgprocitemAnnotationGet() returns the annotation element that created the process item.
    The function ProMfgprocitemReorderlimitsGet() identifies the limits where the specified process item may be moved in the process table. The top limit represents the first process item after which you can insert the step. The lower limit, if any, represents the first process item that must come after the step in the process sequence.
    The limits of reorder are based on step dependencies and priority and prerequisite rules. The input argument options specifies the checks to determine the position of reordering the process item elements. The valid values are:
    •  PRO_MFGPROCREORDER_CHECK_PARENT_CHILD
    •  PRO_MFGPROCREORDER_CHECK_PREREQUISITES
    •  PRO_MFGPROCREORDER_CHECK_PRIORITIES
    The function ProMfgprocitemNextitemGet() returns the process item following the specified item in the process table.
    The function ProMfgprocitemPreviousitemGet() returns the process item preceding the specified process item in the process table.
    The function ProMfgprocitemHolesetdepthtypeGet() returns the type of holeset and holeset end reference contained in the manufacturing process step.
    The output argument end_type can have the following values:
    •  PRO_MFGSTEP_HOLESETEND_REFERENCE—Specifies the end reference surface for the hole depth.
    •  PRO_MFGSTEP_HOLESETEND_ALONG_AXIS—Specifies the end reference by entering a depth value along the hole axis.
    The function ProMfgprocitemHolesetdepthGet() returns the process item holeset depth for a holeset of type BLIND and end reference type of ALONG AXIS.
    The function ProMfgprocitemHolesetdepthSet() sets the holeset depth for a step. This function supports steps with only one holeset. The holeset type must be BLIND and the end reference type will be changed to ALONG AXIS after using this function.
    The function ProMfgprocitemDefaultfixturesetupstepGet() returns the fixture setup defined for the specified operation.
    Modifying Process Items
    Functions Introduced:
  • ProMfgprocitemRedefine()
    		•
  • ProMfgprocitemDelete()
    		•
  • ProMfgprocitemReorder()
    		•
    Use the function ProMfgprocitemRedefine() to redefine the manufacturing item created using an element tree.
    The function ProMfgprocitemDelete() deletes the specified step, operation, or workcell from the manufacturing table.
    The function ProMfgprocitemReorder() reorders a step or operation within the process table.
    Parameters
    Several categories of parameters are accessible for items in the process manager table:
    •  Manufacturing parameters
    •  AE parameters
    •  Step parameters
    •  Template parameters
    •  Special parameters
    •  Global Parameters
    Manufacturing Parameters
    You can access the manufacturing parameters by reading or writing the manufacturing feature or step element tree.
    Annotation Element Parameters
    You can access the annotation element parameters by getting the parent Annotation Element via ProMfgprocitemAnnotationGet() and reading parameters from that object. Refer to the chapter Parameters for details on how to read parameters from items such as annotation elements.
    Step Parameters and Relations
    Step Parameters are parameters assigned to the step object. You can define parameters and relations to a particular step in the process table.
    You can access these parameters by reading them directly from the step object using the standard parameter functions.
    Refer to the chapter Parameters for details on how to read parameters from items.
    Template Parameters
    Template parameters are inherited from the step’s process template.
    Function Introduced:
  • ProMfgprocitemTemplateparamGet()
    		•
    The function ProMfgprocitemTemplateparamGet() obtains a template parameter value for the process item.
    Special Parameters
    Other special parameters are properties of steps and can include the extract status, machining time, the template name, and so on. Some of these properties may be also accessible via the step element tree.
    Functions Introduced:
  • ProMfgprocitemPropertyGet()
    		•
  • ProMfgprocitemPropertySet()
    • The function ProMfgprocitemPropertyGet() returns the value of the special property of the process manager step or operation. The special property can be as follows:
    •  PRO_MFGPROP_EXTRACT_STATUS—Specifies the extraction priority of the step.
    •  PRO_MFGPROP_ACTUAL_MACHINING_TIME—Specifies the machining time of a step.
    •  PRO_MFGPROP_ACTUAL_MACHINING_LENGTH— Specifies the machining distance of a step.
    •  PRO_MFGPROP_TEMPLATE_NAME—Specifies the name of the manufacturing template used.
    •  PRO_MFGPROP_GROUP_LEVEL_1—Specifies a merge group created by merging several Holemaking steps together, to optimize the tool path.
    •  PRO_MFGPROP_GROUP_LEVEL_2—Specifies a merge group created by merging PRO_MFGPROP_GROUP_LEVEL_1 type merge groups together.
    ProMfgprocitemPropertyGet()returns string values for PRO_MFGPROP_GROUP_LEVEL_1 and PRO_MFGPROP_GROUP_LEVEL_2 depending on the location of the process manager step in the merged group. The following table lists all the possible values taken by the special properties.
    Step Location
    Value returned for
    Value returned for
    If the step is a merge leader, but not a merge member.
    “*leader”
    Empty string
    If the step is both a merge leader and merge member.
    Name of the parent merge leader
    “*leader”
    If the step is merge member, but not a merge leader.
    Case 1: It is a two level merge. For example, the parent itself is a merge member.
    Name of the top merge leader
    Name of the parent merge leader
    Case 2: It is a one level merge
    Name of the parent merge leader
    Empty string
    If the step is neither merge leader nor a merge member.
    Empty string
    Empty string
    The function ProMfgprocitemPropertySet() sets the value of the special property of the process manager step or operation.
    Global Parameters and Relations
    Function Introduced:
  • ProMfgProctablemodelGet()
    		•
    The function ProMfgProctablemodelGet() obtains the process model that provides access to the manufacturing global parameters.
    You can use this function to specify parameters and relations to all or selected steps in the process table. The modelitem handle returned by this function can be used to access the Global parameters of the process table.
    Manufacturing Features
    Functions Introduced:
  • ProMfgproctableFeaturesCreate()
    		•
  • ProMfgproctableFeaturesDelete()
    		•
    The function ProMfgproctableFeaturesCreate() creates features for items in the process manufacturing table.
    The function ProMfgproctableFeaturesDelete() deletes all existing manufacturing features from the Creo Parametric model while keeping everything in the process manager unchanged.
    Import and Export of Process Table Contents
    Functions Introduced:
  • ProMfgProctableWrite()
    		•
  • ProMfgProctableSynchronize()
    		•
    The function ProMfgProctableWrite() exports the contents of the manufacturing process table to CSV format. The input arguments of the function are:
    •  mfg—Specifies the manufacturing model.
    •  table_type—Specifies the type of table to be generated as output. The valid values are:
    ○  PRO_MFGPROCTABLE_PROCESS
    ○  PRO_MFGPROCTABLE_WORKCELLS
    •  view_name—Specifies the view name in the setup file; pass NULL to use the current view.
    •  output_file—Specifies the full path and name of the output file.
    The function ProMfgProctableSynchronize() synchronizes the manufacturing table with the input CSV file.
    Notification
    Function Introduced:
  • ProMfgproctableExtractionPostAction
    		•
    The notification ProMfgproctableExtractionPostAction identifies when the user has extracted the process table in order to form manufacturing features. It provides the path to the extraction log file, which can be examined by the application for further information.
    Example 1: To Add Menu Button to The Manufacturing Process Table
    This example enables you to add the Highlight Prereq and the Update Speed and Feed options respectively, to the Tools menu in the Manufacturing Process Table. 
    /*====================================================================*\
  FUNCTION : user_initialize()
  PURPOSE  : 
\*====================================================================*/
int user_initialize(
                    int argc,        
                    char *argv[],
                    char *version, 
                    char *build,
                    wchar_t errbuf[80])
{
  uiCmdCmdId    cmd_id;
  PTUtilInitCounters();
  
  status = ProMfgproctablePushbuttonAdd ("Tools","Highlight Prereq",
                                              L"Highlight Prereq",
                                         L"button_helptext",NULL,
                                         PTMfgProctableItemActionPreReq,
                     "Callback on the new submenu added in  existing menu");
  PT_TEST_LOG_SUCC("ProMfgproctablePushbuttonAdd");
  
  
  status = ProMfgproctablePushbuttonAdd ("Tools","Update Feed & Speed",
                                              L"Update Feed & Speed",
                                         L"button_helptext",NULL,
                                         PTMfgProctableItemFeedSpeed,
                  "Callback on the new submenu added in  existing menu");
  PT_TEST_LOG_SUCC("ProMfgproctablePushbuttonAdd");
  
return (PRO_TK_NO_ERROR); 
}
    Image
    The image above displays the Highlight Prereq and Update Feed & Speed menu buttons added to the Tools menu in the Manufacturing Process Table. When you click the Highlight Prereq option the function PTMfgProctableItemActionPreReq is invoked. The following example deals with this function in detail.
    Example 2: To Highlight the Pre-requisites for the Selected Step in The Manufacturing Process Table
    This example enables you to highlight the pre-requisites for the selected step in the Manufacturing Process Table.
    /*====================================================================*\
    FUNCTION :  PTMfgProctableItemActionPreReq 
    PURPOSE  :  Execute Highlighting of Pre-Requisite steps 
\*====================================================================*/
ProError PTMfgProctableItemActionPreReq (ProMfg mfg, char* button_name, 
                ProAppData appdata)
{
  
  ProElement elem_tree;
  
  status = PTMfgProcitemElemtreeGet(&elem_tree);
  PT_TEST_LOG_SUCC("PTMfgProcitemElemtreeGet");
  
  if ( status == PRO_TK_NO_ERROR)
    {
      status = ProElemtreeWrite (elem_tree, PRO_ELEMTREE_XML, 
               L"selecteditem_prereq.inf");
      PT_TEST_LOG_SUCC (" ProElemtreeWrite ");
      
      if ( status == PRO_TK_NO_ERROR )
      {
        status = ProElemtreeElementVisit( elem_tree, ( ProElempath )NULL ,
                       ( ProElemtreeVisitFilter) NULL,
                       ( ProElemtreeVisitAction) PTMfgElemtreePreReqAction,
                                  NULL );
        PT_TEST_LOG_SUCC (" ProElemtreeElementVisit ");
      }
      
    }
  
  return PRO_TK_NO_ERROR;
}
    Image
    Example 3: To Update Feed and Spindle Speed
    When you click the Update Speed and Feed options in the Tools menu in the Manufacturing Process Table, the function PTMfgProctableItemFeedSpeed is invoked. This sample code enables you to change the cut feed and the spindle speed for the specified tool. 
    /*====================================================================*\
    FUNCTION :  PTMfgProctableItemFeedSpeed()
    PURPOSE  :  Execute Feed/Speed 
\*====================================================================*/
ProError PTMfgProctableItemFeedSpeed (ProMfg mfg, char* button_name
    , ProAppData appdata)
{
  ProAssembly r_solid_obj;
  ProMdl mfg_mdl_under_test;
  ProElempath epath;
  ProElement params_element;
  ProElempathItem  p_items[3];
  ProElemId elem_id;
  ProValueDataType value_type = -1;
  ProValue     value = (ProValue)NULL;
  ProValueData value_data;
  status =ProMdlCurrentGet(&mfg_mdl_under_test);
  PT_TEST_LOG_SUCC("ProMdlCurrentGet");
  
  status = PTMfgProcitemElemtreeGet(&complete_tree);
  PT_TEST_LOG_SUCC("PTMfgProcitemElemtreeGet");
  
  if (status  == PRO_TK_NO_ERROR)
    PTMfgProcitemToolNameGet(complete_tree);
  
  if  (status  == PRO_TK_NO_ERROR)
    {
      status = ProElempathAlloc(&epath);
      PT_TEST_LOG_SUCC ("ProElempathAlloc ()");
      
      p_items[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
      p_items[0].path_item.elem_id = PRO_E_MFG_PARAMS ;
      
      status = ProElempathDataSet(epath, p_items, 1);
      PT_TEST_LOG_SUCC ("ProElempathDataSet()");
      status= ProElemtreeElementGet(complete_tree, epath,
&params_element);
      PT_TEST_LOG_SUCC ("ProElemtreeElementGet()");
      
      if ( status == PRO_TK_NO_ERROR )
      {
        status = ProElemtreeElementVisit( params_element,NULL,
                                  ( ProElemtreeVisitFilter) NULL,
                                  ( ProElemtreeVisitAction) 
                                      PTMfgElemtreeWalkthroughAction,
                                  NULL );
        PT_TEST_LOG_SUCC (" ProElemtreeElementVisit ");
      }      
      ProElempathFree(&epath);    }
    status = ProMfgAssemGet(mfg_mdl_under_test,&r_solid_obj);
  PT_TEST_LOG_SUCC ("ProMfgAssemGet");
    status = ProSolidFeatVisit ((ProSolid)r_solid_obj,
                              (ProFeatureVisitAction)PTMfgMaterialGet,
                              NULL,
                              NULL); 
                                  PT_TEST_LOG_SUCC ("ProSolidFeatureVisit()");
      
  status  = PTMfgDialogCreate(params_element);
    PTUtilInitCounters();
    return PRO_TK_NO_ERROR;
}
    Image
    The section below describes the action functions for the each of the preceding sample code.
    /***********************ACTION FUNCTIONS*************************/
/*--------------------------------------------------------*\
    FUNCTION :  PTMfgElemtreeWalkthroughAction()
    PURPOSE  :  Action function for PTUtilElemtreeWalkthroug
\*--------------------------------------------------------*/
ProError PTMfgElemtreeWalkthroughAction ( ProElement params_element,
                                ProElement  element, ProElempath elem_path,
                                ProAppData app_data )
{    ProElempathItem  p_items[3];
  ProValueDataType value_type = -1;
  ProElemId  elem_id,p_elem_id;  char *  actual_value;
  ProValue     value = (ProValue)NULL;
  ProValueData value_data;  Data_Input *my_data;
  ProElempath      epath;  my_data = (Data_Input*) app_data;
  status = ProElementIdGet( element, &elem_id);
  PT_TEST_LOG_SUCC("ProElementIdGet");
    if ( elem_id == PRO_E_MFG_PARAM_NAME )
    {      status = ProElementValuetypeGet ( element, &value_type );
      PT_TEST_LOG(" ProElementValuetypeGet ", status,
               status != PRO_TK_NO_ERROR && status != PRO_TK_INVALID_TYPE &&
               status != PRO_TK_EMPTY  );
            if(value_type ==PRO_VALUE_TYPE_STRING)
      {       status = ProElementStringGet( element,( ProElementStringOptions)
                   NULL,
                   &actual_value);
          PT_TEST_LOG_SUCC (" ProElementStringGet ");
                  if (  (strcmp ( "CUT_FEED",actual_value)      == 0)
            ||( strcmp ( "SPINDLE_SPEED",actual_value) == 0))
            {            
            status = ProElempathAlloc(&epath);
              PT_TEST_LOG_SUCC ("ProElempathAlloc ()");
                        p_items[0].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
            p_items[0].path_item.elem_index = count;
            p_items[1].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
            p_items[1].path_item.elem_id = PRO_E_MFG_PARAMVAL;
                        status = ProElempathDataSet(epath, p_items, 2);
           PT_TEST_LOG_SUCC ("ProElempathDataSet()");
            status= ProElemtreeElementGet(params_element, epath, &p_element);
           PT_TEST_LOG_SUCC ("ProElemtreeElementGet()");
                        status = ProElementIdGet( p_element, &p_elem_id);
            PT_TEST_LOG_SUCC (" ProElementIdGet ");
                        if (p_elem_id ==PRO_E_MFG_PARAMVAL)
            {              
              status = ProElementValueGet ( p_element, &value);
              PT_TEST_LOG_SUCC("ProElementValueGet");
                            status = ProValueDataGet (value, &value_data);
              PT_TEST_LOG("ProValueDataGet()", status, 
                               (status != PRO_TK_NO_ERROR));
                                if (strcmp ( "CUT_FEED",actual_value) == 0)
                {                  cut_feed = value_data.v.d;
                                    if (FLAG == 1)
                  {                    value_data.v.d = my_data-cut_feed;
                    status = ProValueDataSet (value, &value_data);
                    PT_TEST_LOG("ProValueDataSet()", status, 
                        (status != PRO_TK_NO_ERROR));
                     status = ProElementValueSet ( p_element, value);
                    PT_TEST_LOG_SUCC("ProElementValueGet");
                                      }
                }              
                  if (strcmp ( "SPINDLE_SPEED",actual_value) == 0)
                {                 spindle_speed = value_data.v.d;
                                   if (FLAG == 1)
                  {                 value_data.v.d = my_data-spindle_speed;
                    status = ProValueDataSet (value, &value_data);
                    PT_TEST_LOG("ProValueDataSet()", status, 
                                (status != PRO_TK_NO_ERROR));
                                        status = ProElementValueSet 
                                 (p_element, value);
                    PT_TEST_LOG_SUCC("ProElementValueGet");
                                      }
                }              count++;  
            }            
            ProElempathFree(&epath);
                      }
      }            
            status =  ProMfgproctableDisplayUpdate ();
      PT_TEST_LOG_SUCC ("ProMfgproctableDisplayUpdate");
          }
    return PRO_TK_NO_ERROR;
}
/*--------------------------------------------------------*\
  FUNCTION : PTMfgUsrUpdateAction
  PURPOSE  : Action function for the File Selection

\*--------------------------------------------------------*/
void PTMfgUsrUpdateAction(char *dialog, char *component, ProAppData data)
{  ProElement params_element; 
  ProCharName str;  ProCharName str2;
  double cut_feed_value;  double spindle_speed_value;
  Data_Input data1;  wchar_t* wstr;
  wchar_t* wstr2;  ProErrorlist    p_errors;
  params_element = (ProElement) data; 
    ProUIInputpanelValueGet(DIALOG_NAME,"cut_feed",&wstr);
  ProWstringToString(str, wstr);
  cut_feed_value= atof(str);  
  ProUIInputpanelValueGet(DIALOG_NAME,"spindle_speed",&wstr2);
  ProWstringToString(str2, wstr2);
  spindle_speed_value= atof(str2);  
  data1.cut_feed = cut_feed_value;
  data1.spindle_speed = spindle_speed_value;
   count =0;  FLAG =1;
   status = ProElemtreeWrite 
(params_element, PRO_ELEMTREE_XML, L"before_redef.inf");
  PT_TEST_LOG_SUCC (" ProElemtreeWrite ");
      status = ProElemtreeElementVisit( params_element, ( ProElempath )NULL ,
                     ( ProElemtreeVisitFilter) NULL,
                     ( ProElemtreeVisitAction) PTMfgElemtreeWalkthroughAction,
                      (ProAppData)&data1 );
  PT_TEST_LOG_SUCC (" ProElemtreeElementVisit ");
      status = ProMfgprocitemRedefine (sel_items,complete_tree,&p_errors);
  PT_TEST_LOG_SUCC ("ProMfgprocitemRedefine");
    status =  ProMfgproctableDisplayUpdate ();
  PT_TEST_LOG_SUCC ("ProMfgproctableDisplayUpdate");
    PTUtilInitCounters();
    status = ProUIDialogExit(DIALOG_NAME, 0);
  PT_TEST_LOG_SUCC("ProUIDialogExit"); 
}
/*--------------------------------------------------------*\
  FUNCTION : PTMfgUsrCancelAction
  PURPOSE  : Action function for the Directory Selection
\*--------------------------------------------------------*/
void PTMfgUsrCancelAction(char *dialog, char *component, ProAppData data)
{  ProError status;
    PTUtilInitCounters();
    status = ProUIDialogExit(DIALOG_NAME, 0);
  PT_TEST_LOG_SUCC("ProUIDialogExit");
  }
/*--------------------------------------------------------*\
    FUNCTION :  PTMfgElemtreePreReqAction()
    PURPOSE  :  Get the material 
\*--------------------------------------------------------*/
ProError PTMfgMaterialGet (ProFeature* feat, ProAppData data)
{  ProAsmcompType f_type;
  ProMaterial p_material;  ProFeattype  feat_type;
  ProSolid part;  ProMdl p_mdl_handle; 
  ProCharName c_name;  ProMdl mfg_mdl_under_test;
    status =ProMdlCurrentGet(&mfg_mdl_under_test);
  PT_TEST_LOG_SUCC("ProMdlCurrentGet");
    status = ProFeatureTypeGet(feat,&feat_type);
  PT_TEST_LOG_SUCC("ProFeatureTypeGet");
    if(feat_type==PRO_FEAT_COMPONENT)
    {    status = ProAsmcompTypeGet ((ProAsmcomp*)feat,feat-owner, &f_type);
      PT_TEST_LOG_SUCC("ProAsmcompTypeGet"); 
            if ( f_type ==  PRO_ASM_COMP_TYPE_REF_MODEL)
      {        status = ProAsmcompMdlGet ((ProAsmcomp*)feat,&p_mdl_handle);
        PT_TEST_LOG_SUCC("ProAsmcompMdlGet");
                status = ProMaterialCurrentGet 
                    ((ProSolid)p_mdl_handle,&p_material);
        PT_TEST_LOG_SUCC("ProMaterialCurrentGet");
                ProWstringToString (c_name, p_material.matl_name);
                ProWstringCopy(p_material.matl_name,material_name,
                     PRO_VALUE_UNUSED);
              }
          }  
  return PRO_TK_NO_ERROR;}
/*--------------------------------------------------------*\
    FUNCTION :  PTMfgElemtreePreReqAction()
    PURPOSE  :  Action function for PTUtilElemtreeWalkthroug
\*--------------------------------------------------------*/
ProError PTMfgElemtreePreReqAction ( ProElement elem_tree,
                             ProElement  element, ProElempath elem_path,
                             ProAppData app_data )
{  ProElemId  elem_id;
  ProValueData value_data;  int           ii, counter = 0;
  ProValue      *values = (ProValue *)NULL;
  ProMfgprocItem *item_array;  ProMfgprocItem item;
  ProAssembly r_solid_obj;  ProElement elem_tree_p;
    ProMdl mfg_mdl_under_test;
    status =ProMdlCurrentGet(&mfg_mdl_under_test);
  PT_TEST_LOG_SUCC("ProMdlCurrentGet");
    status = ProMfgAssemGet(mfg_mdl_under_test,&r_solid_obj);
  PT_TEST_LOG_SUCC ("ProMfgAssemGet");
    status = ProElementIdGet( element, &elem_id);
  PT_TEST_LOG_SUCC("ProElementIdGet");
      if (elem_id == PRO_E_NCSEQ_PREREQUISITE_ARR)
    {      status = ProArrayAlloc( 0, sizeof(ProValue), 1,
 (ProArray *)&values );
      PT_TEST_LOG_SUCC("ProArrayAlloc");
            status   = ProArrayAlloc( 0, sizeof(ProMfgprocItem), 1, 
(ProArray *)&item_array );
      PT_TEST_LOG_SUCC("ProArrayAlloc(");
            status = ProElementValuesGet(element, &values );
      PT_TEST_LOG_SUCC("ProArrayAlloc");
            if( status  == PRO_TK_NO_ERROR )
        status  = ProArraySizeGet( (ProArray)values, &counter );
            for( ii = 0; ii < counter; ii++ )
        {        
          if( ( ProValueDataGet( values[ii], &value_data ) == PRO_TK_NO_ERROR )
            && ( value_data.type == PRO_VALUE_TYPE_INT ) )
          {            item.type = PRO_NC_STEP_OBJECT;
            item.id  = value_data.v.i;
            item.owner  = r_solid_obj;          }
                  status = ProArrayObjectAdd((ProArray*)&item_array,-1,1,&item);
          PT_TEST_LOG_SUCC("ProArrayObjectAdd");
        }      
     status = ProMfgproctableSelecteditemsSet 
	(PRO_MFGPROCTABLE_PROCESS,item_array);
      PT_TEST_LOG_SUCC ("ProMfgproctableSelecteditemsSet");
            status =  ProMfgproctableDisplayUpdate ();
      PT_TEST_LOG_SUCC ("ProMfgproctableDisplayUpdate");
            ProArrayFree ( (ProArray *)&values );
      ProArrayFree ( (ProArray *)&item_array );
    }    return PRO_TK_NO_ERROR;
}/*--------------------------------------------------------*\
    FUNCTION : PTMfgDialogCreate 
    PURPOSE  : Creates the dialog 
\*--------------------------------------------------------*/
ProError PTMfgDialogCreate(ProElement params_element)
{    int choice;
  ProCharName str;  ProName wstr;
  status = ProUIDialogCreate(DIALOG_NAME,DIALOG_NAME);
  PT_TEST_LOG_SUCC("ProUIPTMfgDialogCreate");
    status = ProUIDialogWidthSet(DIALOG_NAME,300);
  PT_TEST_LOG_SUCC("ProUIPTMfgDialogCreate");
    status = ProUIDialogHeightSet(DIALOG_NAME,160);
  PT_TEST_LOG_SUCC("ProUIPTMfgDialogCreate");
    status = ProUIDialogTitleSet (DIALOG_NAME,L"Feed/Speed database access");
  PT_TEST_LOG_SUCC ("ProUIDialogTitleSet()");
    status = ProUILabelTextSet (DIALOG_NAME, "tool_id_val", tool_id);
  PT_TEST_LOG_SUCC ("ProUILabelTextSet()");
    status = ProUILabelTextSet (DIALOG_NAME, "material_val", material_name);
  PT_TEST_LOG_SUCC ("ProUILabelTextSet()");
  sprintf(str,"%f",cut_feed);  ProStringToWstring(wstr, str);
  ProUIInputpanelValueSet(DIALOG_NAME,"cut_feed",wstr);
  PT_TEST_LOG_SUCC("ProUIInputpanelValueSet");
  sprintf(str,"%f",spindle_speed);
  ProStringToWstring(wstr, str);  
      ProUIInputpanelValueSet(DIALOG_NAME,"spindle_speed",wstr);
  PT_TEST_LOG_SUCC("ProUIInputpanelValueSet");
  status = ProUIPushbuttonActivateActionSet

  (DIALOG_NAME, UPDATE, PTMfgUsrUpdateAction, params_element);
      PT_TEST_LOG_SUCC("ProUIPushbuttonActivateActionSet");
  status = ProUIPushbuttonActivateActionSet
  (DIALOG_NAME, CANCEL, PTMfgUsrCancelAction, NULL);
  PT_TEST_LOG_SUCC("ProUIPushbuttonActivateActionSet");
  status = ProUIDialogActivate(DIALOG_NAME, &choice);
  PT_TEST_LOG_SUCC("ProUIDialogActivate");
  status = ProUIDialogDestroy(DIALOG_NAME);
  PT_TEST_LOG_SUCC("ProUIDialogDestroy");
}
/*--------------------------------------------------------*\
    FUNCTION : PTMfgProcitemElemtreeGet 
    PURPOSE  : Gets the elem tree of selected item 
\*--------------------------------------------------------*/
 ProError  PTMfgProcitemElemtreeGet(ProElement *elem_tree)
 {   status = ProMfgproctableSelecteditemsGet 
         (PRO_MFGPROCTABLE_PROCESS,&sel_items);
   PT_TEST_LOG_SUCC ("ProMfgproctableSelecteditemsGet");
         /*TBD : Currently one one ( fitst item is checked here...
     To be updated with multiple selections of items in ui ..*/
      status = ProMfgprocitemElemtreeGet (&sel_items[0], elem_tree);
   PT_TEST_LOG_SUCC("ProMfgprocitsmElemtreeGet");
      return status;
    }
/*--------------------------------------------------------*\
    FUNCTION : PTTestMfgProcItemVisit 
    PURPOSE  : Action function for ProMfgProctableVisit 
\*--------------------------------------------------------*/
ProError PTTestMfgProcItemVisit 
  ( ProMfgprocItem* item, ProError error, 
    ProAppData app_data)
     {  ProAnnotation annotation;
  ProMfgstepHolesetEndType end_type;
  ProDrillDepthType depth_type;  
  status = ProMfgprocitemAnnotationGet (item, &annotation);
  PT_TEST_LOG_SUCC ("ProMfgprocitemAnnotationGet");
    if ( status == PRO_TK_NO_ERROR) 
    {      status = ProParameterVisit (&annotation,NULL,
               PTMfgParameterVisit,"HOLE_ADJUST");
      PT_TEST_LOG_SUCC("ProParameterVisit");
    }    if ( found == PRO_B_TRUE)
        {
      status = ProParameterVisit (&annotation,NULL,PTMfgParameterVisit,
          "HOLE_DEP_1");
      PT_TEST_LOG_SUCC("ProParameterVisit");
          status = ProParameterVisit (&annotation,NULL,PTMfgParameterVisit,
                "HOLE_DEP_2");
      PT_TEST_LOG_SUCC("ProParameterVisit");
          }
    status =  ProMfgprocitemHolesetdepthtypeGet (item,&depth_type,&end_type);
  PT_TEST_LOG_SUCC("ProMfgprocitemHolesetdepthtypeGet");
    if ((end_type == PRO_MFGSTEP_HOLESETEND_ALONG_AXIS) && 
           (depth_type ==PRO_DRILL_BLIND))
        {
            status =  ProMfgprocitemHolesetdepthSet (item ,hole_dep_1);
      PT_TEST_LOG_SUCC ("ProMfgprocitemHolesetdepthSet");
    }    if (end_type ==PRO_MFGSTEP_HOLESETEND_REFERENCE)
    {      status =  ProMfgprocitemHolesetdepthSet (item ,hole_dep_2);
      PT_TEST_LOG_SUCC ("ProMfgprocitemHolesetdepthSet");
    }    
  return PRO_TK_NO_ERROR;  
}/*--------------------------------------------------------*\
    FUNCTION :  PTMfgParameterVisit
    PURPOSE  :  Visit the param.
\*--------------------------------------------------------*/
ProError PTMfgParameterVisit(ProParameter* param, ProError status, 
    ProAppData data)
{  ProCharName str;
  ProParamvalue value;  ProParamvalueType  type;
  short   l_val;  
  ProWstringToString(str,param-id);  
  if ( strcmp (str, data) == 0)
        {      status = ProParameterValueGet (param, &value);
      PT_TEST_LOG_SUCC ("ProParameterValueGet()");
            status = ProParamvalueTypeGet (&value, &type);
      PT_TEST_LOG_SUCC ("ProParamvalueTypeGet()");
            if (type ==  PRO_PARAM_BOOLEAN)
      {        status = ProParamvalueValueGet (&value, type, (void *) &l_val);
        PT_TEST_LOG_SUCC ("ProParamvalueValueGet()");
                  if (l_val == 1)
          found  = PRO_B_TRUE;        
        }      
      if (type ==  PRO_PARAM_DOUBLE)      {
        if ( strcmp (str,"HOLE_DEP_1") == 0) 
          {            status = ProParamvalueValueGet 
                 (&value, type, (void *) &hole_dep_1);
            PT_TEST_LOG_SUCC ("ProParamvalueValueGet()");
          }        
        if ( strcmp (str,"HOLE_DEP_2") == 0) 
          {              status = ProParamvalueValueGet 
                (&value, type, (void *) &hole_dep_2);
              PT_TEST_LOG_SUCC ("ProParamvalueValueGet()");
          }        
      }    }
    return PRO_TK_NO_ERROR;
}/*--------------------------------------------------------*\
    FUNCTION :  PTMfgProcitemToolNameGet 
    PURPOSE  :  Get the tool name from elem tree.
\*--------------------------------------------------------*/
ProError PTMfgProcitemToolNameGet(ProElement elem)
{  ProElempath epath;
 ProElement tool_element;  ProElempathItem  p_items[3];
 ProElemId elem_id;  ProValueDataType value_type = -1;
 ProValue     value = (ProValue)NULL;
 ProValueData value_data;  char toolname[100];
 status = ProElemtreeWrite (elem, PRO_ELEMTREE_XML, L"selecteditem_feed.inf");
  PT_TEST_LOG_SUCC (" ProElemtreeWrite ");
    status = ProElempathAlloc(&epath);
  PT_TEST_LOG_SUCC ("ProElempathAlloc ()");
    p_items[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
  p_items[0].path_item.elem_id = PRO_E_TOOL ;
    status = ProElempathDataSet(epath, p_items, 1);
  PT_TEST_LOG_SUCC ("ProElempathDataSet()");
    status= ProElemtreeElementGet(complete_tree, epath, &tool_element);
  PT_TEST_LOG_SUCC ("ProElemtreeElementGet()");
    status = ProElementIdGet( tool_element, &elem_id);
  PT_TEST_LOG_SUCC("ProElementIdGet");
  if ( elem_id == PRO_E_TOOL )    {
      status = ProElementValueGet (tool_element, &value);
      PT_TEST_LOG_SUCC("ProElementValueGet");
            status = ProValueDataGet (value, &value_data);
      PT_TEST_LOG_SUCC("ProValueDataGet()");
            if (value_data.v.w == NULL)
          ProStringToWstring(tool_id,"TOOL_NOT_SET");
       else        ProWstringCopy(value_data.v.w,tool_id,PRO_VALUE_UNUSED);
    }  ProElempathFree(&epath);
 return PRO_TK_NO_ERROR;}
/*====================================================================*\
  FUNCTION : user_terminate()
  PURPOSE  : To handle any termination actions
\*====================================================================*/
void user_terminate(){
}
    Example 4: To Add a Submenu to the Manufacturing Process Table
    The following example enables you to add a menu and submenu to an existing menu option in the Manufacturing Process Table.
      #include <ProMenuBar.h>
  #include <ProMfgproctable.h>
  #include <ProMfg.h>
  #include <ProMdl.h>
  #include <ProMessage.h>
  #include <ProUtil.h>
  ProName submenulabel;
  ProName help;
  ProName submenubutton;
  ProError APITestCommand (ProMfg mfg, char* button_name, 
                 ProAppData appdata);
  ProStringToWstring (submenulabel, "MyNewSubmenu"); 
  ProStringToWstring (submenubutton, "SubmenuButton");
  ProStringToWstring (help, "SubmenuHelp"); 
  status = ProMfgproctableMenuAdd ( "APITestMenu",
  submenulabel, "Insert" );
  PT_TEST_LOG_SUCC("ProMfgproctableMenuAdd")
  status = ProMfgproctablePushbuttonAdd ("APITestMenu", "APITestMain",
                                          submenubutton,
  help, NULL, APITestCommand, NULL );
  PT_TEST_LOG_SUCC("ProMfgproctablePushbuttonAdd");
  ProError APITestCommand (ProMfg mfg, char* button_name, ProAppData appdata) {
    printf("Just some output\n"); 
    return PRO_TK_NO_ERROR;
     }
    Image