open pdf in webbrowser control c# : How to delete text from a pdf in acrobat SDK application service wpf html windows dnn hostwin32-part234

call module('abc',1,2);
/* passing an expression as the */
/*   second argument - INVALID  */
call module('abc',1,x+1);
run;
In the above example, the first call to MODULE is correct because the variable x is 
updated with what the abc routine returns for the second argument. The second call to 
MODULE is not correct because a constant is passed. MODULE issues a warning 
indicating you have passed a constant, and MODULE passes a temporary area instead. 
The third call to MODULE is not correct as an arithmetic expression is passed, causing a 
temporary location from the DATA step to be used. The returned value is lost.
Specifying Formats and Informats to Use with MODULE Arguments
Overview of Specifying Formats and Informats to Use with MODULE 
Arguments
You specify the SAS format and informat for each DLL routine argument by specifying 
in the attribute table the FORMAT attribute in the ARG statement. The format indicates 
how numeric and character values should be passed to the DLL routine and how they 
should be read back upon completion of the routine.
Usually, the format that you use corresponds to a variable type for a given programming 
language. The following sections describe the proper formats that correspond to different 
variable types in various programming languages.
Note: For information about passing character data other than as pointers to character 
strings, see “$BYVALw. Format” on page 304 .
C Language Formats
Table 13.1 C Language Formats
C Type
SAS Format Informat
double
RB8.
float
FLOAT4.
signed int
IB4.
signed short
IB2.
signed long
IB4.
char *
IB4. (32-bit SAS)
char *
IB8 (x64)
unsigned int
PIB4.
unsigned short
PIB2.
Special Considerations When Using External DLLs
301
How to delete text from a pdf in acrobat - delete, remove text from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Allow C# developers to use mature APIs to delete and remove text content from PDF document
delete text pdf; how to delete text in pdf preview
How to delete text from a pdf in acrobat - VB.NET PDF delete text library: delete, remove text from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Programming Guide to Delete Text from PDF File
how to delete text from a pdf in acrobat; remove text from pdf preview
C Type
SAS Format Informat
unsigned long
PIB4.
char[w]
$CHARw. or $CSTRw. (see “$CSTRw. 
Format” on page 304 )
Fortran Language Formats
Table 13.2 Fortran Language Formats
Fortran Type
SAS Format Informat
integer*2
IB2.
integer*4
IB4.
real*4
FLOAT4.
real*8
RB8.
character*w
$CHARw.
The MODULE routines can support Fortran character arguments only if they are not 
expected to be passed by descriptor.
PL/I Language Formats
Table 13.3 PL/I Language Formats
PL/I Type
SAS Format Informat
FIXED BIN(15)
IB2.
FIXED BIN(31)
IB4.
FLOAT BIN(21)
RB4.
FLOAT BIN(31)
RB8.
CHARACTER(w)
$CHARw.
The PL/I descriptions are added here for completeness; this action does not guarantee 
that you can invoke PL/I routines.
COBOL Language Formats
302
Chapter 13 • Accessing External DLLs from SAS under Windows
.NET PDF Document Viewing, Annotation, Conversion & Processing
Redact text content, images, whole pages from PDF file. Annotate & Comment. Edit, update, delete PDF annotations from PDF file. Print.
pdf text remover; delete text from pdf file
C# PDF Converter Library SDK to convert PDF to other file formats
Allow users to convert PDF to Text (TXT) file. can manipulate & convert standard PDF documents in other external third-party dependencies like Adobe Acrobat.
delete text in pdf file online; how to delete text in pdf acrobat
Table 13.4 COBOL Language Formats
COBOL Format
SAS
Format Informat
Description
PIC Sxxxx BINARY
IBw.
integer binary
COMP-2
RB8.
double-precision 
floating point
COMP-1
RB4.
single-precision 
floating point
PIC xxxx or Sxxxx
Fw.
printable numeric
PIC yyyy
$CHARw.
character
The following COBOL specifications might not properly match with the Institute-
supplied formats because zoned and packed decimal are not truly defined for systems 
based on Intel architecture.
Table 13.5 COBOL Language Formats (zoned and packed decimal)
COBOL Format
SAS
Format Informat
Description
PIC Sxxxx DISPLAY
ZDw.
zoned decimal
PIC Sxxxx PACKED-DECIMAL
PDw.
packed decimal
The following COBOL specifications do not have true native equivalents and are usable 
in conjunction with the corresponding S370Fxxx informat and format. The S370F 
elements allow for IBM mainframe-style representations to be read and written in the PC 
environment.
Table 13.6 COBOL Language Formats (PC environment)
COBOL Format
SAS Format Informat
Description
PIC xxxx DISPLAY
S370FZDUw.
zoned decimal 
unsigned
PIC Sxxxx DISPLAY SIGN 
LEADING
S370FZDLw.
zoned decimal leading 
sign
PIC Sxxxx DISPLAY SIGN 
LEADING SEPARATE
S370FZDSw.
zoned decimal leading 
sign separate
PIC Sxxxx DISPLAY SIGN 
TRAILING SEPARATE
S370FZDTw.
zoned decimal trailing 
sign separate
Special Considerations When Using External DLLs
303
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. PowerPoint to PDF Conversion.
how to delete text in pdf converter professional; how to delete text from pdf reader
C# Word - Word Conversion in C#.NET
Word documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Word to PDF Conversion.
pull text out of pdf; delete text from pdf acrobat
COBOL Format
SAS Format Informat
Description
PIC xxxx BINARY
S370FIBUw.
integer binary unsigned
PIC xxxx PACKED-DECIMAL
S370FPDUw.
packed decimal 
unsigned
$CSTRw. Format
If you pass a character argument as a null-terminated string, use the $CSTRw. format. 
This format looks for the last nonblank character of your character argument and passes 
a copy of the string with a null terminator after the last nonblank character. For example, 
the following code fragment displays an attribute table entry:
* attribute table entry;
routine abc minarg=1 maxarg=1;
arg 1 input char format=$cstr10.;
you can use the following DATA step:
data _null_;
rc = module('abc','my string');
run;
The $CSTR format adds a null terminator to the character string my string before 
passing it to the abc routine. This action is equivalent to the following attribute entry:
* attribute table entry;
routine abc minarg=1 maxarg=1;
arg 1 input char format=$char10.;
with the following DATA step:
data _null_;
rc = module('abc','my string'||'00'x);
run;
The first example is easier to understand and easier to use when using variable or 
expression arguments.
The $CSTR informat converts a null-terminated string into a blank-padded string of the 
specified length. If the DLL routine is supposed to update a character argument, use the 
$CSTR informat in the argument attribute.
$BYVALw. Format
When you use a MODULE function to pass a single character by value, the argument is 
automatically promoted to an integer. If you want to use a character expression in the 
MODULE call, you must use the special format and informat called $BYVALw. The 
$BYVALw. format and informat expects a single character and can produce a numeric 
value, the size of which depends on w. $BYVAL2. produces a short, $BYVAL4. 
produces a long, and $BYVAL8. produces a double. Consider this example using the C 
language:
long xyz(a,b)
long a; double b;
{
static char c = 'Y';
if (a == 'X')
return(1);
304
Chapter 13 • Accessing External DLLs from SAS under Windows
VB.NET PDF: How to Create Watermark on PDF Document within
create a watermark that consists of text or image (such And with our PDF Watermark Creator, users need no external application plugin, like Adobe Acrobat.
erase text from pdf file; how to edit and delete text in pdf file online
C# Windows Viewer - Image and Document Conversion & Rendering in
standard image and document in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Convert to PDF.
delete text pdf acrobat; how to delete text from a pdf
else if (b == c)
return(2);
else return(3);
In this example, the xyz routine expects two arguments, a long and a double. If the long 
is an X, the actual value of the long is 88 in decimal. This value is because an ASCII X is 
stored as hexadecimal 58, and this value is promoted to a long, represented as 
0x00000058 (or 88 decimal). If the value of a is X, or 88, a 1 is returned. If the second 
argument, a double, is Y (which is interpreted as 89), then 2 is returned.
Now suppose that you want to pass characters as the arguments to xyz. In C, you would 
invoke them as follows:
x = xyz('X',(double)'Z');
y = xyz('Q',(double)'Y');
This action occurs because X and Q values are automatically promoted to ints (which are 
the same as longs for the sake of this example). The integer values corresponding to 
and Y are cast to doubles.
To call xyz using the MODULEN function, your attribute table must reflect the fact that 
you want to pass characters:
routine xyz minarg=2 maxarg=2 returns=long;
arg 1 input char byvalue format=$byval4.;
arg 2 input char byvalue format=$byval8.;
Note that it is important that the BYVALUE option appear in the ARG statement as well. 
Otherwise, MODULEN assumes that you want to pass a pointer to the routine, instead of 
a value.
Here is the DATA step that invokes MODULEN and passes it characters:
data _null_;
x = modulen('xyz','X','Z');
put x= ' (should be 1)';
y = modulen('xyz','Q','Y');
put y= ' (should be 2)';
run;
Understanding MODULE Log Messages
If you specify i in the control string parameter to MODULE, SAS prints several 
informational messages to the log. You can use these messages to determine whether you 
have passed incorrect arguments or coded the attribute table incorrectly.
Consider this example that uses MODULEIN from within the IML procedure. It uses the 
MODULEIN function to invoke the changi routine (stored in theoretical 
TRYMOD.DLL). In the example, MODULEIN passes the constant 6 and the matrix x2, 
which is a 4x5 matrix to be converted to an integer matrix. The attribute table for 
changi is as follows:
routine changi module=trymod returns=long;
arg 1 input num format=ib4. byvalue;
arg 2 update num format=ib4.;
The following IML step invokes MODULEIN:
proc iml;
x1 = J(4,5,0);
Special Considerations When Using External DLLs
305
C# Excel - Excel Conversion & Rendering in C#.NET
Excel documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Excel to PDF Conversion.
acrobat delete text in pdf; remove text from pdf online
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
other documents are compatible, including PDF, TIFF, MS free hand, free hand line, rectangle, text, hotspot, hotspot more plug-ins needed like Acrobat or Adobe
erase pdf text online; acrobat remove text from pdf
do i=1 to 4;
do j=1 to 5;
x1[i,j] = i*10+j+3;
end;
end;
y1= x1;
x2 = x1;
y2 = y1;
rc = modulein('*i','changi',6,x2);
....
The '*i' control string causes the lines shown in Output 13.1 on page 306 to be 
printed in the log.
Output 13.1 MODULEIN Output
---PARM LIST FOR MODULEIN ROUTINE---  CHR PARM 1 885E0AA8 2A69 (*i)
CHR PARM 2 885E0AD0 6368616E6769 (changi)
NUM PARM 3 885E0AE0 0000000000001840
NUM PARM 4 885E07F0
0000000000002C400000000000002E40000000000000304000000000000031400000000000003240
000000000000384000000000000039400000000000003A400000000000003B400000000000003C40
0000000000004140000000000080414000000000
---ROUTINE changi LOADED AT ADDRESS 886119B8 (PARMLIST AT 886033A0)--- PARM 1
06000000     <CALL-BY-VALUE>
PARM 2 88604720
0E0000000F00000010000000110000001200000018000000190000001A0000001B0000001C000000
22000000230000002400000025000000260000002C0000002D0000002E0000002F00000030000000
---VALUES UPON RETURN FROM changi ROUTINE---   PARM 1 06000000    
<CALL-BY-VALUE>
PARM 2 88604720
140000001F0000002A0000003500000040000000820000008D00000098000000A3000000AE000000
F0000000FB00000006010000110100001C0100005E01000069010000740100007F0100008A010000
---VALUES UPON RETURN FROM MODULEIN ROUTINE---  NUM PARM 3 885E0AE0
0000000000001840
NUM PARM 4 885E07F0
00000000000034400000000000003F4000000000000045400000000000804A400000000000005040
00000000004060400000000000A06140000000000000634000000000006064400000000000C06540
0000000000006E400000000000606F4000000000
The output is divided into four sections.
1. The first section describes the arguments passed to MODULEIN.
The 'CHR PARM n' portion indicates that character parameter n was passed. In the 
example, 885E0AA8 is the actual address of the first character parameter to 
MODULEIN. The value at the address is hexadecimal 2A69, and the ASCII 
representation of that value ('*i') is in parentheses after the hexadecimal value. The 
second parameter is likewise printed. The first two arguments print their ASCII 
equivalents. They are printed because other arguments might contain unreadable 
binary data.
The remaining parameters appear with only hexadecimal representations of their 
values (NUM PARM 3 and NUM PARM 4 in the example).
The third parameter to MODULEIN is numeric, and it is at address 885E0AE0. The 
hexadecimal representation of the floating point number 6 is shown. The fourth 
parameter is at address 885E07F0, which points to an area containing all the values 
for the 4x5 matrix. The *i option prints the entire argument; be careful if you use 
this option with large matrices because the log might become quite large.
306
Chapter 13 • Accessing External DLLs from SAS under Windows
2. The second section of the log lists the arguments to be passed to the requested 
routine and, in this case, changed. This section is important for determining if the 
arguments are being passed to the routine correctly. The first line of this section 
contains the name of the routine and its address in memory. It also contains the 
address of the location of the parameter block that MODULEIN created.
The log contains the status of each argument as it is passed. For example, the first 
parameter in the example is call-by-value (as indicated in the log). The second 
parameter is the address of the matrix. The log shows the address, along with the 
data to which it points.
Note that all the values in the first parameter and in the matrix are long integers 
because the attribute table states that the format is IB4.
3. In the third section, the log contains the argument values upon return from changi. 
The call-by-value argument is unchanged, but the other argument (the matrix) 
contains different values.
4. The last section of the log output contains the values of the arguments as they are 
returned to the MODULEIN calling routine.
Examples
Updating a Character String Argument
This example uses the Win32 routine GetTempPathA. This routine expects as an 
argument a pointer to a buffer, along with the length of the buffer. GetTempPathA fills 
the buffer with a null-terminated string representing the temporary path. Here is the C 
prototype for the GetTempPathA routine:
DWORD WINAPI GetTempPathA
(DWORD nBufferLength, LPSTR lpBuffer);
Here is the attribute table:
routine GetTempPathA
minarg=2
maxarg=2
stackpop=called
returns=long;
arg 1 input  byvalue format=pib4.;
arg 2 update         format=$cstr200.;
Note that the STACKPOP=CALLED option is used; all Win32 service routines require 
this attribute. The first argument is passed by value because it is an input argument only. 
The second argument is an update argument because the contents of the buffer are to be 
updated. The $CSTR200. format allows for a 200-byte character string that is null-
terminated.
Here is the SAS code to invoke the function. In this example, the DLL name 
(KERNEL32) is explicitly given in the call (because the MODULE attribute was not 
used in the attribute file):
filename sascbtbl "sascbtbl.dat";
data _null_;
length path $200;
n = modulen( '*i',
Examples
307
"KERNEL32,GetTempPathA", 199, path );
put n= path=;
run;
Note: KERNEL32.DLL is an internal DLL provided by Windows. Its routines are 
described in the Microsoft Win32 SDK.
The code produces these log messages:
NOTE: Variable PATH is uninitialized.
N=7 PATH=C:\TEMP
The example uses 199 as the buffer length because PATH can hold up to 200 characters 
with one character reserved for the null terminator. The $CSTR200. informat ensures 
that the null-terminator and all subsequent characters are replaced by trailing blanks 
when control returns to the DATA step.
Passing Arguments by Value
This example calls the Beep routine, part of the Win32 API in the KERNEL32 DLL. 
Here is the C prototype for Beep:
BOOL Beep(DWORD dwFreq, DWORD dwDuration)
Here is the attribute table to use:
routine Beep
minarg=2
maxarg=2
stackpop=called
callseq=byvalue
module=kernel32;
arg 1 num format=pib4.;
arg 2 num format=pib4.;
Because both arguments are passed by value, the example includes the 
CALLSEQ=BYVALUE attribute in the ROUTINE statement. It is not necessary to 
specify the BYVALUE option in each ARG statement.
Here is the sample SAS code used to call the Beep function:
filename sascbtbl 'sascbtbl.dat';
data _null_;
rc = modulen("*e","Beep",1380,1000);
run;
The computer speaker beeps.
Using PEEKCLONG to Access a Returned Pointer
The following example uses the lstrcat routine, part of the Win32 API in 
KERNEL32.DLL. lstrcat accepts two strings as arguments, concatenates them, and 
returns a pointer to the concatenated string. The C prototype is
LPTSTR lstrcat (LPTSTR lpszString1, 
LPCTSTR lpszString2);
The following is the proper attribute table:
routine lstrcat
minarg=2
maxarg=2
308
Chapter 13 • Accessing External DLLs from SAS under Windows
stackpop=called
module=KERNEL32
returns=ptr;
arg 1 char format=$cstr200.;
arg 2 char format=$cstr200.;
To use lstrcat, you need to use the SAS PEEKCLONG function to access the data 
referenced by the returned pointer. Here is the sample SAS program that accesses 
lstrcat:
filename sascbtbl 'sascbtbl.dat';
data _null_;
length string1 string2 conctstr $200;
length charptr $20;
string1 = 'This is';
string2 = ' a test!';
charptr=modulec('lstrcat',string1,string2);
concatstr = peekclong(charptr,200);
put concatstr=;
run;
The following output appears in the log:
conctstr=This is a test!
Upon return from MODULEN, the pointer value is stored in RC. The example uses the 
PEEKCLONG function to return the 200 bytes at that location, using the $CSTR200. 
format to produce a blank-padded string that replaces the null termination.
For more information about the PEEKLONG functions, see “PEEKCLONG Function” 
in SAS Functions and CALL Routines: Reference and “PEEKLONG Function” in SAS 
Functions and CALL Routines: Reference
Using Structures
“Grouping SAS Variables as Structure Arguments” on page 299 describes how to use the 
FDSTART attribute to pass several arguments as one structure argument to a DLL 
routine. Refer to that section for an example of the GetClientRect attribute table and C 
language equivalent. This example shows how to invoke the GetClientRect function 
after defining the attribute table.
The most straightforward method works, but generates a warning message about the 
variables not being initialized:
filename sascbtbl 'sascbtbl.dat';
data _null_;
hwnd=modulen('GetForegroundWindow');
call module('GetClientRect',hwnd,
left,top,right,bottom);
put _all_;
run;
To remove the warning, you can use the RETAIN statement to initialize the variables to 
0. Also, you can use shorthand to specify the variable list in the MODULEN statement:
data _null_;
retain left top right bottom 0;
hwnd=modulen('GetForegroundWindow');
call module('GetClientRect',hwnd,
of left--bottom);
Examples
309
put _all_;
run;
Note that the OF keyword indicates that what follows is a list of variables, in this case 
delimited by the double-dash. The output in the log varies depending on the active 
window and looks something like the following:
HWND=3536768 LEFT=2 TOP=2 RIGHT=400
BOTTOM=587
Invoking a DLL Routine from PROC IML
This example shows how to pass a matrix as an argument within PROC IML. The 
example creates a 4x5 matrix. Each cell is set to 10x+y+3, where x is the row number 
and y is the column number. For example, the cell at row 1 column 2 is set to 
(10*1)+2+3, or 15.
The example invokes several routines from the theoretical TRYMOD DLL. It uses the 
changd routine to add 100x+10y to each element, where x is the C row number (0 
through 3) and y is the C column number (0 through 4). The first argument to changd 
indicates what extra amount to sum. The changdx routine works just like changd
except that it expects a transposed matrix. The changi routine works like changd 
except that it expects a matrix of integers. The changix routine works like changdx 
except that integers are expected.
Note: A maximum of three arguments can be sent when invoking a DLL routine from 
PROC IML.
In this example, all four matrices x1, x2, y1, and y2 should become set to the same 
values after their respective MODULEIN calls. Here are the attribute table entries:
routine changd module=trymod returns=long;
arg 1 input num format=rb8. byvalue;
arg 2 update num format=rb8.;
routine changdx module=trymod returns=long
transpose=yes;
arg 1 input num format=rb8. byvalue;
arg 2 update num format=rb8.;
routine changi module=trymod returns=long;
arg 1 input num format=ib4. byvalue;
arg 2 update num format=ib4.;
routine changix module=trymod returns=long
transpose=yes;
arg 1 input num format=ib4. byvalue;
arg 2 update num format=ib4.;
Here is the PROC IML step:
proc iml;
x1 = J(4,5,0);
do i=1 to 4;
do j=1 to 5;
x1[i,j] = i*10+j+3;
end;
end;
y1= x1; x2 = x1; y2 = y1;
rc = modulein('changd',6,x1);
rc = modulein('changdx',6,x2);
rc = modulein('changi',6,y1);
310
Chapter 13 • Accessing External DLLs from SAS under Windows
Documents you may be interested
Documents you may be interested