| /* |
| * DIB driver graphics operations. |
| * |
| * Copyright 2011 Huw Davies |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <assert.h> |
| #include "gdi_private.h" |
| #include "dibdrv.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(dib); |
| |
| static RECT get_device_rect( HDC hdc, int left, int top, int right, int bottom, BOOL rtl_correction ) |
| { |
| RECT rect; |
| |
| rect.left = left; |
| rect.top = top; |
| rect.right = right; |
| rect.bottom = bottom; |
| if (rtl_correction && GetLayout( hdc ) & LAYOUT_RTL) |
| { |
| /* shift the rectangle so that the right border is included after mirroring */ |
| /* it would be more correct to do this after LPtoDP but that's not what Windows does */ |
| rect.left--; |
| rect.right--; |
| } |
| LPtoDP( hdc, (POINT *)&rect, 2 ); |
| if (rect.left > rect.right) |
| { |
| int tmp = rect.left; |
| rect.left = rect.right; |
| rect.right = tmp; |
| } |
| if (rect.top > rect.bottom) |
| { |
| int tmp = rect.top; |
| rect.top = rect.bottom; |
| rect.bottom = tmp; |
| } |
| return rect; |
| } |
| |
| /* Intensities of the 17 glyph levels when drawn with text component of 0xff on a |
| black bkgnd. [A log-log plot of these data gives: y = 77.05 * x^0.4315]. */ |
| static const BYTE ramp[17] = |
| { |
| 0, 0x4d, 0x68, 0x7c, |
| 0x8c, 0x9a, 0xa7, 0xb2, |
| 0xbd, 0xc7, 0xd0, 0xd9, |
| 0xe1, 0xe9, 0xf0, 0xf8, |
| 0xff |
| }; |
| |
| /* For a give text-color component and a glyph level, calculate the |
| range of dst intensities, the min/max corresponding to 0/0xff bkgnd |
| components respectively. |
| |
| The minimum is a linear interpolation between 0 and the value in |
| the ramp table. |
| |
| The maximum is a linear interpolation between the value from the |
| ramp table read in reverse and 0xff. |
| |
| To find the resulting pixel intensity, we note that if the text and |
| bkgnd intensities are the same then the result must be that |
| intensity. Otherwise we linearly interpolate between either the |
| min or the max value and this intermediate value depending on which |
| side of the inequality we lie. |
| */ |
| |
| static inline void get_range( BYTE aa, DWORD text_comp, BYTE *min_comp, BYTE *max_comp ) |
| { |
| *min_comp = (ramp[aa] * text_comp) / 0xff; |
| *max_comp = ramp[16 - aa] + ((0xff - ramp[16 - aa]) * text_comp) / 0xff; |
| } |
| |
| static inline void get_aa_ranges( COLORREF col, struct intensity_range intensities[17] ) |
| { |
| int i; |
| |
| for (i = 0; i < 17; i++) |
| { |
| get_range( i, GetRValue(col), &intensities[i].r_min, &intensities[i].r_max ); |
| get_range( i, GetGValue(col), &intensities[i].g_min, &intensities[i].g_max ); |
| get_range( i, GetBValue(col), &intensities[i].b_min, &intensities[i].b_max ); |
| } |
| } |
| |
| void update_aa_ranges( dibdrv_physdev *pdev ) |
| { |
| COLORREF text = pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pdev->text_color ); |
| get_aa_ranges( text, pdev->glyph_intensities ); |
| } |
| |
| /********************************************************************** |
| * get_text_bkgnd_masks |
| * |
| * See the comment above get_pen_bkgnd_masks |
| */ |
| static inline void get_text_bkgnd_masks( const dibdrv_physdev *pdev, rop_mask *mask ) |
| { |
| mask->and = 0; |
| |
| if (pdev->dib.bit_count != 1) |
| mask->xor = pdev->bkgnd_color; |
| else |
| { |
| mask->xor = ~pdev->text_color; |
| if (GetTextColor( pdev->dev.hdc ) == GetBkColor( pdev->dev.hdc )) |
| mask->xor = pdev->text_color; |
| } |
| } |
| |
| static void draw_glyph( dibdrv_physdev *pdev, const POINT *origin, const GLYPHMETRICS *metrics, |
| const struct gdi_image_bits *image ) |
| { |
| const WINEREGION *clip = get_wine_region( pdev->clip ); |
| int i; |
| RECT rect, clipped_rect; |
| POINT src_origin; |
| dib_info glyph_dib; |
| |
| glyph_dib.bit_count = 8; |
| glyph_dib.width = metrics->gmBlackBoxX; |
| glyph_dib.height = metrics->gmBlackBoxY; |
| glyph_dib.stride = get_dib_stride( metrics->gmBlackBoxX, 8 ); |
| glyph_dib.bits = *image; |
| |
| rect.left = origin->x + metrics->gmptGlyphOrigin.x; |
| rect.top = origin->y - metrics->gmptGlyphOrigin.y; |
| rect.right = rect.left + metrics->gmBlackBoxX; |
| rect.bottom = rect.top + metrics->gmBlackBoxY; |
| |
| for (i = 0; i < clip->numRects; i++) |
| { |
| if (intersect_rect( &clipped_rect, &rect, clip->rects + i )) |
| { |
| src_origin.x = clipped_rect.left - rect.left; |
| src_origin.y = clipped_rect.top - rect.top; |
| |
| pdev->dib.funcs->draw_glyph( &pdev->dib, &clipped_rect, &glyph_dib, &src_origin, |
| pdev->text_color, pdev->glyph_intensities ); |
| } |
| } |
| |
| release_wine_region( pdev->clip ); |
| } |
| |
| static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}; |
| static const int padding[4] = {0, 3, 2, 1}; |
| |
| /*********************************************************************** |
| * get_glyph_bitmap |
| * |
| * Retrieve a 17-level bitmap for the appropiate glyph. |
| * |
| * For non-antialiased bitmaps convert them to the 17-level format |
| * using only values 0 or 16. |
| */ |
| static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT aa_flags, GLYPHMETRICS *metrics, |
| struct gdi_image_bits *image ) |
| { |
| UINT ggo_flags = aa_flags | GGO_GLYPH_INDEX; |
| static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} }; |
| UINT indices[3] = {0, 0, 0x20}; |
| int i, x, y; |
| DWORD ret, size; |
| BYTE *buf, *dst, *src; |
| int pad, stride; |
| |
| image->ptr = NULL; |
| image->is_copy = FALSE; |
| image->free = free_heap_bits; |
| image->param = NULL; |
| |
| indices[0] = index; |
| |
| for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++) |
| { |
| index = indices[i]; |
| ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, 0, NULL, &identity ); |
| if (ret != GDI_ERROR) break; |
| } |
| |
| if (ret == GDI_ERROR) return ERROR_NOT_FOUND; |
| if (!ret) return ERROR_SUCCESS; /* empty glyph */ |
| |
| /* We'll convert non-antialiased 1-bpp bitmaps to 8-bpp, so these sizes relate to 8-bpp */ |
| pad = padding[ metrics->gmBlackBoxX % 4 ]; |
| stride = get_dib_stride( metrics->gmBlackBoxX, 8 ); |
| size = metrics->gmBlackBoxY * stride; |
| |
| buf = HeapAlloc( GetProcessHeap(), 0, size ); |
| if (!buf) return ERROR_OUTOFMEMORY; |
| |
| ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, size, buf, &identity ); |
| if (ret == GDI_ERROR) |
| { |
| HeapFree( GetProcessHeap(), 0, buf ); |
| return ERROR_NOT_FOUND; |
| } |
| |
| if (aa_flags == GGO_BITMAP) |
| { |
| for (y = metrics->gmBlackBoxY - 1; y >= 0; y--) |
| { |
| src = buf + y * get_dib_stride( metrics->gmBlackBoxX, 1 ); |
| dst = buf + y * stride; |
| |
| if (pad) memset( dst + metrics->gmBlackBoxX, 0, pad ); |
| |
| for (x = metrics->gmBlackBoxX - 1; x >= 0; x--) |
| dst[x] = (src[x / 8] & masks[x % 8]) ? 0x10 : 0; |
| } |
| } |
| else if (pad) |
| { |
| for (y = 0, dst = buf; y < metrics->gmBlackBoxY; y++, dst += stride) |
| memset( dst + metrics->gmBlackBoxX, 0, pad ); |
| } |
| |
| image->ptr = buf; |
| return ERROR_SUCCESS; |
| } |
| |
| BOOL render_aa_text_bitmapinfo( HDC hdc, BITMAPINFO *info, struct gdi_image_bits *bits, |
| struct bitblt_coords *src, INT x, INT y, UINT flags, |
| UINT aa_flags, LPCWSTR str, UINT count, const INT *dx ) |
| { |
| dib_info dib; |
| UINT i; |
| DWORD err; |
| BOOL got_pixel; |
| COLORREF fg, bg; |
| DWORD fg_pixel, bg_pixel; |
| struct intensity_range glyph_intensities[17]; |
| |
| assert( info->bmiHeader.biBitCount > 8 ); /* mono and indexed formats don't support anti-aliasing */ |
| |
| if (!init_dib_info_from_bitmapinfo( &dib, info, bits->ptr, 0 )) return FALSE; |
| |
| fg = make_rgb_colorref( hdc, &dib, GetTextColor( hdc ), &got_pixel, &fg_pixel); |
| if (!got_pixel) fg_pixel = dib.funcs->colorref_to_pixel( &dib, fg ); |
| |
| get_aa_ranges( fg, glyph_intensities ); |
| |
| if (flags & ETO_OPAQUE) |
| { |
| rop_mask bkgnd_color; |
| |
| bg = make_rgb_colorref( hdc, &dib, GetBkColor( hdc ), &got_pixel, &bg_pixel); |
| if (!got_pixel) bg_pixel = dib.funcs->colorref_to_pixel( &dib, bg ); |
| |
| bkgnd_color.and = 0; |
| bkgnd_color.xor = bg_pixel; |
| solid_rects( &dib, 1, &src->visrect, &bkgnd_color, 0 ); |
| } |
| |
| for (i = 0; i < count; i++) |
| { |
| GLYPHMETRICS metrics; |
| struct gdi_image_bits image; |
| |
| err = get_glyph_bitmap( hdc, (UINT)str[i], aa_flags, &metrics, &image ); |
| if (err) continue; |
| |
| if (image.ptr) |
| { |
| RECT rect, clipped_rect; |
| POINT src_origin; |
| dib_info glyph_dib; |
| |
| glyph_dib.bit_count = 8; |
| glyph_dib.width = metrics.gmBlackBoxX; |
| glyph_dib.height = metrics.gmBlackBoxY; |
| glyph_dib.stride = get_dib_stride( metrics.gmBlackBoxX, 8 ); |
| glyph_dib.bits = image; |
| |
| rect.left = x + metrics.gmptGlyphOrigin.x; |
| rect.top = y - metrics.gmptGlyphOrigin.y; |
| rect.right = rect.left + metrics.gmBlackBoxX; |
| rect.bottom = rect.top + metrics.gmBlackBoxY; |
| |
| if (intersect_rect( &clipped_rect, &rect, &src->visrect )) |
| { |
| src_origin.x = clipped_rect.left - rect.left; |
| src_origin.y = clipped_rect.top - rect.top; |
| |
| dib.funcs->draw_glyph( &dib, &clipped_rect, &glyph_dib, &src_origin, |
| fg_pixel, glyph_intensities ); |
| } |
| } |
| if (image.free) image.free( &image ); |
| |
| if (dx) |
| { |
| if (flags & ETO_PDY) |
| { |
| x += dx[ i * 2 ]; |
| y += dx[ i * 2 + 1]; |
| } |
| else |
| x += dx[ i ]; |
| } |
| else |
| { |
| x += metrics.gmCellIncX; |
| y += metrics.gmCellIncY; |
| } |
| } |
| free_dib_info( &dib ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_ExtTextOut |
| */ |
| BOOL dibdrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, |
| const RECT *rect, LPCWSTR str, UINT count, const INT *dx ) |
| { |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| UINT aa_flags, i; |
| POINT origin; |
| DWORD err; |
| HRGN saved_clip = NULL; |
| |
| if (flags & ETO_OPAQUE) |
| { |
| rop_mask bkgnd_color; |
| get_text_bkgnd_masks( pdev, &bkgnd_color ); |
| solid_rects( &pdev->dib, 1, rect, &bkgnd_color, pdev->clip ); |
| } |
| |
| if (count == 0) return TRUE; |
| |
| if (flags & ETO_CLIPPED) |
| { |
| HRGN clip = CreateRectRgnIndirect( rect ); |
| saved_clip = add_extra_clipping_region( pdev, clip ); |
| DeleteObject( clip ); |
| } |
| |
| aa_flags = get_font_aa_flags( dev->hdc ); |
| origin.x = x; |
| origin.y = y; |
| for (i = 0; i < count; i++) |
| { |
| GLYPHMETRICS metrics; |
| struct gdi_image_bits image; |
| |
| err = get_glyph_bitmap( dev->hdc, (UINT)str[i], aa_flags, &metrics, &image ); |
| if (err) continue; |
| |
| if (image.ptr) draw_glyph( pdev, &origin, &metrics, &image ); |
| if (image.free) image.free( &image ); |
| |
| if (dx) |
| { |
| if (flags & ETO_PDY) |
| { |
| origin.x += dx[ i * 2 ]; |
| origin.y += dx[ i * 2 + 1]; |
| } |
| else |
| origin.x += dx[ i ]; |
| } |
| else |
| { |
| origin.x += metrics.gmCellIncX; |
| origin.y += metrics.gmCellIncY; |
| } |
| } |
| |
| restore_clipping_region( pdev, saved_clip ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_GetPixel |
| */ |
| COLORREF dibdrv_GetPixel( PHYSDEV dev, INT x, INT y ) |
| { |
| dibdrv_physdev *pdev = get_dibdrv_pdev( dev ); |
| POINT pt; |
| DWORD pixel; |
| |
| TRACE( "(%p, %d, %d)\n", dev, x, y ); |
| |
| pt.x = x; |
| pt.y = y; |
| LPtoDP( dev->hdc, &pt, 1 ); |
| |
| if (pt.x < 0 || pt.x >= pdev->dib.width || |
| pt.y < 0 || pt.y >= pdev->dib.height) |
| return CLR_INVALID; |
| |
| pixel = pdev->dib.funcs->get_pixel( &pdev->dib, &pt ); |
| return pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pixel ); |
| } |
| |
| /*********************************************************************** |
| * dibdrv_LineTo |
| */ |
| BOOL dibdrv_LineTo( PHYSDEV dev, INT x, INT y ) |
| { |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pLineTo ); |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| POINT pts[2]; |
| |
| GetCurrentPositionEx(dev->hdc, pts); |
| pts[1].x = x; |
| pts[1].y = y; |
| |
| LPtoDP(dev->hdc, pts, 2); |
| |
| reset_dash_origin(pdev); |
| |
| if(defer_pen(pdev) || !pdev->pen_lines(pdev, 2, pts, FALSE)) |
| return next->funcs->pLineTo( next, x, y ); |
| |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * get_rop2_from_rop |
| * |
| * Returns the binary rop that is equivalent to the provided ternary rop |
| * if the src bits are ignored. |
| */ |
| static inline INT get_rop2_from_rop(INT rop) |
| { |
| return (((rop >> 18) & 0x0c) | ((rop >> 16) & 0x03)) + 1; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_PatBlt |
| */ |
| BOOL dibdrv_PatBlt( PHYSDEV dev, struct bitblt_coords *dst, DWORD rop ) |
| { |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPatBlt ); |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| INT rop2 = get_rop2_from_rop(rop); |
| BOOL done; |
| |
| TRACE("(%p, %d, %d, %d, %d, %06x)\n", dev, dst->x, dst->y, dst->width, dst->height, rop); |
| |
| if(defer_brush(pdev)) |
| return next->funcs->pPatBlt( next, dst, rop ); |
| |
| update_brush_rop( pdev, rop2 ); |
| |
| done = brush_rects( pdev, 1, &dst->visrect ); |
| |
| update_brush_rop( pdev, GetROP2(dev->hdc) ); |
| |
| if(!done) |
| return next->funcs->pPatBlt( next, dst, rop ); |
| |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_PaintRgn |
| */ |
| BOOL dibdrv_PaintRgn( PHYSDEV dev, HRGN rgn ) |
| { |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPaintRgn ); |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| const WINEREGION *region; |
| int i; |
| RECT rect; |
| |
| TRACE("%p, %p\n", dev, rgn); |
| |
| if(defer_brush(pdev)) return next->funcs->pPaintRgn( next, rgn ); |
| |
| region = get_wine_region( rgn ); |
| if(!region) return FALSE; |
| |
| for(i = 0; i < region->numRects; i++) |
| { |
| rect = get_device_rect( dev->hdc, region->rects[i].left, region->rects[i].top, |
| region->rects[i].right, region->rects[i].bottom, FALSE ); |
| brush_rects( pdev, 1, &rect ); |
| } |
| |
| release_wine_region( rgn ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_PolyPolyline |
| */ |
| BOOL dibdrv_PolyPolyline( PHYSDEV dev, const POINT* pt, const DWORD* counts, DWORD polylines ) |
| { |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPolyPolyline ); |
| DWORD max_points = 0, i; |
| POINT *points; |
| |
| if (defer_pen( pdev )) return next->funcs->pPolyPolyline( next, pt, counts, polylines ); |
| |
| for (i = 0; i < polylines; i++) max_points = max( counts[i], max_points ); |
| |
| points = HeapAlloc( GetProcessHeap(), 0, max_points * sizeof(*pt) ); |
| if (!points) return FALSE; |
| |
| for (i = 0; i < polylines; i++) |
| { |
| memcpy( points, pt, counts[i] * sizeof(*pt) ); |
| pt += counts[i]; |
| LPtoDP( dev->hdc, points, counts[i] ); |
| |
| reset_dash_origin( pdev ); |
| pdev->pen_lines( pdev, counts[i], points, FALSE ); |
| } |
| |
| HeapFree( GetProcessHeap(), 0, points ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_Polyline |
| */ |
| BOOL dibdrv_Polyline( PHYSDEV dev, const POINT* pt, INT count ) |
| { |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPolyline ); |
| POINT *points; |
| |
| if (defer_pen( pdev )) return next->funcs->pPolyline( next, pt, count ); |
| |
| points = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pt) ); |
| if (!points) return FALSE; |
| |
| memcpy( points, pt, count * sizeof(*pt) ); |
| LPtoDP( dev->hdc, points, count ); |
| |
| reset_dash_origin( pdev ); |
| pdev->pen_lines( pdev, count, points, FALSE ); |
| |
| HeapFree( GetProcessHeap(), 0, points ); |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_Rectangle |
| */ |
| BOOL dibdrv_Rectangle( PHYSDEV dev, INT left, INT top, INT right, INT bottom ) |
| { |
| PHYSDEV next = GET_NEXT_PHYSDEV( dev, pRectangle ); |
| dibdrv_physdev *pdev = get_dibdrv_pdev(dev); |
| RECT rect = get_device_rect( dev->hdc, left, top, right, bottom, TRUE ); |
| POINT pts[4]; |
| |
| TRACE("(%p, %d, %d, %d, %d)\n", dev, left, top, right, bottom); |
| |
| if(rect.left == rect.right || rect.top == rect.bottom) return TRUE; |
| |
| if(defer_pen(pdev) || defer_brush(pdev)) |
| return next->funcs->pRectangle( next, left, top, right, bottom ); |
| |
| reset_dash_origin(pdev); |
| |
| /* 4 pts going anti-clockwise starting from top-right */ |
| pts[0].x = pts[3].x = rect.right - 1; |
| pts[0].y = pts[1].y = rect.top; |
| pts[1].x = pts[2].x = rect.left; |
| pts[2].y = pts[3].y = rect.bottom - 1; |
| |
| pdev->pen_lines(pdev, 4, pts, TRUE); |
| |
| /* FIXME: Will need updating when we support wide pens */ |
| |
| rect.left += 1; |
| rect.top += 1; |
| rect.right -= 1; |
| rect.bottom -= 1; |
| |
| brush_rects(pdev, 1, &rect); |
| |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * dibdrv_SetPixel |
| */ |
| COLORREF dibdrv_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color ) |
| { |
| dibdrv_physdev *pdev = get_dibdrv_pdev( dev ); |
| int i; |
| POINT pt; |
| DWORD pixel; |
| const WINEREGION *clip = get_wine_region( pdev->clip ); |
| |
| TRACE( "(%p, %d, %d, %08x)\n", dev, x, y, color ); |
| |
| pt.x = x; |
| pt.y = y; |
| LPtoDP( dev->hdc, &pt, 1 ); |
| |
| /* SetPixel doesn't do the 1bpp massaging like other fg colors */ |
| pixel = get_pixel_color( pdev, color, FALSE ); |
| color = pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pixel ); |
| |
| for (i = 0; i < clip->numRects; i++) |
| { |
| if (pt_in_rect( clip->rects + i, pt )) |
| { |
| RECT rect; |
| rect.left = pt.x; |
| rect.top = pt.y; |
| rect.right = rect.left + 1; |
| rect.bottom = rect.top + 1; |
| |
| pdev->dib.funcs->solid_rects( &pdev->dib, 1, &rect, 0, pixel ); |
| break; |
| } |
| } |
| |
| release_wine_region( pdev->clip ); |
| return color; |
| } |
