Name 

Description 

Creating and Managing Off-screen Bitmaps 

When creating complex graphic images, you should avoid drawing them directly on a canvas that appears onscreen. Instead of drawing on the canvas for a form or control, you can construct a bitmap object, draw on its canvas, and then copy its completed image to the onscreen canvas.
The most common use of an off-screen bitmap is in the Paint method of a graphic control. As with any temporary object, the bitmap should be protected with a try..finally block:  

Loading and Storing Graphics 

All pictures and graphics in Delphi can load their images from files and store them back again (or into different files). You can load or store the image of a picture at any time.
To load an image into a picture from a file, call the picture's LoadFromFile method. To save an image from a picture into a file, call the picture's SaveToFile method.
LoadFromFile and SaveToFile each take the name of a file as the only parameter. LoadFromFile uses the extension of the file name to determine what kind of graphic object it will create and load. SaveToFile saves... more 

Handling Palettes 

For VCL components, when running on a palette-based device (typically, a 256-color video mode), Delphi controls automatically support palette realization. That is, if you have a control that has a palette, you can use two methods inherited from TControl to control how Windows accommodates that palette.
Palette support for controls has these two aspects:

• Specifying a palette for a control
• Responding to palette changes

Most controls have no need for a palette, but controls that contain "rich color" graphic images (such as the image control) might need to interact with Windows and the screen device driver to ensure the proper... more 

Off-screen Bitmaps 

When drawing complex graphic images, a common technique in graphics programming is to create an off-screen bitmap, draw the image on the bitmap, and then copy the complete image from the bitmap to the final destination onscreen. Using an off-screen image reduces flicker caused by repeated drawing directly to the screen.
The bitmap class in Delphi, which represents bitmapped images in resources and files, can also work as an off-screen image.
There are two main aspects to working with off-screen bitmaps:

• Creating and managing off-screen bitmaps.
• Copying bitmapped images.

 

Overview of Graphics 

Delphi encapsulates the Windows GDI at several levels. The most important to you as a component writer is the way components display their images on the screen. When calling GDI functions directly, you need to have a handle to a device context, into which you have selected various drawing tools such as pens, brushes, and fonts. After rendering your graphic images, you must restore the device context to its original state before disposing of it.
Instead of forcing you to deal with graphics at a detailed level, Delphi provides a simple yet complete interface: your component's Canvas property. The canvas... more 

Using a Picture, Graphic, or Canvas 

There are three kinds of classes in Delphi that deal with graphics:

• A canvas represents a bitmapped drawing surface on a form, graphic control, printer, or bitmap. A canvas is always a property of something else, never a stand-alone class.
• A graphic represents a graphic image of the sort usually found in a file or resource, such as a bitmap, icon, or metafile. Delphi defines classes TBitmap, TIcon, and TMetafile, all descended from a generic TGraphic. You can also define your own graphic classes. By defining a minimal standard interface for all graphics, TGraphic provides a... more 

Responding to Changes 

All graphic objects, including canvases and their owned objects (pens, brushes, and fonts) have events built into them for responding to changes in the object. By using these events, you can make your components (or the applications that use them) respond to changes by redrawing their images.
Responding to changes in graphic objects is particularly important if you publish them as part of the design-time interface of your components. The only way to ensure that the design-time appearance of the component matches the properties set in the Object Inspector is to respond to changes in the objects.
To respond to... more 

Responding to Palette Changes 

If your VCL control specifies a palette by overriding GetPalette, Delphi automatically takes care of responding to palette messages from Windows. The method that handles the palette messages is PaletteChanged.
The primary role of PaletteChanged is to determine whether to realize the control's palette in the foreground or the background. Windows handles this realization of palettes by making the topmost window have a foreground palette, with other windows resolved in background palettes. Delphi goes one step further, in that it also realizes palettes for controls within a window in tab order. The only time you might need to... more 

Specifying a Palette for a Control 

To specify a palette for a control, override the control's GetPalette method to return the handle of the palette.
Specifying the palette for a control does these things for your application:

• It tells the application that your control's palette needs to be realized.
• It designates the palette to use for realization.

 

Using Graphics in Components: Overview 

Windows provides a powerful graphics device interface (GDI) for drawing device-independent graphics. The GDI, however, imposes extra requirements on the programmer, such as managing graphic resources. Delphi takes care of all the GDI drudgery, allowing you to focus on productive work instead of searching for lost handles or unreleased resources.
As with any part of the Windows API, you can call GDI functions directly from your Delphi application. But you will probably find that using Delphi's encapsulation of the graphic functions is faster and easier.
The topics in this section include:

• Overview of graphics
• Using the canvas
• Working with pictures... more 

Using the Canvas 

The canvas class encapsulates graphics controls at several levels, including high-level functions for drawing individual lines, shapes, and text; intermediate properties for manipulating the drawing capabilities of the canvas; and in the component library, provides low-level access to the Windows GDI.
The following table summarizes the capabilities of the canvas.
Canvas capability summary  

Working with Pictures 

Most of the graphics work you do in Delphi is limited to drawing directly on the canvases of components and forms. Delphi also provides for handling stand-alone graphic images, such as bitmaps, metafiles, and icons, including automatic management of palettes.
There are three important aspects to working with pictures in Delphi:

• Using a picture
• Loading and storing graphics
• Handling palettes