Initial commit.
[pdfium.git] / core / src / fxge / win32 / fx_win32_print.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.\r
2 // Use of this source code is governed by a BSD-style license that can be\r
3 // found in the LICENSE file.\r
4  \r
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
6 \r
7 #include "../../../include/fxge/fx_ge.h"\r
8 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_\r
9 #include <windows.h>\r
10 #include "../../../include/fxge/fx_ge_win32.h"\r
11 #include "win32_int.h"\r
12 #include "../../../include/fxge/fx_freetype.h"\r
13 #include "../ge/text_int.h"\r
14 #include "../dib/dib_int.h"\r
15 #define SIZETHRESHOLD 1000\r
16 #define OUTPUTPSLEN 4096\r
17 CGdiPrinterDriver::CGdiPrinterDriver(HDC hDC) : CGdiDeviceDriver(hDC, FXDC_PRINTER)\r
18 {\r
19     m_HorzSize = ::GetDeviceCaps(m_hDC, HORZSIZE);\r
20     m_VertSize = ::GetDeviceCaps(m_hDC, VERTSIZE);\r
21     m_bSupportROP = TRUE;\r
22 }\r
23 int CGdiPrinterDriver::GetDeviceCaps(int caps_id)\r
24 {\r
25     if (caps_id == FXDC_HORZ_SIZE) {\r
26         return m_HorzSize;\r
27     }\r
28     if (caps_id == FXDC_VERT_SIZE) {\r
29         return m_VertSize;\r
30     }\r
31     return CGdiDeviceDriver::GetDeviceCaps(caps_id);\r
32 }\r
33 FX_BOOL CGdiPrinterDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,\r
34                                      int alpha_flag, void* pIccTransform)\r
35 {\r
36     if (pSource->IsAlphaMask()) {\r
37         FX_RECT clip_rect(left, top, left + pSrcRect->Width(), top + pSrcRect->Height());\r
38         return StretchDIBits(pSource, color, left - pSrcRect->left, top - pSrcRect->top, pSource->GetWidth(), pSource->GetHeight(),\r
39                              &clip_rect, 0, alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);\r
40     }\r
41     ASSERT(pSource != NULL && !pSource->IsAlphaMask() && pSrcRect != NULL);\r
42     ASSERT(blend_type == FXDIB_BLEND_NORMAL);\r
43     if (pSource->HasAlpha()) {\r
44         return FALSE;\r
45     }\r
46     CFX_DIBExtractor temp(pSource);\r
47     CFX_DIBitmap* pBitmap = temp;\r
48     if (pBitmap == NULL) {\r
49         return FALSE;\r
50     }\r
51     return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);\r
52 }\r
53 FX_BOOL CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,\r
54         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,\r
55         int alpha_flag, void* pIccTransform, int blend_type)\r
56 {\r
57     if (pSource->IsAlphaMask()) {\r
58         int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);\r
59         if (pSource->GetBPP() != 1 || alpha != 255 || !m_bSupportROP) {\r
60             return FALSE;\r
61         }\r
62         if (dest_width < 0 || dest_height < 0) {\r
63             CFX_DIBitmap* pFlipped = pSource->FlipImage(dest_width < 0, dest_height < 0);\r
64             if (pFlipped == NULL) {\r
65                 return FALSE;\r
66             }\r
67             if (dest_width < 0) {\r
68                 dest_left += dest_width;\r
69             }\r
70             if (dest_height < 0) {\r
71                 dest_top += dest_height;\r
72             }\r
73             FX_BOOL ret = GDI_StretchBitMask(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), color, flags, alpha_flag, pIccTransform);\r
74             delete pFlipped;\r
75             return ret;\r
76         }\r
77         CFX_DIBExtractor temp(pSource);\r
78         CFX_DIBitmap* pBitmap = temp;\r
79         if (pBitmap == NULL) {\r
80             return FALSE;\r
81         }\r
82         return GDI_StretchBitMask(pBitmap, dest_left, dest_top, dest_width, dest_height, color, flags, alpha_flag, pIccTransform);\r
83     } else {\r
84         ASSERT(pSource != NULL);\r
85         if (pSource->HasAlpha()) {\r
86             return FALSE;\r
87         }\r
88         if (dest_width < 0 || dest_height < 0) {\r
89             CFX_DIBitmap* pFlipped = pSource->FlipImage(dest_width < 0, dest_height < 0);\r
90             if (pFlipped == NULL) {\r
91                 return FALSE;\r
92             }\r
93             if (dest_width < 0) {\r
94                 dest_left += dest_width;\r
95             }\r
96             if (dest_height < 0) {\r
97                 dest_top += dest_height;\r
98             }\r
99             FX_BOOL ret = GDI_StretchDIBits(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), flags, pIccTransform);\r
100             delete pFlipped;\r
101             return ret;\r
102         }\r
103         CFX_DIBExtractor temp(pSource);\r
104         CFX_DIBitmap* pBitmap = temp;\r
105         if (pBitmap == NULL) {\r
106             return FALSE;\r
107         }\r
108         return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width, dest_height, flags, pIccTransform);\r
109     }\r
110 }\r
111 static CFX_DIBitmap* Transform1bppBitmap(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix)\r
112 {\r
113     ASSERT(pSrc->GetFormat() == FXDIB_1bppRgb || pSrc->GetFormat() == FXDIB_1bppMask || pSrc->GetFormat() == FXDIB_1bppCmyk);\r
114     CFX_FloatRect unit_rect = pDestMatrix->GetUnitRect();\r
115     FX_RECT full_rect = unit_rect.GetOutterRect();\r
116     int full_left = full_rect.left;\r
117     int full_top = full_rect.top;\r
118     CFX_DIBExtractor src_bitmap(pSrc);\r
119     CFX_DIBitmap* pSrcBitmap = src_bitmap;\r
120     if (pSrcBitmap == NULL) {\r
121         return NULL;\r
122     }\r
123     int src_width = pSrcBitmap->GetWidth(), src_height = pSrcBitmap->GetHeight();\r
124     FX_LPBYTE src_buf = pSrcBitmap->GetBuffer();\r
125     FX_DWORD src_pitch = pSrcBitmap->GetPitch();\r
126     FX_FLOAT dest_area = pDestMatrix->GetUnitArea();\r
127     FX_FLOAT area_scale = FXSYS_Div((FX_FLOAT)(src_width * src_height), dest_area);\r
128     FX_FLOAT size_scale = FXSYS_sqrt(area_scale);\r
129     CFX_AffineMatrix adjusted_matrix(*pDestMatrix);\r
130     adjusted_matrix.Scale(size_scale, size_scale);\r
131     CFX_FloatRect result_rect_f = adjusted_matrix.GetUnitRect();\r
132     FX_RECT result_rect = result_rect_f.GetOutterRect();\r
133     CFX_AffineMatrix src2result;\r
134     src2result.e = adjusted_matrix.c + adjusted_matrix.e;\r
135     src2result.f = adjusted_matrix.d + adjusted_matrix.f;\r
136     src2result.a = adjusted_matrix.a / pSrcBitmap->GetWidth();\r
137     src2result.b = adjusted_matrix.b / pSrcBitmap->GetWidth();\r
138     src2result.c = -adjusted_matrix.c / pSrcBitmap->GetHeight();\r
139     src2result.d = -adjusted_matrix.d / pSrcBitmap->GetHeight();\r
140     src2result.TranslateI(-result_rect.left, -result_rect.top);\r
141     CFX_AffineMatrix result2src;\r
142     result2src.SetReverse(src2result);\r
143     CPDF_FixedMatrix result2src_fix(result2src, 8);\r
144     int result_width = result_rect.Width();\r
145     int result_height = result_rect.Height();\r
146     CFX_DIBitmap* pTempBitmap = FX_NEW CFX_DIBitmap;\r
147     if (!pTempBitmap) {\r
148         if (pSrcBitmap != src_bitmap) {\r
149             delete pSrcBitmap;\r
150         }\r
151         return NULL;\r
152     }\r
153     if (!pTempBitmap->Create(result_width, result_height, pSrc->GetFormat())) {\r
154         delete pTempBitmap;\r
155         if (pSrcBitmap != src_bitmap) {\r
156             delete pSrcBitmap;\r
157         }\r
158         return NULL;\r
159     }\r
160     pTempBitmap->CopyPalette(pSrc->GetPalette());\r
161     FX_LPBYTE dest_buf = pTempBitmap->GetBuffer();\r
162     int dest_pitch = pTempBitmap->GetPitch();\r
163     FXSYS_memset8(dest_buf, pSrc->IsAlphaMask() ? 0 : 0xff, dest_pitch * result_height);\r
164     if (pSrcBitmap->IsAlphaMask()) {\r
165         for (int dest_y = 0; dest_y < result_height; dest_y ++) {\r
166             FX_LPBYTE dest_scan = dest_buf + dest_y * dest_pitch;\r
167             for (int dest_x = 0; dest_x < result_width; dest_x ++) {\r
168                 int src_x, src_y;\r
169                 result2src_fix.Transform(dest_x, dest_y, src_x, src_y);\r
170                 if (src_x < 0 || src_x >= src_width || src_y < 0 || src_y >= src_height) {\r
171                     continue;\r
172                 }\r
173                 if (!((src_buf + src_pitch * src_y)[src_x / 8] & (1 << (7 - src_x % 8)))) {\r
174                     continue;\r
175                 }\r
176                 dest_scan[dest_x / 8] |= 1 << (7 - dest_x % 8);\r
177             }\r
178         }\r
179     } else {\r
180         for (int dest_y = 0; dest_y < result_height; dest_y ++) {\r
181             FX_LPBYTE dest_scan = dest_buf + dest_y * dest_pitch;\r
182             for (int dest_x = 0; dest_x < result_width; dest_x ++) {\r
183                 int src_x, src_y;\r
184                 result2src_fix.Transform(dest_x, dest_y, src_x, src_y);\r
185                 if (src_x < 0 || src_x >= src_width || src_y < 0 || src_y >= src_height) {\r
186                     continue;\r
187                 }\r
188                 if ((src_buf + src_pitch * src_y)[src_x / 8] & (1 << (7 - src_x % 8))) {\r
189                     continue;\r
190                 }\r
191                 dest_scan[dest_x / 8] &= ~(1 << (7 - dest_x % 8));\r
192             }\r
193         }\r
194     }\r
195     if (pSrcBitmap != src_bitmap) {\r
196         delete pSrcBitmap;\r
197     }\r
198     return pTempBitmap;\r
199 }\r
200 FX_BOOL CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD color,\r
201                                        const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, FX_LPVOID& handle,\r
202                                        int alpha_flag, void* pIccTransform, int blend_type)\r
203 {\r
204     if (bitmap_alpha < 255 || pSource->HasAlpha() || (pSource->IsAlphaMask() && (pSource->GetBPP() != 1 || !m_bSupportROP))) {\r
205         return FALSE;\r
206     }\r
207     CFX_FloatRect unit_rect = pMatrix->GetUnitRect();\r
208     FX_RECT full_rect = unit_rect.GetOutterRect();\r
209     if (FXSYS_fabs(pMatrix->b) < 0.5f && pMatrix->a != 0 && FXSYS_fabs(pMatrix->c) < 0.5f && pMatrix->d != 0) {\r
210         FX_BOOL bFlipX = pMatrix->a < 0;\r
211         FX_BOOL bFlipY = pMatrix->d > 0;\r
212         return StretchDIBits(pSource, color, bFlipX ? full_rect.right : full_rect.left, bFlipY ? full_rect.bottom : full_rect.top,\r
213                              bFlipX ? -full_rect.Width() : full_rect.Width(), bFlipY ? -full_rect.Height() : full_rect.Height(), NULL, 0,\r
214                              alpha_flag, pIccTransform, blend_type);\r
215     }\r
216     if (FXSYS_fabs(pMatrix->a) < 0.5f && FXSYS_fabs(pMatrix->d) < 0.5f) {\r
217         CFX_DIBitmap* pTransformed = pSource->SwapXY(pMatrix->c > 0, pMatrix->b < 0);\r
218         if (pTransformed == NULL) {\r
219             return FALSE;\r
220         }\r
221         FX_BOOL ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,\r
222                                     alpha_flag, pIccTransform, blend_type);\r
223         delete pTransformed;\r
224         return ret;\r
225     }\r
226     if (pSource->GetBPP() == 1) {\r
227         CFX_DIBitmap* pTransformed = Transform1bppBitmap(pSource, pMatrix);\r
228         if (pIccTransform == NULL) {\r
229             return FALSE;\r
230         }\r
231         SaveState();\r
232         CFX_PathData path;\r
233         path.AppendRect(0, 0, 1.0f, 1.0f);\r
234         SetClip_PathFill(&path, pMatrix, WINDING);\r
235         FX_BOOL ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,\r
236                                     alpha_flag, pIccTransform, blend_type);\r
237         RestoreState();\r
238         delete pTransformed;\r
239         handle = NULL;\r
240         return ret;\r
241     }\r
242     return FALSE;\r
243 }\r
244 CPSOutput::CPSOutput(HDC hDC)\r
245 {\r
246     m_hDC = hDC;\r
247     m_pBuf = NULL;\r
248 }\r
249 CPSOutput::~CPSOutput()\r
250 {\r
251     if (m_pBuf) {\r
252         FX_Free(m_pBuf);\r
253     }\r
254 }\r
255 void CPSOutput::Init()\r
256 {\r
257     m_pBuf = FX_Alloc(FX_CHAR, 1026);\r
258 }\r
259 void CPSOutput::OutputPS(FX_LPCSTR string, int len)\r
260 {\r
261     if (len < 0) {\r
262         len = (int)FXSYS_strlen(string);\r
263     }\r
264     int sent_len = 0;\r
265     while (len > 0) {\r
266         int send_len = len > 1024 ? 1024 : len;\r
267         *(FX_WORD*)m_pBuf = send_len;\r
268         FXSYS_memcpy(m_pBuf + 2, string + sent_len, send_len);\r
269         int ret = ExtEscape(m_hDC, PASSTHROUGH, send_len + 2, m_pBuf, 0, NULL);\r
270         sent_len += send_len;\r
271         len -= send_len;\r
272     }\r
273 }\r
274 CPSPrinterDriver::CPSPrinterDriver()\r
275 {\r
276     m_pPSOutput = NULL;\r
277     m_bCmykOutput = FALSE;\r
278 }\r
279 CPSPrinterDriver::~CPSPrinterDriver()\r
280 {\r
281     EndRendering();\r
282     if (m_pPSOutput) {\r
283         delete m_pPSOutput;\r
284     }\r
285 }\r
286 FX_BOOL CPSPrinterDriver::Init(HDC hDC, int pslevel, FX_BOOL bCmykOutput)\r
287 {\r
288     m_hDC = hDC;\r
289     m_HorzSize = ::GetDeviceCaps(m_hDC, HORZSIZE);\r
290     m_VertSize = ::GetDeviceCaps(m_hDC, VERTSIZE);\r
291     m_Width = ::GetDeviceCaps(m_hDC, HORZRES);\r
292     m_Height = ::GetDeviceCaps(m_hDC, VERTRES);\r
293     m_nBitsPerPixel = ::GetDeviceCaps(m_hDC, BITSPIXEL);\r
294     m_pPSOutput = FX_NEW CPSOutput(hDC);\r
295     if (!m_pPSOutput) {\r
296         return FALSE;\r
297     }\r
298     ((CPSOutput*)m_pPSOutput)->Init();\r
299     m_PSRenderer.Init(m_pPSOutput, pslevel, m_Width, m_Height, bCmykOutput);\r
300     m_bCmykOutput = bCmykOutput;\r
301     HRGN hRgn = ::CreateRectRgn(0, 0, 1, 1);\r
302     int ret = ::GetClipRgn(hDC, hRgn);\r
303     if (ret == 1) {\r
304         ret = ::GetRegionData(hRgn, 0, NULL);\r
305         if (ret) {\r
306             RGNDATA* pData = (RGNDATA*)FX_Alloc(FX_BYTE, ret);\r
307             if (!pData) {\r
308                 return FALSE;\r
309             }\r
310             ret = ::GetRegionData(hRgn, ret, pData);\r
311             if (ret) {\r
312                 CFX_PathData path;\r
313                 path.AllocPointCount(pData->rdh.nCount * 5);\r
314                 for (FX_DWORD i = 0; i < pData->rdh.nCount; i ++) {\r
315                     RECT* pRect = (RECT*)(pData->Buffer + pData->rdh.nRgnSize * i);\r
316                     path.AppendRect((FX_FLOAT)pRect->left, (FX_FLOAT)pRect->bottom, (FX_FLOAT)pRect->right, (FX_FLOAT)pRect->top);\r
317                 }\r
318                 m_PSRenderer.SetClip_PathFill(&path, NULL, FXFILL_WINDING);\r
319             }\r
320             FX_Free(pData);\r
321         }\r
322     }\r
323     ::DeleteObject(hRgn);\r
324     return TRUE;\r
325 }\r
326 int CPSPrinterDriver::GetDeviceCaps(int caps_id)\r
327 {\r
328     switch (caps_id) {\r
329         case FXDC_DEVICE_CLASS:\r
330             return FXDC_PRINTER;\r
331         case FXDC_PIXEL_WIDTH:\r
332             return m_Width;\r
333         case FXDC_PIXEL_HEIGHT:\r
334             return m_Height;\r
335         case FXDC_BITS_PIXEL:\r
336             return m_nBitsPerPixel;\r
337         case FXDC_RENDER_CAPS:\r
338             return m_bCmykOutput ? FXRC_BIT_MASK | FXRC_CMYK_OUTPUT : FXRC_BIT_MASK;\r
339         case FXDC_HORZ_SIZE:\r
340             return m_HorzSize;\r
341         case FXDC_VERT_SIZE:\r
342             return m_VertSize;\r
343     }\r
344     return 0;\r
345 }\r
346 FX_BOOL CPSPrinterDriver::StartRendering()\r
347 {\r
348     return m_PSRenderer.StartRendering();\r
349 }\r
350 void CPSPrinterDriver::EndRendering()\r
351 {\r
352     m_PSRenderer.EndRendering();\r
353 }\r
354 void CPSPrinterDriver::SaveState()\r
355 {\r
356     m_PSRenderer.SaveState();\r
357 }\r
358 void CPSPrinterDriver::RestoreState(FX_BOOL bKeepSaved)\r
359 {\r
360     m_PSRenderer.RestoreState(bKeepSaved);\r
361 }\r
362 FX_BOOL CPSPrinterDriver::SetClip_PathFill(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device,\r
363         int fill_mode)\r
364 {\r
365     m_PSRenderer.SetClip_PathFill(pPathData, pObject2Device, fill_mode);\r
366     return TRUE;\r
367 }\r
368 FX_BOOL CPSPrinterDriver::SetClip_PathStroke(const CFX_PathData* pPathData,\r
369         const CFX_AffineMatrix* pObject2Device,\r
370         const CFX_GraphStateData* pGraphState)\r
371 {\r
372     m_PSRenderer.SetClip_PathStroke(pPathData, pObject2Device, pGraphState);\r
373     return TRUE;\r
374 }\r
375 FX_BOOL CPSPrinterDriver::DrawPath(const CFX_PathData* pPathData,\r
376                                    const CFX_AffineMatrix* pObject2Device,\r
377                                    const CFX_GraphStateData* pGraphState, FX_ARGB fill_color, FX_ARGB stroke_color,\r
378                                    int fill_mode, int alpha_flag, void* pIccTransform, int blend_type)\r
379 {\r
380     if (blend_type != FXDIB_BLEND_NORMAL) {\r
381         return FALSE;\r
382     }\r
383     return m_PSRenderer.DrawPath(pPathData, pObject2Device, pGraphState, fill_color, stroke_color, fill_mode & 3, alpha_flag, pIccTransform);\r
384 }\r
385 FX_BOOL CPSPrinterDriver::GetClipBox(FX_RECT* pRect)\r
386 {\r
387     *pRect = m_PSRenderer.GetClipBox();\r
388     return TRUE;\r
389 }\r
390 FX_BOOL CPSPrinterDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,\r
391                                     int alpha_flag, void* pIccTransform)\r
392 {\r
393     if (blend_type != FXDIB_BLEND_NORMAL) {\r
394         return FALSE;\r
395     }\r
396     return m_PSRenderer.SetDIBits(pBitmap, color, left, top, alpha_flag, pIccTransform);\r
397 }\r
398 FX_BOOL CPSPrinterDriver::StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,\r
399                                         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,\r
400                                         int alpha_flag, void* pIccTransform, int blend_type)\r
401 {\r
402     if (blend_type != FXDIB_BLEND_NORMAL) {\r
403         return FALSE;\r
404     }\r
405     return m_PSRenderer.StretchDIBits(pBitmap, color, dest_left, dest_top, dest_width, dest_height, flags, alpha_flag, pIccTransform);\r
406 }\r
407 FX_BOOL CPSPrinterDriver::StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,\r
408                                       const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, FX_LPVOID& handle,\r
409                                       int alpha_flag, void* pIccTransform, int blend_type)\r
410 {\r
411     if (blend_type != FXDIB_BLEND_NORMAL) {\r
412         return FALSE;\r
413     }\r
414     if (bitmap_alpha < 255) {\r
415         return FALSE;\r
416     }\r
417     handle = NULL;\r
418     return m_PSRenderer.DrawDIBits(pBitmap, color, pMatrix, render_flags, alpha_flag, pIccTransform);\r
419 }\r
420 FX_BOOL CPSPrinterDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,\r
421         CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,\r
422         int alpha_flag, void* pIccTransform)\r
423 {\r
424     return m_PSRenderer.DrawText(nChars, pCharPos, pFont, pCache, pObject2Device, font_size, color, alpha_flag, pIccTransform);\r
425 }\r
426 #endif\r