free c# pdf reader : Copy and paste text from pdf Library control component .net web page winforms mvc ipropertiesandparameters1-part1323

Inventor
®
API: Exploring iProperties and Parameters
11 
A common task is when you have a value you want to save as a custom property within a document.  If 
the property already exists you just want to update the value.  If the property doesn’t exist you 
want to 
create it with the correct value.  The code below demonstrates getting the volume of a part and writing it 
to a custom property named “Volume”.  With the volume as an iProperty it can be used as input for text 
on a drawing.  The portion of this macro that gets the volume and formats the result is outside the scope 
of this paper but helps to demonstrate a practical use of creating and setting the value of an iProperty. 
Public Sub UpdateVolume() 
' Get the active part document. 
Dim invPartDoc As PartDocument 
Set invPartDoc = ThisApplication.ActiveDocument 
' Get the volume of the part.  This will be returned in 
' cubic centimeters. 
Dim dVolume As Double 
dVolume = invPartDoc.ComponentDefinition.MassProperties.Volume 
' Get the UnitsOfMeasure object which is used to do unit conversions. 
Dim oUOM As UnitsOfMeasure 
Set oUOM = invPartDoc.UnitsOfMeasure 
' Convert the volume to the current document units. 
Dim strVolume As String 
strVolume = oUOM.GetStringFromValue(dVolume, _ 
oUOM.GetStringFromType(oUOM.LengthUnits) & "^3") 
' Get the custom property set. 
Dim invCustomPropertySet As PropertySet 
Set invCustomPropertySet = _ 
invPartDoc.PropertySets.Item("Inventor User Defined Properties") 
' Attempt to get an existing custom property named "Volume". 
On Error Resume Next 
Dim invVolumeProperty As Property 
Set invVolumeProperty = invCustomPropertySet.Item("Volume") 
If Err.Number <> 0 Then 
' Failed to get the property, which means it doesn't exist 
' so we'll create it. 
Call invCustomPropertySet.Add(strVolume, "Volume") 
Else 
' We got the property so update the value. 
invVolumeProperty.Value = strVolume 
End If 
End Sub 
Apprentice and Properties 
Apprentice is a programming component separate from Inventor.  It is delivered with Inventor and also as 
part of Inventor View (which is freely available at www.autodesk.com
).  Apprentice provides a small 
subset of Inventor’s capabilities 
as a component that runs within your application.  Apprentice 
doesn’t 
have a user-interface but only a programming interface.  For the information it provides access to it can 
be significantly faster than the equivalent program in Inventor.  Apprentice provides full access to 
properties.  The program below illustrates the use of Apprentice.  Apprentice cannot be used from within 
Inventor’s VBA or an Add
-
In but must be used from an exe program or from within another application’s 
VBA environment (i.e. Excel). 
Copy and paste text from pdf - extract text content from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Feel Free to Extract Text from PDF Page, Page Region or the Whole PDF File
get text from pdf c#; copy and paste text from pdf to excel
Copy and paste text from pdf - VB.NET PDF Text Extract Library: extract text content from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
How to Extract Text from PDF with VB.NET Sample Codes in .NET Application
copy text from scanned pdf to word; cut and paste text from pdf
Inventor
®
API: Exploring iProperties and Parameters
12 
One interesting difference between using Inventor and Apprentice is saving any changes you make. To 
save any changes you make in Inventor you save the document.  The Save method of the Document 
object does this.  However, when working with Apprentice 
you don’t have to save the entire document 
since 
it’s po
ssible to only save the iProperty changes to the document, which is much faster than saving 
the entire document.  The FlushToFile method of the PropertySets object saves any iProperty changes.  
The sample below demonstrates this by opening a document using Apprentice, changing a property 
value, saving the change, and closing everything.   
Public Sub ApprenticeUpdate() 
' Declare a variable for Apprentice. 
Dim invApprentice As New ApprenticeServerComponent 
' Open a document using Apprentice. 
Dim invDoc As ApprenticeServerDocument 
Set invDoc = invApprentice.Open("C:\Temp\Part1.ipt") 
' Get the design tracking property set. 
Dim invDTProperties As PropertySet 
Set invDTProperties = invDoc.PropertySets.Item("Design Tracking Properties") 
' Edit the values of a couple of properties. 
invDTProperties.Item("Checked By").Value = "Bob" 
invDTProperties.Item("Date Checked").Value = Now 
' Save the changes. 
invDoc.PropertySets.FlushToFile 
' Close the document and release all references. 
Set invDoc = Nothing 
invApprentice.Close 
Set invApprentice = Nothing 
End Sub 
Example Property Programs 
There are some associated sample programs that provide more complete examples of the various topics 
covered in this paper and provide practical examples in various programming languages of how to use 
Inventor’s programming interface.
PropertySamples.ivb 
CopyProperties 
Copies a set of properties from a selected document into the active document. 
DumpPropertyInfo 
Displays information about all of the property sets and their properties. 
Properties.xls 
An Excel file where each sheet contains a list of properties and values.  There are two Excel macros 
that are executed using the buttons on the first sheet. 
Set Properties of Active Document 
Copies the properties of the selected Excel sheet into the active 
document. 
Set Properties of Documents 
Copies the properties of the selected Excel sheet into all of the 
Inventor documents in the selected directory.  This sample uses Apprentice. 
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
C#.NET PDF Library - Copy and Paste PDF Pages in C#.NET. Easy to C#.NET Sample Code: Copy and Paste PDF Pages Using C#.NET. C# programming
extract text from pdf java; get text from pdf into excel
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Page: Extract, Copy, Paste PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Copy and Paste PDF Page. VB.NET DLLs: Extract, Copy and Paste PDF Page.
cut text pdf; extract text from pdf to excel
Inventor
®
API: Exploring iProperties and Parameters
13 
Inventor User Defined Properties, {D5CDD505-2E9C-101B-9397-08002B2CF9AE} 
Inventor Summary Information, {F29F85E0-4FF9-1068-AB91-08002B27B3D9} 
Property Name 
Id 
Id Enum 
Type 
Title 
kTitleSummaryInformation  
String 
Subject 
kSubjectSummaryInformation  
String 
Author 
kAuthorSummaryInformation  
String 
Keywords 
kKeywordsSummaryInformation  
String 
Comments 
kCommentsSummaryInformation  
String 
Last Saved By 
kLastSavedBySummaryInformation  
String 
Revision Number 
kRevisionSummaryInformation  
String 
Thumbnail 
17  kThumbnailSummaryInformation  
IPictureDisp 
Inventor Document Summary Information, {D5CDD502-2E9C-101B-9397-08002B2CF9AE} 
Property Name 
Id 
Id Enum 
Type 
Category 
kCategoryDocSummaryInformation  
String 
Manager 
14  kManagerDocSummaryInformation  
String 
Company 
15  kCompanyDocSummaryInformation  
String 
Design Tracking Properties, {32853F0F-3444-11D1-9E93-0060B03C1CA6} 
Property Name 
Id 
Id Enum 
Type 
Creation Time 
kCreationDateDesignTrackingProperties  
Date 
Part Number 
kPartNumberDesignTrackingProperties  
String 
Project 
kProjectDesignTrackingProperties  
String 
Cost Center 
kCostCenterDesignTrackingProperties  
String 
Checked By 
10  kCheckedByDesignTrackingProperties  
String 
Date Checked 
11  kDateCheckedDesignTrackingProperties  
Date 
Engr Approved By 
12  kEngrApprovedByDesignTrackingProperties  
String 
Engr Date Approved 
13  kDateEngrApprovedDesignTrackingProperties  
Date 
User Status 
17  kUserStatusDesignTrackingProperties  
String 
Material 
20  kMaterialDesignTrackingProperties  
String 
Part Property Revision Id 
21  kPartPropRevIdDesignTrackingProperties  
String 
Catalog Web Link 
23  kCatalogWebLinkDesignTrackingProperties  
String 
Part Icon 
28  kPartIconDesignTrackingProperties  
IPictureDisp 
Description 
29  kDescriptionDesignTrackingProperties  
String 
Vendor 
30  kVendorDesignTrackingProperties  
String 
Document SubType 
31  kDocSubTypeDesignTrackingProperties  
String 
Document SubType Name 
32  kDocSubTypeNameDesignTrackingProperties  
String 
Proxy Refresh Date 
33  kProxyRefreshDateDesignTrackingProperties  
Date 
Mfg Approved By 
34  kMfgApprovedByDesignTrackingProperties  
String 
Mfg Date Approved 
35  kDateMfgApprovedDesignTrackingProperties  
Date 
Cost 
36  kCostDesignTrackingProperties  
Currency 
Standard 
37  kStandardDesignTrackingProperties  
String 
Design Status 
40  kDesignStatusDesignTrackingProperties  
Long 
Designer 
41  kDesignerDesignTrackingProperties  
String 
Engineer 
42  kEngineerDesignTrackingProperties  
String 
Authority 
43  kAuthorityDesignTrackingProperties  
String 
Parameterized Template 
44  kParameterizedTemplateDesignTrackingProperties  
Boolean 
Template Row 
45  kTemplateRowDesignTrackingProperties  
String 
External Property Revision Id 
46  kExternalPropRevIdDesignTrackingProperties  
String 
Standard Revision 
47  kStandardRevisionDesignTrackingProperties  
String 
Manufacturer 
48  kManufacturerDesignTrackingProperties  
String 
Standards Organization 
49  kStandardsOrganizationDesignTrackingProperties  
String 
Language 
50  kLanguageDesignTrackingProperties  
String 
Defer Updates 
51  kDrawingDeferUpdateDesignTrackingProperties  
Boolean 
Size Designation 
52 
String 
Categories 
56  kCategoriesDesignTrackingProperties  
String 
Stock Number 
55  kStockNumberDesignTrackingProperties  
String 
Weld Material 
57  kWeldMaterialDesignTrackingProperties  
String 
VB.NET PDF copy, paste image library: copy, paste, cut PDF images
VB.NET PDF - Copy, Paste, Cut PDF Image in VB.NET. using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; VB.NET: Copy and Paste Image in PDF Page.
find and replace text in pdf file; delete text from pdf online
C# PDF copy, paste image Library: copy, paste, cut PDF images in
C#.NET PDF SDK - Copy, Paste, Cut PDF Image in C#.NET. C# Guide C#.NET Demo Code: Copy and Paste Image in PDF Page in C#.NET. This C#
extract text from pdf; extract text from pdf using c#
Inventor
®
API: Exploring iProperties and Parameters
14 
Parameters through the API
Before looking at the programming interface that provides access to the parameters lets first go through a 
brief overview of how parameters work from the perspective of an end-user, and then look at them form 
the perspective of an API user. 
Through the User-Interface 
Each part or assembly document has its own set of parameters.  You access these parameters using the 
Parameters command 
, which displays the Parameters dialog as shown below. 
Let’s look at the 
general functionality supported by all parameters. 
Parameter Name 
All parameters have a unique name.  These names are editable by the end-user 
(except for table parameters where the name is controlled by the spreadsheet).   
Unit 
All parameters have a specified unit type.  The unit type is editable for user parameters.  For table 
parameters it is controlled by the spreadsheet.  For all other types, the unit type is based on the current 
default units defined for the document. 
Equation 
The equation defines the value of the parameter.  The equation is editable by the end-user 
for all parameter types except for reference and table parameters.  The equation specified for a 
parameter must result in units that match the unit specified for that parameter.  For example, if the 
parameters a, b, and c exist and are defined to be inch units, the equation “a * b” is invalid for c because 
the resulting units of multiplying two length units together (inch) will be an area (square inches).  The 
equa
tion “a + b” is valid because the resulting unit is still a length (inch).
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
copy pdf text to word; export highlighted text from pdf
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
VB.NET PDF - Extract Image from PDF Document in VB.NET. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document in VB.NET Project.
copy text from pdf to word; get text from pdf file c#
Inventor
®
API: Exploring iProperties and Parameters
15 
Equations can also call functions.  For example “d0 * sin(d5)” is a valid equation, assuming the 
parameters d0 an d5 exist and are the correct unit type.  To find a description of all of the supported 
functions search for “functions in edit boxes” in Inventor’s online help.  All of the functions listed can be 
used within parameter equations. 
Nominal Value 
The nominal value displays the resulting value of the equation. 
Tolerance 
The tolerance setting in the Parameters dialog specifies which value to use as the model 
value within the part or assembly.  You can choose to use the nominal (which is the default), the upper, 
lower, or median value.   
Model Value 
The model value shows the resulting value after the tolerance setting has been applied to 
the nominal value.  This value will be used when recomputing the part or assembly. 
Export Parameter 
The export parameter check box defines whether this parameter is exported as an 
iProperty or not.  If checked, this parameter is exported as a custom iProperty and is also selectable 
when deriving a part. 
Comment 
The comment field allows the end-user to add a description to a parameter.  The comment is 
editable for all parameter types except for table parameters which are controlled by the spreadsheet. 
Parameter Types 
The parameters are grouped by type within the dialog.  Let’s look at each of these parameter types and 
their functionality.   
Model Parameters 
Model parameters are created automatically whenever you create something within 
Inventor that is dependent on a parameter, i.e. sketch dimensions, features, assembly constraints, 
iMates, etc.  You cannot edit the unit type or delete model parameters. 
Reference Parameters 
Reference Parameters are created automatically whenever a sketch dimension 
is created and is designated as a driven dimension.  By default, dimension constraints are driving 
dimensions.  That is, they drive or control the geometry.  By toggling a dimension constraint to be driven, 
the geometry controls it.  A reference dimension constraint can be created by placing a dimension 
constraint that will over-constrain the sketch.  A warning dialog pops up, notifying you of the problem but 
allows you to proceed with the placement of the dimension as a driven dimension.  You can also toggle 
any existing dimension constraint from driving to driven using the Driven Dimension command, 
 You 
cannot change the unit type or the equation of a reference parameter and you cannot delete a reference 
parameter.                          
User Parameters - User parameters are created by the end-user using the Add button on the Parameters 
dialog.  You have complete control over user parameters and can edit the unit and equation and can also 
delete them. 
Table Parameters 
Table parameters are created automatically whenever an Excel spreadsheet is 
linked to the parameters using the Link button on the Parameters dialog.  Each linked spreadsheet is 
listed in the parameters dialog with the parameters defined in that spreadsheet nested within that sheet in 
the Parameters dialog.  You can’t edit any of the information associated with a table parameter except to 
specify that you want to export it.  Everything else is defined the by the spreadsheet. 
C# PDF insert text Library: insert text into PDF content in C#.net
Text to PDF. C#.NET PDF SDK - Insert Text to PDF Document in C#.NET. Providing C# Demo Code for Adding and Inserting Text to PDF File Page with .NET PDF Library.
extract text from scanned pdf; extract text from pdf c#
C# PDF Text Search Library: search text inside PDF file in C#.net
Text: Search Text in PDF. C# Guide about How to Search Text in PDF Document and Obtain Text Content and Location Information with .NET PDF Control.
can't copy text from pdf; how to copy and paste pdf text
Inventor
®
API: Exploring iProperties and Parameters
16 
Parameters Programming Interface 
Now let’s look at the programming interface for parameters.  The parameter functionality is exposed 
through the Parameters object.  This object is obtained using the Parameters property of either the 
PartComponentDefinition or AssemblyComponentDefinition object as shown below. 
PartDocument
AssemblyDocument
PartComponentDefinition
AssemblyComponentDefinition
Parameters
Parameters
The VBA code shown below obtains the Parameters object.  It will work for either a part or assembly 
document. 
Dim oParameters As Parameters 
Set oParameters = ThisApplication.ActiveDocument.ComponentDefinition.Parameters 
Below is an example that displays the number of parameters in the active document.  It also incorporates 
error handling when attempting to get the Parameters object.  The other samples have omitted error 
handling to make them easier to read. 
Public Sub GetParameters() 
' Get the Parameters object.  This uses error handling and will only be successful 
' if a part or assembly document is active. 
Dim oParameters As Parameters 
On Error Resume Next 
Set oParameters = ThisApplication.ActiveDocument.ComponentDefinition.Parameters 
If Err Then 
' Unable to get the Parameters object, so exit. 
MsgBox "Unable to access the parameters.  A part or assembly must be active." 
Exit Sub 
End If 
On Error Goto 0 
' Do something with the Parameters object. 
MsgBox "The document has " & oParameters.Count & " parameters in it." 
End Sub 
Let’s look at a simple program that uses the Parameter object to change the value of a par
ameter named 
“Length”.  Although it is simple, this program demonstrates the parameter functionality that is most 
commonly used and is frequently the only parameter functionality needed for many programs. 
Public Sub SetParameter() 
' Get the Parameters object.  Assumes a part or assembly document is active. 
Dim oParameters As Parameters 
Set oParameters = ThisApplication.ActiveDocument.ComponentDefinition.Parameters 
' Get the parameter named "Length". 
Dim oLengthParam As Parameter 
Set oLengthParam = oParameters.Item("Length") 
' Change the equation of the parameter. 
oLengthParam.Expression = "3.5 in" 
' Update the document. 
ThisApplication.ActiveDocument.Update 
End Sub 
This program starts by getting the Parameters object, just as the previous sample demonstrated.  The 
Parameters object is a typical collection object.  It supports the Count property which returns the number 
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
C#.NET PDF SDK - Convert PDF to Text in C#.NET. Integrate following RasterEdge C#.NET text to PDF converter SDK dlls into your C#.NET project assemblies;
extract text from image pdf file; cut and paste pdf text
Inventor
®
API: Exploring iProperties and Parameters
17 
of items in the collection and it supports the Item property which lets you access the items within the 
collection.  The Item property will accept a Long value indicating the index of the Parameter within the 
collection you want and it will also accept a String, which specifies the name of the Parameter you want.  
When specifying the name it is case sensitive.  If the name you specify does not exist the call will fail.  In 
this example, as long as there is a parameter named “Length”, the call of the Item property will return the 
parameter and assign it to the variable oLengthParam. 
In the next line the Expression property of the Parameter object is used to set the expression.  The 
Expression property provides read and write access to the equation of the parameter.  The terms 
“Expression” and “Equation” are synonymous when working with parameters. 
The expression is set 
using a String that defines a valid equation.  The same rules apply here as when setting a parameter 
interactively in the Parameters dialog. 
Just as when you edit parameters interactively, you need to tell the model to update to see the results.  
Interactively, you run the Update command 
 In the API, the equivalent is the Update method of the 
Document object. 
Below is a chart that shows the parameter functionality and the equivalent API function.
Parameter.Name 
Ex: Parameter.Name = "Length" 
Parameter.Units 
Ex: Parameter.Units = "mm"  
Parameter.Expression 
Ex: Parameter.Expression = "Height/2 + 5 in" 
Parameter.Value 
Ex: MsgBox "Nominal Value: " & Parameter.Value & " cm" 
Parameter.ModelValueType 
Ex: Parameter.ModelValueType = kUpperValue 
Parameter.ModelValue  
Ex: MsgBox "Model Value: " & Parameter.ModelValue & " cm" 
Parameter.ExposedAsProperty 
Ex: Parameter.ExposedAsProperty = True 
Parameter.Comment 
Ex: Parameter.Comment = "This is the comment." 
There are a few new concepts to understand when working with parameters through the API versus using 
them in the user-interface.  Some of these are also general concepts that apply to other areas of the API 
as well.  Below is a discussion of some of the properties above and these new concepts. 
Expression 
We looked at the Expression property in an earlier example.  Remember that this is exactly the equivalent 
of the Equation field in the parameters dialog.  Setting the Expression property has the same rules as 
entering it manually in the parameters dialog. 
Inventor
®
API: Exploring iProperties and Parameters
18 
Value 
As shown in the chart above, the Value property is the equivalent of the Nominal Value field in the 
parameters dialog.  However, there are some differences between the Nominal Value field in the dialog 
and the Value property or the API.  First, whenever values are passed in the API, either in or out, they 
use Inventor’s internal units; 
distance values are always in centimeters
and angle values are always 
in radians
 This isn’t true of the Expression property since it is just a String that’s describing a value.  
The Value property returns a Double value and is the real internal value of that parameter after its 
expression has been evaluated.  This concept also applies when reading the ModelValue property. 
The idea of a consistent internal unit system applies throughout the entire API and is not limited to 
parameters.  For example if you get the length of a line through the API it will always be in centimeters 
regardless of the unit type the end-user has specified in the Document Options dialog. 
Another difference between the Nominal Value field in the dialog and the Value property of the API is that 
the Value property is editable.  That is you can set the parameter using a Double value instead of having 
to create a string that represents the value.  The same concept of internal units applies when setting the 
Value property; it is always in internal database units. 
Unit 
The Unit property returns a String identifying the unit type 
associated with the parameter.  The Unit property can be set 
using a String that defines a valid unit or you can use one of 
the predefined unit types in UnitsTypeEnum.  The two 
statements below are both valid and have the same result. 
Parameter.Unit = "in" 
Parameter.Unit = kInchLengthUnits 
The UnitsTypeEnum contains a list of the commonly used 
units.   It’s the same list of units that are available if you click 
on the Units field in the parameters dialog and the “Unit Type” 
dialog is displayed, as shown to the right.  The primary benefit 
of using a String is that you can define unit types that are not 
available in the enum list.  For example, square inches are 
not a predefined unit type but by specifying the string “in * in” 
or “in ^ 2” you can define square inch units.  A unit for 
a
cceleration could be defined as “(m / s) / s” or “m / (s^2)”.  
Almost any engineering unit can be defined by combining the 
predefined base units. 
Tolerance 
The Tolerance property of the Parameter object returns a Tolerance 
object.  Using this object you can get and set the various tolerance 
options for the parameter.  The Tolerance dialog shown below 
illustrates setting a tolerance for a parameter interactively.  (You 
access this dialog interactively by selecting the Equation field of a 
parameter in the Parameters dialog and clicking the arrow at the right 
of the field to select the “Tolerance…” option.)  This example sets a 
deviation type of tolerance with a +0.125/-0.0625 tolerance value.  It 
also sets the evaluated size to be the lower value and a precision of 4 
decimal places. The code below uses the Tolerance object to define 
the same tolerance.   
Inventor
®
API: Exploring iProperties and Parameters
19 
The line below sets the tolerance using Strings to define the tolerance values.  When using a String the 
unit can be defined as part of the String or it will default to the document units. 
Call oParam.Tolerance.SetToDeviation("0.125 in", "0.0625 in") 
The line below accomplishes exactly the same result but specifies the tolerances using Double values.  
When providing a Double value, instead of a String, it is always in internal units.  In this case the 
dimension is a length so it is in centimeters. 
Call oParam.Tolerance.SetToDeviation(2.54 / 8, -2.54 / 16) 
These last two lines define the number of decimal places to display for the model value and specifies that 
the lower value is to be used as the evaluated sized. 
oParam.Precision = 4 
oParam.ModelValueType = kLowerValue 
Here’s the result in the part.
Creating Parameters 
You may have noticed that so far in the discussion of the API we have not 
discussed the different types of parameters (model, user, reference, or table).  The 
code we’ve looked at deals with all parameter types as a single generic 
“Parameter” type.  The line of code shown below will work regardless of what type 
of parameter “Length” is.
Set oLengthParam = oParameters.Item("Length") 
Shown to the right is the complete object model for parameters.  The previous 
samples have just used the circled portion.  The Item property of the Parameters 
collection object provides access to all of the parameters in the document, 
regardless of their type.  Also from the Parameters collection object you can 
access other collections that contain the parameters of a specific type.  The Item 
property of those collections will return only the parameters of that specific type.  
It’s also through these type specific collections that you create new parameters.  
The sample below illustrates creating a user parameter.  Notice that it uses the 
UserParameters collection object. 
Dim oUserParams As UserParameters 
Set oUserParams = oCompDef.Parameters.UserParameters 
Dim oParam As Parameter 
Set oParam = oUserParams.AddByExpression("NewParam1", "3", _ 
kInchLengthUnits) 
ModelParameter
ModelParameters
Parameter
Parameters
ParameterTable
ParameterTables
ReferenceParameter
ReferenceParameters
TableParameter
TableParameters
UserParameter
UserParameters
CustomParameterGroup
CustomParameterGroups
Tolerance
Inventor
®
API: Exploring iProperties and Parameters
20 
The example above uses the AddByExpression method of the UserParameters collection to create a new 
par
ameter called “NewParam1”.  The value of the parameter is “3” and the units are inches.  Because the 
units are specified to be inches the value of “3” is interpreted to be 3 inches.  Below is a similar example.
Set oParam = oUserParams.AddByExpression("NewParam2", "3 in", _ 
kMillimeterLengthUnits) 
The example above uses the same method to create the parameter named “NewParam2”.  In this case 
the units are specified to be millimeters but because the expression also defines the unit, the resulting 
parameter value will still be 3 inches, but the parameter unit will be millimeters.  The code below uses the 
AddByValue method to create a new parameter. 
Set oParam = oUserParams.AddByValue("NewParam3", 3 * 2.54, kDefaultDisplayLengthUnits) 
The AddByValue method is similar to the AddByExpression method except instead of the second 
argument being a String that defines the expression of the parameter it is a Double that defines the 
parameter value using internal units.  This means that for lengths the value specified is always in 
centimeters
.  The units for AddByValue are defined just the same as they were for AddByExpression.  
However, this sample demonstrates the use of a special enum value within the UnitsTypeEnum.  The unit 
type kDefaultDisplayLengthUnits specifies that the API is to use whatever the default length unit is for the 
document.  This is the length that the user specifies in the Document Options dialog.  When you use this 
enum, or the equivalent kDefaultDisplayAngleUnits for angles, you’re not speci
fying a particular unit but 
only the type of unit; typically length or angle.  The specific unit type is picked up from the document.  
Since the value you specify is always in internal units, (centimeters or radians), it doesn’t matter to you 
what specific units the end-user has chosen to work in. 
The end result of the previous lines of code creates the parameters shown below.  The default units for 
the document are inches.  That’s why NewParam3 has the unit type “in”.
Through the user-interface you can only create user and table parameters.  (Table parameters are 
created by linking an Excel spreadsheet.)  Model and reference parameters are created automatically as 
you add dimension constraints to the model.   Through the API it is possible to create model and 
reference parameters.  They’re created the same way as user parameters except you use the Add 
methods of the ModelParameters and ReferenceParameters objects.  For most programs you will want to 
create user parameters.  Model and reference parameters are typically created by applications that want 
to expose values to the end-user with the behavior of model or reference parameters. 
Documents you may be interested
Documents you may be interested