pdf viewer in mvc c# : Copy and paste image from pdf to word control application system azure html .net console TET-4.2-manual2-part1739

2.3  Command-Line Examples 21
2.3 Command-Line Examples
The following examples demonstrate some useful combinations of TET command-line 
options. The samples are shown in two variations; the first uses the long format of all 
options, while the second uses the equivalent short option format.
2.3.1 Extracting Text
Extract the text from a PDF document file.pdf in UTF-8 format and store it in file.txt:
tet file.pdf
Exclude the first and last page from text extraction:
tet --firstpage 2 --lastpage last-1 file.pdf
tet -f 2 -l last-1 file.pdf
Supply a directory where the CJK CMaps are located (required for CJK text extraction):
tet --searchpath /usr/local/cmaps file.pdf
tet -s /usr/local/cmaps file.pdf
Extract the text from a PDF in UTF-16 format and store it in file.utf16:
tet --format utf16 --outfile file.utf16 file.pdf
tet --format utf16 -o file.utf16 file.pdf
Extract the text from all PDF files in a directory and store the generated *.txt files in an-
other directory (which must already exist):
tet --targetdir out in/*.pdf
tet -t out in/*.pdf
Extract the text from all PDF files from two directories and store the generated *.txt files 
in the same directory as the corresponding input document:
tet --samedir dir1/*.pdf dir2/*.pdf
Restrict text extraction to a particular area on the page; this can be achieved by supply-
ing a suitable list of page options:
tet --pageopt "includebox={{0 0 200 200}}" file.pdf
Use a response file which contains various command-line options and process all PDF 
documents in the current directory (the file options contains command-line options):
tet @options *.pdf
2.3.2 Extracting Images
Extract images from file.pdf in a page-oriented manner and store them in file*.tif/file*.jpg 
in the directory out:
tet --targetdir out --image file.pdf
tet -t out -i file.pdf
Copy and paste image from pdf to word - copy, paste, cut PDF images in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Detailed tutorial for copying, pasting, and cutting image in PDF page using C# class code
how to copy pdf image to word document; preview paste image into pdf
Copy and paste image from pdf to word - VB.NET PDF copy, paste image library: copy, paste, cut PDF images in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Tutorial for How to Cut or Copy an Image from One Page and Paste to Another
how to paste a picture into a pdf document; how to copy picture from pdf and paste in word
22
Chapter 2:  TET Command-Line Tool
Extract images from file.pdf in a resource-oriented manner and store them in file*.tif/
file*.jpg in the directory out:
tet --targetdir out --image --imageloop resource file.pdf
tet -t out -i --imageloop resource file.pdf
Extract images from file.pdf without image merging; this can be achieved by supplying a 
suitable list of page options which are relevant for image processing:
tet --targetdir out --image --pageopt "imageanalysis={merge={disable}}" file.pdf
tet -t out -i --pageopt "imageanalysis={merge={disable}}" file.pdf
2.3.3 Generating TETML
Generate TETML output in word mode for PDF document file.pdf and store it in file.tetml:
tet --tetml word file.pdf
tet -m word file.pdf
Generate TETML output without any Options elements; this can be achieved by supply-
ing a suitable list of document options:
tet --docopt "tetml={elements={options=false}}" --tetml word file.pdf
Generate TETML output in word mode with all glyph details and store it in file.tetml:
tet --tetml word --pageopt "tetml={glyphdetails={all}}" file.pdf
tet -m word --pageopt "tetml={glyphdetails={all}}" file.pdf
Extract images and generate TETML in a single call:
tet --image --tetml word file.pdf
tet -i -m word file.pdf
Generate TETML output with topdown coordinates:
tet --tetml word --pageopt "topdown={output}" file.pdf
tet -m word --pageopt "topdown={output}" file.pdf
2.3.4 Advanced Options
Supply the document option checkglyphlists to improve Unicode mapping for certain 
kinds of TeX-generated PDF documents:
tet --docopt checkglyphlists file.pdf
Apply Unicode foldings, e.g. space folding: map all variants of Unicode space characters 
to U+0020:
tet --docopt "fold={{[:blank:] U+0020}}" file.pdf
Disable punctuation as word boundary:
tet --pageopt "contentanalysis={punctuationbreaks=false}" file.pdf
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
How to C#: Extract Image from PDF Document. List<PDFImage> allImages = PDFImageHandler. ExtractImages(page); C#: Select An Image from PDF Page by Position.
how to cut a picture out of a pdf file; how to copy pictures from a pdf to word
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Ability to copy selected PDF pages and paste into another The portable document format, known as PDF document, is a widely-used form of file that allows
how to copy and paste a picture from a pdf; how to paste a picture in a pdf
3.1  Exception Handling 23
3TET Library Language Bindings
This chapter discusses specifics for the language bindings which are supplied for the 
TET library. The TET distribution contains full sample code for several small TET appli-
cations in all supported language bindings.
3.1 Exception Handling
Errors of a certain kind are called exceptions in many languages for good reasons – they 
are mere exceptions, and are not expected to occur very often during the lifetime of a 
program. The general strategy is to use conventional error reporting mechanisms (read: 
special error return codes) for function calls which may go wrong often times, and use a 
special exception mechanism for those rare occasions which don’t justify cluttering the 
code with conditionals. This is exactly the path that TET goes: Some operations can be 
expected to go wrong rather frequently, for example:
>Trying to open a PDF document for which one doesn’t have the proper password (but 
see also the shrug feature described in Section 5.1, »Extracting Content from protect-
ed PDF«, page 59);
>Trying to open a PDF document with a wrong file name;
>Trying to open a PDF document which is damaged beyond repair.
TET signals such errors by returning a value of –1 as documented in the API reference. 
Other events may be considered harmful, but will occur rather infrequently, e.g.
>running out of virtual memory;
>supplying wrong function parameters (e.g. an invalid document handle);
>supplying malformed option lists;
>a required resource (e.g. a CMap file for CJK text extract) cannot be found.
When TET detects such a situation, an exception will be thrown instead of passing a spe-
cial error return value to the caller. In languages which support native exceptions 
throwing the exception will be done using the standard means supplied by the lan-
guage or environment. For the C language binding TET supplies a custom exception 
handling mechanism which must be used by clients (see Section 3.2, »C Binding«, page 
24).
It is important to understand that processing a document must be stopped when an 
exception occurred. The only methods which can safely be called after an exception are 
delete( ), get_apiname( ), get_errnum( ), and get_errmsg( ). Calling any other method after 
an exception may lead to unexpected results. The exception will contain the following 
information:
>A unique error number;
>The name of the API function which caused the exception;
>A descriptive text containing details of the problem;
Querying the reason of a failed function call. Some TET function calls, e.g. open_
document( ) or open_page( ), can fail without throwing an exception (they will return -1 
in case of an error). In this situation the functions get_errnum( ), get_errmsg( ), and get_
apiname( ) can be called immediately after a failed function call in order to retrieve de-
tails about the nature of the problem.
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
VB.NET PDF - Extract Image from PDF Document in VB.NET. Support PDF VB.NET : Select An Image from PDF Page by Position. Sample for
copy and paste image from pdf; copy images from pdf file
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
VB.NET DLLs: Extract, Copy and Paste PDF Page. Dim page As PDFPage = doc.GetPage(3) ' Select image by the point (50F, 100F).
paste picture into pdf; paste image in pdf file
24
Chapter 3:  TET Library Language Bindings
3.2 C Binding
TET is written in C with some C++ modules. In order to use the C binding you can use a 
static or shared library (DLL on Windows and MVS), and you need the central TET in-
clude file tetlib.h for inclusion in your client source modules.
Note Applications which use the TET binding for C must be linked with a C++ compiler since the li-
brary includes some parts which are implemented in C++. Using a C linker may result in unre-
solved externals unless the application is linked against the required C++ support libraries.
Exception handling. The TET API provides a mechanism for acting upon exceptions 
thrown by the library in order to compensate for the lack of native exception handling 
in the C language. Using the TET_TRY( ) and TET_CATCH( ) macros client code can be set up 
such that a dedicated piece of code is invoked for error handling and cleanup when an 
exception occurs. These macros set up two code sections: the try clause with code which 
may throw an exception, and the catch clause with code which acts upon an exception. 
If any of the API functions called in the try block throws an exception, program execu-
tion will continue at the first statement of the catch block immediately. The following 
rules must be obeyed in TET client code:
>TET_TRY( ) and TET_CATCH( ) must always be paired.
>TET_new( ) will never throw an exception; since a try block can only be started with a 
valid TET object handle, TET_new( ) must be called outside of any try block.
>TET_delete( ) will never throw an exception, and therefore can safely be called outside 
of any try block. It can also be called in a catch clause.
>Special care must be taken about variables that are used in both the try and catch 
blocks. Since the compiler doesn’t know about the transfer of control from one block 
to the other, it might produce inappropriate code (e.g., register variable optimiza-
tions) in this situation.
Fortunately, there is a simple rule to avoid this kind of problem: Variables used in 
both the try and catch blocks must be declared volatile. Using the volatile keyword sig-
nals to the compiler that it must not apply dangerous optimizations to the variable.
>If a try block is left (e.g., with a return statement, thus bypassing the invocation of 
the corresponding TET_CATCH( )), the TET_EXIT_TRY( ) macro must be called before the 
return statement to inform the exception machinery.
>As in all TET language bindings document processing must stop when an exception 
was thrown.
The following code fragment demonstrates these rules with the typical idiom for deal-
ing with TET exceptions in client code (a full sample can be found in the TET package):
volatile int pageno;
...
if ((tet = TET_new()) == (TET *) 0)
{
printf("out of memory\n");
return(2);
}
TET_TRY(tet)
{
for (pageno = 1; pageno <= n_pages; ++pageno)
{
/* process page */
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
A convenient C#.NET control able to turn all Word text and image content into high quality PDF without losing formatting. Convert
paste image in pdf preview; cut and paste pdf images
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
key. Quick to remove watermark and save PDF text, image, table, hyperlink and bookmark to Word without losing format. Powerful components
paste image into pdf preview; pasting image into pdf
3.2  C Binding 25
if (/* error happened */)
{
TET_EXIT_TRY(tet);
return -1;
}
}
/* statements that directly or indirectly call API functions */
}
TET_CATCH(tet)
{
printf("Error %d in %s() on page %d: %s\n",
TET_get_errnum(tet), TET_get_apiname(tet), pageno, TET_get_errmsg(tet));
}
TET_delete(tet);
Unicode handling for name strings. The C language does not natively support Uni-
code. Some string parameters for API functions may be declared as name strings. These 
are handled depending on the length parameter and the existence of a BOM at the be-
ginning of the string. In C, if the length parameter is different from 0 the string will be 
interpreted as UTF-16. If the length parameter is 0 the string will be interpreted as UTF-8 
if it starts with a UTF-8 BOM, or as EBCDIC UTF-8 if it starts with an EBCDIC UTF-8 BOM, 
or as auto encoding if no BOM is found (or ebcdic on all EBCDIC-based platforms).
Unicode handling for option lists. Strings within option lists require special attention 
since they cannot be expressed as Unicode strings in UTF-16 format, but only as byte ar-
rays. For this reason UTF-8 is used for Unicode options. By looking for a BOM at the be-
ginning of an option TET decides how to interpret it. The BOM will be used to determine 
the format of the string. More precisely, interpreting a string option works as follows:
>If the option starts with a UTF-8 BOM (\xEF\xBB\xBF) it is interpreted as UTF-8.
>If the option starts with an EBCDIC UTF-8 BOM (\x57\x8B\xAB) it is interpreted as 
EBCDIC UTF-8.
>If no BOM is found, the string is treated as winansi (or ebcdic on EBCDIC-based plat-
forms).
Note The TET_convert_to_unicode( ) utility function can be used to create UTF-8 strings from UTF-16 
strings, which is useful for creating option lists with Unicode values.
Using TET as a DLL loaded at runtime. While most clients will use TET as a statically 
bound library or a dynamic library which is bound at link time, you can also load the 
DLL at runtime and dynamically fetch pointers to all API functions. This is especially 
useful to load the DLL only on demand, and on MVS where the library is customarily 
loaded as a DLL at runtime without explicitly linking against TET. TET supports a special 
mechanism to facilitate this dynamic usage. It works according to the following rules:
>Include tetlibdl.h instead of tetlib.h.
>Use TET_new_dl( ) and TET_delete_dl( ) instead of TET_new( ) and TET_delete( ).
>Use TET_TRY_DL( ) and TET_CATCH_DL( ) instead of TET_TRY( ) and TET_CATCH( ).
>Use function pointers for all other TET calls.
>Compile the auxiliary module tetlibdl.c and link your application against the result-
ing object file.
The dynamic loading mechanism is demonstrated in the extractordl.c sample.
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. using RasterEdge.XDoc.PDF; Convert PDF to Word Document in VB.NET Demo Code.
copy image from pdf to word; copy and paste image from pdf to pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET PDF - Add Image to PDF Page in VB.NET. Insert Image to PDF Page Using VB. Add necessary references: RasterEdge.Imaging.Basic.dll.
how to copy a picture from a pdf; how to copy pdf image into word
26
Chapter 3:  TET Library Language Bindings
3.3 C++ Binding
Note For applications written in C++ we recommend to access the TET .NET DLL directly instead of 
via the C++ binding (except for cross-platform applications which should use the C++ binding). 
The TET distribution contains C++ sample code for use with .NET CLI which demonstrates this 
combination.
In addition to the tetlib.h C header file, an object-oriented wrapper for C++ is supplied 
for TET clients. It requires the tet.hpp header file, which in turn includes tetlib.h. Since 
tet.hpp contains a template-based implementation no corresponding tet.cpp module is 
required. Using the C++ object wrapper replaces the functional approach with API func-
tions and TET_ prefixes in all TET function names with a more object-oriented ap-
proach.
String handling in C++. TET’s template-based string handling approach supports the 
following usage patterns with respect to string handling:
>Strings of the C++ standard library type std::wstring are used as basic string type. 
They can hold Unicode characters encoded as UTF-16 or UTF-32. This is the default be-
havior since TET 4.0 and the recommended approach for new applications unless 
custom data types (see next item) offer a significant advantage over wstrings.
>Custom (user-defined) data types for string handling can be used as long as the cus-
tom data type is an instantiation of the basic_string class template and can be con-
verted to and from Unicode via user-supplied converter methods.
>Plain C++ strings can be used for compatibility with existing C++ applications which 
have been developed against TET 3.0 or earlier versions. This compatibility variant is 
only meant for existing applications (see below for notes on source code compatibil-
ity).
The new interface assumes that all strings passed to and received from TET methods are 
native wstrings. Depending on the size of the wchar_t data type, wstrings are assumed to 
contain Unicode strings encoded as UTF-16 (2-byte characters) or UTF-32 (4-byte charac-
ters). Literal strings in the source code must be prefixed with L to designate wide strings. 
Unicode characters in literals can be created with the \u and \U syntax. Although this 
syntax is part of standard ISO C++, some compilers don’t support it. In this case literal 
Unicode characters must be created with hex characters.
Note On EBCDIC-based systems the formatting of option list strings for the wstring-based interface 
requires additional conversions to avoid a mixture of EBCDIC and UTF-16 wstrings in option 
lists. Convenience code for this conversion and instructions are available in the auxiliary mod-
ule utf16num_ebcdic.hpp.
Adjusting applications to the new C++ binding. Existing C++ applications which have 
been developed against TET 3.0 or earlier versions can be adjusted as follows:
>Since the TET C++ class now lives in the pdflib namespace the class name must be 
qualified. In order to avoid the pdflib::TET construct client applications should add 
the following before using TET methods:
using namespace pdflib;
>Switch the application’s string handling to wstrings. This includes data from external 
sources. However, string literals in the source code (including option lists) must also 
be adjusted by prepending the L prefix, e.g.
3.3  C++ Binding 27
const wstring pageoptlist = L"granularity=page";
>Suitable wstring-capable methods (wcerr etc.) must be used to process TET error mes-
sages and exception strings (get_errmsg( ) method in the TET and TET::Exception class-
es).
>The tet.cpp module is no longer required for the TET C++ binding. Although the TET 
distribution contains a dummy implementation of this module, it should be re-
moved from the build process for TET applications.
Full source code compatibility with legacy applications. The new C++ binding has been 
designed with application-level source code compatibility mind, but client applications 
must be recompiled. The following aids are available to achieve full source code com-
patibility for legacy applications:
>Disable the wstring-based interface as follows before including tet.hpp:
#define TETCPP_TET_WSTRING 0
>Disable the pdflib namespace as follows before including tet.hpp:
#define TETCPP_USE_PDFLIB_NAMESPACE 0
Error handling in C++. TET API functions will throw a C++ exception in case of an error. 
These exceptions must be caught in the client code by using C++ try/catch clauses. In or-
der to provide extended error information the TET class provides a public TET::Exception 
class which exposes methods for retrieving the detailed error message, the exception 
number, and the name of the TET API function which threw the exception.
Native C++ exceptions thrown by TET routines will behave as expected. The follow-
ing code fragment will catch exceptions thrown by TET:
try {
...some TET instructions...
} catch (TET::Exception &ex) {
wcerr << L"Error " << ex.get_errnum()
<< L" in " << ex.get_apiname()
<< L"(): " << ex.get_errmsg() << endl;
}
Using TET as a DLL loaded at runtime. Similar to the C language binding the C++ bind-
ing allows you to dynamically attach TET to your application at runtime (see »Using TET 
as a DLL loaded at runtime«, page 25). Dynamic loading can be enabled as follows when 
compiling the application module which includes tet.hpp:
#define TETCPP_DL
1
In addition you must compile the auxiliary module tetlibdl.c and link your application 
against the resulting object file. Since the details of dynamic loading are hidden in the 
TET object it does not affect the C++ API: all method calls look the same regardless of 
whether or not dynamic loading is enabled. The dynamic loading mechanism is demon-
strated in the extractordl sample in the shipped Makefile.
28
Chapter 3:  TET Library Language Bindings
3.4 COM Binding
Installing the TET COM edition. TET can be deployed in all environments that support 
COM components. Installing TET is an easy and straight-forward process. Please note 
the following:
>If you install on an NTFS partition all TET users must have read permission for the 
installation directory, and execute permission for
...\TET 4.2 32-bit\bind\COM\bin\tet_com.dll.
>The installer must have write permission for the system registry. Administrator or 
Power Users group privileges will usually be sufficient.
Exception Handling. Exception handling for the TET COM component is done accord-
ing to COM conventions: when a TET exception occurs, a COM exception will be raised 
and furnished with a clear-text description of the error. In addition the memory allocat-
ed by the TET object is released. The COM exception can be caught and handled in the 
TET client in whichever way the client environment supports for handling COM errors.
Using the TET COM Edition with .NET. As an alternative to the TET.NET edition (see 
Section 3.6, ».NET Binding«, page 31) the COM edition of TET can also be used with .NET. 
First, you must create a .NET assembly from the TET COM edition using the tlbimp.exe 
utility:
tlbimp tet_com.dll /namespace:tet_com /out:Interop.tet_com.dll
You can use this assembly within your .NET application. If you add a reference to tet_
com.dll from within Visual Studio .NET an assembly will be created automatically. The 
following code fragment shows how to use the TET COM edition with C#:
using TET_com;
...
static TET_com.ITET tet;
...
tet = New TET();
...
All other code works as with the .NET edition of TET.
3.5  Java Binding 29
3.5 Java Binding
Installing the TET Java edition. TET is organized as a Java package with the name 
com.pdflib.TET. This package relies on a native JNI library; both pieces must be configured 
appropriately.
In order to make the JNI library available the following platform-dependent steps 
must be performed:
>On Unix systems the library libtet_java.so (on OS X: libtet_java.jnilib) must be placed 
in one of the default locations for shared libraries, or in an appropriately configured 
directory.
>On Windows the library pdf_tet.dll must be placed in the Windows system directory, 
or a directory which is listed in the PATH environment variable.
The TET Java package is contained in the tet.jar file and contains a single class called tet. 
In order to supply this package to your application, you must add tet.jar to your 
CLASSPATH environment variable, add the option -classpath tet.jar in your calls to the 
Java compiler, or perform equivalent steps in your Java IDE. In the JDK you can config-
ure the Java VM to search for native libraries in a given directory by setting the 
java.library.path property to the name of the directory, e.g.
java -Djava.library.path=. extractor
You can check the value of this property as follows:
System.out.println(System.getProperty("java.library.path"));
Using TET in J2EE application servers and Servlet containers. TET is perfectly suited for 
server-side Java applications. The TET distribution contains sample code and configura-
tion for using TET in J2EE environments. The following configuration issues must be ob-
served:
>The directory where the server looks for native libraries varies among vendors. Com-
mon candidate locations are system directories, directories specific to the underly-
ing Java VM, and local server directories. Please check the documentation supplied 
by the server vendor.
>Application servers and Servlet containers often use a special class loader which may 
be restricted or uses a dedicated classpath. For some servers it is required to define a 
special classpath to make sure that the TET package will be found.
More detailed notes on using TET with specific Servlet engines and application servers 
can be found in additional documentation in the J2EE directory of the TET distribution.
Unicode and legacy encoding conversion. For the convenience of TET users we list 
some useful string conversion methods here. Please refer to the Java documentation for 
more details. The following constructor creates a Unicode string from a byte array, us-
ing the platform’s default encoding:
String(byte[] bytes)
The following constructor creates a Unicode string from a byte array, using the encod-
ing supplied in the enc parameter (e.g. SJIS, UTF8, UTF-16):
String(byte[] bytes, String enc)
30
Chapter 3:  TET Library Language Bindings
The following method of the String class converts a Unicode string to a string according 
to the encoding specified in the enc parameter:
byte[] getBytes(String enc)
Javadoc documentation for TET. The TET package contains Javadoc documentation for 
TET. The Javadoc contains only abbreviated descriptions of all TET API methods; please 
refer to Section 10, »TET Library API Reference«, page 141, for more details.
In order to configure Javadoc for TET in Eclipse proceed as follows:
>In the Package Explorer right-click on the Java project and select Javadoc Location.
>Click on Browse... and select the path where the Javadoc (which is part of the TET 
package) is located.
After these steps you can browse the Javadoc for TET, e.g. with the Java Browsing perspec-
tive or via the Help menu.
Exception handling. The TET language binding for Java will throw native Java excep-
tions of the class TETException. TET client code must use standard Java exception syntax:
TET tet = null;
try {
...TET method invocations...
} catch (TETException e) {
System.err.print("TET exception occurred:\n");
System.err.print("[" + e.get_errnum() + "] " + e.get_apiname() + ": " +
e.get_errmsg() + "\n");
} catch (Exception e) {
System.err.println(e.getMessage());
} finally {
if (tet != null) {
tet.delete();                     /* delete the TET object */
}
}
Since TET declares appropriate throws clauses, client code must either catch all possible 
exceptions or declare those itself.
Documents you may be interested
Documents you may be interested