Create a Customized HTML5 Audio Player. Into practise and create a customised HTML5 audio player. I'll miss out the design stage as it's. Up of the HTML5 doctype.
- @Readie - thank you, I've just come back to this problem. And this gives a good framework to start from.
- $21.25 i like my Coffee Black #00000 - HTML Color Code -Gift Women's Fitted T-Shirt $19.90 Front End MVD Classic T-Shirt $29.50 How to tell the difference between HTML and HTML5.
HTML
Online product Designer Tool built in HTML5. The T-Shirt Design tool is one of our. I gotta tell ya I am pretty disappointed with all of the T-shirt design tools on the market. With the exception of. I think online t-shirt designing tool is one of the best way to increase the sales and as well. I'm looking for a JavaScript/HTML5 based solution for a t-shirt design tool, similar to this one: I'm looking for preferably an open.
5 SECOND EDITIONBRUCE LAWSON REMY SHARP
Introducing HTML5, Second Edition Bruce Lawson and Remy Sharp New Riders 1249 Eighth Street Berkeley, CA 94710 510/524-2178 510/524-2221 (fax) Find us on the Web at: www.newriders.com To report errors, please send a note to [email protected] New Riders is an imprint of Peachpit, a division of Pearson Education Copyright © 2012 by Remy Sharp and Bruce Lawson Project Editor: Michael J. Nolan Development Editor: Margaret S. Anderson/Stellarvisions Technical Editors: Patrick H. Lauke (www.splintered.co.uk), Robert Nyman (www.robertnyman.com) Production Editor: Cory Borman Copyeditor: Gretchen Dykstra Proofreader: Jan Seymour Indexer: Joy Dean Lee Compositor: Danielle Foster Cover Designer: Aren Howell Straiger Cover photo: Patrick H. Lauke (splintered.co.uk) Notice of Rights All rights reserved. No part of this book may be reproduced or transmitted in any form by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the publisher. For information on getting permission for reprints and excerpts, contact [email protected] peachpit.com. Notice of Liability The information in this book is distributed on an “As Is” basis without warranty. While every precaution has been taken in the preparation of the book, neither the authors nor Peachpit shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the instructions contained in this book or by the computer software and hardware products described in it. Trademarks Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and Peachpit was aware of a trademark claim, the designations appear as requested by the owner of the trademark. All other product names and services identified throughout this book are used in editorial fashion only and for the benefit of such companies with no intention of infringement of the trademark. No such use, or the use of any trade name, is intended to convey endorsement or other affiliation with this book. ISBN 13: 978-0-321-78442-1 ISBN 10: 0-321-78442-1 987654321 Printed and bound in the United States of America
ACKNOWLEDGEMENTS Huge thanks to coauthor-turned-friend Remy Sharp, and friendturned-ruthless-tech-editor Patrick Lauke: il miglior fabbro. At New Riders, Michael Nolan, Margaret Anderson, Gretchen Dykstra, and Jan Seymour deserve medals for their hard work and their patience. Thanks to the Opera Developer Relations Team, particularly the editor of dev.opera.com, Chris Mills, for allowing me to reuse some materials I wrote for him, Daniel Davis for his description of , Shwetank Dixit for checking some drafts, and David Storey for being so knowledgeable about Web Standards and generously sharing that knowledge. Big shout to former team member Henny Swan for her support and lemon cake. Elsewhere in Opera, the specification team of James Graham, Lachlan Hunt, Philip Jägenstedt, Anne van Kesteren, and Simon Pieters checked chapters and answered 45,763 daft questions with good humour. Nothing in this book is the opinion of Opera Software ASA. Ian Hickson has also answered many a question, and my fellow HTML5 doctors (www.html5doctor.com) have provided much insight and support. Many thanks to Richard Ishida for explaining to me and allowing me to reproduce his explanation. Also to Aharon Lanin. Smoochies to Robin Berjon and the Mozilla Developer Center who allowed me to quote them. Thanks to Gez Lemon and mighty Steve Faulkner for advice on WAI-ARIA. Thanks to Denis Boudreau, Adrian Higginbotham, Pratik Patel, Gregory J. Rosmaita, and Léonie Watson for screen reader advice. Thanks to Stuart Langridge for drinkage, immoral support, and suggesting the working title “HTML5 Utopia.” Mr. Last Week’s creative vituperation provided loadsalaffs. Thanks, whoever you are. Thanks to John Allsopp, Tantek Çelik, Christian Heilmann, John Foliot, Jeremy Keith, Matt May, and Eric Meyer for conversations about the future of markup. Silvia Pfeiffer’s blog posts on multimedia were invaluable to my understanding.
iv
ements
Stu Robson braved IE6 to take the screenshot in Chapter 1, Terence Eden took the BlackBerry screenshots in Chapter 3, Julia Gosling took the photo of Remy’s magic HTML5 moustache in Chapter 4, and Jake Smith provided valuable feedback on early drafts of my chapters. Lastly, but most importantly, thanks to the thousands of students, conference attendees, and Twitter followers for their questions and feedback. This book is in memory of my grandmothers, Marjorie Whitehead, 8 March 1917–28 April 2010, and Elsie Lawson 6 June 1920–20 August 2010. This book is dedicated to Nongyaw, Marina, and James, without whom life would be monochrome. —Bruce Lawson
Über thanks to Bruce who invited me to coauthor this book and without whom I would have spent the early part of 2010 complaining about the weather instead of writing this book. On that note, I’d also like to thank Chris Mills for even recommending me to Bruce. To Robert Nyman, my technical editor: when I was in need of someone to challenge my JavaScript, I knew there would always be a Swede at hand. Thank you for making sure my code was as sound as it could be. Equally to Patrick Lauke, who also whipped some of my code, and certainly parts of my English, into shape. Thanks to the local Brighton cafés, [email protected] and Café Délice, for letting me spend so many hours writing this book and drinking your coffee. To my local Brighton digital community and new friends who have managed to keep me both sane and insane over the last few years of working alone. Thank you to Danny Hope, Josh Russell, and Anna Debenham for being my extended colleagues. Thank you to Jeremy Keith for letting me rant and rail over HTML5 and bounce ideas, and for encouraging me to publish my thoughts. Equal thanks to Jessica for letting us talk tech over beers!
ements
v
To the HTML5 Doctors and Rich Clark in particular for inviting me to contribute—and also to the team for publishing such great material. To the whole #jquery-ot channel for their help when I needed to debug, or voice my frustration over a problem, and for being someplace I could go rather than having to turn to my cats for JavaScript support. To the #whatwg channel for their help when I had misinterpreted the specification and needed to be put back on the right path. In particular to Anne Van Kesteren, who seemed to always have the answers I was looking for, perhaps hidden under some secret rock I’m yet to discover. To all the conference organisers that invited me to speak, to the conference goers that came to hear me ramble, to my Twitter followers that have helped answer my questions and helped spur me on to completing this book with Bruce: thank you. I’ve tried my best with the book, and if there’s anything incorrect or out of date: blame Bruce buy the next edition. ;-) To my wife, Julie: thank you for supporting me for all these many years. You’re more than I ever deserved and without you, I honestly would not be the man I am today. Finally, this book is dedicated to Tia. My girl. I wrote the majority of my part of this book whilst you were on our way to us. I always imagined that you’d see this book and be proud and equally embarrassed. That won’t happen now, and even though you’re gone, you’ll always be with us and never forgotten. —Remy Sharp
CONTENTS
ix
1
The
2
Using new HTML5 structural elements
10
When to use the new HTML5 structural elements
13
What’s the point?
20
Summary
21
CHAP TE R 3
6
Styling HTML5 with CSS
23
Structuring main content areas
24
Adding blog posts and comments
30
Working with HTML5 outlines
31
Understanding WAI-ARIA
49
Even more new structures!
53
Redefined elements
65
Global attributes
70
Removed attributes
75
Features not covered in this book
77
Summary
78
Forms We
HTML, and now it
79 s us back
80
New input types
80
New attributes
87
<progress>, <meter> elements
94
Putting all this together
95
Backwards compatibility with legacy browsers
99
Styling new form fields and error messages
100
Overriding browser defaults
102
Using JavaScript for DIY validation
104
ntents
CHA P T E R 4
CHA P T E R 5
CHA P T E R 6
CHA P T E R 7
vii
Avoiding validation
105
Summary
108
Video and Audio
109
Native multimedia: why, what, and how?
110
Codecs—the horror, the horror
117
Rolling custom controls
123
Multimedia accessibility
136
Synchronising media tracks
139
Summary
142
Canvas
143
Canvas basics
146
Drawing paths
150
Using transformers: pixels in disguise
153
Capturing images
155
Pushing pixels
159
Animating your canvas paintings
163
Summary
168
Data Storage
169
Storage options
170
Web Storage
172
Web SQL Database
184
IndexedDB
195
Summary
205
Offline
207
Pulling the plug: going offline
208
The cache manifest
209
Network and fallback in detail
212
How to serve the manifest
214
The browser-server process
214
applicationCache
217
Debugging tips
219
Using the manifest to detect connectivity
221
Killing the cache
222
Summary
223
viii
ntents
CHAP TE R 9
CHAPT E R 1 0
CHAPT E R 1 1
CHAPT E R 1 2
225
Getting into drag
226
Interoperability of dragged data
230
How to drag any element
232
Adding custom drag icons
233
Accessibility
234
Summary
236
Geolocation
237
Sticking a pin in your user
238
API methods
240
Summary
248
Messaging and Workers
249
Chit chat with the Messaging API
250
Threading using Web Workers
252
Summary
264
Real Time
265
WebSockets: working with streaming data
266
Server-Sent Events
270
Summary
274
Polyfilling: Patching Old Browsers to Support HTML5 Today
275
Introducing polyfills
276
Feature detection
277
Detecting properties
278
The undetectables
281
Where to find polyfills
281
A working example with Modernizr
282
Summary
284
And finally...
285
Index
286
INTRODUCTION Welcome to the second edition of the Remy & Bruce show. Since the first edition of this book came out in July 2010, much has changed: support for HTML5 is much more widespread; Internet Explorer 9 finally came out; Google Chrome announced it would drop support for H.264 video; Opera experimented with video streaming from the user’s webcam via the browser, and HTML5 fever became HTML5 hysteria with any new technique or technology being called HTML5 by clients, bosses, and journalists. All these changes, and more, are discussed in this shiny second edition. There is a brand new Chapter 12 dealing with the realities of implementing all the new technologies for old browsers. And we’ve corrected a few bugs, tweaked some typos, rewritten some particularly opaque prose, and added at least one joke. We’re two developers who have been playing with HTML5 since Christmas 2008—experimenting, participating in the mailing list, and generally trying to help shape the language as well as learn it. Because we’re developers, we’re interested in building things. That’s why this book concentrates on the problems that HTML5 can solve, rather than on an academic investigation of the language. It’s worth noting, too, that although Bruce works for Opera Software, which began the proof of concept that eventually led to HTML5, he’s not part of the specification team there; his interest is as an author using the language for an accessible, easy-to-author, interoperable Web.
Who’s this book for? No knowledge of HTML5 is assumed, but we do expect that you’re an experienced (X)HTML author, familiar with the concepts of semantic markup. It doesn’t matter whether you’re more familiar with HTML or XHTML DOCTYPEs, but you should be happy coding any kind of strict markup. While you don’t need to be a JavaScript ninja, you should have an understanding of the increasingly important role it plays in modern web development, and terms like DOM and API won’t make you drop this book in terror and run away.
x
n
Still here? Good.
What this book isn’t This is not a reference book. We don’t go through each element or API in a linear fashion, discussing each fully and then moving on. The specification does that job in mind-numbing, tear-jerking, but absolutely essential detail. What the specification doesn’t try to do is teach you how to use each element or API or how they work with one another, which is where this book comes in. We’ll build up examples, discussing new topics as we go, and return to them later when there are new things to note. You’ll also realise, from the title and the fact that you’re comfortably holding this book without requiring a forklift, that this book is not comprehensive. Explaining a 700-page specification (by comparison, the first HTML spec was three pages long) in a medium-sized book would require Tardis-like technology (which would be cool) or microscopic fonts (which wouldn’t).
What do we mean by HTML5? This might sound like a silly question, but there is an increasing tendency amongst standards pundits to lump all exciting new web technologies into a box labeled HTML5. So, for example, we’ve seen SVG (Scalable Vector Graphics) referred to as “one of the HTML5 family of technologies,” even though it’s an independent W3C graphics spec that’s ten years old. Further confusion arises from the fact that the official W3C spec is something like an amoeba: Bits split off and become their own specifications, such as Web Sockets or Web Storage (albeit from the same Working Group, with the same editors). So what we mean in this book is “HTML5 and related specifications that came from the WHATWG” (more about this exciting acronym soon). We’re also bringing a “plus one” to the party— Geolocation—which has nothing to do with our definition of HTML5, but which we’ve included for the simple reason that it’s really cool, we’re excited about it, and it’s part of NEWT: the New Exciting Web Technologies.
n
xi
Who? What? When? Why? A short history of HTML5 History sections in computer books usually annoy us. You don’t need to know about ARPANET or the history of HTTP to understand how to write a new language. Nevertheless, it’s useful to understand how HTML5 came about, because it will help you understand why some aspects of HTML5 are as they are, and hopefully preempt (or at least soothe) some of those “WTF? Why did they design it like that?” moments.
How HTML5 nearly never was In 1998, the W3C decided that they would not continue to evolve HTML. The future, they believed (and so did your authors) was XML. So they froze HTML at version 4.01 and released a specification called XHTML 1.0, which was an XML version of HTML that required XML syntax rules such as quoting attributes, closing some tags while self-closing others, and the like. Two flavours were developed (well, actually three, if you care about HTML Frames, but we hope you don’t because they’re gone from HTML5). XHTML Transitional was designed to help people move to the gold standard of XHTML Strict. This was all tickety-boo—it encouraged a generation of developers (or at least the professional-standard developers) to think about valid, well-structured code. However, work then began on a specification called XHTML 2.0, which was a revolutionary change to the language, in the sense that it broke backwardscompatibility in the cause of becoming much more logical and better-designed. A small group at Opera, however, was not convinced that XML was the future for all web authors. Those individuals began extracurricular work on a proof-of-concept specification that extended HTML forms without breaking backward-compatibility. That spec eventually became Web Forms 2.0, and was subsequently folded into the HTML5 spec. They were quickly joined by individuals from Mozilla and this group, led by Ian “Hixie” Hickson of Opera, continued working on the specification privately with Apple “cheering from the sidelines” in a small group that called itself the WHATWG (Web Hypertext Application Technology Working Group, www.whatwg.org). You can see
xii
n
this genesis still in the copyright notice on the WHATWG version of the spec “© Copyright 2004–2011 Apple Computer, Inc., Mozilla Foundation, and Opera Software ASA (note that you are licensed to use, reproduce, and create derivative works).” Hickson moved to Google, where he continued to work full-time as editor of HTML5 (then called Web Applications 1.0). In 2006 the W3C decided that they had perhaps been overly optimistic in expecting the world to move to XML (and, by extension, XHTML 2.0): “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,” said Tim Berners-Lee. The resurrected HTML Working Group voted to use the WHATWG’s Web Applications spec as the basis for the new version of HTML, and thus began a curious process whereby the same spec was developed simultaneously by the W3C (co-chaired by Sam Ruby of IBM and Chris Wilson of Microsoft, and later by Ruby, Paul Cotton of Microsoft, and Maciej Stachowiak of Apple), and the WHATWG, under the continued editorship of Hickson.
In search of the spec Because the HTML5 specification is being developed by both the W3C and WHATWG, there are different versions of it. Think of the WHATWG versions as being an incubator group. The official W3C snapshot is www.w3.org/TR/html5/, while http://dev.w3.org/html5/spec/ is the latest editor’s draft and liable to change. The WHATWG has dropped version numbers, so the “5” has gone; it’s just “HTML‚—the living standard.” Find this at http://whatwg.org/html but beware there are hugely experimental ideas in there. Don’t assume that because it’s in this document it’s implemented anywhere or even completely thought out yet. This spec does, however, have useful annotations about implementation status in different browsers. There’s a one-page version of the complete WHATWG specifications called “Web Applications 1.0” that incorporates everything from the WHATWG at http://www.whatwg.org/specs/web-apps/current-work/ complete.html but it might kill your browser as it’s massive with many scripts. A lot of the specification is algorithms really intended for those implementing HTML (browser manufacturers, for example). The spec that we have bookmarked is a useful version for the Web at http://developers. whatwg.org, which removes all the stuff written for implementers and presents it with attractive CSS, courtesy of Ben Schwarz. This contains the experimental stuff, too. Confused? http://wiki.whatwg.org/wiki/FAQ#What_are_the_various_versions_of_the_spec.3F lists and describes these different versions. Geolocation is not a WHATWG spec. You can go to http://www.w3.org/TR/geolocation-API/ to find it.
n
xiii
The process has been highly unusual in several respects. The first is the extraordinary openness; anyone could join the WHATWG mailing list and contribute to the spec. Every email was read by Hickson or the core WHATWG team (which included such luminaries as the inventor of JavaScript and Mozilla CTO Brendan Eich, Safari and WebKit Architect David Hyatt, and inventor of CSS and Opera CTO Håkon Wium Lie). Good ideas were implemented and bad ideas rejected, regardless of who the source was or who they represented, or even where those ideas were first mooted. Additional good ideas were adopted from Twitter, blogs, and IRC. In 2009, the W3C stopped work on XHTML 2.0 and diverted resources to HTML5 and it was clear that HTML5 had won the battle of philosophies: purity of design, even if it breaks backwards-compatibility, versus pragmatism and “not breaking the Web.” The fact that the HTML5 working groups consisted of representatives from all the browser vendors was also important. If vendors were unwilling to implement part of the spec (such as Microsoft’s unwillingness to implement , or Mozilla’s opposition to ) it was dropped. Hickson has said, “The reality is that the browser vendors have the ultimate veto on everything in the spec, since if they don’t implement it, the spec is nothing but a work of fiction.” Many participants found this highly distasteful: Browser vendors have hijacked “our Web,” they complained with some justification. It’s fair to say that the working relationship between W3C and WHATWG has not been as smooth as it could be. The W3C operates under a consensus-based approach, whereas Hickson continued to operate as he had in the WHATWG—as benevolent dictator (and many will snort at our use of the word benevolent in this context). It’s certainly the case that Hickson had very firm ideas of how the language should be developed.
The philosophies behind HTML5 Behind HTML5 is a series of stated design principles (http://www.w3.org/TR/html-design-principles). There are three main aims to HTML5:
•
Specifying current browser behaviours that are interoperable
• •
Defining error handling for the first time Evolving the language for easier authoring of web applications
xiv
n
Not breaking existing web pages Many of our current methods of developing sites and applications rely on undocumented (or at least unspecified) features incorporated into browsers over time. For example, XMLHttpRequest (XHR) powers untold numbers of Ajax-driven sites. It was invented by Microsoft, and subsequently reverseengineered and incorporated into all other browsers, but had never been specified as a standard (Anne van Kesteren of Opera finally specified it as part of the WHATWG). Such a vital part of so many sites left entirely to reverse-engineering! So one of the first tasks of HTML5 was to document the undocumented, in order to increase interoperability by leaving less to guesswork for web authors and implementors of browsers. It was also necessary to unambiguously define how browsers and other user agents should deal with invalid markup. This wasn’t a problem in the XML world; XML specifies “draconian error handling” in which the browser is required to stop rendering if it finds an error. One of the major reasons for the rapid ubiquity and success of the Web (in our opinion) was that even bad code had a fighting chance of being rendered by some or all browsers. The barrier to entry to publishing on the Web was democratically low, but each browser was free to decide how to render bad code. Something as simple as Hello mum!
(note the mismatched closing tags) produces different DOMs in different browsers. Different DOMs can cause the same CSS to have a completely different rendering, and they can make writing JavaScript that runs across browsers much harder than it needs to be. A consistent DOM is so important to the design of HTML5 that the language itself is defined in terms of the DOM. In the interest of greater interoperability, it’s vital that error handling be identical across browsers, thus generating the exact same DOM even when confronted with broken HTML. In order for that to happen, it was necessary for someone to specify it. As we said, the HTML5 specification is well over 700 pages long, but only 300 or so are relevant to web authors (that’s you and us); the rest of it is for implementers of browsers, telling them exactly how to parse markup, even bad markup.
n
Doctype Declaration Html5
xvWeb applications An increasing number of sites on the Web are what we’ll call web applications; that is, they mimic desktop apps rather than traditional static text-images-links documents that make up the majority of the Web. Examples are online word processors, photo-editing tools, mapping sites, and so on. Heavily powered by JavaScript, these have pushed HTML 4 to the edge of its capabilities. HTML5 specifies new DOM APIs for drag and drop, server-sent events, drawing, video, and the like. These new interfaces that HTML pages expose to JavaScript via objects in the DOM make it easier to write such applications using tightly specified standards rather than barely documented hacks. Even more important is the need for an open standard (free to use and free to implement) that can compete with proprietary standards like Adobe Flash or Microsoft Silverlight. Regardless of your thoughts on those technologies or companies, we believe that the Web is too vital a platform for society, commerce, and communication to be in the hands of one vendor. How differently would the Renaissance have progressed if Caxton held a patent and a monopoly on the manufacture of printing presses?
Don’t break the Web There are exactly umpty-squillion web pages already out there, and it’s imperative that they continue to render. So HTML5 is (mostly) a superset of HTML 4 that continues to define how browsers should deal with legacy markup such as , , and other such presentational tags, because millions of web pages use them. But authors should not use them, as they’re obsolete. For web authors, semantic markup still rules the day, although each reader will form her own conclusion as to whether HTML5 includes enough semantics, or too many elements. As a bonus, HTML5’s unambiguous parsing rules should ensure that ancient pages will work interoperably, as the HTML5 parser will be used for all HTML documents once it’s implemented in all browsers.
What about XML? HTML5 is not an XML language (it’s not even an SGML language, if that means anything important to you). It must be served as text/html. If, however, you need to use XML, there is an XML serialisation called XHTML5. This allows all the same
xvi
n
features, but (unsurprisingly) requires a more rigid syntax (if you’re used to coding XHTML, this is exactly the same as you already write). It must be well-formed XML and it must be served with an XML MIME type, even though IE8 and its antecedents can’t process it (it offers it for downloading rather than rendering it). Because of this, we are using HTML rather than XHTML syntax in this book.
HTML5 support HTML5 is moving very fast now. The W3C specification went to last call in May 2011, but browsers were implementing HTML5 support (particularly around the APIs) long before then. That support is going to continue growing as browsers start rolling out features, so instances where we say “this is only supported in browser X” will rapidly date—which is a good thing. New browser features are very exciting and some people have made websites that claim to test browsers’ HTML5 support. Most of them wildly pick and mix specs, checking for HTML5, related WHATWG-derived specifications such as Web Workers and then, drunk and giddy with buzzwords, throw in WebGL, SVG, the W3C File API, Media Queries, and some Apple proprietary whizbangs before hyperventilating and going to bed for a lie-down. Don’t pay much attention to these sites. Their point systems are arbitrary, their definition of HTML5 meaningless and misleading. As Patrick Lauke, our technical editor, points out, “HTML5 is not a race. The idea is not that the first browser to implement all will win the Internet. The whole idea behind the spec work is that all browsers will support the same feature set consistently.” If you want to see the current state of support for New Exciting Web Technologies, we recommend http://caniuse.com by Alexis Deveria.
Let’s get our hands dirty So that’s your history lesson, with a bit of philosophy thrown in. It’s why HTML5 sometimes willfully disagrees with other specifications—for backwards-compatibility, it often defines what browsers actually do, rather than what an RFC document specifies they ought to do. It’s why sometimes HTML5 seems like a kludge or a compromise—it is. And if that’s the price we have to pay for an interoperable open Web, then your authors say, “Viva pragmatism!” Got your seatbelt on? Let’s go.
CHAPTER 1 Main Structure
Bruce Lawson
ALTHougH MucH oF the attention that HTML5 has
received revolves around the new APIs, there is a great deal to interest markup monkeys as well as JavaScript junkies. There are 30 new elements with new semantics that can be used in traditional “static” pages. There is also a swathe of new form controls that can abolish JavaScript form validation altogether. So, let’s get our hands dirty. In this chapter, we’ll transform the current markup structure of s into a semantic system. New HTML5 structural elements like , , , , and <article> designate specific
types of content. We’ll look at how these work, and how HTML5 documents have an unambiguous outline and are—arguably—more “semantic.”
2
IN TRodu cIN g HT ML 5
The First things first: the DOCTYPE:
That’s it. No unwieldy string that even the most prolific web authors need to cut and paste. No URLs. No version number. That’s all. It’s not so much an instruction as an incantation: it’s required by browsers that need the presence of a DOCTYPE to trigger standards mode, and this is the shortest string that does this reliably. We’ve written in uppercase so that it’s both HTML and XML compliant, and suggest you do the same. Then we need to define the document’s character encoding. Not doing so can result in an obscure but real security risk (see http://code.google.com/p/doctype/wiki/ArticleUtf7). This should be in the first 512 bytes of the document. Unless you can think of a splendid reason not to use it, we recommend UTF-8 as the character encoding: <meta charset=utf-8>
Take a look at that <meta> tag very carefully. Those who are accustomed to writing XHTML will notice three oddities. The first is that the <meta> tag is much shorter than the tag we are familiar with—<meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8”>. This is still possible, but the shorter way is better as it’s easier to type and works everywhere already. You’ll also notice that I haven’t quoted the attribute charset=”utf-8”. Neither have I self-closed the tag <meta charset=utf-8 />. HTML5 is not an XML language, so you don’t need to do those things. But you can if you prefer. All of these are equally valid HTML5: <META <META <META <META <meta <meta <meTa <meTa
CHARSET=UTF-8> CHARSET=UTF-8 /> CHARSET=”UTF-8”> CHARSET=”UTF-8” /> charset=utf-8> charset=utf-8 /> CHARset=”utf-8”> CHARset=”utf-8” />
cHA p TE R 1 : M A I N STR u cTu R E : THE < HE Ad >
3
Pick a style and stick with it Just because you can use any of the aforementioned syntaxes doesn’t mean you should mix them all up, however. That would prove a maintenance nightmare, particularly in a large team. Our advice is to pick a style that works for you and stick with it. It doesn’t matter which you choose; Remy prefers XHTML syntax while Bruce prefers lowercase, attribute minimisation (so controls rather than controls=”controls”) and only quoting attributes when it’s necessary, as in adding two classes to an element—so but . You’ll see both styles in this book, as we each work as we feel most comfortable and you need to be able to read both. As a brave new HTML5 author, you’re free to choose—but having chosen, keep to it.
Why such appallingly lax syntax? The answer is simple: browsers never cared about XHTML syntax if it was sent as text/html— only the XHTML validator did. Therefore, favouring one form over the other in HTML5 would be entirely arbitrary, and cause pages that didn’t follow that format to be invalid, although they would work perfectly in any browser. So HTML5 is agnostic about which you use. While we’re on the subject of appallingly lax syntax rules (from an XHTML perspective), let’s cheat and, after adding the document title, go straight to the content: <meta charset=utf-8>
Today I drank coffee for breakfast. 14 hours later, ¬ I went to bed.
If we validate this exhilarating blog, we find that it validates fine, yet it has no tag, no , and no (Figure 1.1). FIguRE 1.1 Shockingly, with no head, body, or HTML tag, the document validates.
4
IN TRodu cIN g HT ML 5
This is perhaps one of those WTF? moments I mentioned in the introduction. These three elements are (XHTML authors, are you sitting down?) entirely optional, because browsers assume them anyway. A quick glance under the browser hood with Opera Dragonfly confirms this (Figure 1.2). FIguRE 1.2 Opera Dragonfly debugger shows that browsers add the missing elements.
Best Html5 Tools
Figure 1.3 shows it using the Internet Explorer 6 developer tools.FIguRE 1.3 Internet Explorer 6, like all other browsers, adds missing elements in the DOM. (Old versions of IE seem to swap
Today I drank coffee for breakfast. 14 hours later, ¬ I went to bed.
Active3 years, 7 months ago
Based on Creating an HTML 5 canvas painting application I created a HTML5 canvas painting application. It works fine, but after creating each object I just need to drag the objects. Working demo
How to implement drag and drop of the figures?
Jonas48.2k87 gold badges246 silver badges323 bronze badges
rameshramesh2,00612 gold badges58 silver badges102 bronze badges
5 Answers
If you are using the raphael as 'raw' lib you must handle the undo/redo by yourself.The graphiti lib did have Undo/Redo Stack inside and supports the export for SVG, PNG, JSON,...
Additional you have some kind of Viso like connectors and ports.
Greetings
user1397870
When the user clicks on the canvas, you have to check the coordinates (compare it to the coordinates for the objects), and see if it's on an object. E.g. You can test if a point (e.g. the coordinates for the mousedown even) is within a circle with this method:
If the mousedown is on the object, you have to change the objects coordinates according to how the mouse is moved.
Here is an example, where you can drag a circle:
Try it on jsFiddle
JonasJonas48.2k87 gold badges246 silver badges323 bronze badges
The same effect can be accomplished using Raphael.js (http://raphaeljs.com/) with Joint.jS (http://www.jointjs.com/).
Shapes created with Raphael can be accessed like any DOM element and can be manipulated via attributes. It is an awesome framework.
Joint.js helps in connecting the shapes. They also have a diagramming library and can help create ERD, Statemachine and several common diagrams. The best part is that you can extend their diagram element and create your own custom elements. Its jaw-dropingly cool.
Checkout their demos with source code at http://www.jointjs.com/demos
SrikanthSrikanth
I don't think there's an easy way to do this.
If you're just dealing with lines, my approach would be to keep track of all lines created, with starting coordinates, ending coordinates and some kind of z-index. When the user starts a dragging action (onmousedown), you have to check if the point is near the line, and then update the object and redraw the canvas when the mouse is moved.
This gets a lot more complicated if you're dealing with complex objects though. You'll probably have to find a solution to check if a point is inside a path.
Community♦
amiuhleamiuhle
Valid Html5 Doctype
Objects drawn into HTML5 Canvas are turned into pixels and then forgotten. You can't adjust properties on them and have the canvas update to see the effects. You can remember them yourself, but the canvas will still have those pixels set, so you'd have to basically redraw the whole canvas (or at least some of it) when you adjust a property.
You might want to consider SVG for this application instead, SVG elements are remembered in the DOM and when their properties are updated the browser will update the graphic to reflect the changes.
If you must use canvas, then you're going to need to write quite a bit of code to handle mouse-hits, object properties, and repaints.
James ClarkJames Clark