Thank you, and welcome to the second day of WWDC. As Travis mentioned, my name is Derek Clegg. I work in Quartz Imaging Technologies. I'm the Principal Engineer responsible for our PDF support in Mac OS X. So today what we're going to talk about is what's PDF. That's the principal focus. I think a lot of people don't actually understand what PDF is, what it does, so we're going to focus a lot on PDF per se. And then also we want to talk about how Mac OS X, in particular Quartz, uses PDF.

So what's PDF? Well, all it really is, at the bottom, is just a file format. It's a way of specifying how data goes into a file. But what it's trying to do is provide a persistent representation of document layout. And what's really important for us in particular, and what's very nice about PDF, is that it's independent of your software, your hardware, your operating system. A PDF file sort of works on Mac OS X, it works on Mac OS 9, it works on Windows. So that's a very valuable thing for us.

So the thing-- PDF is actually a specification. It's published by Adobe. You can go download it from the web. You can go buy it as a book. The current version is the 1.3, second edition. It's a very nice specification, unlike some specifications in the world. And Adobe has just recently published the 1.4 differences. This is the document that describes how PDF 1.4 differs from PDF 1.3. So they actually haven't published the 1.4 spec yet, but they do have information about what's coming down the road.

So let's talk a little bit about what PDF, the problem PDF is trying to solve. Okay, so we have a document, we have information we want to convey. If you think about that, the basic bottom level is just content. It's like the words you're using and it's the images you're using and it's the, you know, the line art you're trying to display.

And sometimes it's sufficient just to have content alone. A good example of that is HTML. HTML is a format which has pure content. It really doesn't have a strong layout sense. If your browser decides to use a different font or position things on the page in its own way, it's free to do that.

That's good, but that's often not sufficient. And in particular, you often want to add layout information into your content stream. So you want to be able to say, "Okay, this image appears here and there's this title here and this text flows this way around here and this, you know, this page number appears right at this point on the bottom of the page." A traditional example of this is PostScript.

PostScript represents document content and layout information in a very nice way. PDF is exactly analogous in that sense. It contains both content and layout information. And it sort of--whoops--sort of lives one step above the actual device. I mean, you can sort of say, well, you go from content which is an abstract representation, sort of like the words you're using, to layout which is positioning information as well.

So, you can say, "Okay, I'm going to print this thing on a piece of paper." PDF lives in this middle area where you have all of the information you need in terms of content, but you don't--you're not tied to a particular device. You're not tied to a resolution, to a particular color space, to, you know, a piece of paper. So, PDF and PostScript live in the same place in terms of the document representation.

So as I mentioned, PDF contains sort of describes the document. And there's really two parts that we're interested in. In Quartz, we're interested in one part, and PDF contains an additional part. The page content is the part of PDF that actually says, here's what a page looks like.

This is the titles here, and there's these 14 lines of text, and then there's an image. The document itself, though, is bigger than that in PDF. There's sort of additional metadata that can go into a document. There's a page that describes information about the document that's not actually displayed as part of the page.

So, as an example, the document can contain things like annotations, additional information that's relative to the page, which isn't actually part of the page itself, hypertext links, interactive forms--some of you might have used Acrobat and brought up a PDF file and been able to fill in a form. In PDF 1.4, they've added what's known as logical structure tagging.

This is a mechanism where you can say, "Oh, on this page, this is a paragraph and this word in this paragraph is in Spanish and this word over here is in, I don't know, Chinese." And so it's pure meta information that's not really part of the page proper. It's sort of information about the page. It doesn't affect how the page is displayed. The page content itself is made up of three pieces. There's text, pretty obviously you need text to convey information, vector art, and sampled images.

Now, Quartz 2D, what we care about in Mac OS X and on the Quartz 2D part, we only are interested in page content. The document content, while it's very important, is not something that we can take advantage of on the level of Quartz 2D. We want to have a persistent graphics representation, so we're concerned primarily with page content, and that's what I'm going to be talking about today. Some people sort of have referred to this as dumb PDF, which is sort of true. It's the PDF without as much metadata as you might get if you generate it from Macrobat, but that's perfectly appropriate for the applications we use it for in Quartz 2D.

So let's dive down a little bit into what is in a page, what's the page content. A page description is a way of representing the page in a device and resolution independent manner. What that means is that the page isn't tied to a particular, say, screen that you're going to display on or printer you're going to. It's independent of that. It's an abstract specification of how the document gets laid out.

And it's resolution independent. You're not tied to a particular bit depth or color space. You can go to CMYK or RGB printers. The document is the same, independent of the destination. The contents are independent of the creator, which means in particular that all the PDF that's generated is going to end up being the same format. It's not like a special Windows PDF or a special Adobe PDF or a special Apple PDF.

PDF is the same. And in particular, we take that very seriously at Apple. We're not going to generate special Apple PDF that only works on Mac OS X machines or anything like that. What we generate will work on Acrobat, on Windows, on Mac, on Unix platforms. So we want to make sure that we are generating PDF that is independent of, in some sense, independent of us, that works everywhere.

And the page itself is based on the, the PDF page description is based on the PostScript imaging model. Those of you who are familiar with PostScript might recognize this, and I'll talk about this a little bit more. So the question is, what's an imaging model? I mean, when we sort of talk about the PostScript imaging model or the Quartz Studio imaging model, an imaging model is just an abstract way of saying how you're going to put things on a page. so that you get the result you want to get.

Obviously, an imaging model needs to be capable of describing simple things, complex things. If you want to do anything complicated like a magazine illustration or an ad for a magazine or something like that, you're going to need to have a relatively sophisticated imaging model. Unsurprisingly, you're going to have to have fonts, you're going to have to have images like you might get from a digital camera, and you're going to need vector art.

PDF has a particular imaging model, a particular way of specifying how things get put on the page. Its imaging model is based on the painter's algorithm, which is essentially how a painter paints. You put down paint on a page, you put down more paint on top, what you put down on top obscures what's underneath, and you sort of build up your image, your page, by putting more important paint up, and you sort of build from the bottom up.

Now, one thing that's slightly different in PDF 1.4, they've added the notion of transparency. So, it's not, it's, the paint you put on top doesn't necessarily completely obscure what's underneath. You can think of it as the paint, sort of like watercolors. When you put a watercolor down, you don't obscure what's underneath, you sort of shade what's underneath.

So, that's the same sort of idea. In PDF, the imaging model, you can paint things, you can paint glyphs, you can paint vectors, you can paint images. Um, that's the idea. Um, that's the idea. That's sort of their basic set of three things. There's nothing else that's available for you. Turns out that's actually rich enough for pretty much everything you want to do.

Um, and the paint, in this metaphor, is a color, for example, RGB values or CMYK values. It could be a grayscale value. A paint can also be a pattern, so you might have a replicated sequence of stars or ducks or something. And, um, it could be a gradient, which is, you know, a smooth transition from one color to another over a range of space.

Another very important part of the imaging model is that paint only is drawn within a current clip region. This is, again, if you'll let me extend the metaphor, this is exactly what a painter does. You put down some tape, and when you paint, you're only going to show the paint in that region which you've taped off. This is very valuable when you're trying to draw complicated images.

I built up a complicated piece of artwork to be able to clip to a certain region. The key thing, and I think the thing that's very important for PDF is that the PDF and PostScript imaging models are identical. Anything you can represent in PostScript, you can represent in PDF. So that's very, very powerful.

But that doesn't mean that they're the same thing. PDF is a more restricted format than PostScript. There's a lot more stuff you can do. There's different types of things you can do in PostScript that you can't do in PDF, but the end result is that everything that you can image in PostScript, you can image in PDF.

So, now we're going to talk a little bit about a PDF document and what's actually inside there. So, the PDF document is the thing that's like foo.pdf if you look at it in your Mac OS X machine. It can contain more than one page, obviously. You might have, say, a book, for example, that you're publishing. As I mentioned before, pages can contain text, vector art, and sampled images, and then as I mentioned before, documents may contain this metadata that tells you information about the pages. So let's go into that a little bit more, into the contents of a particular page.

So the vector art is actually relatively simple, and yet it's very rich and very powerful. All vector art is constructed from curves, in this case, Bezier curves, that's the only curve you can use, and lines. So you can build up any shape you want to from curves and lines.

It turns out that's actually a pretty rich set of, even though it's simple, it actually lets you do almost all vector art that you would like to do. When you build up a path, you can stroke it, or you can fill it, or you can use the path to specify a clip region.

So you might, for example, have four curves that you collect together and create a circle, and you could fill the circle and then clip to that and draw some stuff inside of that, and so on. And then another important part, and this sort of follows through for each of the pieces of PDF that you can draw on a page, is something known as the current transformation matrix.

This is a transformation that lets you draw a page. So this is a transformation that lets you map, to sort of essentially modify the coordinates, the drawing, from what you specify to what gets drawn on the page. So you can change the transformation matrix, you can rotate it, or you can scale it, and what you draw, what you specify will be drawn through that transformation matrix onto the page.

So for example, if you wanted to draw a rotated rectangle, you could just draw your rectangle the regular way, change the transformation matrix to rotate, and then when the rectangle gets put on the page, it's drawn rotated. This is actually very powerful. It's part of the PostScript image. PostScript uses the same thing, and it makes it easy to do complicated drawing simply.

The second part of PDF in terms of building up the page content that's important is sample images. Sample images are just like what you get from your digital camera. It's just an array of samples. This many samples across, 1,078, this many samples down. Each sample represents a color. It's just a value that represents a color at that point in the rectangle. PDF has a nice, rich set of bit depths that it supports. It supports 1, 2, 4, and 8.

This is pretty much industry standard. There's also 12-bit images, but those aren't so common currently. PDF may and I don't know whether they'll support that in the future. Again, just like with vector art, all the images that are drawn are mapped through the current transformation matrix. That means that you can take your image, your 10x7 image, and rotate the transformation matrix.

You can draw the image, and the image will show up rotated. You don't actually have to calculate what the pixel values are as you rotate the image yourself. PDF knows how to do that for you, and you end up with a very nice, rotated image without actually having to rotate it yourself.

And then finally, fonts, so pretty much for page content, you know, the meat of things is the text, the information, the words you're trying to convey, fonts are used to convey that obviously, and each font consists of a set of glyphs, a glyph is just a representation of a character in the font, it's treated from the point of view of PDF typically as an outline, just like a piece of vector art essentially.

As a consequence, glyphs can be stroked or filled just like with vector art, and you can also clip through them, so you can have a big capital letter A and you can say clip to that and everything you draw from that point on would be clipped through that letter A.

So you can get nice complicated graphic results using it very simply. And as with vector art and with images, glyphs are mapped through the current transformation matrix, so if you want to draw a rotated text, you can do that simply, the same font can be used to draw a skewed text or a scaled text, so everything sort of goes through the context.

So if you want to draw a rotated text, you can do that simply, the same font can be used to draw a skewed text or a scaled text, so everything sort of goes through the context of the text. To the left is an image that appears for the internet server, which; should appear for the internet server.

Now fonts are actually a big thing in the industry. There's lots of different types of fonts that have come through over the years. The big ones are the ones from Adobe and TrueType. Adobe Type 1 is innate. Obviously the Adobe ones are part of PDF. Adobe Type 1 is fully supported in PDF. The Adobe Type 1 Multiple Master as well. Adobe, the CFF, Compact Font Format, is also supported. That's essentially sort of a variation of Type 1, but it's a smaller format. It's used as the basis for OTF fonts.

Adobe Type 0 is sort of a container for CID fonts. CID fonts are used for Chinese, Japanese, Korean, Vietnamese languages. Essentially any language where you have a large number of glyphs, typically in the order of many thousands, to represent the language. This is a very important thing for, say, the Japanese market, where you want to be able to support various forms of Japanese fonts that have many, many glyphs in them. And then, of course, TrueType, probably an old standard for most of you.

There are cases when, for copyright reasons or a variety, maybe user choice, it's impossible or not reasonable to embed the font. So PDF, unlike PostScript, PDF actually also lets you specify metadata about a font. So you may put a reference into your document that you're using Optima, but you might not, for some reason, embed Optima. But you can include enough information in the PDF document that allows some other system to fo the font, to create an approximate font that looks very close to the original font.

And this is really valuable when you are in a situation where, for some reason, you can't embed the font or you have files that don't have it. You get a pretty close look, it's not 100%, but it's a lot better than, for example, in PostScript where if you didn't have the font, you get Courier, which looked awful. Some of you may actually remember that.

So there's two major types of color spaces that are interesting in PDF. There's device-dependent color. It's... It's used in the situations where you're not as concerned with the fidelity of the color representation. In general, we, because we're very interested in high fidelity color reproduction, aren't too keen on encouraging it, but it is available.

There's Device Gray, Device RGB, Device CMYK. The device independent colors, basically the calibrated colors, are also supported. And in that case, there's Calibrated Gray and Calibrated RGB. L*, A*, B*, which is a color science color space that you could probably forget about and never be affected by. And then finally, the important one, which is ICC Profiles. Same sort of thing we use in ColorSync. They're much more common nowadays than the other two color spaces, and they do provide for high calibrated color.

In addition, PDF lets you do two other special color spaces. There's the index color space where what you're specifying at that point is each value is an index into a table of other colors. So a good example of this is GIF images. Some of you may be familiar with that where you really, your image is only 256 values, but each value from 0 to 255 is an index into some other color table. So PDF has that support in there. It's perhaps not as used as much nowadays. But it is available. And then separation and device in.

These are essentially the same thing. Separation is like device one. What it allows you to do, this is used when you're for printing typically. You often will want to do a CMYK printing pass. And you might have another separation or two or three, maybe an orange. CMYK is cyan, magenta, yellow, black. So because it's difficult to get a pure orange or a pure purple or some other color. You might have an additional separation. So PDF allows you to do this. This is really for high end printing applications. It's not typical for most use, but it is available.

Okay, so we've talked at this point about the PDF content, what goes into it, the painting, the color and so on. So you have now sort of you can imagine maybe to build up a magazine page. You have all these images and all this vector art and all this text and these fonts and all this other stuff in there. And that could be huge.

And then you have the PDF file. And the first thing that you run into immediately is, well how do I keep the file size to be a reasonable size? Fortunately, PDF has built into it a way to compress the data in the PDF file. And some of you may or may not have opened up a PDF file and noticed it's lots of binary data. And you think, oh my goodness, this is a binary format. It's actually, I mean it's, it is a binary format in some sense. But really what you're seeing is the compressed data typically. Not necessarily some sort of weird structure that you can't understand.

So there's two mechanisms for compressing data in PDF. There's the lossless one, the case which you typically want for page content where you don't want to lose information. And then for images, there's both lossless mechanisms and lossy. Lossy is really very valuable for say images with color. It's basically the basis of JPEG and so on.

So for page content, there's two typical ways. There's LZW, which is, many of you are familiar with that from the patent issues and so on, compression. And then there's flake compression, it's also called, it's available like Zlib and stuff like that. This is another, this is a really much more common method because it's patent free that's being used more and more now. But both of these are very, can be very powerful in their own ways and are supported natively in PDF.

For images, it's a little bit more complicated. For lossless compression of images, which is typically good for grayscale, there's a PNG equivalent. PNG specifies a way to use flight compression for encoding image data, so there's an equivalent way in PDF to specify that, although PDF doesn't allow you to embed a PNG image directly. It lets you embed the PNG data directly.

For grayscale proper, typically one bit, a fax for example, there's the CCIT group 3 and group 4 compression mechanisms, and also run length, not so interesting, but it's available. And then in 1.4, there's this new cool thing, which is actually going to replace CCITT group 3 and group 4 in the industry, called JBIG2, which is a way of compressing specifically sort of tailored to fax data in a very nice way that's a lot great, gives you a lot better compression than CCITT fax compression. But that's in 1.4.

The two lossy ways of compressing, there's JPEG for color, is the most interesting case. Grayscale doesn't compress very well with JPEG. And of course, Grayscale, you can compress it with JPEG or with JBIG2. There's a mechanism for JBIG2 which lets you do lossy compression of Grayscale. Now we have a PDF document.

You have everything's compressed, it's all ready. So let's talk a little bit about what it's like to actually create a PDF document or display it. So I wrote a lot of the code that creates both PostScript and PDF files. And this first one is a big, big advantage. You can do single pass file generation when you're generating PDF. That means that--well, basically PDF has a way of referencing objects before they're actually specified in the file.

So you can--if you want to write an image, you can say, "Oh, here's an image that I want you to display now." And then sometime down the road, you can actually write out the image data. The problem--the reason that's good is because you can actually--you can actually--you can actually--you can actually--you can actually sort of create the file as you're going along and when you're ready, you can dump the image data.

You don't have to sort of store the image data someplace else and then copy it back into the file when you need to display it. I mean, PostScript has not one pass file generation and it's terrible. You do--and it puts lots of temporary files, you're copying stuff all the time, it's a big mess. PDF is really great because you can do one pass, done. You have the output.

This is really good when you're spooling and you're spooling large files because you're spooling time to the printer is going to be a lot faster. So you can do a lot faster. The sort of the--the corollary to that is that what you end up with when you're trying to display the document is random access.

It's not like PostScript where you have to sort of start at the beginning and seek to the information you need. PDF has a cross-reference table at the end that tells you where every object in the document lives. So you can quickly go to page number so and so, image number so and so, and pretty much constant time independent of the number of pages, the file size and so on. So that's a really big one when you're displaying. It's actually a big one. And then you can do a lot of things with it.

So you can do a lot of things with it. So you can do a lot of things And what's also nice about PDF is that it's-- and each page is independent of other pages. Those of you who might have worked with PostScript before, know that to display page number 355, you pretty much need to display all the pages up until then.

Unless, you know, you sort of hope that the document structure and comments are correct and the pages really are independent and so on. But if a bad PostScript file, you've got to display everything until that page in order to make sure you know it's correct. PDF encapsulates each page as an independent entity. They're not-- they don't refer to pages prior or after them. So this is really good for display. You can quickly display the 30th page, the 300th page in constant time.

I've talked a little bit about PostScript and PDF. And I want to talk a little bit more about the differences there, those of you-- this might be more interesting to those of you who are more familiar with PostScript and not so much with PDF. PDF is really an absolute-- it's not an absolute description of where things go. It's not a calculated description of where things go. So PostScript allows you to calculate the positions of things, it allows you to measure strings and do divide by two to center and stuff like that. PostScript is a calculated way of displaying content.

PDF is an absolute way. And so that's actually a big difference for those of you who are familiar with PostScript. You need to sort of know where everything's going to end up in order to generate your PDF file. Unlike with PostScript, where you sort of figure it out on the printer.

On the other hand, it's good to not have to do that because it's less work if you know where everything's supposed to be. Of course, PDF can contain hyperlinks, metadata, annotations, things that are going to be used when you're displaying it in Acrobat or some other interactive mechanism. PostScript doesn't have that. PostScript is pretty much pure content, pure layout. It doesn't have this sort of additional information.

And also PDF, unlike PostScript, is a really strictly defined file structure. It's hard to write a PDF file by hand. It's really easy to write PostScript files by hand. But that's good because that means that a computer can read and process a PDF file very rapidly. PostScript, you have to do a lot of processing and parsing and interpretation.

So what that means is, of course, you get, as I mentioned before, random access of your data and page independence. That's a really key feature. And then, as I mentioned before, the font foeing, for example, PDF files will contain additional information that might be used in the case that you have to substitute in some sense.

You can't fully get what you need because the PDF file doesn't embed the font. So it has extra stuff that allows you to synthesize more correctly what you get. Not just a replacement with Courier, but a replacement with a Sans Serif multiple master font that's tweaked just the right way so it looks pretty good.

So that's sort of a big, you know, wide overview of what PDF, what contains, what's interesting about PDF from the point of view of Quartz 2D. So the real question at that point is like, why did we choose to use PDF of all things? I mean, we could have gone out and said, well, we want a persistent graphics file format, let's write our own or let's use PNG or something weird like that. So what we wanted is something clearly that was robust. We needed something that was, that people in the industry use, not just us, but everybody in the industry.

So how do we use it? Well, at the bottom, the most important part is in Quartz 2D. We looked at the PDF imaging model. We said, OK, that's what we want as our imaging model. We want to use the same ideas that PDF has to build up the Quartz 2D imaging model.

So we took the ideas wholesale and we said, this is how we're going to draw on the screen, on the piece of paper, and so on. As a consequence, we also said, obviously, we want this to be our persistent graphics format. We want to be able to say, if we're drawing on the screen and using this imaging model, we want to write it out to PDF so we can actually get good results when we go to the printer and so on.

And what we also are not interested in doing, we don't want to say, oh, OK, well, this is good. And we're just going to stay here. We're going to-- now we're going to diverge. We're going to make our own PDF. We don't want to do that. That's bad.

We want to track the Adobe standard. We want to be in sync with them, keep as close as possible with them. So that we don't diverge from their model. Because we're using their model. And we're sort of want to pay deference to that and make sure that we track their standard as closely as possible.

So, what we have right now in PDF, sorry in Quartz 2D is support for the 1.2 specification and much of the 1.3 specification. The 1.4 spec is going to be coming out soon and we want to be able to track that as well, so we're, you know, we're really committed to trying to make sure that we keep on top of the 1.3 spec, 1.4 spec and make sure that we have support and that our model matches what PDF provides.

And what I want to emphasize in particular, as you can see here, we're interested in not all of the spec. As I mentioned before, the spec is actually very complicated and large, there's lots of pieces to it. A lot of it is document, the document model specific. It's sort of the part that says, you know, here's how annotations work, here's how hypertext links work and so on.

So, we're not on the Quartz 2D level interested in that part of it. That's something that's a high priority. We're interested in the higher level thing, for example, for Acrobat or other programs that might be doing interactive PDF display. We're, since we're focused on the persistent graphics format, we're tailoring our support specifically to the part of the document model that's relevant. And as you can see on the other axis, the imaging model, sort of all of the imaging model, however, we want to keep that going up all the way.

Now, in addition to Quartz 2D, which is a big part of our PDF usage, Mac OS X uses PDF in other ways, mostly by leveraging what we provide in Quartz 2D. Pretty much in Mac OS X, PDF is our high-fidelity digital master recording of application drawing. So, the idea is that if an application draws on the screen a certain way using the course 2D APIs, what they get out, if they choose to, is a PDF file that represents that drawing precisely.

So that if we took that PDF file and brought it up in Acrobat, they would see the same thing in Acrobat that they're seeing on the screen. That's a really important feature for us to make sure that the drawing that you do to the screen ends up in the PDF file precisely. Including things like all the fonts being correct, all the colors being calibrated, everything that you've actually asked for.

So just to summarize, I've talked about a bunch of different parts of PDF and what it's like and then how we use it. It really is, it's really powerful. It's a super format. I like it a lot, it turns out, and it provides a really good high fidelity representation of information.

It's really good for color calibration, font preservation, all the stuff you need to make sure that what you're drawing on the screen matches exactly what you're printing to the page. And it's our native format for persistent graphics representation. We want to make sure that we keep it as our way of representing what's drawn persistently into a file.

And all of the Quartz 2D imaging model is built on top of the PDF imaging model. There's another talk later, I think it's right after this one, which goes more in depth into the Quartz 2D APIs and how some of that relates directly to what I've been talking here about.

We're pretty consistent in terms of what you're going to see. So, we're going to be looking at the Quartz 2D APIs, what you can do with the Quartz 2D APIs, with what you can do, what the imaging model is in PDF. So, there's almost a one-to-one mapping in some cases, because we really think it's a very valuable imaging model, very important format to support.

So if you want more information about PDF in particular, go to the Adobe website, not the Apple website. They have the PDF spec, they have the 1.4 differences, you can download a bunch of other information about PDF. It's got a lot of detail there that you might want to know about. I think you can buy the PDF 1.3 specification from Amazon. I certainly think you can download it from here as a PDF file.

And I think at this point I want to bring back Travis, who will talk a little bit about the roadmap, and then we'll open it up for question and answers. Thank you, Derek. Yeah, before we go to question and answer, I just want to be able to point you to some of the other graphic-related sessions at WWDC.

Obviously we're in 108, PDF, Quartz, and Mac OS X. As Derek mentioned, a follow-on session, which is in Room A1 at 10:30, is the 2D Graphics Using Quartz. If you want to empower your application with the ability to create PDFs and leverage our services, that's the session you need to attend. We'll be talking about the Quartz 2D API and tell you how to use it.

Then also, a common request we get, Quartz-related request we get from developers is anti-alias text. And we have several sessions that are going to tell you how to use the existing text APIs in Mac OS X and have them leverage the Quartz 2D API. And then we have the Quartz 2D API, which is going to be able to leverage Quartz for the final drawing or rendering, where you get the nice subpixel anti-aliasing that Mac OS X is capable of providing. That's session 110. Then we have session 117, which is going to be all about Image Capture Framework, which is a new framework that allows your application to interact with digital cameras. It's very, very interesting. You've seen it demoed in several of the introductory sessions yesterday.

Next we have color sync. Color sync is very, very important. One of the sort of key hidden features in Mac OS X's imaging model in particular Quartz is the fact that it's fully color managed. So if you're using the Quartz 2D APIs to draw your graphics or you're doing something like drawing a PDF on screen, Mac OS X knows how to interact with color sync and provide high level color management to that content.

And it is something that's fairly simple to do and we want to spend time in the color sync session educating developers on how they need to do things like tag profiles and understand how the color workflow works internally. So that you can make any application on Mac OS X be fully color managed regardless if it's displaying content on screen or sending the content out to an output device. We have another session on text so that if you still want to learn how to do nice anti-alias text using Quartz, there's some content in the text on Mac OS X.

We have a session on text on the Mac OS X session which although it talks about some of the other text APIs such as MLTE, those are fully interoperable in terms of having the graphics displayed by Quartz. And then a very interesting session is 404 which is OpenGL high performance 2D. If you're doing anything with large bitmaps and you want very high performance, getting those bitmaps on screen, then you need to see this session. Some very, very interesting demonstrations.

Some very interesting concepts will be expressed at this session. And then we also have a printing session where we'll talk about Mac OS X printing architecture and we'll cover printing from the perspective of Carbon developers. We'll even get into a little bit for developers who are familiar with BSD and we'll also talk a little bit about Cocoa printing.

Finally, we have a very interesting session, which is the Graphics and Imaging Tips and Tricks. If you're a Carbon developer and you want to learn how to fully leverage Quartz in your application, this will be an important session for you to attend. We have a lot of content relating to Quick Draw and Quartz integration, and also cover certain cases like how do you print content.

Also talk about the printing context on Mac OS X, which are a little bit different from what you might be used to in Mac OS 9. So it's also a very, very good session. Then we'll finish the graphic sessions at this Worldwide Developer Conference with a feedback forum Friday at 2 p.m.