free c# pdf reader : Extract text from pdf online Library software class asp.net wpf azure ajax ipropertiesandparameters0-part1322

Inventor
®
API:  
Exploring iProperties and Parameters 
Brian Ekins 
Autodesk   
DE101-1 
This session provides an overview of how the Inventor Application Programming Interface (API) 
works. It begins with a brief introduction of some basic API concepts and then puts them into practice using 
iProperties and Parameters. iProperties and Parameters are two of the most used areas of Inventor and are 
also commonly accessed through the programming interface. The use of the API will be demonstrated and 
example programs that use these concepts will be shown. 
About the Speaker: 
Brian is a designer for the Autodesk Inventor® programming interface. He began working in the CAD industry 
over 25 years ago in various positions, including CAD administrator, applications engineer, CAD API 
designer, and consultant. Brian was the original designer of the Inventor® API and has presented at 
conferences and taught classes throughout the world to thousands of users and programmers. 
brian.ekins@autodesk.com 
Extract text from pdf online - 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
copy and paste pdf text; extract text from pdf with formatting
Extract text from pdf online - 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
extract text from pdf acrobat; copy text from pdf in preview
Inventor
®
API: Exploring iProperties and Parameters
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
image. Extract image from PDF free in .NET framework application with trial SDK components and online C# class source code. A powerful
copying text from pdf to word; copy text from pdf online
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
Extract image from PDF free in .NET framework application with trial SDK components for .NET. Online source codes for quick evaluation in VB.NET class.
copy text from locked pdf; extract text from pdf online
Inventor
®
API: Exploring iProperties and Parameters
API Terminology and Basic Concepts 
Before looking at iProperties and Parameters here’s a brief review of the various terms and concepts 
used by Inventor’s programming interface.
API 
API stands for Application Programming Interface Any application that supports driving it with a program 
has some type of API.  Inventor supports a programming interface that uses Microsoft technology called 
COM Automation
 This is the same technology that Word and Excel use for their API’s. 
If you’ve ever 
programmed them then many of the concepts you learned will transfer over when programming Inventor.  
If you haven’t programmed them, the things you learn when programming Inventor will give you a head
-
start if you do need to program them in the future. 
SDK 
SDK stands for Software Development Kit.  Many applications provide a software development kit with 
the application to help support developers that want to write programs for the application.  A software 
development kit typically consists of documentation, tools, and samples that can help you understand and 
use the application’s API.  The documentation for Inventor’s API is installed when you install 
Inventor and 
is accessible through the Help
Additional Resources
Programming Help command.  Inventor also 
pro
vides an SDK that is copied onto your disk when Inventor is installed.  You’ll need to take the extra 
step and install the SDK to have access to the additional tools and samples.  You do this by running 
Inventor 2009\SDK\DeveloperTools.msi  
Object Oriented Programming 
Object Oriented Programming is a programming methodology used by Inventor to provide its 
programming interface.  It provides a logical way of organizing an API and makes it easier to use.  Here 
are the object oriented 
terms you’ll need to 
be familiar when 
using Inventor’s API
Object 
A programming object usually represents a logical entity but can also serve to group related 
functionality
 Some examples of objects in Inventor’s API are 
the Parameter, Property, 
ExtrudeFeature, and MateConstraint objects.  Some Inventor API objects also represent more 
abstract concepts like Vector, SketchOptions, and UnitsOfMeasure.  The functionality that a particular 
object supports is exposed through its MethodsProperties, and Events.  
Here’s a non
-programming 
example to illustrate these concepts. 
Properties - A company that sells chairs might allow a customer to 
design a chair by filling out an order form like the one shown to the 
right.  The options on the order form define the various properties 
of the desired chair.  By setting the properties to the desired values 
the customer is able to describe the specific chair they want.  An 
API object has properties that let you get and set information 
associated with it.  For example, an ExtrudeFeature object 
supports the Name and Suppression properties. 
Methods - Methods are basically instructions that the object 
understands.  In the real world, these are actions you would 
perform with the chair.  For example, you could move the chair, 
cause it to fold up, or throw it in the trash.  In the programming 
world the objects are smart and instead of you performing the 
action you tell the object to perform the action itself; move, fold, and delete.   
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
C# compress PDF, C# print PDF, C# merge PDF files, C# view PDF online, C# convert PDF to tiff, C# read PDF, C# convert PDF to text, C# extract PDF pages, C#
acrobat remove text from pdf; copy text from pdf
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
file & pages edit, C#.NET PDF pages extract, copy, paste C#.NET rotate PDF pages, C#.NET search text in PDF C#.NET read barcodes from PDF, C#.NET OCR scan PDF.
extract formatted text from pdf; extract text from pdf open source
Inventor
®
API: Exploring iProperties and Parameters
Property
PropertySets
PropertySet
Parameter
Parameters
Tolerance
Application
PartDocument
PartComponentDefinition
Documents
Events 
For the chair example, events would be like adding sensors to the chair so you would be 
notified anytime anyone sat on the chair, or if it was moved.  In Inventor events notify you when 
certain things happen in Inventor. 
All objects have a defined set of methods, properties, and events.  These represent the settings, 
actions, and notifications that are associated with that object. 
Object Model 
With the type of API that Inventor uses the objects are exposed through 
something known as the Object Model or Object Hierarchy The object 
model provides Inventor objects in a structured, organized way.  The object 
model typically defines the parent-child relationships between objects.  To 
access a specific object you need to first access some object within the object 
model.  From that object you can them move through the hierarchy to get to the 
specific object you want. 
The picture to the right shows the object model for the commonly used objects 
associated with parameters and iProperties.  You’ll typically 
gain access to the 
object model through the Application object and then traverse from object to object 
to get to the specific object you want.  
You’ll see examples of this later.
Object Browser 
The Object Browser is a tool within VBA that allows you 
to see all of the objects, methods, properties, and events 
for Inventor’s AP
I.  For the methods, properties, and 
events, it also shows you the arguments and for 
properties indicates if the property is read-write or read-
only.  This is a very useful tool when using Inventor’s 
API.  
You can access the Object Browser from Inventor’s 
VBA environment by pressing the F2 key.  You open the 
VBA environment by pressing Alt+F11. 
The Object Browser is also a convenient entry to 
Inventor’s programming help since it is cont
ext sensitive.  
You can pick any object, method, property, or event in 
the browser and press F1 and it will open the help window for the selected item. 
Collection Objects 
A Collection is a special type of object that provides access to a group of other objects.  To support this 
capability all collections have the following two properties; Count and Item. The Count property tells you 
how many objects are in the collection.  The Item property returns an item from the collection.  You can 
always specify which item to return by using its index within the collection and some collections also let 
you specify the item by name.  An example of a collection object is the Parameters object.  Through this 
object you have access to all of the parameters within a document.  You’ll see examples of the use of 
collection objects later in this paper. 
What Development Environment to Use?
To write a program you need to use some type of programming language.  There are many choices out 
there and they all have various advantages and disadvantages.  
If you’re new to programming or 
VB.NET PDF - Convert PDF Online with VB.NET HTML5 PDF Viewer
C# compress PDF, C# print PDF, C# merge PDF files, C# view PDF online, C# convert PDF to tiff, C# read PDF, C# convert PDF to text, C# extract PDF pages, C#
extract highlighted text from pdf; c# extract pdf text
VB.NET PDF - Annotate PDF Online with VB.NET HTML5 PDF Viewer
VB.NET HTML5 PDF Viewer: Annotate PDF Online. This part will explain the usages of annotation tabs on RasterEdge VB.NET HTML5 PDF Viewer. Text Markup Tab. Item.
copy paste text pdf file; copy pdf text to word document
Inventor
®
API: Exploring iProperties and Parameters
Inventor’s API,
I wou
ld recommend using Inventor’s VBA (Visual Basic for Applications).  VBA comes free 
with Inventor and is easier to use than any of the other languages for programming Inventor.  
Here’s just 
enough of an introduction to VBA that you can try out the programs shown later. 
To open the VBA interface you must first have Inventor running and then you can either press Alt+F11 or 
use the Tools
Macro
Visual Basic Editor command.  
There’s a default VBA project created that you 
will typically write your programs in that
’s called “ApplicationProject”.  The project window shows the 
available projects and their contents.  Expand the tree so you can see Module1 and double-click on it, as 
shown below.  That will open the code window so you can begin programming. 
To make things a little smoother I would also recommend changing a couple of the VBA settings.  In VBA 
run the Tools
Options command and change the Auto Syntax Check and Require Variable 
Declaration settings as shown below. 
Accessing Documents in the API
To do anything with Inventor’s API you need to gain access to the object that 
supports the functionality you want.  If you look at the object model diagram to 
the right you’ll notice that properties and parameters are both under the 
PartDocument object.  To access parameters or properties you need to first 
gain access to the document that contains them. 
There are actually several different types of document objects with 
PartDocument, AssemblyDocument, and DrawingDocument being the most 
common types.  There is another type called the Document object that is a 
special kind of object that can represent any of the other document types.  
Using the Document object is very convenient in many programs because it 
allows a single program to handle any type of document without requiring you 
to special case for each specific type of document. 
Property
PropertySets
PropertySet
Parameter
Parameters
Tolerance
Application
PartDocument
PartComponentDefinition
Documents
C# HTML5 PDF Viewer SDK to annotate PDF document online in C#.NET
C# HTML5 PDF Viewer: Annotate PDF Online. This part will explain the usages of annotation tabs on RasterEdge C#.NET HTML5 PDF Viewer. Text Markup Tab. Item. Name
copy text from protected pdf to word; extract text from pdf file using java
C# HTML5 PDF Viewer SDK to convert and export PDF document to
C# compress PDF, C# print PDF, C# merge PDF files, C# view PDF online, C# convert PDF to tiff, C# read PDF, C# convert PDF to text, C# extract PDF pages, C#
a pdf text extractor; extracting text from pdf
Inventor
®
API: Exploring iProperties and Parameters
Before looking specifically at propert
ies and parameters, let’s look at some 
of the most common ways of 
accessing documents using Inventor’s programming interface.
Get the Document the end-user is editing 
The most common technique for getting a document is to get the document the end-user is currently 
editing.  This is also the easiest since the Application object provides direct access to this document 
through its ActiveDocument property.   
Public Sub GetActiveDocumentSample() 
' Get the active document. 
Dim oDoc As Document 
Set oDoc = ThisApplication.ActiveDocument 
MsgBox "Got " & oDoc.FullFileName 
End Sub 
Opening an existing Document 
You can use the API to open an existing document.  The Document object that represents the document 
just opened is returned. 
Public Sub OpenDocumentSample() 
' Open an existing document from disk. 
Dim oDoc As Document 
Set oDoc = ThisApplication.Documents.Open("C:\Temp\Part.ipt", True) 
' Call a property of the Document to show its name. 
MsgBox "Opened " & oDoc.FullFilename 
End Sub 
Create a new document 
New documents are created using the Add method of the Documents collection.  You specify the type of 
document and the template to use.  You can use the GetTemplateFile method to get the default template 
filename.  This is demonstrated below. 
Public Sub CreateDocumentSample() 
' Create a new part document using the default template. 
Dim oDoc As Document 
Set oDoc = ThisApplication.Documents.Add(kPartDocumentObject, _ 
ThisApplication.FileManager.GetTemplateFile(kPartDocumentObject)) 
MsgBox "Created " & oDoc.DisplayName 
End Sub 
iProperties Through the API
Through the User-Interface
Before looking at the programming interface for iProperties let’s do a quick review of iProperties from an 
end-user perspective.  iProperties are accessed through the iProperties dialog.  There are several tabs at 
the top that organize the available properties.  There are also some tabs on this dialog that are not 
actually iProperties.  For example, the General tab provides access to information about the document, 
the Save tab provides options that control how the thumbnail image is captured, and the Physical tab 
provides the various physical properties of the part or assembly document.  If you need access to this 
information it is available through the API but not through the 
iProperties portion of the API that we’re 
discussing here. 
Inventor
®
API: Exploring iProperties and Parameters
iProperties are accessed through the Properties dialog as shown below.  The various properties are 
organized by tabs.  The picture below on the left illustrates a typical tab of the Properties dialog where 
you have access to a specific set of properties.  The set of iProperties shown on each tab are predefined 
and cannot be changed.  However, using the Custom tab (shown in the picture on the right) you can add 
additional properties to the document.  This allows you to associate any information you want with the 
document. 
Through the API 
The object model for iProperties is shown to the right.  As discussed 
earlier, properties are owned by documents and to get access to 
properties you go through the document that owns them. 
Property Naming 
Even though the programming interface for iProperties is simple, people 
still tend to struggle with it.  I believe this is primarily because of not 
knowing how to access a specific property.  Before discussing 
iProperties in detail, a brief discussion of naming is appropriate to help 
describe the concepts Inventor uses.  The picture to the right shows a 
person and three different ways to identify this person.  His full legal 
name is a good way to identify him, although a bit formal.  His social 
security number is good, but not very user friendly.  His nickname, 
although 
commonly used, can have problems since it’s not as likely to 
be unique and Bill could change it.  The point is that there are three 
ways to identify this person, each one with its own pros and cons.
Like Bill, iProperties also have several names.  Understanding this single concept should help you 
overcome most of the problems other people have had when working with iProperties.  The various 
iProperty objects, their names and best use suggestions are described below. 
PropertySets Objects 
The PropertySets obj
ect serves as the access point to iProperties.  The PropertySets object itself doesn’t 
have a name but is simply a collection object that provides access to the various PropertySet objects.  
Using the Item method of the PropertySets object you specify which PropertySet object you want.  The 
Item method accepts an Integer value indicating the index of the PropertySet object you want, but more 
important, it also accepts the name of the PropertySet object you want.  The next section discusses 
PropertySet objects and their various names. 
Legal Name:  
William Harry Potter 
Nickname: Bill 
SSN: 365-58-9401 
Property
PropertySets
PropertySet
Application
Document
Documents
Inventor
®
API: Exploring iProperties and Parameters
PropertySet Objects 
The PropertySet object is a collection object and provides access to a set of iProperties.  The PropertySet 
object is roughly equivalent to a tab on the Properties dialog.   The Summary, Project, Status, and 
Custom tabs of the dialog contain the iProperties that are exposed through the programming interface. 
There are four PropertySet objects in an Inventor document; Summary Information, Document Summary 
Information, Design Tracking Properties, and User Defined Properties. 
PropertySet objects are named as a way to identify a particular PropertySet object.  A PropertySet object 
has three names; Name, Internal Name, and Display Name.  Using the previous analogy of Bill, the Name 
is equivalent to his legal name, the Internal Name is equivalent to his social security number, and the 
Display Name is equivalent to his nickname.  Let’s look at a specific example to illustrate this.  There is a 
PropertySet object that has the following names: 
Name: Inventor Summary Information 
Internal Name: {F29F85E0-4FF9-1068-AB91-08002B27B3D9} 
DisplayName: Summary Information 
Any one of these can be used as input to the Item method in order to get this particular PropertySet 
object.  I would suggest always using the Name for the following reasons.  The Name cannot be changed, 
is guaranteed to be consistent over time, and is an English human readable string.  The Internal Name 
cannot be changed and will remain consistent but it is not very user-friendly and makes your source code 
more difficult to read.  The Display Name is not guaranteed to remain constant.  The Display Name is the 
localized version of the name and will change for each language.  A chart showing the names of the four 
standard PropertySet objects is on page 13 of this paper. 
Below is an example of obtaining one of the PropertySet objects.  In this case the summary information 
set of iProperties. 
Public Sub GetPropertySetSample() 
' Get the active document. 
Dim invDoc As Document 
Set invDoc = ThisApplication.ActiveDocument 
' Get the summary information property set. 
Dim invSummaryInfo As PropertySet 
Set invSummaryInfo = invDoc.PropertySets.Item("Inventor Summary Information") 
End Sub 
Property Objects 
A Property object represents an individual property.  Each Property object also has three names; Name, 
Display Name, and ID.  Many of the same principles discussed for PropertySet objects applies here.  The 
Name is an English string that is guaranteed to remain constant.  The Display Name is the localized 
version of the Name and can change, so it’s not a reliable method of accessing a particular property.  The 
ID is a number and is similar to the Internal Name of the PropertySet object, but is a simple Integer 
number instead of a GUID.  I would recommend using the name of the property to access a specific one.  
Below is an example of the three identifiers for a particular property. 
Name: Part Number 
DisplayName: Part Number 
ID: 5 or kPartNumberDesignTrackingProperties 
Inventor
®
API: Exploring iProperties and Parameters
The following code gets the iProperty that represents the part number. 
Public Sub GetPropertySample() 
' Get the active document. 
Dim invDoc As Document 
Set invDoc = ThisApplication.ActiveDocument 
' Get the design tracking property set. 
Dim invDesignInfo As PropertySet 
Set invDesignInfo = invDoc.PropertySets.Item("Design Tracking Properties") 
' Get the part number property. 
Dim invPartNumberProperty As Property 
Set invPartNumberProperty = invDesignInfo.Item("Part Number") 
End Sub 
You may see program samples that use identifiers like kPartNumberDesignTrackingProperties to specify 
a specific property.  These identifiers are defined in the Inventor type library and provide a convenient 
way of specifying the ID of a property.  For the part number, instead of specifying the ID as 5 you can use 
kPartNumberDesignTrackingProperties.  This makes your code more readable.  If you want to use the ID 
instead of the Name you need to use the ItemByPropId property instead of the standard Item property of 
the PropertySets object.  For consistency I would recommend using the Name in both cases. 
Now that we have a reference to a specific property we can use its programming properties to get and set 
the value.  The Property object supports a property called Value that provides this capability.  For 
example, the line below can be added to the previous sample to display the current part number. 
MsgBox "The part number is: " & invPartNumberProperty.Value 
This next line sets the value of the part number iProperty. 
invPartNumberProperty.Value = "Part-001" 
The Value property uses an interesting programming feature that is useful to understand when working 
with iProperties.  The Value property is of type Variant.  A Variant is a special type that can represent 
almost any other type.  For example, a Variant can hold a String, Double, Date, Object, or most any other 
type.  iProperties take advantage of this since they allow the value to be one of many different types.  You 
see this when working with custom (user defined) properties, as shown in the picture below.  When 
creating or modifying a custom iProperty you define the type; Text, Date, Number, or Yes or No.  This 
results in an iProperty being created where the value contains a String, Date, Double, or Boolean value. 
When s
etting the value of any of Inventor’s predefined iProperties, Inventor forces them to be the correct 
type and will convert them automatically, when possible.  If you supply a value that can’t be converted to 
the expected type, it will fail.  In the table on page 13 of this paper, the type of each property is listed.  
Most of the standard iProperties are Strings, with a few Date, Currency, Boolean, and Long values.  
Inventor
®
API: Exploring iProperties and Parameters
10 
There is also one other type called IPictureDisp.  This type is used for the thumbnail picture associated 
with a document.  Using this you can extract and set the thumbnail picture for a document. 
Creating Properties 
When you create custom iProperties using the Properties dialog, as shown in the previous picture, you 
specify the type of property y
ou’re going to create; Text, Date, Number, or Yes or No.  When you create 
them using Inventor’s programming interface you don’t explicitly specify the type but it is implicitly 
determined based on the type of variable you input. 
New iPropertiies can only be created within the Custom (user defined) set of properties.  New iProperties 
are created using the Add method of the PropertySet object.  The sample below illustrates creating four 
new iProperties, one of each type. 
Public Sub CreateCustomProperties() 
' Get the active document. 
Dim invDoc As Document 
Set invDoc = ThisApplication.ActiveDocument 
' Get the user defined (custom) property set. 
Dim invCustomPropertySet As PropertySet 
Set invCustomPropertySet = invDoc.PropertySets.Item( _ 
"Inventor User Defined Properties") 
' Declare some variables that will contain the various values. 
Dim strText As String 
Dim dblValue As Double 
Dim dtDate As Date 
Dim blYesOrNo As Boolean 
' Set values for the variables. 
strText = "Some sample text." 
dblValue = 3.14159 
dtDate = Now 
blYesOrNo = True 
' Create the properties. 
Dim invProperty As Property 
Set invProperty = invCustomPropertySet.Add(strText, "Test Test") 
Set invProperty = invCustomPropertySet.Add(dblValue, "Test Value") 
Set invProperty = invCustomPropertySet.Add(dtDate, "Test Date") 
Set invProperty = invCustomPropertySet.Add(blYesOrNo, "Test Yes or No") 
End Sub 
Documents you may be interested
Documents you may be interested