convert pdf to image c# free : Extract data from pdf file to excel control Library platform web page asp.net .net web browser fulton_fulton65-part579

like. In reality, a full discussion of WebGL, even the basic concepts, could take up an
entire volume.
If you are interested in WebGL, we strongly recommend that you consult http://lear
ningwebgl.com for more examples and the latest information about this exciting yet still
experimental context for HTML5 Canvas.
WebGL JavaScript Libraries
At the start of this section, we promised to show you some libraries that can be used
with WebGL to make it easier to develop applications. Here are some of the more in‐
teresting libraries and projects.
Google O3D
Google’s O3D library was once a browser plug-in, but has now been released as a stand‐
alone  JavaScript  library for WebGL. The examples of using O3D with JavaScript—
including a fairly spectacular 3D pool game—are very impressive. O3D allows you to
load COLLADA 3D models created with Google SketchUp (as well as other 3D pack‐
ages).
The required code looks about as complex as straight WebGL code, so while this is very
powerful, you might want to look at some of the other libraries here first if you are just
starting out.
C3DL
The tagline for C3DL is “WebGL made easy!” C3DL, or “Canvas 3D JS Library,” is similar
to GLGE, but it seems to have a head start thanks to a larger API and more support.
This library also appears to be slanted toward games; a real-time strategy (RTS) and an
arcade game are featured as its more prominent demos. The library supports COLLADA
models, and the code also appears very straightforward to implement.
SpiderGL
“3D Graphics for Next-Generation WWW” is how SpiderGL bills itself to the world.
This library appears to be very similar to GLGE and C3DL, except that the demos focus
more on lighting, color, and textures than on games and applications. It also supports
COLLADA models.
SceneJS
SceneJS is geared toward rendering 3D scenes built as COLLADA JSON models in
WebGL. You can also define and manipulate 3D scenes. Loading and rendering the
models is a straightforward process, and the results are quite impressive.
3D with WebGL  |  629
Extract data from pdf file to excel - extract form data from PDF in C#.net, ASP.NET, MVC, Ajax, WPF
Help to Read and Extract Field Data from PDF with a Convenient C# Solution
extract data out of pdf file; export excel to pdf form
Extract data from pdf file to excel - VB.NET PDF Form Data Read library: extract form data from PDF in vb.net, ASP.NET, MVC, Ajax, WPF
Convenient VB.NET Solution to Read and Extract Field Data from PDF
html form output to pdf; extracting data from pdf files
CopperLicht
This commercial library advertises itself as the “fast WebGL JavaScript 3D Engine.” All
the demos are game-oriented, and the library supports many commercial 3D formats.
It has both collision detection and physics built in. The demos are fast and are fun to
play. This library appears to be centered on loading and using external 3D assets, so if
that is what you are looking for, this might be your best choice.
GLGE
“WebGL for the lazy” is the tagline for this JavaScript library. The author of the library,
Paul Brunt, says this about GLGE:
The aim of GLGE is to mask the involved nature of WebGL from the web developer, who
can then spend his/her time creating richer content for the Web.
This is a high-level API that is still in development. Just like O3D, it has the ability to
load COLLADA models. Applications written with GLGE are created with a combina‐
tion of XML and JavaScript. It looks very promising.
Of all of these libraries, GLGE appears to be a favorite among indie developers. It takes
a lot of the pain out of WebGL by using XML to define 3D objects, meshes, materials,
and so on.
Three.js
The most promising WebGL library might be three.js. It’s a free, lightweight API that is
gaining popularity because it is easy to use and implement.
One final note about WebGL: Microsoft has vowed to not support
WebGL in the IE browser. They believe that it poses a security threat,
and they balk at it because it is not a W3C standard. However, there is
a plug-in named iewebgl that will run most WebGL content in Internet
Explorer.
Multiplayer Applications with ElectroServer 5
Because Flash has built-in support for communication via sockets, its applications have
had the ability to open socket communications with server-side applications for many
years. HTML (until Web Sockets), on the other hand, has never had the ability to reliably
communicate to a socket server without performing some sleight of hand, usually in‐
volving constant polling by the web browser for new information from the web server.
ElectroServer from Electrotank was one of the first reliable socket-server applications
built to communicate with Flash clients. Over the past couple years, ElectroServer has
630  |  Chapter 11: Further Explorations
C# PDF Text Extract Library: extract text content from PDF file in
Able to extract and get all and partial text content from PDF file. How to C#: Extract Text Content from PDF File. Add necessary references:
saving pdf forms in acrobat reader; pdf form save in reader
VB.NET PDF Text Extract Library: extract text content from PDF
Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Extract Text Content from PDF File in VB.NET.
how to save editable pdf form in reader; extract data from pdf table
been updated with APIs for iOS, C#, C++, and now JavaScript. This first iteration of the
ElectroServer JavaScript API does not use WebSockets but instead implements Java‐
Script polling. However, with the availability of ElectroServer’s simplified JavaScript
API, you can still start to write multiplayer applications using HTML5 Canvas.
While this portion of the chapter is specific to ElectroServer, many of
the multiplayer/multiuser concepts are applicable to other technologies
as well.
Installing ElectroServer
To get started with multiplayer development using HTML5 Canvas and the Electro‐
Server socket server, you first need to download the free, 25-user version of the software
from Electrotank. You can download the appropriate version for your operating system
(Windows, Mac, Linux) at this site.
There are some installation prerequisites, such as having Java version
1.6. For detailed installation instructions for every OS, visit this site.
The install package includes the server software, client APIs, documentation, and sam‐
ple applications. After you have installed the server software, you should have a folder
named something like Electroserver_5_x_ on your computer. We used Mac OS X for
this test, so this folder was created inside the Mac Applications folder. On Windows, it
will be created in the location you specify upon installation.
Starting the server
After you have the files installed, you need to start the ElectroServer socket server by
finding  the  installation  directory  and  executing  the  file  Start_ElectroServer_5_0_1.
(Note: the three numbers at the end of this file will change as the version is upgraded,
but the concept will remain the same.)
When ElectroServer starts, you should see a screen similar to Figure 11-3.
Multiplayer Applications with ElectroServer 5  |  631
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut Image in Page. Data: Read, Extract Field Data. Data: Auto Fill-in Field
cannot save pdf form in reader; pdf data extraction open source
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
External cross references. Private data of other applications. Flatten visible layers. VB.NET Demo Code to Optimize An Exist PDF File in Visual C#.NET Project.
extract data from pdf forms; export pdf data to excel
Figure 11-3. ElectroServer started
The server will run on your local machine for testing purposes. However, for any real-
world application, you will need to install a production version of the software on a web
server.
The ElectroServer admin tool
Because ElectroServer is a socket server, it listens on a specified port for communication
from the JavaScript client using one of the supported protocols. ElectroServer supports
multiple protocols, but we need to make sure we are using the BinaryHTTP protocol
for the JavaScript API. The default port for BinaryHTTP in ElectroServer is 8989.
When the ElectroServer JavaScript API is updated to support Web‐
Sockets, the port and protocol will likely be different.
There is a nifty admin tool for ElectroServer that allows you to view and modify all the
supported protocols and ports, as well as many other cool features of the socket server.
In the /admin directory of the install folder, you should find both an installer for an
Adobe AIR admin tool (named something like es5-airadmin-5.0.0.air), and a /webad‐
min directory with an HTML file named webadmin.html. Either one will work for this
exercise.
632  |  Chapter 11: Further Explorations
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
Microsoft Office Word, Excel and PowerPoint data to PDF form. Merge PDF with byte array, fields. Merge PDF without size limitation. Append one PDF file to the end
extract table data from pdf; how to fill out pdf forms in reader
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
Merge Microsoft Office Word, Excel and PowerPoint data to PDF form. Append one PDF file to the end of another and save to a single PDF file.
how to extract data from pdf to excel; how to fill out a pdf form with reader
For the admin console to display properly, the server needs to be started.
When you launch the admin tool, you will be asked to supply a username and password.
The  default  is administrator  and password,  unless  you  changed  them  upon
installation.
After you log in, click the Server Management button on the top menu, and then choose
the Gateways option from the side menu. You should see a screen that looks similar to
Figure 11-4.
Figure 11-4. ElectroServer ports and protocols
This screen shows you the port settings for each protocol that ElectroServer supports.
For the JavaScript API, we are most interested in the BinaryHTTP setting, which you
can see is set to port 8989.
Multiplayer Applications with ElectroServer 5  |  633
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Library. Best Microsoft Office Excel to adobe PDF file converter SDK for Visual Studio .NET. Merge all Excel sheets to one PDF file. Export
can reader edit pdf forms; extract data from pdf to excel online
C# PDF File Compress Library: Compress reduce PDF size in C#.net
All object data. File attachment. External cross references. Private data of other applications. Flatten visible layers. C#.NET DLLs: Compress PDF Document.
extract data from pdf; extract pdf form data to xml
The JavaScript API
Besides starting ElectroServer, you will also need the JavaScript API so that you can
begin building Canvas apps that connect to the server. You should be able to find the
JavaScript API in the /apis/client/javascript directory of the folder in which you installed
ElectroServer. (This name might change in the final version.) The API should be named
ElectroServer-5-Client-JavaScript.js.
The Basic Architecture of a Socket-Server Application
Now that you have ElectroServer ready to go and you have the JavaScript API, it is time
to learn a bit about how socket-server-based multiplayer/multiuser applications are
designed. Using a socket server means you are creating an application that relies on a
client for input from a user, as well as relying on a server to distribute that input to other
users who are connected to the first user.
A good example of this is a chat application. Most chat applications require a user to
enter a room (a logical space in which people are “chatting”—that is, exchanging mes‐
sages), where that user can see the messages of other people in the same virtual space.
In that room, the client is “connected” to those other users. However, it is usually not a
direct connection (such as peer-to-peer), but instead, it is a connection through a port
to a socket server.
The socket server acts as the traffic cop for the chat messages. It listens on a port (in our
case, 8989) for messages coming in from the clients. Those messages need to be for‐
matted in a way that the server can understand so that it can process them. The JavaScript
API we will use performs this formatting for our client applications.
When the socket server receives a message from the client, it routes the various text
messages sent by each client back out to the other clients in the room. However, it can
also do much more by using server-side processing, such as holding the list of current
messages, so that people entering the room while the chat is ongoing can see what has
been said previously, scan chat messages for swear words, award points to users for their
input, or anything else you can dream up.
When the server finally processes the message and sends it back, the client then pro‐
cesses that message. In the case of the chat, that processing usually involves displaying
the message on the canvas.
The Basic Architecture of an ElectroServer Application
ElectroServer acts very much like the socket-server application we described in the
previous section. It listens on specified ports for different protocols; when messages
arrive, they are routed back to the connected clients.
634  |  Chapter 11: Further Explorations
However, ElectroServer has some specific features that we should discuss. Some of these
exist on other socket-server platforms, while some don’t. However, much of this dis‐
cussion will still be applicable to other socket servers when they make JavaScript APIs
available.
Client
The client for an ElectroServer application is a program written in one of the API-
supported language platforms, including Flash ActionScript 2, Flash ActionScript 3,
Java, Objective-C, C#/.NET, and now JavaScript. The client is the application, which the
user will manipulate to send messages through the API to ElectroServer. This is usually
a game, a chat room, a virtual world, or some other kind of multiuser social or com‐
munication application.
All the communication with ElectroServer is event-based. The client application uses
the JavaScript API to send events, and the client defines event handlers that listen for
messages  from  ElectroServer. All  of  these messages and events  are  communicated
through the API, which in turn is communicating through port 8989 using the Bina‐
ryHTTP protocol (at least for our examples).
Zones, rooms, and games
When a user first connects to ElectroServer, she needs to join or create a zone, which is
simply a collection of rooms. If the user tries to create a zone that already exists, she will
be added to that zone without creating a new one.
After entering a zone, the user needs to join a room in that zone. If a user attempts to
create a new room that already exists, she will be added to that room instead.
Beyond zones and rooms, ElectroServer also offers a GameManager
API that allows you to further segment users into specific instances of
a game that is being played. We do not get this granular for the examples
in this chapter.
Extensions
Extensions are server-side code modules that can process data sent by clients before that
data is sent back to other clients. Extensions can also process and create their own events.
For many games, the extension contains much of the game logic, relying on the clients
for displaying and gathering user input.
At the very minimum, an extension contains what is known as a plug-in. A plug-in is a
code module written in ActionScript 1 (basically JavaScript) or Java that can be instan‐
tiated and scoped to a room. For example, if you were making a card game, you would
want a card game plug-in on the server to handle things like shuffling the deck and
Multiplayer Applications with ElectroServer 5  |  635
making sure the correct player wins a hand. In this way, the server holds the true state
of the game. Using an extension helps keep a game flowing and lessens the users’ ability
to cheat. For the simple examples in this chapter, we will not be using any server-side
extensions. However, if you delve further into ElectroServer or other socket-server ap‐
plications, you should make sure to learn as much as possible about them.
Creating a Chat Application with ElectroServer
As an example, we are going to create a single chat application using the ElectroServer
JavaScript API. Users will submit a chat message through an HTML form, and the
displayed chat will be in HTML5 Canvas. We are also going to create and display some
messages from ElectroServer so that you can see the status of the connection to the
server.
Establishing a connection to ElectroServer
First, a client application is written so that it includes the ElectroServer JavaScript API:
<script src="ElectroServer-5-Client-JavaScript.js"></script>
The client application makes a connection to ElectroServer running on a server at a
specific URL, listening on a specific port, using a specific protocol. For our examples,
this will be localhost, 8989, and BinaryHTTP, respectively.
We need to use these values to make a connection from the client to the server. We do
this by first creating an instance of the ElectroServer object and then calling its meth‐
ods. We start by creating an instance of an ElectroServer server connection named
server. We then configure a new variable named availableConnection with the pre‐
vious properties we described, and then we add it to the server variable with a call to
the method addAvailableConnection().  We will create all of  this  code inside our
canvasApp() function:
var server = new ElectroServer.Server("server1");
var availableConnection = new ElectroServer.AvailableConnection
("localhost"8989ElectroServer.TransportType.BinaryHTTP);
server.addAvailableConnection(availableConnection);
Now we need to use the server variable we just configured to establish a connection to
ElectroServer. We do this by setting a new variable, es, as an instance of the class
ElectroServer. We then call its initialize() method and add the server we just con‐
figured to the es object by calling the addServer() method of the ElectroServer server
engine property:
var es = new ElectroServer();
es.initialize();
es.engine.addServer(server);
636  |  Chapter 11: Further Explorations
We are almost ready to try to connect to ElectroServer. However, first we need to create
some event handlers for ElectroServer events. Remember when we told you that all
the  communication  with  ElectroServer  is  done  through  creating  and listening  for
events? This is where that process begins. We need to listen for the following events:
ConnectionResponse LoginResponse JoinRoomEvent JoinZoneEvent Connectio
nAttemptResponse, and PublicMessageEvent:
es.engine.addEventListener(MessageType.ConnectionResponseonConnectionResponse);
es.engine.addEventListener(MessageType.LoginResponseonLoginResponse);
es.engine.addEventListener(MessageType.JoinRoomEventonJoinRoomEvent);
es.engine.addEventListener(MessageType.JoinZoneEventonJoinZoneEvent);
es.engine.addEventListener(MessageType.ConnectionAttemptResponse,
onConnectionAttemptResponse);
es.engine.addEventListener(MessageType.PublicMessageEventonPublicMessageEvent);
Finally, when we have everything ready, we call the connect method of the Electro
Server object and wait for events to be handled by the event listener functions we have
just established:
es.engine.connect();
When the ElectroServer API object tries to connect to an ElectroServer server, a
ConnectionAttemptResponse event will be fired back to the client from the server. We
handle that event with the onConnectionAttemptResponse() event handler. For our
application, we don’t do anything with this event except create a status message for it
that we will display. The statusMessages variable is an array of messages that we keep
around to display back as debug information for our chat application. We will discuss
this briefly in the next section:
function onConnectionAttemptResponse(event) {
statusMessages.push("connection attempt response!!");
}
At this point, the client waits for a ConnectionResponse event to be sent back from the
ElectroServer server. When the client application receives a ConnectionResponse event,
it handles it with the onConnectionResponse() event handler. When the connection is
established, the client then attempts to log on to the server. To make a logon attempt,
we need a username. We will create a random username, but it could come from an
account on a web server, a form field or cookie, Facebook Connect, or any other location
or service you might have available.
After we have a username, we create a LoginRequest() object, set the userName prop‐
erty, and then call the send() method of the es.engine object. This is how we will send
all messages to ElectroServer from this point forward:
function onConnectionResponse(event) {
statusMessages.push("Connect Successful?: "+event.successful);
var r = new LoginRequest();
r.userName = "CanvasUser_" + Math.floor(Math.random() * 1000);
Multiplayer Applications with ElectroServer 5  |  637
es.engine.send(r);
}
When ElectroServer responds from the LoginRequest, it is time to join a zone and a
room. Recall that any user connected to ElectroServer needs to belong to a room, and
every room belongs to a zone. Therefore, we need to make a user belong to one of each,
which we accomplish with a CreateRoomRequest(). We set the zoneName property to
TestZoneChat and the roomName property to TestRoomChat. If either of these does not
already exist, it will be created by the server. If they do exist, the user will be added to
them. We then send the message to ElectroServer:
function onLoginResponse(event) {
statusMessages.push("Login Successful?: "+event.successful);
username = event.userName;
var crr = new CreateRoomRequest();
crr.zoneName = "TestZoneChat";
crr.roomName = "TestRoomChat";
es.engine.send(crr);
}
We still need to wait for a couple responses from ElectroServer events that come back
through the API via port 8989. We know we have to join a zone, and we handle the event
with the function onJoinZoneEvent(), but we don’t need to do anything with it:
function onJoinZoneEvent(event) {
statusMessages.push("joined a zone");
}
The most important event we are waiting to handle is JoinRoomEvent. When we receive
this event, we know that we have joined both a zone and a room, and the application is
ready to run. For the chat application, this means the user can start typing and sending
messages. First, we set the _room variable equal to the Room object, which was returned
by the event from ElectroServer. We will use this variable for our further communi‐
cations with ElectroServer. The other thing we do in this function is set an HTML
<div> with the id of inputForm, which is made visible by changing its style. The input
Form <div> is invisible when the page loads. We do this so that the user won’t send chat
messages before the connection to ElectroServer is established. Now that everything
is ready to go, we display the inputForm <div> so that chatting can start:
function onJoinRoomEvent(event) {
statusMessages.push("joined a room");
_room = es.managerHelper.zoneManager.zoneById
(event.zoneId).roomById(event.roomId);
var formElement = document.getElementById("inputForm");
formElement.setAttribute("style""display:true");
}
638  |  Chapter 11: Further Explorations
Documents you may be interested
Documents you may be interested