Converting from Pro/DEVELOP
You can convert functions from Pro/DEVELOP to Creo TOOLKIT, and also mix the two styles of functions.
Using Pro/DEVELOP Applications with Creo Toolkit
Creo TOOLKIT replaces Pro/DEVELOP and provides most of the functionality that existed in Pro/DEVELOP. Existing Pro/DEVELOP applications will not become obsolete however, for the following reasons:
| • | Creo TOOLKIT inherits from Pro/DEVELOP the mechanisms by which the application C code is integrated into Creo Parametric. These mechanisms will continue to be used by Creo TOOLKIT for the indefinite future. |
| • | The complete library of Pro/DEVELOP functions is installed automatically along with the library of Creo TOOLKIT functions, and will be installed in this way from Release 2000i onwards. |
Therefore, Pro/DEVELOP applications built using Release 17 will continue to work with Pro/ENGINEER Release 18 and later, without having to be recompiled and relinked. Using Creo TOOLKIT, you can recompile and relink Pro/DEVELOP applications developed using Release 17 without having to change the source code. These applications will continue to function
as before.
However, you should plan to convert your applications to Creo TOOLKIT as soon as possible, even if you do not need to use any of the new functionality provided by Creo TOOLKIT. The conversion is desirable because Creo TOOLKIT provides more consistent and complete functionality, even in areas already well-covered by Pro/DEVELOP. In addition, PTC will give lower priority to requests for enhancements and maintenance to Pro/DEVELOP functions than to requests for equivalent Creo TOOLKIT functions, where they exist.
Thanks to the technology they share, you can use functions from both Creo TOOLKIT and Pro/DEVELOP within a single application. This means that:
| • | You can convert a Pro/DEVELOP application to use Creo TOOLKIT functions gradually. |
| • | Pro/DEVELOP applications can use the new functionality provided by Creo TOOLKIT without the immediate need for a complete conversion. |
A final reason for wanting to mix Pro/DEVELOP and Creo TOOLKIT functions is that not all of the Pro/DEVELOP functions have been replaced by equivalent Creo TOOLKIT functions.
Techniques of Conversion and Mixing
Besides a difference in the conventions they use, Pro/DEVELOP and Creo TOOLKIT reference items in the Creo Parametric database in different ways. The following sections describe the technical points to consider when you convert from Pro/DEVELOP to Creo TOOLKIT, or when you mix both types of functions in a single application.
Terminology
In general, the terminology used by Creo TOOLKIT is close to that of Pro/DEVELOP. The following table lists the most important terms that differ in meaning between the two toolkits.
|
Creo Toolkit
|
Pro/DEVELOP
|
|---|---|
|
Object
|
N/A
|
|
Model
|
Object
|
|
Solid (part or assembly)
|
Model
|
|
Surface
|
Face or surface
|
|
Component of an assembly
|
Member
|
|
Component path
|
Member identifier table (memb_id_tab)
|
|
External data
|
Generic application data
|
General Functionality
To find the functions in Creo TOOLKIT that cover a particular area of functionality, scan the section in this user’s guide, or use the Topical option in the Creo TOOLKIT browser. Beware of any difference in terminology from Pro/DEVELOP identified in the previous section.
If you want to find the Creo TOOLKIT equivalent of a particular Pro/DEVELOP function, refer to the table Equivalent Pro/DEVELOP Functions. The table maps each Pro/DEVELOP function to the closest equivalent Creo TOOLKIT function (or functions).
In some functional areas, especially where Pro/DEVELOP provided good coverage, you can use the equivalent Creo TOOLKIT functions in an identical way, although the function names, return values, and sometimes the order of the arguments have
been changed to conform to Creo TOOLKIT conventions.
For example, the following Pro/DEVELOP functions are almost exactly equivalent to the Creo TOOLKIT functions listed.
|
Pro/DEVELOP Function
|
Creo Toolkit Function
|
|---|---|
|
promenu_create()
|
ProMenuFileRegister()
|
|
promenu_expand()
|
ProMenuAuxfileRegister()
|
|
promenu_on_button()
|
ProMenubuttonActionSet()
|
Other functions require more care, however. For example, one of the conventions of Creo TOOLKIT is that the input arguments come before the output arguments.
In some areas of functionality, traditional Pro/DEVELOP techniques have been replaced in Creo TOOLKIT by techniques that are more general, flexible, and consistent with the techniques used within Creo Parametric. A good example is the visit functions, which replace two different Pro/DEVELOP techniques. For example:
|
Pro/DEVELOP Function
|
Creo Toolkit Equivalent
|
|---|---|
|
prodb_get_feature_ids()
|
ProSolidFeatVisit()
|
|
prodb_first_part_face(), prodb_next_part_face()
|
ProSolidBodySurfaceVisit()
|
It is possible to use the Creo TOOLKIT visit functions to create a utility that follows one of the Pro/DEVELOP styles. An example is shown in the section Expandable Arrays.
Some areas of Creo TOOLKIT functionality reveal a more general, and more consistent, view of the contents of the Creo Parametric database than that familiar to users of Pro/DEVELOP, and therefore require a slightly deeper understanding. For example, Creo TOOLKIT does not contain exact equivalents of the following Pro/DEVELOP functions for traversing the components of an assembly:
| • | prodb_first_member() |
| • | prodb_next_member() |
Assembly components (called “members” in Pro/DEVELOP) are represented as features in the Creo Parametric database, so these two functions can be replaced by a call to ProSolidFeatVisit(), using ProFeatureTypeGet() to identify the features of type PRO_FEAT_COMPONENT. The feature identifier for an assembly component is identical to the member identifier used in Pro/DEVELOP.
In the same way, the following Pro/DEVELOP functions that find datum planes and datum curves are also replaced by more generic functions in Creo TOOLKIT:
| • | prodb_first_datum() |
| • | prodb_next_datum() |
| • | prodb_get_datum_curves() |
Here, too, the first step is to traverse the features using ProSolidFeatVisit(). You can then traverse all the geometrical items in a feature using ProFeatureGeomitemVisit(). Datum planes are geometry items of type PRO_SURFACE, in features of type PRO_FEAT_DATUM; datum curves are geometry items of type PRO_CURVE, which can occur in features of many types.
This manual always explains the structure of the Creo Parametric database wherever necessary, without assuming any prior knowledge of the Pro/DEVELOP viewpoint. As shown in the previous examples, if you are converting a Pro/DEVELOP application that traverses Creo Parametric geometry, you should pay particular attention to the Core: 3D Geometry section.
You can use Creo TOOLKIT functions to create utilities for the specific cases you need. Many such utilities are provided in the sample code located
under the Creo TOOLKIT loadpoint.
Finally, Creo TOOLKIT covers whole new areas of functionality that were not supported at all by Pro/DEVELOP, such as the direct programmatic creation of features, including simple kinds of sketched features, datum planes, and manufacturing
features. Some Pro/DEVELOP applications, especially those that create features using user-defined features (UDFs), and which customize Manufacturing, may therefore benefit from a complete redesign to take full advantage of Creo TOOLKIT.
Registry Files
The Creo TOOLKIT registry file has the same format as the Pro/DEVELOP registry file. The search path used by Creo TOOLKIT to find the registry file is like that used by Pro/DEVELOP. However, the file name prodev.dat is now replaced by creotk.dat or protk.dat, and the configuration file option prodevdat is now either creotkdat, or protkdat, or toolkit_registry_file. To convert from Pro/DEVELOP to Creo TOOLKIT, simply substitute these names.
For an extended period, the search path for the Pro/DEVELOP registry file will continue to be used by Creo Parametric, in addition to the search path for Creo TOOLKIT. Therefore, you do not need to rename the Pro/DEVELOP registry file or configuration file option immediately.
Menu and Message Files
Although the Pro/DEVELOP functions for accessing menus and messages have been replaced by close equivalents in Creo TOOLKIT, the menu and message files themselves retain exactly the same form and function. No conversion is necessary.
Unlocking Your Application
The Creo TOOLKIT script for unlocking a finished application is named protk_unlock, but is otherwise identical to prodev_unlock.
Application Program Structure
All the Pro/DEVELOP run modes are available in identical form in Creo TOOLKIT, and the structure of a Creo TOOLKIT application is the same as that of a Pro/DEVELOP application. Some of the core functions have been given new Creo TOOLKIT-style names for the sake of consistency, but are otherwise the same. The functions user_initialize() and user_terminate() remain identical in name and purpose.
Handles and Data Types
Although Creo TOOLKIT is more rigorous than Pro/DEVELOP in the way it references objects in the Creo Parametric database, there are some close correspondences that simplify the task of mixing Pro/DEVELOP and Creo TOOLKIT functions.
As a general rule, database items referred to in Pro/DEVELOP by the type Prohandle, and referred to as OHandles (opaque handles) in Creo TOOLKIT, are pointers to the same Creo Parametric data structures. You can directly convert them by casting. The following table lists the most important examples.
|
Pro/DEVELOP Prohandle for the item type
|
Can be cast directly to the Creo Toolkit object
|
|---|---|
|
Object
|
ProMdl
|
|
Assembly
|
ProAssembly
|
|
Part
|
ProPart
|
|
Model (part or assembly)
|
ProSolid
|
|
Surface
|
ProSurface
|
|
Contour
|
ProContour
|
|
Edge
|
ProEdge
|
|
Curve
|
ProCurve
|
|
Datum quilt
|
ProQuilt
|
|
Point
|
ProPoint
|
|
Axis
|
ProAxis
|
|
Coordinate system
|
ProCsys
|
For database items that can be identified in Pro/DEVELOP by an integer identifier, that identifier is the same one generated by Creo TOOLKIT functions such as ProSurfaceIdGet() and ProEdgeIdGet(), and is the same one required as input to functions such as ProSurfaceInit(). It is also the value of the id field when one of these objects is represented as a ProGeomitem.
Converting a Pro/DEVELOP integer identifier to a Creo TOOLKIT OHandle can be done in two ways:
| • | Convert to a Prohandle within Pro/DEVELOP using pro_element_info(), then cast the resulting pointer. |
| • | Use the identifier directly as the input to the appropriate Pro*Init() function. |
The following diagrams show the possible conversion paths between Pro/DEVELOP and Creo TOOLKIT for database items.
The first diagram applies to objects of type Surface, Edge, Axis, Csys, Curve, Point, and Quilt. In each case, replace the
asterisk (*) with the appropriate name.
Pro/DEVELOP Database Item Conversion Path
The exception to the previous diagram is that the Pro/DEVELOP function pro_element_info() is not supported for coordinate system datums.
A contour does not have an integer identifier in either Pro/DEVELOP or Creo TOOLKIT, but you can convert the Pro/DEVELOP Prohandle to ProContour and back by casting.
A view does not have an integer identifier in Creo TOOLKIT, but you can convert the Pro/DEVELOP Prohandle to ProView by casting.
A vertex is represented in Pro/DEVELOP as an edge (or a curve) and a value for the parameter tof either 0 or 1. Creo TOOLKIT uses this technique in the ProSelection object, but for function inputs and in ProGeomitem it uses the specific types PRO_EDGE_START and PRO_EDGE_END (and PRO_CRV_START and PRO_CRV_END for datum curve ends). Because PRO_EDGE_START and PRO_CRV_START always refer to the end wheret = 0, conversion is easy.
A feature is represented in Creo TOOLKIT by ProFeature, which is a DHandle, and therefore not equivalent to a Pro/DEVELOP Prohandle. The integer identifier still maps directly, however.
The following diagram applies to converting features.
Feature Conversion
The following objects are DHandles, which are identical in form to ProModelitem and were identified only by an integer identifier in Pro/DEVELOP. They also inherit from ProModelitem, which means that, for example, ProSelectionModelitemGet() can be used to unpack them from a ProSelection object after calling ProSelect(). In each case, the id field in the object handle corresponds to the integer id used to identify these objects in Pro/DEVELOP.
| • | ProDimension |
| • | ProGtol |
| • | ProDtlnote |
| • | ProDtlentity |
| • | ProDtlsyminst |
| • | ProDtlsymdef |
| • | ProDtlgroup |
| • | ProDgmitem |
| • | ProNote |
Note
The objects ProDtlnote and ProNote refer to detail (drawing) notes, and notes respectively. They share the same value of the type field - PRO_NOTE - but they are distinguished by the type of their owning model.
The following diagram applies to Creo TOOLKIT objects ProSolid, ProPart, and ProAssembly when you map to Pro/DEVELOP parts and assemblies. For objects of type ProMdl that are not parts or assemblies, the integer identifiers are not applicable, but the rest of the diagram is correct.
Pro/DEVELOP Part and Assembly Mapping
Many explicit data types from Pro/DEVELOP have been carried across into Creo TOOLKIT directly, and, although they generally have been given new names, they are directly compatible. In fact, the remaining Pro/DEVELOP include files now reference the new definitions in the Creo TOOLKIT include files.
Enumerated types have also been given new names for their values, and in some cases where Pro/DEVELOP used #defined values of an integer, Creo TOOLKIT provides an enum. However, the integer mapping of the values is retained in every case. Some examples of Pro/DEVELOP data types now defined in Creo TOOLKIT are shown in the following table.
|
Pro/DEVELOP
|
Creo Toolkit
|
|---|---|
|
Ptc_surf
|
ProSurfacedata
|
|
Ptc_curve
|
ProCurvedata
|
|
Pro_linestyle
|
ProLinestyle
|
|
pro_mode
|
ProMode
|
|
Pro_text_attributes
|
ProTextAttribute
|
|
int
|
ProMousebutton
|
|
int
|
ProDrawMode
|
|
int
|
ProColortype
|
For some items that have representations in both Creo TOOLKIT and Pro/DEVELOP, the data structures are not the same, and no direct conversion is possible. However, you can always convert by reducing
such structures to their component data items. For example, to convert the Pro/DEVELOP representation of a parameter, Pro_parameter_info, to the Creo TOOLKIT ProParameter object, you can use functions such as ProParameterInit() and ProParameterValueWithUnitsSet(), using the fields in the Pro/DEVELOP structure as inputs. (In this case, it would probably be better to make a complete conversion to the Creo TOOLKIT functions, and thus avoid mixing these types in an application.)
A more complex example of this is the Pro/DEVELOP Select3d structure, whose Creo TOOLKIT counterpart is ProSelection. The following table explains the mapping by showing the fields of Select3d alongside the Creo TOOLKIT functions that extract the equivalent information from ProSelection.
|
Select3d Field
|
Creo Toolkit Read Access
|
|---|---|
|
sel_type
|
ProSelectionModelitemGet(), then read modelitem.type. See the note that follows this table.
|
|
selected_id
|
ProSelectionModelitemGet(), then read modelitem.id.
|
|
selected_ptr
|
ProSelectionModelitemGet(), then Pro*Init(), depending on the type.
|
|
select_pnt
|
ProSelectionPoint3dGet().
|
|
sel_param
|
ProSelectionUvParamGet().
|
|
sel_depth
|
ProSelectionDepthGet().
|
|
part_ptr
|
ProSelectionAsmcomppathGet(), and ProAsmcomppathMdlGet().
|
|
assembly_ptr
|
ProSelectionAsmcomppathGet(), then read comppath.owner.
|
|
memb_num
|
ProSelectionAsmcomppathGet(), then read comppath.table_num.
|
|
memb_id_tab
|
ProSelectionAsmcomppathGet(), then read comppath.comp_id_tab.
|
|
view_ptr
|
ProSelectionViewGet().
|
Note
The values of the Select3d field sel_type do not map directly to values of ProType, used in ProModelitem. Do not convert these types by direct assignment. See the next table for the mapping.
This table also makes clear what data from Pro/DEVELOP you need to build a ProSelection object in Creo TOOLKIT, using the functions ProSelectionAlloc(), ProSelectionSet(), ProSelectionUvParamSet(), and ProSelectionVerify().
There was an anomaly in selecting datum points in Pro/DEVELOP that has been corrected in Creo TOOLKIT. The selected_id is the identifier of the feature, and the datum point identifier is given by the field sel_elem_id. However, this does not carry over into Creo TOOLKIT—the ProModelitem identifier is the identifier of the datum point. (To get the feature, use the function ProGeomitemFeatureGet().)
The following table shows how the values of the sel_type field in Select3d (and the corresponding pro_select() option strings) map to values of ProType used in Creo TOOLKIT for ProModelitem and ProGeomitem objects used in Creo TOOLKIT as object handles that inherit from ProModelitem, such as ProGeomitem, ProDimension, ProGtol, ProDtlnote, and so forth.
|
pro_select() option
|
Select3d sel_type
|
ProType
|
|---|---|---|
|
point
|
SEL_3D_PNT
|
PRO_POINT
|
|
axis
|
SEL_3D_AXIS
|
PRO_AXIS
|
|
datum
|
SEL_3D_SRF
|
PRO_SURFACE
|
|
csys
|
SEL_3D_CSYS
|
PRO_CSYS
|
|
feature
|
SEL_3D_FEAT
|
PRO_FEATURE
|
|
edge
|
SEL_3D_EDG
|
PRO_EDGE
|
|
edge_end
|
SEL_3D_VERT
|
PRO_EDGE_START or PRO_EDGE_END
|
|
curve
|
SEL_3D_CURVE
|
PRO_CURVE
|
|
curve_end
|
SEL_CURVE_END
|
PRO_CRV_START or PRO_CRV_END
|
|
sldedge
|
SEL_3D_EDGE
|
PRO_EDGE
|
|
qltedge
|
SEL_3D_EDGE
|
PRO_EDGE
|
|
surface
|
SEL_3D_SRF
|
PRO_SURFACE
|
|
sldface
|
SEL_3D_SRF
|
PRO_SURFACE
|
|
qltface
|
SEL_3D_SRF
|
PRO_SURFACE
|
|
dtmqlt
|
SEL_3D_SRF_LIST
|
PRO_QUILT
|
|
part
|
SEL_3D_PART
|
PRO_PART
|
|
prt_or_asm
|
SEL_3D_PART
|
PRO_PART or PRO_ASSEMBLY
|
|
dimension
|
DTL_DIM
|
PRO_DIMENSION
|
|
ref_dim
|
DTL_REFDIM
|
PRO_REF_DIMENSION
|
|
gtol
|
DTL_GTOL
|
PRO_GTOL
|
|
dtl_symbol
|
DTL_SYMBOL
|
PRO_SYMBOL_INSTANCE
|
|
dwg_table
|
SEL_DWG_TABLE
|
PRO_DRAW_TABL
|
|
any_note
|
DTL_USER_NOTE
|
PRO_NOTE
|
|
note_3d
|
SEL_3D_NOTE
|
PRO_NOTE
|
|
dgm_obj
|
SEL_DGM_REF_OBJ
|
PRO_DIAGRAM_OBJECT
|
|
dgm_non_cable_wire
|
DTL_WIRE
|
PRO_DIAGRAM_WIRE
|
|
draft_ent
|
DTL_DRAFT_ENT
|
PRO_DRAFT_ENTITY
|
|
ext_obj
|
SEL_3D_EXT_OBJ
|
PRO_EXTOBJ
|
|
table_cell
|
SEL_TABLE_CELL
|
PRO_DRAW_TABLE_CELL
|
To minimize the need to convert between Select3d and ProSelection, follow these guidelines:
| • | If you need a Select3d as an input to a Pro/DEVELOP function, and the element referred to is to be selected interactively, use one of the Pro/DEVELOP select functions listed below instead of ProSelect() until you can convert the whole application.
|
| • | If you need to use a Pro/DEVELOP function whose output is, or contains, a Select3d, try to process the output using Pro/DEVELOP functions instead of converting to a ProSelection object where possible. For example, use pro_show_select() instead of ProSelectionHighlight(). |
To help you maintain such mixtures, the online browser retains the description of the Pro/DEVELOP selection functions and Select3d that are, strictly speaking, superseded by Creo TOOLKIT.
However, PTC recommends that you retain your documentation for Pro/DEVELOP to use with Creo TOOLKIT.