how to upload pdf file in database using c# : Search a pdf file for text application SDK utility html .net web page visual studio PrecisionTreeAutomationGuide0-part772

Automating PrecisionTree with VBA 
The purpose of this document is to introduce PrecisionTree’s Excel Developer Kit (XDK) and explain how 
you can use V A to automate PrecisionTree. The term “automate” simply means that you write a 
program in VBA to make PrecisionTree do what you normally do through the PrecisionTree user 
interface. For example, suppose you often need to build a decision tree with a particular structure and 
then perform sensitivity analysis on its key inputs. This requires a considerable number of steps—
virtually the same steps—each time you do it. Wouldn’t it be nice to click a button and have all of these 
steps magically happen? This is exactly the type of thing you will learn how to do with the PrecisionTree 
Introduction to VBA
Visual Basic for Applications, or VBA, is the programming language for Excel. It is also the programming 
language for other applications in Microsoft Office: Word, PowerPoint, and Outlook, for example. It is 
even the programming language for some non-Microsoft products. To understand how this works, it 
helps to separate the name V A into two parts: “Visual  asic” and “for Applications.” You can think of 
Visual  asic, or V , as the “backbone” programming language. It contains programming elements that all 
programmers use, regardless of the programming language or the type of development task. For 
example, it contains subroutines, variable types, logical constructs such as If-Then-Else, loops for 
repetitive tasks, arrays for storing lists, and much more. Actually, there are non-VBA versions of VB. For 
example, you might be familiar with VB6 or VB.NET. All of these versions of VB, including VBA, are 
extremely popular because VB is fairly easy to learn and quite powerful. In any case, to learn VBA for 
Excel or PrecisionTree, you must first learn the backbone VB language. 
The following is a typical segment of VB code. Even if you know nothing about programming, you will 
probably have little trouble understanding what this code accomplishes. Again, this is the attraction of 
VB. It is relatively easy to learn and understand. Note the lines that begin with an apostrophe. These 
lines are called comments. They are ignored by VBA when the program runs, but they are very useful for 
Sub Invoice() 
' Declare variables. 
Dim nProducts As Integer, i As Integer 
Dim total As Currency, subTotal As Currency 
Dim nPurchased As Variant, unitPrice As Variant 
' Define constants for this business. 
Const taxRate = 0.06 
Const cutoff1 = 50, cutoff2 = 100 
Const discount1 = 0.05, discount2 = 0.1 
' Enter information about this order 
nProducts = 4 
nPurchased = Array(5, 2, 1, 6) 
unitPrice = Array(20, 10, 50, 30) 
total = 0 
' Loop over all products purchased. 
For i = 1 To nProducts 
' Calculate revenue, including possible discount, for this product. 
1 If you are already familiar with V V A for Excel, you can skip to the section “Introduction to the PrecisionTree XDK” 
on page 5. 
Search a pdf file for text - search text inside PDF file in, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
find and replace text in pdf file; cannot select text in pdf file
Search a pdf file for text - VB.NET PDF Text Search Library: search text inside PDF file in, ASP.NET, MVC, Ajax, WinForms, WPF
Learn How to Search Text in PDF Document and Obtain Text Content and Location Information in VB.NET application
search text in multiple pdf; how to make a pdf file text searchable
subTotal = nPurchased(i) * unitPrice(i) 
If subTotal >= cutoff2 Then 
subTotal = (1 - discount2) * subTotal 
ElseIf subTotal >= cutoff1 Then 
subTotal = (1 - discount1) * subTotal 
End If 
' Add to total for this order. 
total = total + subTotal 
' Add tax. 
total = (1 + taxRate) * total 
' Display result. 
MsgBox "The total for this order, including tax, is " & Format(total, "$#,#00.00") 
End Sub 
If you run this code in Excel, you will see the display (a message box) in Figure 1. 
Figure 1 Result of VBA Program 
Subroutines, Programs, and Macros 
Before proceeding, it is useful to discuss three terms you often hear: subroutine, program, and macro. A 
subroutine is any section of code that begins with the keyword Sub and ends with the keyword End Sub. 
Its purpose is typically to perform one specific task. A program is a collection of one or more related 
subroutines that achieves an overall goal. In practice, long programs are often broken up into smaller 
subroutines for enhanced readability and easier debugging. A macro is essentially the same as a 
program, and it is the term favored by many Excel programmers. However, if your programs are 
relatively short, consisting of a single subroutine, the terms subroutine, program, and macro are 
practically synonymous and are often used interchangeably. 
Object Models 
The above Invoice subroutine can be run in Excel, but it really has nothing to do with Excel. There are no 
references to ranges, formulas, worksheets, charts, or other items you use in Excel. The code is pure VB. 
ut now we come to the “for Applications” part of V A. All of the familiar items in Excel, which will now 
be called objects, are part of an object model that Excel provides to programmers through VBA. This 
means that you as a programmer can reference these objects in your VBA code. In short, this object 
model allows you to “make things happen” through V A code, rather than through the usual Excel user 
interface. In this way, you can automate Excel with VBA. 
So what does an object model, or Excel’s object model in particular, look like? At the top level, it is 
simply a list of things—objects—that the software contains. Excel’s object model is quite large because 
everything you see in Excel is an object. One of the most common objects is the Range object: any range 
of cells (including a single cell). But there are over a hundred more objects, including the Worksheet 
object, the Chart object, the PivotTable object, and so on. There are also singular and plural objects. For 
C# Word - Search and Find Text in Word
PDF to text, C#.NET convert PDF to images, C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET search text in
text searchable pdf file; convert pdf to searchable text online
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Embedded print settings. Embedded search index. Bookmarks. Flatten visible layers. VB.NET Demo Code to Optimize An Exist PDF File in Visual C#.NET Project.
search text in pdf image; search pdf for text in multiple files
example, there is the plural Worksheets object, the collection of all worksheets in an Excel workbook, 
and there is the singular Worksheet object, a particular worksheet in the workbook.  
Figure 2 displays a partial list of the objects in Excel, plural (yellow) and singular (blue). 
Figure 2 Excel Object Model 
However, there is much more to an object model than the list of its objects. First, there is a hierarchy 
among many objects.  asically, this means that you often need to “drill down” to get to the object you 
want. A good example is a Range object, such as cell B3. The idea is that a range is contained in a 
worksheet, which is contained in a workbook. So the hierarchy is WorkbookWorksheetRange, and 
the following line of code is typical: 
C# PDF delete text Library: delete, remove text from PDF file in
option). Description: Delete specified string text that match the search option from PDF file. Parameters: Name, Description, Valid Value.
text searchable pdf; find text in pdf image
C# PowerPoint - Search and Find Text in PowerPoint
PDF to text, C#.NET convert PDF to images, C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET search text in
pdf find highlighted text; converting pdf to searchable text format
ActiveWorkbook.Worksheets(“Costs”).Range(“B3”).Value = 10 
You read this as: Starting in the active workbook, go to cell B3 of the worksheet named Costs, and enter 
the value 10. This concept of hierarchy is crucial to learning VBA for Excel or PrecisionTree. 
Second, most objects have properties and methods.
(Methods are also called functions.) If you think of 
objects as nouns, then you can think of properties as adjectives and methods as verbs. Properties 
describe an object, and methods indicate what you can do to, or with, an object. For example, a Range 
object has a Value property, which was used in the above line of code. Similarly, a Font object has a 
Color property, a Size property, and many others. A typical object with methods is the Worksheet 
object. It has a Delete method, a Move method, and a few others. 
Although less common, many objects also have events that they respond to. A good example is the 
Open event of a Workbook object. This event occurs—it “fires”—when you open the workbook. VBA 
allows you to write event handlers for the event. This is code that is executed when the event fires. 
As you begin VBA programming for Excel, you gradually learn the most common objects, the hierarchies 
between them, their most common properties, methods, and events, and the syntax for using these in 
VBA code. It takes practice and perseverance, but if you want to make Excel “sing and dance” with the 
click of a button, this is time well spent. 
By now, you should be starting to see the big VBA picture. Just as the Excel application can be 
automated through its object model, other applications can be automated through their object models. 
Microsoft Word is a typical example. Its objects are not the same as Excel’s. Instead of Worksheet, 
Range, and other typical Excel objects, Word has Sentence, Paragraph, and other objects that are useful 
in word processing, and these objects have their own hierarchies, properties, methods, and events. 
Fortunately, if you already know VBA for Excel and you want to learn VBA for Word, all you need to 
learn is the object model for Word. The backbone VB language is exactly the same in both applications. 
Admittedly, it is not a trivial task to learn a new application’s object model, but knowing V  for one 
application, like Excel, provides a big head start for learning VB for another application, like Word. 
Using the Visual Basic Editor (VBE) 
You will be doing all of your programming in the Visual Basic Editor (VBE). The easiest way is to open 
VBE from Excel is to press Alt+F11. Alternatively, if the Excel Developer tab is visible, you can click the 
Visual Basic button on its ribbon. The VBE window appears in Figure 3. In particular, the Project pane on 
the left shows a list of all open workbooks. (To get back to the Excel window, you can click the Excel icon 
on the toolbar below the menu bar.) 
C# PDF File Compress Library: Compress reduce PDF size in
size, images size reducing can help to reduce PDF file size effectively. will also take up too much space, glyph file unreferenced can be Embedded search index.
pdf search and replace text; how to select text in a pdf
C# PDF replace text Library: replace text in PDF content in
Replace old string by new string in the PDF file. option, The search and replace match rules. Description: Delete specified string text that match the search
find text in pdf files; search text in pdf using java
Figure 3 Visual Basic Editor 
As you can see in the figure, the selected file contains a module. You will write all of your code in 
modules. (Actually, there are exceptions to this, but they aren’t discussed here.)  y default, a file 
doesn’t contain a module, but you can insert one through the Insert menu. Then you will see a big white 
space on the right where you can start typing your code. Some of the code for this particular module 
appears in the figure. 
Introduction to the PrecisionTree XDK 
Like Excel and Word, PrecisionTree has its own object model. It can be used to change application 
settings, build a decision tree, generate reports, run sensitivity analyses, and other PrecisionTree tasks. 
The details of these possibilities are discussed in some detail later in this document and in the 
accompanying PrecisionTree XDK example files. 
Two questions probably come to mind. Do you really need to learn how to automate PrecisionTree with 
VBA, and, if you do, how do you learn the language? 
There are at least two reasons why you might want to automate PrecisionTree with VBA. First, it lets you 
automate tasks that you perform repeatedly. For example, suppose you need to build a reasonably large 
decision tree with a particular structure, generate reports, and perform sensitivity analyses. If you do 
this once or twice, it is probably not worth the effort to write a VBA program to automate the process. 
However, if you do this repeatedly, a VBA program can replace many mouse clicks with a single click. 
Indeed, this is why VBA for Excel is so popular among users—it lets them automate repetitive tasks with 
the click of a button. This same motivation certainly applies to repetitive tasks in PrecisionTree. 
VB.NET PDF replace text library: replace text in PDF content in vb
Replace Text in PDF File. The following coding example illustrates how to perform PDF text replacing function in your VB.NET project, according to search option
pdf text searchable; pdf find text
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Name. Description. 13. Page Thumbnails. Navigate PDF document with thumbnails. 14. Text Search. Search text within file by using Ignore case or Whole word search
how to select all text in pdf file; find and replace text in pdf
Second, suppose you are developing models for colleagues or clients who have little experience with 
PrecisionTree. Instead of teaching them how the PrecisionTree user interface works, it might be easier 
to develop a VBA application that allows them to simply click a button to make implement the entire 
The PrecisionTree object model has a fairly large number of objects. Many of the objects, including 
those you will use most often, appear in Figure 4. Specifically, most of the objects (also called “classes”) 
at the bottom right in this figure are associated with decision trees, the main focus of this guide and the 
PrecisionTree XDK example files. As you can see, there is also a section of the XDK for automating 
influence diagrams, but because influence diagrams are not used nearly as frequently as decision trees, 
this part of the XDK is not discussed here. 
Figure 4 PrecisionTree Object Model 
Assuming you think VBA for PrecisionTree is for you, how do you learn the language? First, you need 
some facility in VBA for Excel. As discussed earlier, this requires you to learn the fundamentals of the VB 
“backbone” language and the basics of the Excel object model. There are a number of reference books 
on V A for Excel, as well as Excel’s own online help. One recommendation is the first 10 chapters of VBA 
for Modelers by Albright. This book provides concise explanations and plenty of example code to get you 
up to speed in both the VB language and the Excel object model. 
Once you are familiar with VBA for Excel, you have at least four options—which are not mutually 
exclusive—for extending your knowledge to VBA for PrecisionTree. 
You can continue reading this document. It provides an overview of what can be done, and it 
provides sample code for how to do it. Alternatively, you can watch the introductory video that 
covers much of the same material. It is available from the Developer Kit (XDK) item under 
PrecisionTree Help. 
You can do what all good programmers do—mimic code written by others. Examples of programs 
written for PrecisionTree are provided in a number of PrecisionTree XDK example files. (They can be 
found from the Developer Kit (XDK) item under PrecisionTree Help.) Once you see how something is 
done, such as building a decision tree or performing sensitivity analysis, you will probably have little 
difficulty adapting the code for your own use. 
You can open the Reference document from the Developer Kit (XDK) item under PrecisionTree Help 
and start browsing. This document is quite long, and no sane person would ever read it from 
beginning to end, but it gives you a quick sense of the PrecisionTree object model, and it often 
enables you to find the specific details you need for your program. 
You can open the Object Browser that is part of the Visual Basic Editor. This is particularly useful if 
you are in the midst of writing a program and need information on one specific detail. The Object 
Browser is discussed later in this document. 
By the way, if you are familiar with VBA for Excel, you might want to start by recording macros for 
PrecisionTree, just as you can do for Excel. Unfortunately, this doesn’t work. If you turn on the recorder 
and start clicking PrecisionTree buttons, you will get some recorded code, but it will be entirely 
irrelevant. To automate PrecisionTree, you have to write the code. 
Setting Library References 
Before you can access the PrecisionTree XDK with VBA code, you must first set references to two 
PrecisionTree libraries (from References in the Tools menu of the Visual Basic Editor). These are the 
PtreeXLA and Palisade PrecisionTree 6.x Object Library references, illustrated in Figure 5. (The former 
references the Ptree.xla add-in file. The latter is abbreviated as PtreeOL6 in the Visual Basic Object 
Browser.) This should be the first step before writing any VBA macros to automate PrecisionTree. 
Figure 5 PrecisionTree References 
PrecisionTree Automation Guidelines 
This section provides some guidelines for automating PrecisionTree with VBA code. The guidelines in 
this section are purposely kept brief and are intended only to give you the “lay of the land” and alert you 
to a few technical issues. For a more pictorial set of guidelines for the PrecisionTree object model, you 
should examine the file PrecisionTree XDK - Object Model Diagrams.xlsx. To see complete applications 
of PrecisionTree automation, you should look at the accompanying PrecisionTree XDK example files. And 
finally, you can always visit the PrecisionTree XDK documentation or the Object Browser in the Visual 
Basic Editor. 
By the way, you will notice that all of the formal names of PrecisionTree objects start with PT, as in 
PTApplicationSettings. However, there are typically referenced by a property or method that doesn’t 
include the PT prefix, such as ApplicationSettings. 
Getting Started: The “Root” Object 
The “root” object that everything starts from is the PrecisionTree object, a reference to PrecisionTree. 
All other PrecisionTree objects are down the hierarchy from it. For example, you will see 
PrecisionTree.ModelWorkbook, PrecisionTree.ApplicationSettings, and others. These and other objects 
down the hierarchy will be discussed shortly. 
Technical Note: PrecisionTree Function versus PrecisionTree Object 
There is a subtle issue you should be aware of. As it is used here, PrecisionTree is a function in the 
PtreeXLA library that returns a PrecisionTree object in the PtreeOL6 library.
To put it another way, if 
2 Remember that PtreeOL6 is the abbreviation for the Palisade PrecisionTree 6.x Object Library. 
you did not reference the PtreeXLA library and wrote a typical line such as the following, PrecisionTree 
wouldn’t be recognized.  
PrecisionTree.ApplicationSettings.ReportPlacement = PTActiveWorkbook 
However, if you do reference PtreeXLA, as you should, you can simply write PrecisionTree, followed by 
any of its properties or methods, and it will work fine. (In particular, you do not need to declare 
PrecisionTree as an object variable.) 
Changing Application Settings 
You can change application settings with PrecisionTree.ApplicationSettings, just as you can through the 
usual Utilities menu in PrecisionTree. For example, the following lines change the report placement 
setting and guarantee that new reports won’t overwrite existing reports. 
With PrecisionTree.ApplicationSettings 
.ReportPlacement = PTActiveWorkbook 
.ReportOverwriteExisting = False 
End With 
As you will see in the XDK example files, if you use VBA to change any application settings, it is always a 
good programming practice to restore these settings to their original values at the end of the program. 
Referencing the Model Workbook and Models 
In all likelihood, the primary reason you will automate PrecisionTree is to work with decision trees: to 
create them, modify them, or generate reports from them. Therefore, you might expect that you could 
reference a decision tree directly from the PrecisionTree root object. However, this isn’t quite how it 
works. There is at least one layer in between. 
First, there is the PTModelWorkbook object. As its name implies, this is a reference to an Excel 
workbook, and it is a direct descendant of the root PrecisionTree object. It has one optional argument, a 
reference to the particular workbook that contains, or will contain, the decision tree. (If this argument is 
omitted, as it often is, the active workbook is used. Alternatively, a safer approach is to reference 
ThisWorkbook, a built-in Excel object that refers to the workbook that contains the code. Then you can 
run the code even if another workbook happens to be active.) If you want to create a new tree from 
scratch, the following lines are typical. 
Dim dTree As PTDecisionTree 
Set dTree = PrecisionTree.ModelWorkbook _ 
.DecisionTrees.Add(ActiveSheet.Range(“B2”), ,”My Tree”) 
As this code indicates, a PTModelWorkbook object is obtained from the ModelWorkbook property. This 
object has a DecisionTrees property that returns a collection of decision trees, and you can add a 
member to this collection. Only the first argument of the Add method is required. It specifies the 
starting cell for the tree. The optional third argument specifies the name of the tree. (The second 
argument, True by default, indicates that the current application settings will be applied to this tree.) 
Actually, as you will see in later examples in this document, you don’t need to create an explicit 
PTDecisionTree object (dTree in the above code). You can create it implicitly with the following With 
line. Then you can change properties of the tree inside the With block.  
With PrecisionTree.ModelWorkbook _ 
.DecisionTrees.Add(ActiveSheet.Range(“B2”), ,”My Tree”) 
Once the tree exists, you can reference it by name, but the ModelWorkbook property is still required. 
Here is how you could start a With block to make changes to an existing tree. 
With PrecisionTree.ModelWorkbook.DecisionTrees(“My Tree”) 
Alternatively, you can go one farther step down the hierarchy by referencing a PTModel object. This is a 
reference to any decision model, either a decision tree or an influence diagram. There are two ways you 
can reference a model, either through the Models property or through the ModelsOnWorksheet 
method, both members of the PTModelWorkbook object. As the names suggest, the Models method 
returns the collection of all models (decision trees or influence diagrams) in the workbook, whereas the 
ModelsOnWorksheet returns the collection of models on a specified worksheet. For example, either of 
the following lines starts a With block for working with an existing tree: 
With PrecisionTree.ModelWorkbook.Models(“My Tree”) 
With PrecisionTree.ModelWorkbook.ModelsOnWorksheet(wsTree)(“My Tree”) 
This last line requires some clarification. First, it assumes that the worksheet with the tree is code-
named wsTree. If the name of the worksheet, the one that appears on the worksheet tab, is Tree, you 
could replace wsTree with Worksheets(“Tree”). Second, it might look strange to follow one argument in 
parentheses by another. However, the last part of the line is really equivalent to 
.ModelsOnWorksheet(wsTree).Item(“My Tree”) 
The Item property of a collection is always the default property and can be (and usually is) omitted—
hence the two consecutive set of parentheses. 
Working with Decision Trees: Nodes and Branches 
Decision trees are by their very nature visual, and it helps to visualize their structure as you work with 
them in VBA code. Decision trees have nodes, followed by branches, followed by more nodes, followed 
by more branches, and so on. This sequence can occur in almost any order. The three types of nodes 
you encounter most often are decision nodes (squares), chance nodes (circles), and end nodes 
(triangles). The branches emanating from decision or chance nodes have values, usually monetary 
values (and often equal to 0), and the branches emanating from a chance node also have probabilities 
that sum to 1. In addition, all decision and chance nodes and branches have names—the labels that 
appear to the right of nodes and on the branches. 
If you use VBA to build a decision tree from scratch, you must specify all of this information—node 
types, names, values, and probabilities—and as you will see shortly, it is quite easy to do so. However, 
you also have to maneuver between nodes and branches so that you can “build” the tree in the proper 
sequence. There are several ways to reference nodes and branches in a tree, but the following 
guidelines are arguably the one you will find most useful. 
A tree has a RootNode property, the leftmost node in the tree. You get it “for free” as soon as 
you create a new tree. 
Each node—technically a PTDecisionTreeNode object—has a NodeType property. The three 
most common node types are PTTreeDecisionNode, PTTreeChanceNode, and PTTreeEndNode. 
Each decision and chance node has a ChildBranches property that references the collection of 
branches emanating from that node. 
Documents you may be interested
Documents you may be interested