display pdf winform c# : Rotate single page in pdf file application SDK utility html wpf web page visual studio 7053154973-Excel%202007%20VBA%20Programmers%20Reference%20-%20Wrox%2020077-part699

The following is valid syntax but causes a run-time error:
Range(“A1”).Copy (Range(“B1”))
With the Call Statement
If you use the Call statement, you must place parentheses around the arguments you pass to the called
procedure:
Call PostInput(SalesData, “B3”)
Because Call is of limited use, not being able to process a return value, and muddies the water with its
own rules, it is preferable not to use it.
Variable Declaration
You have seen many examples of the use of variables for storing information. It is now time to discuss
the rules for creating variable names, look at different types of variables, and talk about the best way to
define variables.
So far you have been creating variables simply by using them. This is referred to as implicit variable dec-
laration. Most computer languages require you to employ explicit variable declaration. This means that
you must define the names of all the variables you are going to use before using them in code. VBA
allows both types of declarations. If you want to declare a variable explicitly, do so using a Dim state-
ment or one of its variations, which is discussed shortly. The following Dim statement declares a variable
called SalesData
Sub GetData()
Dim SalesData
SalesData = InputBox(Prompt:=”Enter Target Sales”)
...
Most users find implicit declaration easier than explicit declaration, but there are many advantages to
being explicit. One advantage is the preservation of capitalization. More important advantages are dis-
cussed later in this chapter.
Variable names can be constructed from letters and numbers and the underscore
character. The name must start with a letter and can be up to 255 characters in length.
It is a good idea to avoid using any special characters in variable names. To be on the
safe side, you should only use the letters of the alphabet (upper- and lowercase),
plus the numbers 0–9 and the underscore (_). Also, variable names can’t be the same
as VBA keywords, such as Sub and End, or VBA function names.
38
Chapter 1: Primer in Excel VBA
Rotate single page in pdf file - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
rotate pdf pages individually; pdf rotate page and save
Rotate single page in pdf file - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
rotate pages in pdf online; pdf page order reverse
If you do not explicitly declare a variable name, you can get odd effects regarding its capitalization. Say
you write the following code:
Sub GetData()
SalesData = InputBox(Prompt:=”Enter Target Sales”)
If salesdata = “” Then Exit Sub
...
You will find that when you press Enter at the end of line 3, the original occurrence of SalesData loses
its capitalization and the procedure reads as follows:
Sub GetData()
salesdata = InputBox(Prompt:=”Enter Target Sales”)
If salesdata = “” Then Exit Sub
...
In fact, any time you edit the procedure and alter the capitalization of salesdata, the new version will
be applied throughout the procedure. If you declare SalesData in a Dim statement, the capitalization
you use on that line will prevail throughout the procedure. You can now type the variable name in low-
ercase in the body of the code and obtain confirmation that it has been correctly spelled as you move to a
new line.
Option Explicit
There is a way to force explicit declaration in VBA. Place the statement OptionExplicit in the declara-
tions section of your module, which is at the very top of your module, before any procedures, as shown
in Figure 1-26.
Figure 1-26
You might have noticed that if you enter VBA words, such as inputbox, in lowercase,
they are automatically converted to VBA’s standard capitalization when you move to
the next line. This is a valuable form of feedback that tells you the word has been
recognized as valid VBA code. It is a good idea to always type VBA words in lower-
case and look for the change.
39
Chapter 1: Primer in Excel VBA
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
using RasterEdge.XDoc.PDF; How to VB.NET: Delete a Single PDF Page from PDF File. This is a VB .NET example for how to delete a single page from a PDF document.
how to reverse pages in pdf; pdf rotate pages and save
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
x86. Demo Code: How to Delete a Single PDF Page from PDF File in C#.NET. How to delete a single page from a PDF document. String
rotate pdf pages; rotate pages in pdf expert
When you try to compile your module or run a procedure using explicit variable declaration, VBA will
check for variables that have not been declared, highlight them, and show an error message. This has an
enormous benefit. It picks up spelling mistakes, which are among the most common errors in program-
ming. Consider the following version of GetData, where there is no OptionExplicit at the top of the
module and, therefore, implicit declaration is used:
Sub GetData()
SalesData = InputBox(Prompt:=”Enter Target Sales”)
If SaleData = “” Then Exit Sub
Range(“B2”).Value = SalesData
End Sub
This code will never enter any data into cell B2. VBA happily accepts the misspelled SaleData in the If
test as a new variable that is empty, and thus is considered to be a zero-length string for the purposes of
the test. Consequently, the ExitSubis always executed and the final line is never executed. This type of
error, especially when embedded in a longer section of code, can be very difficult to see.
If you include OptionExplicit in your declarations section, and DimSalesData at the beginning of
GetData, you will get an error message, Variable not defined, immediately after you attempt to run
GetData. The undefined variable will be highlighted so that you can see exactly where the error is.
Scope and Lifetime of Variables
There are two important concepts associated with variables:
The scope of a variable defines which procedures can use that variable
The lifetime of a variable defines how long that variable retains the values assigned to it
The following procedure illustrates the lifetime of a variable:
Sub LifeTime()
Dim Sales
Sales = Sales + 1
MsgBox Sales
End Sub
You can have OptionExplicit automatically added to any new modules you create.
In the VBE, use Tools➪Options and click the Editor tab. Check the box against
Require Variable Declaration. This is a highly recommended option. Note that sett-
ting this option will not affect any existing modules, where you will need to insert
Option Explicitmanually.
Option Explicitonly applies to the module it appears in. Each module requiring
explicit declaration of variables must repeat the statement in its declarations section.
40
Chapter 1: Primer in Excel VBA
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
This guiding page will help you merge two or more PDF documents into a single one in a Visual Basic .NET imaging application.
how to rotate pdf pages and save permanently; how to rotate a single page in a pdf document
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
PDF file to the end of another and save to a single PDF file. NET document imaging toolkit, also offers other advanced PDF document page processing and
reverse page order pdf; how to rotate all pages in pdf
Every time LifeTime is run, it displays a value of one. This is because the variable Sales is only
retained in memory until the end of the procedure. The memory Sales uses is released when the End
Subis reached. Next time LifeTimeis run, Salesis re-created and treated as having a 0 value. The life-
time of Sales is the time taken to run the procedure. You can increase the lifetime of Sales by declaring
it in a Static statement:
Sub LifeTime()
Static Sales
Sales = Sales + 1
MsgBox Sales
End Sub
The lifetime of Sales is now extended to the time that the workbook is open. The more times LifeTime
is run, the higher the value of Sales will become.
The following two procedures illustrate the scope of a variable:
Sub Scope1()
Static Sales
Sales = Sales + 1
MsgBox Sales
End Sub
Sub Scope2()
Static Sales
Sales = Sales + 10
MsgBox Sales
End Sub
The variable Salesin Scope1 is not the same variable as the Sales in Scope2. Each time Scope1 is 
executed, the value of its Sales will increase by one, independently of the value of Sales in Scope2.
Similarly, the Sales in Scope2will increase by 10 with each execution of Scope2, independently of the
value of Sales in Scope1. Any variable declared within a procedure has a scope that is confined to that
procedure. A variable that is declared within a procedure is referred to as a procedure-level variable.
Variables can also be declared in the declarations section at the top of a module, as shown in the follow-
ing version of the code:
Option Explicit
Dim Sales
Sub Scope1()
Sales = Sales + 1
MsgBox Sales
End Sub
Sub Scope2()
Sales = Sales + 10
MsgBox Sales
End Sub
41
Chapter 1: Primer in Excel VBA
How to C#: Basic SDK Concept of XDoc.PDF for .NET
insert, delete, re-order, copy, paste, cut, rotate, and save or query data and save the PDF document. The PDFPage class presents a single page in a PDFDocument
reverse pdf page order online; rotate pdf page and save
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C# Users can view PDF document in single page or continue
rotate pdf page; how to change page orientation in pdf document
Scope1and Scope2are now processing the same variable, Sales. Avariable declared in the declarations
section of a module is referred to as a module-level variable, and its scope is now the whole module.
Therefore, it is visible to all the procedures in the module. Its lifetime is now the time that the workbook
is open.
If a procedure in the module declares a variable with the same name as a module-level variable, the
module-level variable will no longer be visible to that procedure. It will process its own procedure-level
variable.
Module-level variables, declared in the declarations section of the module with a Dimstatement, are not
visible to other modules. If you want to share a variable between modules, you need to declare it as
Publicin the declarations section:
Public Sales
Publicvariables can also be made visible to other workbooks, or VBAprojects. To accomplish this, a
reference to the workbook containing the Publicvariable is created in the other workbook, using Tools
➪References in the VBE.
Variable Type
Computers store different types of data in different ways. The way a number is stored is quite different
from the way text, or a character string, is stored. Different categories of numbers are also stored in dif-
ferent ways. An integer (a whole number with no decimals) is stored differently from a number with
decimals. Most computer languages require that you declare the type of data to be stored in a variable.
VBA does not require this, but your code will be more efficient if you do declare variable types. It is also
more likely that you will discover any problems that arise when data is converted from one type to
another, if you have declared your variable types. 
The following table has been taken directly from the VBA Help files. It defines the various data types
available in VBA and their memory requirements. It also shows you the range of values that each type
can handle:
Data type
Storage size
Range
Byte
1 byte
0 to 255
Boolean
2 bytes
Trueor False
Integer
2 bytes
-32,768 to 32,767
Long
4 bytes
-2,147,483,648 to 2,147,483,647
(long integer)
Single
4 bytes
-3.402823E38 to -1.401298E-45 for negative values; 
(single-precision 
1.401298E-45 to 3.402823E38 for positive values
floating-point)
Double
8 bytes
-1.79769313486231E308 to -4.94065645841247E-324 
(double-precision 
for negative values; 4.94065645841247E-324 to 
floating-point)
1.79769313486232E308 for positive values
42
Chapter 1: Primer in Excel VBA
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
With VB.NET PDF SDK, PDF document page can be rotated to 90, 180, and 270 in clockwise. Both a single page and whole file pages can be rotated and saved as
rotate pdf page few degrees; how to rotate all pages in pdf in preview
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
TIFF conversion control, C# developers can render and convert PDF document to TIFF image file with no loss in original file quality. Both single page and multi
pdf reverse page order online; reverse page order pdf online
Data type
Storage size
Range
Currency
8 bytes
-922,337,203,685,477.5808 to 922,337,203,685,477.5807
(scaled integer)
Decimal
14 bytes
+/-79,228,162,514,264,337,593,543,950,335 with no decimal
point; +/-7.9228162514264337593543950335 with 28 places
to the right of the decimal; the smallest non-0 number is
+/-0.0000000000000000000000000001
Date
8 bytes
January 1, 100 to December 31, 9999
Object
4 bytes
Any Object reference
String
10 bytes + string 
0 to approximately 2 billion characters
(variable-length)
length
String
Length of string
1 to approximately 65,400 characters
(fixed-length)
Variant
16 bytes
Any numeric value up to the range of a Double
(with numbers)
Variant
22 bytes + string 
Same range as for variable-length String
(with characters)
length
User-defined
Number required  The range of each element is the same as the range of its 
(using Type)
by elements
data type
If you do not declare a variable’s type, it defaults to the Variant type. Variants take up more memory
than any other type because each Variant has to carry information with it that tells VBA what type of
data it is currently storing, as well as store the data itself.
Variantsuse more computer overhead when they are processed. VBAhas to figure out what types it is
dealing with and whether it needs to convert between types in order to process the number. If maximum
processing speed is required for your application, you should declare your variable types, taking advan-
tage of those types that use less memory when you can. For example, if you know your numbers will be
whole numbers in the range of -32000 to +32000, you would use an Integer type.
Declaring Variable Type
You can declare a variable’s type on a Dim statement, or related declaration statements such as Public.
The following declares Sales to be a double precision floating-point number:
Dim Sales As Double
You can declare more than one variable on a Dim:
Dim SalesData As Double, Index As Integer, StartDate As Date
The following can be a trap:
Dim Col, Row, Sheet As Integer
43
Chapter 1: Primer in Excel VBA
Many users assume that this declares each variable to be Integer. This is not true. Col and Roware
Variantbecause they have not been given a type. To declare all three as Integer, the line should be
as follows:
Dim Col As Integer, Row As Integer, Sheet As Integer
Declaring Function and Parameter Types
If you have input parameters for sub procedures or function procedures, you can define each parameter
type in the first line of the procedure as follows:
Function IsHoliday(WhichDay As Date)
Sub Marine(CrewSize As Integer, FuelCapacity As Double)
You can also declare the return value type for a function. The following example is for a function that
returns a value of True or False:
Function IsHoliday(WhichDay As Date) As Boolean
Constants
You have seen that many intrinsic constants are built into VBA, such as vbYes and vbNo, discussed pre-
viously. You can also define your own constants. Constants are handy for holding numbers or pieces of
text that do not change while your code is running, but that you want to use repeatedly in calculations
and messages. Constants are declared using the Const keyword, as follows:
Const Pi = 3.14159265358979 
You can include the constant’s type in the declaration:
Const Version As String = “Release 3.9a”
Constants follow the same rules regarding scope as variables. If you declare a constant within a proce-
dure, it will be local to that procedure. If you declare it in the declarations section of a module, it will be
available to all procedures in the module. If you want to make it available to all modules, you can
declare it to be Public as follows:
Public Const Error666 As String = “You can’t do that”
Variable Naming Conventions
You can call your variables and user-defined functions anything you want, except where there is a clash
with VBAkeywords and function names. However, many programmers adopt a system whereby the
variable or object type is included, in abbreviated form, in the variable name, usually as a prefix, so
instead of declaring: 
Dim SalesData As Double
you can use:
Dim dSalesData As Double
44
Chapter 1: Primer in Excel VBA
Wherever dSalesData appears in your code, you will be reminded that the variable is of type Double.
Alternatively, you could use this line of code:
Dim dblSalesData As Double
For the sake of simplicity, this approach has not been used so far in this chapter, but from here onward,
the examples will use a system to create variable names. This is the convention used in this book:
One-letter prefixes for the common data types: 
Dim iColumn As Integer
Dim lRow As Long
Dim dProduct As Double
Dim sName As String
Dim vValue As Variant
Dim bChoice As Boolean
Two- or three-letter prefixes for object types:
Dim objExcel As Object
Dim rngData As Range
Dim wkbSales As Workbook
In addition to these characters, a lowercase a will be inserted in front of array variables, which are dis-
cussed later in this chapter. If the variable is a module-level variable, it will also have a lowercase m
placed in front of it. If it is a public variable, it will have a lowercase g (for global) placed in front of it.
For example, malEffect would be a module-level array variable containing long integer values.
Object Variables
The variables you have seen so far have held data such as numbers and text. You can also create object
variables to refer to objects such as worksheets and ranges. The Set statement is used to assign an object
reference to an object variable. Object variables should also be declared and assigned a type as with nor-
mal variables. If you don’t know the type, you can use the generic term Object as the type:
Dim objWorkbook As Object
Set objWorkbook = ThisWorkbook
MsgBox objWorkbook.Name
It is more efficient to use the specific object type if you can. The following code creates an object variable
rng,referring to cell B10 in Sheet1, in the same workbook as the code. It then assigns values to the
object and the cell above:
Sub ObjectVariable()
Dim rng As Range
Set rng = ThisWorkbook.Worksheets(“Sheet1”).Range(“C10”)
rng.Value = InputBox(“Enter Sales for January”)
rng.Offset(-1, 0).Value = “January Sales”
End Sub
If you are going to refer to the same object more than once, it is more efficient to create an object variable
than to keep repeating a lengthy specification of the object. It also makes code easier to read and write.
45
Chapter 1: Primer in Excel VBA
Object variables can also be very useful for capturing the return values of some methods, particularly
when you are creating new instances of an object. For example, with either the Workbooks object or the
Worksheetsobject, the Addmethod returns a reference to the new object. This reference can be assigned
to an object variable so that you can easily refer to the new object in later code:
Sub NewWorkbook()
Dim wkb As Workbook, wks As Worksheet
Set wkb = Workbooks.Add
Set wks = wkb.Worksheets.Add(After:=wkb.Sheets(wkb.Sheets.Count))
wks.Name = “January”
wks.Range(“A1”).Value = “Sales Data”
wkb.SaveAs Filename:=”JanSales.xlsx”
End Sub
This example creates a new empty workbook and assigns a reference to it to the object variable wkb.
Anew worksheet is added to the workbook, after any existing sheets, and a reference to the new work-
sheet is assigned to the object variable wks. The name on the tab at the bottom of the worksheet is then
changed to January, and the heading Sales Data is placed in cell A1. Finally, the new workbook is saved
as JanSales.xlsx.
Note that the parameter after the Worksheets.Add is in parentheses. Because you are assigning the
return value of the Addmethod to the object variable, any parameters must be in parentheses. If the
return value of the Addmethod were ignored, the statement would be without parentheses, as follows:
wkb.Worksheets.Add After:=wkb.Sheets(wkb.Sheets.Count)
With...End With
Object variables provide a useful way to refer to objects in shorthand, and are also more efficiently pro-
cessed by VBA than fully qualified object strings. Another way to reduce the amount of code you write,
and also increase processing efficiency, is to use a With...EndWith structure. The final example in the
previous section could be rewritten as follows:
With wkb
.Worksheets.Add After:=.Sheets(.Sheets.Count)
End With
VBA knows that anything starting with a period is a property or a method of the object following the
With. You can rewrite the entire NewWorkbookprocedure to eliminate the wkbobject variable, as follows:
Sub NewWorkbook()
Dim wks As Worksheet
With Workbooks.Add
Set wks = .Worksheets.Add(After:=.Sheets(.Sheets.Count))
wks.Name = “January”
wks.Range(“A1”).Value = “Sales Data”
.SaveAs Filename:=”JanSales.xlsx”
End With
End Sub
You can take this a step further and eliminate the wks object variable:
46
Chapter 1: Primer in Excel VBA
Sub NewWorkbook()
With Workbooks.Add
With .Worksheets.Add(After:=.Sheets(.Sheets.Count))
.Name = “January”
.Range(“A1”).Value = “Sales Data”
End With
.SaveAs Filename:=”JanSales.xlsx”
End With
End Sub
If you find this confusing, you can compromise with a combination of object variables and With...End
With:
Sub NewWorkbook()
Dim wkb As Workbook, wks As Worksheet
Set wkb = Workbooks.Add
With wkb
Set wks = .Worksheets.Add(After:=.Sheets(.Sheets.Count))
With wks
.Name = “January”
.Range(“A1”).Value = “Sales Data”
End With
.SaveAs Filename:=”JanSales.xlsx”
End With
End Sub
With...End Withis useful when references to an object are repeated in a small section of code.
Making Decisions
VBA provides two main structures for making decisions and carrying out alternative processing, repre-
sented by the If and SelectCase statements. If is the more flexible one, but SelectCase is better
when you are testing a single variable.
If Statements
Ifcomes in three forms: the IIffunction, the one-line Ifstatement, and the block Ifstructure. The fol-
lowing dTax function uses the IIf (Immediate If) function:
Function dTax(dProfitBeforeTax As Double) As Double
dTax = IIf(dProfitBeforeTax > 0, 0.3 * dProfitBeforeTax, 0)
End Function
IIfis similar to the Excel worksheet IFfunction. It has three input arguments: the first is a logical test,
the second is an expression that is evaluated if the test is true, and the third is an expression that is eval-
uated if the test is false. 
In this example, the IIf function tests that the dProfitBeforeTax value is greater than 0. If the test is
true, IIf calculates 30% of dProfitBeforeTax. If the test is false, IIf calculates 0. The calculated IIf
value is then assigned to the return value of the Tax function. The Tax function can be rewritten using
the single-line If statement as follows:
47
Chapter 1: Primer in Excel VBA
Documents you may be interested
Documents you may be interested