generated.c

Wine-20031016

}

static void test_pack_EMRPIXELFORMAT(void)
{
    /* EMRPIXELFORMAT (pack 4) */
    TEST_TYPE(EMRPIXELFORMAT, 48, 4);
    TEST_FIELD(EMRPIXELFORMAT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPIXELFORMAT, PIXELFORMATDESCRIPTOR, pfd, 8, 40, 4);
}

static void test_pack_EMRPLGBLT(void)
{
    /* EMRPLGBLT (pack 4) */
    TEST_TYPE(EMRPLGBLT, 140, 4);
    TEST_FIELD(EMRPLGBLT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPLGBLT, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPLGBLT, POINTL[3], aptlDest, 24, 24, 4);
    TEST_FIELD(EMRPLGBLT, LONG, xSrc, 48, 4, 4);
    TEST_FIELD(EMRPLGBLT, LONG, ySrc, 52, 4, 4);
    TEST_FIELD(EMRPLGBLT, LONG, cxSrc, 56, 4, 4);
    TEST_FIELD(EMRPLGBLT, LONG, cySrc, 60, 4, 4);
    TEST_FIELD(EMRPLGBLT, XFORM, xformSrc, 64, 24, 4);
    TEST_FIELD(EMRPLGBLT, COLORREF, crBkColorSrc, 88, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, iUsageSrc, 92, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, offBmiSrc, 96, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, cbBmiSrc, 100, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, offBitsSrc, 104, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, cbBitsSrc, 108, 4, 4);
    TEST_FIELD(EMRPLGBLT, LONG, xMask, 112, 4, 4);
    TEST_FIELD(EMRPLGBLT, LONG, yMask, 116, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, iUsageMask, 120, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, offBmiMask, 124, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, cbBmiMask, 128, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, offBitsMask, 132, 4, 4);
    TEST_FIELD(EMRPLGBLT, DWORD, cbBitsMask, 136, 4, 4);
}

static void test_pack_EMRPOLYBEZIER(void)
{
    /* EMRPOLYBEZIER (pack 4) */
    TEST_TYPE(EMRPOLYBEZIER, 36, 4);
    TEST_FIELD(EMRPOLYBEZIER, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYBEZIER, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYBEZIER, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYBEZIER, POINTL[1], aptl, 28, 8, 4);
}

static void test_pack_EMRPOLYBEZIERTO(void)
{
    /* EMRPOLYBEZIERTO (pack 4) */
    TEST_TYPE(EMRPOLYBEZIERTO, 36, 4);
    TEST_FIELD(EMRPOLYBEZIERTO, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYBEZIERTO, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYBEZIERTO, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYBEZIERTO, POINTL[1], aptl, 28, 8, 4);
}

static void test_pack_EMRPOLYDRAW(void)
{
    /* EMRPOLYDRAW (pack 4) */
    TEST_TYPE(EMRPOLYDRAW, 40, 4);
    TEST_FIELD(EMRPOLYDRAW, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYDRAW, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYDRAW, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYDRAW, POINTL[1], aptl, 28, 8, 4);
    TEST_FIELD(EMRPOLYDRAW, BYTE[1], abTypes, 36, 1, 1);
}

static void test_pack_EMRPOLYGON(void)
{
    /* EMRPOLYGON (pack 4) */
    TEST_TYPE(EMRPOLYGON, 36, 4);
    TEST_FIELD(EMRPOLYGON, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYGON, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYGON, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYGON, POINTL[1], aptl, 28, 8, 4);
}

static void test_pack_EMRPOLYLINE(void)
{
    /* EMRPOLYLINE (pack 4) */
    TEST_TYPE(EMRPOLYLINE, 36, 4);
    TEST_FIELD(EMRPOLYLINE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYLINE, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYLINE, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYLINE, POINTL[1], aptl, 28, 8, 4);
}

static void test_pack_EMRPOLYLINETO(void)
{
    /* EMRPOLYLINETO (pack 4) */
    TEST_TYPE(EMRPOLYLINETO, 36, 4);
    TEST_FIELD(EMRPOLYLINETO, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYLINETO, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYLINETO, DWORD, cptl, 24, 4, 4);
    TEST_FIELD(EMRPOLYLINETO, POINTL[1], aptl, 28, 8, 4);
}

static void test_pack_EMRPOLYPOLYGON(void)
{
    /* EMRPOLYPOLYGON (pack 4) */
    TEST_TYPE(EMRPOLYPOLYGON, 44, 4);
    TEST_FIELD(EMRPOLYPOLYGON, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYPOLYGON, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYPOLYGON, DWORD, nPolys, 24, 4, 4);
    TEST_FIELD(EMRPOLYPOLYGON, DWORD, cptl, 28, 4, 4);
    TEST_FIELD(EMRPOLYPOLYGON, DWORD[1], aPolyCounts, 32, 4, 4);
    TEST_FIELD(EMRPOLYPOLYGON, POINTL[1], aptl, 36, 8, 4);
}

static void test_pack_EMRPOLYPOLYLINE(void)
{
    /* EMRPOLYPOLYLINE (pack 4) */
    TEST_TYPE(EMRPOLYPOLYLINE, 44, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, DWORD, nPolys, 24, 4, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, DWORD, cptl, 28, 4, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, DWORD[1], aPolyCounts, 32, 4, 4);
    TEST_FIELD(EMRPOLYPOLYLINE, POINTL[1], aptl, 36, 8, 4);
}

static void test_pack_EMRPOLYTEXTOUTA(void)
{
    /* EMRPOLYTEXTOUTA (pack 4) */
    TEST_TYPE(EMRPOLYTEXTOUTA, 80, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, exScale, 28, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, LONG, cStrings, 36, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTA, EMRTEXT[1], aemrtext, 40, 40, 4);
}

static void test_pack_EMRPOLYTEXTOUTW(void)
{
    /* EMRPOLYTEXTOUTW (pack 4) */
    TEST_TYPE(EMRPOLYTEXTOUTW, 80, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, exScale, 28, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, LONG, cStrings, 36, 4, 4);
    TEST_FIELD(EMRPOLYTEXTOUTW, EMRTEXT[1], aemrtext, 40, 40, 4);
}

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

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

static void test_pack_EMRRESIZEPALETTE(void)
{
    /* EMRRESIZEPALETTE (pack 4) */
    TEST_TYPE(EMRRESIZEPALETTE, 16, 4);
    TEST_FIELD(EMRRESIZEPALETTE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRRESIZEPALETTE, DWORD, ihPal, 8, 4, 4);
    TEST_FIELD(EMRRESIZEPALETTE, DWORD, cEntries, 12, 4, 4);
}

static void test_pack_EMRRESTOREDC(void)
{
    /* EMRRESTOREDC (pack 4) */
    TEST_TYPE(EMRRESTOREDC, 12, 4);
    TEST_FIELD(EMRRESTOREDC, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRRESTOREDC, LONG, iRelative, 8, 4, 4);
}

static void test_pack_EMRROUNDRECT(void)
{
    /* EMRROUNDRECT (pack 4) */
    TEST_TYPE(EMRROUNDRECT, 32, 4);
    TEST_FIELD(EMRROUNDRECT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRROUNDRECT, RECTL, rclBox, 8, 16, 4);
    TEST_FIELD(EMRROUNDRECT, SIZEL, szlCorner, 24, 8, 4);
}

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

static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
{
    /* EMRSCALEVIEWPORTEXTEX (pack 4) */
    TEST_TYPE(EMRSCALEVIEWPORTEXTEX, 24, 4);
    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xNum, 8, 4, 4);
    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xDenom, 12, 4, 4);
    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yNum, 16, 4, 4);
    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yDenom, 20, 4, 4);
}

static void test_pack_EMRSCALEWINDOWEXTEX(void)
{
    /* EMRSCALEWINDOWEXTEX (pack 4) */
    TEST_TYPE(EMRSCALEWINDOWEXTEX, 24, 4);
    TEST_FIELD(EMRSCALEWINDOWEXTEX, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xNum, 8, 4, 4);
    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xDenom, 12, 4, 4);
    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yNum, 16, 4, 4);
    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yDenom, 20, 4, 4);
}

static void test_pack_EMRSELECTCLIPPATH(void)
{
    /* EMRSELECTCLIPPATH (pack 4) */
    TEST_TYPE(EMRSELECTCLIPPATH, 12, 4);
    TEST_FIELD(EMRSELECTCLIPPATH, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSELECTCLIPPATH, DWORD, iMode, 8, 4, 4);
}

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

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

static void test_pack_EMRSELECTPALETTE(void)
{
    /* EMRSELECTPALETTE (pack 4) */
    TEST_TYPE(EMRSELECTPALETTE, 12, 4);
    TEST_FIELD(EMRSELECTPALETTE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSELECTPALETTE, DWORD, ihPal, 8, 4, 4);
}

static void test_pack_EMRSETARCDIRECTION(void)
{
    /* EMRSETARCDIRECTION (pack 4) */
    TEST_TYPE(EMRSETARCDIRECTION, 12, 4);
    TEST_FIELD(EMRSETARCDIRECTION, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETARCDIRECTION, DWORD, iArcDirection, 8, 4, 4);
}

static void test_pack_EMRSETBKCOLOR(void)
{
    /* EMRSETBKCOLOR (pack 4) */
    TEST_TYPE(EMRSETBKCOLOR, 12, 4);
    TEST_FIELD(EMRSETBKCOLOR, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETBKCOLOR, COLORREF, crColor, 8, 4, 4);
}

static void test_pack_EMRSETBKMODE(void)
{
    /* EMRSETBKMODE (pack 4) */
    TEST_TYPE(EMRSETBKMODE, 12, 4);
    TEST_FIELD(EMRSETBKMODE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETBKMODE, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETBRUSHORGEX(void)
{
    /* EMRSETBRUSHORGEX (pack 4) */
    TEST_TYPE(EMRSETBRUSHORGEX, 16, 4);
    TEST_FIELD(EMRSETBRUSHORGEX, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETBRUSHORGEX, POINTL, ptlOrigin, 8, 8, 4);
}

static void test_pack_EMRSETCOLORADJUSTMENT(void)
{
    /* EMRSETCOLORADJUSTMENT (pack 4) */
    TEST_TYPE(EMRSETCOLORADJUSTMENT, 32, 4);
    TEST_FIELD(EMRSETCOLORADJUSTMENT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETCOLORADJUSTMENT, COLORADJUSTMENT, ColorAdjustment, 8, 24, 2);
}

static void test_pack_EMRSETDIBITSTODEVICE(void)
{
    /* EMRSETDIBITSTODEVICE (pack 4) */
    TEST_TYPE(EMRSETDIBITSTODEVICE, 76, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, RECTL, rclBounds, 8, 16, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xDest, 24, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, yDest, 28, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xSrc, 32, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, ySrc, 36, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cxSrc, 40, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cySrc, 44, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBmiSrc, 48, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBmiSrc, 52, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBitsSrc, 56, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBitsSrc, 60, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iUsageSrc, 64, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iStartScan, 68, 4, 4);
    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cScans, 72, 4, 4);
}

static void test_pack_EMRSETICMMODE(void)
{
    /* EMRSETICMMODE (pack 4) */
    TEST_TYPE(EMRSETICMMODE, 12, 4);
    TEST_FIELD(EMRSETICMMODE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETICMMODE, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETMAPMODE(void)
{
    /* EMRSETMAPMODE (pack 4) */
    TEST_TYPE(EMRSETMAPMODE, 12, 4);
    TEST_FIELD(EMRSETMAPMODE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETMAPMODE, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETMAPPERFLAGS(void)
{
    /* EMRSETMAPPERFLAGS (pack 4) */
    TEST_TYPE(EMRSETMAPPERFLAGS, 12, 4);
    TEST_FIELD(EMRSETMAPPERFLAGS, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETMAPPERFLAGS, DWORD, dwFlags, 8, 4, 4);
}

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

static void test_pack_EMRSETMITERLIMIT(void)
{
    /* EMRSETMITERLIMIT (pack 4) */
    TEST_TYPE(EMRSETMITERLIMIT, 12, 4);
    TEST_FIELD(EMRSETMITERLIMIT, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETMITERLIMIT, FLOAT, eMiterLimit, 8, 4, 4);
}

static void test_pack_EMRSETPIXELV(void)
{
    /* EMRSETPIXELV (pack 4) */
    TEST_TYPE(EMRSETPIXELV, 20, 4);
    TEST_FIELD(EMRSETPIXELV, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETPIXELV, POINTL, ptlPixel, 8, 8, 4);
    TEST_FIELD(EMRSETPIXELV, COLORREF, crColor, 16, 4, 4);
}

static void test_pack_EMRSETPOLYFILLMODE(void)
{
    /* EMRSETPOLYFILLMODE (pack 4) */
    TEST_TYPE(EMRSETPOLYFILLMODE, 12, 4);
    TEST_FIELD(EMRSETPOLYFILLMODE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETPOLYFILLMODE, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETROP2(void)
{
    /* EMRSETROP2 (pack 4) */
    TEST_TYPE(EMRSETROP2, 12, 4);
    TEST_FIELD(EMRSETROP2, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETROP2, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETSTRETCHBLTMODE(void)
{
    /* EMRSETSTRETCHBLTMODE (pack 4) */
    TEST_TYPE(EMRSETSTRETCHBLTMODE, 12, 4);
    TEST_FIELD(EMRSETSTRETCHBLTMODE, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETSTRETCHBLTMODE, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETTEXTALIGN(void)
{
    /* EMRSETTEXTALIGN (pack 4) */
    TEST_TYPE(EMRSETTEXTALIGN, 12, 4);
    TEST_FIELD(EMRSETTEXTALIGN, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETTEXTALIGN, DWORD, iMode, 8, 4, 4);
}

static void test_pack_EMRSETTEXTCOLOR(void)
{
    /* EMRSETTEXTCOLOR (pack 4) */
    TEST_TYPE(EMRSETTEXTCOLOR, 12, 4);
    TEST_FIELD(EMRSETTEXTCOLOR, EMR, emr, 0, 8, 4);
    TEST_FIELD(EMRSETTEXTCOLOR, COLORREF, crColor, 8, 4, 4);
}