c# ghostscript pdf to image : Attach image to pdf form software control cloud windows web page .net class TutorialPacket1-part1080

test it, and note that your page now has a 500-pixel-high blank space just below the image. That’s
the canvas, but we want it in front of the image, not underneath.
To move the canvas in front of the image, you need to use CSS absolute positioning. Simply
insert style="position:absolute;" in the img tag, and style="position:relative;"
in the opening canvas tag. Although it isn’t necessary here, I also recommend adding
position:relative; to the style of the enclosing div.
Basically, position:absolute tells the browser to go ahead and place the element as usual,
but then back up and place the next element as if the absolutely positioned element weren’t there.
The explanation of position:relative (relative to not setting the position property at all) is
more technical, but it works. In any case, please make these changes now and check that the
page layout looks the same as it did before the canvas was there.
2. Draw on it using JavaScript.
You now have an invisible space where you can draw. To actually draw on it, you need to add
some JavaScript to your page.
JavaScript is a programming language that you can use to manipulate anything and everything on
a web page, changing the page from mere static information into a dynamic program (usually with
user interactivity). To insert JavaScript code into a page you use the script element, like this:
// JavaScript code goes here.
The script can be placed inside either head or body, but I usually put it in the latter, after all of
the page’s visible content. So please do that, and then put the following JavaScript code inside the
var theCanvas = document.getElementById("theCanvas");
var theContext = theCanvas.getContext("2d");
theContext.arc(300, 50, 5, 0, 2*Math.PI);
theContext.fillStyle = "red";
The first line searches your page for an HTML element with id="theCanvas", and gives your
JavaScript code access to this element through a variable of the same name. (You could use a
different name for the variable, and actually most browsers will create a variable with the same
name for you by default, but it’s a good idea to make it explicit.) The second line is needed for
technical reasons: It gives you access to what’s called the canvas’s graphics context, which is
what you use for the actual drawing. Once you have that, the next four lines draw a red filled circle
on the canvas, centered at pixel coordinates (300, 50), with the second coordinate measured down
from the top. The radius of the circle is 5 pixels, and the last two arguments of the arc function
specify the beginning and ending angles (in case you ever want to fill a pie slice instead of a full
Go ahead and test this JavaScript code, then try changing the location and size and color of the
red circle. (Besides common color names like "red", you can use hexadecimal codes of the form
Attach image to pdf form - C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#.net, ASP.NET, MVC, WinForms, WPF
Online C# Tutorial to Automatically Fill in Field Data to PDF
convert pdf file to fillable form online; add fillable fields to pdf
Attach image to pdf form - VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
create fillable forms in pdf; create a pdf form to fill out
"#rrggbb", just as in CSS.)
These six lines of JavaScript illustrate several important features of the language’s syntax:
All words are case-sensitive.
The = symbol is used to set the value of a variable.
Every statement ends with a semicolon.
Function arguments are in parentheses, which are required even when there are no
A period (or “dot”) indicates variables and functions that belong to a particular object.
In fact, most of the syntax of JavaScript is ultimately borrowed from C, and from its descendants
such as C++ and Java, so if you already know one of these languages, you won’t need to learn
much new syntax. However, the higher-level features of JavaScript are quite different from these
other languages and may take more getting used to. For example, all JavaScript variables are
declared using the var keyword, rather than by specifying a particular data type such as int or
double. This is because JavaScript variable types are determined automatically as your program
runs—a feature that many of us find unsettling.
3. Put it in motion.
Our next goal is to put that red dot (which will represent the launched projectile) into motion.
First, insert two more lines of JavaScript, somewhere before beginPath, to define general
coordinates x and y for the center of the dot:
var x = 300;
var y = 50;
Then, in the line that calls the arc function, change the constants 300 and 50 to x and y. These
changes should have no effect by themselves, but now you can move the four graphics
instructions into a self-contained function that will work for any x and y values. To create your own
function in JavaScript you use the function keyword (analogous to var for variables), like this:
function drawProjectile() {
theContext.arc(x, y, 5, 0, 2*Math.PI);
theContext.fillStyle = "red";
(Again the syntax is taken from C, using curly braces to group together the statements that are
part of the function definition.) In addition, you need another function that will change the values of x
and y. Let’s call this one moveProjectile:
function moveProjectile() {
x += 1;
window.setTimeout(moveProjectile, 1000/30);
VB.NET Image: Image Drawing SDK, Draw Text & Graphics on Image
text writing function and graphics drawing function, we attach links to provide powerful & profession imaging controls, PDF document, image to pdf files and
convert pdf forms to fillable; change font size in fillable pdf form
VB.NET Image: VB.NET Rectangle Annotation Imaging Control
Able to attach a user-defined shadow to created rectangle annotation to provide powerful & profession imaging controls, PDF document, image to pdf files and
create a fillable pdf form from a pdf; convert an existing form into a fillable pdf
Here the first statement adds 1 to the value of x (you could alternatively write x = x + 1); the
second statement calls the drawProjectile function; and the third statement tells your browser
to call the moveProjectile function again in 1000/30 milliseconds (so it will be called about 30
times per second). This is the “trick” that keeps the animation going.
You still need to get the process started, by calling moveProjectile once from outside of any
(Put this statement right after your variable initializations.) When you test this code, you should see
the red dot being drawn repeatedly at rightward-moving locations across the window, right up to the
edge of the canvas.
To merely move the red dot, erasing it from its previous location, you can just erase the whole
canvas at the beginning of the drawProjectile function:
theContext.clearRect(0, 0, theCanvas.width, theCanvas.height);
(The clearRect function can be used more generally to erase any rectangular area, where the
parameters are the left, top, width, and height, respectively, all in nominal pixel coordinates. Here
you also see that the theCanvas object provides width and height variables that you can use
as needed.)
Again, be sure to test this change to your code.
This method of erasing and redrawing the projectile might seem cumbersome, especially compared
to higher-level graphics environments in which you could simply change the values of x and y and
see the object move automatically in response. That higher-level approach is called retained-mode
graphics, and it’s more convenient for animating the motions of a limited number of objects. The
canvas element, instead, implements what’s called immediate-mode graphics, in which each
shape is immediately drawn as pixels and only the pixels themselves are stored in the computer’s
memory. Immediate-mode graphics provides better performance for complex images that cannot
be reduced to a few hundred (or fewer) discrete lines or polygons. Should you ever want a
retained-mode environment for your animations, you can learn one of the JavaScript libraries
implements retained-mode graphics on top of canvas.
4. Put in the physics.
Of course you don’t want the projectile to move in an arbitrary way; you want it to move in
response to earth’s gravity. So please remove the statement x += 1 from your
moveProjectile function and replace it with some physics calculations, starting with these
variable definitions:
var newtonG = 6.67e-11;        // grav. constant in SI units
var earthMass = 5.97e24;       // kilograms
var dt = 5;                    // time step in seconds
var r = Math.sqrt(x*x + y*y);
var accel = newtonG * earthMass / (r * r);  // magnitude of a
Here you see how to enter numbers in scientific notation and how to do some simple arithmetic,
VB.NET Word: VB Tutorial to Convert Word to Other Formats in .NET
rendered REImage into desired document image format 2007 or later versions into PDF, tiff, bmp NET Word converting functions but also attach detailed programming
convert word to pdf fillable form; convert an existing form into a fillable pdf form
VB.NET Image: VB.NET Sample Code to Draw EAN-13 Barcode on Image
How to Attach EAN-13 Barcode Image to Word in VB.NET. NET EAN-13 barcode generation tutorial page on how to add & insert EAN-13 barcode into image, PDF or Word
create fillable form from pdf; fillable pdf forms
including a square root. Note that JavaScript (like C and Java) has no exponentiation operator, so
to square a number you just multiply it by itself. As in Java and C++, the double-slash indicates the
start of a comment, which continues to the end of the line. I should also explain that by declaring
these new variables (with var) inside your moveProjectile function you are making them local
to that function, so they aren’t available to any of the rest of your code, and their values disappear
between successive calls to the function. The alternative is to make a variable global, which you
do by declaring it outside of any function (as you did with x and y). It’s a good habit to make
variables local whenever possible. (Unfortunately, JavaScript doesn’t actually require you to
declare variables at all—but any undeclared variables automatically become global, and this can
result in buggy code. Please declare all your variables!)
The last line of code above calculates the magnitude of our projectile’s acceleration, using
Newton’s law of universal gravitation. (The projectile’s mass cancels out.) Notice how I’ve
assumed that x and y are now measured in meters, from the center of the earth. We can find the x
and y components of the acceleration vector with the aid of a sketch:
From the similar triangles you can see that the x component of the acceleration vector is minus its
magnitude times the ratio x/r, and similarly for the y component. The code to compute these
components is therefore:
var ax = -accel * x / r;
var ay = -accel * y / r;
From these acceleration components you can now update the components of the projectile’s
velocity, and then use these to update the position:
vx += ax * dt;
vy += ay * dt;
x += vx * dt;
y += vy * dt;
I’ve already chosen a dt value of 5 seconds, which is quite short compared to the natural time
scale for a low-earth orbit (on the order of an hour). But because dt isn’t infinitesimal, this algorithm
predicts the projectile’s motion only approximately. The particular approximation used here is
sometimes called the Euler-Cromer algorithm
; it improves upon the standard Euler algorithm by
using the new velocities, rather than the old ones, to update the positions.
Besides inserting all this code into your moveProjectile function, you also need to declare and
initialize the velocity variables. Since their values need to persist through multiple calls to
moveProjectile, you should declare them at the global level:
var vx = 6000;   // meters per second
VB.NET TIFF: VB.NET Code to Scan Document into TIFF Image File
generate those scanned documents in TIFF or PDF file format. you are also allowed to determine the image type, TIFF Here we attach a link which can lead you to
change pdf to fillable form; create a fillable pdf form online
var vy = 0;
While you’re at it, you’d better properly initialize the position:
var earthRadius = 6371000;   // meters
var mountainHeight = earthRadius * 0.165;  // chosen to match image
var x = 0;
var y = earthRadius + mountainHeight;
Finally, in your drawProjectile function, you need to convert the physical coordinates into
canvas pixel coordinates:
var metersPerPixel = earthRadius / (0.355 * theCanvas.width);
var pixelX = theCanvas.width/2 + x/metersPerPixel;
var pixelY = theCanvas.height/2 - y/metersPerPixel;
The number 0.355 in the first line is chosen to match the image, and the minus sign in the last line
is because the pixel coordinate is measured down from the top. Now just use pixelX and
pixelY instead of x and y in the arc function (there’s no need to round these values to integers),
and it should all work. Try it!
One piece of physics that’s still missing is the earth’s hard surface. To stop the simulation when
the projectile hits the ground, all you need to do is enclose most of the code in moveProjectile
in an if statement:
var r = Math.sqrt(x*x + y*y);
if (r > earthRadius) {
var accel = newtonG * earthMass / (r * r);
// and so on...
(Let’s continue to neglect the rather dramatic effects that earth’s atmosphere would have on a
projectile moving several kilometers per second!)
Of course, the whole point of the simulation is that for sufficiently high initial speeds, the projectile
will never hit the ground. In that case you probably want to stop it after a complete orbit. You can
do so by saving the old value of x just before you update it, and then testing whether x has
changed from negative to positive:
var lastx = x;
x += vx * dt;
y += vy * dt;
if (!((lastx < 0) && (x >= 0))) {
window.setTimeout(moveProjectile, 1000/30);
(Note the use of the logical operators && for and and ! for not.)
5. Debug JavaScript errors.
It would be astonishing if by this time you haven’t made at least one typographical or other error
while entering your JavaScript code. In that case, you may have found that the code simply fails to
run, with no apparent explanation.
Fortunately, you can get an explanation in such cases by viewing your browser’s JavaScript
console. The way to view it varies with different browsers; it may be called something like Web
Inspector, perhaps under a special Developer menu that you have to enable. If you haven’t
already, take the time to find it now, and then check out what it shows when you introduce a fatal
error into your code (perhaps misspelling one of the variable names). The console should display
an error message, the most important part of which is the line number of the offending code. This
would also be a good time to configure your text editor to display line numbers in the left margin, if it
isn’t already doing so.
Of course, the more troublesome bugs are those that don’t generate error messages but still cause
your program to produce incorrect results. To diagnose those, you can use the console.log
function to send your own diagnostic messages to the console:
console.log("Entering drawProjectile function");
console.log("Current position is " + x + ", " + y);
The second example also illustrates how the + operator can be used to concatenate text strings,
and how JavaScript automatically converts numbers to strings when necessary.
This was a long section of the tutorial, but it covered a lot of material: the JavaScript programming
language, the HTML5 canvas element, and an algorithm for integrating Newton’s second law to
predict the motion of a projectile.
At the end of this packet are one-page reference sheets on JavaScript and Canvas graphics,
which give an overview of the features covered here and a number of other useful features. The
example pages that accompany this tutorial also demonstrate several features of these
For more comprehensive references, you can try W3Schools
and also the HTML5 Canvas
site. Stack Overflow
is again an essential resource. The definitive book on JavaScript is
David Flanagan’s JavaScript: The Definitive Guide
, which includes a chapter on canvas graphics.
A nice book that’s dedicated to the latter is Core HTML5 Canvas
by David Geary.
To learn more about solving Newton’s second law (and other differential equations) on a computer,
some of the best textbooks are Numerical Methods for Physics
by Alejandro Garcia,
Computational Physics
by Giordano and Nakanishi, and Introduction to Computer Simulation
by Gould, Tobochnik, and Christian.
User Interaction
After finishing the previous section
of this tutorial, you should have a working web simulation of
Newton’s Cannon, with animated graphics. But the simulation runs just once when the page loads,
and the projectile’s initial velocity is hard-coded to a fixed value. Your next task is to hand the
control of the simulation over to the user.
1. Add a “Fire!” button.
First let’s add a “Fire!” button to start the simulation. To put a button to your page you can use the
HTML input element, like this:
<input type="button" value="Fire!">
Go ahead and insert this code, below the div that contains the image and the canvas, but above
the paragraph of text, and check that the button appears. To center the button, put it inside its own
div with a style attribute that sets text-align:center. (You could put the button inside a
paragraph instead of a div, but it’s best to reserve paragraphs for text.)
Next you need a JavaScript function to call when the button is pressed. This function should
initialize the position and velocity variables, then call moveProjectile to get the simulation
function fireProjectile() {
x = 0;
y = earthRadius + mountainHeight;
vx = 6000;
vy = 0;
The position and velocity variables still need to be declared at the global level (so their values
persist after this function exits), but those declarations can now be shortened to a single line:
var x, y, vx, vy;     // position and velocity
To call fireProjectile when the button is pressed, you can simply set the button’s onclick
attribute inside its HTML tag:
<input type="button" value="Fire!" onclick="fireProjectile();">
Now, when you load the page, you can fire the projectile repeatedly. Try it!
But there’s a slight problem: If you impatiently click the Fire! button again, before the projectile has
landed, the simulation will restart and will now run twice as fast as before. This is because you’ve
called moveProjectile again while another call to moveProjectile is still pending via the
most recent setTimeout, so you end up with two calls to moveProjectile either pending or
running at any given time. You can fix this bug by storing the result of setTimeout in a variable:
timer = window.setTimeout(moveProjectile, 1000/30);
Declare this timer variable at the global level, and then insert the following line at the beginning of
2. Add a slider to set the launch speed.
Finally it’s time to let the user adjust the projectile’s initial speed. The best way to do this is with a
slider control:
<input type="range" min="0" max="8000" step="100" value="3000">
Insert this tag right after the one for the button, inside the same div, and check that it shows up in
your browser. (Support for this HTML5 feature has been slow in coming to certain browsers, most
notably Firefox, which didn’t implement it until August 2013.) The attribute meanings should be self-
explanatory; I’ve chosen their values based on my personal judgment, which you should feel free
to override.
To access the slider’s value from your JavaScript code, you need to set its id attribute:
... type="range" id="speedSlider" min="0" ...
Then declare and initialize a global variable with the same name:
var speedSlider = document.getElementById("speedSlider");
Now you can simply replace the line in fireProjectile that sets vx with the following:
vx = Number(speedSlider.value);
(The Number function forces JavaScript to convert the value from a character string to a number
immediately, rather than later when you try to do arithmetic with it. This doesn’t matter here, but I’ve
found that it can sometimes dramatically affect performance so I consider it a good habit. The
reason why the value is a string to begin with is rooted in the conventions used for all input
Once again, be sure to test your code after making these
3. Add a numerical readout for the slider.
Unfortunately, the slider doesn’t automatically come with a numerical readout to show the user its
value. But you add one pretty easily.
Start by adding the following line of code to your HTML, in between the button and the slider:
Initial speed = <span id="speedReadout">3000</span> m/s
The span element is the in-line version
of div; it does nothing inherently to its content, but lets you
change the styling or, in this case, assign an id. To access this element from JavaScript, put it
into a variable as usual:
var speedReadout = document.getElementById("speedReadout");
Next, define a function that sets the content of the readout to the slider’s value whenever it is
function showSpeed() {
speedReadout.innerHTML = speedSlider.value;
Now you can just add calls to this function as attributes inside the slider’s HTML tag:
... value="3000" oninput="showSpeed();" onchange="showSpeed();">
(Why two different attributes? The first, oninput, is supposed to “fire” whenever the user moves
the slider’s thumb, while the second, onchange, is supposed to fire only when the thumb is
released. But there has been some inconsistency among browsers in implementing these features,
so I’m in the habit of using both, just to be safe.)
Just as most web developers frown upon the use of in-line styling via the style attribute, they
also tend to frown upon the use of in-line JavaScript via attributes like onclick and onchange.
Apparently their view is that all JavaScript code should be segregated in its own separate file,
rather than being mixed in with the HTML. That’s actually pretty easy to do, but I frankly don’t see
any advantage to it for the types of applications discussed here.
The User Interface reference sheet at the end of this packet summarizes the syntax not only for
buttons and sliders, but also for other common types of graphical user-interface features such as
checkboxes, drop-down menus, and direct mouse (or touch) events on a canvas. The examples
that accompany this tutorial demonstrate each of these interaction mechanisms.
If you look up user-interface controls in a more general HTML reference site or book, you’ll find
them in the section on forms. That’s because these controls were originally intended for use on
forms that users fill out in order to send information back to web servers. Fortunately, the
technologies are sufficiently powerful that we client-side web programmers have successfully co-
opted them. Just don’t be surprised if the examples that you find elsewhere are cluttered with
extraneous <form> tags and references to “submit” buttons.
Finishing Touches
After finishing the previous section
of this tutorial, you should have a fully functional simulation of
Newton’s Cannon. If it’s good enough for you, you can now put this simulation aside and move on
to another HTML5 project. On the other hand, if you’re a perfectionist like me, you might first want
to refine the Newton’s Cannon simulation in a few ways.
Each of the following refinements can be made independently, so feel free to skip any that don’t
interest you.
The original Newton’s Cannon illustration shows the paths of the projectiles, so perhaps yours
should too.
The best way to add “trails” to this simulation is to draw them on a separate canvas, sandwiched in
between the existing canvas and the underlying image. You can do this with just four additional
lines of code:
1. A line of HTML, in between your existing img and canvas elements, to add the second
canvas. Give it id="trailCanvas", with the same dimensions as the others and
2. A declaration/initialization for a JavaScript variable trailCanvas, otherwise identical to the
one for theCanvas.
3. Similarly, a declaration/initialization for the new graphics context (call it trailContext),
analogous to theContext.
4. Finally, in your drawProjectile function, a line to draw a small dot at the projectile’s
current location. This is easiest if you actually make the dot a rectangle, because there’s a
one-line convenience function for drawing rectangles:
trailContext.fillRect(pixelX-0.5, pixelY-0.5, 1, 1);
The first two parameters are the coordinates of the rectangle’s upper-left corner, so I’ve
subtracted 0.5 to center it precisely; the third and fourth parameters are the rectangle’s width
and height.
The new canvas’s fillStyle defaults to black, but feel free to change this to a different color if
you prefer.
When you test these changes, you should find that the dots are close enough together to form a
continuous curve. (If they weren’t so close, and you still wanted a continuous curve, you could use
the moveTo and lineTo functions to draw lines. This would also require a couple of new global
variables to store the projectile’s previous location, and a bit of code to ensure that you don’t
connect the end of one path to the beginning of the next.)
Notice that the canvas can accumulate an unlimited number of trails, with thousands upon
thousands of individual dots, with absolutely no performance penalty. This is one advantage of
immediate-mode graphics over retained-mode graphics.
Documents you may be interested
Documents you may be interested