how to show pdf file in asp.net page c# : Text searchable pdf control SDK platform web page wpf winforms web browser VSTO3-part2051

Context Provided to Hosted Code 
It is critical that your hosted code get context—it needs to get the 
Application object or Document object for the Office application into which it 
is loading.  COM add-ins are provided with context through an interface 
implemented by the add-in class.  Outlook add-ins in VSTO are provided with 
context through a class created in the project that represents the application 
being customized.  Code behind a document in VSTO is provided with 
context through a class created in the project that represents the document 
being customized. 
Entry Point for Hosted Code 
At startup, Office calls into an entry point where your code can run for the 
first time and register for events that may occur later in the session.  For a 
COM add-in, this entry point is the OnConnection method of the 
IDTExtensibility2 interface implemented by the COM add-in.  For a VSTO 
Outlook add-in and VSTO code behind a document this entry point is the 
Startup event handler. 
How Code Gets Run After Startup 
Once hosted code starts up, code continues to run in one or more of the 
following ways. 
Code Runs In Response to Events Fired By Office 
The most common way that code runs after startup is in response to 
events that occur in the Office application.  For example, Office raises events 
when a document opens or a cell in a spreadsheet changes.  Listing 1-26 
shows a simple class that listens to the change event that Excel’s Worksheet 
object raises.  Typically, you will hook up event listeners like the one shown 
in Listing 1-26 when the initial entry point of your code is called. 
Interface Methods Called On Objects Provided To Office 
Objects such as the startup class for a COM add-in implement an interface 
called IDTExtensibility2 that has methods that Office calls during the run of 
the Office application.  For example, if the user turns off the COM add-in, 
Office calls the OnDisconnection method on the IDTExtensibility2 interface 
implemented by the COM add-in.  In this way, additional code runs after the 
initial entry point has run. 
Events Raised on Code Behind Classes 
The classes generated in VSTO projects that represent the customized 
application or document handle the Startup and Shutdown events.  After the 
Text searchable pdf - search text inside PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
search text in multiple pdf; text searchable pdf
Text searchable pdf - VB.NET PDF Text Search Library: search text inside PDF file in vb.net, 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
find and replace text in pdf; search text in pdf image
constructor of the class executes, Office raises the Startup event.  When the 
document is about to be closed, Office raises the Shutdown event. 
How Code Gets Unloaded 
Your code gets unloaded in a number of ways, depending on the 
development pattern you are using.  If you are using the automation 
executable pattern, your code unloads when the automation executable you 
have written exits. If you are using the add-in pattern, your code unloads 
when the Office application exits or when the user turns off the add-in via an 
add-in management dialog.  If you are using the code behind pattern, your 
code unloads when the document associated with your code is closed. 
In the hosted patterns of running code there is some method that is called 
or event that is raised notifying you that you are about to be unloaded.  For 
COM add-ins, Office calls the OnDisconnection method.  For VSTO code 
behind documents and Outlook add-ins, Office raises the Shutdown event 
before your code is unloaded. 
Office Automation Executables 
We now consider each of these three patterns of Office solutions in more 
detail.  Office solutions that use the automation executable pattern start up an 
Office application in a very straightforward manner—by creating a new 
instance of the Application object associated with the Office application.  
Because the automation executable controls the Office application, the 
automation executable runs code at startup and any time thereafter when 
executing control returns to the automation executable. 
When an automation executable uses new to create an Application object, 
the automation executable controls the lifetime of the application by holding 
the created Application object in a variable.  Office determines whether it can 
shut down by determining the reference count or number of clients that are 
using its Application object. 
In Listing 2-1, as soon as 
new
is used to create the myExcelApp variable, 
Excel starts and adds one to its count of clients that it knows are holding a 
reference to Excel’s Application object.  When the myExcelApp variable goes 
out of scope (when Main exits) .NET garbage collection releases the object 
and Excel is notified that the console application no longer needs Excel’s 
Application object.  This causes Excel’s count of clients holding a reference 
VB.NET Create PDF from Text to convert txt files to PDF in vb.net
Best VB.NET adobe text to PDF converter library for Visual Studio .NET project. Batch convert editable & searchable PDF document from TXT formats in VB.NET
how to select text in a pdf; how to select text in pdf image
C# Create PDF from Text to convert txt files to PDF in C#.net, ASP
Visual Studio .NET project. .NET control for batch converting text formats to editable & searchable PDF document. Free .NET library for
convert pdf to searchable text online; search pdf documents for text
to Excel’s Application object to go to zero and Excel exits as no clients are 
using Excel anymore. 
When you create an Office application by creating a new instance of the 
Application object, the application starts up without showing its window.  
This is useful because you can automate the application without distracting 
the user by popping up windows.  If you need to show the application 
window, you can set the Visible property of the Application object to 
true
 
If you make the main window visible, the user controls the lifetime of the 
application.  In Excel, the application will not exit until the user quits the 
application and your variable holding the Excel Application object is garbage 
collected.  Word behaves differently—the application exits when the user 
quits the application even if a variable is still holding an instance of the Word 
Application object. 
Listing 2-1 sets the status bar of Excel to say “Hello World” and opens a 
new blank workbook in Excel by calling the Add method of Excel’s 
Workbooks collection.  Chapters 3 through 5 cover the Excel object model in 
more detail. 
Listing 2-1: Automation of a Excel via a console application. 
using System; 
using Excel = Microsoft.Office.Interop.Excel; 
using System.Windows.Forms; 
namespace ConsoleApplication 
class Program 
static bool exit = false
static void Main(string[] args) 
Excel.Application myExcelApp = new 
Excel.Application(); 
myExcelApp.Visible = true
myExcelApp.StatusBar = "Hello World"
myExcelApp.Workbooks.Add(System.Type.Missing); 
myExcelApp.SheetBeforeDoubleClick += new 
Excel.AppEvents_SheetBeforeDoubleClickEventHandler(myExce
lApp_SheetBeforeDoubleClick); 
while (exit == false
System.Windows.Forms.Application.DoEvents(); 
C# Create PDF Library SDK to convert PDF from other file formats
The PDF document file created by RasterEdge C# PDF document creator library is searchable and can be fully populated with editable text and graphics
find text in pdf files; pdf text select tool
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
webpage. Create high quality Word documents from both scanned PDF and searchable PDF files without losing formats in VB.NET. Support
cannot select text in pdf file; search pdf for text
static void myExcelApp_SheetBeforeDoubleClick(object 
Sh, Microsoft.Office.Interop.Excel.Range Target, ref bool 
Cancel) 
exit = true
Listing 2-1 also illustrates how an automation executable can yield time 
back to the Office application.  A reference to the System.Windows.Forms 
assembly must be added to the project. After a event handlers are hooked up, 
System.Windows.Forms.Application.DoEvents() is called in a loop to allow 
the Excel application to run normally.  If the user double clicks on a cell, 
Office yields time back to the event handler in the automation executable.  In 
the handler for the double click event, we set the static variable exit to 
true
which will cause the loop calling DoEvents to exit and the automation 
executable to exit. 
You can see the lifetime management of Excel in action by running the 
automation executable in Listing 2-1 and exiting Excel without double 
clicking on a cell.  Excel will continue to run in a hidden state, waiting for the 
console application to release its reference to Excel’s Application object. 
Creating a Console Application that Automates Word 
In this section, we are going to walk through the creation of a simple 
console application that automates Word.  A wiki is a kind of online 
encyclopedia that users can contribute to. For an example, see 
http://www.officewiki.net
for a wiki that documents the Office PIAs.  Wikis 
use simple, easy-to-edit text files that any visitor to the wiki can edit without 
having to know HTML.  These text files have simple representations of even 
complex elements like tables. Our console application will read a simple text 
file that specifies a table in wiki text format.  It will then automate Word to 
create a Word table that matches the text file specification. 
In the wiki text format, a table that looks like Table 2-1 is specified by 
the text in Listing 2-2. 
Table 2-1: A simple table showing the properties and methods of Word’s 
Add-in object. 
Property or 
Method 
Name 
Return Type 
Property  
Application  Application 
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
NET project. Powerful .NET control for batch converting PDF to editable & searchable text formats in C# class. Free evaluation library
make pdf text searchable; how to select all text in pdf
C# Create PDF from Tiff Library to convert tif images to PDF in C#
Selection of turning tiff into searchable PDF or scanned PDF. Online demo allows converting tiff to PDF online. C# source codes are provided to use in .NET class
pdf searchable text converter; pdf find and replace text
Property 
Autoload 
Boolean 
Property 
Compiled 
Boolean 
Property 
Creator 
Int32 
Method 
Delete 
Void 
Property 
Index 
Int32 
Property 
Installed 
Boolean 
Property 
Name 
String 
Property 
Parent 
Object 
Property 
Path 
String 
Listing 2-2: A Wiki text representation of Table 1-4. 
||Property or Method||Name||Return Type|| 
||Property||Application||Application|| 
||Property||Autoload||Boolean|| 
||Property||Compiled||Boolean|| 
||Property||Creator||Int32|| 
||Method||Delete||Void|| 
||Property||Index||Int32|| 
||Property||Installed||Boolean|| 
||Property||Name||String|| 
||Property||Parent||Object|| 
||Property||Path||String|| 
We will use Visual Studio .NET 2005 to create a console application.  
After launching Visual Studio, choose New Project… from the File menu.  
The new project dialog shows a variety of project types.  Select the Visual C# 
node from the list of project types and select the Windows node under the 
Visual C# node.  This is slightly counter intuitive as there is an Office node 
available as well, but the Office node only shows VSTO code behind 
document projects and the VSTO Outlook add-in project. 
After you select the Windows node, you will see in the window to the 
right the available templates.  Select the Console Application template.  Name 
your console application project then press the OK button to create your 
project.  In Figure 2-1 we’ve created a console application called WordWiki.  
Note that the new project dialog can have a different appearance than the one 
shown in Figure 2-1 depending on the profile you are using.  In this book, we 
assume you are using the Visual C# Development Settings profile.  You can 
change your profile by choosing Import and Export Settings… from the Tools 
menu. 
VB.NET Create PDF from Tiff Library to convert tif images to PDF
files, VB.NET view PDF online, VB.NET convert PDF to tiff, VB.NET read PDF, VB.NET convert PDF to text, VB.NET Turning tiff into searchable PDF or scanned PDF.
how to search a pdf document for text; text searchable pdf file
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Word
C# users can convert Convert Microsoft Office Word to searchable PDF online, create multi empowered to add annotations to Word, such as add text annotations to
how to make pdf text searchable; how to select text on pdf
Figure 2-1: Creating a console application from the New Project dialog
Once you press the OK button, Visual Studio creates a console 
application project for you.  Visual Studio displays the contents of the project 
in the Solution Explorer window as shown in Figure 2-2.   
XImage.OCR for .NET, Recognize Text from Images and Documents
Output OCR result to memory, text searchable PDF, Word, Text file, etc. Next Steps. Download Free Trial Download and try OCR for .NET with online support.
search a pdf file for text; convert pdf to word searchable text
VB.NET Create PDF Library SDK to convert PDF from other file
searchable PDF document. Gratis control for creating PDF from multiple image formats such as tiff, jpg, png, gif, bmp, etc. Create writable PDF file from text (
select text in pdf file; how to make a pdf file text searchable
Figure 2-2The Console application project “WordWiki” shown in Solution 
Explorer. 
By default, a newly created console application references the assemblies 
System, System.Data, and System.Xml.  We also need to add a reference to 
the Word 2003 PIA.  We do this by right clicking on the References folder 
and choosing Add Reference… from the popup menu that appears.  This 
shows the Add Reference dialog in Figure 2-3.  Click on the COM tab and 
select the Microsoft Word 11.0 Object Library to add a reference to the Word 
2003 PIA.  Then click the OK button. 
Figure 2-3: Adding a reference to the Microsoft Word 2003 PIA. 
Visual Studio adds the reference to the Word 2003 PIA and adds 
additional references to the stdole, VBIDE, and Microsoft.Office.Core PIAs 
as shown in Figure 2-4.  These additional PIAs are ones that the Word PIA 
depends on.  Stdole is a PIA that contains the definition of some of the types 
that COM object models need.  VBIDE is the PIA for the object model 
associated with the VBA editor integrated into Office.  Microsoft.Office.Core 
(office.dll) is the PIA for common functionality shared by all the Office 
applications such as the object model for the toolbars and menus. 
Figure 2-4: When you add the Word 2003 PIA, dependent PIA references are 
automatically added to the project. 
Now that the proper references have been added to our console 
application, let’s start writing code.  Double click on Program.cs in the 
Solution Explorer window to edit the main source code file for the console 
application.  If you have outlining turned on, you will see the text “using …” 
at the top of the Program.cs file with a + sign next to it.  Click on the + sign to 
expand out the code where the using directives are placed.  Add the following 
three using directives so we can use objects from the Word PIA and the 
Microsoft.Office.Core PIA as well as classes in the System.IO namespace. 
using Office = Microsoft.Office.Core; 
using Word = Microsoft.Office.Interop.Word; 
using System.IO; 
We are now ready to write some real code that automates Word to create 
a table after reading a text input file in the wiki table format.  The entire 
listing of our program is shown in Listing 2-3.  Rather than explain every line 
of code in that listing, we will focus on the lines of code that automate Word.  
We assume the reader has some knowledge of how to read a text file in .NET 
and parse a string via the Split method.  We will briefly touch on some objects 
in the Word object model here, but Chapters 6 through 8 cover the Word 
object model in much more detail. 
The first thing we do in Listing 2-3 is declare a new instance of the Word 
application object by adding this line of code to Main method of our program 
class. 
Word.Application theApplication = new Word.Application(); 
Although Word.Application is an interface, we are allowed to create a 
new instance of this interface because the compiler knows that the 
Word.Application interface is associated with a COM object that it knows 
how to start.  When Word starts in response to an automation executable 
creating a new instance of its application object, it starts up without showing 
any windows.  You can automate Word in this invisible state when you want 
to automate Word without confusing the user by bringing up the Word 
window.  For this example, we want to make Word show its main window, 
and we do so by adding this line of code: 
theApplication.Visible = true; 
Next, we want to create a new empty Word document into which we will 
generate our table.  We do this by calling the Add method on the Documents 
collection returned by Word’s application object.  The Add method takes four 
optional parameters that we want to omit.  Optional parameters in Word 
methods are specified as omitted by passing by reference a variable 
containing the special value Type.Missing.  We declare a variable called 
missing
that we set to Type.Missing and pass it by reference to each 
parameter we wish to omit as shown here: 
object missing = Type.Missing; 
Word.Document theDocument = theApplication.Documents.Add( 
ref missing, 
ref missing,  
ref missing,  
ref missing); 
With a document created, we want to read the input text file specified by 
the command line argument passed to our console application.  We want to 
parse that text file to calculate the number of columns and rows.  Once we 
know the number of columns and rows, we use the line of code below to get a 
Range object from the Document object.  By passing our 
missing
variable to 
the optional parameters, the Range method will return a range that includes 
the entire text of the document. 
Word.Range range = theDocument.Range(ref missing, ref 
missing); 
We then use our Range object to add a table by calling the Add method of 
the Tables collection returned by the Range object.  We pass the Range object 
again as the first parameter to the Add method to specify that we want to 
replace the entire contents of the document with the table.  We also specify 
the number of rows and columns we want. 
Word.Table table = range.Tables.Add( 
range,  
rowCount,  
columnCount,  
ref missing,  
ref missing); 
The Table object has a Cell method that takes a row and column and 
returns a Cell object.  The Cell object has a Range property that returns a 
Range object for the cell in question that we can use to set the text and 
formatting of the cell.  The code that sets the cells of the table is shown 
below. Note that as in most of the Office object models, the indices are 1-
based meaning they start with one as the minimum value rather than being 0-
based and starting with zero as the minimum value. 
for (columnIndex = 1; columnIndex <= columnCount; 
columnIndex++) 
Word.Cell cell = table.Cell(rowIndex, columnIndex); 
cell.Range.Text = splitRow[columnIndex]; 
Code to set the formatting of the table by setting the table to size to fit 
contents and bolding the header row is shown below.  We use the Row object 
returned by 
table.Rows[1]
which also has a Range property that returns a 
Range object for the row in question.  Also, we encounter code that sets the 
first row of the table to be bolded.  One would expect to be able to write the 
code 
table.Rows[1].Range.Bold = true
, but Word’s object model 
expects an 
int
value (0 or 1) rather than a 
bool
.  This is one of many 
examples you will come across where the Office object models don’t match 
.NET guidelines because of their origins in COM. 
// Format table 
table.Rows[1].Range.Bold = 1; 
Documents you may be interested
Documents you may be interested