GDI Overview - Windows API Reference

Graphics Device Interface (GDI) Overview

The Graphics Device Interface (GDI) is a core component of the Windows operating system that provides a consistent, device-independent way for applications to render graphics on various output devices. GDI handles everything from drawing simple lines and shapes to displaying complex text and images.

Key Concepts

Device Contexts (DCs)

A device context is a data structure that contains information about the drawing attributes of a particular output device. When you want to draw something, you first obtain a handle to a device context for the target device (e.g., a window on the screen, a printer). The DC stores attributes like the current pen, brush, font, color, and drawing mode.

Common types of DCs include:

Screen DC: For drawing directly to the screen.
Printer DC: For drawing to a printer.
Memory DC: For off-screen drawing operations, useful for creating buffered images or animations before displaying them.

GDI Objects

GDI uses various objects to define drawing attributes. Applications create these objects and then select them into a device context before drawing. Common GDI objects include:

Pens: Define the color, width, and style (solid, dashed, dotted) of lines.
Brushes: Define the color and pattern used to fill areas and draw text characters.
Fonts: Specify the typeface, size, and style of text.
Palettes: Manage the set of colors available for display on color devices.
Regions: Define arbitrary areas that can be used for clipping or filling.

Drawing Functions

GDI provides a rich set of functions for drawing various graphical elements:

Basic Shapes: Functions like LineTo, Rectangle, Ellipse, Polygon, and Polyline.
Text: Functions like TextOut and ExtTextOut for drawing text, and SetTextAlign to control text alignment.
Bitmaps and Metafiles: Functions for manipulating and drawing raster images (bitmaps) and vector-based graphics (metafiles).
Color Operations: Functions to set text and background colors, and to manipulate color palettes.

Device Independence

GDI's strength lies in its device independence. Developers write drawing code that targets GDI, and GDI translates these operations into the specific commands required by the underlying hardware (e.g., graphics card, printer driver). This means an application can draw to a screen and a printer without significant code changes.

Performance Considerations

For performance-critical applications, especially those involving complex animations or frequent updates, developers might leverage GDI+ or DirectX. However, for many standard graphical tasks, GDI remains a reliable and efficient choice.

Example Snippet (Conceptual C++)


// Obtain a device context for the application's window
HDC hdc = GetDC(hWnd);

// Create a pen for drawing red lines
HPEN hPen = CreatePen(PS_SOLID, 2, RGB(255, 0, 0));
HPEN hOldPen = (HPEN)SelectObject(hdc, hPen);

// Draw a line
MoveToEx(hdc, 10, 10, NULL);
LineTo(hdc, 100, 100);

// Restore the original pen and clean up
SelectObject(hdc, hOldPen);
DeleteObject(hPen);

// Release the device context
ReleaseDC(hWnd, hdc);

MSDN Community