BOOL EMFDRV_RestoreDC( PHYSDEV dev, INT level ) { PHYSDEV next = GET_NEXT_PHYSDEV( dev, pRestoreDC ); EMFDRV_PDEVICE* physDev = (EMFDRV_PDEVICE*)dev; DC *dc = get_dc_ptr( dev->hdc ); EMRRESTOREDC emr; BOOL ret; emr.emr.iType = EMR_RESTOREDC; emr.emr.nSize = sizeof(emr); if (level < 0) emr.iRelative = level; else emr.iRelative = level - dc->saveLevel - 1; release_dc_ptr( dc ); physDev->restoring++; ret = next->funcs->pRestoreDC( next, level ); physDev->restoring--; if (ret) EMFDRV_WriteRecord( dev, &emr.emr ); return ret; }
/****************************************************************** * EMFDRV_CreatePalette */ static DWORD EMFDRV_CreatePalette(PHYSDEV dev, HPALETTE hPal) { WORD i; struct { EMRCREATEPALETTE hdr; PALETTEENTRY entry[255]; } pal; memset( &pal, 0, sizeof(pal) ); if (!GetObjectW( hPal, sizeof(pal.hdr.lgpl) + sizeof(pal.entry), &pal.hdr.lgpl )) return 0; for (i = 0; i < pal.hdr.lgpl.palNumEntries; i++) pal.hdr.lgpl.palPalEntry[i].peFlags = 0; pal.hdr.emr.iType = EMR_CREATEPALETTE; pal.hdr.emr.nSize = sizeof(pal.hdr) + pal.hdr.lgpl.palNumEntries * sizeof(PALETTEENTRY); pal.hdr.ihPal = EMFDRV_AddHandle( dev, hPal ); if (!EMFDRV_WriteRecord( dev, &pal.hdr.emr )) pal.hdr.ihPal = 0; return pal.hdr.ihPal; }
/*********************************************************************** * EMFDRV_ArcChordPie */ static BOOL EMFDRV_ArcChordPie( PHYSDEV dev, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend, DWORD iType ) { INT temp, xCentre, yCentre, i; double angleStart, angleEnd; double xinterStart, yinterStart, xinterEnd, yinterEnd; EMRARC emr; RECTL bounds; EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev; if(left == right || top == bottom) return FALSE; if(left > right) {temp = left; left = right; right = temp;} if(top > bottom) {temp = top; top = bottom; bottom = temp;} if(GetGraphicsMode(physDev->hdc) == GM_COMPATIBLE) { right--; bottom--; } emr.emr.iType = iType; emr.emr.nSize = sizeof(emr); emr.rclBox.left = left; emr.rclBox.top = top; emr.rclBox.right = right; emr.rclBox.bottom = bottom; emr.ptlStart.x = xstart; emr.ptlStart.y = ystart; emr.ptlEnd.x = xend; emr.ptlEnd.x = yend; /* Now calculate the BBox */ xCentre = (left + right + 1) / 2; yCentre = (top + bottom + 1) / 2; xstart -= xCentre; ystart -= yCentre; xend -= xCentre; yend -= yCentre; /* invert y co-ords to get angle anti-clockwise from x-axis */ angleStart = atan2( -(double)ystart, (double)xstart); angleEnd = atan2( -(double)yend, (double)xend); /* These are the intercepts of the start/end lines with the arc */ xinterStart = (right - left + 1)/2 * cos(angleStart) + xCentre; yinterStart = -(bottom - top + 1)/2 * sin(angleStart) + yCentre; xinterEnd = (right - left + 1)/2 * cos(angleEnd) + xCentre; yinterEnd = -(bottom - top + 1)/2 * sin(angleEnd) + yCentre; if(angleStart < 0) angleStart += 2 * M_PI; if(angleEnd < 0) angleEnd += 2 * M_PI; if(angleEnd < angleStart) angleEnd += 2 * M_PI; bounds.left = min(xinterStart, xinterEnd); bounds.top = min(yinterStart, yinterEnd); bounds.right = max(xinterStart, xinterEnd); bounds.bottom = max(yinterStart, yinterEnd); for(i = 0; i <= 8; i++) { if(i * M_PI / 2 < angleStart) /* loop until we're past start */ continue; if(i * M_PI / 2 > angleEnd) /* if we're past end we're finished */ break; /* the arc touches the rectangle at the start of quadrant i, so adjust BBox to reflect this. */ switch(i % 4) { case 0: bounds.right = right; break; case 1: bounds.top = top; break; case 2: bounds.left = left; break; case 3: bounds.bottom = bottom; break; } } /* If we're drawing a pie then make sure we include the centre */ if(iType == EMR_PIE) { if(bounds.left > xCentre) bounds.left = xCentre; else if(bounds.right < xCentre) bounds.right = xCentre; if(bounds.top > yCentre) bounds.top = yCentre; else if(bounds.bottom < yCentre) bounds.right = yCentre; } if(!EMFDRV_WriteRecord( dev, &emr.emr )) return FALSE; EMFDRV_UpdateBBox( dev, &bounds ); return TRUE; }
/********************************************************************** * EMFDRV_ExtTextOut */ BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx ) { EMREXTTEXTOUTW *pemr; DWORD nSize; BOOL ret; EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE*) dev; int textHeight = 0; int textWidth = 0; const UINT textAlign = GetTextAlign(physDev->hdc); nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT); TRACE("%s %s count %d nSize = %ld\n", debugstr_wn(str, count), wine_dbgstr_rect(lprect), count, nSize); pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); pemr->emr.iType = EMR_EXTTEXTOUTW; pemr->emr.nSize = nSize; pemr->iGraphicsMode = GetGraphicsMode(physDev->hdc); pemr->exScale = pemr->eyScale = 1.0; /* FIXME */ pemr->emrtext.ptlReference.x = x; pemr->emrtext.ptlReference.y = y; pemr->emrtext.nChars = count; pemr->emrtext.offString = sizeof(*pemr); memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR)); pemr->emrtext.fOptions = flags; if(!lprect) { pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0; pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1; } else { pemr->emrtext.rcl.left = lprect->left; pemr->emrtext.rcl.top = lprect->top; pemr->emrtext.rcl.right = lprect->right; pemr->emrtext.rcl.bottom = lprect->bottom; } pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR); if(lpDx) { UINT i; SIZE strSize; memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT)); for (i = 0; i < count; i++) { textWidth += lpDx[i]; } GetTextExtentPoint32W(physDev->hdc, str, count, &strSize); textHeight = strSize.cy; } else { UINT i; INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx); SIZE charSize; for (i = 0; i < count; i++) { GetTextExtentPoint32W(physDev->hdc, str + i, 1, &charSize); dx[i] = charSize.cx; textWidth += charSize.cx; textHeight = max(textHeight, charSize.cy); } } switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) { case TA_CENTER: { pemr->rclBounds.left = x - (textWidth / 2) - 1; pemr->rclBounds.right = x + (textWidth / 2) + 1; break; } case TA_RIGHT: { pemr->rclBounds.left = x - textWidth - 1; pemr->rclBounds.right = x; break; } default: { /* TA_LEFT */ pemr->rclBounds.left = x; pemr->rclBounds.right = x + textWidth + 1; } } switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) { case TA_BASELINE: { TEXTMETRICW tm; GetTextMetricsW(physDev->hdc, &tm); /* Play safe here... it's better to have a bounding box */ /* that is too big than too small. */ pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y + tm.tmDescent + 1; break; } case TA_BOTTOM: { pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y; break; } default: { /* TA_TOP */ pemr->rclBounds.top = y; pemr->rclBounds.bottom = y + textHeight + 1; } } ret = EMFDRV_WriteRecord( dev, &pemr->emr ); if(ret) EMFDRV_UpdateBBox( dev, &pemr->rclBounds ); HeapFree( GetProcessHeap(), 0, pemr ); return ret; }
/****************************************************************** * CloseEnhMetaFile (GDI32.@) */ HENHMETAFILE WINAPI CloseEnhMetaFile(HDC hdc) /* [in] metafile DC */ { HENHMETAFILE hmf; EMFDRV_PDEVICE *physDev; DC *dc; EMREOF emr; HANDLE hMapping = 0; TRACE("(%p)\n", hdc ); if (!(dc = get_dc_ptr( hdc ))) return NULL; if (GetObjectType( hdc ) != OBJ_ENHMETADC) { release_dc_ptr( dc ); return NULL; } if (dc->refcount != 1) { FIXME( "not deleting busy DC %p refcount %u\n", hdc, dc->refcount ); release_dc_ptr( dc ); return NULL; } physDev = (EMFDRV_PDEVICE *)dc->physDev; if(dc->saveLevel) RestoreDC(hdc, 1); if (physDev->dc_brush) DeleteObject( physDev->dc_brush ); if (physDev->dc_pen) DeleteObject( physDev->dc_pen ); if (physDev->screen_dc) DeleteDC( physDev->screen_dc ); emr.emr.iType = EMR_EOF; emr.emr.nSize = sizeof(emr); emr.nPalEntries = 0; emr.offPalEntries = FIELD_OFFSET(EMREOF, nSizeLast); emr.nSizeLast = emr.emr.nSize; EMFDRV_WriteRecord( dc->physDev, &emr.emr ); /* Update rclFrame if not initialized in CreateEnhMetaFile */ if(physDev->emh->rclFrame.left > physDev->emh->rclFrame.right) { physDev->emh->rclFrame.left = physDev->emh->rclBounds.left * physDev->emh->szlMillimeters.cx * 100 / physDev->emh->szlDevice.cx; physDev->emh->rclFrame.top = physDev->emh->rclBounds.top * physDev->emh->szlMillimeters.cy * 100 / physDev->emh->szlDevice.cy; physDev->emh->rclFrame.right = physDev->emh->rclBounds.right * physDev->emh->szlMillimeters.cx * 100 / physDev->emh->szlDevice.cx; physDev->emh->rclFrame.bottom = physDev->emh->rclBounds.bottom * physDev->emh->szlMillimeters.cy * 100 / physDev->emh->szlDevice.cy; } if (physDev->hFile) /* disk based metafile */ { if (SetFilePointer(physDev->hFile, 0, NULL, FILE_BEGIN) != 0) { CloseHandle( physDev->hFile ); free_dc_ptr( dc ); return 0; } if (!WriteFile(physDev->hFile, physDev->emh, sizeof(*physDev->emh), NULL, NULL)) { CloseHandle( physDev->hFile ); free_dc_ptr( dc ); return 0; } HeapFree( GetProcessHeap(), 0, physDev->emh ); hMapping = CreateFileMappingA(physDev->hFile, NULL, PAGE_READONLY, 0, 0, NULL); TRACE("hMapping = %p\n", hMapping ); physDev->emh = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0); TRACE("view = %p\n", physDev->emh ); CloseHandle( hMapping ); CloseHandle( physDev->hFile ); } hmf = EMF_Create_HENHMETAFILE( physDev->emh, (physDev->hFile != 0) ); physDev->emh = NULL; /* So it won't be deleted */ free_dc_ptr( dc ); return hmf; }
/*********************************************************************** * EMFDRV_CreateBrushIndirect */ DWORD EMFDRV_CreateBrushIndirect( PHYSDEV dev, HBRUSH hBrush ) { DWORD index = 0; LOGBRUSH logbrush; if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return 0; switch (logbrush.lbStyle) { case BS_SOLID: case BS_HATCHED: case BS_NULL: { EMRCREATEBRUSHINDIRECT emr; emr.emr.iType = EMR_CREATEBRUSHINDIRECT; emr.emr.nSize = sizeof(emr); emr.ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr.lb.lbStyle = logbrush.lbStyle; emr.lb.lbColor = logbrush.lbColor; emr.lb.lbHatch = logbrush.lbHatch; if(!EMFDRV_WriteRecord( dev, &emr.emr )) index = 0; } break; case BS_PATTERN: case BS_DIBPATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )]; BITMAPINFO *info = (BITMAPINFO *)buffer; DWORD info_size; void *bits; UINT usage; if (!get_brush_bitmap_info( hBrush, info, &bits, &usage )) break; info_size = get_dib_info_size( info, usage ); emr = HeapAlloc( GetProcessHeap(), 0, sizeof(EMRCREATEDIBPATTERNBRUSHPT)+info_size+info->bmiHeader.biSizeImage ); if(!emr) break; if (logbrush.lbStyle == BS_PATTERN && info->bmiHeader.biBitCount == 1) { /* Presumably to reduce the size of the written EMF, MS supports an * undocumented iUsage value of 2, indicating a mono bitmap without the * 8 byte 2 entry black/white palette. Stupidly, they could have saved * over 20 bytes more by also ignoring the BITMAPINFO fields that are * irrelevant/constant for monochrome bitmaps. * FIXME: It may be that the DIB functions themselves accept this value. */ emr->emr.iType = EMR_CREATEMONOBRUSH; usage = DIB_PAL_MONO; /* FIXME: There is an extra DWORD written by native before the BMI. * Not sure what its meant to contain. */ emr->offBmi = sizeof( EMRCREATEDIBPATTERNBRUSHPT ) + sizeof(DWORD); emr->cbBmi = sizeof( BITMAPINFOHEADER ); } else { emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT; emr->offBmi = sizeof( EMRCREATEDIBPATTERNBRUSHPT ); emr->cbBmi = info_size; } emr->ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr->iUsage = usage; emr->offBits = emr->offBmi + emr->cbBmi; emr->cbBits = info->bmiHeader.biSizeImage; emr->emr.nSize = emr->offBits + emr->cbBits; memcpy( (BYTE *)emr + emr->offBmi, info, emr->cbBmi ); memcpy( (BYTE *)emr + emr->offBits, bits, emr->cbBits ); if(!EMFDRV_WriteRecord( dev, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); } break; default: FIXME("Unknown style %x\n", logbrush.lbStyle); break; } return index; }
BOOL EMFDRV_StretchBlt( PHYSDEV devDst, struct bitblt_coords *dst, PHYSDEV devSrc, struct bitblt_coords *src, DWORD rop ) { BOOL ret; PEMRBITBLT pEMR; UINT emrSize; UINT bmiSize; UINT bitsSize; UINT size; BITMAP BM; WORD nBPP = 0; LPBITMAPINFOHEADER lpBmiH; HBITMAP hBitmap = NULL; DWORD emrType; if (devSrc->funcs == devDst->funcs) return FALSE; /* can't use a metafile DC as source */ if (src->log_width == dst->log_width && src->log_height == dst->log_height) { emrType = EMR_BITBLT; emrSize = sizeof(EMRBITBLT); } else { emrType = EMR_STRETCHBLT; emrSize = sizeof(EMRSTRETCHBLT); } hBitmap = GetCurrentObject(devSrc->hdc, OBJ_BITMAP); if(sizeof(BITMAP) != GetObjectW(hBitmap, sizeof(BITMAP), &BM)) return FALSE; nBPP = BM.bmPlanes * BM.bmBitsPixel; if(nBPP > 8) nBPP = 24; /* FIXME Can't get 16bpp to work for some reason */ bitsSize = get_dib_stride( BM.bmWidth, nBPP ) * BM.bmHeight; bmiSize = sizeof(BITMAPINFOHEADER) + (nBPP <= 8 ? 1 << nBPP : 0) * sizeof(RGBQUAD); size = emrSize + bmiSize + bitsSize; pEMR = HeapAlloc(GetProcessHeap(), 0, size); if (!pEMR) return FALSE; /* Initialize EMR */ pEMR->emr.iType = emrType; pEMR->emr.nSize = size; pEMR->rclBounds.left = dst->log_x; pEMR->rclBounds.top = dst->log_y; pEMR->rclBounds.right = dst->log_x + dst->log_width - 1; pEMR->rclBounds.bottom = dst->log_y + dst->log_height - 1; pEMR->xDest = dst->log_x; pEMR->yDest = dst->log_y; pEMR->cxDest = dst->log_width; pEMR->cyDest = dst->log_height; pEMR->dwRop = rop; pEMR->xSrc = src->log_x; pEMR->ySrc = src->log_y; GetTransform(devSrc->hdc, 0x204, &pEMR->xformSrc); pEMR->crBkColorSrc = GetBkColor(devSrc->hdc); pEMR->iUsageSrc = DIB_RGB_COLORS; pEMR->offBmiSrc = emrSize; pEMR->offBitsSrc = emrSize + bmiSize; pEMR->cbBmiSrc = bmiSize; pEMR->cbBitsSrc = bitsSize; if (emrType == EMR_STRETCHBLT) { PEMRSTRETCHBLT pEMRStretch = (PEMRSTRETCHBLT)pEMR; pEMRStretch->cxSrc = src->log_width; pEMRStretch->cySrc = src->log_height; } /* Initialize BITMAPINFO structure */ lpBmiH = (LPBITMAPINFOHEADER)((BYTE*)pEMR + pEMR->offBmiSrc); lpBmiH->biSize = sizeof(BITMAPINFOHEADER); lpBmiH->biWidth = BM.bmWidth; lpBmiH->biHeight = BM.bmHeight; lpBmiH->biPlanes = BM.bmPlanes; lpBmiH->biBitCount = nBPP; /* Assume the bitmap isn't compressed and set the BI_RGB flag. */ lpBmiH->biCompression = BI_RGB; lpBmiH->biSizeImage = bitsSize; lpBmiH->biYPelsPerMeter = 0; lpBmiH->biXPelsPerMeter = 0; lpBmiH->biClrUsed = nBPP <= 8 ? 1 << nBPP : 0; /* Set biClrImportant to 0, indicating that all of the device colors are important. */ lpBmiH->biClrImportant = 0; /* Initialize bitmap bits */ if (GetDIBits(devSrc->hdc, hBitmap, 0, (UINT)lpBmiH->biHeight, (BYTE*)pEMR + pEMR->offBitsSrc, (LPBITMAPINFO)lpBmiH, DIB_RGB_COLORS)) { ret = EMFDRV_WriteRecord(devDst, (EMR*)pEMR); if (ret) EMFDRV_UpdateBBox(devDst, &(pEMR->rclBounds)); } else ret = FALSE; HeapFree( GetProcessHeap(), 0, pEMR); return ret; }
/********************************************************************** * EMFDRV_ExtTextOut */ BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx ) { EMFDRV_PDEVICE *physDev = get_emf_physdev( dev ); DC *dc = get_physdev_dc( dev ); EMREXTTEXTOUTW *pemr; DWORD nSize; BOOL ret; int textHeight = 0; int textWidth = 0; const UINT textAlign = dc->textAlign; const INT graphicsMode = dc->GraphicsMode; FLOAT exScale, eyScale; nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT); TRACE("%s %s count %d nSize = %d\n", debugstr_wn(str, count), wine_dbgstr_rect(lprect), count, nSize); pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize); if (graphicsMode == GM_COMPATIBLE) { const INT horzSize = GetDeviceCaps( dev->hdc, HORZSIZE ); const INT horzRes = GetDeviceCaps( dev->hdc, HORZRES ); const INT vertSize = GetDeviceCaps( dev->hdc, VERTSIZE ); const INT vertRes = GetDeviceCaps( dev->hdc, VERTRES ); SIZE wndext, vportext; GetViewportExtEx( dev->hdc, &vportext ); GetWindowExtEx( dev->hdc, &wndext ); exScale = 100.0 * ((FLOAT)horzSize / (FLOAT)horzRes) / ((FLOAT)wndext.cx / (FLOAT)vportext.cx); eyScale = 100.0 * ((FLOAT)vertSize / (FLOAT)vertRes) / ((FLOAT)wndext.cy / (FLOAT)vportext.cy); } else { exScale = 0.0; eyScale = 0.0; } pemr->emr.iType = EMR_EXTTEXTOUTW; pemr->emr.nSize = nSize; pemr->iGraphicsMode = graphicsMode; pemr->exScale = exScale; pemr->eyScale = eyScale; pemr->emrtext.ptlReference.x = x; pemr->emrtext.ptlReference.y = y; pemr->emrtext.nChars = count; pemr->emrtext.offString = sizeof(*pemr); memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR)); pemr->emrtext.fOptions = flags; if(!lprect) { pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0; pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1; } else { pemr->emrtext.rcl.left = lprect->left; pemr->emrtext.rcl.top = lprect->top; pemr->emrtext.rcl.right = lprect->right; pemr->emrtext.rcl.bottom = lprect->bottom; } pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR); if(lpDx) { UINT i; SIZE strSize; memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT)); for (i = 0; i < count; i++) { textWidth += lpDx[i]; } if (GetTextExtentPoint32W( dev->hdc, str, count, &strSize )) textHeight = strSize.cy; } else { UINT i; INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx); SIZE charSize; for (i = 0; i < count; i++) { if (GetTextExtentPoint32W( dev->hdc, str + i, 1, &charSize )) { dx[i] = charSize.cx; textWidth += charSize.cx; textHeight = max(textHeight, charSize.cy); } } } if (physDev->path) { pemr->rclBounds.left = pemr->rclBounds.top = 0; pemr->rclBounds.right = pemr->rclBounds.bottom = -1; goto no_bounds; } /* FIXME: handle font escapement */ switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) { case TA_CENTER: { pemr->rclBounds.left = x - (textWidth / 2) - 1; pemr->rclBounds.right = x + (textWidth / 2) + 1; break; } case TA_RIGHT: { pemr->rclBounds.left = x - textWidth - 1; pemr->rclBounds.right = x; break; } default: { /* TA_LEFT */ pemr->rclBounds.left = x; pemr->rclBounds.right = x + textWidth + 1; } } switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) { case TA_BASELINE: { TEXTMETRICW tm; if (!GetTextMetricsW( dev->hdc, &tm )) tm.tmDescent = 0; /* Play safe here... it's better to have a bounding box */ /* that is too big than too small. */ pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y + tm.tmDescent + 1; break; } case TA_BOTTOM: { pemr->rclBounds.top = y - textHeight - 1; pemr->rclBounds.bottom = y; break; } default: { /* TA_TOP */ pemr->rclBounds.top = y; pemr->rclBounds.bottom = y + textHeight + 1; } } EMFDRV_UpdateBBox( dev, &pemr->rclBounds ); no_bounds: ret = EMFDRV_WriteRecord( dev, &pemr->emr ); HeapFree( GetProcessHeap(), 0, pemr ); return ret; }
/*********************************************************************** * EMFDRV_CreateBrushIndirect */ DWORD EMFDRV_CreateBrushIndirect( PHYSDEV dev, HBRUSH hBrush ) { DWORD index = 0; LOGBRUSH logbrush; if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return 0; switch (logbrush.lbStyle) { case BS_SOLID: case BS_HATCHED: case BS_NULL: { EMRCREATEBRUSHINDIRECT emr; emr.emr.iType = EMR_CREATEBRUSHINDIRECT; emr.emr.nSize = sizeof(emr); emr.ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr.lb.lbStyle = logbrush.lbStyle; emr.lb.lbColor = logbrush.lbColor; emr.lb.lbHatch = logbrush.lbHatch; if(!EMFDRV_WriteRecord( dev, &emr.emr )) index = 0; } break; case BS_DIBPATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; DWORD bmSize, biSize, size; BITMAPINFO *info = GlobalLock( (HGLOBAL)logbrush.lbHatch ); if (info->bmiHeader.biCompression) bmSize = info->bmiHeader.biSizeImage; else bmSize = get_dib_image_size( info ); biSize = bitmap_info_size(info, LOWORD(logbrush.lbColor)); size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize + bmSize; emr = HeapAlloc( GetProcessHeap(), 0, size ); if(!emr) break; emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT; emr->emr.nSize = size; emr->ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr->iUsage = LOWORD(logbrush.lbColor); emr->offBmi = sizeof(EMRCREATEDIBPATTERNBRUSHPT); emr->cbBmi = biSize; emr->offBits = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize; emr->cbBits = bmSize; memcpy((char *)emr + sizeof(EMRCREATEDIBPATTERNBRUSHPT), info, biSize + bmSize ); if(!EMFDRV_WriteRecord( dev, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); GlobalUnlock( (HGLOBAL)logbrush.lbHatch ); } break; case BS_PATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )]; BITMAPINFO *dst_info, *src_info = (BITMAPINFO *)buffer; struct gdi_image_bits bits; DWORD size; if (!get_bitmap_image( (HANDLE)logbrush.lbHatch, src_info, &bits )) break; if (src_info->bmiHeader.biBitCount != 1) { FIXME("Trying to create a color pattern brush\n"); if (bits.free) bits.free( &bits ); break; } /* FIXME: There is an extra DWORD written by native before the BMI. * Not sure what its meant to contain. */ size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + sizeof(DWORD) + sizeof(BITMAPINFOHEADER) + src_info->bmiHeader.biSizeImage; emr = HeapAlloc( GetProcessHeap(), 0, size ); if(!emr) { if (bits.free) bits.free( &bits ); break; } dst_info = (BITMAPINFO *)((LPBYTE)(emr + 1) + sizeof(DWORD)); dst_info->bmiHeader = src_info->bmiHeader; memcpy( &dst_info->bmiHeader + 1, bits.ptr, dst_info->bmiHeader.biSizeImage ); if (bits.free) bits.free( &bits ); emr->emr.iType = EMR_CREATEMONOBRUSH; emr->emr.nSize = size; emr->ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); /* Presumably to reduce the size of the written EMF, MS supports an * undocumented iUsage value of 2, indicating a mono bitmap without the * 8 byte 2 entry black/white palette. Stupidly, they could have saved * over 20 bytes more by also ignoring the BITMAPINFO fields that are * irrelevant/constant for monochrome bitmaps. * FIXME: It may be that the DIB functions themselves accept this value. */ emr->iUsage = DIB_PAL_MONO; emr->offBmi = (LPBYTE)dst_info - (LPBYTE)emr; emr->cbBmi = sizeof( BITMAPINFOHEADER ); emr->offBits = emr->offBmi + emr->cbBmi; emr->cbBits = dst_info->bmiHeader.biSizeImage; if(!EMFDRV_WriteRecord( dev, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); } break; default: FIXME("Unknown style %x\n", logbrush.lbStyle); break; } return index; }
/*********************************************************************** * EMFDRV_CreateBrushIndirect */ DWORD EMFDRV_CreateBrushIndirect( DC *dc, HBRUSH hBrush ) { DWORD index = 0; LOGBRUSH logbrush; if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return 0; switch (logbrush.lbStyle) { case BS_SOLID: case BS_HATCHED: case BS_NULL: { EMRCREATEBRUSHINDIRECT emr; emr.emr.iType = EMR_CREATEBRUSHINDIRECT; emr.emr.nSize = sizeof(emr); emr.ihBrush = index = EMFDRV_AddHandleDC( dc ); emr.lb = logbrush; if(!EMFDRV_WriteRecord( dc, &emr.emr )) index = 0; } break; case BS_DIBPATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; DWORD bmSize, biSize, size; BITMAPINFO *info = GlobalLock16(logbrush.lbHatch); if (info->bmiHeader.biCompression) bmSize = info->bmiHeader.biSizeImage; else bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth, info->bmiHeader.biHeight, info->bmiHeader.biBitCount); biSize = DIB_BitmapInfoSize(info, LOWORD(logbrush.lbColor)); size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize + bmSize; emr = HeapAlloc( GetProcessHeap(), 0, size ); if(!emr) break; emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT; emr->emr.nSize = size; emr->ihBrush = index = EMFDRV_AddHandleDC( dc ); emr->iUsage = LOWORD(logbrush.lbColor); emr->offBmi = sizeof(EMRCREATEDIBPATTERNBRUSHPT); emr->cbBmi = biSize; emr->offBits = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize; memcpy((char *)emr + sizeof(EMRCREATEDIBPATTERNBRUSHPT), info, biSize + bmSize ); if(!EMFDRV_WriteRecord( dc, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); GlobalUnlock16(logbrush.lbHatch); } break; case BS_PATTERN: FIXME("Unsupported style %x\n", logbrush.lbStyle); break; default: FIXME("Unknown style %x\n", logbrush.lbStyle); break; } return index; }
static BOOL EMFDRV_BitBlockTransfer( PHYSDEV devDst, INT xDst, INT yDst, INT widthDst, INT heightDst, PHYSDEV devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, DWORD rop, DWORD emrType) { BOOL ret; PEMRBITBLT pEMR; UINT emrSize; UINT bmiSize; UINT bitsSize; UINT size; BITMAP BM; WORD nBPP; LPBITMAPINFOHEADER lpBmiH; EMFDRV_PDEVICE* physDevSrc = (EMFDRV_PDEVICE*)devSrc; HBITMAP hBitmap = GetCurrentObject(physDevSrc->hdc, OBJ_BITMAP); if (emrType == EMR_BITBLT) emrSize = sizeof(EMRBITBLT); else if (emrType == EMR_STRETCHBLT) emrSize = sizeof(EMRSTRETCHBLT); else return FALSE; if(sizeof(BITMAP) != GetObjectW(hBitmap, sizeof(BITMAP), &BM)) return FALSE; nBPP = BM.bmPlanes * BM.bmBitsPixel; if(nBPP > 8) nBPP = 24; /* FIXME Can't get 16bpp to work for some reason */ bitsSize = DIB_GetDIBWidthBytes(BM.bmWidth, nBPP) * BM.bmHeight; bmiSize = sizeof(BITMAPINFOHEADER) + (nBPP <= 8 ? 1 << nBPP : 0) * sizeof(RGBQUAD); size = emrSize + bmiSize + bitsSize; pEMR = HeapAlloc(GetProcessHeap(), 0, size); if (!pEMR) return FALSE; /* Initialize EMR */ pEMR->emr.iType = emrType; pEMR->emr.nSize = size; pEMR->rclBounds.left = xDst; pEMR->rclBounds.top = yDst; pEMR->rclBounds.right = xDst + widthDst - 1; pEMR->rclBounds.bottom = yDst + heightDst - 1; pEMR->xDest = xDst; pEMR->yDest = yDst; pEMR->cxDest = widthDst; pEMR->cyDest = heightDst; pEMR->dwRop = rop; pEMR->xSrc = xSrc; pEMR->ySrc = ySrc; pEMR->xformSrc.eM11 = 1.0; /** FIXME: */ pEMR->xformSrc.eM12 = 0.0; /** Setting default */ pEMR->xformSrc.eM21 = 0.0; /** value. */ pEMR->xformSrc.eM22 = 1.0; /** Where should we */ pEMR->xformSrc.eDx = 0.0; /** get that info */ pEMR->xformSrc.eDy = 0.0; /** ???? */ pEMR->crBkColorSrc = GetBkColor(physDevSrc->hdc); pEMR->iUsageSrc = DIB_RGB_COLORS; pEMR->offBmiSrc = emrSize; pEMR->cbBmiSrc = bmiSize; pEMR->offBitsSrc = emrSize + bmiSize; pEMR->cbBitsSrc = bitsSize; if (emrType == EMR_STRETCHBLT) { PEMRSTRETCHBLT pEMRStretch = (PEMRSTRETCHBLT)pEMR; pEMRStretch->cxSrc = widthSrc; pEMRStretch->cySrc = heightSrc; } /* Initialize BITMAPINFO structure */ lpBmiH = (LPBITMAPINFOHEADER)((BYTE*)pEMR + pEMR->offBmiSrc); lpBmiH->biSize = sizeof(BITMAPINFOHEADER); lpBmiH->biWidth = BM.bmWidth; lpBmiH->biHeight = BM.bmHeight; lpBmiH->biPlanes = BM.bmPlanes; lpBmiH->biBitCount = nBPP; /* Assume the bitmap isn't compressed and set the BI_RGB flag. */ lpBmiH->biCompression = BI_RGB; lpBmiH->biSizeImage = bitsSize; lpBmiH->biYPelsPerMeter = /* 1 meter = 39.37 inch */ MulDiv(GetDeviceCaps(physDevSrc->hdc,LOGPIXELSX),3937,100); lpBmiH->biXPelsPerMeter = MulDiv(GetDeviceCaps(physDevSrc->hdc,LOGPIXELSY),3937,100); lpBmiH->biClrUsed = nBPP <= 8 ? 1 << nBPP : 0; /* Set biClrImportant to 0, indicating that all of the device colors are important. */ lpBmiH->biClrImportant = 0; /* Initialize bitmap bits */ if (GetDIBits(physDevSrc->hdc, hBitmap, 0, (UINT)lpBmiH->biHeight, (BYTE*)pEMR + pEMR->offBitsSrc, (LPBITMAPINFO)lpBmiH, DIB_RGB_COLORS)) { ret = EMFDRV_WriteRecord(devDst, (EMR*)pEMR); if (ret) EMFDRV_UpdateBBox(devDst, &(pEMR->rclBounds)); } else ret = FALSE; HeapFree( GetProcessHeap(), 0, pEMR); return ret; }
INT CDECL EMFDRV_StretchDIBits( PHYSDEV dev, INT xDst, INT yDst, INT widthDst, INT heightDst, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits, const BITMAPINFO *info, UINT wUsage, DWORD dwRop ) { EMRSTRETCHDIBITS *emr; BOOL ret; UINT bmi_size=0, bits_size, emr_size; bits_size = DIB_GetDIBImageBytes(info->bmiHeader.biWidth, info->bmiHeader.biHeight, info->bmiHeader.biBitCount); /* calculate the size of the colour table */ bmi_size = bitmap_info_size(info, wUsage); emr_size = sizeof (EMRSTRETCHDIBITS) + bmi_size + bits_size; emr = HeapAlloc(GetProcessHeap(), 0, emr_size ); if (!emr) return 0; /* write a bitmap info header (with colours) to the record */ memcpy( &emr[1], info, bmi_size); /* write bitmap bits to the record */ memcpy ( ( (BYTE *) (&emr[1]) ) + bmi_size, bits, bits_size); /* fill in the EMR header at the front of our piece of memory */ emr->emr.iType = EMR_STRETCHDIBITS; emr->emr.nSize = emr_size; emr->xDest = xDst; emr->yDest = yDst; emr->cxDest = widthDst; emr->cyDest = heightDst; emr->dwRop = dwRop; emr->xSrc = xSrc; /* FIXME: only save the piece of the bitmap needed */ emr->ySrc = ySrc; emr->iUsageSrc = wUsage; emr->offBmiSrc = sizeof (EMRSTRETCHDIBITS); emr->cbBmiSrc = bmi_size; emr->offBitsSrc = emr->offBmiSrc + bmi_size; emr->cbBitsSrc = bits_size; emr->cxSrc = widthSrc; emr->cySrc = heightSrc; emr->rclBounds.left = xDst; emr->rclBounds.top = yDst; emr->rclBounds.right = xDst + widthDst; emr->rclBounds.bottom = yDst + heightDst; /* save the record we just created */ ret = EMFDRV_WriteRecord( dev, &emr->emr ); if(ret) EMFDRV_UpdateBBox( dev, &emr->rclBounds ); HeapFree(GetProcessHeap(), 0, emr); return ret ? heightSrc : GDI_ERROR; }
/*********************************************************************** * EMFDRV_CreateBrushIndirect */ DWORD EMFDRV_CreateBrushIndirect( PHYSDEV dev, HBRUSH hBrush ) { DWORD index = 0; LOGBRUSH logbrush; if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return 0; switch (logbrush.lbStyle) { case BS_SOLID: case BS_HATCHED: case BS_NULL: { EMRCREATEBRUSHINDIRECT emr; emr.emr.iType = EMR_CREATEBRUSHINDIRECT; emr.emr.nSize = sizeof(emr); emr.ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr.lb.lbStyle = logbrush.lbStyle; emr.lb.lbColor = logbrush.lbColor; emr.lb.lbHatch = logbrush.lbHatch; if(!EMFDRV_WriteRecord( dev, &emr.emr )) index = 0; } break; case BS_DIBPATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; DWORD bmSize, biSize, size; BITMAPINFO *info = GlobalLock( (HGLOBAL)logbrush.lbHatch ); if (info->bmiHeader.biCompression) bmSize = info->bmiHeader.biSizeImage; else bmSize = DIB_GetDIBImageBytes(info->bmiHeader.biWidth, info->bmiHeader.biHeight, info->bmiHeader.biBitCount); biSize = bitmap_info_size(info, LOWORD(logbrush.lbColor)); size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize + bmSize; emr = HeapAlloc( GetProcessHeap(), 0, size ); if(!emr) break; emr->emr.iType = EMR_CREATEDIBPATTERNBRUSHPT; emr->emr.nSize = size; emr->ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); emr->iUsage = LOWORD(logbrush.lbColor); emr->offBmi = sizeof(EMRCREATEDIBPATTERNBRUSHPT); emr->cbBmi = biSize; emr->offBits = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize; emr->cbBits = bmSize; memcpy((char *)emr + sizeof(EMRCREATEDIBPATTERNBRUSHPT), info, biSize + bmSize ); if(!EMFDRV_WriteRecord( dev, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); GlobalUnlock( (HGLOBAL)logbrush.lbHatch ); } break; case BS_PATTERN: { EMRCREATEDIBPATTERNBRUSHPT *emr; BITMAPINFOHEADER *info; BITMAP bm; DWORD bmSize, biSize, size; GetObjectA((HANDLE)logbrush.lbHatch, sizeof(bm), &bm); if (bm.bmBitsPixel != 1 || bm.bmPlanes != 1) { FIXME("Trying to create a color pattern brush\n"); break; } /* BMP will be aligned to 32 bits, not 16 */ bmSize = DIB_GetDIBImageBytes(bm.bmWidth, bm.bmHeight, bm.bmBitsPixel); biSize = sizeof(BITMAPINFOHEADER); /* FIXME: There is an extra DWORD written by native before the BMI. * Not sure what its meant to contain. */ size = sizeof(EMRCREATEDIBPATTERNBRUSHPT) + biSize + bmSize + sizeof(DWORD); emr = HeapAlloc( GetProcessHeap(), 0, size ); if(!emr) break; info = (BITMAPINFOHEADER *)((LPBYTE)emr + sizeof(EMRCREATEDIBPATTERNBRUSHPT) + sizeof(DWORD)); info->biSize = sizeof(BITMAPINFOHEADER); info->biWidth = bm.bmWidth; info->biHeight = bm.bmHeight; info->biPlanes = bm.bmPlanes; info->biBitCount = bm.bmBitsPixel; info->biSizeImage = bmSize; GetBitmapBits((HANDLE)logbrush.lbHatch, bm.bmHeight * BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), (LPBYTE)info + sizeof(BITMAPINFOHEADER)); /* Change the padding to be DIB compatible if needed */ if (bm.bmWidth & 31) EMFDRV_PadTo32((LPBYTE)info + sizeof(BITMAPINFOHEADER), bm.bmWidth, bm.bmHeight); emr->emr.iType = EMR_CREATEMONOBRUSH; emr->emr.nSize = size; emr->ihBrush = index = EMFDRV_AddHandle( dev, hBrush ); /* Presumably to reduce the size of the written EMF, MS supports an * undocumented iUsage value of 2, indicating a mono bitmap without the * 8 byte 2 entry black/white palette. Stupidly, they could have saved * over 20 bytes more by also ignoring the BITMAPINFO fields that are * irrelevant/constant for monochrome bitmaps. * FIXME: It may be that the DIB functions themselves accept this value. */ emr->iUsage = DIB_PAL_MONO; emr->offBmi = (LPBYTE)info - (LPBYTE)emr; emr->cbBmi = biSize; emr->offBits = emr->offBmi + biSize; emr->cbBits = bmSize; if(!EMFDRV_WriteRecord( dev, &emr->emr )) index = 0; HeapFree( GetProcessHeap(), 0, emr ); } break; default: FIXME("Unknown style %x\n", logbrush.lbStyle); break; } return index; }
/********************************************************************** * EMFDRV_PolyPolylinegon * * Helper for EMFDRV_PolyPoly{line|gon} */ static BOOL EMFDRV_PolyPolylinegon( PHYSDEV dev, const POINT* pt, const INT* counts, UINT polys, DWORD iType) { EMRPOLYPOLYLINE *emr; DWORD cptl = 0, poly, size, i; INT point; const RECTL empty = {0, 0, -1, -1}; RECTL bounds = empty; const POINT *pts; BOOL ret, use_small_emr = TRUE, bounds_valid = TRUE; pts = pt; for(poly = 0; poly < polys; poly++) { cptl += counts[poly]; if(counts[poly] < 2) bounds_valid = FALSE; for(point = 0; point < counts[poly]; point++) { /* check whether all points fit in the SHORT int POINT structure */ if( ((pts->x+0x8000) & ~0xffff ) || ((pts->y+0x8000) & ~0xffff ) ) use_small_emr = FALSE; if(pts == pt) { bounds.left = bounds.right = pts->x; bounds.top = bounds.bottom = pts->y; } else { if(bounds.left > pts->x) bounds.left = pts->x; else if(bounds.right < pts->x) bounds.right = pts->x; if(bounds.top > pts->y) bounds.top = pts->y; else if(bounds.bottom < pts->y) bounds.bottom = pts->y; } pts++; } } if(!cptl) bounds_valid = FALSE; size = FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts[polys]); if(use_small_emr) size += cptl * sizeof(POINTS); else size += cptl * sizeof(POINTL); emr = HeapAlloc( GetProcessHeap(), 0, size ); emr->emr.iType = iType; if(use_small_emr) emr->emr.iType += EMR_POLYPOLYLINE16 - EMR_POLYPOLYLINE; emr->emr.nSize = size; if(bounds_valid) emr->rclBounds = bounds; else emr->rclBounds = empty; emr->nPolys = polys; emr->cptl = cptl; if(polys) { memcpy( emr->aPolyCounts, counts, polys * sizeof(DWORD) ); if(cptl) { if(use_small_emr) { POINTS *out_pts = (POINTS *)(emr->aPolyCounts + polys); for(i = 0; i < cptl; i++ ) { out_pts[i].x = pt[i].x; out_pts[i].y = pt[i].y; } } else memcpy( emr->aPolyCounts + polys, pt, cptl * sizeof(POINTL) ); } } ret = EMFDRV_WriteRecord( dev, &emr->emr ); if(ret && !bounds_valid) { ret = FALSE; SetLastError( ERROR_INVALID_PARAMETER ); } if(ret) EMFDRV_UpdateBBox( dev, &emr->rclBounds ); HeapFree( GetProcessHeap(), 0, emr ); return ret; }