| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "core/fxge/include/fx_ge.h" |
| |
| #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_DESKTOP_ |
| #include <windows.h> |
| #include <algorithm> |
| |
| namespace Gdiplus { |
| using std::min; |
| using std::max; |
| } // namespace Gdiplus |
| |
| #include <gdiplus.h> |
| |
| #include "core/fxge/include/cfx_gemodule.h" |
| #include "core/fxge/win32/cfx_windowsdib.h" |
| #include "core/fxge/win32/win32_int.h" |
| |
| using namespace Gdiplus; // NOLINT |
| using namespace Gdiplus::DllExports; // NOLINT |
| |
| #define GdiFillType2Gdip(fill_type) \ |
| (fill_type == ALTERNATE ? FillModeAlternate : FillModeWinding) |
| |
| enum { |
| FuncId_GdipCreatePath2, |
| FuncId_GdipSetPenDashStyle, |
| FuncId_GdipSetPenDashArray, |
| FuncId_GdipSetPenDashCap197819, |
| FuncId_GdipSetPenLineJoin, |
| FuncId_GdipSetPenWidth, |
| FuncId_GdipCreateFromHDC, |
| FuncId_GdipSetPageUnit, |
| FuncId_GdipSetSmoothingMode, |
| FuncId_GdipCreateSolidFill, |
| FuncId_GdipFillPath, |
| FuncId_GdipDeleteBrush, |
| FuncId_GdipCreatePen1, |
| FuncId_GdipSetPenMiterLimit, |
| FuncId_GdipDrawPath, |
| FuncId_GdipDeletePen, |
| FuncId_GdipDeletePath, |
| FuncId_GdipDeleteGraphics, |
| FuncId_GdipCreateBitmapFromFileICM, |
| FuncId_GdipCreateBitmapFromStreamICM, |
| FuncId_GdipGetImageHeight, |
| FuncId_GdipGetImageWidth, |
| FuncId_GdipGetImagePixelFormat, |
| FuncId_GdipBitmapLockBits, |
| FuncId_GdipGetImagePaletteSize, |
| FuncId_GdipGetImagePalette, |
| FuncId_GdipBitmapUnlockBits, |
| FuncId_GdipDisposeImage, |
| FuncId_GdipFillRectangle, |
| FuncId_GdipCreateBitmapFromScan0, |
| FuncId_GdipSetImagePalette, |
| FuncId_GdipSetInterpolationMode, |
| FuncId_GdipDrawImagePointsI, |
| FuncId_GdipCreateBitmapFromGdiDib, |
| FuncId_GdiplusStartup, |
| FuncId_GdipDrawLineI, |
| FuncId_GdipResetClip, |
| FuncId_GdipCreatePath, |
| FuncId_GdipAddPathPath, |
| FuncId_GdipSetPathFillMode, |
| FuncId_GdipSetClipPath, |
| FuncId_GdipGetClip, |
| FuncId_GdipCreateRegion, |
| FuncId_GdipGetClipBoundsI, |
| FuncId_GdipSetClipRegion, |
| FuncId_GdipWidenPath, |
| FuncId_GdipAddPathLine, |
| FuncId_GdipAddPathRectangle, |
| FuncId_GdipDeleteRegion, |
| FuncId_GdipGetDC, |
| FuncId_GdipReleaseDC, |
| FuncId_GdipSetPenLineCap197819, |
| FuncId_GdipSetPenDashOffset, |
| FuncId_GdipResetPath, |
| FuncId_GdipCreateRegionPath, |
| FuncId_GdipCreateFont, |
| FuncId_GdipGetFontSize, |
| FuncId_GdipCreateFontFamilyFromName, |
| FuncId_GdipSetTextRenderingHint, |
| FuncId_GdipDrawDriverString, |
| FuncId_GdipCreateMatrix2, |
| FuncId_GdipDeleteMatrix, |
| FuncId_GdipSetWorldTransform, |
| FuncId_GdipResetWorldTransform, |
| FuncId_GdipDeleteFontFamily, |
| FuncId_GdipDeleteFont, |
| FuncId_GdipNewPrivateFontCollection, |
| FuncId_GdipDeletePrivateFontCollection, |
| FuncId_GdipPrivateAddMemoryFont, |
| FuncId_GdipGetFontCollectionFamilyList, |
| FuncId_GdipGetFontCollectionFamilyCount, |
| FuncId_GdipSetTextContrast, |
| FuncId_GdipSetPixelOffsetMode, |
| FuncId_GdipGetImageGraphicsContext, |
| FuncId_GdipDrawImageI, |
| FuncId_GdipDrawImageRectI, |
| FuncId_GdipDrawString, |
| FuncId_GdipSetPenTransform, |
| }; |
| static LPCSTR g_GdipFuncNames[] = { |
| "GdipCreatePath2", |
| "GdipSetPenDashStyle", |
| "GdipSetPenDashArray", |
| "GdipSetPenDashCap197819", |
| "GdipSetPenLineJoin", |
| "GdipSetPenWidth", |
| "GdipCreateFromHDC", |
| "GdipSetPageUnit", |
| "GdipSetSmoothingMode", |
| "GdipCreateSolidFill", |
| "GdipFillPath", |
| "GdipDeleteBrush", |
| "GdipCreatePen1", |
| "GdipSetPenMiterLimit", |
| "GdipDrawPath", |
| "GdipDeletePen", |
| "GdipDeletePath", |
| "GdipDeleteGraphics", |
| "GdipCreateBitmapFromFileICM", |
| "GdipCreateBitmapFromStreamICM", |
| "GdipGetImageHeight", |
| "GdipGetImageWidth", |
| "GdipGetImagePixelFormat", |
| "GdipBitmapLockBits", |
| "GdipGetImagePaletteSize", |
| "GdipGetImagePalette", |
| "GdipBitmapUnlockBits", |
| "GdipDisposeImage", |
| "GdipFillRectangle", |
| "GdipCreateBitmapFromScan0", |
| "GdipSetImagePalette", |
| "GdipSetInterpolationMode", |
| "GdipDrawImagePointsI", |
| "GdipCreateBitmapFromGdiDib", |
| "GdiplusStartup", |
| "GdipDrawLineI", |
| "GdipResetClip", |
| "GdipCreatePath", |
| "GdipAddPathPath", |
| "GdipSetPathFillMode", |
| "GdipSetClipPath", |
| "GdipGetClip", |
| "GdipCreateRegion", |
| "GdipGetClipBoundsI", |
| "GdipSetClipRegion", |
| "GdipWidenPath", |
| "GdipAddPathLine", |
| "GdipAddPathRectangle", |
| "GdipDeleteRegion", |
| "GdipGetDC", |
| "GdipReleaseDC", |
| "GdipSetPenLineCap197819", |
| "GdipSetPenDashOffset", |
| "GdipResetPath", |
| "GdipCreateRegionPath", |
| "GdipCreateFont", |
| "GdipGetFontSize", |
| "GdipCreateFontFamilyFromName", |
| "GdipSetTextRenderingHint", |
| "GdipDrawDriverString", |
| "GdipCreateMatrix2", |
| "GdipDeleteMatrix", |
| "GdipSetWorldTransform", |
| "GdipResetWorldTransform", |
| "GdipDeleteFontFamily", |
| "GdipDeleteFont", |
| "GdipNewPrivateFontCollection", |
| "GdipDeletePrivateFontCollection", |
| "GdipPrivateAddMemoryFont", |
| "GdipGetFontCollectionFamilyList", |
| "GdipGetFontCollectionFamilyCount", |
| "GdipSetTextContrast", |
| "GdipSetPixelOffsetMode", |
| "GdipGetImageGraphicsContext", |
| "GdipDrawImageI", |
| "GdipDrawImageRectI", |
| "GdipDrawString", |
| "GdipSetPenTransform", |
| }; |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreatePath2)(GDIPCONST GpPointF*, |
| GDIPCONST BYTE*, |
| INT, |
| GpFillMode, |
| GpPath** path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenDashStyle)( |
| GpPen* pen, |
| GpDashStyle dashstyle); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenDashArray)(GpPen* pen, |
| GDIPCONST REAL* dash, |
| INT count); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenDashCap197819)( |
| GpPen* pen, |
| GpDashCap dashCap); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenLineJoin)(GpPen* pen, |
| GpLineJoin lineJoin); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenWidth)(GpPen* pen, REAL width); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateFromHDC)(HDC hdc, |
| GpGraphics** graphics); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPageUnit)(GpGraphics* graphics, |
| GpUnit unit); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetSmoothingMode)( |
| GpGraphics* graphics, |
| SmoothingMode smoothingMode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateSolidFill)(ARGB color, |
| GpSolidFill** brush); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipFillPath)(GpGraphics* graphics, |
| GpBrush* brush, |
| GpPath* path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteBrush)(GpBrush* brush); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreatePen1)(ARGB color, |
| REAL width, |
| GpUnit unit, |
| GpPen** pen); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenMiterLimit)(GpPen* pen, |
| REAL miterLimit); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawPath)(GpGraphics* graphics, |
| GpPen* pen, |
| GpPath* path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeletePen)(GpPen* pen); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeletePath)(GpPath* path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteGraphics)(GpGraphics* graphics); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateBitmapFromFileICM)( |
| GDIPCONST WCHAR* filename, |
| GpBitmap** bitmap); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateBitmapFromStreamICM)( |
| IStream* stream, |
| GpBitmap** bitmap); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImageWidth)(GpImage* image, |
| UINT* width); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImageHeight)(GpImage* image, |
| UINT* height); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImagePixelFormat)( |
| GpImage* image, |
| PixelFormat* format); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipBitmapLockBits)( |
| GpBitmap* bitmap, |
| GDIPCONST GpRect* rect, |
| UINT flags, |
| PixelFormat format, |
| BitmapData* lockedBitmapData); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImagePalette)( |
| GpImage* image, |
| ColorPalette* palette, |
| INT size); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImagePaletteSize)(GpImage* image, |
| INT* size); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipBitmapUnlockBits)( |
| GpBitmap* bitmap, |
| BitmapData* lockedBitmapData); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDisposeImage)(GpImage* image); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipFillRectangle)(GpGraphics* graphics, |
| GpBrush* brush, |
| REAL x, |
| REAL y, |
| REAL width, |
| REAL height); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateBitmapFromScan0)( |
| INT width, |
| INT height, |
| INT stride, |
| PixelFormat format, |
| BYTE* scan0, |
| GpBitmap** bitmap); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetImagePalette)( |
| GpImage* image, |
| GDIPCONST ColorPalette* palette); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetInterpolationMode)( |
| GpGraphics* graphics, |
| InterpolationMode interpolationMode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawImagePointsI)( |
| GpGraphics* graphics, |
| GpImage* image, |
| GDIPCONST GpPoint* dstpoints, |
| INT count); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateBitmapFromGdiDib)( |
| GDIPCONST BITMAPINFO* gdiBitmapInfo, |
| VOID* gdiBitmapData, |
| GpBitmap** bitmap); |
| typedef Status(WINAPI* FuncType_GdiplusStartup)( |
| OUT uintptr_t* token, |
| const GdiplusStartupInput* input, |
| OUT GdiplusStartupOutput* output); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawLineI)(GpGraphics* graphics, |
| GpPen* pen, |
| int x1, |
| int y1, |
| int x2, |
| int y2); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipResetClip)(GpGraphics* graphics); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreatePath)(GpFillMode brushMode, |
| GpPath** path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipAddPathPath)( |
| GpPath* path, |
| GDIPCONST GpPath* addingPath, |
| BOOL connect); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPathFillMode)(GpPath* path, |
| GpFillMode fillmode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetClipPath)(GpGraphics* graphics, |
| GpPath* path, |
| CombineMode combineMode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetClip)(GpGraphics* graphics, |
| GpRegion* region); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateRegion)(GpRegion** region); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetClipBoundsI)(GpGraphics* graphics, |
| GpRect* rect); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetClipRegion)( |
| GpGraphics* graphics, |
| GpRegion* region, |
| CombineMode combineMode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipWidenPath)(GpPath* nativePath, |
| GpPen* pen, |
| GpMatrix* matrix, |
| REAL flatness); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipAddPathLine)(GpPath* path, |
| REAL x1, |
| REAL y1, |
| REAL x2, |
| REAL y2); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipAddPathRectangle)(GpPath* path, |
| REAL x, |
| REAL y, |
| REAL width, |
| REAL height); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteRegion)(GpRegion* region); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetDC)(GpGraphics* graphics, |
| HDC* hdc); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipReleaseDC)(GpGraphics* graphics, |
| HDC hdc); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenLineCap197819)( |
| GpPen* pen, |
| GpLineCap startCap, |
| GpLineCap endCap, |
| GpDashCap dashCap); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenDashOffset)(GpPen* pen, |
| REAL offset); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipResetPath)(GpPath* path); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateRegionPath)(GpPath* path, |
| GpRegion** region); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateFont)( |
| GDIPCONST GpFontFamily* fontFamily, |
| REAL emSize, |
| INT style, |
| Unit unit, |
| GpFont** font); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetFontSize)(GpFont* font, |
| REAL* size); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateFontFamilyFromName)( |
| GDIPCONST WCHAR* name, |
| GpFontCollection* fontCollection, |
| GpFontFamily** FontFamily); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetTextRenderingHint)( |
| GpGraphics* graphics, |
| TextRenderingHint mode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawDriverString)( |
| GpGraphics* graphics, |
| GDIPCONST UINT16* text, |
| INT length, |
| GDIPCONST GpFont* font, |
| GDIPCONST GpBrush* brush, |
| GDIPCONST PointF* positions, |
| INT flags, |
| GDIPCONST GpMatrix* matrix); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipCreateMatrix2)(REAL m11, |
| REAL m12, |
| REAL m21, |
| REAL m22, |
| REAL dx, |
| REAL dy, |
| GpMatrix** matrix); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteMatrix)(GpMatrix* matrix); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetWorldTransform)( |
| GpGraphics* graphics, |
| GpMatrix* matrix); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipResetWorldTransform)( |
| GpGraphics* graphics); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteFontFamily)( |
| GpFontFamily* FontFamily); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeleteFont)(GpFont* font); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipNewPrivateFontCollection)( |
| GpFontCollection** fontCollection); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDeletePrivateFontCollection)( |
| GpFontCollection** fontCollection); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipPrivateAddMemoryFont)( |
| GpFontCollection* fontCollection, |
| GDIPCONST void* memory, |
| INT length); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetFontCollectionFamilyList)( |
| GpFontCollection* fontCollection, |
| INT numSought, |
| GpFontFamily* gpfamilies[], |
| INT* numFound); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetFontCollectionFamilyCount)( |
| GpFontCollection* fontCollection, |
| INT* numFound); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetTextContrast)(GpGraphics* graphics, |
| UINT contrast); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPixelOffsetMode)( |
| GpGraphics* graphics, |
| PixelOffsetMode pixelOffsetMode); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipGetImageGraphicsContext)( |
| GpImage* image, |
| GpGraphics** graphics); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawImageI)(GpGraphics* graphics, |
| GpImage* image, |
| INT x, |
| INT y); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawImageRectI)(GpGraphics* graphics, |
| GpImage* image, |
| INT x, |
| INT y, |
| INT width, |
| INT height); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipDrawString)( |
| GpGraphics* graphics, |
| GDIPCONST WCHAR* str, |
| INT length, |
| GDIPCONST GpFont* font, |
| GDIPCONST RectF* layoutRect, |
| GDIPCONST GpStringFormat* stringFormat, |
| GDIPCONST GpBrush* brush); |
| typedef GpStatus(WINGDIPAPI* FuncType_GdipSetPenTransform)(GpPen* pen, |
| GpMatrix* matrix); |
| #define CallFunc(funcname) \ |
| ((FuncType_##funcname)GdiplusExt.m_Functions[FuncId_##funcname]) |
| typedef HANDLE(__stdcall* FuncType_GdiAddFontMemResourceEx)(PVOID pbFont, |
| DWORD cbFont, |
| PVOID pdv, |
| DWORD* pcFonts); |
| typedef BOOL(__stdcall* FuncType_GdiRemoveFontMemResourceEx)(HANDLE handle); |
| void* CGdiplusExt::GdiAddFontMemResourceEx(void* pFontdata, |
| uint32_t size, |
| void* pdv, |
| uint32_t* num_face) { |
| if (m_pGdiAddFontMemResourceEx) { |
| return ((FuncType_GdiAddFontMemResourceEx)m_pGdiAddFontMemResourceEx)( |
| (PVOID)pFontdata, (DWORD)size, (PVOID)pdv, (DWORD*)num_face); |
| } |
| return nullptr; |
| } |
| FX_BOOL CGdiplusExt::GdiRemoveFontMemResourceEx(void* handle) { |
| if (m_pGdiRemoveFontMemResourseEx) { |
| return ((FuncType_GdiRemoveFontMemResourceEx)m_pGdiRemoveFontMemResourseEx)( |
| (HANDLE)handle); |
| } |
| return FALSE; |
| } |
| static GpBrush* _GdipCreateBrush(DWORD argb) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpSolidFill* solidBrush = nullptr; |
| CallFunc(GdipCreateSolidFill)((ARGB)argb, &solidBrush); |
| return solidBrush; |
| } |
| static CFX_DIBitmap* _StretchMonoToGray(int dest_width, |
| int dest_height, |
| const CFX_DIBitmap* pSource, |
| FX_RECT* pClipRect) { |
| FX_BOOL bFlipX = dest_width < 0; |
| if (bFlipX) { |
| dest_width = -dest_width; |
| } |
| FX_BOOL bFlipY = dest_height < 0; |
| if (bFlipY) { |
| dest_height = -dest_height; |
| } |
| int result_width = pClipRect->Width(); |
| int result_height = pClipRect->Height(); |
| int result_pitch = (result_width + 3) / 4 * 4; |
| CFX_DIBitmap* pStretched = new CFX_DIBitmap; |
| if (!pStretched->Create(result_width, result_height, FXDIB_8bppRgb)) { |
| delete pStretched; |
| return nullptr; |
| } |
| LPBYTE dest_buf = pStretched->GetBuffer(); |
| int src_width = pSource->GetWidth(); |
| int src_height = pSource->GetHeight(); |
| int y_unit = src_height / dest_height; |
| int x_unit = src_width / dest_width; |
| int area_unit = y_unit * x_unit; |
| LPBYTE src_buf = pSource->GetBuffer(); |
| int src_pitch = pSource->GetPitch(); |
| for (int dest_y = 0; dest_y < result_height; dest_y++) { |
| LPBYTE dest_scan = dest_buf + dest_y * result_pitch; |
| int src_y_start = bFlipY ? (dest_height - 1 - dest_y - pClipRect->top) |
| : (dest_y + pClipRect->top); |
| src_y_start = src_y_start * src_height / dest_height; |
| LPBYTE src_scan = src_buf + src_y_start * src_pitch; |
| for (int dest_x = 0; dest_x < result_width; dest_x++) { |
| int sum = 0; |
| int src_x_start = bFlipX ? (dest_width - 1 - dest_x - pClipRect->left) |
| : (dest_x + pClipRect->left); |
| src_x_start = src_x_start * src_width / dest_width; |
| int src_x_end = src_x_start + x_unit; |
| LPBYTE src_line = src_scan; |
| for (int src_y = 0; src_y < y_unit; src_y++) { |
| for (int src_x = src_x_start; src_x < src_x_end; src_x++) { |
| if (!(src_line[src_x / 8] & (1 << (7 - src_x % 8)))) { |
| sum += 255; |
| } |
| } |
| src_line += src_pitch; |
| } |
| dest_scan[dest_x] = 255 - sum / area_unit; |
| } |
| } |
| return pStretched; |
| } |
| static void OutputImageMask(GpGraphics* pGraphics, |
| BOOL bMonoDevice, |
| const CFX_DIBitmap* pBitmap, |
| int dest_left, |
| int dest_top, |
| int dest_width, |
| int dest_height, |
| FX_ARGB argb, |
| const FX_RECT* pClipRect) { |
| ASSERT(pBitmap->GetBPP() == 1); |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| int src_width = pBitmap->GetWidth(), src_height = pBitmap->GetHeight(); |
| int src_pitch = pBitmap->GetPitch(); |
| uint8_t* scan0 = pBitmap->GetBuffer(); |
| if (src_width == 1 && src_height == 1) { |
| if ((scan0[0] & 0x80) == 0) { |
| return; |
| } |
| GpSolidFill* solidBrush; |
| CallFunc(GdipCreateSolidFill)((ARGB)argb, &solidBrush); |
| if (dest_width < 0) { |
| dest_width = -dest_width; |
| dest_left -= dest_width; |
| } |
| if (dest_height < 0) { |
| dest_height = -dest_height; |
| dest_top -= dest_height; |
| } |
| CallFunc(GdipFillRectangle)(pGraphics, solidBrush, (float)dest_left, |
| (float)dest_top, (float)dest_width, |
| (float)dest_height); |
| CallFunc(GdipDeleteBrush)(solidBrush); |
| return; |
| } |
| if (!bMonoDevice && abs(dest_width) < src_width && |
| abs(dest_height) < src_height) { |
| FX_RECT image_rect(dest_left, dest_top, dest_left + dest_width, |
| dest_top + dest_height); |
| image_rect.Normalize(); |
| FX_RECT image_clip = image_rect; |
| image_clip.Intersect(*pClipRect); |
| if (image_clip.IsEmpty()) { |
| return; |
| } |
| image_clip.Offset(-image_rect.left, -image_rect.top); |
| CFX_DIBitmap* pStretched = nullptr; |
| if (src_width * src_height > 10000) { |
| pStretched = |
| _StretchMonoToGray(dest_width, dest_height, pBitmap, &image_clip); |
| } else { |
| pStretched = |
| pBitmap->StretchTo(dest_width, dest_height, FALSE, &image_clip); |
| } |
| GpBitmap* bitmap; |
| CallFunc(GdipCreateBitmapFromScan0)(image_clip.Width(), image_clip.Height(), |
| (image_clip.Width() + 3) / 4 * 4, |
| PixelFormat8bppIndexed, |
| pStretched->GetBuffer(), &bitmap); |
| int a, r, g, b; |
| ArgbDecode(argb, a, r, g, b); |
| UINT pal[258]; |
| pal[0] = 0; |
| pal[1] = 256; |
| for (int i = 0; i < 256; i++) { |
| pal[i + 2] = ArgbEncode(i * a / 255, r, g, b); |
| } |
| CallFunc(GdipSetImagePalette)(bitmap, (ColorPalette*)pal); |
| CallFunc(GdipDrawImageI)(pGraphics, bitmap, |
| image_rect.left + image_clip.left, |
| image_rect.top + image_clip.top); |
| CallFunc(GdipDisposeImage)(bitmap); |
| delete pStretched; |
| return; |
| } |
| GpBitmap* bitmap; |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat1bppIndexed, scan0, &bitmap); |
| UINT palette[4] = {PaletteFlagsHasAlpha, 2, 0, argb}; |
| CallFunc(GdipSetImagePalette)(bitmap, (ColorPalette*)palette); |
| Point destinationPoints[] = {Point(dest_left, dest_top), |
| Point(dest_left + dest_width, dest_top), |
| Point(dest_left, dest_top + dest_height)}; |
| CallFunc(GdipDrawImagePointsI)(pGraphics, bitmap, destinationPoints, 3); |
| CallFunc(GdipDisposeImage)(bitmap); |
| } |
| static void OutputImage(GpGraphics* pGraphics, |
| const CFX_DIBitmap* pBitmap, |
| const FX_RECT* pSrcRect, |
| int dest_left, |
| int dest_top, |
| int dest_width, |
| int dest_height) { |
| int src_width = pSrcRect->Width(), src_height = pSrcRect->Height(); |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| if (pBitmap->GetBPP() == 1 && (pSrcRect->left % 8)) { |
| FX_RECT new_rect(0, 0, src_width, src_height); |
| CFX_DIBitmap* pCloned = pBitmap->Clone(pSrcRect); |
| if (!pCloned) { |
| return; |
| } |
| OutputImage(pGraphics, pCloned, &new_rect, dest_left, dest_top, dest_width, |
| dest_height); |
| delete pCloned; |
| return; |
| } |
| int src_pitch = pBitmap->GetPitch(); |
| uint8_t* scan0 = pBitmap->GetBuffer() + pSrcRect->top * src_pitch + |
| pBitmap->GetBPP() * pSrcRect->left / 8; |
| GpBitmap* bitmap = nullptr; |
| switch (pBitmap->GetFormat()) { |
| case FXDIB_Argb: |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat32bppARGB, scan0, &bitmap); |
| break; |
| case FXDIB_Rgb32: |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat32bppRGB, scan0, &bitmap); |
| break; |
| case FXDIB_Rgb: |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat24bppRGB, scan0, &bitmap); |
| break; |
| case FXDIB_8bppRgb: { |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat8bppIndexed, scan0, |
| &bitmap); |
| UINT pal[258]; |
| pal[0] = 0; |
| pal[1] = 256; |
| for (int i = 0; i < 256; i++) { |
| pal[i + 2] = pBitmap->GetPaletteEntry(i); |
| } |
| CallFunc(GdipSetImagePalette)(bitmap, (ColorPalette*)pal); |
| break; |
| } |
| case FXDIB_1bppRgb: { |
| CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch, |
| PixelFormat1bppIndexed, scan0, |
| &bitmap); |
| break; |
| } |
| } |
| if (dest_height < 0) { |
| dest_height--; |
| } |
| if (dest_width < 0) { |
| dest_width--; |
| } |
| Point destinationPoints[] = {Point(dest_left, dest_top), |
| Point(dest_left + dest_width, dest_top), |
| Point(dest_left, dest_top + dest_height)}; |
| CallFunc(GdipDrawImagePointsI)(pGraphics, bitmap, destinationPoints, 3); |
| CallFunc(GdipDisposeImage)(bitmap); |
| } |
| CGdiplusExt::CGdiplusExt() { |
| m_hModule = nullptr; |
| m_GdiModule = nullptr; |
| for (size_t i = 0; i < sizeof g_GdipFuncNames / sizeof(LPCSTR); i++) { |
| m_Functions[i] = nullptr; |
| } |
| m_pGdiAddFontMemResourceEx = nullptr; |
| m_pGdiRemoveFontMemResourseEx = nullptr; |
| } |
| void CGdiplusExt::Load() { |
| CFX_ByteString strPlusPath = ""; |
| FX_CHAR buf[MAX_PATH]; |
| GetSystemDirectoryA(buf, MAX_PATH); |
| strPlusPath += buf; |
| strPlusPath += "\\"; |
| strPlusPath += "GDIPLUS.DLL"; |
| m_hModule = LoadLibraryA(strPlusPath.c_str()); |
| if (!m_hModule) { |
| return; |
| } |
| for (size_t i = 0; i < sizeof g_GdipFuncNames / sizeof(LPCSTR); i++) { |
| m_Functions[i] = GetProcAddress(m_hModule, g_GdipFuncNames[i]); |
| if (!m_Functions[i]) { |
| m_hModule = nullptr; |
| return; |
| } |
| } |
| uintptr_t gdiplusToken; |
| GdiplusStartupInput gdiplusStartupInput; |
| ((FuncType_GdiplusStartup)m_Functions[FuncId_GdiplusStartup])( |
| &gdiplusToken, &gdiplusStartupInput, nullptr); |
| m_GdiModule = LoadLibraryA("GDI32.DLL"); |
| if (!m_GdiModule) { |
| return; |
| } |
| m_pGdiAddFontMemResourceEx = |
| GetProcAddress(m_GdiModule, "AddFontMemResourceEx"); |
| m_pGdiRemoveFontMemResourseEx = |
| GetProcAddress(m_GdiModule, "RemoveFontMemResourceEx"); |
| } |
| CGdiplusExt::~CGdiplusExt() {} |
| LPVOID CGdiplusExt::LoadMemFont(LPBYTE pData, uint32_t size) { |
| GpFontCollection* pCollection = nullptr; |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipNewPrivateFontCollection)(&pCollection); |
| GpStatus status = |
| CallFunc(GdipPrivateAddMemoryFont)(pCollection, pData, size); |
| if (status == Ok) { |
| return pCollection; |
| } |
| CallFunc(GdipDeletePrivateFontCollection)(&pCollection); |
| return nullptr; |
| } |
| void CGdiplusExt::DeleteMemFont(LPVOID pCollection) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeletePrivateFontCollection)((GpFontCollection**)&pCollection); |
| } |
| FX_BOOL CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void** bitmap) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| PixelFormat format; |
| switch (pBitmap->GetFormat()) { |
| case FXDIB_Rgb: |
| format = PixelFormat24bppRGB; |
| break; |
| case FXDIB_Rgb32: |
| format = PixelFormat32bppRGB; |
| break; |
| case FXDIB_Argb: |
| format = PixelFormat32bppARGB; |
| break; |
| default: |
| return FALSE; |
| } |
| GpStatus status = CallFunc(GdipCreateBitmapFromScan0)( |
| pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap->GetPitch(), format, |
| pBitmap->GetBuffer(), (GpBitmap**)bitmap); |
| if (status == Ok) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CGdiplusExt::GdipCreateFromImage(void* bitmap, void** graphics) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpStatus status = CallFunc(GdipGetImageGraphicsContext)( |
| (GpBitmap*)bitmap, (GpGraphics**)graphics); |
| if (status == Ok) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CGdiplusExt::GdipCreateFontFamilyFromName(const FX_WCHAR* name, |
| void* pFontCollection, |
| void** pFamily) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpStatus status = CallFunc(GdipCreateFontFamilyFromName)( |
| (GDIPCONST WCHAR*)name, (GpFontCollection*)pFontCollection, |
| (GpFontFamily**)pFamily); |
| if (status == Ok) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CGdiplusExt::GdipCreateFontFromFamily(void* pFamily, |
| FX_FLOAT font_size, |
| int fontstyle, |
| int flag, |
| void** pFont) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpStatus status = |
| CallFunc(GdipCreateFont)((GpFontFamily*)pFamily, font_size, fontstyle, |
| Unit(flag), (GpFont**)pFont); |
| if (status == Ok) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| void CGdiplusExt::GdipGetFontSize(void* pFont, FX_FLOAT* size) { |
| REAL get_size; |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpStatus status = CallFunc(GdipGetFontSize)((GpFont*)pFont, (REAL*)&get_size); |
| if (status == Ok) { |
| *size = (FX_FLOAT)get_size; |
| } else { |
| *size = 0; |
| } |
| } |
| void CGdiplusExt::GdipSetTextRenderingHint(void* graphics, int mode) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipSetTextRenderingHint)((GpGraphics*)graphics, |
| (TextRenderingHint)mode); |
| } |
| void CGdiplusExt::GdipSetPageUnit(void* graphics, uint32_t unit) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipSetPageUnit)((GpGraphics*)graphics, (GpUnit)unit); |
| } |
| FX_BOOL CGdiplusExt::GdipDrawDriverString(void* graphics, |
| unsigned short* text, |
| int length, |
| void* font, |
| void* brush, |
| void* positions, |
| int flags, |
| const void* matrix) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpStatus status = CallFunc(GdipDrawDriverString)( |
| (GpGraphics*)graphics, (GDIPCONST UINT16*)text, (INT)length, |
| (GDIPCONST GpFont*)font, (GDIPCONST GpBrush*)brush, |
| (GDIPCONST PointF*)positions, (INT)flags, (GDIPCONST GpMatrix*)matrix); |
| if (status == Ok) { |
| return TRUE; |
| } |
| return FALSE; |
| } |
| void CGdiplusExt::GdipCreateBrush(uint32_t fill_argb, void** pBrush) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipCreateSolidFill)((ARGB)fill_argb, (GpSolidFill**)pBrush); |
| } |
| void CGdiplusExt::GdipDeleteBrush(void* pBrush) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeleteBrush)((GpSolidFill*)pBrush); |
| } |
| void* CGdiplusExt::GdipCreateFontFromCollection(void* pFontCollection, |
| FX_FLOAT font_size, |
| int fontstyle) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| int numFamilies = 0; |
| GpStatus status = CallFunc(GdipGetFontCollectionFamilyCount)( |
| (GpFontCollection*)pFontCollection, &numFamilies); |
| if (status != Ok) { |
| return nullptr; |
| } |
| GpFontFamily* family_list[1]; |
| status = CallFunc(GdipGetFontCollectionFamilyList)( |
| (GpFontCollection*)pFontCollection, 1, family_list, &numFamilies); |
| if (status != Ok) { |
| return nullptr; |
| } |
| GpFont* pFont = nullptr; |
| status = CallFunc(GdipCreateFont)(family_list[0], font_size, fontstyle, |
| UnitPixel, &pFont); |
| if (status != Ok) { |
| return nullptr; |
| } |
| return pFont; |
| } |
| void CGdiplusExt::GdipCreateMatrix(FX_FLOAT a, |
| FX_FLOAT b, |
| FX_FLOAT c, |
| FX_FLOAT d, |
| FX_FLOAT e, |
| FX_FLOAT f, |
| void** matrix) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipCreateMatrix2)(a, b, c, d, e, f, (GpMatrix**)matrix); |
| } |
| void CGdiplusExt::GdipDeleteMatrix(void* matrix) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeleteMatrix)((GpMatrix*)matrix); |
| } |
| void CGdiplusExt::GdipDeleteFontFamily(void* pFamily) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeleteFontFamily)((GpFontFamily*)pFamily); |
| } |
| void CGdiplusExt::GdipDeleteFont(void* pFont) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeleteFont)((GpFont*)pFont); |
| } |
| void CGdiplusExt::GdipSetWorldTransform(void* graphics, void* pMatrix) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipSetWorldTransform)((GpGraphics*)graphics, (GpMatrix*)pMatrix); |
| } |
| void CGdiplusExt::GdipDisposeImage(void* bitmap) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDisposeImage)((GpBitmap*)bitmap); |
| } |
| void CGdiplusExt::GdipDeleteGraphics(void* graphics) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipDeleteGraphics)((GpGraphics*)graphics); |
| } |
| FX_BOOL CGdiplusExt::StretchBitMask(HDC hDC, |
| BOOL bMonoDevice, |
| const CFX_DIBitmap* pBitmap, |
| int dest_left, |
| int dest_top, |
| int dest_width, |
| int dest_height, |
| uint32_t argb, |
| const FX_RECT* pClipRect, |
| int flags) { |
| ASSERT(pBitmap->GetBPP() == 1); |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| GpGraphics* pGraphics = nullptr; |
| CallFunc(GdipCreateFromHDC)(hDC, &pGraphics); |
| CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel); |
| if (flags & FXDIB_NOSMOOTH) { |
| CallFunc(GdipSetInterpolationMode)(pGraphics, |
| InterpolationModeNearestNeighbor); |
| } else { |
| CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeHighQuality); |
| } |
| OutputImageMask(pGraphics, bMonoDevice, pBitmap, dest_left, dest_top, |
| dest_width, dest_height, argb, pClipRect); |
| CallFunc(GdipDeleteGraphics)(pGraphics); |
| return TRUE; |
| } |
| FX_BOOL CGdiplusExt::StretchDIBits(HDC hDC, |
| const CFX_DIBitmap* pBitmap, |
| int dest_left, |
| int dest_top, |
| int dest_width, |
| int dest_height, |
| const FX_RECT* pClipRect, |
| int flags) { |
| GpGraphics* pGraphics; |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipCreateFromHDC)(hDC, &pGraphics); |
| CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel); |
| if (flags & FXDIB_NOSMOOTH) { |
| CallFunc(GdipSetInterpolationMode)(pGraphics, |
| InterpolationModeNearestNeighbor); |
| } else if (pBitmap->GetWidth() > abs(dest_width) / 2 || |
| pBitmap->GetHeight() > abs(dest_height) / 2) { |
| CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeHighQuality); |
| } else { |
| CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeBilinear); |
| } |
| FX_RECT src_rect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight()); |
| OutputImage(pGraphics, pBitmap, &src_rect, dest_left, dest_top, dest_width, |
| dest_height); |
| CallFunc(GdipDeleteGraphics)(pGraphics); |
| CallFunc(GdipDeleteGraphics)(pGraphics); |
| return TRUE; |
| } |
| static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState, |
| const CFX_Matrix* pMatrix, |
| DWORD argb, |
| FX_BOOL bTextMode = FALSE) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| FX_FLOAT width = pGraphState ? pGraphState->m_LineWidth : 1.0f; |
| if (!bTextMode) { |
| FX_FLOAT unit = |
| pMatrix ? 1.0f / ((pMatrix->GetXUnit() + pMatrix->GetYUnit()) / 2) |
| : 1.0f; |
| if (width < unit) { |
| width = unit; |
| } |
| } |
| GpPen* pPen = nullptr; |
| CallFunc(GdipCreatePen1)((ARGB)argb, width, UnitWorld, &pPen); |
| LineCap lineCap = LineCapFlat; |
| DashCap dashCap = DashCapFlat; |
| FX_BOOL bDashExtend = FALSE; |
| switch (pGraphState->m_LineCap) { |
| case CFX_GraphStateData::LineCapButt: |
| lineCap = LineCapFlat; |
| break; |
| case CFX_GraphStateData::LineCapRound: |
| lineCap = LineCapRound; |
| dashCap = DashCapRound; |
| bDashExtend = TRUE; |
| break; |
| case CFX_GraphStateData::LineCapSquare: |
| lineCap = LineCapSquare; |
| bDashExtend = TRUE; |
| break; |
| } |
| CallFunc(GdipSetPenLineCap197819)(pPen, lineCap, lineCap, dashCap); |
| LineJoin lineJoin = LineJoinMiterClipped; |
| switch (pGraphState->m_LineJoin) { |
| case CFX_GraphStateData::LineJoinMiter: |
| lineJoin = LineJoinMiterClipped; |
| break; |
| case CFX_GraphStateData::LineJoinRound: |
| lineJoin = LineJoinRound; |
| break; |
| case CFX_GraphStateData::LineJoinBevel: |
| lineJoin = LineJoinBevel; |
| break; |
| } |
| CallFunc(GdipSetPenLineJoin)(pPen, lineJoin); |
| if (pGraphState->m_DashCount) { |
| FX_FLOAT* pDashArray = FX_Alloc( |
| FX_FLOAT, pGraphState->m_DashCount + pGraphState->m_DashCount % 2); |
| int nCount = 0; |
| FX_FLOAT on_leftover = 0, off_leftover = 0; |
| for (int i = 0; i < pGraphState->m_DashCount; i += 2) { |
| FX_FLOAT on_phase = pGraphState->m_DashArray[i]; |
| FX_FLOAT off_phase; |
| if (i == pGraphState->m_DashCount - 1) { |
| off_phase = on_phase; |
| } else { |
| off_phase = pGraphState->m_DashArray[i + 1]; |
| } |
| on_phase /= width; |
| off_phase /= width; |
| if (on_phase + off_phase <= 0.00002f) { |
| on_phase = 1.0f / 10; |
| off_phase = 1.0f / 10; |
| } |
| if (bDashExtend) { |
| if (off_phase < 1) { |
| off_phase = 0; |
| } else { |
| off_phase -= 1; |
| } |
| on_phase += 1; |
| } |
| if (on_phase == 0 || off_phase == 0) { |
| if (nCount == 0) { |
| on_leftover += on_phase; |
| off_leftover += off_phase; |
| } else { |
| pDashArray[nCount - 2] += on_phase; |
| pDashArray[nCount - 1] += off_phase; |
| } |
| } else { |
| pDashArray[nCount++] = on_phase + on_leftover; |
| on_leftover = 0; |
| pDashArray[nCount++] = off_phase + off_leftover; |
| off_leftover = 0; |
| } |
| } |
| CallFunc(GdipSetPenDashArray)(pPen, pDashArray, nCount); |
| FX_FLOAT phase = pGraphState->m_DashPhase; |
| if (bDashExtend) { |
| if (phase < 0.5f) { |
| phase = 0; |
| } else { |
| phase -= 0.5f; |
| } |
| } |
| CallFunc(GdipSetPenDashOffset)(pPen, phase); |
| FX_Free(pDashArray); |
| pDashArray = nullptr; |
| } |
| CallFunc(GdipSetPenMiterLimit)(pPen, pGraphState->m_MiterLimit); |
| return pPen; |
| } |
| static FX_BOOL IsSmallTriangle(PointF* points, |
| const CFX_Matrix* pMatrix, |
| int& v1, |
| int& v2) { |
| int pairs[] = {1, 2, 0, 2, 0, 1}; |
| for (int i = 0; i < 3; i++) { |
| int pair1 = pairs[i * 2]; |
| int pair2 = pairs[i * 2 + 1]; |
| FX_FLOAT x1 = points[pair1].X, x2 = points[pair2].X; |
| FX_FLOAT y1 = points[pair1].Y, y2 = points[pair2].Y; |
| if (pMatrix) { |
| pMatrix->Transform(x1, y1); |
| pMatrix->Transform(x2, y2); |
| } |
| FX_FLOAT dx = x1 - x2; |
| FX_FLOAT dy = y1 - y2; |
| FX_FLOAT distance_square = (dx * dx) + (dy * dy); |
| if (distance_square < (1.0f * 2 + 1.0f / 4)) { |
| v1 = i; |
| v2 = pair1; |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| FX_BOOL CGdiplusExt::DrawPath(HDC hDC, |
| const CFX_PathData* pPathData, |
| const CFX_Matrix* pObject2Device, |
| const CFX_GraphStateData* pGraphState, |
| uint32_t fill_argb, |
| uint32_t stroke_argb, |
| int fill_mode) { |
| int nPoints = pPathData->GetPointCount(); |
| if (nPoints == 0) { |
| return TRUE; |
| } |
| FX_PATHPOINT* pPoints = pPathData->GetPoints(); |
| GpGraphics* pGraphics = nullptr; |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipCreateFromHDC)(hDC, &pGraphics); |
| CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel); |
| CallFunc(GdipSetPixelOffsetMode)(pGraphics, PixelOffsetModeHalf); |
| GpMatrix* pMatrix = nullptr; |
| if (pObject2Device) { |
| CallFunc(GdipCreateMatrix2)(pObject2Device->a, pObject2Device->b, |
| pObject2Device->c, pObject2Device->d, |
| pObject2Device->e, pObject2Device->f, &pMatrix); |
| CallFunc(GdipSetWorldTransform)(pGraphics, pMatrix); |
| } |
| PointF* points = FX_Alloc(PointF, nPoints); |
| BYTE* types = FX_Alloc(BYTE, nPoints); |
| int nSubPathes = 0; |
| FX_BOOL bSubClose = FALSE; |
| int pos_subclose = 0; |
| FX_BOOL bSmooth = FALSE; |
| int startpoint = 0; |
| for (int i = 0; i < nPoints; i++) { |
| points[i].X = pPoints[i].m_PointX; |
| points[i].Y = pPoints[i].m_PointY; |
| FX_FLOAT x, y; |
| if (pObject2Device) { |
| pObject2Device->Transform(pPoints[i].m_PointX, pPoints[i].m_PointY, x, y); |
| } else { |
| x = pPoints[i].m_PointX; |
| y = pPoints[i].m_PointY; |
| } |
| if (x > 50000 * 1.0f) { |
| points[i].X = 50000 * 1.0f; |
| } |
| if (x < -50000 * 1.0f) { |
| points[i].X = -50000 * 1.0f; |
| } |
| if (y > 50000 * 1.0f) { |
| points[i].Y = 50000 * 1.0f; |
| } |
| if (y < -50000 * 1.0f) { |
| points[i].Y = -50000 * 1.0f; |
| } |
| int point_type = pPoints[i].m_Flag & FXPT_TYPE; |
| if (point_type == FXPT_MOVETO) { |
| types[i] = PathPointTypeStart; |
| nSubPathes++; |
| bSubClose = FALSE; |
| startpoint = i; |
| } else if (point_type == FXPT_LINETO) { |
| types[i] = PathPointTypeLine; |
| if (pPoints[i - 1].m_Flag == FXPT_MOVETO && |
| (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) && |
| points[i].Y == points[i - 1].Y && points[i].X == points[i - 1].X) { |
| points[i].X += 0.01f; |
| continue; |
| } |
| if (!bSmooth && points[i].X != points[i - 1].X && |
| points[i].Y != points[i - 1].Y) { |
| bSmooth = TRUE; |
| } |
| } else if (point_type == FXPT_BEZIERTO) { |
| types[i] = PathPointTypeBezier; |
| bSmooth = TRUE; |
| } |
| if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) { |
| if (bSubClose) { |
| types[pos_subclose] &= ~PathPointTypeCloseSubpath; |
| } else { |
| bSubClose = TRUE; |
| } |
| pos_subclose = i; |
| types[i] |= PathPointTypeCloseSubpath; |
| if (!bSmooth && points[i].X != points[startpoint].X && |
| points[i].Y != points[startpoint].Y) { |
| bSmooth = TRUE; |
| } |
| } |
| } |
| if (fill_mode & FXFILL_NOPATHSMOOTH) { |
| bSmooth = FALSE; |
| CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeNone); |
| } else if (!(fill_mode & FXFILL_FULLCOVER)) { |
| if (!bSmooth && (fill_mode & 3)) { |
| bSmooth = TRUE; |
| } |
| if (bSmooth || (pGraphState && pGraphState->m_LineWidth > 2)) { |
| CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeAntiAlias); |
| } |
| } |
| int new_fill_mode = fill_mode & 3; |
| if (nPoints == 4 && !pGraphState) { |
| int v1, v2; |
| if (IsSmallTriangle(points, pObject2Device, v1, v2)) { |
| GpPen* pPen = nullptr; |
| CallFunc(GdipCreatePen1)(fill_argb, 1.0f, UnitPixel, &pPen); |
| CallFunc(GdipDrawLineI)( |
| pGraphics, pPen, FXSYS_round(points[v1].X), FXSYS_round(points[v1].Y), |
| FXSYS_round(points[v2].X), FXSYS_round(points[v2].Y)); |
| CallFunc(GdipDeletePen)(pPen); |
| return TRUE; |
| } |
| } |
| GpPath* pGpPath = nullptr; |
| CallFunc(GdipCreatePath2)(points, types, nPoints, |
| GdiFillType2Gdip(new_fill_mode), &pGpPath); |
| if (!pGpPath) { |
| if (pMatrix) { |
| CallFunc(GdipDeleteMatrix)(pMatrix); |
| } |
| FX_Free(points); |
| FX_Free(types); |
| CallFunc(GdipDeleteGraphics)(pGraphics); |
| return FALSE; |
| } |
| if (new_fill_mode) { |
| GpBrush* pBrush = _GdipCreateBrush(fill_argb); |
| CallFunc(GdipSetPathFillMode)(pGpPath, GdiFillType2Gdip(new_fill_mode)); |
| CallFunc(GdipFillPath)(pGraphics, pBrush, pGpPath); |
| CallFunc(GdipDeleteBrush)(pBrush); |
| } |
| if (pGraphState && stroke_argb) { |
| GpPen* pPen = _GdipCreatePen(pGraphState, pObject2Device, stroke_argb, |
| fill_mode & FX_STROKE_TEXT_MODE); |
| if (nSubPathes == 1) { |
| CallFunc(GdipDrawPath)(pGraphics, pPen, pGpPath); |
| } else { |
| int iStart = 0; |
| for (int i = 0; i < nPoints; i++) { |
| if (i == nPoints - 1 || types[i + 1] == PathPointTypeStart) { |
| GpPath* pSubPath; |
| CallFunc(GdipCreatePath2)(points + iStart, types + iStart, |
| i - iStart + 1, |
| GdiFillType2Gdip(new_fill_mode), &pSubPath); |
| iStart = i + 1; |
| CallFunc(GdipDrawPath)(pGraphics, pPen, pSubPath); |
| CallFunc(GdipDeletePath)(pSubPath); |
| } |
| } |
| } |
| CallFunc(GdipDeletePen)(pPen); |
| } |
| if (pMatrix) { |
| CallFunc(GdipDeleteMatrix)(pMatrix); |
| } |
| FX_Free(points); |
| FX_Free(types); |
| CallFunc(GdipDeletePath)(pGpPath); |
| CallFunc(GdipDeleteGraphics)(pGraphics); |
| return TRUE; |
| } |
| |
| class GpStream final : public IStream { |
| public: |
| GpStream() : m_RefCount(1), m_ReadPos(0) {} |
| |
| // IUnknown |
| HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, |
| void** ppvObject) override { |
| if (iid == __uuidof(IUnknown) || iid == __uuidof(IStream) || |
| iid == __uuidof(ISequentialStream)) { |
| *ppvObject = static_cast<IStream*>(this); |
| AddRef(); |
| return S_OK; |
| } |
| return E_NOINTERFACE; |
| } |
| ULONG STDMETHODCALLTYPE AddRef() override { |
| return (ULONG)InterlockedIncrement(&m_RefCount); |
| } |
| ULONG STDMETHODCALLTYPE Release() override { |
| ULONG res = (ULONG)InterlockedDecrement(&m_RefCount); |
| if (res == 0) { |
| delete this; |
| } |
| return res; |
| } |
| |
| // ISequentialStream |
| HRESULT STDMETHODCALLTYPE Read(void* Output, |
| ULONG cb, |
| ULONG* pcbRead) override { |
| size_t bytes_left; |
| size_t bytes_out; |
| if (pcbRead) { |
| *pcbRead = 0; |
| } |
| if (m_ReadPos == m_InterStream.GetLength()) { |
| return HRESULT_FROM_WIN32(ERROR_END_OF_MEDIA); |
| } |
| bytes_left = m_InterStream.GetLength() - m_ReadPos; |
| bytes_out = std::min(pdfium::base::checked_cast<size_t>(cb), bytes_left); |
| FXSYS_memcpy(Output, m_InterStream.GetBuffer() + m_ReadPos, bytes_out); |
| m_ReadPos += (int32_t)bytes_out; |
| if (pcbRead) { |
| *pcbRead = (ULONG)bytes_out; |
| } |
| return S_OK; |
| } |
| HRESULT STDMETHODCALLTYPE Write(void const* Input, |
| ULONG cb, |
| ULONG* pcbWritten) override { |
| if (cb <= 0) { |
| if (pcbWritten) { |
| *pcbWritten = 0; |
| } |
| return S_OK; |
| } |
| m_InterStream.InsertBlock(m_InterStream.GetLength(), Input, cb); |
| if (pcbWritten) { |
| *pcbWritten = cb; |
| } |
| return S_OK; |
| } |
| |
| // IStream |
| HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER) override { |
| return E_NOTIMPL; |
| } |
| HRESULT STDMETHODCALLTYPE CopyTo(IStream*, |
| ULARGE_INTEGER, |
| ULARGE_INTEGER*, |
| ULARGE_INTEGER*) override { |
| return E_NOTIMPL; |
| } |
| HRESULT STDMETHODCALLTYPE Commit(DWORD) override { return E_NOTIMPL; } |
| HRESULT STDMETHODCALLTYPE Revert() override { return E_NOTIMPL; } |
| HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER, |
| ULARGE_INTEGER, |
| DWORD) override { |
| return E_NOTIMPL; |
| } |
| HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER, |
| ULARGE_INTEGER, |
| DWORD) override { |
| return E_NOTIMPL; |
| } |
| HRESULT STDMETHODCALLTYPE Clone(IStream** stream) override { |
| return E_NOTIMPL; |
| } |
| HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER liDistanceToMove, |
| DWORD dwOrigin, |
| ULARGE_INTEGER* lpNewFilePointer) override { |
| long start = 0; |
| long new_read_position; |
| switch (dwOrigin) { |
| case STREAM_SEEK_SET: |
| start = 0; |
| break; |
| case STREAM_SEEK_CUR: |
| start = m_ReadPos; |
| break; |
| case STREAM_SEEK_END: |
| start = m_InterStream.GetLength(); |
| break; |
| default: |
| return STG_E_INVALIDFUNCTION; |
| break; |
| } |
| new_read_position = start + (long)liDistanceToMove.QuadPart; |
| if (new_read_position < 0 || |
| new_read_position > m_InterStream.GetLength()) { |
| return STG_E_SEEKERROR; |
| } |
| m_ReadPos = new_read_position; |
| if (lpNewFilePointer) { |
| lpNewFilePointer->QuadPart = m_ReadPos; |
| } |
| return S_OK; |
| } |
| HRESULT STDMETHODCALLTYPE Stat(STATSTG* pStatstg, |
| DWORD grfStatFlag) override { |
| if (!pStatstg) { |
| return STG_E_INVALIDFUNCTION; |
| } |
| ZeroMemory(pStatstg, sizeof(STATSTG)); |
| pStatstg->cbSize.QuadPart = m_InterStream.GetLength(); |
| return S_OK; |
| } |
| |
| private: |
| LONG m_RefCount; |
| int m_ReadPos; |
| CFX_ByteTextBuf m_InterStream; |
| }; |
| |
| typedef struct { |
| BITMAPINFO* pbmi; |
| int Stride; |
| LPBYTE pScan0; |
| GpBitmap* pBitmap; |
| BitmapData* pBitmapData; |
| GpStream* pStream; |
| } PREVIEW3_DIBITMAP; |
| |
| static PREVIEW3_DIBITMAP* LoadDIBitmap(WINDIB_Open_Args_ args) { |
| GpBitmap* pBitmap; |
| GpStream* pStream = nullptr; |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| Status status = Ok; |
| if (args.flags == WINDIB_OPEN_PATHNAME) { |
| status = CallFunc(GdipCreateBitmapFromFileICM)((wchar_t*)args.path_name, |
| &pBitmap); |
| } else { |
| if (args.memory_size == 0 || !args.memory_base) { |
| return nullptr; |
| } |
| pStream = new GpStream; |
| pStream->Write(args.memory_base, (ULONG)args.memory_size, nullptr); |
| status = CallFunc(GdipCreateBitmapFromStreamICM)(pStream, &pBitmap); |
| } |
| if (status != Ok) { |
| if (pStream) { |
| pStream->Release(); |
| } |
| return nullptr; |
| } |
| UINT height, width; |
| CallFunc(GdipGetImageHeight)(pBitmap, &height); |
| CallFunc(GdipGetImageWidth)(pBitmap, &width); |
| PixelFormat pixel_format; |
| CallFunc(GdipGetImagePixelFormat)(pBitmap, &pixel_format); |
| int info_size = sizeof(BITMAPINFOHEADER); |
| int bpp = 24; |
| int dest_pixel_format = PixelFormat24bppRGB; |
| if (pixel_format == PixelFormat1bppIndexed) { |
| info_size += 8; |
| bpp = 1; |
| dest_pixel_format = PixelFormat1bppIndexed; |
| } else if (pixel_format == PixelFormat8bppIndexed) { |
| info_size += 1024; |
| bpp = 8; |
| dest_pixel_format = PixelFormat8bppIndexed; |
| } else if (pixel_format == PixelFormat32bppARGB) { |
| bpp = 32; |
| dest_pixel_format = PixelFormat32bppARGB; |
| } |
| LPBYTE buf = FX_Alloc(BYTE, info_size); |
| BITMAPINFOHEADER* pbmih = (BITMAPINFOHEADER*)buf; |
| pbmih->biBitCount = bpp; |
| pbmih->biCompression = BI_RGB; |
| pbmih->biHeight = -(int)height; |
| pbmih->biPlanes = 1; |
| pbmih->biWidth = width; |
| Rect rect(0, 0, width, height); |
| BitmapData* pBitmapData = FX_Alloc(BitmapData, 1); |
| CallFunc(GdipBitmapLockBits)(pBitmap, &rect, ImageLockModeRead, |
| dest_pixel_format, pBitmapData); |
| if (pixel_format == PixelFormat1bppIndexed || |
| pixel_format == PixelFormat8bppIndexed) { |
| DWORD* ppal = (DWORD*)(buf + sizeof(BITMAPINFOHEADER)); |
| struct { |
| UINT flags; |
| UINT Count; |
| DWORD Entries[256]; |
| } pal; |
| int size = 0; |
| CallFunc(GdipGetImagePaletteSize)(pBitmap, &size); |
| CallFunc(GdipGetImagePalette)(pBitmap, (ColorPalette*)&pal, size); |
| int entries = pixel_format == PixelFormat1bppIndexed ? 2 : 256; |
| for (int i = 0; i < entries; i++) { |
| ppal[i] = pal.Entries[i] & 0x00ffffff; |
| } |
| } |
| PREVIEW3_DIBITMAP* pInfo = FX_Alloc(PREVIEW3_DIBITMAP, 1); |
| pInfo->pbmi = (BITMAPINFO*)buf; |
| pInfo->pScan0 = (LPBYTE)pBitmapData->Scan0; |
| pInfo->Stride = pBitmapData->Stride; |
| pInfo->pBitmap = pBitmap; |
| pInfo->pBitmapData = pBitmapData; |
| pInfo->pStream = pStream; |
| return pInfo; |
| } |
| |
| static void FreeDIBitmap(PREVIEW3_DIBITMAP* pInfo) { |
| CGdiplusExt& GdiplusExt = |
| ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt; |
| CallFunc(GdipBitmapUnlockBits)(pInfo->pBitmap, pInfo->pBitmapData); |
| CallFunc(GdipDisposeImage)(pInfo->pBitmap); |
| FX_Free(pInfo->pBitmapData); |
| FX_Free((LPBYTE)pInfo->pbmi); |
| if (pInfo->pStream) { |
| pInfo->pStream->Release(); |
| } |
| FX_Free(pInfo); |
| } |
| |
| CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, |
| LPVOID pData, |
| FX_BOOL bAlpha); |
| CFX_DIBitmap* CGdiplusExt::LoadDIBitmap(WINDIB_Open_Args_ args) { |
| PREVIEW3_DIBITMAP* pInfo = ::LoadDIBitmap(args); |
| if (!pInfo) { |
| return nullptr; |
| } |
| int height = abs(pInfo->pbmi->bmiHeader.biHeight); |
| int width = pInfo->pbmi->bmiHeader.biWidth; |
| int dest_pitch = (width * pInfo->pbmi->bmiHeader.biBitCount + 31) / 32 * 4; |
| LPBYTE pData = FX_Alloc2D(BYTE, dest_pitch, height); |
| if (dest_pitch == pInfo->Stride) { |
| FXSYS_memcpy(pData, pInfo->pScan0, dest_pitch * height); |
| } else { |
| for (int i = 0; i < height; i++) { |
| FXSYS_memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i, |
| dest_pitch); |
| } |
| } |
| CFX_DIBitmap* pDIBitmap = _FX_WindowsDIB_LoadFromBuf( |
| pInfo->pbmi, pData, pInfo->pbmi->bmiHeader.biBitCount == 32); |
| FX_Free(pData); |
| FreeDIBitmap(pInfo); |
| return pDIBitmap; |
| } |
| #endif |
