Working with the QTDrawable interface

As we've seen, the QTDrawable interface is used to handle the negotiation between the QTCanvas and one of several QuickTime objects. The QuickTime objects that implement the QTDrawable interface are extensive and include the following:

• the QTPlayer class, which presents the movie controller
• the MoviePlayer or QTImageProducer classes, which present the Movie data type
• the GraphicsImporteDrawer class, which wraps the graphics importer to present images from a data source, typically image files
• the ImagePresenter class, which presents the DSequence but for a single image only, allowing image data to be loaded and kept in memory, providing a faster redraw than the GraphicsImporter object
• the SWCompositor class, which presents the sprite world
• the SGDrawer class, which presents the sequence grabber and sequence grabber channel (video) components
• the GroupDrawable class, which groups QTDrawable objects into the same canvas.
• the QTEffect class, which wraps the visual effects architecture of QuickTime
• the QTImageDrawer class, which allows the results of Java painting into a java.awt.Image to be captured and drawn by QuickTime

The QTDrawable interface is designed to work hand-in-hand with a QTCanvas object. The class that implements this interface draws into the supplied QDGraphics object. The QTCanvas will call the methods of its client (setting its destination QDGraphics, setting display bounds, and redrawing it) as required.

These methods are used by the QTCanvas to notify the client object that it has been added to or removed from the QTCanvas. Various clients require this notification:

• QTPlayer, so it can declare its interest in mouse and key events
• QTImageDrawer, so that it can create an java.awt.Image object to paint into
• QTDisplaySpaces , to allow the attachment of controllers that are interested in receiving events whose source is the QTCanvas
• setDisplayBounds(), getDisplayBounds()

  These methods are used to get the current size of a QTCanvas client and set its size. The QTCanvas determines the size of itself and its client based on a complex interaction between the size the QTCanvas parent container allocates to the QTCanvas, the initial (or best) size of its client, and the setting of the resize and alignment flags of the QTCanvas itself.

  Once the QTCanvas has determined the correct size of itself and its client, it uses the setDisplayBounds() method to resize and locate its client. The size and location of a QTCanvas and its client is always the same.

• redraw() This method is used to tell the client to redraw itself. Both the setDisplayBounds() and redraw() methods of a client are only called by the QTCanvas paint() method, with the setDisplayBounds() call, if required, being always called before a redraw() call.
• getGWorld(), setGWorld() These methods are used to set the QTDrawable client's destination QDGraphics if the client of a QTCanvas is a QTDrawable, as is normally the case. All QTDrawable objects must have a destination QDGraphics at all times. As such, if a QTDrawable client is removed from a QTCanvas or the QTCanvas has been hidden myQTCanvas.setVisible (false);

  then a special QDGraphics, QDGraphics.scratch(), is used to indicate to the QTDrawable that it is invisible and basically disabled. While the following methods are not used specifically in the relationship between QTCanvas and its client, they are presented here for the sake of completeness and also express capabilities that all QTDrawable objects possess:

• getClip(), setClip() All QTDrawable objects have the ability to clip their drawn pixels to a specified region. The getClip() and setClip() methods are used to get and set a clipping region. null can be used and returned, and it indicates that the QTDrawable currently has no clipping region set.

  The DirectGroup display space enables one or more QTDrawable objects to draw into the same QTCanvas destination QDGraphics. It provides the capability to layer the objects in such a group, so that the objects do not draw over each other. This layering is achieved through the use of clipping regions. The DirectGroup clips its members so that members that are behind others cannot draw into the area where those in front are positioned. As this group by definition draws directly to the screen, this is the only means that can be used to avoid the flickering that would occur if the QTDrawable objects could not be clipped.

• getMatrix(), setMatrix(), getInitialSize()

The QTDrawable interface also extends the Transformable interface.

The Transformable interface expresses the ability of QuickTime drawers to have a matrix applied that will map the source pixels of a drawing object to some transformed destination appearance. A matrix allows the following transformations to be applied in the rendering process:

• translation. Drawing pixels from an x or y location
• scaling. Scaling the image by an x or y scaling factor
• rotation. Rotating the image a specified number of degrees
• skew. Skewing the image by a specified amount
• perspective. Applying an appearance of perspective to the image

Your application can freely mix and match these different transformations at its own discretion.

All QTDrawable objects can have a matrix applied to them that will transform their visual appearance. A Sprite in a SpriteWorld can also have matrix transformations applied to it, as can a 3D model. The TwoDSprite also implements the Transformable interface.

The Transformable interface allows for applications to define behaviors that can be applied to any of these objects. For example, the
quicktime.app.actions.Dragger, which will position objects in response to a mouseDragged event, is defined totally in terms of the Transformable interface. Thus, the Dragger can reposition any TwoDSprite in a SWCompositor or any QTDrawable in a GroupDrawable. Using interfaces to express common functionality is a powerful concept and is relied upon extensively in the QuickTime for Java Application Framework.