how to display pdf file in c# : Export highlighted text from pdf software Library dll windows asp.net web page web forms Excel40-part213

B2+1=8+1=9, hence we find the result 9
3
=729 instead. In B4 the
macro then computes 730
3
=3.87E+08, and from there the size of the
results quickly escalates to exceed the numerical capacity of the spread-
sheet (approximately 9.9×10
307
) in B8, which is why we see the overflow
sign ########. Therefore one should use For Each … Next loops only on
cells containing values that are independent of all other data in the
selected block.
11 Power1 first reads the numerical values of all cells, and stores them in an
array. The mathematical operations are then performed on these stored
data, so that there is no ambiguity involved. Consequently, Power1 yields
correct results for either column. However, Power1 may fail when the
selected block is too large (which, depending on the amount of available
memory, and the version of Excel used, typically will happen only when
the array has more than a few thousand elements). In that case, use Special
Copy Values to duplicate the numerical values of the array elements in
another block, then use a macro such as Power that does not suffer from
size limitations.
12 Verify that the macros Power and/or Power1 work with one- or two-dimen-
sional arrays, i.e., with blocks regardless of their size, as long as they
contain two or more cells in the array. Note that the macro will not accept a
single cell as valid input: an array must contain more than one cell.
10.1e
Numerical precision
In order to test how well macros such as Power or Power1 work, we now
make a complementary macro to counteract the effects of the first. To do so,
switch back to the Module1 page, highlight one of the macros (either Power
or Power1) in its entirety, and use Ctrl+c and Ctrl+v to deposit a copy of it
lower on the same Module1 page. Then modify the copy to read (if you use
Power)
Sub Root()
For Each Cell In Selection.Cells
Cell.Value = Cell.Value ^ 1/3
Next Cell
End Sub
where we have again boldfaced the two changes to be made, one in the
macro name (you are again welcome to select a different name here), the
other in the mathematical operation, which now calculates the inverse
operation, i.e., the cube root if you earlier raised to the cube power. If you use
Power1, make the corresponding two changes in that macro instead.
1 Assign the new macros separate shortcut keycodes. (Such keycodes are case
sensitive, i.e., they distinguish between lower case and capitals. You can
therefore select Ctrl+Z, which you obtain by simultaneously depressing
10.1 What is a macro?
387
Export highlighted text from pdf - extract text content from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Feel Free to Extract Text from PDF Page, Page Region or the Whole PDF File
get text from pdf image; copy text from pdf to word
Export highlighted text from pdf - VB.NET PDF Text Extract Library: extract text content from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
How to Extract Text from PDF with VB.NET Sample Codes in .NET Application
export text from pdf to excel; extract pdf text to word
the Ctrl, Shift and z keys, which is easily done with three fingers.) Use a pair
of corresponding macros (Power & Root, or Power1 & Root1) to test their
performance, by first raising numbers to some power, and by then taking
their corresponding roots. This should undo the effect of the first macro,
and recover the original values.
2 Let the spreadsheet compute the differences between the original and final
data. First make an array containing, say, some simple integers, and copy it.
On the copy, now test the operation of the two macros, e.g., by first using the
Power macro three times in succession on the same data, followed by three
uses of the Root macro. In principle, this should return the original data. In
practice, some round-offerrors may creep in, typically of the order of 10–6or
so, which are easily visualized by computing in a third array the differences
between the original data and the copy. The small differences shown may be
perfectly satisfactory for most purposes, but since in Excel all standard
spreadsheet operations are performed at a much higher precision, it is
useful to fix the macro which, apparently, worked in the so-called single-
precisiondata mode.
3 The cause of the problem lies in the numbers 3 and 1/3 used to raise the
individual terms of the array to their cube power, and to take their cube
root. When we raised the individual cells in the block (or the individual ele-
ments in Array) to their cube power, we reduced the results to single preci-
sion. To demonstrate this and, at the same time, fix the problem, add a
dimension statement to bothmacros, reading “Dim p As Double”, and add a
line specifying the value of p (e.g., either “p=3” or “p=1/3”). Finally, in the
For Each … Next (or in the nested For … Next loop) refer to p rather than to 3
(or 1/3). The macros now should read like the example shown below, where
we have also added a title and some comment lines and, as before, bold-
faced the most recent changes.
' ROOT
'
' An example showing how to capture data from a high-
' lighted block of cells, and raise all its terms to
' some power, in double precision. Note that the input
' data are overwritten by the output data.
'
Sub Root()
Dim p As Double
p = 1 / 3
For Each Cell In Selection.Cells
Cell.Value = Cell.Value ^ p
Next Cell
End Sub
4 Verify that repeated use of the Power and Root (or Power1 and Root1)
macros now does lead to computational errors with relative values smaller
than 10
–15
. This final example illustrates that, while the spreadsheet always
(and automatically) treats data as double precision, the mathematical oper-
ations in VBA must be told specifically to do so!
388
Some useful macros
C# PDF Text Highlight Library: add, delete, update PDF text
etc. Able to remove highlighted text in PDF document in C#.NET. Support to change PDF highlight color in Visual C# .NET class. Able
copying text from pdf to word; delete text from pdf
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
Text in any fonts, colors and sizes, or highlighted characters are easy to be converted to plain text. Text can be extracted from scanned PDF image with OCR
copy text from locked pdf; extract text from pdf to word
In general, VBA allows us to leave the parameter dimensions unspecified.
However, we have already seen that dimensioning is necessaryfor arrays,
and for using double precision. Moreover, dimensioning is advisable for
integers, because it saves computer memory and speeds up macro execu-
tion. Dimensioning is even advisable in general, because it can help us catch
typos, an aspect to which we will return later. Regardless of the reasons for it,
a parameter dimension must always be specified before that parameter is
used in the macro. During macro writing, it is often convenient to place the
dimension statement at the top of the block of instructions where the para-
meter is first used. At the final clean up you may then want to collect and
combine all dimension statements, and place them at the top of the macro.
This makes it easier to find them, guards against dimensioning the same
parameter twice, and reduces the line count of the macro.
10.1f
Communication via boxes
We have already seen in some of the sample macros of the previous section
that a message boxis readily incorporated in a macro, and can then help to
verify that a macro works properly. It can also deliver a warning or other
message to the user, and it can even carry a limited amount of information
back to the macro. There are two other types of boxes that can be used if
more information needs to be exchanged between the user and  the
program. An input box is essentially a message box with a windowin which
the user can place specific information (such as numerical values, formulas,
addresses, text) that can then be read by the macro. A dialog boxis the most
versatile type of communication box, since it can contain any number of
input windows and buttons, of all the types encountered in Excel dialog
boxes. Dialog boxes can give macros a professional appearance. However,
their construction often takes too long to make them worthwhile for the
simple programs with which we deal here, and we will therefore not discuss
them. Instead, we will use the much simpler input boxes to achieve the same
goal. Below, then, we restrict the discussion to message and input boxes, in
that order.
All message boxes carry at least one button, usually just the OK button
that must be pressed to make the box disappear and to continue the macro,
thereby making sure that the user has acknowledged the message. The use of
message boxes can be extended so that they carry a limited amount of infor-
mation from the user back to the macro during the execution of that macro.
For example, the algorithms for forward and inverse Fourier transformation
are very similar, and one might want to use a single macro instead, com-
bined with a message box that provides the necessary binary information so
that the user can choose one or the other. Imagine that, in this case, the
needed information is stored in the value of an integer iSign, which can have
the value of either+1 or -1. (How to use such information in the macro will
be illustrated in section 10.5.) Likewise, the weighted least squares program
10.1 What is a macro?
389
VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net
Plain text can get from any fonts, colors and sizes, or highlighted characters. Text extraction from scanned PDF image with OCR component in VB.NET.
can't copy text from pdf; copy text from pdf online
of section 10.7 has two forms, depending on whether the intercept is vari-
able or is set equal to zero. In this case, a single program with a message box
can again be used instead of two separate macros. Below we show two exam-
ples of message boxes that could be used to provide information to the
Fourier transformation program. Try them out.
Sub Box1()
Ans = MsgBox("Forward Fourier transform?", vbYesNo)
If Ans = vbYes Then iSign = 1
If Ans = vbNo Then iSign = -1
MsgBox "The value of iSign is " & iSign
'for testing
End Sub
Sub Box2()
Msg = Msg & "Press YES for a forward transform, "
Msg = Msg & Chr(13)
Msg = Msg & "press NO for an inverse transform."
Config = vbYesNo + vbQuestion
Title = "Forward or inverse FT?"
Ans = MsgBox(Msg, Config, Title)
If Ans = vbYes Then iSign = 1
If Ans = vbNo Then iSign = -1
MsgBox "The value of iSign is " & iSign
'for testing
End Sub
You will recognize that both message boxes accomplish the same purpose,
the only difference being that the second is somewhat more elaborate, with
a title and a question mark. Chr(13) is the character code for a linefeed, so
that the message appears on two lines. The general syntax of a message box
can be either
MsgBox "
message
", 
configuration
, "
title
"
or
Answer = MsgBox ("
message
", 
configuration
, "
title
"
)
while the message, configuration and/or title can be specified either directly
following MsgBoxor in separate lines. Here messagedenotes the (obligatory)
message, which can consist of text and/or numbers: text must be within
quotation marks ("), while text and specific output information must be
separated by an ampersand, &. The optional configuration refers tobuttons
and/or icons. When configuration is left blank, only an OK button will show,
the status of which can be determined by calling vbOK. Possible two-button
combinations are designated with the self-explanatory names vbOKCancel,
vbYesNo, and vbRetryCancel, and there are also two three-button combina-
tions, vbYesNoCancel and vbAbortRetryIgnore. There are four possible
icons,  addressable  as  vbInformation,  vbQuestion,  vbExclamation  and
vbCritical respectively. (Excel 97 and later versions have a few more, includ-
ing three with specific default buttons.) When both a button (other than the
default vbOK) and an icon is required, they are both specified, separated by a
+sign, as in Box2(). Finally, the optional title defines the text in the blue
390
Some useful macros
space at the very top of the message box. If unspecified, the default title is
Microsoft Excel. Below, several of these combinations are shown. Play with
them to see what they do!
MsgBox "Nicely done! The answer was indeed " & 79
MsgBox "Nicely done! The answer was indeed " & 79, vbExclamation
MsgBox "Correctly answered!",, "Congratulations"
'Note the two commas needed to make "Congratulations" a title
MsgBox "Correctly answered!", vbExclamation, "Congratulations"
MsgBox "Correctly answered! Do you want" & Chr(13) & _
"to try your luck one more time?", vbYesNo + vbExclamation, _
"Congratulations"
'Note the plus sign to specify buttons as well as an icon,
'and a more compact way to write a multi-line message.
Despite these embellishments, a message box works mostly as a one-way
messenger: it can give you information fromthe macro, but it can only carry
limited, binary information (of the yes/no type) back to the macro. The sim-
plest way to provide general (i.e., numerical or textual) information tothe
macro is through an input box. As our first example of an input box consider
Sub Box3( ). The optional items in parentheses are, in this order, the message
and the box title. We use a message box on the next line to verify that the
program has indeed read the information. Check it out.
Sub Box3()
myValue = InputBox("Enter your favorite number here", "Number")
MsgBox "You chose the number " & myValue
'optional verification
End Sub
The following example shows that the entered number has really been
read properly, because the macro does not merely accept it as some kind of
text but considers it as a number, and rejects incorrect offerings. Here, just
for the sake of variety, the (obligatory) message and the (optional) title are
specified in separate lines, and an (optional) default value is specified as
well. Again, if we want to specify a default value but no title, two commas
need to separate the message from the default to let the program know what
is what. Here the arguments (such as Message, Title, and Default) of the
input box are specified in advance, which makes the code longer but
perhaps somewhat easier to read.
Sub Box4()
Message = "Enter an integer between 1 and 100 here:"
Title = "Integer"
Default = "1"
myValue = InputBox(Message, Title, Default)
If myValue < 1 Then
MsgBox "The selected number is too small."
End
End If
If myValue > 100 Then
MsgBox "The selected number is larger than 100."
End
End If
10.1 What is a macro?
391
If myValue - Int(myValue) <> 0 Then
MsgBox "The selected number is not an integer."
End
End If
MsgBox "You chose the number " & myValue
End Sub
As our next example we use the input box to specify a single address, then
verify that the address was read correctly by displaying it in a message box.
When an input box is used to read either a single address or an address range
of a multi-cell array (a block), preface the InputBox instruction with the
command Set, and use Application. before InputBox.Then use that
address to select the range, as in
Sub Box5()
Dim myAddress As Range
Set myAddress = Application.InputBox _
(Prompt:="The address is:", Type:=8)
myAddress.Select
MsgBox "The address is " & myAddress.Item(1, 1).Address
End Sub
The address can be entered either as text, or by highlighting the cell
involved with the mouse pointer. In the latter case it may be shown in the
message box in so-called row-column notation, as in R3C7 for row 3 column
7, i.e., G3. Note that Type:=0 will read a formula, Type:=1 a number, Type:
=2 a text string, Type:=4 will yield a logical value (True when the address
contains a number, False when it is empty or contains a zero), Type:=8 will
read a cell reference as a Range, and Type:=64 will read an array.
In order to read other information at that address, such as a value, you can
proceed as in
Sub Box6()
Dim myAddress As Range
Set myAddress = Application.InputBox _
(Prompt:="The address is:", Type:=8)
myAddress.Select
myValue = Selection.Value
MsgBox "Address " & myAddress.Item(1, 1).Address & _
" contains the value " & myValue
End Sub
although it would be simpler to turn things around, i.e., to use the input box
to read the value and, as an afterthought, obtain the associated address.
Our final example shows how to read the address range of a multi-cell
array (a block), and to verify that you have indeed read that information cor-
rectly:
Sub Box7()
Dim myRange As Range
Set myRange = Application.InputBox _
(Prompt:="The range is:", Type:=8)
392
Some useful macros
myRange.Select
' Verify that we have read the range values
Dim NR As Integer, NC As Integer
NR = myRange.Rows.Count
NC = myRange.Columns.Count
MsgBox "The range is " & myRange.Item(1, 1).Address & _
":" & myRange.Item(NR, NC).Address
Dim myValue As Variant
myValue = Selection.Value
For j = 1 To NC
For i = 1 To NR
MsgBox "Address number " & i & "," & j & " is " & _
Selection.Item(i, j).Address & _
" and contains the value " & myValue(i, j)
Next i
Next j
End Sub
Because a message box cannot display a multi-address range by simply
calling it as MsgBox "The range is " & myRange,we have circumvented
this problem here by specifying the first and last address in the array, and by
then displaying that information in the spreadsheet format, with a colon as
separator. The second message box illustrates how to pack a lot of informa-
tion into a single, small message box.
Finally, note that one can readily trip up these last three boxes by entering
a range into Box5 or Box6, or a single address in Box7. This may be accept-
able if you use the macro only yourself. However, if you intend the macro to
be shared with others, you should add some lines of code to catch such likely
errors. In the worked-out macro programs of the next sections you will
encounter several examples of such input-checking code.
10.1g
Subroutines
Whenthesametaskisperformedatdifferentplacesinamacro,orisneeded
in several macros, we cansimply repeat the code for it every time it is
needed.However,whenthattaskisnontrivial,itisoftenmoreconvenientto
isolatethecorrespondingcode,andtoplaceitinanindependentsubrou-
tine,thatcanbeinvoked('called')wheneverneeded,fromanywhereinside
amacro,orfrominside anyothermacro.Forexample,insection10.5 we
will use a Fourier transform, and we will also need to perform several
Fouriertransformationsinsection10.6.Ratherthanrepeatthesamecode
severaltimes,itthenmakesmoresensetoplacethecodeforcomputingthe
Fouriertransformationina separatesubroutine,callablefrom anywhere.
Moreover,sinceasubroutineisafree-standingprogram,itiseasilytestedas
such.
The subroutine call must specify all parameters that the subroutine must
have to do its job, and those it must communicate back to the calling
10.1 What is a macro?
393
program. This is where the brackets are used: they specify the data that must
go into and/or come out of the subroutine.
Below we will illustrate this with an example so simple that you normally
would not write a separate subroutine for it.
Sub myMacro()
a = 1
b = 2
c = 0
MsgBox "(1): Before the subroutine call, c = " & c
Call mySum(a, b, c)
MsgBox "(4): After the subroutine call, c = " & c
End Sub
Sub mySum(a, b, c)
MsgBox "(2): a = " & a & ", b = " & b & ", c = " & c
c = a + b
MsgBox "(3): a = " & a & ", b = " & b & ", c = " & c
End Sub
Note that the brackets must contain the parameters that go into the sub-
routine (here: a and b) as well as those that it must report out (in this
example: c). The number of these parameters must be the same, and their
data type must also match. However, their names may differ, as illustrated
here:
Sub mySum(q, r, s)
MsgBox "(2): q = " & q & ", r = " & r & ", s = " & s
s = q + r
MsgBox "(3): q = " & q & ", r = " & r & ", s = " & s
End Sub
This subroutine, when called by myMacro( ), will translate ainto q, and b
into r, will then compute s, and return it to myMacro( ), which will interpret
the latter as c. The translations are done purely on the basis of the order in
which the parameters appear inside the brackets, so you must be careful
with these. In fact, you could write the following subroutine.
Sub mySum (b, c, a)
a = b + c
End Sub
and get away with it, although it might confuse a reader (though not the
computer) that the symbols used in the subroutine are a permutation of
those in the calling program. Try it out.It will show you that the subroutine
assigns parameter values exclusively on the basis of their positions in the
subroutine call, not on the basis of their names. This makes it easy to call the
subroutine from different macros, but initially may be confusing. In that
case, use the same names throughout.
Note that the output parameters will be computed but will not be trans-
ferred back to the calling macro when they are not specified in the subrou-
394
Some useful macros
tine call. For example, try the following combination, which calculates call
right, but fails to make it available to the calling macro:
Sub myMacro()
a = 1
b = 2
c = 0
MsgBox "Before the subroutine call, c = " & c
Call mySum (a, b)
MsgBox "After the subroutine call, c = " & c
End Sub
Sub mySum(a, b)
MsgBox "a = " & a & ", b = " & b & ", c = " & c
c = a + b
MsgBox "a = " & a & ", b = " & b & ", c = " & c
End Sub
Such problems with data transfer can be avoided by declaring the para-
meters involved as Public, in which case they are accessible throughout the
entire VBA module. Public parameters must be declared at the very begin-
ning of the module, in the format of a dimension statement, but with
Publicinstead of Dim, as illustrated below. Note that, in this case, we can
merely invoke the subroutine by stating its name, leaving out its brackets
and, even, the instruction Call.
Public a, b, c
Sub myMacro()
a = 1
b = 2
c = 0
MsgBox "Before the subroutine call, c = " & c
mySum
MsgBox "After the subroutine call, c = " & c
End Sub
Sub mySum
MsgBox "a = " & a & ", b = " & b & ", c = " & c
c = a + b
MsgBox "a = " & a & ", b = " & b & ", c = " & c
End Sub
The program shown in section 10.9 illustrates this format.
10.2
A case study: interpolating in a set of equidistant data
As an example of writing a macro we will here illustrate its progress, includ-
ing its validation  at various stages.  As  our  example we  will  use the
Savitzky–Golay method to interpolate in a set of equidistant data points. In
other words, given a set of data x,yfor evenly spaced x-values, we want to
10.2 A case study: interpolating in a set of equidistant data
395
estimate a value for yat an arbitrary value for xinside the range covered. In
this example we will first consider interpolating in a set of seven adjacent
data points, and we will assume that, over the limited range of those seven
adjacent data, their y-values can be approximated satisfactorily by the
quadratic expression y=a+bx+cx
2
.
The macro must of course be based on an algorithm, for which we will use
the Savitzky–Golay method, which we briefly encountered in section 3.3,
described in somewhat more detail in section 8.5, and further apply in
section 10.9. The macro should do the following:
1 read the x,ydata
2 read the specific x-value XX where the function must be interpolated
3 compute and display the corresponding, interpolated y-value YY 
In our example we will assume that the x- and y-values are stored in
columns on the spreadsheet. We will read them separately, so that those
columns need not be adjacent to each other. We will therefore use three
input boxes, one each to enter the x-values, the y-values, and the specific x-
value for which we want to interpolate the data. We will use a message box to
display the resulting y-value.
You may often want to start writing a macro by first testing its algorithm.
Once the central logic of the macro is working smoothly, you can then add
the segments dealing with data input and output. Alternatively, when the
algorithm is straightforward and well-understood, it may be easier to start at
the data input stage (which often takes the most effort), and to work from
there in a linear fashion. In the present example we will use the latter
approach.
10.2a
Step-by-step
No matter how we approach the task of writing a macro, we have to do it
step-by-step. It is easiest to validate every small part as we write it, by includ-
ing performance tests at every stage, and by progressing to the next segment
of code only after the earlier parts have been checked and verified. The per-
formance testing is best done by including message boxes that validate the
code, and by repeatedly going back and forth between the macro and the
spreadsheet to verify the code at every step. After validation, ‘comment-out’
the test lines by preceding them with, say, a triple quote,''', or'
/
, in order
to distinguish them from those comment lines (starting with a single') you
want to keep in the final version. Then, when the macro is complete, remove
all test lines starting with ''' or'
/
. (In order to save printed space, we have
removed the test lines after their first use in the examples given below.)
First we write and validate code to read the x-values. Start with a new
spreadsheet, open a module (I
nsert M
acro M
odule in Excel 5 and Excel
396
Some useful macros
Documents you may be interested
Documents you may be interested