itextsharp add annotation to existing pdf c# : Add url link to pdf application software cloud html windows azure class 1482-part1767

On March 2, 1993, Tim Berners-Lee commented:
HTTP2 allows a document to contain any type which the user has said he can handle,
not just registered MIME types. So one can experiment. Yes I think there is a case for
postscript with hypertext. I don’t know whether display postscript has enough. I know
Adobe are trying to establish their own postscript-based “PDF” which will have links,
and be readable by their proprietary brand of viewers.
I thought that a generic overlaying language for anchors (HyTime based?) would allow
the hypertext and the graphics/video standards to evolve separately, which would help
both.
Let the 
IMG
tag be 
INCLUDE
and let it refer to an arbitrary document type. Or 
EMBED
if
INCLUDE
sounds like a cpp include which people will expect to provide SGML source code
to be parsed inline—not what was intended.
HyTime was an early, SGML-based hypertext document system. It loomed large in
many early discussions of HTML, and later XML.
Tim’s proposal for an 
<INCLUDE>
tag was never implemented, although you can see
echoes of it in 
<object>
<embed>
, and the 
<iframe>
element.
Finally, on March 12, 1993, Marc Andreessen revisited the thread:
Back to the inlined image thread again—I’m getting close to releasing Mosaic v0.10,
which will support inlined GIF and XBM images/bitmaps, as mentioned previously. [...]
We’re not prepared to support 
INCLUDE
/
EMBED
at this point. [...] So we’re probably going
to go with 
<IMG SRC="url">
(not 
ICON
, since not all inlined images can be meaningfully
called icons). For the time being, inlined images won’t be explicitly content-type’d; down
the road, we plan to support that (along with the general adaptation of MIME). Actually,
the image reading routines we’re currently using figure out the image format on the fly,
so the filename extension won’t even be significant.
An Unbroken Line
I am extraordinarily fascinated with all aspects of this almost 17-year-old conversation
that led to the creation of an HTML element that has been used on virtually every web
page ever published. Consider this:
• HTTP still exists. It successfully evolved from 0.9 into 1.0 and later 1.1, and still
it evolves.
• HTML still exists. That rudimentary data format (it didn’t even support inline
images!) successfully evolved into 2.0, 3.2, and 4.0. HTML is an unbroken line. A
twisted, knotted, snarled line, to be sure—there were plenty of “dead branches”
in the evolutionary tree, places where standards-minded people got ahead of them-
selves (and ahead of authors and implementors)—but still, here we are in 2010,
and web pages from 1990 still render in modern browsers. I just loaded one up in
the browser of my state-of-the-art Android mobile phone, and I didn’t even get
prompted to “please wait while importing legacy format...”
An Unbroken Line | 7
Download from Library of Wow! eBook <www.wowebook.com>
Add url link to pdf - 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 preview; add links to pdf online
Add url link to pdf - 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 a link to a pdf in preview; clickable links in pdf files
• HTML has always been a conversation between browser makers, authors, stand-
ards wonks, and other people who just showed up and liked to talk about angle
brackets. Most of the successful versions of HTML have been “retro-specs,” catch-
ing up to the world while simultaneously trying to nudge it in the right direction.
Anyone who tells you that HTML should be kept “pure” (presumably by ignoring
browser makers, or ignoring authors, or both) is simply misinformed. HTML has
never been pure, and all attempts to purify it have been spectacular failures,
matched only by the attempts to replace it.
• None of the browsers in use in 1993 still exist in any recognizable form. Netscape
Navigator was abandoned in 1998 and rewritten from scratch to create the Mozilla
Suite, which was then forked to create Firefox. Internet Explorer had its humble
“beginnings” in “Microsoft Plus! for Windows 95,” where it was bundled with
some desktop themes and a pinball game; but of course, that browser can be traced
back further too.
• Some of the operating systems from 1993 still exist, but none of them are relevant
to the modern Web. Most people today who “experience” the Web do so on a PC
running Windows 2000 or later, a Mac running Mac OS X, a PC running some
flavor of Linux, or a handheld device like an iPhone. In 1993, Windows was at
Version 3.1 (and competing with OS/2), Macs were running System 7, and Linux
was distributed via Usenet. (Want to have some fun? Find a graybeard and whisper
“Trumpet Winsock” or “MacPPP.”)
• Some of the same people are still around and still involved in what we now simply
call “web standards.” That’s after almost 20 years. And some were involved in
predecessors of HTML, going back into the 1980s and before.
• Speaking of predecessors.... With the eventual popularity of HTML and the Web,
it is easy to forget the contemporary formats and systems that informed their de-
sign. Before you read this chapter, had you ever heard of Andrew? Intermedia?
HyTime? And HyTime was not some rinky-dink academic research project; it was
an ISO standard approved for military use. It was Big Business. And you can read
about it yourself at http://www.sgmlsource.com/history/hthist.htm.
But none of this answers the original question: why do we have an 
<img>
element? Why
not an 
<icon>
element? Or an 
<include>
element? Why not a hyperlink with an
include
attribute, or some combination of 
rel
values? Why an 
<img>
element? Quite
simply, because Marc Andreessen shipped one, and shipping code wins.
That’s not to say that all shipping code wins; after all, Andrew and Intermedia and
HyTime shipped code too. Code is necessary but not sufficient for success. And I cer-
tainly don’t mean to say that shipping code before a standard will produce the best
solution. Marc’s 
<img>
element didn’t mandate a common graphics format; it didn’t
define how text flowed around it; it didn’t support text alternatives or fallback content
for older browsers. And 17 years later, we’re still struggling with content sniffing, and
it’s still a source of crazy security vulnerabilities. You can trace that through the Great
8 | Chapter 1: How Did We Get Here?
Download from Library of Wow! eBook <www.wowebook.com>
C# PDF Library SDK to view, edit, convert, process PDF file for C#
editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update
adding a link to a pdf; add links to pdf acrobat
C#: How to Add HTML5 Document Viewer Control to Your Web Page
type="text/css"/> <link rel="stylesheet _viewerTopToolbar.addTab(_tabRedact); //add Tab "Sample customStyle({ background: "url('RasterEdge_Resource_Files/images
adding an email link to a pdf; pdf link to specific page
Browser Wars, all the way back to February 25, 1993, when Marc Andreessen off-
handedly remarked, “MIME, someday, maybe,” and then shipped his code anyway.
A Timeline of HTML Development from 1997 to 2004
In December 1997, the World Wide Web Consortium (W3C) published HTML 4.0
and promptly shut down the HTML Working Group. Less than two months later, a
separate W3C Working Group published XML 1.0. A mere three months after that,
the W3C held a workshop called “Shaping the Future of HTML” to answer the ques-
tion, “Has W3C given up on HTML?” This was the answer:
In discussions, it was agreed that further extending HTML 4.0 would be difficult, as
would converting 4.0 to be an XML application. The proposed way to break free of these
restrictions is to make a fresh start with the next generation of HTML based upon a suite
of XML tag-sets.
The W3C rechartered the HTML Working Group to create this “suite of XML tag-
sets.” The members’ first step, in December 1998, was to draft an interim specification
that simply reformulated HTML in XML without adding any new elements or attrib-
utes. This specification later became known as “XHTML 1.0”. It defined a new MIME
type for XHTML documents, 
application/xhtml+xml
. However, to ease the migration
of existing HTML 4 pages, it also included Appendix C, which “summarizes design
guidelines for authors who wish their XHTML documents to render on existing HTML
user agents.” Appendix C said you were allowed to author so-called “XHTML” pages
but still serve them with the 
text/html
MIME type.
The next target was web forms. In August 1999, the same HTML Working Group
published a first draft of XHTML Extended Forms. Its members set the expectations
in the very first sentences of this draft document:
After careful consideration, the HTML Working Group has decided that the goals for
the next generation of forms are incompatible with preserving backward compatibility
with browsers designed for earlier versions of HTML. It is our objective to provide a clean
new forms model (“XHTML Extended Forms”) based on a set of well-defined require-
ments. The requirements described in this document are based on experience with a very
broad spectrum of form applications.
A few months later, “XHTML Extended Forms” was renamed “XForms” and moved
to its own Working Group. That group worked in parallel with the HTML Working
Group and finally published the first edition of XForms 1.0 in October 2003.
Meanwhile, with the transition to XML complete, the members of the HTML Working
Group set their sights on creating “the next generation of HTML.” In May 2001, they
published the first edition of XHTML 1.1, which added only a few minor features on
top of XHTML 1.0 but eliminated the “Appendix C” loophole. Starting with
Version 1.1, all XHTML documents were to be served with a MIME type of
application/xhtml+xml
.
A Timeline of HTML Development from 1997 to 2004 | 9
Download from Library of Wow! eBook <www.wowebook.com>
VB.NET Image: VB Code to Download and Save Image from Web URL
to download image from website link more easily from image downloading from web URL, RasterEdge .NET powerful & profession imaging controls, PDF document, image
pdf link to attached file; pdf hyperlink
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program of PDF document, including editing PDF url links and quick navigation link in bookmark
change link in pdf; adding hyperlinks to pdf files
Everything You Know About XHTML Is Wrong
Why are MIME types important? Why do I keep coming back to them? Three words:
draconian error handling. Browsers have always been “forgiving” with HTML. If you
create an HTML page but forget to give it a 
<title>
, browsers will display the page
anyway, even though the 
<title>
element has always been required in every version of
HTML. Certain tags are not allowed within other tags, but if you create a page that
puts them inside anyway, browsers will just deal with it (somehow) and move on with-
out displaying an error message.
As you might expect, the fact that “broken” HTML markup still worked in web brows-
ers led authors to create broken HTML pages. A lot of broken pages. By some estimates,
over 99 percent of HTML pages on the Web today have at least one error in them. But
because these errors don’t cause browsers to display visible error messages, nobody
ever fixes them.
The W3C saw this as a fundamental problem with the Web, and set out to correct it.
XML, published in 1997, broke from the tradition of forgiving clients and mandated
that all programs that consumed XML must treat so-called “well-formedness” errors
as fatal. This concept of failing on the first error became known as “draconian error
handling,” after the Greek leader Draco, who instituted the death penalty for relatively
minor infractions of his laws. When the W3C reformulated HTML as an XML vo-
cabulary, the people in charge mandated that all documents served with the new
application/xhtml+xml
MIME type would be subject to draconian error handling. If
there was even a single error in your XHTML page, web browsers would have no choice
but to stop processing and display an error message to the end user.
This idea was not universally popular. With an estimated error rate of 99 percent on
existing pages, the ever-present possibility of displaying errors to the end user, and the
dearth of new features in XHTML 1.0 and 1.1 to justify the cost, web authors basically
ignored 
application/xhtml+xml
. But that doesn’t mean they ignored XHTML alto-
gether. Oh, most definitely not. Appendix C of the XHTML 1.0 specification gave the
web authors of the world a loophole: “Use something that looks kind of like XHTML
syntax, but keep serving it with the 
text/html
MIME type.” And that’s exactly what
thousands of web developers did: they “upgraded” to XHTML syntax but kept serving
it with a 
text/html
MIME type.
Even today, while many web pages claim to be XHTML—they start with the XHTML
doctype on the first line, use lowercase tag names, use quotes around attribute values,
and add a trailing slash after empty elements like 
<br />
and 
<hr />
—only a tiny fraction
of these pages are served with the 
application/xhtml+xml
MIME type that would trigger
XML’s draconian error handling. Any page served with a MIME type of 
text/html
,
regardless of its doctype, syntax, or coding style, will be parsed using a “forgiving”
HTML parser, silently ignoring any markup errors and never alerting end users (or
anyone else), even if the page is technically broken.
10 | Chapter 1: How Did We Get Here?
Download from Library of Wow! eBook <www.wowebook.com>
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET of PDF document, including editing PDF url links and quick navigation link in bookmark
pdf email link; add hyperlink pdf
C# PDF insert image Library: insert images into PDF in C#.net, ASP
C#.NET PDF SDK - Add Image to PDF Page in C#.NET. How to Insert & Add Image, Picture or Logo on PDF Page Using C#.NET. Add Image to PDF Page Using C#.NET.
adding a link to a pdf in preview; pdf link open in new window
XHTML 1.0 included this loophole, but XHTML 1.1 closed it, and the never-finalized
XHTML 2.0 continued the tradition of requiring draconian error handling. And that’s
why there are billions of pages that claim to be XHTML 1.0, and only a handful that
claim to be XHTML 1.1 (or XHTML 2.0). So, are you really using XHTML? Check
your MIME type. (Actually, if you don’t know what MIME type you’re using, I can
pretty much guarantee that you’re still using 
text/html
.) Unless you’re serving your
pages with a MIME type of 
application/xhtml+xml
, your so-called “XHTML” is XML
in name only.
A Competing Vision
In June 2004, the W3C held the Workshop on Web Applications and Compound
Documents. Present at this workshop were representatives of several browser vendors,
web development companies, and other W3C members. A group of interested parties,
including the Mozilla Foundation and Opera Software, gave a presentation on their
competing visions of the future of the Web: an evolution of the existing HTML 4 stand
ard to include new features for modern web application developers:
The following seven principles represent what we believe to be the most critical require-
ments for this work:
Backward compatibility, clear migration path
Web application technologies should be based on technologies authors are familiar
with, including HTML, CSS, DOM, and JavaScript.
Basic Web application features should be implementable using behaviors, scripting,
and style sheets in IE6 today so that authors have a clear migration path. Any sol-
ution that cannot be used with the current high-market-share user agent without
the need for binary plug-ins is highly unlikely to be successful.
Well-defined error handling
Error handling in Web applications must be defined to a level of detail where User
Agents (UAs) do not have to invent their own error handling mechanisms or reverse
engineer other User Agents’.
Users should not be exposed to authoring errors
Specifications must specify exact error recovery behaviour for each possible error
scenario. Error handling should for the most part be defined in terms of graceful
error recovery (as in CSS), rather than obvious and catastrophic failure (as in XML).
Practical use
Every feature that goes into the Web Applications specifications must be justified
by a practical use case. The reverse is not necessarily true: every use case does not
necessarily warrant a new feature.
Use cases should preferably be based on real sites where the authors previously used
a poor solution to work around the limitation.
Scripting is here to stay
But should be avoided where more convenient declarative markup can be used.
Scripting should be device and presentation neutral unless scoped in a device-
specific way (e.g., unless included in XBL).
A Competing Vision | 11
Download from Library of Wow! eBook <www.wowebook.com>
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark: Edit Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note.
add url link to pdf; adding links to pdf in preview
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note
add page number to pdf hyperlink; add url pdf
Device-specific profiling should be avoided
Authors should be able to depend on the same features being implemented in desk-
top and mobile versions of the same UA.
Open process
The Web has benefited from being developed in an open environment. Web
Applications will be core to the Web, and its development should also take place in
the open. Mailing lists, archives and draft specifications should continuously be
visible to the public.
In a straw poll, the workshop participants were asked, “Should the W3C develop de-
clarative extensions to HTML and CSS and imperative extensions to DOM, to address
medium level Web Application requirements, as opposed to sophisticated, fully-
fledged OS-level APIs?” The vote was 11 to 8 against. In their summary of the work
shop, the W3C’s members wrote, “At present, W3C does not intend to put any re-
sources into the third straw-poll topic: extensions to HTML and CSS for Web Appli-
cations, other than technologies being developed under the charter of current W3C
Working Groups.”
Faced with this decision, the people who had proposed evolving HTML and HTML
forms had only two choices: give up, or continue their work outside of the W3C. They
chose the latter, registered the whatwg.org domain, and in June 2004, the WHAT
Working Group was born.
What Working Group?
What the heck is the WHAT Working Group? I’ll let it explain for itself:
The Web Hypertext Applications Technology Working Group is a loose, unofficial, and
open collaboration of Web browser manufacturers and interested parties. The group
aims to develop specifications based on HTML and related technologies to ease the de-
ployment of interoperable Web Applications, with the intention of submitting the results
to a standards organisation. This submission would then form the basis of work on for-
mally extending HTML in the standards track.
The creation of this forum follows from several months of work by private e-mail on
specifications for such technologies. The main focus up to this point has been extending
HTML4 Forms to support features requested by authors, without breaking backward
compatibility with existing content. This group was created to ensure that future devel-
opment of these specifications will be completely open, through a publicly-archived,
open mailing list.
The key phrase here is “without breaking backward compatibility.” XHTML (minus
the Appendix C loophole) is not backward compatible with HTML. It requires an
entirely new MIME type, and it mandates draconian error handling for all content
served with that MIME type. XForms is not backward compatible with HTML forms,
because it can only be used in documents that are served with the new XHTML MIME
type, which means that XForms also mandates draconian error handling. All roads lead
to MIME.
12 | Chapter 1: How Did We Get Here?
Download from Library of Wow! eBook <www.wowebook.com>
Instead of scrapping over a decade’s worth of investment in HTML and making 99
percent of existing web pages unusable, the WHAT Working Group decided to take a
different approach: documenting the “forgiving” error handling algorithms that brows-
ers actually used. Web browsers have always been forgiving of HTML errors, but no-
body had ever bothered to write down exactly how they did it. NCSA Mosaic had its
own algorithms for dealing with broken pages, and Netscape tried to match them. Then
Internet Explorer tried to match Netscape. Then Opera and Firefox tried to match
Internet Explorer. Then Safari tried to match Firefox. And so on, right up to the present
day. Along the way, developers burned thousands and thousands of hours trying to
make their products compatible with those of their competitors.
If that sounds like an insane amount of work, that’s because it is. Or rather, it was. It
took several years, but (modulo a few obscure edge cases) the WHAT Working Group
successfully documented how to parse HTML in a way that is compatible with existing
web content. Nowhere in the final algorithm is there a step that mandates that the
HTML consumer should stop processing and display an error message to the end user.
While all that reverse-engineering was going on, the WHAT Working Group was qui-
etly working on a few other things, too. One of them was a specification, initially dub-
bed Web Forms 2.0, that added new types of controls to HTML forms. (You’ll learn
more about web forms in Chapter 9.) Another was a draft specification called “Web
Applications 1.0” that included major new features, like a direct-mode drawing canvas
(see Chapter 4) and native support for audio and video without plug-ins (see Chapter 5).
Back to the W3C
For several years, the W3C and the WHAT Working Group largely ignored each other.
While the WHAT Working Group focused on web forms and new HTML features, the
W3C HTML Working Group was busy with Version 2.0 of XHTML. But by October
2006, it was clear that the WHAT Working Group had picked up serious momentum,
while XHTML 2 was still languishing in draft form, unimplemented by any major
browser. In October 2006, Tim Berners-Lee, the founder of the W3C itself, announced
that the W3C would work together with the WHAT Working Group to evolve HTML:
Some things are clearer with hindsight of several years. It is necessary to evolve HTML
incrementally. The attempt to get the world to switch to XML, including quotes around
attribute values and slashes in empty tags and namespaces all at once didn’t work. The
large HTML-generating public did not move, largely because the browsers didn’t com-
plain. Some large communities did shift and are enjoying the fruits of well-formed sys-
tems, but not all. It is important to maintain HTML incrementally, as well as continuing
a transition to a well-formed world, and developing more power in that world.
The plan is to charter a completely new HTML group. Unlike the previous one, this one
will be chartered to do incremental improvements to HTML, and also in parallel
XHTML. It will have a different chair and staff contact. It will work on HTML and
XHTML together. We have strong support for this group, from many people we have
talked to, including browser makers.
Back to the W3C | 13
Download from Library of Wow! eBook <www.wowebook.com>
There will also be work on forms. This is a complex area, as existing HTML forms and
XForms are both form languages. HTML forms are ubiquitously deployed, and there are
many implementations and users of XForms. Meanwhile, the Webforms submission has
suggested sensible extensions to HTML forms. The plan is, informed by Webforms, to
extend HTML forms.
One of the first things the newly rechartered W3C HTML Working Group decided was
to rename “Web Applications 1.0” to “HTML5.” And here we are, diving into HTML5.
Postscript
In October 2009, the W3C shut down the XHTML 2 Working Group and issued this
statement to explain the decision:
When W3C announced the HTML and XHTML 2 Working Groups in March 2007, we
indicated that we would continue to monitor the market for XHTML 2. W3C recognizes
the importance of a clear signal to the community about the future of HTML.
While we recognize the value of the XHTML 2 Working Group’s contributions over the
years, after discussion with the participants, W3C management has decided to allow the
Working Group’s charter to expire at the end of 2009 and not to renew it.
The ones that win are the ones that ship.
Further Reading
• “The History of the Web”, an old draft by Ian Hickson
• “HTML/History”, by Michael Smith, Henri Sivonen, and others
• “A Brief History of HTML”, by Scott Reynen
14 | Chapter 1: How Did We Get Here?
Download from Library of Wow! eBook <www.wowebook.com>
CHAPTER 2
Detecting HTML5 Features
Diving In
You may well ask, “How can I start using HTML5 if older browsers don’t support it?”
But the question itself is misleading. HTML5 is not one big thing; it is a collection of
individual features. So, you can’t detect “HTML5 support,” because that doesn’t make
any sense. But you can detect support for individual features, like canvas, video, or
geolocation.
Detection Techniques
When your browser renders a web page, it constructs a Document Object Model
(DOM), a collection of objects that represent the HTML elements on the page. Every
element—every 
<p>
, every 
<div>
, every 
<span>
—is represented in the DOM by a dif-
ferent object. (There are also global objects, like 
window
and 
document
, that aren’t tied
to specific elements.)
All DOM objects share a set of common properties, but some objects have more than
others. In browsers that support HTML5 features, certain objects will have unique
properties. A quick peek at the DOM will tell you which features are supported.
There are four basic techniques for detecting whether a browser supports a particular
feature. From simplest to most complex:
1.Check if a certain property exists on a global object (such as 
window
or 
navigator
).
For  an  example  of  testing  for  geolocation  support,  see “Geolocation”
on page 24.
2.Create an element, then check if a certain property exists on that element.
For an example of testing for canvas support, see “Canvas” on page 16.
3.Create an element, check if a certain method exists on that element, then call the
method and check the value it returns.
15
Download from Library of Wow! eBook <www.wowebook.com>
Download from Library of Wow! eBook 
<www.wowebook.com>
For an example of testing which video formats are supported, see “Video For-
mats” on page 19.
4.Create an element, set a property to a certain value, then check if the property has
retained its value.
For an example of testing which 
<input>
types are supported, see “Input
Types” on page 25.
Modernizr: An HTML5 Detection Library
Modernizr is an open source, MIT-licensed JavaScript library that detects support for
many HTML5 and CSS3 features. At the time of writing, the latest version is 1.1. You
should always use the latest version. To do so, include the following 
<script>
element
at the top of your page:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Dive into HTML5</title>
<script src="modernizr.min.js"></script> 
</head>
<body>
...
</body>
</html>
Modernizr runs automatically. There is no 
modernizr_init()
function to call. When it
runs, it creates a global object called 
Modernizr
that contains a set of Boolean properties
for each feature it can detect. For example, if your browser supports the canvas API
(see Chapter 4), the 
Modernizr.canvas
property will be 
true
. If your browser does not
support the canvas API, the 
Modernizr.canvas
property will be 
false
:
if (Modernizr.canvas) {
// let's draw some shapes!
} else {
// no native canvas support available :(
}
Canvas
HTML5 defines the 
<canvas>
element as “a resolution-dependent bitmap canvas which
can be used for rendering graphs, game graphics, or other visual images on the fly.” A
canvas is a rectangle in your page within which you can use JavaScript to draw anything
you want. HTML5 defines a set of functions (“the canvas API”) for drawing shapes,
defining paths, creating gradients, and applying transformations.
Checking for canvas API support uses detection technique #2 (see “Detection Tech-
niques” on page 15). If your browser supports the canvas API, the DOM object it creates
16 | Chapter 2: Detecting HTML5 Features
Download from Library of Wow! eBook <www.wowebook.com>
Documents you may be interested
Documents you may be interested