c# pdf viewer library free : Change page order pdf reader application Library tool html .net web page online World%20of%20Warcraft%20Programming%20(2nd%20Edition)10-part1762

Chapter 4
Working with Tables
59
Run the following in your interpreter to create a sample table and a function
that will allow you to easily print the contents of the array part of a table that
is passed in as an argument:
tmp = {“alpha“, “beta“, “gamma“}
function print_array(tbl)
for i = 1, #tbl do
print(i, tbl[i])
end
end
To print the current list, use the following command:
> print_array(tmp)
1
alpha
2
beta
3
gamma
To add a new element to the end of the list, call
table.insert()
with the
table you’d like to alter and the value you’d like to add:
> table.insert(tmp, “delta“)
> table.insert(tmp, “epsilon“)
> print_array(tmp)
1
alpha
2
beta
3
gamma
4
delta
5
epsilon
To insert a new value at a given position, call
table.insert()
with the
optional secondparameter
pos
,anumberthatindicates atwhatposition you’d
like toadd the element. When you insert a valuein this way, all elements after
the given position will be renumbered and moved up.
> table.insert(tmp, 3, “zeta“)
> print_array(tmp)
1
alpha
2
beta
3
zeta
4
gamma
5
delta
6
epsilon
When using the position argument, it’s important to make sure you’re
supplying a valid number. The position should always be between
1
,which
inserts the value at the front of the list, and
#tmp + 1
,which inserts itafter the
Change page order pdf reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change pdf page order reader; how to move pages in a pdf document
Change page order pdf reader - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to move pages in pdf acrobat; change pdf page order preview
60
Part I
Learning to Program
current last element. If you supply a value outside this range, the results are
unpredictable.
Removing Elements from an Array
Lua includes a function to remove elements from a table, and the syntax is
similar to its companion
table.insert()
:
value = table.remove(tbl [, pos])
This function takes up to two parameters:
tbl
—The table to alter
pos
(optional)—The element to remove from the table
Thefunction signature iswrittenas ifitwasan assignment.Thisis shorthand
notation to show that the function also returns something:
value
—The value removed from the table
Again, the brackets around
pos
show that it is an optional parameter.When
aposition isn’t included, Lua will remove the last element in the table (that is,
the elementat the
#tbl
position).
To remove the last element of a table, use the following command:
> removed = table.remove(tmp)
> print_array(tmp)
1
alpha
2
beta
3
zeta
4
gamma
5
delta
> print(removed)
epsilon
By simply calling
table.remove()
with only a table argument, the last
element has been removedand we’re left with the rest of the table.
Here’s how to remove a specific element in a table:
> removed = table.remove(tmp, 3)
> print_array(tmp)
1
alpha
2
beta
3
gamma
4
delta
> print(removed)
zeta
When anelementis removedfromthe middleofthetable(including the first
element), all other elements are renumbered and shifted down. This ensures
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order of a you want to see other VB.NET Word document editing controls, please read this Word reading page which has
reverse page order pdf; how to reverse pages in pdf
C# Word - Process Word Document in C#
various Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or
move pages in pdf; move pages in pdf document
Chapter 4
Working with Tables
61
that the elements of the array are always numbered properly so the array part
functions all work properly.
Just because a function has return values doesn’t mean you have to do
anything with them. You could just as easily call
table.remove()
,ignoring
the return value entirely.
Sorting the Elements of an Array
When an array contains basic elements such as strings and numbers that can
be easily compared, there is a standard library function to sort the list. The
syntax of the
table.sort()
function follows:
table.sort(tbl [, comp])
The second argument to
table.sort()
is coveredin detail in Chapter 5, but
the first argument is the table that you would like to sort. You can call this
function and pass it a table to be sorted as the first argument:
> print_array(tmp)
1
alpha
2
beta
3
gamma
4
delta
> table.sort(tmp)
> print_array(tmp)
1
alpha
2
beta
3
delta
4
gamma
Because the values in this table are strings, they are sorted alphabetically,
in ascending order (this is the default). If the table contained numbers, they
would be sorted in the same way.
Asimple sort like this won’t be effective for more complex values (such as
tables),orwhenthevalues inan arrayaremixed(such asstrings andnumbers).
Chapter 5 will show you how to use the second argument to
table.sort()
to
custom tailor the
sort
function for these situations.
Using Tables as Namespaces
You’ve already been introduced to a few functions that are grouped together:
table.insert()
table.remove()
table.sort()
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
PDF Document; Remove Password from PDF; Change PDF Permission Settings. Page: Insert PDF pages; VB.NET Page: Delete PDF VB.NET Annotate: PDF Markup & Drawing. XDoc
rearrange pages in pdf reader; how to move pdf pages around
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
how to reorder pages in pdf file; move pages in a pdf file
62
Part I
Learning to Program
When functions are grouped together in this manner, they are said to be
part of a namespace, in this case, the
table
namespace. Namespaces provide a
logical grouping of functions that are related,collected in a Lua table. Because
tables can hold function values, the preceding functions are also accessible
using:
table[“insert“]()
table[“remove“]()
table[“sort“]()
Creating a new namespace is a matter of writing your new functions,
creating a new table,andsetting the appropriate key/valuepairs in your table.
Creating a Namespace of Utility Functions
You’ve already written a few utility functions that might be handy to keep
around, such as
convert_c2f()
.You can create a new namespace to start
storing these functions by defining a new table:
> util = {}
Adding Functions to a Namespace
You have two differentways to add functions to a namespace: by indexing the
table and storing the value of an existing function, or by defining the function
directly as part of the namespace.
Storing an Existing Function
Ifyou’veclosed yourpreviousLua session,redefine yourCelsius to Fahrenheit
conversion function:
function convert_c2f(celsius)
return (celsius * 1.8) + 32
end
Now that you have a function to which you can refer, run the following
code to store it in the
util
table:
> util.celsius2fahrenheit = convert_c2f
This function can then be accessed directly from the
util
table:
> print(util.celsius2fahrenheit(0))
32
> print(util.celsius2fahrenheit(-40))
-40
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
how to change page order in pdf acrobat; rearrange pdf pages online
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
VB.NET PDF - How to Modify PDF Document Page in VB.NET. VB.NET Guide for Processing PDF Document Page and Sorting PDF Pages Order.
move pdf pages in preview; pdf rearrange pages
Chapter 4
Working with Tables
63
Defining a New Function
Rather than define a function with a name and then set it as part of the
namespace,you can define thefunction directlyas part ofthe namespace. Run
the following code:
function util.factorial(num)
local total = 1
for i = 1, num do
total = total * i
end
return total
end
You may recall from Chapter 3 that this method of function definition is
syntactic sugar and is translated by Lua into the following:
util.factorial = function(num)
local total = 1
for i = 1, num do
total = total * i
end
return total
end
Using the first form is often the most convenient way to define functions,
and it makes the code easier to read compared to the alternative methods.
More often than not, when you read a namespace definition, you will see it in
this form; however, as always, feel free to develop your own style.
Object-Oriented Programming with Tables
Tablescanalsobeusedforadifferenttypeofprogrammingcalledobject-oriented
programming. In this type of programming, data is described as objects, which
containmethods,specialfunctions thatactdirectlyon orthroughthatobject.Lua
provides some simple mechanisms to enable object-oriented programming,
but does not strictly enforce any particular style of programming.
Creating a Non-Object-Oriented Counter
To illustrate some of the benefits this type of programming provides, run the
following in your interpreter:
-- Create a new scope for local variables
do
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Empower C# Users to Change the Rotation Angle of PDF File DLLs for PDF Page Rotation in C#.NET Project. In order to run the sample code, the following steps
how to rearrange pages in a pdf reader; rearrange pages in pdf
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Change PDF original password. In order to run the sample code, the following steps would be
change page order pdf reader; how to reorder pages in pdf online
64
Part I
Learning to Program
-- Create a counter that cannot be accessed outside this scope
local counter = 0
-- Global functions to interact with counter
function counter_get()
return counter
end
function counter_inc()
counter = counter + 1
end
end
This block of code makes a simple, one-way counter that can’t be decre-
mented, but can be retrieved and incremented via the
counter_get()
and
counter_inc()
functions. Explore this by running the following in your
interpreter:
> print(counter_get())
0
> counter_inc()
> counter_inc()
> print(counter_get())
2
> counter = counter - 1
stdin:1: attempt to perform arithmetic on global 'counter' (a nil value)
stack traceback:
stdin:1: in main chunk
[C]: ?
You can see that the counter variable is not accessible outside of the created
scope and thus can’t be altered without calling the provided functions. This
code implements a single counter when, in fact, you might need more than
one. Because these functions are tied to a specific counter variable, they are
very limited.
Using Tables as Simple Objects
Thefollowing is adifferentimplementationforthesimple counter,making the
counteran objectwith two methods,
get
and
inc
.Unlike the first example, the
countercanbe altereddirectly withoutcallingthe functions. Run the following
code in your interpreter:
counter = {
count = 0
}
function counter.get(self)
Chapter 4
Working with Tables
65
return self.count
end
function counter.inc(self)
self.count = self.count + 1
end
This program allows you to do the following:
> print(counter.get(counter))
0
> counter.inc(counter)
> print(counter.get(counter))
1
In this implementation,the actual counter variableis storedin a table (which
serves as the object). Each of the functions that interact with this value has an
argument named
self
,which is expected to be a counter object. You could
make a new counter by running the following:
> counter2 = {
>> count = 15,
>> get = counter.get,
>> inc = counter.inc,
>> }
> print(counter2.get(counter2))
15
Because the functions are just Lua values and they are designed to work on
an argument rather than some magical hidden variable, you can copy them
into your counter.As a matter of fact,the functions will work correctly even if
you call
counter.get()
but pass it the
counter2
object:
> print(counter.get(counter2))
15
> print(counter.get == counter2.get)
true
This should be no surprise because you’re just moving and copying refer-
encestothesamefunctions around.Although thisimplementationis definitely
more convenient than the first attempt,it can be made even easier.Right now,
you have to call the function and pass in the counter object, causing you
to type the object’s name twice. Lua provides a bit of syntactic sugar that
helps you.
Using : to Call Object Methods
In the preceding example you can refer to
get
and
inc
as object methods
because they are written to be called within the context of an object. Lua
66
Part I
Learning to Program
provides a bit of syntactic sugar that makes calling an objects methods easier.
Instead of typing
counter.get(counter)
,you can call
counter:get()
.
Lua translates
counter:get()
into
counter.get(counter)
,saving you a bit
of typing and making code easier to read. This all happens behind the scenes
and prevents from you having to pass the object in every time you make a
method call.
Defining Functions Using :
You can use the
:
operator to define functions, making this type of program-
ming even more natural. When this happens, Lua includes an implicit first
argument called
self
.That’s why you used the variable name
self
in the
previous example.
Redefine the earlier functions by typing the following into your interpreter:
counter = {
count = 0
}
function counter:get()
return self.count
end
function counter:inc()
self.count = self.count + 1
end
This code is roughly equivalentto the following definition:
counter = {
count = 0
}
function counter.get(self)
return self.count
end
function counter.inc(self)
self.count = self.count + 1
end
Test this new version with the following code:
> print(counter:get())
0
> counter:inc()
> counter:inc()
> print(counter:get())
2
Chapter 4
Working with Tables
67
COMMON ERRORS
If you attempt to call a method that expects the self argument with a period
instead of a colon, you might get an error similar to this:
stdin:2: attempt to index local 'self' (a nil value)
Most of the time, when you get this error, it means you are accidentally call-
ing a method without passing a first argument, or you used a period where
you meant to use a colon.
Making a Better Counter
The counter program still has room for improvement because the way new
counters are created is relatively clunky. Run the following to define a more
robust counter system:
-- Create a new scope for local variables
do
local function get(self)
return self.count
end
local function inc(self)
self.count = self.count + 1
end
function new_counter(value)
if type(value) ~= “number“ then
value = 0
end
local obj = {
count = value,
get = get,
inc = inc,
}
return obj
end
end
This example provides a single global function called
new_counter
,which
takes the initial value of the counter as an argument. It returns a new object
containing two methods and the counter value itself. This type of function is
typically called a factory function because it just returns new objects each time
you call it. Run a few tests to ensure the system works properly:
> counter = new_counter()
> print(counter:get())
68
Part I
Learning to Program
0
> counter2 = new_counter(15)
> print(counter2:get())
15
> counter:inc()
> print(counter:get())
1
> print(counter2:get())
15
Although the implementation may seem a bit more complex than the
previous attempts,creating and manipulatingnew counters is extremely easy.
Choose whichever implementation makes the most sense in your code.
Extending Tables with Metatables
Each table in Lua is capable of having a metatable attached to it. A metatable is
asecondary table that gives Lua extrainformation about how thattable should
be treated when it is used. For example, by default, when you try to print a
table youaregiven a string thatlooks something like
table: 0x30d470
,which
isn’t extremely readable. Lua provides a way to change this behavior using
metatables and metamethods.
Adding a Metatable
Ametatable is nothing morethan a tableused to storeextra information about
the tables to which it is attached. They can be passed around, attached to
multiple tables, and altered at any time. To begin redefining the behavior of
atable, you must create a metatable and attach it to a table object, using the
setmetatable()
function. This function takes two arguments:
tbl
—The table to alter
mt
—The table to attach to
tbl
In addition,
setmetatable()
returns a singleargument, the tableyoupassed
in as the first argument. This can be helpful when creating new tables to pass
directly to
setmetatable()
.Run the following code to create some tables to
play with, and attach the same metatable to each of them:
tbl1 = {“alpha“, “beta“, “gamma“}
tbl2 = {“delta“, “epsilon“, “zeta“}
tbl3 = {}
mt = {}
setmetatable(tbl1, mt)
setmetatable(tbl2, mt)
setmetatable(tbl3, mt)
Documents you may be interested
Documents you may be interested