c# ghostscript pdf to image : Convert pdf into fillable form application Library tool html asp.net .net online TutorialPacket2-part1081

It’s also a nice touch to add a button to clear the trails and start over. Add a line of HTML code for
this new button, analogous to that for the “Fire!” button. Set the onclick attribute to call a new
function called clearTrails, and have this function call trailContext.clearRect in a way
analogous to the first line of your drawProjectile function.
3-D shading
Newton’s illustrator used shading to give the planet a three-dimensional appearance. You can do
the same for your projectile by filling it with a radial gradient instead of a solid color. In your
drawProjectile function, just replace the line that sets fillStyle with the following four
var theGradient = theContext.createRadialGradient(
pixelX-1, pixelY-2, 1, pixelX, pixelY, 5);
theGradient.addColorStop(0, "#ffd0d0");
theGradient.addColorStop(1, "#ff0000");
theContext.fillStyle = theGradient;
The parameters of the createRadialGradient function define two circles, in terms of their
center locations and radii (here 1 and 5, respectively). The addColorStop functions then specify
the colors on (and beyond) these circles, and the gradient automatically interpolates between them.
Try changing the gradient metrics and colors until you’re happy with the appearance.
Bigger buttons
Choosing optimum sizes for things is tricky in a web app, because you don’t know the user’s
screen size. There are several reasons, though, why you might want to make buttons bigger than
their default sizes. A quick-and-dirty way to enlarge them is to specify a larger font via the CSS
font-size property. But I’ve found that styling buttons is tricky, producing inconsistent results in
different browsers.
A robust, but cumbersome, alternative is to avoid buttons entirely and instead just use links. The
HTML code for your Fire! button would then be:
<a class="customButton" href="javascript:void(0)" 
onclick="fireProjectile();" ontouchstart="">Fire!</a>
Try this out and check that the “button” still works. I don’t actually understand the reason for
javascript:void(0), but seemingly knowledgable people recommend
it. The empty
ontouchstart attribute is a detail that improves the behavior on mobile devices.
The class attribute is a convenient way of applying the same styling to multiple elements. To
make it work, you define the class inside a style element in the head portion of your source file.
After much fiddling, I’ve settled on the following styling for my custom buttons:
.customButton {  /* style a link as a push-button */
display: inline-block; 
width: 60px; 
height: 24px; 
line-height: 24px; 
font-size: 15px; 
Convert pdf into fillable 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
create fill in pdf forms; converting a word document to pdf fillable form
Convert pdf into fillable 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
convert pdf fill form; pdf fillable form creator
font-family: sans-serif; 
text-align: center;
color: black; 
background: -webkit-linear-gradient(white,#eeeeee,#eeeeee,#e0e0e0);
background: linear-gradient(white,#eeeeee,#eeeeee,#e0e0e0);
text-decoration: none; 
border: 1px solid gray; 
border-radius: 5px;
-webkit-user-select: none;
-moz-user-select: -moz-none;
-ms-user-select: none;
user-select: none;
cursor: pointer;
-webkit-tap-highlight-color: rgba(0,0,0,0);
.customButton:active {
background: -webkit-linear-gradient(#909090,#808080,#808080,#707070);
background: linear-gradient(#909090,#808080,#808080,#707070);
Yes, it’s cumbersome, and I don’t claim that it’s perfect. I hope you can guess what most of these
CSS properties do. The gradients use various gray levels to give the buttons a nice 3-D
appearance. (You can, of course, use brighter colors if you don’t think they’ll be too distracting.)
Some of the property names are nonstandard, specific to particular browsers or groups of
browsers (Webkit, Mozilla, and Microsoft). The dot before customButton indicates that we’re
defining a class, and the curly braces enclose all the property settings that belong to that class.
The active pseudo-class changes the button’s color while it is being pressed.
Styling the slider
Slider controls look a little different in each different browser—with the exception of Internet
Explorer, in which they look a lot different. In IE the default width is much larger, and the default
“padding”, or extra space, above and below the slider is absurdly large. IE also puts ugly tick
marks along the slider’s track, and puts a pop-up numerical readout, rounded to the nearest
integer, above the slider while you’re adjusting it.
Here’s the styling that I use to fix all these issues (formatted for use inside the style element in
your page’s head):
input[type="range"] {
width: 140px;
padding: 0px;
input[type="range"]::-ms-tooltip {
display: none;       /* hide readout in IE */
input[type="range"]::-ms-track {
color: transparent;  /* hide tick marks in IE */
Even with these changes, sliders will look very different in IE than in other browsers. But the
remaining differences are primarily a matter of taste, and there’s something to be said for keeping
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
public override void ConvertToDocument(DocumentType targetType, Stream stream). Description: Convert to PDF/TIFF and save it into stream. Parameters:
converting a word document to a fillable pdf form; pdf fillable forms
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Turn all Excel spreadsheet into high quality PDF without Create searchable and scanned PDF files from Excel. Convert to PDF with embedded fonts or without
convert word to fillable pdf form; pdf add signature field
the appearance consistent within each browser.
Fixed-width speed readout
You may have noticed that if you reduce the launch speed below 1000 m/s, all the GUI controls
shift as they are re-centered to accommodate the loss of a digit in the speed readout. If you find
this behavior annoying, you can easily fix it with a bit of styling:
<span id="speedReadout" style="display:inline-block; 
width:2.3em; text-align:right;">
Specifying the width in em units (each equal to the font size in pixels) is more robust than using
pixel units if you later decide to change the font size. But this fix is still a bit of a kludge, because I
determined the optimum width by trial and error and the number is somewhat font-dependent.
If you now view the page on a smartphone, however, you’ll see that the readout looks funny
because the number is in a smaller font than the text around it. That’s because smartphones
automatically enlarge font sizes for readability when a “block” (such as a paragraph or a div) is
wider than a certain amount (typically 320 pixels). Giving the readout a fixed width required making
it its own block, so now it doesn’t get enlarged. The best fix, at least for the most common mobile
browsers, is probably to turn off the automatic enlargement by inserting
into the style of the enclosing div.
Special characters
As a final tweak to the appearance of the line of GUI controls, you can insert a little extra space to
separate logically distinct elements. One way to do this is by adjusting the left and right margins,
but a slightly easier method is to insert two or three “non-breaking space” characters,
into the HTML just after the Fire! button (and two or three more just before the Clear button, if
you’ve implemented that).
Another nice aesthetic touch is to change the straight typewriter-style apostrophe in Newton's to a
pretty typographer’s apostrophe (or right single quote):
You can use similar syntax in your HTML to insert a wide variety of special characters, inluding
math symbols, Greek letters, and accented letters. Each code begins with an ampersand and ends
with a semicolon, with a unique few-letter sequence in between. Several of the most useful are
listed on the accompanying HTML 
and styling reference sheet
, which also provides a link to a
complete list.
More tweaks for mobile
On touch screen devices, touching an element on a web page can sometimes make the browser
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
for turning all PowerPoint presentation into high quality PDF Convert to PDF with embedded fonts or without Convert multiple pages PowerPoint to fillable and
convert pdf to form fillable; auto fill pdf form from excel
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
NET control able to turn all Word text and image content into high quality PDF without losing formatting. Convert multiple pages Word to fillable and editable
convert html form to pdf fillable form; convert word doc to fillable pdf form
think you want to select it for copying. That makes sense for text, but not for most GUI controls.
I’ve found this behavior particularly annoying for sliders, so I generally put the following CSS into
the <style> element in my document’s header:
input {
-webkit-user-select: none;
-moz-user-select: -moz-none;
-ms-user-select: none;
user-select: none;
Another issue with mobile devices is that they need to know or assume a value for the full width of
your web page in pixels—and on iOS (at least), this number defaults to an annoyingly large value
of 980. (I try to keep the content of my pages considerably narrower, so they won’t monopolize my
laptop screen or exceed the width of an 800-pixel projector.) Fortunately, you can change this
default by putting another meta tag into your page’s header:
<meta name="viewport" content="width=640">
As long as users are holding their devices in portrait orientation, the optimum setting for the content
width is just a little more than the width of your page’s body (or widest block). The down-side is that
this makes your page harder to use in landscape orientation, because users probably won’t be
able to zoom out far enough to see all the important parts at once. Try it, in any case, and decide
what setting best suits your layout and the uses you have in mind.
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Turn all PowerPoint presentation into high quality PDF Convert to PDF with embedded fonts or without Convert multiple pages PowerPoint to fillable and editable
convert word document to pdf fillable form; form pdf fillable
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
all Word text and image content into high quality PDF Create PDF files from both DOC and DOCX formats. Convert multiple pages Word to fillable and editable PDF
create a fillable pdf form; convert pdf to fillable pdf form
Next Steps
I hope that after finishing
the Newton’s Cannon simulation you are now eager to go on and create
your own web simulations. Of course, every simulation is different, and will present its own
challenges. Here, though, is some general advice on how to proceed.
Review the reference materials.
Spend some time looking over all of the reference materials that accompany this tutorial
. In these
materials I’ve tried to concisely summarize most of the HTML, CSS, and JavaScript features that
I’ve used in creating physics simulations for the web. If you invest some time to learn what’s in
these materials, then you’ll know where to quickly look up most of the vocabulary and syntax you
Look at all the sample pages.
To complement the dry austerity of the reference sheets, a variety of sample pages also
accompany this tutorial
. Please try each of these, and then use your browser’s View Source
command to see how they work.
You may also wish to look at some more elaborate examples of HTML5 physics simulations. Here
is a list
of links to example simulations, by myself and others, whose source code you should
mostly be able to read after completing this tutorial.
Modify the sample pages.
I also recommend downloading each of the sample pages to your own computer, so you can use
them to tinker and explore. Here are just a few ideas:
Modify the Canvas Graphics and GUI
sample page to add more color choices, a slider to
control the opacity, and/or one or more additional shapes. If you’re feeling ambitious, modify
it so you can draw a shape by clicking on (or touching) the canvas instead of pressing the
Modify the Simple Paint
sample page by adding a slider to set the brush size and a drop-
down menu to select the color. You could even try adding more sophisticated features such
as different brush shapes and airbrush effects.
Modify the Spaceship
sample page to put the spaceship’s speed and direction under the
user’s control.
Modify the Star Motion
sample page to draw star trails as in a long-exposure photo.
Choose a project that interests you.
Enough of my ideas! Now that you’ve explored and practiced for a while, I hope you’re ready to
create a web simulation of your own design. Now would be a good time to think over your ideas
and choose one that seems reasonably straightforward to code. Think about what you want the
simulation to accomplish, and how you can implement the needed features using the tools you’ve
learned in this tutorial. Sketch what you want the simulation to look like on the screen, and jot down
whatever other thoughts you have about the details.
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Turn all Excel spreadsheet into high quality PDF without Create searchable and scanned PDF files from Excel in VB Convert to PDF with embedded fonts or without
pdf fill form; pdf create fillable form
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
Convert OpenOffice Spreadsheet data to PDF. Export PDF document from OpenOffice Presentation. Turn ODT, ODS, ODP forms into fillable PDF formats.
convert word form to pdf with fillable; convert pdf fillable form
The rest of this document discusses a few miscellaneous issues that you may need to consider as
you develop your own simulations in HTML5 and JavaScript.
Think carefully about interface design.
While it’s natural for a physicist to focus on the underlying calculations that a simulation performs,
your audience will learn more (and will grow to include more users) if you also make your best
effort to design a good user interface. Doing so often requires quite a bit of creativity and hard
Here are some of the questions you should ask yourself as you design a user interface:
Which type of GUI control (e.g., checkbox, radio buttons, slider) is the most appropriate and
the most intuitive for each simulation setting or action?
How wide a parameter space do you want your users to explore? Will they be able to find the
parameters you have in mind without having to read lengthy instructions? Or are you being
so restrictive that there is no room for creative exploration?
Who are the intended users of your simulation? Students who need to use it to complete an
assignment, or members of the general public who are merely curious or want to be
entertained? Will your intended users have the patience to read whatever instructions are
needed to successfully use the simulation?
What is the best visual design for your simulation? Should the graphics be realistic or
abstract? How can you make the layout, fonts, and colors aesthetically pleasing without
distracting from the content? Should all of the controls be visible at all times, or should some
of them be initially hidden?
Is your interface equally usable on both traditional computers and mobile devices? How wide
a range of devices can you feasibly support?
While there is no universal recipe for a good user interface, I still rely heavily on three principles
emphasized in the original (1985) edition of Inside Macintosh
, the programmer’s manual for the first
mass-market computer with a graphical user interface. Those principles are responsiveness,
permissiveness, and consistency.
Responsiveness means that user inputs have immediate, rather than delayed, effects. Try to
provide some instant visual feedback whenever the user checks a box or drags a slider. Don’t
make the user choose multiple settings before the simulation even starts.
Permissiveness means that your simulation should allow the user to take any reasonable action at
any time. Try not to disable controls while the simulation runs. You want the user to feel in control
of the software—not the other way around.
Consistency means using input mechanisms that are similar to what users already understand
from using other software. Use push-buttons, checkboxes, and menus in standard ways, and give
them standard appearances. If you must invent an unusual input mechanism, try to make it mimic
some real-world action such as pointing or pulling. Don’t force users to read lengthy instructions
just to figure out how to control your simulation.
Inevitably, there will be times when you need to violate all of these principles. Just be sure to
violate them thoughtfully, not accidentally.
C# Create PDF Library SDK to convert PDF from other file formats
Create fillable PDF document with fields. with 2 blank pages PDFDocument doc = PDFDocument.Create(2); // Save the new created PDF document into file doc
create fill pdf form; asp.net fill pdf form
VB.NET Create PDF Library SDK to convert PDF from other file
Best VB.NET component to convert Microsoft Office Word cake, as it can be easily integrated into many MS Visual Studio .NET applications to create PDF with just
convert word to pdf fillable form online; convert an existing form into a fillable pdf form
Consider performance limits.
For some types of simulations, computational speed is critical. Examples would include many-body
simulations of 100 or more particles, solving partial differential equations, and anything that needs
to quickly generate intricate, detailed images.
The good news is that in most modern browsers, JavaScript runs only a little slower than native
code. That’s because modern browsers employ just-in-time compilation, rather than interpreting
your source code anew during every iteration of a loop. On today’s personal computers, this
means you can perform about a billion elementary computations per second. That’s about 40
million computations per animation frame, at an aesthetically pleasing frame rate.
Of course, some users may be running your simulation on mobile devices that are slower than
your personal computer by an order of magnitude or more. For this reason it may be a good idea to
let the user adjust whatever parameter determines the required computational horsepower—such
as the number of particles or the resolution of a grid.
One quirk of JavaScript is that it provides no true multi-dimensional arrays. You can always create
an array of arrays, but I’ve found that this can impair performance. Instead I recommend using
large one-dimensional arrays and indexing into them manually: index = x + xSize*y. I’ve also
found that it helps to initialize such an array sequentially, nesting the x loop inside the y loop rather
than the other way around.
In general, JavaScript just-in-time compilers tend to be temperamental, because they must be able
to adapt to bizarre actions l
ike suddenly changing the type of a var
iable from an integer to a string
(or to something even more complex). To optimize performance your code must behave
predictably, rather than taking advantage of all of JavaScript’s permissiveness.
To generate intricate images, you may need to manipulate the pixel data directly via the
createImageData and putImageData functions. The Two-Source 
sample page
demonstrates this method.
Learn about libraries.
If you want to do something complicated for which JavaScript doesn’t provide a built-in solution,
you may be able to build on the work of other programmers by using one of the many freely
available JavaScript code libraries. Using a library can save you a lot of work, and you’ll often end
up with better results. On the other hand, each library comes with its own learning curve, and using
one often means sacrificing some flexibility and performance.
Personally, I try to use libraries only when they’ll help me do something that I’m convinced I
otherwise wouldn’t be able to do at all (given my limited time and background). This means that I
avoid using libraries when they would merely make a task slightly easier: experience has taught
me that more often than not, the time spent figuring out how to use the library outweighs the time
saved coding with it. Of course, your needs and priorities may be different from mine. But my
general aversion to libraries means that I know very little about most of them, so I’m not well
qualified to make recommendations. Here, in any case, is an inevitably incomplete list of libraries
that, from what I’ve heard, might be useful (or even essential) for certain types of physics
is a general-purpose library for manipulating the elements of web pages and
circumventing many incompatibilities between browsers. It’s very widely used by
professionals, and many other libraries depend on it. One of these is jQuery UI
, a library of
user-interface widgets. A companion library called jQuery Mobile
is also compatible with
touch-screen devices.
is one of many libraries for plotting two-dimensional charts, built on top of jQuery. It can
produce some slick-looking plots with little effort, but it lacks some features you might need
for scientific plotting.
is a suite of libraries for retained-mode graphics, animation, and sound. It seems
to be aimed at developers who are already familiar with Flash.
is a sophisticated retained-mode graphics library built on top of canvas. Super
Planet Crash
uses this library.
is a retained-mode 3-D graphics library that is similar in many ways to Visual
. It can be used as a library in your own projects, but it also comes with its own web-
based editing and hosting environment that frees you from having to provide HTML
boilerplate. Unfortunately it is not yet compatible with most mobile devices.
Easy Java/JavaScript Simulations
is not a stand-alone library but rather a front-end
development tool that simplifies the process of creating many types of physics simulations.
The latest version can output JavaScript (in addition to Java) code.
Numeric Javascript
is a library for linear algebra and other numerical tasks.
is a library for mathematical typesetting in HTML pages. It can translate LaTeX
code into high-quality typeset equations.
To use a JavaScript library, your page imports it just like any other external script, via a (separate)
script element with a src attribute and no content:
<script src="myLibrary.js"></script>
You can either host a copy of the library on your own server, or provide (in the src attribute) the
URL of a copy that is hosted on a so-called content distribution network (CDN). Follow any of the
links above for specific instructions on obtaining and using that library.
Choose a web hosting service.
Once your web application is complete, how do you share it with the world?
Ideally, your school or institution provides a server to which you can upload web pages of your
own creation via FTP or the equivalent. But not everyone is so fortunate. More and more schools
are now using content management systems for all their web-based course materials, and these
systems won’t always play nice with your page design and JavaScript code. Or you may be in a
situation where you have no institution-provided web hosting at all.
The best solution in these cases is probably to just pay for your own web hosting service. I can't
recommend a particular vendor, but there are many choices and it shouldn’t cost more than a few
dollars per month. You’re looking for “shared” hosting (the inexpensive kind, for sites that won’t get
huge amounts of traffic), and you should be sure that the service includes FTP access so you can
directly upload your finished web pages.
There are also free hosting services out there in the Cloud, but they all seem to involve
compromises. For a web simulation that uses no images or other external files, a good option is
, a site intended for sharing code among web programmers. This site requires that you
license your code for unlimited reuse, with attribution (like the examples in this tutorial). You can
also try more generic free hosting services such as Weebly
or Google Sites
, but these typically
give you less control over the appearance of your pages, or force you to treat stand-alone pages
as attachments (to be downloaded and saved by users, rather than immediately displayed in
Join the Physics HTML5 Google Group.
I’ve set up a Google Group for physicists and physics teachers to discuss web programming in
HTML5 and JavaScript. You can view the group discussions at:
To join the group (so you can post your own messages), go to this URL and click “Apply to join
group”. (You need to have a Google account.) My hope is that, over time, this forum will remedy
many of the deficiencies of the tutorial you have just completed.
<h1>Top-level heading</h1>
<br>  (forced line break)
<ul> <!--bulleted list-->
<li>Another item</li>
<li>Yet another item</li>
HTML and Styling Reference
HTML template
<!DOCTYPE html>
<meta charset="utf-8">
<title>Your title goes here.</title>
Your content goes here.
Text structure
<b>Bold text</b>
<i>Italic text</i>
 &lt;     >  &gt;     &  &amp;     °  &deg;     •  &bull;     Δ  &Delta;     π  &pi; 
“  &ldquo;     ”  &rdquo;     ‘  &lsquo;     ’  &rsquo;     —  &mdash;     −  &minus;   
(More at http://www.webstandards.org/learn/reference/charts/entities/
HTML comment
<!-- This comment won't affect the page display. -->
<a href="http://site.com/path/file.html">Link text goes here</a>
<img src="imagefile.png" width="200" height="100">
<ol> <!--numbered list-->
<li>First item</li>
<li>Second item</li>
<li>Third item</li>
Generic elements s <div>Generic block element</div>
<span>Generic in-line element</span>
Fonts and colors <h1 style="font-size:24px; color:red;">
<body style="font-family:sans-serif; background-color:#d0d0d0;">
Centered text
<h1 style="text-align:center;">Centered Heading</h1>
Floating block
<div style="width:200px; float:right; margin:0 0 10px 10px;">
Floating content (often an image) goes here.
(Note the 10-pixel bottom and left margins.)
<p>This paragraph will wrap around the floating block.</p>
Centered layout
<div style="width:600px; margin-left:auto; margin-right:auto;">
This 600-pixel-wide block will be centered in the window.
<div style="width:610px;">
<div style="width:400px; float:left; margin-right:10px;">
Left column content
<div style="width:200px; float:left;">
Right column content
Documents you may be interested
Documents you may be interested