GdiUtil.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: GDI utility functions (Migrated from UtilFunc.cpp)
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/Common.h>
#include <uLib/UtilFunc.h>
#include <uLib/Debug.h>
#include <uLib/StrFunc.h>

#if 0 // Lab area..
#endif // Lab area..

#if defined(_MSC_VER)
  #define USE_GRADIENTCOLOR_ASM  1  // Use _gradcolor.asm
  #define USE_SCALECOLOR_ASM     0  // Use C++ fallback implementation
#else
  #define USE_GRADIENTCOLOR_ASM  0  // Use C++ fallback implementation
  #define USE_SCALECOLOR_ASM     0  // Use C++ fallback implementation
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// WinGDI functions
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// A considerably easier way to create a font instance.

HFONT WINAPI CreateFontEx( CSTR Typeface, int Points, int Weight, DWORD Charset, DWORD Quality )
{
    Points = ScreenFontHeight( Points );
    return ::CreateFont( Points, 0,0,0, Weight, 0,0,0, Charset,
        OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, Quality,
        FF_DONTCARE, Typeface
        );
}

// Compute font height to use in LOGFONT.lfHeight from size in Points.
// If RefDC is given, compute for that DC, else for the screen.
// Note: These two APIs use each other (in a careful manner).

int WINAPI FontHeight( HDC hdc, int Points ) // Uses ScreenFontHeight
{
    int height; // 1 typographic point == 1/72'th of an inch.

    if (!hdc) height = ScreenFontHeight( Points ); // Fwd recursion !
    else height = -MulDiv( Points, GetDeviceCaps( hdc, LOGPIXELSY ),72 );
    return height;
}

int WINAPI ScreenFontHeight( WORD Points ) // Uses FontHeight
{
    int height = 0;
    HDC dc = GetDesktopDC();
    if (dc)
    {
        height = FontHeight( dc, Points );
        ReleaseDesktopDC( dc );
    }
    return height;
}

// GetWndFont - Get the current font for hWnd..

HFONT WINAPI GetWndFont( HWND hWnd, LOGFONT* pLogFont )
{
    LOGFONT lf;
    HDC hdc = GetDC( hWnd );
    HFONT hfont = GetCurrentFontEx( hdc, &lf );
    ReleaseDC( hWnd, hdc );
    if (pLogFont) *pLogFont = lf;
    return hfont;
}

// WhereXY - Get the current drawing position in HDC

POINT WINAPI WhereXY( HDC dc )
{
    POINT xy = {0,0};
    if (MoveToEx( dc, 0,0, &xy )) // Dummy move to get the current XY pos
        MoveToEx( dc, xy.x, xy.y, NULL ); // Undo the move
    return xy;
}

// Release dc and return NULL if successful.

HDC WINAPI ReleaseWndDC( HDC dc )
{
    HWND wnd = WindowFromDC( dc );
    if (wnd && ReleaseDC( wnd, dc )) dc = (HDC)NULL;
    return dc;
}

// Desktop DC

HDC WINAPI GetDesktopDC()
{
    return GetDC( GetDesktopWindow() );
}

void WINAPI ReleaseDesktopDC( HDC hDeskDC )
{
    ReleaseDC( GetDesktopWindow(), hDeskDC );
}

// Create screen compatible memory DC and bitmap.

HDC WINAPI CreateMemoryDC( UINT cx, UINT cy, HBITMAP* pOldBmp )
{
    HDC hdc = GetDesktopDC();
    HDC hMemDC = CreateCompatibleDC( hdc );
    if (cx && cy && hMemDC)
    {
        HBITMAP hBmp = CreateCompatibleBitmap( hdc, cx, cy );
        HBITMAP oldBmp = SelectBitmap( hMemDC, hBmp );
        if (pOldBmp) *pOldBmp = oldBmp;
    }
    ReleaseDesktopDC( hdc );
    return hMemDC;
}

// Delete memory DC and return it's drawing bitmap.
// PONDER: Rename DeleteMemoryDC to DoneMemoryDC..?

HBITMAP WINAPI DeleteMemoryDC( HDC hMemDC, HBITMAP oldBmp )
{
    HBITMAP memBmp = (HBITMAP) GetCurrentObject( hMemDC, OBJ_BITMAP );
    if (oldBmp)
    {
        oldBmp = SelectBitmap( hMemDC, oldBmp );
        // Alert programmer if f.ex. drawing bitmap was deselected after CreateMemoryDC..
        if (oldBmp != memBmp) DPrint( DP_WARNING, _F("oldBmp != memBmp selected in hMemDC.\n") );
    }
    DeleteDC( hMemDC );
    return memBmp;
}

// Get logical pixels per inch for the screen

void WINAPI GetScreenLPI( PPOINT pLpi )
{
    HDC hdc = GetDesktopDC();
    pLpi->x = GetDeviceCaps( hdc, LOGPIXELSX );
    pLpi->y = GetDeviceCaps( hdc, LOGPIXELSY );
    ReleaseDesktopDC( hdc );
}

// Create a bitmap from a given icon

#if 1 // Revised to use the new CreateMemoryDC() and DeleteMemoryDC().

HBITMAP WINAPI CreateIconBitmap( HICON hIcon, HBRUSH hbrBkg, UINT cx, UINT cy )
{
    RECT r;
    HBITMAP orgBmp;
    if (!cx) cx = SYSMET( CXSMICON );
    if (!cy) cy = SYSMET( CYSMICON );
    if (!hbrBkg) hbrBkg = SYSHBR( 3DFACE );
    HDC mdc = CreateMemoryDC( cx, cy, &orgBmp );

    SetRect( &r, 0,0, cx,cy );
    FillRect( mdc, &r, hbrBkg );
    DrawIconEx( mdc, 0,0, hIcon, cx,cy, 0, NULL, DI_NORMAL );

    return DeleteMemoryDC( mdc, orgBmp );
}

#else // Original, plain Win32
HBITMAP WINAPI CreateIconBitmap( HICON hIcon, HBRUSH hbrBkg, UINT cx, UINT cy )
{
    if (!cx) cx = SYSMET( CXSMICON );
    if (!cy) cy = SYSMET( CYSMICON );
    RECT r;
    HDC hdc = GetDesktopDC();
    HDC mdc = CreateCompatibleDC( hdc );
    HBITMAP mbm = CreateCompatibleBitmap( hdc, cx, cy );
    ReleaseDesktopDC( hdc );

    mbm = SelectBitmap( mdc, mbm ); // Swap
    SetRect( &r, 0,0, cx,cy );
    FillRect( mdc, &r, hbrBkg ); //SYSHBR(3DFACE) );
    DrawIconEx( mdc, 0,0, hIcon, cx,cy, 0, NULL, DI_NORMAL );
    mbm = SelectBitmap( mdc, mbm ); // Swap back

    DeleteDC( mdc );
    return mbm;
}
#endif

// CreateMaskBitmap - Create a B/W mask bitmap suitable for use with MaskBlt

HBITMAP WINAPI CreateMaskBitmap( HBITMAP img, COLORREF transp )
{
    BITMAP   bim; ::GetObject( img, sizeof(BITMAP), &bim );
    RECT     r  = { 0,0, bim.bmWidth, bim.bmHeight };

    HDC      sdc = CreateCompatibleDC( NULL );          // Source dc
    HBITMAP  obs = (HBITMAP) SelectObject( sdc, img );  // Holds the image
    COLORREF ocs = SetBkColor( sdc, transp );           // This voodoo does it!

    HDC      mdc  = CreateCompatibleDC( NULL );         // Target dc
    HBITMAP  mask = CreateBitmap( bim.bmWidth, bim.bmHeight, 1,1,NULL );
    HBITMAP  obd  = (HBITMAP) SelectObject( mdc, mask ); // Now we can draw

    BitBlt( mdc, 0,0, bim.bmWidth, bim.bmHeight, sdc, 0,0, SRCCOPY ); // Make mono
    InvertRect( mdc, &r ); // Invert the mask to satisfy standard MaskBlt.

  #if 0 // Superfluous cleaning up, since the DCs will be deleted
    SelectObject( mdc, obd );
    SetBkColor( sdc, ocs );
    SelectObject( sdc, obs );
  #endif
    DeleteDC( mdc );
    DeleteDC( sdc );

    return mask;
}

#pragma warning( disable: 4533 ) // initialization of 'r' is skipped by 'goto __cab_Exit'

HBITMAP WINAPI CreateAntialiasedBitmap(
    UINT cx, UINT cy, UINT mu, PFnPaintBitmap PaintBitmap, PVOID Ctx
    )
{
    HBITMAP hBmp = NULL; // Result

    if (!PaintBitmap)
    {
        SetLastError( ERROR_INVALID_FUNCTION );
        //goto __cab_Exit;
    }
    else
    {
        HBITMAP obmMem, obmTmp, hbTmp;
        UINT _cx = mu*cx, _cy = mu*cy;

        HDC hTmpDC = CreateMemoryDC( _cx, _cy, &obmTmp );
        RECT r = MkRect( 0,0, _cx, _cy );

        // Paint the bitmap in upscaled size..

        bool ok;
        PAINTBMPSTRUCT ps;
        ps.hDC = hTmpDC;
        ps.rcPaint = r;
        ps.mu = mu;
        ps.ctx = Ctx;
        #ifndef HAVE_STRUCTURED_EH
            ok = PaintBitmap( &ps ); // Call back..
        #else
            __try { ok = PaintBitmap( &ps ); } // Call back..
            __except_execute
            {
                TRACE( DP_ERROR, _F("Exception 0x%08X in user's PaintPitmap (%p).\n"),
                    GetExceptionCode(), PaintBitmap );
                ok = false;
            }
            __end_except
        #endif

        hbTmp = DeleteMemoryDC( hTmpDC, obmTmp ); // Retrieve the oversized bitmap.

        // Halftone stretch to target..

        if ( !ok ) DeleteBitmap( hbTmp ); // If painter returned false, or excepted..
        else
        {
            HDC hMemDC = CreateMemoryDC( cx, cy, &obmMem ); // Create target w blank bitmap.
            hTmpDC = CreateCompatibleDC( hMemDC );          // Create mem dc w/o bitmap.
            obmTmp = SelectBitmap( hTmpDC, hbTmp );         // Select the oversized bitmap.

            SetStretchBltMode( hMemDC, HALFTONE );
            SetBrushOrgEx( hMemDC, 0,0, NULL );
            StretchBlt( hMemDC, 0,0, cx, cy, hTmpDC, 0,0, _cx, _cy, SRCCOPY );

            hBmp = DeleteMemoryDC( hMemDC, obmMem ); // Retrieve the antialiased bitmap.

            SelectBitmap( hTmpDC, obmTmp );
            DeleteDC( hTmpDC );
        }
    }
  //__cab_Exit:
    return hBmp;
}
#pragma warning( default: 4533 )

// DeleteObjectEx - Return NULL on success, else hObj.

HGDIOBJ WINAPI DeleteObjectEx( HGDIOBJ hObj )
{
    return hObj ? (DeleteObject( hObj ) ? NULL : hObj) : hObj;
}

// Get the handle and optional data of a GDI object in HDC

// x64 breakage: lbHatch may hold x64 HANDLE, making sizeof(LOGBRUSH) == sizeof(LOGPEN)
//void __checkGdiObjSizes()
//{
//    DPrint( DP_DEBUG, _F("sizeof(LOGBRUSH) = %lu\n"), sizeof(LOGBRUSH) );
//    DPrint( DP_DEBUG, _F("sizeof(LOGFONT) = %lu\n"), sizeof(LOGFONT) );
//    DPrint( DP_DEBUG, _F("sizeof(LOGPEN) = %lu\n"), sizeof(LOGPEN) );
//    DPrint( DP_DEBUG, _F("sizeof(EXTLOGPEN) = %lu\n"), sizeof(EXTLOGPEN) );
//    DPrint( DP_DEBUG, _F("sizeof(BITMAP) = %lu\n"), sizeof(BITMAP) );
//    DPrint( DP_DEBUG, _F("sizeof(DIBSECTION) = %lu\n"), sizeof(DIBSECTION) );
//    DPrint( DP_DEBUG, _F("sizeof(WORD) = %lu\n"), sizeof(WORD) );
//    DPrint( DP_DEBUG, _F("sizeof(LOGCOLORSPACE) = %lu\n"), sizeof(LOGCOLORSPACE) );
//}

HGDIOBJ WINAPI GetCurrentObjectEx( HDC hdc, UINT ObjType, PVOID pObjData )
{
    HGDIOBJ hObj = NULL;
    UINT DataSize = 0;

    // DataSize used to be an argument, as in GetObject().
    // As of x64, unfortunately LOGBRUSH.lbHatch may hold an x64 HANDLE,
    // making  sizeof(LOGBRUSH) == sizeof(LOGPEN), and thus defeating the
    // original switch statement and forcing a breaking API change.

    if (pObjData)
    switch( ObjType )
    {
        case OBJ_BRUSH:  DataSize = sizeof(LOGBRUSH); break;
        case OBJ_FONT:   DataSize = sizeof(LOGFONT); break;
        case OBJ_PEN:    DataSize = sizeof(LOGPEN); break;
        case OBJ_EXTPEN: DataSize = sizeof(EXTLOGPEN); break;
        case OBJ_BITMAP: DataSize = sizeof(BITMAP); break;
        case OBJ_PAL:    DataSize = sizeof(WORD); break;
        case OBJ_COLORSPACE: DataSize = sizeof(LOGCOLORSPACE); break;
        case OBJ_DIBSECTION: // Special, unverified
            DataSize = sizeof(DIBSECTION);
            ObjType = OBJ_BITMAP;
            break;
        default: break;
    }
    hObj = GetCurrentObject( hdc, ObjType );
    if (hObj && DataSize) GetObject( hObj, DataSize, pObjData ); // Get the object's data
    return hObj;
}

// Draw a bitmap through a monochrome mask

bool WINAPI DrawMaskedBitmap( HDC hdc, int x, int y, HBITMAP hBmp, HBITMAP hMask )
{
    BITMAP bm;
    GetObject( hBmp, sizeof(bm), &bm );
    HDC mdc = CreateCompatibleDC( hdc );
    HBITMAP hbm = SelectBitmap( mdc, hBmp );

    bool ok = bool_cast( MaskBlt(
        hdc, x,y, bm.bmWidth, bm.bmHeight, mdc,0,0, hMask,0,0, R4_MASKBLT
        ));

    SelectBitmap( mdc, hbm );
    DeleteDC( mdc );
    return ok;
}

// Draw a bitmap transparently

bool WINAPI DrawTransparentBitmap(
    HDC hdc, int x, int y, int w, int h, HBITMAP hBmp, COLORREF cTrans
    )
{
    BITMAP bm;
    GetObject( hBmp, sizeof(bm), &bm );
    if (!w) w = bm.bmWidth;
    if (!h) h = bm.bmHeight;
    HDC mdc = CreateCompatibleDC( hdc );
    HBITMAP hbm = SelectBitmap( mdc, hBmp );

    bool ok = bool_cast( TransparentBlt(
        hdc, x,y, w,h, mdc, 0,0, bm.bmWidth, bm.bmHeight, cTrans
        ));

    SelectBitmap( mdc, hbm );
    DeleteDC( mdc );
    return ok;
}

// Normal bitmap blits..

void WINAPI DrawBitmap( HDC hdc, int x, int y, HBITMAP hBmp )
{
    BITMAP bm;
    GetObject( hBmp, sizeof(bm), &bm );
    HDC mdc = CreateCompatibleDC( hdc );
    HBITMAP hbm = SelectBitmap( mdc, hBmp );

    BitBlt(  hdc, x, y, bm.bmWidth, bm.bmHeight, mdc, 0,0, SRCCOPY );

    SelectBitmap( mdc, hbm );
    DeleteDC( mdc );
}

// Stretched bitmap blit..

void WINAPI DrawBitmapEx(
    HDC hdc, int x, int y, int cx, int cy,
    HBITMAP hBmp, int imx, int imy, int imw, int imh,
    DWORD rasterOp
    )
{
    if (!imw || !imh)
    {
        BITMAP bm; GetObject( hBmp, sizeof(bm), &bm );
        if (!imw) imw = bm.bmWidth;
        if (!imh) imh = bm.bmHeight;
    }
    if (!cx || !cy)
    {
        HWND hWnd = WindowFromDC( hdc );
        RECT r; GetClientRect( hWnd, &r );
        if (!cx) cx = r.right;
        if (!cy) cy = r.bottom;
    }

    // PONDER: Constrain cx/cy and imw/imh to respective right/bottom corners?

    HDC mdc = CreateCompatibleDC( hdc );
    HBITMAP hbm = SelectBitmap( mdc, hBmp );
    int sbmode = SetStretchBltMode( hdc, HALFTONE );
    SetBrushOrgEx( hdc, 0, 0, NULL );

    StretchBlt( hdc, x, y, cx, cy, mdc, imx, imy, imw, imh, rasterOp );

    SetStretchBltMode( hdc, sbmode );
    SelectBitmap( mdc, hbm );
    DeleteDC( mdc );
}

// Draw a gradient filled rectangle

#ifndef GRADIENT_D
void WINAPI DrawGradientRect( HDC hdc, PRECT pRc, COLORREF c1, COLORREF c2, UINT opt )
{
    TRIVERTEX     vtx[2];
    GRADIENT_RECT mesh;

    SetTriVertex( &vtx[0], pr->left, pr->top, c1 );
    SetTriVertex( &vtx[1], pr->right, pr->bottom, c2 );
    SetRectMesh( &mesh, 0,1 );

    GradientFill( hdc, vtx,2, &mesh,1, opt );
}
#else
void WINAPI DrawGradientRect( HDC hdc, PRECT pRc, COLORREF c1, COLORREF c2, UINT type )
{
    TRIVERTEX vtx[4];
    if (type == GRADIENT_D) // Diagonal gradient :)
    {
        GRADIENT_TRIANGLE mesh[2];
        COLORREF c3 = RGB(
            BYTE( (WORD(GetRValue(c1)) + GetRValue(c2)) / 2),
            BYTE( (WORD(GetGValue(c1)) + GetGValue(c2)) / 2),
            BYTE( (WORD(GetBValue(c1)) + GetBValue(c2)) / 2)
            );
        // = GradientColor( c1,c2, 1,3 );
        SetTriVertex( &vtx[0], pRc->left, pRc->bottom, c3 );
        SetTriVertex( &vtx[1], pRc->left, pRc->top, c1 );
        SetTriVertex( &vtx[2], pRc->right, pRc->top, c3 );
        SetTriVertex( &vtx[3], pRc->right, pRc->bottom, c2 );
        SetTriMesh( &mesh[0], 0, 1, 2 );
        SetTriMesh( &mesh[1], 0, 2, 3 );
        GradientFill( hdc, vtx,4, mesh,2, GRADIENT_FILL_TRIANGLE );
    }
    else // Horizontal or Vertical
    {
        GRADIENT_RECT mesh;
        SetTriVertex( &vtx[0], pRc->left, pRc->top, c1 );
        SetTriVertex( &vtx[1], pRc->right, pRc->bottom, c2 );
        SetRectMesh( &mesh, 0,1 );
        GradientFill( hdc, vtx,2, &mesh,1, type );
    }
}
#endif

void WINAPI SetTriVertex( PTRIVERTEX pVtx, int x, int y, COLORREF cr, BYTE Alpha )
{
    pVtx->x = x; pVtx->y = y;
    pVtx->Red = COLOR16( GetRValue( cr )) << 8;
    pVtx->Green = COLOR16( GetGValue( cr )) << 8;
    pVtx->Blue = COLOR16( GetBValue( cr )) << 8;
    pVtx->Alpha = COLOR16( Alpha ) << 8;
}

void WINAPI SetTriMesh( PGRADIENT_TRIANGLE pTri, UINT Vtx1, UINT Vtx2, UINT Vtx3 )
{
    pTri->Vertex1 = Vtx1;
    pTri->Vertex2 = Vtx2;
    pTri->Vertex3 = Vtx3;
}

void WINAPI SetRectMesh( PGRADIENT_RECT pRect, UINT TopLeft, UINT BotRight )
{
    pRect->UpperLeft = TopLeft;
    pRect->LowerRight = BotRight;
}

void WINAPI SetRedraw( HWND hwnd, bool on )
{
    WM_SetRedraw( hwnd, on );
    if (on) InvalidateRect( hwnd, NULL, false );
}

void WINAPI Line( HDC hdc, int x1, int y1, int x2, int y2 )
{
    MoveToEx( hdc, x1, y1, NULL );
    LineTo( hdc, x2, y2 );
}

void WINAPI GetIsoTriangleVertices(
    POINT* Vtx, int xOrg, int yOrg, int Radius, double Orientation )
{
    static const double angleStep = (2.0 * M_PI) / 3.0;
    double& dir = Orientation; // Fingersaving alias..

    // PONDER: Eliminate one sin/cos pair call by precomputing sin/cos pairs
    // for Orientation and angleStep and using those for the Vtx calculations.

    Vtx[0].x = xOrg + int( Radius * cos( dir ));
    Vtx[0].y = yOrg - int( Radius * sin( dir ));
    Vtx[1].x = xOrg + int( Radius * cos( dir + angleStep ));
    Vtx[1].y = yOrg - int( Radius * sin( dir + angleStep ));
    Vtx[2].x = xOrg + int( Radius * cos( dir - angleStep ));
    Vtx[2].y = yOrg - int( Radius * sin( dir - angleStep ));
}

void WINAPI DrawIsoTriangle(
    HDC hdc, int xOrg, int yOrg, int Radius, double Orientation )
{
    POINT pt[3];
    /*
      Usage example:
        HBRUSH hbr = SelectBrush( hdc, GetStockBrush( HOLLOW_BRUSH ));
        HPEN hpen = SelectPen( hdc, GetStockPen( WHITE_PEN ));
        int x = rDisp.left + (rDisp.right - rDisp.left) / 2;
        int y = rDisp.top + (rDisp.bottom - rDisp.top) / 2;
        DrawIsoTriangle( hdc, x, y, 100, -M_PI/2.0 );
        SelectPen( hdc, hpen );
        SelectBrush( hdc, hbr );
    */
    GetIsoTriangleVertices( pt, xOrg, yOrg, Radius, Orientation );
    Polygon( hdc, pt, 3 );
    //IF_DEBUG( Line( hdc, xOrg, yOrg, pt[0].x, pt[0].y ));
}

// Color scaling

static BYTE _mulimClr( BYTE val, BYTE mul, BYTE div )
{
    WORD lum = WORD( val ) * mul / div;
    return (lum > 255) ? 255 : (BYTE) lum;
}

#if !USE_SCALECOLOR_ASM // In _gradcolor.asm
// FIXME: The assembly implementation needs rethinking...
COLORREF WINAPI ScaleColorRef( COLORREF color, BYTE mul, BYTE div )
{
    COLORREF result;
    if (mul == div) result = color;
    else
    {
        BYTE rr = _mulimClr( GetRValue( color ), mul, div );
        BYTE gg = _mulimClr( GetGValue( color ), mul, div );
        BYTE bb = _mulimClr( GetBValue( color ), mul, div );
        result = RGB( rr,gg,bb );
    }
    return result;
}
#endif

#if !USE_GRADIENTCOLOR_ASM // C++ fallback implementation
//
// GradientColor procuces a smooth color crossfade from c1 to c2.
// Length is the desired run length from c1 to c2, and Ix is the step nr.
//
COLORREF WINAPI GradientColor( COLORREF c1, COLORREF c2, WORD Ix, WORD Length )
{
    BYTE r1 = GetRValue( c1 );
    BYTE g1 = GetGValue( c1 );
    BYTE b1 = GetBValue( c1 );
    SHORT dr = SHORT(GetRValue( c2 )) - r1;
    SHORT dg = SHORT(GetGValue( c2 )) - g1;
    SHORT db = SHORT(GetBValue( c2 )) - b1;
    WORD N = Length-1; // Divisor need to comply with Ix 0..Length-1
    WORD r = WORD(r1) + ((dr * SHORT(Ix)) / N);
    WORD g = WORD(g1) + ((dg * SHORT(Ix)) / N);
    WORD b = WORD(b1) + ((db * SHORT(Ix)) / N);
    return RGB( BYTE(r), BYTE(g), BYTE(b) );
}
#endif

// Convert RGB to weighted grayscale.

COLORREF WINAPI GrayScaleColor( COLORREF rgb )
{
    static const float coef[3] = { 0.2126f, 0.7152f, 0.0722f }; // sRGB
    //static const float coef[3] = { 0.2989f, 0.5870f, 0.1140f }; // CCIR 601 (NTSC)
    BYTE luma = BYTE(
        coef[0] * GetRValue(rgb) +
        coef[1] * GetGValue(rgb) +
        coef[2] * GetBValue(rgb)
        );
    return RGB( luma,luma,luma );
}

// Region supplements

int WINAPI MapRegionToWindow( HRGN hRgn, HWND hWnd )
{
    POINT pt = {0,0};
    MapWindowPoints( HWND_DESKTOP, hWnd, &pt, 1 );
    return OffsetRgn( hRgn, pt.x, pt.y );
}

RGNDATA* WINAPI AllocAndGetRegionData( HRGN hRgn, RECT** ppRc )
{
    DWORD cbRgn = GetRegionData( hRgn, 0, NULL );
    RGNDATA* pRgn = (RGNDATA*) mem_Alloc( cbRgn );
    if (pRgn)
    {
        GetRegionData( hRgn, cbRgn, pRgn );
        if (ppRc) *ppRc = (RECT*) pRgn->Buffer;
    }
    return pRgn;
}

RGNDATA* WINAPI FreeRegionData( RGNDATA* pRgn )
{
    return (RGNDATA*) mem_Free( pRgn ); // Null-safe
}

#if _DEBUG // Dump region data to the debugger.
void WINAPI DumpRegionData( CSTR Title, HRGN hRgn )
{
    RECT* pr = NULL;
    RGNDATA* pRgn = AllocAndGetRegionData( hRgn, &pr );
    if (pRgn)
    {
        RECT r = pRgn->rdh.rcBound;
        DPrint( DP_INFO, _F("%s: Bounds={%li,%li,%li,%li}, Count=%lu, Type=%lu\n"),
            Title, r.left, r.top, r.right, r.bottom, pRgn->rdh.nCount, pRgn->rdh.iType
            );
        for( DWORD ix = 0, N = pRgn->rdh.nCount; ix < N; ++ix )
        {
            r = *pr++;
            DPrint( DP_INFO, _F("  Rect[%lu] = {%li,%li,%li,%li}\n"),
                ix, r.left, r.top, r.right, r.bottom );
        }
        pRgn = FreeRegionData( pRgn );
    }
}
#endif

// Path/Region supplements

// Retrieve the current path data from a display context.

bool WINAPI GetGdiPathData( HDC hdc, OUT PGdiPathData pData )
{
    int nPts = GetPath( hdc, NULL, NULL, 0 );
    bool ok = (nPts > 1);
    TRACE_IF( !ok, DP_ERROR, _F("GetPath == %i: %s\n"), nPts, SysErrorMsg() );
    // GetPath sometimes fails (with no error code) even when there is a valid path.
    // I.e: GetPath( hdc, 0,0,0 ) == -1, and GetLastError() == 0.
    // It seems to be a somewhat stochastic GDI bug..?
    // Converting the path to a region appears more reliable.
    if (ok)
    {
        LPPOINT pPt = (LPPOINT) mem_Alloc( nPts * sizeof(POINT) + nPts );
        LPBYTE pType = (LPBYTE)( pPt + nPts ); // NB: C pointer arithmetic.
        if ( ok = (pPt != NULL) )
        {
            int cPts = GetPath( hdc, pPt, pType, nPts );
            ok = (cPts == nPts);
            if (ok)
            {
                RECT r = { LONG_MAX, LONG_MAX, 0,0 }; // bounds
                LPPOINT ppt = pPt;
                for( int ix = 0; ix < cPts; ix++, ppt++ )
                {
                    long x = ppt->x, y = ppt->y; // pre-ref to quicken access
                    if (x < r.left)   r.left   = x;
                    if (x > r.right)  r.right  = x;
                    if (y < r.top)    r.top    = y;
                    if (y > r.bottom) r.bottom = y;
                }
                pData->Bounds = r;
                pData->nPoints = cPts;
                pData->pPoint = pPt;
                pData->pType = pType;
            }
            else
            {
                DWORD err = GetLastError(); // Pray GetPath actually used SetLastError()
                mem_Free( pPt ); // Dispose the buffer so we don't leak.
                SetLastError( err );
            }
        }
    }
    return ok;
}

// Dispose path data retrieved by GetGdiPathData().

void WINAPI FreeGdiPathData( PGdiPathData pData )
{
    mem_Free( pData->pPoint ); // Null-safe
}

// Compute the bounding rect for the current HDC path.

bool WINAPI GetGdiPathBounds( HDC hdc, PRECT pBounds )
{
    GdiPathData pd;
    bool ok = GetGdiPathData( hdc, &pd );
    if (ok)
    {
        *pBounds = pd.Bounds;
        FreeGdiPathData( &pd );
    }
    return ok;
}

// Convert the current HDC path to a region and retrieve the region data.

HRGN WINAPI GetGdiPathRgn( HDC hdc, OUT RGNDATA** pRgnData, OPTOUT RECT** pRgnRects )
{
    HRGN pathRgn = PathToRegion( hdc );
    TRACE_IF( !pathRgn, DP_ERROR, _F("PathToRegion: %s\n"), SysErrorMsg() );
    if (pathRgn)
    {
        *pRgnData = AllocAndGetRegionData( pathRgn, pRgnRects );
    }
    return pathRgn;
}

// Convert a HDC path into a region and get it's bounding rect.
// Somewhat superfluous as you may use PathToRegion and GetRgnBox
// if that's all you need. Retained just for edification..

HRGN WINAPI GetGdiPathRgnBounds( HDC hdc, OUT PRECT pBounds )
{
    RGNDATA* rgnData;
    RECT* rgnRects; // Region rectangles.
    HRGN pathRgn = GetGdiPathRgn( hdc, &rgnData, &rgnRects );
    if (pathRgn)
    {
        *pBounds = rgnData->rdh.rcBound;
        FreeRegionData( rgnData );
    }
    return pathRgn;
}

// Offset an array of points by dx/dy.

void OffsetPoints( POINT* Pts, UINT nPts, int dx, int dy )
{
    POINT* pt = Pts;
    for( UINT ix=0; ix < nPts; ix++, pt++ )
    {
        pt->x += dx;
        pt->y += dy;
    }
}

// Offset the retrieved region data by dx/dy.

void OffsetRgnData( PRGNDATA prd, int dx, int dy )
{
    PRECT pr = (PRECT) prd->Buffer;
    OffsetRect( &prd->rdh.rcBound, dx, dy );
    for( DWORD ix=0, N=prd->rdh.nCount; ix < N; ix++, pr++ )
    {
        OffsetRect( pr, dx, dy );
    }
}

// An initialized MAT2 is a mandatory parameter for GetGlyphOutline().

void SetIdentityMat2( MAT2* pm )
{
    static const FIXED zero = {0,0}, one = {0,1};
    pm->eM11 = pm->eM22 = one;
    pm->eM12 = pm->eM21 = zero;
}

// EOF