c# itextsharp pdf page to image : Convert password protected pdf to normal pdf control application platform web page html asp.net web browser FBeginner8-part1255

Reallocate will change the size of an existing memory segment, making it larger or 
smaller as needed. If the new segment is larger than the existing segment, then the data 
in the existing segment will be preserved. If the new segment is smaller than the existing 
segment, the data in the existing segment will be truncated. Reallocate does not clear 
the added memory or change any existing data.
All of these functions will return a memory address if successful. If the functions 
cannot allocate the memory segment, then a NULL pointer (0) is returned. You should 
check the return value each time you use these functions to be sure that the memory 
segment was successfully created. Trying to use a bad pointer will result in undesirable 
behavior or system crashes.
There is no intrinsic method for determining the size of an allocation; you must 
keep track of this information yourself.
Caution Be careful not to use the same pointer variable to allocate two or more 
memory segments. Reusing a pointer without first deallocating the segment it points to 
will result in the memory segment being lost causing a memory leak.
Pointer Arithmetic and Pointer Indexing
When you create a memory segment using the allocation functions, you will need a 
way to access the data contained within the segment. In FreeBasic there are two 
methods for accessing data in the segment; using the indirection operator with pointer 
arithmetic, and pointer indexing. 
Pointer arithmetic, as the name suggests, adds and subtracts values to a pointer to 
access individual elements within a memory segment. When you create a typed pointer 
such as DimmyPointerasIntegerptr, the compiler knows that the data being used 
with this pointer is of size Integer or 4 bytes. The pointer, when initialized, points to the 
first element of the segment. You can express this as *(myPtr + 0). To access the second 
element, you need to add 1 to the pointer, which can be expressed as *(myPtr + 1). 
Since the compiler knows that the pointer is an Integer pointer, adding 1 to the pointer 
reference will actually increment the address contained in myPtr by 4, the size of an 
Integer. This is why using typed pointers is preferable over untyped pointers. The 
compiler does much of the work for you in accessing the data in the memory segment.
Notice that the construct is *(myPtr + 1) and not *myPtr + 1. The * operator has 
higher precedence than +, so *myPtr + 1 will actually increment the contents myPtr 
points to, and not the pointer address.  *myPtr will be evaluated first, which returns the 
contents of the memory location and then +1 will be evaluated, adding 1 to the memory 
location. By wrapping myPtr + 1 within parenthesis, you force the compiler to evaluate 
myPtr + 1 first, which increments the pointer address, and then the * is applied to return 
the contents of the new address.
Pointer indexing works the same way as pointer arithmetic, but the details are 
handled by the compiler. *(myPtr + 1) is equivalent to myPtr[1]. Again, since the 
compiler knows that myPtr is an integer pointer, it can calculate the correct memory 
offsets to return the proper values using the index. Which format you use if up to you, but 
most programmers use the index method because of its simplicity.
The following program shows both methods of accessing a memory segment.
1
OptionExplicit
81
Convert password protected pdf to normal 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
pdf password unlock; break pdf password
Convert password protected pdf to normal 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
adding a password to a pdf; convert password protected pdf to excel online
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
DimmyPtrAsIntegerPtr
DimAsIntegeri
'Tryandallocatespacefor10integers
myPtr=Callocate(10,Sizeof(Integer))
'Makesurethespacewasallocated
IfmyPtr=0Then
Print"Couldnotallocatespaceforbuffer."
End1
EndIf
'Loaddataintothebuffer
Print"Loadingdata,printdatausing*..."
Fori=0To9
*(myPtr+i)=i
Print"Index:";i;"data:";*(myPtr+i)
Next
Print
'Printdatafrombuffer
Print"Showdatausingindexing..."
Fori=0To9
Print"Index:";i;"data:";myPtr[i]
Next
'Freethememory
DeallocatemyPtr
Sleep
End
Listing 8.2: ptraccess.bas
Analysis:
In lines 3 and 4 the working variables are declared. Space for 10 integers 
is created in Line 7 using the Callocate function. Lines 10 through 13 check to make sure 
that the memory was allocated. If it wasn't, the program ends. The End 1 terminates the 
program with an exit code of 1. This is useful for instances where the program may be 
run from a batch file and you want to make sure the program ran successfully. You can 
check the exit code in the batch file and take the appropriate action.
Lines 17 through 20 load and print the memory segment with ten integers using 
the indirection operator and pointer arithmetic. Lines 25 through 27 print out the values 
using the index method. Notice that the index method is much more compact and easier 
to read. In line 30 the buffer is deallocated, even though it isn't strictly necessary as the 
program is terminating. Deallocating memory is a good habit to get into, even when it 
may not be strictly necessary. The program is closed in the usual way.
82
C# Image: How to Integrate Web Document and Image Viewer
RasterEdgeImagingDeveloperGuide8.0.pdf: from this user TextSize: 12, TextStyle :"normal"}); FreehandAnnoStyle = new public string fid; protected void Page_Load
create password protected pdf from word; adding a password to a pdf file
C# TIFF: C#.NET Code to Create Online TIFF Document Viewer
create more web viewers on PDF and Word Arial", TextSize: 12, TextStyle :"normal"}); FreehandAnnoStyle = new mode; public string fid; protected void Page_Load
pdf password encryption; pdf password security
When you run the program you should see the following output.
Loadingdata,printdatausing*...
Index:0data:0
Index:1data:1
Index:2data:2
Index:3data:3
Index:4data:4
Index:5data:5
Index:6data:6
Index:7data:7
Index:8data:8
Index:9data:9
Showdatausingindexing...
Index:0data:0
Index:1data:1
Index:2data:2
Index:3data:3
Index:4data:4
Index:5data:5
Index:6data:6
Index:7data:7
Index:8data:8
Index:9data:9
Output 8.2: Output of ptraccess.bas
As you can see from the output, both formats produce the same results, but the 
index method is a lot easier to read and understand, and less error-prone than the 
indirection method.
Pointer Functions
Freebasic has a set of pointer functions to complement the pointer operators. The 
following table lists the pointer functions.
Function
Syntax
Comment
Cptr
myPtr = Cptr(data_type, 
expression)
Converts expression to a 
data_type pointer. 
Expression can be another 
83
C# Word: How to Create Word Online Viewer in C# Application
creating, you can go to PDF Web Viewer Arial", TextSize: 12, TextStyle :"normal"}); FreehandAnnoStyle = new mode; public string fid; protected void Page_Load
pdf print protection; pdf password protect
C# DICOM - How to Create Web Viewer
Allow C#.NET users to save or print (convert) web DICOM file to TIFF or PDF file. public string mode; public string fid; protected void Page_Load(object
convert password protected pdf to word online; password protected pdf
Function
Syntax
Comment
pointer or an integer.
Peek
B = Peek(data_type, 
pointer)
Peek returns the contents of 
memory location pointer to 
by pointer. Data_type 
specifies the type of 
expected data.
Poke
Poke data_type, pointer, 
expression
Puts the value of expression 
into the memory location 
pointed to by pointer. The 
data_type specifies the type 
of data being placed into 
the memory location.
Sadd
myPtr = 
Sadd(string_variable)
Returns the location in 
memory where the string 
data in a dynamic string is 
located.
Strptr
myPtr = 
Strptr(string_variable)
The same as Sadd.
Procptr
myPtr = Procptr(function)
Returns the address of a 
function. This works the 
same way as the addressof 
operator @.
Varptr
myPtr = Varptr(variable)
This function works the 
same way as the addressof 
operator @.
Table 8.3: Pointer Functions
The Sadd and Strptr functions will be discussed in the chapter on the string data 
types. The Peek and Poke functions have been added for the purposes of supporting 
legacy code. Procptr and Varptr both work just like the address of operator, but Proptr 
only works on subroutines and functions and Varptr only works on variables. Cptr is useful 
for casting an untyped pointer to a typed pointer, such as a return value from a third 
party library.
Subroutine and Function Pointers
Subroutines and functions, like variables, reside in memory and have an address 
associated with their entry point. You can use these addresses to create events in your 
programs, to create pseudo-objects and are used in callback functions. You create a sub 
or function pointer just like any other pointer except you declare your variable as a 
pointer to a subroutine or function rather than as a pointer to a data type. Before using a 
function pointer, it must be initialized to the address of a subroutine or function using 
Procptr or @. Once initialized, you use the pointer in the same manner as calling the 
original subroutine or function. The following program illustrates declaring an using a 
function pointer.
84
C# Excel: Tutorial for Web Excel Document Viewer Creation
viewer to load, view, annotate, convert and save Support saving modified Excel document PDF and TIFF string mode; public string fid; protected void Page_Load
create pdf password; adding password to pdf
C# PowerPoint: Create Web Document Viewer for PowerPoint Viewing
are entitled to view, annotate, and convert PowerPoint document saving web PowerPoint document to PDF and TIFF. mode; public string fid; protected void Page_Load
change password on pdf document; convert pdf password protected to word online
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
OptionExplicit
'Declareourfunctiontobeusedwithpointer
DeclareFunctionPower(numberAsInteger,pwrAsInteger)AsInteger
'Dimafunctionpointer
DimFuncPtrAsFunction(xAsInteger,yAsInteger)AsInteger
'Gettheaddressofthefunction
FuncPtr=@Power
'Usethefunctionpointer
Print"2raisedtothepowerof4is";FuncPtr(2,4)
Sleep
End
'Writethefunctionthatwillbecalled
FunctionPower(numberAsInteger,pwrAsInteger)AsInteger
Returnnumber^pwr
EndFunction
Listing 8.3: funcptr.bas
Analysis:
Line 4 declares the function prototype that will be used with the function 
pointer. Line 7 declares the function pointer using the the As Function syntax. Notice that 
the Dim statement does not use the Ptr keyword; the compiler knows that this will be a 
function pointer since it is declared using the As Function method. When declaring a 
function pointer, the parameter list must match the number and type of parameters of 
the pointed-to function, but as you can see, the names do not have to match. In fact, the 
pointer can be declared as DimFuncPtrAsFunction(AsInteger,AsInteger)As
Integer, without the parameter names. The only requirement is to make sure that the 
type and number of parameters, and the return type, match the function declaration and 
definition. Line 10 initializes the function pointer to the address of the function using the 
address of operator @. You could use Procptr here as well.  Line 13 uses the pointer to 
call the function. The calling syntax is the same as using the function name: FuncPtr(2,4) 
is equivalent to Power(2, 4). Lines 15 and 16 close the program in the usual way. Lines 19 
through 21 define the actual Power function. 
Running the program will produce the following result.
2raisedtothepowerof4is16
Listing 8.4: Output of funcptr.bas
85
While this example program may not seem to have any advantages over just 
calling the function directly, you can use this method to call several functions using a 
single function pointer. For example, if you were creating your own user interface, you 
could implement events using a function pointer that called one of several different 
subroutines depending on the object receiving the event. The only requirement would be 
that each subroutine must contain the same number and type of parameters.
Creating a Callback Function
One of the primary uses for function pointers is to create callback functions. A 
callback function is a function that you have created in your program that is called by a 
function or subroutine in an external library. Windows uses callback functions to 
enumerate through Window objects like fonts, printers and forms. The qsort, function 
contained within the C Runtime Library sorts the elements of an array using a callback 
function to determine the sort order. The prototype for the qsort function is contained in 
stdlib.bi:
declaresubqsortcdeclalias"qsort"(byvalasanyptr,byvalassize_t,
byvalassize_t,byvalasfunctioncdecl(byvalasanyptr,byvalasany
ptr)asinteger)
The following lists the parameter information for the qsort subroutine.
1. The first parameter is the address to the first element of the array. The easiest way 
to pass this information to qsort is to append the address of operator to the first 
element index: @myArray(0). 
2. The second parameter is the number of elements in the array, that is the array 
count.
3. The third parameter is the size of each element in bytes. For an array of integers, 
the element size would be 4 bytes.
4. The fourth parameter is a function pointer to the user created compare function. 
The function must be declared using the Cdecl passing model, as shown in this 
parameter. 
Using this information, you can see how qsort works. By passing the address of the 
first element along with the count of elements, and the size of each element, qsort can 
iterate through the array using pointer arithmetic. Qsort will take two array elements, 
pass them to your user defined compare function and use the compare function's return 
value to sort the array elements. It does this repeatedly until each array element is in 
sorted order. The following program uses the qsort subroutine and a compare function to 
sort an array of integers. 
1
2
3
4
5
6
7
8
9
10
OptionExplicit
#include"crt.bi"
'Declarethecomparefunction
'Thisisdefinedinthesamemannerastheqsortdeclaration
DeclareFunctionQCompareCdecl(Byvale1AsAnyPtr,Byvale2AsAnyPtr)_
AsInteger
'Dimensionthearraytosort
86
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
DimmyArray(10)AsInteger
DimiAsInteger
'Seedtherandomnumbergenerator
RandomizeTimer
Print"Unsorted"
'Loadthearraywithsomerandomnumbers
Fori=0To9
'Rndreturnsanumberbetween0and1
'Thisconvertsthenumbertoaninteger
myArray(i)=Int(Rnd*20)
'Printunsortedarray
Print"i=";i;"value=";myArray(i)
Next
Print
'Calltheqsortsubroutine
qsort@myArray(0),10,Sizeof(Integer),@QCompare
Print
'Printsortedarray.
Print"Sorted"
Fori=0To9
'Rndreturnsanumberbetween0and1toconverttointeger
Print"i=";i;"value=";myArray(i)
Next
Sleep
End
'Theqsortfunctionexpectsthreenumbers
'fromthecomparefunction:
'­1:ife1islessthane2
'0:ife1isequaltoe2
'1:ife1isgreaterthane2
FunctionQCompareCdecl(Byvale1AsAnyPtr,_
Byvale2AsAnyPtr)AsInteger
DimAsIntegerel1,el2
StaticcntAsInteger

'Getthecallcountanditemspassed
cnt+=1
'Getthevalues,mustcasttointegerptr
el1=*(Cptr(IntegerPtr,e1))
87
56
57
58
59
60
61
62
63
64
65
66
el2=*(Cptr(IntegerPtr,e2))
Print"Qsortcalled";cnt;"time(s)with";el1;"and";el2;"."
'Comparethevalues
Ifel1<el2Then
Return­1
Elseifel1>el2Then
Return1
Else
Return0
EndIf
EndFunction
Listing 8.5: qsort.bas
Analysis:
Line 3 includes the crt.bi file so that the qsort routine will be available in 
the program. You need to include this file if you want to use any of the CRT functions. 
Line 7 declares the compare function. You will notice that it is declared as a  Cdecl 
function, which matches the 4
th
parameter definition in the qsort declaration. Since qsort 
expects to see either a -1, 0 or 1, the function's return type is an integer. The undercores 
character _ at the end of line 7 is the line continuation character and tells the compiler 
that the following line is actually a part of this line. In line 11 an array of integers is 
dimensioned. The array will have 10 elements, with indexes from 0 to 9. Line 12 
dimensions a working variable i, that will be used to load and display the array values.
Line 15 seeds the random number generator by using the value from the Timer 
function. The Timer function returns the number of seconds, as a double-type value, 
since the computer was started. Lines 19 through 25 initializes the array with some 
random integers and displays them to the console screen. The code in line 22, Int(Rnd * 
20), uses the Rnd function which returns a double precision number between 0 and 1. 
That number is multiplied by twenty to produce a double-precision number between 0 
and 20 which is then converted to an integer value using the Int function. Since Int 
returns the largest integer less than or equal to the input, the resulting random numbers 
will range from 0 to 19. In line 24 the value of the current array index is printed to the 
console screen.
In line 29 the qsort subroutine is called. Since the array indexes range from 0 to 9, 
the address of operator on the zero index in used for the first parameter. The array size is 
10, so that is used as the second parameter. The array is an integer array, so 
Sizeof(Integer) is used to pass the array element size. The final parameter is the address 
of the compare function which is passed to qsort using the address of operator. Lines 34 
through 37 print out the now sorted array. Lines 39 and 40 close the program in the usual 
way.
Lines 47 through 66 contain the compare function code. In line 47 the function is 
defined just like the declare statement in line 7 using two Any Ptr parameters and 
returning an integer. The Any Ptrs allow qsort to be able to sort any type of data, 
including composite types. Lines 49 and 50 delcare the function's working variables. 
Qsort will pass pointers to the functions, not the actual data, so two integers need to be 
declared so that the data that the pointers point to can be compared. The variable cnt is 
defined as Static so that its value will be preserved between calls to the function. Cnt is 
used to keep track of how many calls to the function qsort will make as it sorts the array.
88
Lines 55 and 56 use the indirection operator to return the data from the passed 
pointers. Notice the Cptr is used to convert the Any Ptr parameters to Integer Ptrs before 
using the indirection operator. Remember that the code inside the parenthesis will be 
executed before applying the indirection operator. Line 57 prints out the current call 
count and the passed parameter values.
Line 59 through 65 compare the two values and return the appropriate indicator 
value back to qsort. The Return statement, as expected, is used to set the function's 
return value. The function is closed using the End Function keywords in line 66.
When you run the program you should something similar to the following.
Unsorted
i=0value=14
i=1value=18
i=2value=2
i=3value=14
i=4value=3
i=5value=15
i=6value=16
i=7value=4
i=8value=10
i=9value=19
Qsortcalled1time(s)with18and15.
Qsortcalled2time(s)with19and15.
Qsortcalled3time(s)with10and15.
Qsortcalled4time(s)with2and15.
Qsortcalled5time(s)with14and15.
Qsortcalled6time(s)with3and15.
Qsortcalled7time(s)with14and15.
Qsortcalled8time(s)with16and15.
Qsortcalled9time(s)with4and15.
Qsortcalled10time(s)with16and15.
Qsortcalled11time(s)with4and15.
Qsortcalled12time(s)with18and16.
Qsortcalled13time(s)with19and18.
Qsortcalled14time(s)with18and16.
Qsortcalled15time(s)with10and4.
Qsortcalled16time(s)with2and10.
Qsortcalled17time(s)with14and10.
89
Qsortcalled18time(s)with3and14.
Qsortcalled19time(s)with14and14.
Qsortcalled20time(s)with10and4.
Qsortcalled21time(s)with2and10.
Qsortcalled22time(s)with14and10.
Qsortcalled23time(s)with3and14.
Qsortcalled24time(s)with10and4.
Qsortcalled25time(s)with2and10.
Qsortcalled26time(s)with3and10.
Qsortcalled27time(s)with3and4.
Qsortcalled28time(s)with2and4.
Qsortcalled29time(s)with3and2.
Sorted
i=0value=2
i=1value=3
i=2value=4
i=3value=10
i=4value=14
i=5value=14
i=6value=15
i=7value=16
i=8value=18
i=9value=19
Output 8.3: Output of qsort.bas
The first group of numbers show the unsorted array. The middle group of numbers 
show the number of times the compare function is called along with the values being 
sorted. The last group of numbers show the sorted array. Even though qsort is called 
quite a number of times even on this small array, the routine is extremely fast since it 
uses pointers to sort the values in the array.
Pointer to Pointer
In FreeBasic you can create a pointer to any of the supported data types, including 
the pointer data type. A pointer to a pointer is useful in situations where you need to 
return a pointer to a function or in creating specialized data structures such as linked-lists 
and ragged arrays. A pointer to a pointer is called multi-level indirection.
Caution You can have as many levels of indirection as needed, but anything 
beyond two levels is rarely useful and difficult to manage.
90
Documents you may be interested
Documents you may be interested