// CONTENT OF THE FILE DEVELOP.H

#ifndef DEVELOP_H

#define DEVELOP_H

extern "C"{  // extern directive because I want to work with C++

                   //   since Pro/TOOLKIT stuff is all written in C it

                   // must be designated as C code

      #include <ProToolkit.h>

      #include <ProUtil.h>

      #include <ProMenu.h>

      #include <ProMenuBar.h>

      #include <ProMessage.h>

      #include <ProWindows.h>

      #include <ProSurface.h>

      #include <ProSelection.h>

      #include <ProGeomitem.h>

      #include <ProGraphic.h>

      #include <ProGeomitemdata.h>

      #include <UtilCollect.h>

      #include <ProUdf.h>

      // these 2 function must always be decreated and

      // defined in your Pro/TOOLKIT dll application

      int user_initialize(int argc,char ** argv);

      void user_terminate();

}

static ProName dev_msg;

// this macro will be a time saver

#define MSGFILE  ProStringToWstring(dev_msg,"develop_msg.txt")

//udf function

void user_place_udf();

#endif

// CONTENT OF THE FILE UDF.CPP

#include "develop.h"

#include <string>

#include <vector>

using namespace std;

ProError add_ref(ProMdl handle,int item_id,

                         ProType item_type,

                         ProBoolean ref_bool,

                         char * c_prompt,

                         ProUdfdata udf_data){

      ProModelitem modelitem;

      ProSelection selection;

      ProLine prompt;

      ProUdfreference reference;

      ProError err;

      err=ProModelitemInit(handle,item_id,item_type,&modelitem);

      if(PRO_TK_NO_ERROR != err) goto error;

      err=ProSelectionAlloc(NULL,&modelitem,&selection);

      if(PRO_TK_NO_ERROR != err) goto error;

      ProStringToWstring(prompt,c_prompt);

      err=ProUdfreferenceAlloc(prompt,selection,ref_bool,&reference);

      if(PRO_TK_NO_ERROR != err) goto error;

      err=ProUdfdataReferenceAdd(udf_data,reference);

      if(PRO_TK_NO_ERROR != err) goto error;

      err=ProSelectionFree(&selection);

error:

      return err;

}

void user_place_udf(){

      ProError err_acomps,err,err_csys;

      ProAsmcomp *asm_comps;

      int n_asm_comps,plate_feat_id,n_csys;

      ProFamilyName mdl_name;

      char c_mdl_name[PRO_FAMILY_NAME_SIZE],c_name[PRO_FAMILY_NAME_SIZE];

      ProMdl asmbly,plate;

      ProMdlType mdl_type;

      ProUdfdata udf_data;

      char prof_name[]="bos";

      ProLine w_name,w_string;

      ProUdfvardim vardim;

      ProFeature f_top_plane;

      ProGeomitem g_top_plane;

      ProIdTable comp_id_table;

      ProAsmcomppath comp_path;

      ProGroup udf;

      ProCsys     *p_csys;

      vector<int> csys_ids;

      ProMdlCurrentGet(&asmbly);  // the main assembly handle

      err_acomps = ProUtilCollectAsmcomp((ProAssembly) asmbly,&asm_comps);

      ProArraySizeGet ((ProArray)asm_comps, &n_asm_comps);

    for (int i=0; i<n_asm_comps; i++)

    {

        ProAsmcompMdlNameGet (& (asm_comps[i]), &mdl_type, mdl_name);

            ProWstringToString(c_mdl_name,mdl_name);

            string stl_mdl_name(c_mdl_name);

            string::size_type pos = stl_mdl_name.find("PLATE");

            if(pos != string::npos){ //found

                  ProMessageDisplay(MSGFILE, "DEVUSER %0s", c_mdl_name);

                  ProMessageClear();

                  ProAsmcompMdlGet((ProAsmcomp *) &(asm_comps[i]), &plate);  // our plate

                  plate_feat_id = asm_comps[i].id;

                  break;

            }

      }

      err = ProUtilFindFeatureByName((ProSolid)plate,ProStringToWstring(w_string,"TOP"),&f_top_plane);

      err = ProUtilFindFeatureGeomitemByName(&f_top_plane,PRO_SURFACE ,ProStringToWstring(w_string,"TOP"),&g_top_plane);

      err_csys = ProUtilCollectSolidCsys((ProSolid)asmbly,&p_csys);

      ProArraySizeGet ((ProArray)p_csys, &n_csys);

      for (int i=0; i<n_csys; i++)

    {

            ProModelitem mitem;

            ProFeature feature;

            string::size_type pos;

            ProCsysToGeomitem((ProSolid)asmbly,p_csys[i],&mitem);

            ProGeomitemFeatureGet(&mitem,&feature);

            ProModelitemNameGet(&feature,w_name);

            ProWstringToString(c_name,w_name);

            string stl_name(c_name);

            pos = stl_name.find("ACS");

            if(pos != string::npos){  // FOUND

                  csys_ids.push_back(mitem.id);

            }

      }

      double Yradius = .2, Xradius = .4;

      for (unsigned int i = 0; i<csys_ids.size(); i++){

            err = ProUdfdataAlloc(&udf_data);

            err = ProUdfdataNameSet(udf_data,ProStringToWstring(w_string,prof_name),NULL);

            err = ProUdfdataDependencySet(udf_data,PROUDFDEPENDENCY_INDEPENDENT);

            err = ProUdfdataScaleSet(udf_data,PROUDFSCALETYPE_SAME_DIMS,0);

            err = ProUdfdataDimdisplaySet(udf_data,PROUDFDIMDISP_NORMAL);

            add_ref(asmbly,csys_ids[i],PRO_CSYS,PRO_B_TRUE,"coordinate system",udf_data);

            add_ref(plate,g_top_plane.id,PRO_SURFACE,PRO_B_FALSE,"top plane",udf_data);

            ProUdfvardimAlloc(ProStringToWstring(w_string,"Yradius"),Yradius,PROUDFVARTYPE_DIM,&vardim);

            ProUdfdataUdfvardimAdd(udf_data,vardim);

            ProUdfvardimAlloc(ProStringToWstring(w_string,"Xradius"),Xradius,PROUDFVARTYPE_DIM,&vardim);

            ProUdfdataUdfvardimAdd(udf_data,vardim);

            for (int j=0; j<4; j++)

                  err=ProUdfdataOrientationAdd(udf_data,PROUDFORIENT_NO_FLIP);

            comp_id_table[0]=plate_feat_id;

            ProAsmcomppathInit( (ProSolid) plate, comp_id_table, 1, &comp_path);

            err=ProUdfCreate((ProSolid)plate,udf_data,&comp_path,NULL,0,&udf);

            err=ProUdfdataFree(udf_data);

      }

      ProWindowRepaint(PRO_VALUE_UNUSED);

      // clean up

      if (PRO_TK_NO_ERROR == err_acomps) ProArrayFree ((ProArray*)&asm_comps);

      if (PRO_TK_NO_ERROR == err_csys ) ProArrayFree ((ProArray*)&p_csys);

}