c# itextsharp pdf page to image : Annotate protected pdf control application platform web page html asp.net web browser FBeginner9-part1256

One application of a pointer to pointer is the creation of memory arrays. The 
following program demonstrates the creation, manipulation and freeing of a memory 
array.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
OptionExplicit
'Declareapointertoanintpointer
DimmyMemArrayAsIntegerPtrPtr
DimAsIntegeri,j
'Create10rowsofintegerpointers
myMemArray=Callocate(10,Sizeof(IntegerPtr))
'Add10columnsofintegerstoeachrow
Fori=0To9
myMemArray[i]=Callocate(10,Sizeof(Integer))
Next
'Addsomedatatothememorysegment
Fori=0To9
Forj=0To9
myMemArray[i][j]=Int(Rnd*10)
Next
Next
'Printoutdata
Fori=0To9
Forj=0To9
Print"i,j=";i;",";j;"MemArray=";myMemArray[i][j]
Next
Next
'Freememorysegment
Fori=0To9
DeallocatemyMemArray[i]
Next
'Freethepointertopointer
DeallocatemyMemArray
Sleep
End
Listing 8.6: memarray.bas
Analysis:
Line 4 dimensions a pointer to an integer pointer, myMemArray, which 
will simulate a two dimensional array, with myMemArray pointing to a list of integer 
91
Annotate protected pdf - C# PDF Password Library: add, remove, edit PDF file password in C#.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
add password to pdf file without acrobat; pdf passwords
Annotate protected pdf - VB.NET PDF Password Library: add, remove, edit PDF file password in vb.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
pdf protected mode; password on pdf
pointers. This list of pointers will comprise the “rows” of the array. Line 5 just declares 
some working variables that are used in the For-Next loops later in the program.
Line 8 creates the rows of the array by allocating a memory segment that will 
contain 4 integer pointers, which are initialized in lines 11 through 13. Remember that 
the index method of accessing a pointer automatically does the pointer arithmetic for 
you. The code in lines 11 through 13 iterates through the memory segment created in 
line 8 and initializes the memory segment with pointers to memory segments that will 
contain integers. In other words, you have a pointer that is pointing to a list of pointers. 
These newly created memory segments are the columns for each row. Each column index 
will be a pointer to a memory location containing an integer.
Lines 16 through 20 add some random numbers to the memory array. Notice that 
by using the indexing method you can access the memory array just like a normal array. i 
points to the row (the list of pointers) and j points to the individual columns within that 
row which contain the integer data. The same method is used in lines 23 through 27 to 
print out the array values.
Lines 30 through 32 free the individual rows of memory that were created in line 8. It is 
important that each row be freed before freeing myMemArray. If you were to just free 
myMemArray, the rows would still be in memory, but unaccessible, causing a memory 
leak. Once all the rows have been freed, myMemArray can be freed in line 34. Since the 
program is terminating, Deallocating the memory is not strictly required in this instance, 
but if you needed to reuse the memory,  then you must Deallocate in the method 
described, otherwise you will get a memory leak while the program is running. Lines 36 
and 37 close the program in the usual way.
Running the program should produce a result similar to the following.
i,j=0,1MemArray=5
i,j=0,2MemArray=1
i,j=0,3MemArray=8
i,j=0,4MemArray=5
i,j=1,0MemArray=4
i,j=1,1MemArray=3
i,j=1,2MemArray=8
i,j=1,3MemArray=8
i,j=1,4MemArray=7
i,j=2,0MemArray=1
i,j=2,1MemArray=8
i,j=2,2MemArray=7
i,j=2,3MemArray=5
i,j=2,4MemArray=3
i,j=3,0MemArray=0
i,j=3,1MemArray=0
i,j=3,2MemArray=3
92
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
Support for customizing image size. Password protected PDF document can be converted and changed. Open source codes can be added to C# class.
create password protected pdf reader; change password on pdf
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
PDF in C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET PDF Document Viewer, C#.NET Able to convert password protected PDF document.
pdf security password; convert password protected pdf to normal pdf
i,j=3,3MemArray=1
i,j=3,4MemArray=1
i,j=4,0MemArray=9
i,j=4,1MemArray=4
i,j=4,2MemArray=1
i,j=4,3MemArray=0
i,j=4,4MemArray=0
Output 8.4: Output of memarray.bas
As you can see from the output, the memory array behaves exactly like a 
predefined array. This structure is useful for adding dynamic arrays to type definitions, 
which normally cannot hold a dynamic array. You will see this in more detail in the 
chapter on composite types.
One last note on this program. If you run the program more than once, you will 
notice that the values in the array are always the same, even though the program is 
generating random numbers. This is because the program did not seed the random 
number generator using the Randomize statement. To get different numbers for each run, 
add RandomizeTimerbefore calling the Rnd function.
A Look Ahead
Pointers are an efficient and powerful data type, and you will be seeing more of 
them in this book, including the next chapter where you will explore the string data types 
available in FreeBasic.
93
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
Create editable Word file online without email. Supports transfer from password protected PDF. VB.NET class source code for .NET framework.
copy text from protected pdf; add password to pdf file
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Password protected PDF file can be printed to Word for mail merge. C# source code is available for copying and using in .NET Class.
copy protecting pdf files; open password protected pdf
9
String Data Types
Strings are an essential part of programming, and proper manipulation of  strings 
is an essential skill for any programmer. You will need to use strings in virtually every 
program you will write, from games to data entry programs. Strings are important 
because humans use strings to communicate concepts and ideas. A menu in a game 
communicates the various game options to the user. An address stored in a database 
communicates the location of the person who lives at that address. Programs are 
solutions to problems, and in most cases, must communicate that solution to the user 
through the use of strings.
Computers however, only understand numbers.  The string “¡FreeBasic está 
fresco!“ has no meaning to the computer. For the very first computers this did not matter 
much, since those early computers were just glorified calculators, albeit calculators that 
took up a whole room. However it soon became evident to computer engineers that in 
order for the computer to be a useful tool, it needed to be able to somehow recognize 
string data, and be able to manipulate that string data.
Since computers only understand numbers, the solution was to convert alpha-
numeric characters to numbers via translation tables. The familiar ASCII code table is one 
such translation scheme that takes a set of alpha-numeric characters and converts them 
to numbers. The “A” character is encoded as decimal 65, the exclamation point as 
decimal 33 and the number 1 is encoded as decimal 49. When you press any key on your 
keyboard, a scancode for that key is generated and stored in the computer as a number.
Humans group letters together to form words, and words to form sentences. A 
certain arrangement of letters and words mean something according to the semantic 
rules the writer's language. When you read the string “FreeBasic is cool!” you understand 
the meaning of the words if you can read the English language. The computer however 
doesn't know what FreeBasic is and doesn't know what it means to be cool. When you 
read that something is “cool” you know that this is slang for great or excellent. All the 
computer can do is store the string in memory in a way that preserves the format of the 
string so that a human reading the string will understand its meaning.
While computers have grown in both speed and capacity, the basic computing 
processes haven't changed since the 1950's. The next revolution in computing won't be 
quantum processors or holographic memory; it will be when computers can understand 
language.
The solution to the storage problem was to simply store string data in memory as a 
sequence of bytes, and terminate that sequence of bytes with a character 0. To put it 
another way, a string in computer memory is an array of characters, terminated with a 
character 0 to signal the end of the string. Virtually all early programming languages, and 
many modern ones, have no native String data type. A string in C is a Null (character 0) 
terminated array of Char, where Char can be interpreted as both a character and number. 
While this scheme accurately reflects the internal structure of a string in memory, it is 
hard to work with and error prone, and doesn't reflect the way humans work with string 
data. A better solution to the problem was the creation of the native String data type. The 
internal structure of a string has not changed, it is still stored in memory as a sequence 
94
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
Can I use RasterEdge C#.NET PDF document merging & splitting toolkit SDK to split password-protected PDF document using Visual C# code?
pdf password unlock; copy from protected pdf
.NET PDF SDK - Description of All PDF Processing Control Feastures
PDF Document Protect. PDF Password. Able to Open password protected PDF; Allow users to add password to PDF; Allow users to remove password from PDF;
acrobat password protect pdf; break a pdf password
of bytes terminated by a Null character, but the programmer can interact with string data 
in a more natural, humanistic way.
FreeBasic has four intrinsic string data types, listed in the following table.
String Type
Declaration
Purpose
Dynamic String
Dim myString as String
8-bit string that is 
dynamically allocated and 
automatically resized.
Fixed Length String
Dim myString as String * 
length
8-bit, fixed-length string.
Zstring
Dim myString as Zstring * 
length
Dim myString as Zstring Ptr
8-bit, fixed-length, Null 
terminated character string. 
A Zstring is a C-style string.
Wstring
Dim myString as Wstring * 
length
Dim myString as Wstring Ptr
16-bit, fixed-length, Null 
terminated string used with 
Unicode functions.
Table 9.1: Intrinsic FreeBasic String Data Types
All FreeBasic strings can hold up to 2 GB of data, or up to the amount of memory 
on your computer.
Dynamic Strings
Dynamic strings are variable-length strings that the compiler automatically 
allocates and resizes as needed. Dynamic strings are actually structures stored in 
memory, called a string descriptor, that contain a pointer to the string data, the length of 
the string data and the size of the string allocation. Dynamic strings are allocated in 36 
byte blocks, which reduces the amount of resizing that the compiler must do if the string 
size changes. The following program displays the internal string structure data for a 
typical dynamic string
3
.
1
2
3
4
5
6
7
8
9
10
11
12
OptionExplicit
'Stringdescriptor
TypeStringDesc
strdataAsZstringPtr
lengthAsInteger
sizeAsInteger
EndType
'Createastring
DimAsStringmyString="ThisisadynamicstringinFreeBasic!"
'Dimensionapointertothestringdescriptor
3
String descriptor code provided by FreeBasic forum member cha0s.
95
C# PDF: C# Code to Create Mobile PDF Viewer; C#.NET Mobile PDF
also allows developers to annotate, process and float DocWidth = 819; protected void Page_Load Demo_Docs/").Replace("\\" Sample.pdf"; this.SessionId
break password on pdf; add password to pdf online
C# Image: How to Integrate Web Document and Image Viewer
developers to view, edit, annotate and process RasterEdgeImagingDeveloperGuide8.0. pdf: from this user manual mode; public string fid; protected void Page_Load
pdf owner password; convert password protected pdf files to word online
13
14
15
16
17
18
19
20
21
DimAsStringDescPtrStringData=Cptr(stringdescPtr,@myString)
'Printstringdescriptordata
Print"Data:";*(StringData­>strdata)
Print"Length:";StringData­>length
Print"Size:";StringData­>size
Sleep
End
Listing 9.1: dynastring.bas
Analysis:
Lines 4 through 8 defines the string descriptor data type. The strdata 
field is a pointer to a NULL terminated string in memory. The length fields contains the 
number of characters in the string. The size field indicates the length of the current 
memory-block allocation. Line 11 creates a dynamic string and initializes the value of the 
string. Line 13 creates a pointer, StringData, that points to the string descriptor of 
myString. Notice that the address of operator is used to return the address of the string 
descriptor, which is then cast as a StringDesc Ptr using the Cptr function.
Lines 16 through 18 then print out the string descriptor data. The member 
operator, ->, is used with type definition pointers and is comparable to using *PtrName. 
The member operator will be discussed in the chapter on composite types. The program 
is closed in the usual way.
Running the program in FBIde will produce the following result.
Data:ThisisadynamicstringinFreeBasic!
Length:38
Size:72
Output 9.1: Output of dynastring.bas
Dynamic strings use Zstrings strings internally so that you can pass a dynamic 
string to a function that expects a Null terminated string and the function will work 
correctly. The Windows api, the C runtime library and most third-party libraries written in 
C expect a Null terminated string as a string parameter.
Caution In other versions of Basic, strings have been used to load and manipulate 
binary data. If the binary data contains a Null character, this could cause problems with 
FreeBasic strings, since the Null character is used to terminate a string. While it is 
possible to have an embedded Null in a dynamic string (since dynamic strings have a 
string descriptor), if you pass this data to a third party library function that is expecting a 
C-style string, the data will read only up to the Null character, resulting in data loss. 
Instead of using strings to read binary data, you should byte arrays instead.
96
Since a dynamic string is actually a pointer to a string descriptor, you cannot use 
dynamic strings in type definitions that you are going to save to a file. You should use a 
fixed length string instead.
Fixed Length Strings
Fixed length strings are defined using a length parameter, and can only hold 
strings that are less than or equal to the defined size. Trying to initialize a fixed length 
string with data that is longer than the defined size will result in the string being 
truncated to fit.
The following short program illustrates creating and using a fixed length string.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
OptionExplicit
'Defineafixedlengthstring
DimmyFStringAsString*20
'Savesomedatinthestring
myFString="Thisshouldfit."
PrintmyFString
'Thisdatawillbetruncated.
myFString="Thisstringwillbetruncated."
PrintmyFString
Sleep
End
Listing 9.2: fixedstr.bas
Analysis:
Lines 4 defines a fixed length string that can hold up to 20 characters. 
Line 7 loads the variable with a string and line 8 prints the contents of the variable. Since 
the string "This should fit." is smaller than 20 characters, so the whole string will be 
printed out. Line 11 tries to initialize the string with data that is longer than 20 characters 
so the string will be truncated when it is printed out in line 12.
When you run the program you should see the following output.
Thisshouldfit.
Thisstringwillbe
Output 9.2: Output of fixedstr.bas
97
As you can see from the output, if a string is too long to fit in the variable, it will be 
truncated to fit. Fixed length strings are very useful when creating random access records 
using type definitions. This technique is used in the chapter on file handling.
Zstrings
Zstrings are Null terminated, C-style strings. The main purpose of a Zstring is to 
interface with third-party libraries that expect a C-style strings, however they are useful 
even if you do not plan to pass them to third-party libraries. Zstrings can be defined just 
like a fixed-length string, DimmyZstringasZstring*10, and FreeBasic will handle 
them just like fixed strings, automatically truncating data to fit the defined size. 
Unlike fixed strings however, Zstrings can be dynamically managed by declaring a 
Zstring pointer and using the associated memory functions. When using a dynamically 
allocated Zstring, you must be careful not to overwrite the the size of the string, as this 
will overwrite parts of memory not contained in the string and may cause the program or 
even the operating system to crash.
When using either type of Zstring, FreeBasic will manage the terminating Null 
character for you, but the storage size of a Zstring will be 1 less than the defined size 
since the the Null character occupies the last character position. When calculating the 
size of a Zstring be sure to add 1 to the value to account for the Null terminator. You must 
also not include the character 0 in any of your data, or the data will be truncated since 
FreeBasic will see the Null character as the end of the string.
The following program shows both uses of the Zstring data type.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
OptionExplicit
'DeclareafixedlengthZstring
DimmyFixedZstringAsZstring*20+1
'DeclareadynamicZstring
DimmyDynaZstringAsZstringPtr
'Loadsomedataintothefixedzstring
Print"123456789012345678901"
myFixedZstring="Thisshouldfit."
PrintmyFixedZstring
myFixedZstring="Thiswillbetruncated."
PrintmyFixedZstring
'Createadynamiczstring
Print"123456789012345678901"
myDynaZstring=Callocate(20+1)
*myDynaZstring="Let'saddsomedata."
Print*myDynaZstring
'Resizethestring:20forcurrentdata+5fornew
'data+1forNull
myDynaZstring=Reallocate(myDynaZstring,20+5+1)
Print"12345678901234567890123456"
98
24
25
26
27
28
29
30
31
*myDynaZstring="Let'saddsomemoredata."
PrintmyDynaZstring[0]
'Deallocatethememorysegment
DeallocatemyDynaZstring
Sleep
End
Listing 9.3: zstring.bas
Analysis:
Line 4 declares a fixed length Zstring. Notice that the desired data length 
is 20 so 1 is added to to allocate space for the terminating Null character. Line 6 declares 
a pointer to a Zstring that will be managed dynamically. Line 9 prints out a ruler to 
compare the print statements in line 11 and 13. Line 10 initializes the Zstring with some 
data that is small enough to fit in the declared size. Line 12 adds some data that is too 
long to fit within the Zstring, which will be truncated to fit. 
Line 16 prints another ruler for comparison with the dynamic Zstring data. Line 17 
Callocates enough space for a 20-byte string along with the terminating Null character. 
Since myDynaZstring is defined as a Zstring Ptr, the indirection operator is used to 
initialize the variable data in line 18. Line 22 resizes the Zstring to hold 5 additional 
characters plus the terminating Null using the Reallocate function. Another ruler is 
printed in line 23 to show the new size of the data loaded into the variable in line 24. Line 
25 uses the pointer index method to print out the contents of the variable. Line 28 
deallocates the allocated memory.
When you run this program you should get the following output.
123456789012345678901
Thisshouldfit.
Thiswillbetruncat
123456789012345678901
Let'saddsomedata.
12345678901234567890123456
Let'saddsomemoredata.
Output 9.3: Output of zstring.bas
As you can see, the fixed length version of the Zstring data type behaves exactly 
like the fixed string data type and the dynamic version behaves exactly like any other 
pointer-based memory segment. Since there is no intrinsic method for determining the 
size of a Zstring allocation, you must be careful not to over-run the buffer. The best way 
to do this is to keep a current allocation size in a separate variable that can be referenced 
as needed.
You will notice in Line 25 of the listing that the pointer index method was used to 
print the contents of the resized Zstring. What would the output be if you changed the 
99
index from 0 to 6? Remember that a pointer index behaves much like an array index, and 
a Zstring could be viewed as an array of characters. If you were to use 6 as the index, the 
output would be addsomemoredata. The Print statement would start at character 
position 6 and print everything up to the terminating Null character. 
You can directly assign a fixed length Zstring to a dynamic string. For a dynamic 
Zstring, the pointer must be dereferenced by using * or the pointer index method. Keep 
in mind that the behavior of the indexing method is the same for assignments as it is for 
the Print statement.
Wstrings
Dynamic, fixed and Zstrings all use 1 byte per character. Wstrings, also called wide 
strings, use 2 bytes per character and is generally used in conjunction with Unicode 
strings functions. Unicode is, strictly speaking, a character coding scheme designed to 
associate a number for every character of every language used in the world today, as 
well as some ancient languages that are of historical interest. In the context of 
developing an application, Unicode is used to internationalize a program so that the end-
user can view the program in their native language.
Wstrings can be both fixed length and dynamic and are similar to Zstrings. 
Wstrings will be discussed in more detail in the chapter on Unicode.
String Functions
Creating and using strings in your application will often consist of manipulating 
those strings and FreeBasic has a rich set of string functions, which are listed in the 
following table.
Function
Syntax
Comment
Asc
B = Asc(string)
B = Asc(string, position)
Returns the character code 
of the first character in a 
string as a uninteger, or the 
character code of character 
at position.
Bin
B = Bin(number)
B = Bin(number, digits)
Returns the binary form of 
number as a string. Can 
optionally return only 
number of digits.
Chr
B = Chr(code)
B = Chr(code, code, ...)
Returns the character 
represented by Ascii Code. If 
multiple codes are passed to 
Chr, the function will return 
a string of characters.
Hex
B = Hex(number)
B = Hex(number, digits)
Returns the hexadecimal 
form of number as a string. 
Can optionally return only 
number of digits.
Instr
B = Instr(string, substring)
B = Instr(start, string, 
Returns the position of 
substring within string as an 
100
Documents you may be interested
Documents you may be interested