gdi32: Add driver entry points for a number of font functions.
[wine] / dlls / gdi32 / dibdrv / dc.c
1 /*
2  * DIB driver initialization and DC functions.
3  *
4  * Copyright 2011 Huw Davies
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <assert.h>
22
23 #include "gdi_private.h"
24 #include "dibdrv.h"
25
26 #include "wine/exception.h"
27 #include "wine/debug.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(dib);
30
31 static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff};
32 static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f};
33
34 static void calc_shift_and_len(DWORD mask, int *shift, int *len)
35 {
36     int s, l;
37
38     if(!mask)
39     {
40         *shift = *len = 0;
41         return;
42     }
43
44     s = 0;
45     while ((mask & 1) == 0)
46     {
47         mask >>= 1;
48         s++;
49     }
50     l = 0;
51     while ((mask & 1) == 1)
52     {
53         mask >>= 1;
54         l++;
55     }
56     *shift = s;
57     *len = l;
58 }
59
60 static void init_bit_fields(dib_info *dib, const DWORD *bit_fields)
61 {
62     dib->red_mask    = bit_fields[0];
63     dib->green_mask  = bit_fields[1];
64     dib->blue_mask   = bit_fields[2];
65     calc_shift_and_len(dib->red_mask,   &dib->red_shift,   &dib->red_len);
66     calc_shift_and_len(dib->green_mask, &dib->green_shift, &dib->green_len);
67     calc_shift_and_len(dib->blue_mask,  &dib->blue_shift,  &dib->blue_len);
68 }
69
70 BOOL init_dib_info(dib_info *dib, const BITMAPINFOHEADER *bi, const DWORD *bit_fields,
71                    RGBQUAD *color_table, int color_table_size, void *bits, enum dib_info_flags flags)
72 {
73     dib->bit_count    = bi->biBitCount;
74     dib->width        = bi->biWidth;
75     dib->height       = bi->biHeight;
76     dib->stride       = get_dib_stride( dib->width, dib->bit_count );
77     dib->bits.ptr     = bits;
78     dib->bits.is_copy = FALSE;
79     dib->bits.free    = NULL;
80     dib->bits.param   = NULL;
81     dib->flags        = flags;
82
83     if(dib->height < 0) /* top-down */
84     {
85         dib->height = -dib->height;
86     }
87     else /* bottom-up */
88     {
89         /* bits always points to the top-left corner and the stride is -ve */
90         dib->bits.ptr = (BYTE*)dib->bits.ptr + (dib->height - 1) * dib->stride;
91         dib->stride  = -dib->stride;
92     }
93
94     dib->funcs = &funcs_null;
95
96     switch(dib->bit_count)
97     {
98     case 32:
99         if(bi->biCompression == BI_RGB)
100             bit_fields = bit_fields_888;
101
102         init_bit_fields(dib, bit_fields);
103
104         if(dib->red_mask == 0xff0000 && dib->green_mask == 0x00ff00 && dib->blue_mask == 0x0000ff)
105             dib->funcs = &funcs_8888;
106         else
107             dib->funcs = &funcs_32;
108         break;
109
110     case 24:
111         dib->funcs = &funcs_24;
112         break;
113
114     case 16:
115         if(bi->biCompression == BI_RGB)
116             bit_fields = bit_fields_555;
117
118         init_bit_fields(dib, bit_fields);
119
120         if(dib->red_mask == 0x7c00 && dib->green_mask == 0x03e0 && dib->blue_mask == 0x001f)
121             dib->funcs = &funcs_555;
122         else
123             dib->funcs = &funcs_16;
124         break;
125
126     case 8:
127         dib->funcs = &funcs_8;
128         break;
129
130     case 4:
131         dib->funcs = &funcs_4;
132         break;
133
134     case 1:
135         dib->funcs = &funcs_1;
136         break;
137
138     default:
139         TRACE("bpp %d not supported, will forward to graphics driver.\n", dib->bit_count);
140         return FALSE;
141     }
142
143     if(color_table)
144     {
145         if (flags & private_color_table)
146         {
147             dib->color_table = HeapAlloc(GetProcessHeap(), 0, color_table_size * sizeof(dib->color_table[0]));
148             if(!dib->color_table) return FALSE;
149             memcpy(dib->color_table, color_table, color_table_size * sizeof(color_table[0]));
150         }
151         else
152             dib->color_table = color_table;
153         dib->color_table_size = color_table_size;
154     }
155     else
156     {
157         dib->color_table = NULL;
158         dib->color_table_size = 0;
159     }
160
161     return TRUE;
162 }
163
164 BOOL init_dib_info_from_packed(dib_info *dib, const BITMAPINFOHEADER *bi, WORD usage, HPALETTE palette)
165 {
166     DWORD *masks = NULL;
167     RGBQUAD *color_table = NULL, pal_table[256];
168     BYTE *ptr = (BYTE*)bi + bi->biSize;
169     int num_colors = get_dib_num_of_colors( (const BITMAPINFO *)bi );
170
171     if(bi->biCompression == BI_BITFIELDS)
172     {
173         masks = (DWORD *)ptr;
174         ptr += 3 * sizeof(DWORD);
175     }
176
177     if(num_colors)
178     {
179         if(usage == DIB_PAL_COLORS)
180         {
181             PALETTEENTRY entries[256];
182             const WORD *index = (const WORD*) ptr;
183             UINT i, count = GetPaletteEntries( palette, 0, num_colors, entries );
184             for (i = 0; i < num_colors; i++, index++)
185             {
186                 PALETTEENTRY *entry = &entries[*index % count];
187                 pal_table[i].rgbRed      = entry->peRed;
188                 pal_table[i].rgbGreen    = entry->peGreen;
189                 pal_table[i].rgbBlue     = entry->peBlue;
190                 pal_table[i].rgbReserved = 0;
191             }
192             color_table = pal_table;
193             ptr += num_colors * sizeof(WORD);
194         }
195         else
196         {
197             color_table = (RGBQUAD*)ptr;
198             ptr += num_colors * sizeof(*color_table);
199         }
200     }
201
202     return init_dib_info(dib, bi, masks, color_table, num_colors, ptr, private_color_table);
203 }
204
205 BOOL init_dib_info_from_bitmapinfo(dib_info *dib, const BITMAPINFO *info, void *bits, enum dib_info_flags flags)
206 {
207     unsigned int colors = get_dib_num_of_colors( info );
208     void *colorptr = (char *)&info->bmiHeader + info->bmiHeader.biSize;
209     const DWORD *bitfields = (info->bmiHeader.biCompression == BI_BITFIELDS) ? (DWORD *)colorptr : NULL;
210
211     return init_dib_info( dib, &info->bmiHeader, bitfields, colors ? colorptr : NULL, colors, bits, flags );
212 }
213
214 BOOL init_dib_info_from_bitmapobj(dib_info *dib, BITMAPOBJ *bmp, enum dib_info_flags flags)
215 {
216     if (!bmp->dib)
217     {
218         char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
219         BITMAPINFO *info = (BITMAPINFO *)buffer;
220
221         get_ddb_bitmapinfo( bmp, info );
222         return init_dib_info_from_bitmapinfo( dib, info, bmp->bitmap.bmBits,
223                                               flags | private_color_table );
224     }
225     return init_dib_info( dib, &bmp->dib->dsBmih, bmp->dib->dsBitfields,
226                           bmp->color_table, bmp->nb_colors, bmp->dib->dsBm.bmBits, flags );
227 }
228
229 static void clear_dib_info(dib_info *dib)
230 {
231     dib->color_table = NULL;
232     dib->bits.ptr    = NULL;
233     dib->bits.free   = NULL;
234     dib->bits.param  = NULL;
235 }
236
237 /**********************************************************************
238  *      free_dib_info
239  *
240  * Free the resources associated with a dib and optionally the bits
241  */
242 void free_dib_info(dib_info *dib)
243 {
244     if (dib->flags & private_color_table)
245         HeapFree(GetProcessHeap(), 0, dib->color_table);
246
247     if (dib->bits.free) dib->bits.free( &dib->bits );
248     clear_dib_info( dib );
249 }
250
251 void copy_dib_color_info(dib_info *dst, const dib_info *src)
252 {
253     dst->bit_count        = src->bit_count;
254     dst->red_mask         = src->red_mask;
255     dst->green_mask       = src->green_mask;
256     dst->blue_mask        = src->blue_mask;
257     dst->red_len          = src->red_len;
258     dst->green_len        = src->green_len;
259     dst->blue_len         = src->blue_len;
260     dst->red_shift        = src->red_shift;
261     dst->green_shift      = src->green_shift;
262     dst->blue_shift       = src->blue_shift;
263     dst->funcs            = src->funcs;
264     dst->color_table_size = src->color_table_size;
265     dst->color_table      = NULL;
266     dst->flags            = src->flags;
267     if(dst->color_table_size)
268     {
269         int size = dst->color_table_size * sizeof(dst->color_table[0]);
270         if (dst->flags & private_color_table)
271         {
272             dst->color_table = HeapAlloc(GetProcessHeap(), 0, size);
273             memcpy(dst->color_table, src->color_table, size);
274         }
275         else
276             dst->color_table = src->color_table;
277     }
278 }
279
280 DWORD convert_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bitblt_coords *src,
281                           const BITMAPINFO *dst_info, void *dst_bits, BOOL add_alpha )
282 {
283     dib_info src_dib, dst_dib;
284     DWORD ret;
285
286     if ( !init_dib_info_from_bitmapinfo( &src_dib, src_info, src_bits, 0 ) )
287         return ERROR_BAD_FORMAT;
288     if ( !init_dib_info_from_bitmapinfo( &dst_dib, dst_info, dst_bits, 0 ) )
289         return ERROR_BAD_FORMAT;
290
291     __TRY
292     {
293         dst_dib.funcs->convert_to( &dst_dib, &src_dib, &src->visrect );
294         ret = TRUE;
295     }
296     __EXCEPT_PAGE_FAULT
297     {
298         WARN( "invalid bits pointer %p\n", src_bits );
299         ret = FALSE;
300     }
301     __ENDTRY
302
303     /* We shared the color tables, so there's no need to free the dib_infos here */
304     if(!ret) return ERROR_BAD_FORMAT;
305
306     /* update coordinates, the destination rectangle is always stored at 0,0 */
307     src->x -= src->visrect.left;
308     src->y -= src->visrect.top;
309     offset_rect( &src->visrect, -src->visrect.left, -src->visrect.top );
310
311     if (add_alpha && dst_dib.funcs == &funcs_8888 && src_dib.funcs != &funcs_8888)
312     {
313         DWORD *pixel = dst_dib.bits.ptr;
314         int x, y;
315
316         for (y = src->visrect.top; y < src->visrect.bottom; y++, pixel += dst_dib.stride / 4)
317             for (x = src->visrect.left; x < src->visrect.right; x++)
318                 pixel[x] |= 0xff000000;
319     }
320
321     return ERROR_SUCCESS;
322 }
323
324 static void update_fg_colors( dibdrv_physdev *pdev )
325 {
326     pdev->pen_color   = get_pixel_color( pdev, pdev->pen_colorref,   TRUE );
327     pdev->brush_color = get_pixel_color( pdev, pdev->brush_colorref, TRUE );
328 }
329
330 static void update_masks( dibdrv_physdev *pdev, INT rop )
331 {
332     calc_and_xor_masks( rop, pdev->pen_color, &pdev->pen_and, &pdev->pen_xor );
333     update_brush_rop( pdev, rop );
334     if( GetBkMode( pdev->dev.hdc ) == OPAQUE )
335         calc_and_xor_masks( rop, pdev->bkgnd_color, &pdev->bkgnd_and, &pdev->bkgnd_xor );
336 }
337
338  /***********************************************************************
339  *           add_extra_clipping_region
340  *
341  * Temporarily add a region to the current clipping region.
342  * The returned region must be restored with restore_clipping_region.
343  */
344 HRGN add_extra_clipping_region( dibdrv_physdev *pdev, HRGN rgn )
345 {
346     HRGN ret, clip;
347
348     if (!(clip = CreateRectRgn( 0, 0, 0, 0 ))) return 0;
349     CombineRgn( clip, pdev->clip, rgn, RGN_AND );
350     ret = pdev->clip;
351     pdev->clip = clip;
352     return ret;
353 }
354
355 /***********************************************************************
356  *           restore_clipping_region
357  */
358 void restore_clipping_region( dibdrv_physdev *pdev, HRGN rgn )
359 {
360     if (!rgn) return;
361     DeleteObject( pdev->clip );
362     pdev->clip = rgn;
363 }
364
365 /**********************************************************************
366  *           dibdrv_CreateDC
367  */
368 static BOOL dibdrv_CreateDC( PHYSDEV *dev, LPCWSTR driver, LPCWSTR device,
369                              LPCWSTR output, const DEVMODEW *data )
370 {
371     dibdrv_physdev *pdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pdev) );
372
373     if (!pdev) return FALSE;
374     if (!(pdev->clip = CreateRectRgn(0, 0, 0, 0)))
375     {
376         HeapFree( GetProcessHeap(), 0, pdev );
377         return FALSE;
378     }
379     clear_dib_info(&pdev->dib);
380     clear_dib_info(&pdev->brush_dib);
381     push_dc_driver( dev, &pdev->dev, &dib_driver );
382     return TRUE;
383 }
384
385 /***********************************************************************
386  *           dibdrv_DeleteDC
387  */
388 static BOOL dibdrv_DeleteDC( PHYSDEV dev )
389 {
390     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
391     TRACE("(%p)\n", dev);
392     DeleteObject(pdev->clip);
393     free_pattern_brush(pdev);
394     free_dib_info(&pdev->dib);
395     HeapFree( GetProcessHeap(), 0, pdev );
396     return TRUE;
397 }
398
399 /***********************************************************************
400  *           dibdrv_SelectBitmap
401  */
402 static HBITMAP dibdrv_SelectBitmap( PHYSDEV dev, HBITMAP bitmap )
403 {
404     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectBitmap );
405     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
406     BITMAPOBJ *bmp = GDI_GetObjPtr( bitmap, OBJ_BITMAP );
407     TRACE("(%p, %p)\n", dev, bitmap);
408
409     if (!bmp) return 0;
410     assert(bmp->dib);
411
412     free_dib_info(&pdev->dib);
413     pdev->defer = 0;
414     if(!init_dib_info_from_bitmapobj(&pdev->dib, bmp, private_color_table))
415         pdev->defer |= DEFER_FORMAT;
416
417     GDI_ReleaseObj( bitmap );
418
419     return next->funcs->pSelectBitmap( next, bitmap );
420 }
421
422 /***********************************************************************
423  *           dibdrv_SetBkColor
424  */
425 static COLORREF dibdrv_SetBkColor( PHYSDEV dev, COLORREF color )
426 {
427     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetBkColor );
428     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
429
430     pdev->bkgnd_color = get_pixel_color( pdev, color, FALSE );
431
432     if( GetBkMode(dev->hdc) == OPAQUE )
433         calc_and_xor_masks( GetROP2(dev->hdc), pdev->bkgnd_color, &pdev->bkgnd_and, &pdev->bkgnd_xor );
434     else
435     {
436         pdev->bkgnd_and = ~0u;
437         pdev->bkgnd_xor = 0;
438     }
439
440     update_fg_colors( pdev ); /* Only needed in the 1 bpp case */
441
442     return next->funcs->pSetBkColor( next, color );
443 }
444
445 /***********************************************************************
446  *           dibdrv_SetBkMode
447  */
448 static INT dibdrv_SetBkMode( PHYSDEV dev, INT mode )
449 {
450     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetBkMode );
451     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
452
453     if( mode == OPAQUE )
454         calc_and_xor_masks( GetROP2(dev->hdc), pdev->bkgnd_color, &pdev->bkgnd_and, &pdev->bkgnd_xor );
455     else
456     {
457         pdev->bkgnd_and = ~0u;
458         pdev->bkgnd_xor = 0;
459     }
460
461     return next->funcs->pSetBkMode( next, mode );
462 }
463
464 /***********************************************************************
465  *           dibdrv_SetDeviceClipping
466  */
467 static void dibdrv_SetDeviceClipping( PHYSDEV dev, HRGN vis_rgn, HRGN clip_rgn )
468 {
469     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDeviceClipping );
470     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
471     TRACE("(%p, %p, %p)\n", dev, vis_rgn, clip_rgn);
472
473     CombineRgn( pdev->clip, vis_rgn, clip_rgn, clip_rgn ? RGN_AND : RGN_COPY );
474     return next->funcs->pSetDeviceClipping( next, vis_rgn, clip_rgn);
475 }
476
477 /***********************************************************************
478  *           dibdrv_SetDIBColorTable
479  */
480 static UINT dibdrv_SetDIBColorTable( PHYSDEV dev, UINT pos, UINT count, const RGBQUAD *colors )
481 {
482     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDIBColorTable );
483     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
484     TRACE("(%p, %d, %d, %p)\n", dev, pos, count, colors);
485
486     if( pdev->dib.color_table && pos < pdev->dib.color_table_size )
487     {
488         if( pos + count > pdev->dib.color_table_size ) count = pdev->dib.color_table_size - pos;
489         memcpy( pdev->dib.color_table + pos, colors, count * sizeof(RGBQUAD) );
490
491         pdev->bkgnd_color = get_pixel_color( pdev, GetBkColor( dev->hdc ), FALSE );
492         update_fg_colors( pdev );
493
494         update_masks( pdev, GetROP2( dev->hdc ) );
495     }
496     return next->funcs->pSetDIBColorTable( next, pos, count, colors );
497 }
498
499 /***********************************************************************
500  *           dibdrv_SetROP2
501  */
502 static INT dibdrv_SetROP2( PHYSDEV dev, INT rop )
503 {
504     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetROP2 );
505     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
506
507     update_masks( pdev, rop );
508
509     return next->funcs->pSetROP2( next, rop );
510 }
511
512 const struct gdi_dc_funcs dib_driver =
513 {
514     NULL,                               /* pAbortDoc */
515     NULL,                               /* pAbortPath */
516     dibdrv_AlphaBlend,                  /* pAlphaBlend */
517     NULL,                               /* pAngleArc */
518     NULL,                               /* pArc */
519     NULL,                               /* pArcTo */
520     NULL,                               /* pBeginPath */
521     dibdrv_BlendImage,                  /* pBlendImage */
522     NULL,                               /* pChoosePixelFormat */
523     NULL,                               /* pChord */
524     NULL,                               /* pCloseFigure */
525     NULL,                               /* pCreateBitmap */
526     NULL,                               /* pCreateCompatibleDC */
527     dibdrv_CreateDC,                    /* pCreateDC */
528     NULL,                               /* pCreateDIBSection */
529     NULL,                               /* pDeleteBitmap */
530     dibdrv_DeleteDC,                    /* pDeleteDC */
531     NULL,                               /* pDeleteObject */
532     NULL,                               /* pDescribePixelFormat */
533     NULL,                               /* pDeviceCapabilities */
534     NULL,                               /* pEllipse */
535     NULL,                               /* pEndDoc */
536     NULL,                               /* pEndPage */
537     NULL,                               /* pEndPath */
538     NULL,                               /* pEnumFonts */
539     NULL,                               /* pEnumICMProfiles */
540     NULL,                               /* pExcludeClipRect */
541     NULL,                               /* pExtDeviceMode */
542     NULL,                               /* pExtEscape */
543     NULL,                               /* pExtFloodFill */
544     NULL,                               /* pExtSelectClipRgn */
545     NULL,                               /* pExtTextOut */
546     NULL,                               /* pFillPath */
547     NULL,                               /* pFillRgn */
548     NULL,                               /* pFlattenPath */
549     NULL,                               /* pFontIsLinked */
550     NULL,                               /* pFrameRgn */
551     NULL,                               /* pGdiComment */
552     NULL,                               /* pGdiRealizationInfo */
553     NULL,                               /* pGetCharABCWidths */
554     NULL,                               /* pGetCharABCWidthsI */
555     NULL,                               /* pGetCharWidth */
556     NULL,                               /* pGetDeviceCaps */
557     NULL,                               /* pGetDeviceGammaRamp */
558     NULL,                               /* pGetFontData */
559     NULL,                               /* pGetFontUnicodeRanges */
560     NULL,                               /* pGetGlyphIndices */
561     NULL,                               /* pGetGlyphOutline */
562     NULL,                               /* pGetICMProfile */
563     dibdrv_GetImage,                    /* pGetImage */
564     NULL,                               /* pGetKerningPairs */
565     NULL,                               /* pGetNearestColor */
566     NULL,                               /* pGetOutlineTextMetrics */
567     dibdrv_GetPixel,                    /* pGetPixel */
568     NULL,                               /* pGetPixelFormat */
569     NULL,                               /* pGetSystemPaletteEntries */
570     NULL,                               /* pGetTextCharsetInfo */
571     NULL,                               /* pGetTextExtentExPoint */
572     NULL,                               /* pGetTextExtentExPointI */
573     NULL,                               /* pGetTextFace */
574     NULL,                               /* pGetTextMetrics */
575     NULL,                               /* pIntersectClipRect */
576     NULL,                               /* pInvertRgn */
577     dibdrv_LineTo,                      /* pLineTo */
578     NULL,                               /* pModifyWorldTransform */
579     NULL,                               /* pMoveTo */
580     NULL,                               /* pOffsetClipRgn */
581     NULL,                               /* pOffsetViewportOrg */
582     NULL,                               /* pOffsetWindowOrg */
583     dibdrv_PaintRgn,                    /* pPaintRgn */
584     dibdrv_PatBlt,                      /* pPatBlt */
585     NULL,                               /* pPie */
586     NULL,                               /* pPolyBezier */
587     NULL,                               /* pPolyBezierTo */
588     NULL,                               /* pPolyDraw */
589     NULL,                               /* pPolyPolygon */
590     dibdrv_PolyPolyline,                /* pPolyPolyline */
591     NULL,                               /* pPolygon */
592     dibdrv_Polyline,                    /* pPolyline */
593     NULL,                               /* pPolylineTo */
594     dibdrv_PutImage,                    /* pPutImage */
595     NULL,                               /* pRealizeDefaultPalette */
596     NULL,                               /* pRealizePalette */
597     dibdrv_Rectangle,                   /* pRectangle */
598     NULL,                               /* pResetDC */
599     NULL,                               /* pRestoreDC */
600     NULL,                               /* pRoundRect */
601     NULL,                               /* pSaveDC */
602     NULL,                               /* pScaleViewportExt */
603     NULL,                               /* pScaleWindowExt */
604     dibdrv_SelectBitmap,                /* pSelectBitmap */
605     dibdrv_SelectBrush,                 /* pSelectBrush */
606     NULL,                               /* pSelectClipPath */
607     NULL,                               /* pSelectFont */
608     NULL,                               /* pSelectPalette */
609     dibdrv_SelectPen,                   /* pSelectPen */
610     NULL,                               /* pSetArcDirection */
611     dibdrv_SetBkColor,                  /* pSetBkColor */
612     dibdrv_SetBkMode,                   /* pSetBkMode */
613     dibdrv_SetDCBrushColor,             /* pSetDCBrushColor */
614     dibdrv_SetDCPenColor,               /* pSetDCPenColor */
615     dibdrv_SetDIBColorTable,            /* pSetDIBColorTable */
616     NULL,                               /* pSetDIBitsToDevice */
617     dibdrv_SetDeviceClipping,           /* pSetDeviceClipping */
618     NULL,                               /* pSetDeviceGammaRamp */
619     NULL,                               /* pSetLayout */
620     NULL,                               /* pSetMapMode */
621     NULL,                               /* pSetMapperFlags */
622     dibdrv_SetPixel,                    /* pSetPixel */
623     NULL,                               /* pSetPixelFormat */
624     NULL,                               /* pSetPolyFillMode */
625     dibdrv_SetROP2,                     /* pSetROP2 */
626     NULL,                               /* pSetRelAbs */
627     NULL,                               /* pSetStretchBltMode */
628     NULL,                               /* pSetTextAlign */
629     NULL,                               /* pSetTextCharacterExtra */
630     NULL,                               /* pSetTextColor */
631     NULL,                               /* pSetTextJustification */
632     NULL,                               /* pSetViewportExt */
633     NULL,                               /* pSetViewportOrg */
634     NULL,                               /* pSetWindowExt */
635     NULL,                               /* pSetWindowOrg */
636     NULL,                               /* pSetWorldTransform */
637     NULL,                               /* pStartDoc */
638     NULL,                               /* pStartPage */
639     dibdrv_StretchBlt,                  /* pStretchBlt */
640     NULL,                               /* pStretchDIBits */
641     NULL,                               /* pStrokeAndFillPath */
642     NULL,                               /* pStrokePath */
643     NULL,                               /* pSwapBuffers */
644     NULL,                               /* pUnrealizePalette */
645     NULL,                               /* pWidenPath */
646     NULL,                               /* pwglCopyContext */
647     NULL,                               /* pwglCreateContext */
648     NULL,                               /* pwglCreateContextAttribsARB */
649     NULL,                               /* pwglDeleteContext */
650     NULL,                               /* pwglGetPbufferDCARB */
651     NULL,                               /* pwglGetProcAddress */
652     NULL,                               /* pwglMakeContextCurrentARB */
653     NULL,                               /* pwglMakeCurrent */
654     NULL,                               /* pwglSetPixelFormatWINE */
655     NULL,                               /* pwglShareLists */
656     NULL,                               /* pwglUseFontBitmapsA */
657     NULL                                /* pwglUseFontBitmapsW */
658 };