display pdf in browser from byte array c# : How to permanently rotate pdf pages software SDK cloud windows wpf asp.net class Driving%20Word%20and%20Excel%20from%20Visual%20FoxPro0-part1940

3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
DEV185 
Driving Word and Excel from VFP 
By Tamar E. Granor, Ph.D. 
Visual FoxPro is a great database product, but it's not a word processor or a spreadsheet. 
Why try to fit a square peg in a round hole? If you need a word processor or spreadsheet, 
use one. 
This session shows you how to create, access and manipulate Word documents and Excel 
spreadsheets from a Visual FoxPro application. Learn how VFP can use Word to create 
reports, send data to an Excel workbook, read Word and Excel documents, and much 
more. This session assumes some familiarity with Word and/or Excel and a basic 
understanding of object-oriented programming. They refer to Office 97, except where noted, 
but all examples should work as shown in Office 2000.  
Is Everything a Nail? 
When you're really familiar with a product, it's tempting to use it for all your needs. Many 
people have been doing that with FoxPro for years. Need a number cruncher? Write it in 
FoxPro. Need a word processor? Write it in FoxPro. Need a file manager? Write it in 
FoxPro. That we can do some many diverse things is a testament to FoxPro's strength and 
versatility. But using our hammer (FoxPro) to do it doesn't make all those tasks nails. 
Both user's needs and applications' capabilities are growing. While it made sense to write a 
simple word processor for editing customer notes in FoxPro/DOS in 1994, it doesn't make 
sense to do so in Visual FoxPro 6.0 in 1999. There are too many other alternatives out there 
that can just be plugged into a VFP app. 
Microsoft's COM (Component Object Model or Common Object Model) specifies ways for 
applications to work together. It's a successor to OLE (Object Linking and Embedding), 
which in turn was a successor to DDE (Dynamic Data Exchange). COM offers several 
approaches to communication between apps. One of the most powerful is automation, the 
ability for one application to order another around. (Other COM techniques include ActiveX 
controls and in-place activation.) 
Automation Basics 
Two applications are involved in any automation session. The application that's in charge 
(issuing the orders) is called the automation client (or just client). The application being 
manipulated is the automation server (or just server). The client addresses an instance of 
the server as if it were any other object, reading and setting properties and calling methods. 
This simple technique means that a VFP application (the client) can address anything from 
How to permanently rotate pdf pages - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
rotate pages in pdf permanently; save pdf after rotating pages
How to permanently rotate pdf pages - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
rotate pdf pages in reader; rotate pdf pages by degrees
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
the Office applications to Windows' file system to Lotus Notes and much more. In fact, VFP 
itself can be used as an automation server. 
To start an automation session, the client creates or grabs a reference to an instance of the 
server. Creating an automation server instance isn't much different than creating any other 
object in VFP. You call CreateObject() and tell it what to create. For example, to create an 
instance of the Word automation server, issue: 
oWord = CreateObject("Word.Application") 
Once this command finishes, oWord contains a reference to an instance of Word, which 
can be manipulated by calling methods or changing properties. (That's if all is well. If Word 
isn't installed or isn't properly registered, you get an error message.) By default, the Office 
automation servers are created invisible. To make the Word instance visible, issue: 
oWord.Visible = .T. 
To close the Word instance, use: 
oWord.Quit() 
Using Excel is almost identical. To create an Excel instance, issue: 
oExcel = CreateObject("Excel.Application") 
Except for the variable name used (and that's just my choice for readable code), the 
commands to make the Excel automation server visible and to close it are identical to those 
for Word: 
oExcel.Visible = .T. 
oExcel.Quit() 
Of course, not all the properties and methods of Word and Excel are the same; after all, the 
two applications have different purposes and abilities. Other servers can also be 
instantiated with CreateObject(), but have different properties and methods. 
It's also possible with some servers to latch onto an existing instance. The GetObject() 
function looks for an instance of the server and returns a reference to that object, if there is 
one. To get a reference to an open instance of Word, use: 
oWord = GetObject(,"Word.Application") 
Note that the first parameter is omitted. If the application you name isn't already open, you 
get an error; GetObject() doesn't open a new instance for you. 
There's another way to use GetObject(), as well. You can pass a filename as the first 
parameter; this asks VFP to open the appropriate application for the file, then open the file. 
It's like double clicking on the file in Explorer. This approach returns a reference to the 
object inside the application that refers to the open file (a Document in Word, a WorkBook 
object in Excel). 
But What's in There? 
A Visible property to make the application show and a Quit method to close it are pretty 
obvious guesses for most automation servers (though not all have them or call them that). 
But they're not all that useful. How do you find out the properties and methods of the server 
VB.NET PDF Page Redact Library: redact whole PDF pages in vb.net
extract, copy, paste, C#.NET rotate PDF pages, C#.NET If you need to permanently removing visible text and our redact function API and redact entire PDF pages.
how to rotate just one page in pdf; rotate all pages in pdf and save
C# PDF Page Redact Library: redact whole PDF pages in C#.net, ASP.
Page: Rotate a PDF Page. PDF Read. Text: Extract Redaction is the process of permanently removing visible our redact function API to redact entire PDF pages.
save pdf rotate pages; rotate one page in pdf
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
you want to use? If you're lucky, the application's documentation tells you. If not, you're 
headed down a rough road. 
For the Office applications, there are three main approaches to determining the properties 
and methods of the servers and how to use them. In most cases, you'll need to combine all 
three to get what you need. 
Read the Fine Manual 
Word and Excel (along with the other Office apps) each supply a Help file that documents 
its members. In each case, you'll find it from the main Help menu by selecting Contents and 
Index, then going down to the bottom. Near the last item, you should find "Microsoft Blah 
Visual Basic Reference," where "Blah" is the application you're looking at. Double-clicking 
that item expands it and makes available "Visual Basic Reference". Choose that one to 
open the relevant Help file. (For the Office 2000 applications, look for "Programming 
Information" near the bottom of the Contents list.) 
If you didn't find the appropriate Visual Basic reference, it means you didn't install that Help 
file with the application. To do so, you have to choose Custom rather than Complete 
installation. ("Complete" seems to mean "typical" more than "everything.") You can install 
the file at any time by running Setup again. 
Why "Visual Basic Reference?" The language used for writing code in the Office 
applications is a version of Visual Basic called "Visual Basic for Applications" or VBA. When 
you use automation with those apps, although you're writing VFP code, you're talking to the 
VBA parsing engine. 
In addition, the Office 97/Visual Basic Programmer's Guide is available online. As of this 
writing, you could find it at http://www.microsoft.com/OfficeDev/Articles/OPG/. 
Let Someone Else Write the Code 
The macro recorders of Word and Excel turn user actions into VBA code. So one way to 
figure out how to automate something is to record a macro to do it, then examine the 
macro. (Choose Tools-Macro-Record New Macro to start recording.) This approach shows 
you the properties and methods involved as well as the parameters to pass to the methods.  
Converting a VBA macro to VFP code is harder than it should be for several reasons. This 
line of Word VBA code, which moves the insertion point (the vertical bar that determines 
where the next character is inserted) one character to the right, demonstrates the problems: 
Selection.MoveRight Unit:=wdCharacter, Count:=1 
First, unlike VFP, VBA makes some assumptions about what object you're talking to. In the 
line above, Selection is really This.Selection (though VBA doesn't actually support the VFP 
keyword This), the current selection (highlighted area) of the Word instance.  
Second, VBA allows methods to use what are called named parameters. In the code above, 
the method called is MoveRight. Two parameters are passed, each in the form: 
parameter name := parameter value 
VB.NET Image: How to Process & Edit Image Using VB.NET Image
VB.NET Image Rotator Add-on to Rotate Image, VB.NET Watermark Maker to VB.NET image editor control SDK, will the original image file be changed permanently?
how to rotate pdf pages and save permanently; rotate pdf pages on ipad
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Excel
to change view orientation by clicking rotate button. users can convert Excel to PDF document, export Users can save Excel annotations permanently by clicking
pdf rotate page and save; rotate all pages in pdf preview
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
This syntax allows VBA programmers to include only the parameters they need and not 
worry about the order of the parameters. However, VFP doesn't support named parameters; 
you must specify parameters in the right order. Fortunately, the Help file shows the 
parameters in their required order. 
The first parameter in the example shows the third problem that occurs in translating VBA to 
VFP. It specifies that a parameter called Unit should have the value wdCharacter, but what's 
wdCharacter? It's one of dozens of defined constants available in Word's version of VBA. (It 
turns out that wdCharacter is 1.) 
Word's VBA Help doesn't supply the values of defined constants. In fact, Help uses them 
exclusively and doesn't show their actual values anywhere. To find out what wdCharacter 
and all the others stand for, use the Object Browser available through the Visual Basic 
Editor. 
Before moving on to the Object Browser, there are a couple of thing worth noting about the 
Macro Recorder and the Visual Basic Editor. First, be aware that the Macro Recorder 
doesn't always produce the best code for a task. The code it produces gives you an idea of 
what can be done, but there may be better ways to accomplish the same task. 
Second, the Visual Basic Editor has a feature called IntelliSense that makes writing code 
there easier. When you type an object name and a period (like "oRange."), an appropriate 
list of properties and methods appears. When you choose a method from the list (use Tab 
to choose without ending the line), a list of parameters for that method appears like a tooltip 
to guide you. As you enter parameters, your position in the parameter list is highlighted to 
keep you on track. Unfortunately, VFP doesn't support IntelliSense yet. 
Take Me for a Browse 
One of the most powerful tools available for figuring out automation code is the Object 
Browser (figure 1). It lets you drill into the various objects in the hierarchy to determine their 
properties and methods, see the parameters for methods, determine the value of constants, 
and more. 
The easiest way to find out about a specific item is to type it into the search dropdown and 
press Enter or click the Find (binoculars) button. The middle pane fills with possibly 
appropriate references 
choose one to learn more about it. Figure 1 shows the Object 
Browser used to determine the value of the constant wdCharacter. At the very bottom, you 
can see that it's a constant with a value of 1. 
VB.NET Image: How to Create a Customized VB.NET Web Viewer by
used document & image files (PDF, Word, TIFF btnRotate270: rotate image or document page in burnAnnotationToImages: permanently burn drawn annotation on page in
how to rotate page in pdf and save; pdf rotate all pages
How to C#: Cleanup Images
By setting the BinarizeThreshold property whose value range is 0 to 255, it will permanently modify the image to 1bpp grayscale image of the Detect Blank Pages.
rotate single page in pdf; rotate pages in pdf
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
Figure 1 The Object Browser 
Use this tool to find out constant values, properties and methods, and more. 
Here, it shows that wdCharacter is a constant with a value of 1 and is a member of a group of constants called 
WdUnits. 
The Object Browser is also useful for moving around the object hierarchy to get a feel for 
what the various objects can do. In Figure 2, the Search Results pane has been closed and 
the members of Word's Table object are shown in the right pane. The Sort method is 
highlighted, so the very bottom panel shows its (complex) calling syntax. The advantage of 
this approach over Help is that the Object Browser actually looks at the server itself, so the 
list it shows must be correct while Help can contain errors. Even better, the Object Browser 
and Help can work together. Press F1 in the Browser and Help opens to the highlighted 
item. 
How to C#: Color and Lightness Effects
Geometry: Rotate. Image Bit Depth. Color and Contrast. Cleanup Images. Effect VB.NET How-to, VB.NET PDF, VB.NET Word range is 0 to 255, it will permanently modify
how to rotate one page in a pdf file; how to reverse pages in pdf
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
Figure 2 Members and Syntax in the Object Browser 
You can examine objects and their properties and 
methods using the Browser.  
With these tools in hand, you can start the process of writing code to automate Word and 
Excel. 
Taking up a Collection 
The object models of both Word and Excel (along with most COM servers) contain many 
collections. A collection is the OOP world's version of an array. It contains references to a 
number of objects, generally of the same type, and provides access to those objects. Visual 
FoxPro has a few native collections (Forms, Pages, etc.) as well as several COM collections 
(such as Projects). 
Most collections (though not the native VFP collections) have a few methods and properties 
in common. The Count property typically tells you how many items are in the collection. 
Item, which is a method in some collections and a property in others (it's a property in the 
Office apps), provides access to the individual members of the collection.  
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
Whether a method or a property, Item typically takes a single parameter or index, and 
returns a reference to that member of the collection. In many cases, you can specify the 
item you want by name rather than number. _VFP.Projects.Item["Tastrade.PJX"] provides a 
reference to the TasTrade project, if it's open, for example.  
In addition, many collections let you omit the Item keyword and simply attach the 
parameter/index to the collection name. So we can write _VFP.Projects["Tastrade.PJX"] 
and still get a reference to the project. 
What's the Word? 
Automation to Word changed dramatically between Word 95 and Word 97. Word 95 had a 
very simple object model consisting primarily of a single object (Word.Basic). In Word 97 
and later, the object model better reflects the internal structure of Word and its documents. 
The key object in Word is Document, which represents a single, open document. The Word 
server has a Documents collection, containing references to all open documents. The 
server also has an ActiveDocument property that points to the currently active document. 
The Document object has lots of properties and methods. Many of its properties are 
references to collections, such as Paragraphs, Tables and Sections. Each of those 
collections contains references to objects of the indicated type. Each object contains 
information about the appropriate piece of the document. For example, the Paragraph 
object has properties like KeepWithNext and Style. 
The Word server object, called Application, has its own set of properties and methods, 
including a number of other collections. In addition to ActiveDocument and Visible, the 
Application object's properties include StartupPath, Version and WindowState. The Quit 
method used above has several optional parameters 
the first indicates what to do if any 
open documents have been changed and not saved. In addition to Quit, the application 
object has methods for converting measurements from one set of units to another, checking 
grammar and spelling, and much more.  
Word Visual Basic Help contains a diagram of Word's object model. The figure is "live" 
when you click on an object, you're taken to the Help topic for that object. Figure 3 shows 
the portion of the object model diagram that describes the Document object. 
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
Figure 3 Word Object Model 
The Help file offers a global view of Word's structure. 
Managing Documents 
The methods for creating, opening, saving and closing documents are fairly straightforward. 
The only complication is in what object provides which method. The methods for creating 
and opening a document belong to the Documents collection. The methods for saving and 
closing a document belong to the Document object. Although confusing at first glance, this 
actually makes sense since you don't have a Document object to work with at the time you 
create or open a document. But when it comes time to save or close it, a document 
reference is available. (Files in VFP's Project object work the same way. Add is a method of 
the Files collection, but Remove belongs to the File object.) 
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
To open an existing document, use the Open method. Open has many parameters, but 
most of the time, the only one that matters is the first, the name and path of the file to open. 
The Word server doesn't recognize VFP's search path, so you usually need to provide the 
full path to the document, like this: 
oDocument = oWord.Documents.Open("d:\writing\confs\la99\dev185.doc") 
If it's successful, Open returns an object reference to the newly opened document. If the 
specified document doesn't exist, an error is generated and nothing is returned. (This 
example, like the others below, assumes you have an instance of Word running, with 
oWord holding a reference to it.) 
To create a new document, use the Add method, which has only two, optional, parameters. 
The important one is the first, which indicates the path to the template on which the new 
document should be based. If it's omitted, the new document is based on the Normal 
template. 
Templates in Word allow you to define the framework for documents and then create as 
many documents as you want based on that framework. A template can contain both text 
and formatting, including style definitions (see Working with Styles below), and can be quite 
simple or extremely complex. It can also contain bookmarks, named points in the document, 
which you can use to quickly access to a particular position. 
Like Open, Add returns a reference to the newly created document. This line creates a new 
document based on the "Elegant Fax" template that comes with Word.  
oDocument = oWord.Documents.Add( ; 
"E:\Msoffice\Templates\Letters & Faxes\Elegant Fax.DOT") 
As with Open, the full path to the template is needed. To do so, though, you need to know 
where Word is installed or at least, where the templates are kept. Fortunately, Word 
provides some clues. The DefaultFilePath method of the Options object (which is a member 
of the Word Application object) can return the root directory for both the user's own 
templates and user's workgroup's templates. Using that information, we can search for the 
path to a specific template, given its name. The NewDocument method of the cusWord 
class on the conference CD accepts a template with or without a path and attempts to 
locate the template file before creating a new document. 
When you're finished working with a document, two methods are available to save it. Save 
saves the document back to its current file; if it's never been saved, that pops up the Save 
As dialog box. SaveAs lets you specify the file name (and a lot of other stuff) without seeing 
a dialog, which is usually what you want with automation code. 
If the currently active document has already been saved, this line resaves it without user 
intervention: 
oWord.ActiveDocument.Save() 
To save the document to a different file or to save a document for the first time without the 
user specifying a file name, call SaveAs and pass the file name, like this: 
oWord.ActiveDocument.SaveAs("D:\Documents\ThisIsNew.DOC") 
3
rd
Annual Southern California Visual FoxPro Conference
Sponsored by Microcomputer Engineering Services, LLC 
Copyright 1999, Tamar E. Granor 
10 
Be careful. When you pass a file name to SaveAs, it overwrites any existing file without 
prompting. (Of course, SaveAs, like Word's other methods, doesn't respect VFP's SET 
SAFETY setting, since it's not running inside VFP.) 
Accessing Parts of a Document 
Most of what you want to do with Word involves adding to, modifying or reading an existing 
document. There are a variety of ways to do these things, but the key to just about all of 
them is the Range object and, to a lesser extent, the Selection object. 
The Selection object represents the currently highlighted (that is, selected) portion in a 
document. If nothing is highlighted, Selection refers to the insertion point. There's only one 
Selection object, accessed directly from the Word server. For example, to find out how 
many paragraphs are in the current selection, you can use this code: 
nParagraphs = oWord.Selection.Paragraphs.Count 
A Range object can represent any portion of a document. Multiple ranges can be defined 
and used at the same time. Many Word objects have a Range property that contains an 
object reference to a range for the original object. For example, to create a Range from the 
third paragraph of the active document, you can use: 
oRange = oWord.ActiveDocument.Paragraphs[3].Range 
Document has a Range method that lets you specify a range by character position. For 
example, to get a reference to a Range from the 100
th
to 250
th
characters in the active 
document, use: 
oRange = oWord.ActiveDocument.Range(100,250) 
Document's Content property contains a reference to a Range consisting of the entire main 
document (the body of the document without headers, footers, footnotes, and so on). So the 
next two commands are equivalent: 
oRange = oWord.ActiveDocument.Range() 
oRange = oWord.ActiveDocument.Content 
It's easy to switch between Selection and Range objects. Like many other objects, Selection 
has a Range property. Range has a Select method that highlights the range's contents, 
turning it into the Selection. For example, to highlight the range from the previous example, 
use: 
oRange.Select() 
Selection and Range seem quite similar and, in many ways, they are, but there are 
differences. The biggest, of course, is that you can have multiple Ranges, but only one 
Selection. In addition, working with a Range is usually faster than working with a Selection. 
On the whole, Word VBA experts recommend using Range rather than Selection wherever 
possible. The main reason is that using Selection is essentially duplicating screen actions 
with code; Range lets you operate more directly. Word's Macro Recorder tends to use the 
Selection object; this is one thing to be aware of when converting Word macros to VFP 
code.  
Documents you may be interested
Documents you may be interested