c# pdf to image ghostscript : Convert word to fillable pdf form Library control component .net azure asp.net mvc x3dom5-part479

X3DOM Documentation, Release 1.4.0
Returns Properties object
Returns the properties object of the X3D element. This holds all configuration parameters of the X3D element.
2.1.2 Docs
The documentation API is a set of static functions (object literal)which allows to obtain documetantion related infor-
mation formthe library:
var info;
var info_pane;
info = x3dom.docs.getNodeTreeInfo();
info_pane = getElementById(’infopane’);
info_pane.innerHTML = info;
The documentation module is optional and only provided with the x3dom-full package.
getNodeTreeInfo()
Returns A divelement containin the nodes and link to specification
Return a div filled with nodes implemented and link to documentation. This can be used to build interactive
documentation.
Note: Unstable API method. Name and retrun value might change
getComponentInfo()
Returns A div element containin the nodes and link to specification, grouped by components and
sorted alphabetically
Return a div filled with nodes implemented and link to documentation. This particular method returns the the
nodes grouped by components and sorted alphabetically.
This can be used to build interactive documentation.
Note: Unstable API method. Name and retrun value might change
2.2 Nodes
The following list is a live generated node list. You can only see this information in a browser. Ifyou are viewing this
documentation in other formats, please visit theNodeTypeTreedocument and click on a Node to view the related
X3D specification.
Warning: Not all nodes andfully implemented right now.
2.3 Components
X3DOM features a component system which allows you to load parts of the system at runtime. Components are a
set of X3D nodes logically grouped together and put into a file. For example, the Geometry2D component consists
of nodes named Arc2D, Circle2D, etc and is stored in a file named Geometry2D.js. Those components are then
furthergroupedintoprofileswhichcombine themfor specific applicationdomains. For example there is acoreprofile,
an immersive profile, Interchange profile, and so on. Except for the full profile, profiles are an abstract concept and
not reflected in file layout.
2.2. Nodes
47
Convert word to fillable 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 word doc to fillable pdf form; create a fillable pdf form online
Convert word to fillable 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
convert html form to pdf fillable form; create a fillable pdf form from a word document
X3DOM Documentation, Release 1.4.0
While logical grouping like this falls mostly into the category of code organization, it can be utilized to load only the
parts you need for yourapplication. With X3DOM there are two versions of the library in the distribution package:
• the standard full profile file: x3dom-full.js
• the core containing only basic nodes: x3dom.js
Youwillfindthesefiles inreleasedirectoryofX3DOM.Note thatthis iscurrentlythe developmentversionofX3DOM.
http://x3dom.org/download/dev/.
The full profile contains all the nodes of the officialX3Dspecification, as far as they are implemented in X3DOM,
merged into one file.
When using x3dom.js (core) you may need to either include or dynamically load additional nodes you need to
render your model. This can be achieved by including the required node implementations files in your HTML using
the <script> tag, or byinstructing X3DOM to load the components at runtime.
By default X3DOM comes with the following additional nodes:
• Geometry2D
• VolumeRendering
• Geospatial
If you are using x3dom.js and you need to load the nodes above, you can use one of the methods described below.
Note: It is recommended that you use the full X3DOM version (x3dom-full.js) in production environments -
unless there is a very specific reason not to. The full version is compacted, optimized and in almost all cases the
right way of including X3DOM. Should you opt for using the methods described here, you are trading negligible
saving in initial download size for a much slower loading system, additional requests, way more complicated setup
and maintenance, inability to use the browsers cache, problems with firewalls, proxy servers, CORS issues, CDNs,
and not being able to run run locally without a web server.
2.3.1 Static component loading
This technique works by manually including the X3DOM core library plus the components you need for rendering
your model. Yourresulting HTML could look like this.
<script src="x3dom.js"></script>
<script src="Primitives2D.js"></script>
<script src="Other.js"></script>
Benefits ofthis approach:
• static loading (no ajax requests)
• works locally without a web serverinstance
Drawbacks ofthis approach:
• more requests are required
• more files to manage in complex setups (could be somewhat mitigated using something like Sprockets)
This is essentially how we build the full profile library, except that we deliver everything in one optimized file. When
you write your own components,youcan use this method - it also works with the full profile X3DOM file.
When to use this method:
• When youwrite your own components
• During development and testing
48
Chapter 2. Reference
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
advanced .NET control to change ODT, ODS, ODP forms to fillable PDF formats in using RasterEdge.XDoc.Word; How to Use C#.NET Demo Code to Convert ODT to PDF in
pdf add signature field; create a pdf form to fill out and save
C# Create PDF Library SDK to convert PDF from other file formats
Best C#.NET component to create searchable PDF document from Microsoft Office Word, Excel and PowerPoint. Create fillable PDF document with fields.
pdf fill form; create fillable pdf form
X3DOM Documentation, Release 1.4.0
2.3.2 Dynamic component loading
X3DOM features a mechanism to load files at runtime. With this approach it is possible to load anything from
anywhere and inject that code into your application. Be aware of this possible exploit when using the technique
described here.
Warning: In order to allow dynamic loading of components, you need to tell X3DOM to turn off its security
precautions before including the X3DOM library. These precaution prevents the library from executing code that
is known to be insecure. Only use this feature if there is absolutely noother option for you.
In order to disable security measures in X3DOM,put the following statement in your document <head> section and
before the inclusion of X3DOM:
<head>
<script>
X3DOM_SECURITY_OFF true;
</script>
<script src="x3dom.js"></script>
...
</head>
Now, dynamic loading components at runtime is enabled and can be used by putting the following parameters in you
X3D scene.
<x3d>
<param name="component" value="Primitives2D,Other"></param>
<param name="loadpath" value="http://yourserver/path/"></param>
...
</x3d>
If loadpath is not set X3DOM tries to load the component from the documents parent URL.
Keep in mind that the dynamic loading of X3DOM components performs an synchronous Ajax request. As such all
the limitations of Ajax requests apply,plus the library is blocking your browser until it gets a response.
Drawbacks ofthis approach:
• load order is important and has to be maintained by developer
• needs a web server running (ajax)
• blocks the browser during loading of files
• code injection possibility high
• needs much more requests
• ajax request caching not really supported
When to use this method:
• never (unless there’s no otherfeasible way)
2.3.3 Extending X3DOM
In this chapter you will learn how to extend X3DOM with your own nodes which you can load using the methods
outlined above. We recommend to use the static loading approach in combination with the core profile x3dom.js.
This results in the inclusion of x3dom.js and YourComponent.js which will contain your custom code.
To follow this chapter you need at least basic understanding ofthe following concepts, principles, or technologies:
2.3. Components
49
C# PDF Field Edit Library: insert, delete, update pdf form field
A professional PDF form creator supports to create fillable PDF form in C#.NET. An advanced PDF form maker allows users to create editable PDF form in C#.NET.
acrobat fill in pdf forms; convert word document to pdf fillable form
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET Convert OpenOffice Spreadsheet data to PDF. Turn ODT, ODS, ODP forms into fillable PDF formats.
convert pdf to fillable form; convert pdf to fillable pdf form
X3DOM Documentation, Release 1.4.0
• object orientation
• class based object model
• programming ingeneral
• Javascript programming
• the Javascript object model
• XML and HTML5
Object system
In order to register a new node within the X3DOM system, you need to create the equivalent of a class that inherits
properties from a superclass. Javascript itself does not implement a class based object model, it provides aprototype
model.Aprototypebasedobjectmodelcanbeseenasasupersetofatraditionalclassbasedmodel.Withaprototype
based object system, one can implement a more limited class based system. That is exactlywhat X3DOM does.
For each node you want to implement in X3DOM you need to call the function:
x3dom.registerNodeType("YourNodeName""GroupName", definitionObj);
This registers a node within the X3DOM system and provides a hook to the implementation of this class. The first
parameter also is the name of the XML tag you are writing code for. The third parameter to registerNodeType is the
return value of a call to the X3DOM function:
defineClass(superclassObj, constructorObj, implementationObj);
This function is roughly equivalent to creating a class definition in a language with an traditional class based object
system.
Note: The defineClass function resides in the global Javascript namespace whereas the registerNodeType
function is nested within the x3dom namespace. This is intentionally soand not a typo.
Hello World
Let’s say we want to implement a customnode which echos a “Hello World” to the console, we first need to decided
how the XML should look like. In this case, we simply want another XML tag that looks like this:
<x3d>
<scene>
<hello></hello>
<-- this is new
</scene>
</x3d>
Since there is no Hello node in the X3DOM system nothing happens when we run this X3D in the browser. The
<hello> tagis notrecognized and therefore ignored byX3DOM.Inorderto make X3DOM aware of the <hello>
tag we need to registera new node with the systemand provide animplementation for that node. In order to do so we
are using the two function calls described above:
x3dom.registerNodeType(
"Hello",
"Core",
defineClass(x3dom.nodeTypes.X3DNode,
function (ctx) {
x3dom.nodeTypes.Hello.superClass.call(this, ctx);
}, {
nodeChangedfunction() {
50
Chapter 2. Reference
VB.NET Create PDF Library SDK to convert PDF from other file
Best VB.NET component to convert Microsoft Office Word, Excel and Create fillable PDF document with fields in Visual Basic .NET application.
attach image to pdf form; convert word form to fillable pdf
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Create PDF files from both DOC and DOCX formats. Convert multiple pages Word to fillable and editable PDF documents.
create pdf fillable form; change font size in fillable pdf form
X3DOM Documentation, Release 1.4.0
x3dom.debug.logInfo(’Hello World from the e console’);
}
}
)
);
First, the hello node is registeredwithX3DOM,the hellonode belongs tothe core nodes. We then create animplemen-
tation object of the type x3dom.nodeTypes.X3DNode, the superclass. We also define a constructor for our node
in form of a function object that we pass to the defineClass() function (second positional parameter). The last
parameterconsists of an object literal containing function definitions for the node API. In this example we implement
afunction called nodeChanged which will be called by X3DOM anytime there is a change to the node element in
the DOM. It is also called when the node is encountered the first time. This is the place where print a message to the
console using the X3DOM debug facilities.
The nodeChanged function is not the only function you can pass your implementation. For example, there is a
fieldChanged method which is called whenever a attribute in the DOM changes, and you can implement your
own methods here.
More
For more examples of nodes, please refer tothesourcecodeoftheX3DOMnodes. It’s the best way to learn how to
deal with the X3DOM node system.
2.3. Components
51
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Convert multiple pages Word to fillable and editable PDF documents in both .NET WinForms and ASP.NET. Convert both DOC and DOCX formats to PDF files.
create fill pdf form; convert word form to pdf with fillable
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB Convert multiple pages PowerPoint to fillable and editable
convert pdf form fillable; change pdf to fillable form
X3DOM Documentation, Release 1.4.0
52
Chapter 2. Reference
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
C#.NET convert PDF to text, C#.NET convert PDF to images How-to, VB.NET PDF, VB.NET Word, VB.NET Create fillable and editable PDF documents from Excel in Visual
convert pdf to form fillable; convert pdf fill form
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
NET PDF SDK- Create PDF from Word in Visual An excellent .NET control support convert PDF to multiple Create fillable and editable PDF documents from Excel in
convert pdf fillable form to html; convert pdf file to fillable form
CHAPTER
3
Notes & How-Tos
Design notes, legal information and changelog are here for the interested.
3.1 Notes
Different topics of interest. This section should be seen as incubation space for collaboration and ideas. Ultimately
things move up tothe main documentation.
3.1.1 Loading resources from external servers
Sometimes it is desirabletoloadresources,like textures,fromotherlocations than yourweb server. The most common
use case being servingtextures from aCDN. While technically not a problem, there are security mechanisms in place
to prevent injection of malicious code into your application. Browser vendors started to block loading of resources
originating from domains unless these resources marked safe by the foreign web server.
The corresponding W3C specification is called Cross-Origin Resource Sharing [CORS2010] and adhered to by most
browsers. And inessence, you need toconfigure the foreign web serverto add a HTTPheader that marks the resource
safe for your domain. Say, your application is served from http://yoursite.org and needs to load resources
from http://othersite.org, the webserver of othersite.org needs to set a HTTP header that marks
yoursite.org safe forcross site requests. Forexample:
Access-Control-Allow-Origin: http://yoursite.org
If you don’t care and want to allow access to all users, you can add e.g. the following to your httpd.conf (given you
are using Apache2):
<Directory />
Header set Access-Control-Allow-Origin "
*
"
Header set Access-Control-Allow-Headers "Content-Type"
Header set Access-Control-Allow-Methods "GET, PUT, OPTIONS, DELETE, POST"
</Directory>
An alternative to adhering to the CORS protocol, is to setting up a proxy server forwarding requests to the foreign
serverinthe background. Ifyoucandoawaywith thebenefitsCDNprovides this techniquemay be aviablealternative.
More information on CORS and setting HTTP headers:
• Cross-OriginResourceSharing
• Apachemod_headers
• Lighttpdmod_setenv
53
X3DOM Documentation, Release 1.4.0
• NGINXheadersmodule
• Others
More information on proxy configuration:
• Apachemod_proxy
• LighttpdModProxy
• NGINXproxymodule
Developing locally
While the HTTP headers method presented above is the best practice in production environments, it is unpractical
for local development of your application. Fortunately there are a couple of workarounds making you develop with
pleasure.
• Use a real web server (e.g. Apache) to deliver your site locally
• Use a web serverwith proxy module to fetch external resources form a live website
• Use browser flags to disable security measures
The latter one being the most flaky. It is not guaranteed that the browser will support disabling security in the long
run. Also strange behaviourin case of magically enabled security after updates in combination with browser caches.
Using a web server
Installing a web server locally and serving your files under the localhost domain is the best way of developing web
applications. We also recommend you use this technique when developing with X3DOM. Using a full web stack
locally ensures that your browser behaves the same way it would when loading a website over the internet. Requests
are sent and received by the browser just like they would in a production environment. It is also the only way to
properly test Ajax functionality and HTTPfeatures,like expiry headers.
There are various ways toinstall a webserver on your machine. Incase of Mac OS X, Apache is already installed and
you can just put yourdocuments in your Site folder.
OnLinux therearevariouswaystoinstallApachedepending onyourdistribution. Most likelytwo orthreecommands
should suffice.
Windows users are best served with a package calledXAMPP,which also caters various Unix based systems.
Using a web server with proxy pass
What about external resources in local development, I want to develop locally and load textures from
textureheaven.net. Youcould install as system wide proxy server,which processes the request and response to
textureheaven.net and adds the correspoding CORS header to the response. Another straight forward way is
to leverage the power of what you already have: yourlocal web server.
The setup is more elaborate and out ofthe scope of this document. Here are some pointer of howto get started.
First you need to confiture your web server to answer requests to textureheaven.net instead of sending those
requests to the real textureheaven.net web server. To do so you need to make an entry in your /etc/hosts
file so the address does not resolve to the real site but to localhost. Within your web server configuration you
now create a virtual host that answers requests to textureheaven.net and proxies them request to the real
textureheaven.net site. In order to make this all work, you finally need to add a CORS header to the response
(e.g. Access-Control-Allow-Origin:
http://localhost)
54
Chapter 3. Notes & How-Tos
X3DOM Documentation, Release 1.4.0
Sounds too complicated? There’s a shortcut way. But as with all shortcuts, use it withcaution.
Disable browser security
If you have all resources locally,there is a shortcut for circumventing the CORS mechanisms. Please use with care.
Chrome The Chrome browser allows you to disable a security precaution that prevents you loading resources from
disk. Use the following startup parameters:
--allow-file-access-from-files
--allow-file-access
--disable-web-security
Firefox Enter the following in your location bar:
about:config
Acknowledge the secuirty warning and enter the following in the filter bar:
fileuri
Look for the option called security.fileuri.strict_origin_policy and set it to false. +++ Draft +++
3.1.2 Complex models
While X3DOM is very well suited for small models up to a few kilobytes in size, big models can become a major
problem. This section takes a look at the different aspects involved and tries to find partial solutions to the problem.
The problems canbe broken down to the following areas:
• Loading a HTML/X3Dfile containing a lot of data
• Parsing data into the DOM
• Storing data in memory
And server side:
• I/O when sending big files (sendfile)
• Server stalling because user presses “reload” endlessly when not informed that an operation is in progress and
consequently exhausting free server slots.
While most of these problems are inherent to the domain we are moving in, and not X3DOM specific, measures can
be taken tooptimize loading of large chunks of data, especially cutting down transmission time over the network.
Another, more complex problem, is presented by the way JavaScript and DOM work. There is no manual memory
management possible and freeing up memory is left to the garbage collector that runs at intervals out of our control.
We can not even manually start garbage collection. And if we could, there is quite some overhead involved in garbage
collection.
The only alternative to cope with the memory specific problem is circumventing the DOM entirely parsing. While
this somewhat defies the purpose ofX3DOM, itmaypresent a viable alternative forperformance criticalapplications.
Various techniques and ideas are explored further in the following sections.
It is paramount to keep in mind, no matter how much we optimize, the use of complex models is limited by the
following boundaries:
• Memory of client (storing more data)
3.1. Notes
55
X3DOM Documentation, Release 1.4.0
• Processing powerof client machine (parsing more faster)
In the following sections we are presenting various tools and techniques to optimize various aspects of loading big
models.
Delivering deflated content (HTTP/1.1)
The most obvious idea is tocompress the HTML/XML files. Luckily this is the easiest to implement andwill improve
performance of loading time significantly. Most web browsers support the deflate algorithms (ZIP) and can handle
compressed files onthe fly. The web serveris configured tocompress HTML files beforedelivering them to the client.
By means of setting the HTTP (Accpet-Encoding), header, denoting a compressed file arrives, the client can act on
this information and decompress the deflated file on the fly. Any browser that supports the HTTP/1.1 should be able
to handle deflated input.
In order to enable your webserver to compress the files during transport, the configuration needs to be alterd. How to
achieve this can be found in you web server documentation. For exmaple:
• Apache
• NGINX
• Lighttpd
If you are using a different web server, refer to its documentation.
Benefits
It is considered good practice for web development to enable in-memory compression for text resources like HTML,
CSS, JS. Tests showed that file size can be reduced to about 50%. Transmission time should be typically cut in half.
For exmaple, the vary large model of the walking soldier () is about 13MB in size. Using GZIP compression, this
model is only 5.2MB big.
Drawbacks
This method does not present us with any significant drawbacks.
Aslight overhead on server-and client-side processing poweris inherent with on-the-fly compression. Caching tech-
niques ofweb servers and browser mitigate the small performance hit ofon-the-fly compression.
An actual benchmark ofdecompressing the soldier model has not yet been conducted. However the ventured guess is
that the savings of network time outperform the decompression algorithmwhich runs naively.
Forvery large files this technique maynot be beneficial since the servermayblock too long duringcompression or the
client,especially with slow clients, may take to long to decompress. This however needs to be verified and tested.
We recommend to enable compression on your web server and only out out if there are performance hits than can be
attributed to compression.
Makeing use of browser side caching
• Etags
• Expire headers
• HTML5 offline stuff?
• etc.
56
Chapter 3. Notes & How-Tos
Documents you may be interested
Documents you may be interested