itextsharp add annotation to existing pdf c# : Convert excel to pdf with hyperlinks control software system azure html wpf console 1483-part1770

to represent a 
<canvas>
element will have a 
getContext()
method (see “Simple
Shapes” on page 58). If your browser doesn’t support the canvas API, the DOM object
it creates for a 
<canvas>
element will have only the set of common properties, not any-
thing canvas-specific. You can check for canvas support using this function:
function supports_canvas() {
return !!document.createElement('canvas').getContext;
}
This function starts by creating a dummy 
<canvas>
element:
return !!document.createElement('canvas').getContext;
This element is never attached to your page, so no one will ever see it. It’s just floating
in memory, going nowhere and doing nothing, like a canoe on a lazy river.
As soon as you create the dummy 
<canvas>
element, you test for the presence of a
getContext()
method. This method will only exist if your browser supports the canvas
API:
return !!document.createElement('canvas').getContext;
Finally, you use the double-negative trick to force the result to a Boolean value (
true
or 
false
):
return !!document.createElement('canvas').getContext;
This function will detect support for most of the canvas API, including shapes (see
“Simple Shapes” on page 58), paths (see “Paths” on page 61), gradients (see “Gra-
dients” on page 67), and patterns. It will not detect the third-party 
explorercanvas
library (see “What About IE?” on page 73) that implements the canvas API in
Microsoft Internet Explorer.
Instead of writing this function yourself, you can use Modernizr (introduced in the
preceding section) to detect support for the canvas API:
if (Modernizr.canvas) {
// let's draw some shapes!
} else {
// no native canvas support available :(
}
There is a separate test for the canvas text API, which I will demonstrate next.
Canvas Text
Even if your browser supports the canvas API, it might not support the canvas text API.
The canvas API grew over time, and the text functions were added late in the game.
Some browsers shipped with canvas support before the text API was complete.
Checking for canvas text API support again uses detection technique #2 (see “Detection
Techniques” on page 15). If your browser supports the canvas API, the DOM object it
creates to represent a 
<canvas>
element will have the 
getContext()
method (see “Simple
Canvas Text | 17
Download from Library of Wow! eBook <www.wowebook.com>
Convert excel to pdf with hyperlinks - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add links to pdf in acrobat; add page number to pdf hyperlink
Convert excel to pdf with hyperlinks - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
add email link to pdf; add hyperlinks to pdf online
Shapes” on page 58). If your browser doesn’t support the canvas API, the DOM object
it creates for a 
<canvas>
element will have only the set of common properties, not any-
thing canvas-specific. You can check for canvas text support using this function:
function supports_canvas_text() {
if (!supports_canvas()) { return false; }
var dummy_canvas = document.createElement('canvas');
var context = dummy_canvas.getContext('2d');
return typeof context.fillText == 'function';
}
The function starts by checking for canvas support, using the 
supports_canvas()
func-
tion introduced in the previous section:
if (!supports_canvas()) { return false; }
If your browser doesn’t support the canvas API, it certainly won’t support the canvas
text API!
Next, you create a dummy 
<canvas>
element and get its drawing context. This is guar-
anteed to work, because the 
supports_canvas()
function already checked that the
getContext()
method exists on all canvas objects:
var dummy_canvas = document.createElement('canvas');
var context = dummy_canvas.getContext('2d');
Finally, you check whether the drawing context has a 
fillText()
function. If it does,
the canvas text API is available:
return typeof context.fillText == 'function';
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for the canvas text API:
if (Modernizr.canvastext) {
// let's draw some text!
} else {
// no native canvas text support available :(
}
Video
HTML5 defines a new element called 
<video>
for embedding video in your web pages.
Embedding video used to be impossible without third-party plug-ins such as Apple
QuickTime or Adobe Flash.
18 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Embed PDF hyperlinks to HTML links in VB.NET. Available zoom setting (fit page, fit width). .NET component to convert adobe PDF file to html viewer.
convert doc to pdf with hyperlinks; pdf edit hyperlink
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed PDF hyperlinks to HTML links. Our PDF to HTML converter library control is a 100% clean .NET which is designed to help .NET developers convert PDF to HTML
c# read pdf from url; chrome pdf from link
The 
<video>
element is designed to be usable without any detection scripts. You can
specify multiple video files, and browsers that support HTML5 video will choose one
based on what video formats they support.*
Browsers that don’t support HTML5 video will ignore the 
<video>
element completely,
but you can use this to your advantage and tell them to play video through a third-party
plug-in instead. Kroc Camen has designed a solution called Video for Everybody! that
uses HTML5 video where available, but falls back to QuickTime or Flash in older
browsers. This solution uses no JavaScript whatsoever, and it works in virtually every
browser, including mobile browsers.
If you want to do more with video than plop it on your page and play it, you’ll need to
use JavaScript. Checking for video support uses detection technique #2 (see “Detection
Techniques” on page 15). If your browser supports HTML5 video, the DOM object it
creates to represent a 
<video>
element will have a 
canPlayType()
method. If your
browser doesn’t support HTML5 video, the DOM object it creates for a 
<video>
ele-
ment will have only the set of properties common to all elements. You can check for
video support using this function:
function supports_video() {
return !!document.createElement('video').canPlayType;
}
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for HTML5 video:
if (Modernizr.video) {
// let's play some video!
} else {
// no native video support available :(
// maybe check for QuickTime or Flash instead
}
There is a separate test for detecting which video formats your browser can play, which
I will demonstrate next.
Video Formats
Video formats are like written languages. An English newspaper may convey the same
information as a Spanish newspaper, but if you can only read English, only one of them
will be useful to you! To play a video, your browser needs to understand the “language”
in which the video was written.
* See “A gentle introduction to video encoding, part 1: container formats” and “part 2: lossy video codecs” to
learn about different video formats.
Video Formats | 19
Download from Library of Wow! eBook <www.wowebook.com>
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
to svg, C#.NET convert PDF to text, C#.NET convert PDF to images to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET Able to replace all PDF page contents in VB.NET
add links in pdf; clickable links in pdf
VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in
svg, C#.NET convert PDF to text, C#.NET convert PDF to images VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET an easy work and gives quick access to PDF page and
add url to pdf; adding a link to a pdf
The “language” of a video is called a “codec”—this is the algorithm used to encode the
video into a stream of bits. There are dozens of codecs in use all over the world. Which
one should you use? The unfortunate reality of HTML5 video is that browsers can’t
agree on a single codec. However, they seem to have narrowed it down to two. One
codec costs money (because of patent licensing), but it works in Safari and on the
iPhone. (This one also works in Adobe Flash, if you use a solution like Video for
Everybody!.) The other codec is free and works in open source browsers like
Chromium and Mozilla Firefox.
Checking for video format support uses detection technique #3 (see “Detection Tech-
niques” on page 15). If your browser supports HTML5 video, the DOM object it creates
to represent a 
<video>
element will have a 
canPlayType()
method. This method will tell
you whether the browser supports a particular video format.
This function checks for the patent-encumbered format supported by Macs and
iPhones:
function supports_h264_baseline_video() {
if (!supports_video()) { return false; }
var v = document.createElement("video");
return v.canPlayType('video/mp4; codecs="avc1.42E01E, mp4a.40.2"');
}
The  function  starts  by  checking  for  HTML5  video  support,  using  the
supports_video()
function from the previous section:
if (!supports_video()) { return false; }
If your browser doesn’t support HTML5 video, it certainly won’t support any video
formats!
Next, the function creates a dummy 
<video>
element (but doesn’t attach it to the page,
so it won’t be visible) and calls the 
canPlayType()
method. This method is guaranteed
to be there, because the 
supports_video()
function just checked for it:
var v = document.createElement("video");
return v.canPlayType('video/mp4; codecs="avc1.42E01E, mp4a.40.2"');
A “video format” is really a combination of several different things. In technical terms,
you’re asking the browser whether it can play H.264 Baseline video and AAC LC audio
in an MPEG-4 container.
The 
canPlayType()
function doesn’t return 
true
or 
false
. In recognition of how com-
plex video formats are, the function returns a string:
"probably"
If the browser is fairly confident it can play this format
†I’ll explain what all that means in Chapter 5. You might also be interested in reading “A gentle introduction
to video encoding”.
20 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
.NET PDF SDK | Read & Processing PDF files
Able to convert PDF documents into other formats (multipage TIFF, JPEG, etc Include extraction of text, hyperlinks, bookmarks and metadata; Advanced document
pdf link to email; add links to pdf in preview
PDF Image Viewer| What is PDF
with advanced capabilities, such as text extraction, hyperlinks, bookmarks and easy-to-use interface enabling you to quickly convert your PDF images into
pdf link to attached file; adding links to pdf document
"maybe"
If the browser thinks it might be able to play this format
""
(an empty string)
If the browser is certain it can’t play this format
This second function checks for the open video format supported by Mozilla Firefox
and other open source browsers. The process is exactly the same; the only difference
is the string you pass in to the 
canPlayType()
function. In technical terms, you’re asking
the browser whether it can play Theora video and Vorbis audio in an Ogg container:
function supports_ogg_theora_video() {
if (!supports_video()) { return false; }
var v = document.createElement("video");
return v.canPlayType('video/ogg; codecs="theora, vorbis"');
}
Finally, WebM is a newly open-sourced (and non-patent-encumbered) video codec that
will be included in the next version of major browsers, including Chrome, Firefox, and
Opera. You can use the same technique to detect support for open WebM video:
function supports_webm_video() {
if (!supports_video()) { return false; }
var v = document.createElement("video");
return v.canPlayType('video/webm; codecs="vp8, vorbis"');
}
Instead of writing this function yourself, you can use Modernizr to detect support for
several different HTML5 video formats (note that Modernizr does not yet have support
for detecting support for the open WebM video format):
if (Modernizr.video) {
// let's play some video! but what kind?
if (Modernizr.video.ogg) {
// try Ogg Theora + Vorbis in an Ogg container
} else if (Modernizr.video.h264){
// try H.264 video + AAC audio in an MP4 container
}
}
Local Storage
HTML5 Storage provides a way for websites to store information on your computer
and retrieve it later. The concept is similar to cookies, but it’s designed for larger quan-
tities of information. Cookies are limited in size, and your browser sends them back to
the web server every time it requests a new page (which takes extra time and precious
bandwidth). HTML5 Storage stays on your computer, and websites can access it with
JavaScript after the page is loaded.
Local Storage | 21
Download from Library of Wow! eBook <www.wowebook.com>
Ask Professor Markup
Q: Is local storage really part of HTML5? Why is it in a separate specification?
A: The short answer is yes, local storage is part of HTML5. The slightly longer answer
is that local storage used to be part of the main HTML5 specification, but it was split
out into a separate specification because some people in the HTML5 Working Group
complained that HTML5 was too big. If that sounds like slicing a pie into more pieces
to reduce the total number of calories...well, welcome to the wacky world of standards.
Checking for HTML5 Storage support uses detection technique #1 (see “Detection
Techniques” on page 15). If your browser supports HTML5 Storage, there will be a
localStorage
property on the global 
window
object. If your browser doesn’t support
HTML5 Storage, the 
localStorage
property will be undefined. You can check for local
storage support using this function:
function supports_local_storage() {
return ('localStorage' in window) && window['localStorage'] !== null;
}
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for HTML5 local storage:
if (Modernizr.localstorage) {
// window.localStorage is available!
} else {
// no native support for local storage :(
// maybe try Gears or another third-party solution
}
Note that JavaScript is case-sensitive. The Modernizr attribute is called 
localstorage
(all lowercase), but the DOM property is called 
window.localStorage
(mixed case).
Ask Professor Markup
Q: How secure is my HTML5 Storage database? Can anyone read it?
A: Anyone who has physical access to your computer can probably look at (or even
change) your HTML5 Storage database. Within your browser, any website can read
and modify its own values, but sites can’t access values stored by other sites. This is
called a same-origin restriction.
22 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
Web Workers
Web workers provide a standard way for browsers to run JavaScript in the background.
With web workers, you can spawn multiple “threads” that all run at the same time,
more or less. (Think of how your computer can run multiple applications at the same
time, and you’re most of the way there.) These “background threads” can do complex
mathematical calculations, make network requests, or access local storage while the
main web page responds to the user scrolling, clicking, or typing.
Checking for web workers uses detection technique #1 (see “Detection Techni-
ques” on page 15). If your browser supports the Web Worker API, there will be a
Worker
property on the global 
window
object. If your browser doesn’t support the Web
Worker API, the 
Worker
property will be undefined. This function checks for web
worker support:
function supports_web_workers() {
return !!window.Worker;
}
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for web workers:
if (Modernizr.webworkers) {
// window.Worker is available!
} else {
// no native support for web workers :(
// maybe try Gears or another third-party solution
}
Note that JavaScript is case-sensitive. The Modernizr attribute is called 
webworkers
(all
lowercase), but the DOM object is called 
window.Worker
(with a capital “W” in
“Worker”).
Offline Web Applications
Reading static web pages offline is easy: connect to the Internet, load a web page,
disconnect from the Internet, drive to a secluded cabin, and read the web page at your
leisure. (To save time, you may wish to skip the step about the cabin.) But what about
using web applications like Gmail or Google Docs when you’re offline? Thanks to
HTML5, anyone (not just Google!) can build a web application that works offline.
Offline web applications start out as online web applications. The first time you visit
an offline-enabled website, the web server tells your browser which files it needs in
order to work offline. These files can be anything—HTML, JavaScript, images, even
videos (see “Video” on page 18). Once your browser downloads all the necessary files,
you can revisit the website even if you’re not connected to the Internet. Your browser
will notice that you’re offline and use the files it has already downloaded. When you
get back online, any changes you’ve made can be uploaded to the remote web server.
Offline Web Applications | 23
Download from Library of Wow! eBook <www.wowebook.com>
Checking for offline support uses detection technique #1 (see “Detection Techni-
ques” on page 15). If your browser supports offline web applications, there will be an
applicationCache
property on the global 
window
object. If your browser doesn’t support
offline web applications, the 
applicationCache
property will be undefined. You can
check for offline support with the following function:
function supports_offline() {
return !!window.applicationCache;
}
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for offline web applications:
if (Modernizr.applicationcache) {
// window.applicationCache is available!
} else {
// no native support for offline :(
// maybe try Gears or another third-party solution
}
Note that JavaScript is case-sensitive. The Modernizr attribute is called 
applicationc
ache
(all lowercase), but the DOM object is called 
window.applicationCache
(mixed
case).
Geolocation
Geolocation is the art of figuring out where you are in the world and (optionally) sharing
that information with people you trust. There are many ways to figure out where you
are—your IP address, your wireless network connection, which cell tower your phone
is talking to, or dedicated GPS hardware that receives latitude and longitude informa-
tion from satellites in the sky.
Ask Professor Markup
Q: Is geolocation part of HTML5? Why are you talking about it?
A: Geolocation support is being added to browsers right now, along with support for
new HTML5 features. Strictly speaking, geolocation is being standardized by the Geo
location Working Group, which is separate from the HTML5 Working Group. But I’m
going to talk about geolocation in this book anyway, because it’s part of the evolution
of the Web that’s happening now.
Checking for geolocation support uses detection technique #1 (see “Detection Tech-
niques” on page 15). If your browser supports the geolocation API, there will be a
geolocation
property on the global 
navigator
object. If your browser doesn’t support
the geolocation API, the 
geolocation
property will be undefined. Here’s how to check
for geolocation support:
24 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
function supports_geolocation() {
return !!navigator.geolocation;
}
Instead of writing this function yourself, you can use Modernizr (see “Modernizr: An
HTML5 Detection Library” on page 16) to detect support for the geolocation API:
if (Modernizr.geolocation) {
// let's find out where you are!
} else {
// no native geolocation support available :(
// maybe try Gears or another third-party solution
}
If your browser does not support the geolocation API natively, there is still hope.
Gears is an open source browser plug-in from Google that works on Windows, Mac,
Linux, Windows Mobile, and Android. It provides a number of features for older
browsers that do not support all the fancy new stuff we’ve discussed in this chapter.
One of the features that Gears provides is a geolocation API. It’s not the same as the
navigator.geolocation
API, but it serves the same purpose.
There are also device-specific geolocation APIs on several mobile phone platforms,
including BlackBerryNokia, Palm, and OMTP BONDI.
Chapter 6 will go into excruciating detail about how to use all of these different APIs.
Input Types
You know all about web forms, right? Make a 
<form>
, add a few 
<input type="text">
elements and maybe an 
<input type="password">
, and finish it off with an 
<input
type="submit">
button.
You don’t know the half of it. HTML5 defines over a dozen new input types that you
can use in your forms:
<input type="search">
See http://bit.ly/9mQt5C for search boxes
<input type="number">
See http://bit.ly/aPZHjD for spinboxes
<input type="range">
See http://bit.ly/dmLiRr for sliders
<input type="color">
See http://bit.ly/bwRcMO for color pickers
<input type="tel">
See http://bit.ly/amkWLq for telephone numbers
<input type="url">
See http://bit.ly/cjKb3a for web addresses
Input Types | 25
Download from Library of Wow! eBook <www.wowebook.com>
<input type="email">
See http://bit.ly/aaDrgS for email addresses
<input type="date">
See http://bit.ly/c8hL58 for calendar date pickers
<input type="month">
See http://bit.ly/cDgHRI for months
<input type="week">
See http://bit.ly/bR3r58 for weeks
<input type="time">
See http://bit.ly/bfMCMn for timestamps
<input type="datetime">
See http://bit.ly/c46zVW for precise, absolute date/timestamps
<input type="datetime-local">
See http://bit.ly/aziNkE for local dates and times
Checking for HTML5 input types uses detection technique #4 (see “Detection Tech-
niques” on page 15). First, you create a dummy 
<input>
element in memory:
var i = document.createElement("input");
The default input type for all 
<input>
elements is 
"text"
. This will prove to be vitally
important.
Next, set the 
type
attribute on the dummy 
<input>
element to the input type you want
to detect:
i.setAttribute("type", "color");
If your browser supports that particular input type, the 
type
property will retain the
value you set. If your browser doesn’t support that particular input type, it will ignore
the value you set and the 
type
property will still be 
"text"
:
return i.type !== "text";
Instead of writing 13 separate functions yourself, you can use Modernizr (see “Mod-
ernizr: An HTML5 Detection Library” on page 16) to detect support for all the new
input types defined in HTML5. Modernizr reuses a single 
<input>
element to efficiently
detect support for all 13 input types. Then it builds a hash called 
Modernizr.input
types
, which contains 13 keys (the HTML5 
type
attributes) and 13 Boolean values
(
true
if supported, 
false
if not):
if (!Modernizr.inputtypes.date) {
// no native support for <input type="date"> :(
// maybe build one yourself with
// Dojo 
// or jQueryUI
}
26 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
Documents you may be interested
Documents you may be interested