generated.c

Wine-20031016

{
    /* EMRARC (pack 4) */
    TEST_TYPE(EMRARC, 40, 4);
    TEST_FIELD(EMRARC, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRARC, RECTL, rclBox, 8, 16, 4);
    TEST_FIELD(EMRARC, POINTL, ptlStart, 24, 8, 4);
    TEST_FIELD(EMRARC, POINTL, ptlEnd, 32, 8, 4);
}

static void test_pack_EMRARCTO(void)
{
    /* EMRARCTO (pack 4) */
    TEST_TYPE(EMRARCTO, 40, 4);
    TEST_FIELD(EMRARCTO, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRARCTO, RECTL, rclBox, 8, 16, 4);
    TEST_FIELD(EMRARCTO, POINTL, ptlStart, 24, 8, 4);
    TEST_FIELD(EMRARCTO, POINTL, ptlEnd, 32, 8, 4);
}

static void test_pack_EMRBEGINPATH(void)
{
    /* EMRBEGINPATH (pack 4) */
    TEST_TYPE(EMRBEGINPATH, 8, 4);
    TEST_FIELD(EMRBEGINPATH, EMR, emr, 0, 8, 4);
}

static void test_pack_EMRBITBLT(void)
{
    /* EMRBITBLT (pack 4) */
    TEST_TYPE(EMRBITBLT, 100, 4);
    TEST_FIELD(EMRBITBLT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRBITBLT, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRBITBLT, LONG, xDest, 24, 4, 4);
    TEST_FIELD(EMRBITBLT, LONG, yDest, 28, 4, 4);
    TEST_FIELD(EMRBITBLT, LONG, cxDest, 32, 4, 4);
    TEST_FIELD(EMRBITBLT, LONG, cyDest, 36, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, dwRop, 40, 4, 4);
    TEST_FIELD(EMRBITBLT, LONG, xSrc, 44, 4, 4);
    TEST_FIELD(EMRBITBLT, LONG, ySrc, 48, 4, 4);
    TEST_FIELD(EMRBITBLT, XFORM, xformSrc, 52, 24, 4);
    TEST_FIELD(EMRBITBLT, COLORREF, crBkColorSrc, 76, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, iUsageSrc, 80, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, offBmiSrc, 84, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
    TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
}

static void test_pack_EMRCHORD(void)
{
    /* EMRCHORD (pack 4) */
    TEST_TYPE(EMRCHORD, 40, 4);
    TEST_FIELD(EMRCHORD, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRCHORD, RECTL, rclBox, 8, 16, 4);
    TEST_FIELD(EMRCHORD, POINTL, ptlStart, 24, 8, 4);
    TEST_FIELD(EMRCHORD, POINTL, ptlEnd, 32, 8, 4);
}

static void test_pack_EMRCLOSEFIGURE(void)
{
    /* EMRCLOSEFIGURE (pack 4) */
    TEST_TYPE(EMRCLOSEFIGURE, 8, 4);
    TEST_FIELD(EMRCLOSEFIGURE, EMR, emr, 0, 8, 4);
}

static void test_pack_EMRCREATEBRUSHINDIRECT(void)
{
    /* EMRCREATEBRUSHINDIRECT (pack 4) */
    TEST_TYPE(EMRCREATEBRUSHINDIRECT, 24, 4);
    TEST_FIELD(EMRCREATEBRUSHINDIRECT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRCREATEBRUSHINDIRECT, DWORD, ihBrush, 8, 4, 4);
    TEST_FIELD(EMRCREATEBRUSHINDIRECT, LOGBRUSH, lb, 12, 12, 4);
}

static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
{
    /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
    TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, ihBrush, 8, 4, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, iUsage, 12, 4, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBmi, 16, 4, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
}

static void test_pack_EMRCREATEMONOBRUSH(void)
{
    /* EMRCREATEMONOBRUSH (pack 4) */
    TEST_TYPE(EMRCREATEMONOBRUSH, 32, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, ihBrush, 8, 4, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, iUsage, 12, 4, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBmi, 16, 4, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
}

static void test_pack_EMRCREATEPEN(void)
{
    /* EMRCREATEPEN (pack 4) */
    TEST_TYPE(EMRCREATEPEN, 28, 4);
    TEST_FIELD(EMRCREATEPEN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRCREATEPEN, DWORD, ihPen, 8, 4, 4);
    TEST_FIELD(EMRCREATEPEN, LOGPEN, lopn, 12, 16, 4);
}

static void test_pack_EMRDELETECOLORSPACE(void)
{
    /* EMRDELETECOLORSPACE (pack 4) */
    TEST_TYPE(EMRDELETECOLORSPACE, 12, 4);
    TEST_FIELD(EMRDELETECOLORSPACE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRDELETECOLORSPACE, DWORD, ihCS, 8, 4, 4);
}

static void test_pack_EMRDELETEOBJECT(void)
{
    /* EMRDELETEOBJECT (pack 4) */
    TEST_TYPE(EMRDELETEOBJECT, 12, 4);
    TEST_FIELD(EMRDELETEOBJECT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRDELETEOBJECT, DWORD, ihObject, 8, 4, 4);
}

static void test_pack_EMRELLIPSE(void)
{
    /* EMRELLIPSE (pack 4) */
    TEST_TYPE(EMRELLIPSE, 24, 4);
    TEST_FIELD(EMRELLIPSE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRELLIPSE, RECTL, rclBox, 8, 16, 4);
}

static void test_pack_EMRENDPATH(void)
{
    /* EMRENDPATH (pack 4) */
    TEST_TYPE(EMRENDPATH, 8, 4);
    TEST_FIELD(EMRENDPATH, EMR, emr, 0, 8, 4);
}

static void test_pack_EMREOF(void)
{
    /* EMREOF (pack 4) */
    TEST_TYPE(EMREOF, 20, 4);
    TEST_FIELD(EMREOF, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREOF, DWORD, nPalEntries, 8, 4, 4);
    TEST_FIELD(EMREOF, DWORD, offPalEntries, 12, 4, 4);
    TEST_FIELD(EMREOF, DWORD, nSizeLast, 16, 4, 4);
}

static void test_pack_EMREXCLUDECLIPRECT(void)
{
    /* EMREXCLUDECLIPRECT (pack 4) */
    TEST_TYPE(EMREXCLUDECLIPRECT, 24, 4);
    TEST_FIELD(EMREXCLUDECLIPRECT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXCLUDECLIPRECT, RECTL, rclClip, 8, 16, 4);
}

static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
{
    /* EMREXTCREATEFONTINDIRECTW (pack 4) */
    TEST_TYPE(EMREXTCREATEFONTINDIRECTW, 332, 4);
    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, DWORD, ihFont, 8, 4, 4);
    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EXTLOGFONTW, elfw, 12, 320, 4);
}

static void test_pack_EMREXTCREATEPEN(void)
{
    /* EMREXTCREATEPEN (pack 4) */
    TEST_TYPE(EMREXTCREATEPEN, 56, 4);
    TEST_FIELD(EMREXTCREATEPEN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTCREATEPEN, DWORD, ihPen, 8, 4, 4);
    TEST_FIELD(EMREXTCREATEPEN, DWORD, offBmi, 12, 4, 4);
    TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBmi, 16, 4, 4);
    TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
    TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
    TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
}

static void test_pack_EMREXTFLOODFILL(void)
{
    /* EMREXTFLOODFILL (pack 4) */
    TEST_TYPE(EMREXTFLOODFILL, 24, 4);
    TEST_FIELD(EMREXTFLOODFILL, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTFLOODFILL, POINTL, ptlStart, 8, 8, 4);
    TEST_FIELD(EMREXTFLOODFILL, COLORREF, crColor, 16, 4, 4);
    TEST_FIELD(EMREXTFLOODFILL, DWORD, iMode, 20, 4, 4);
}

static void test_pack_EMREXTSELECTCLIPRGN(void)
{
    /* EMREXTSELECTCLIPRGN (pack 4) */
    TEST_TYPE(EMREXTSELECTCLIPRGN, 20, 4);
    TEST_FIELD(EMREXTSELECTCLIPRGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, cbRgnData, 8, 4, 4);
    TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, iMode, 12, 4, 4);
    TEST_FIELD(EMREXTSELECTCLIPRGN, BYTE[1], RgnData, 16, 1, 1);
}

static void test_pack_EMREXTTEXTOUTA(void)
{
    /* EMREXTTEXTOUTA (pack 4) */
    TEST_TYPE(EMREXTTEXTOUTA, 76, 4);
    TEST_FIELD(EMREXTTEXTOUTA, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMREXTTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
}

static void test_pack_EMREXTTEXTOUTW(void)
{
    /* EMREXTTEXTOUTW (pack 4) */
    TEST_TYPE(EMREXTTEXTOUTW, 76, 4);
    TEST_FIELD(EMREXTTEXTOUTW, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMREXTTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMREXTTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTW, FLOAT, exScale, 28, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
    TEST_FIELD(EMREXTTEXTOUTW, EMRTEXT, emrtext, 36, 40, 4);
}

static void test_pack_EMRFILLPATH(void)
{
    /* EMRFILLPATH (pack 4) */
    TEST_TYPE(EMRFILLPATH, 24, 4);
    TEST_FIELD(EMRFILLPATH, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRFILLPATH, RECTL, rclBounds, 8, 16, 4);
}

static void test_pack_EMRFILLRGN(void)
{
    /* EMRFILLRGN (pack 4) */
    TEST_TYPE(EMRFILLRGN, 36, 4);
    TEST_FIELD(EMRFILLRGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRFILLRGN, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRFILLRGN, DWORD, cbRgnData, 24, 4, 4);
    TEST_FIELD(EMRFILLRGN, DWORD, ihBrush, 28, 4, 4);
    TEST_FIELD(EMRFILLRGN, BYTE[1], RgnData, 32, 1, 1);
}

static void test_pack_EMRFLATTENPATH(void)
{
    /* EMRFLATTENPATH (pack 4) */
    TEST_TYPE(EMRFLATTENPATH, 8, 4);
    TEST_FIELD(EMRFLATTENPATH, EMR, emr, 0, 8, 4);
}

static void test_pack_EMRFORMAT(void)
{
    /* EMRFORMAT (pack 4) */
    TEST_TYPE(EMRFORMAT, 16, 4);
    TEST_FIELD(EMRFORMAT, DWORD, dSignature, 0, 4, 4);
    TEST_FIELD(EMRFORMAT, DWORD, nVersion, 4, 4, 4);
    TEST_FIELD(EMRFORMAT, DWORD, cbData, 8, 4, 4);
    TEST_FIELD(EMRFORMAT, DWORD, offData, 12, 4, 4);
}

static void test_pack_EMRFRAMERGN(void)
{
    /* EMRFRAMERGN (pack 4) */
    TEST_TYPE(EMRFRAMERGN, 44, 4);
    TEST_FIELD(EMRFRAMERGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRFRAMERGN, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRFRAMERGN, DWORD, cbRgnData, 24, 4, 4);
    TEST_FIELD(EMRFRAMERGN, DWORD, ihBrush, 28, 4, 4);
    TEST_FIELD(EMRFRAMERGN, SIZEL, szlStroke, 32, 8, 4);
    TEST_FIELD(EMRFRAMERGN, BYTE[1], RgnData, 40, 1, 1);
}

static void test_pack_EMRGDICOMMENT(void)
{
    /* EMRGDICOMMENT (pack 4) */
    TEST_TYPE(EMRGDICOMMENT, 16, 4);
    TEST_FIELD(EMRGDICOMMENT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRGDICOMMENT, DWORD, cbData, 8, 4, 4);
    TEST_FIELD(EMRGDICOMMENT, BYTE[1], Data, 12, 1, 1);
}

static void test_pack_EMRGLSBOUNDEDRECORD(void)
{
    /* EMRGLSBOUNDEDRECORD (pack 4) */
    TEST_TYPE(EMRGLSBOUNDEDRECORD, 32, 4);
    TEST_FIELD(EMRGLSBOUNDEDRECORD, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRGLSBOUNDEDRECORD, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRGLSBOUNDEDRECORD, DWORD, cbData, 24, 4, 4);
    TEST_FIELD(EMRGLSBOUNDEDRECORD, BYTE[1], Data, 28, 1, 1);
}

static void test_pack_EMRGLSRECORD(void)
{
    /* EMRGLSRECORD (pack 4) */
    TEST_TYPE(EMRGLSRECORD, 16, 4);
    TEST_FIELD(EMRGLSRECORD, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRGLSRECORD, DWORD, cbData, 8, 4, 4);
    TEST_FIELD(EMRGLSRECORD, BYTE[1], Data, 12, 1, 1);
}

static void test_pack_EMRINVERTRGN(void)
{
    /* EMRINVERTRGN (pack 4) */
    TEST_TYPE(EMRINVERTRGN, 32, 4);
    TEST_FIELD(EMRINVERTRGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRINVERTRGN, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRINVERTRGN, DWORD, cbRgnData, 24, 4, 4);
    TEST_FIELD(EMRINVERTRGN, BYTE[1], RgnData, 28, 1, 1);
}

static void test_pack_EMRINTERSECTCLIPRECT(void)
{
    /* EMRINTERSECTCLIPRECT (pack 4) */
    TEST_TYPE(EMRINTERSECTCLIPRECT, 24, 4);
    TEST_FIELD(EMRINTERSECTCLIPRECT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRINTERSECTCLIPRECT, RECTL, rclClip, 8, 16, 4);
}

static void test_pack_EMRLINETO(void)
{
    /* EMRLINETO (pack 4) */
    TEST_TYPE(EMRLINETO, 16, 4);
    TEST_FIELD(EMRLINETO, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRLINETO, POINTL, ptl, 8, 8, 4);
}

static void test_pack_EMRMASKBLT(void)
{
    /* EMRMASKBLT (pack 4) */
    TEST_TYPE(EMRMASKBLT, 128, 4);
    TEST_FIELD(EMRMASKBLT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRMASKBLT, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRMASKBLT, LONG, xDest, 24, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, yDest, 28, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, cxDest, 32, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, cyDest, 36, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, dwRop, 40, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, xSrc, 44, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, ySrc, 48, 4, 4);
    TEST_FIELD(EMRMASKBLT, XFORM, xformSrc, 52, 24, 4);
    TEST_FIELD(EMRMASKBLT, COLORREF, crBkColorSrc, 76, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, iUsageSrc, 80, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, offBmiSrc, 84, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, cbBmiSrc, 88, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, offBitsSrc, 92, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, cbBitsSrc, 96, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, xMask, 100, 4, 4);
    TEST_FIELD(EMRMASKBLT, LONG, yMask, 104, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, iUsageMask, 108, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, offBmiMask, 112, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
    TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
}

static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
{
    /* EMRMODIFYWORLDTRANSFORM (pack 4) */
    TEST_TYPE(EMRMODIFYWORLDTRANSFORM, 36, 4);
    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, DWORD, iMode, 32, 4, 4);
}

static void test_pack_EMRMOVETOEX(void)
{
    /* EMRMOVETOEX (pack 4) */
    TEST_TYPE(EMRMOVETOEX, 16, 4);
    TEST_FIELD(EMRMOVETOEX, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRMOVETOEX, POINTL, ptl, 8, 8, 4);
}

static void test_pack_EMROFFSETCLIPRGN(void)
{
    /* EMROFFSETCLIPRGN (pack 4) */
    TEST_TYPE(EMROFFSETCLIPRGN, 16, 4);
    TEST_FIELD(EMROFFSETCLIPRGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMROFFSETCLIPRGN, POINTL, ptlOffset, 8, 8, 4);
}

static void test_pack_EMRPAINTRGN(void)
{
    /* EMRPAINTRGN (pack 4) */
    TEST_TYPE(EMRPAINTRGN, 32, 4);
    TEST_FIELD(EMRPAINTRGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPAINTRGN, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPAINTRGN, DWORD, cbRgnData, 24, 4, 4);
    TEST_FIELD(EMRPAINTRGN, BYTE[1], RgnData, 28, 1, 1);
}

static void test_pack_EMRPIE(void)
{
    /* EMRPIE (pack 4) */
    TEST_TYPE(EMRPIE, 40, 4);
    TEST_FIELD(EMRPIE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPIE, RECTL, rclBox, 8, 16, 4);
    TEST_FIELD(EMRPIE, POINTL, ptlStart, 24, 8, 4);
    TEST_FIELD(EMRPIE, POINTL, ptlEnd, 32, 8, 4);