You are previewing HTML5: Up and Running.

HTML5: Up and Running

Cover of HTML5: Up and Running by Mark Pilgrim Published by O'Reilly Media, Inc.
  1. HTML5: Up and Running
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. Preface
      1. Diving In
      2. Conventions Used in This Book
      3. Using Code Examples
      4. A Note on the Editions of This Book
      5. Safari® Books Online
      6. How to Contact Us
    3. 1. How Did We Get Here?
      1. Diving In
      2. MIME Types
      3. A Long Digression into How Standards Are Made
      4. An Unbroken Line
      5. A Timeline of HTML Development from 1997 to 2004
      6. Everything You Know About XHTML Is Wrong
      7. A Competing Vision
      8. What Working Group?
      9. Back to the W3C
      10. Postscript
      11. Further Reading
    4. 2. Detecting HTML5 Features
      1. Diving In
      2. Detection Techniques
      3. Modernizr: An HTML5 Detection Library
      4. Canvas
      5. Canvas Text
      6. Video
      7. Video Formats
      8. Local Storage
      9. Web Workers
      10. Offline Web Applications
      11. Geolocation
      12. Input Types
      13. Placeholder Text
      14. Form Autofocus
      15. Microdata
      16. Further Reading
    5. 3. What Does It All Mean?
      1. Diving In
      2. The Doctype
      3. The Root Element
      4. The <head> Element
      5. New Semantic Elements in HTML5
      6. A Long Digression into How Browsers Handle Unknown Elements
      7. Headers
      8. Articles
      9. Dates and Times
      10. Navigation
      11. Footers
      12. Further Reading
    6. 4. Let’s Call It a Draw(ing Surface)
      1. Diving In
      2. Simple Shapes
      3. Canvas Coordinates
      4. Paths
      5. Text
      6. Gradients
      7. Images
      8. What About IE?
      9. A Complete Example
      10. Further Reading
    7. 5. Video on the Web
      1. Diving In
      2. Video Containers
      3. Video Codecs
      4. Audio Codecs
      5. What Works on the Web
      6. Licensing Issues with H.264 Video
      7. Encoding Ogg Video with Firefogg
      8. Batch Encoding Ogg Video with ffmpeg2theora
      9. Encoding H.264 Video with HandBrake
      10. Batch Encoding H.264 Video with HandBrake
      11. Encoding WebM Video with ffmpeg
      12. At Last, the Markup
      13. What About IE?
      14. A Complete Example
      15. Further Reading
    8. 6. You Are Here (And So Is Everybody Else)
      1. Diving In
      2. The Geolocation API
      3. Show Me the Code
      4. Handling Errors
      5. Choices! I Demand Choices!
      6. What About IE?
      7. geo.js to the Rescue
      8. A Complete Example
      9. Further Reading
    9. 7. The Past, Present, and Future of Local Storage for Web Applications
      1. Diving In
      2. A Brief History of Local Storage Hacks Before HTML5
      3. Introducing HTML5 Storage
      4. Using HTML5 Storage
      5. HTML5 Storage in Action
      6. Beyond Named Key/Value Pairs: Competing Visions
      7. Further Reading
    10. 8. Let’s Take This Offline
      1. Diving In
      2. The Cache Manifest
      3. The Flow of Events
      4. The Fine Art of Debugging, a.k.a. “Kill Me! Kill Me Now!”
      5. Let’s Build One!
      6. Further Reading
    11. 9. A Form of Madness
      1. Diving In
      2. Placeholder Text
      3. Autofocus Fields
      4. Email Addresses
      5. Web Addresses
      6. Numbers As Spinboxes
      7. Numbers As Sliders
      8. Date Pickers
      9. Search Boxes
      10. Color Pickers
      11. And One More Thing...
      12. Further Reading
    12. 10. “Distributed,” “Extensibility,” and Other Fancy Words
      1. Diving In
      2. What Is Microdata?
      3. The Microdata Data Model
      4. Marking Up People
      5. Marking Up Organizations
      6. Marking Up Events
      7. Marking Up Reviews
      8. Further Reading
    13. A. The All-in-One Almost-Alphabetical Guide to Detecting Everything
      1. List of Elements
      2. Further Reading
    14. Index
    15. About the Author
    16. Colophon
    17. SPECIAL OFFER: Upgrade this ebook with O’Reilly
O'Reilly logo

Images

IE[a]

Firefox

Safari

Chrome

Opera

iPhone

Android

7.0+

3.0+

3.0+

3.0+

10.0+

1.0+

1.0+

[a] Internet Explorer support requires the third-party explorercanvas library.

Figure 4-12 shows an image of a cat displayed with the <img> element.

Cat with an <img> element

Figure 4-12. Cat with an <img> element

Figure 4-13 shows the same cat, drawn on a canvas.

Cat with a <canvas> element

Figure 4-13. Cat with a <canvas> element

The canvas drawing context defines several methods for drawing an image on a canvas:

  • drawImage(image, dx, dy) takes an image and draws it on the canvas. The given coordinates (dx, dy) will be the upper-left corner of the image. Coordinates (0, 0) would draw the image at the upper-left corner of the canvas.

  • drawImage(image, dx, dy, dw, dh) takes an image, scales it to a width of dw and a height of dh, and draws it on the canvas at coordinates (dx, dy).

  • drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh) takes an image, clips it to the rectangle (sx, sy, sw, sh), scales it to dimensions (dw, dh), and draws it on the canvas at coordinates (dx, dy).

The HTML5 specification explains the drawImage() parameters:

The source rectangle is the rectangle [within the source image] whose corners are the four points (sx, sy), (sx+sw, sy), (sx+sw, sy+sh), (sx, sy+sh).

The destination rectangle is the rectangle [within the canvas] whose corners are the four points (dx, dy), (dx+dw, dy), (dx+dw, dy+dh), (dx, dy+dh).

Figure 4-14 gives a visual representation of these parameters.

To draw an image on a canvas, you need an image. The image can be an existing <img> element, or you can create an Image object with JavaScript. Either way, you need to ensure that the image is fully loaded before you can draw it on the canvas.

If you’re using an existing <img> element, you can safely draw it on the canvas during the window.onload event:

<img id="cat" src="images/cat.png" alt="sleeping cat" width="177" height="113">
<canvas id="e" width="177" height="113"></canvas>
<script>
window.onload = function() {
  var canvas = document.getElementById("e");
  var context = canvas.getContext("2d");
  var cat = document.getElementById("cat");
  context.drawImage(cat, 0, 0);
};
</script>
How drawImage() maps an image to a canvas

Figure 4-14. How drawImage() maps an image to a canvas

If you’re creating the image object entirely in JavaScript, you can safely draw the image on the canvas during the Image.onload event:

<canvas id="e" width="177" height="113"></canvas>
<script>
  var canvas = document.getElementById("e");
  var context = canvas.getContext("2d");
  var cat = new Image();
  cat.src = "images/cat.png";
  cat.onload = function() {
    context.drawImage(cat, 0, 0);
  };
</script>

The optional third and fourth parameters to the drawImage() method control image scaling. Figure 4-15 shows the same image of a cat, scaled to half its width and height and drawn repeatedly at different coordinates within a single canvas:

Here is the script that produces the “multicat” effect:

cat.onload = function() {
  for (var x = 0, y = 0;
       x < 500 && y < 375;
       x += 50, y += 37) {   
    context.drawImage(cat, x, y, 88, 56);
  }
};

All this effort raises a legitimate question: why would you want to draw an image on a canvas in the first place? What does the extra complexity buy you over an <img> element and some CSS rules? Even the “multicat” effect could be replicated with 10 overlapping <img> elements.

The simple answer is that you’d do this for the same reason you might want to draw text on a canvas (see Text). Our canvas coordinates diagram (see Canvas Coordinates) included text, lines, and shapes; the text-on-a-canvas element was just one part of a larger work. A more complex diagram could easily use drawImage() to include icons, sprites, or other graphics.

Multicat!

Figure 4-15. Multicat!

The best content for your career. Discover unlimited learning on demand for around $1/day.