static CPDF_TextObject* AddTextObjToPageObjects(CPDF_PageObjects* pPageObjs, FX_COLORREF crText,
CPDF_Font* pFont, FX_FLOAT fFontSize, FX_FLOAT fCharSpace, int32_t nHorzScale,
const CPDF_Point& point, const CFX_ByteString& text)
{
CPDF_TextObject* pTxtObj = new CPDF_TextObject;
CPDF_TextStateData* pTextStateData = pTxtObj->m_TextState.GetModify();
pTextStateData->m_pFont = pFont;
pTextStateData->m_FontSize = fFontSize;
pTextStateData->m_CharSpace = fCharSpace;
pTextStateData->m_WordSpace = 0;
pTextStateData->m_TextMode = 0;
pTextStateData->m_Matrix[0] = nHorzScale / 100.0f;
pTextStateData->m_Matrix[1] = 0;
pTextStateData->m_Matrix[2] = 0;
pTextStateData->m_Matrix[3] = 1;
FX_FLOAT rgb[3];
rgb[0] = FXARGB_R(crText) / 255.0f ;
rgb[1] = FXARGB_G(crText) / 255.0f;
rgb[2] = FXARGB_B(crText) / 255.0f;
pTxtObj->m_ColorState.SetFillColor(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB),rgb, 3);
pTxtObj->m_ColorState.SetStrokeColor(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB),rgb, 3);
pTxtObj->SetPosition(point.x,point.y);
pTxtObj->SetText(text);
pPageObjs->InsertObject(pPageObjs->GetLastObjectPosition(),pTxtObj);
return pTxtObj;
}
void CFX_PSRenderer::SetColor(FX_DWORD color, int alpha_flag, void* pIccTransform)
{
if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
pIccTransform = NULL;
}
FX_BOOL bCMYK = FALSE;
if (pIccTransform) {
ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
color = FXGETFLAG_COLORTYPE(alpha_flag) ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
FX_LPBYTE pColor = (FX_LPBYTE)&color;
pIccModule->TranslateScanline(pIccTransform, pColor, pColor, 1);
color = m_bCmykOutput ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
bCMYK = m_bCmykOutput;
} else {
bCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
}
if (bCMYK != m_bCmykOutput || !m_bColorSet || m_LastColor != color) {
CFX_ByteTextBuf buf;
if (bCMYK) {
buf << FXSYS_GetCValue(color) / 255.0 << FX_BSTRC(" ") << FXSYS_GetMValue(color) / 255.0 << FX_BSTRC(" ")
<< FXSYS_GetYValue(color) / 255.0 << FX_BSTRC(" ") << FXSYS_GetKValue(color) / 255.0 << FX_BSTRC(" k\n");
} else {
buf << FXARGB_R(color) / 255.0 << FX_BSTRC(" ") << FXARGB_G(color) / 255.0 << FX_BSTRC(" ")
<< FXARGB_B(color) / 255.0 << FX_BSTRC(" rg\n");
}
if (bCMYK == m_bCmykOutput) {
m_bColorSet = TRUE;
m_LastColor = color;
}
m_pOutput->OutputPS((FX_LPCSTR)buf.GetBuffer(), buf.GetSize());
}
}
static void AddRectToPageObjects(CPDF_PageObjects* pPageObjs, FX_COLORREF crFill, const CPDF_Rect& rcFill)
{
CPDF_PathObject* pPathObj = new CPDF_PathObject;
CPDF_PathData* pPathData = pPathObj->m_Path.GetModify();
pPathData->AppendRect(rcFill.left,rcFill.bottom,rcFill.right,rcFill.top);
FX_FLOAT rgb[3];
rgb[0] = FXARGB_R(crFill) / 255.0f ;
rgb[1] = FXARGB_G(crFill) / 255.0f;
rgb[2] = FXARGB_B(crFill) / 255.0f;
pPathObj->m_ColorState.SetFillColor(CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB), rgb, 3);
pPathObj->m_FillType = FXFILL_ALTERNATE;
pPathObj->m_bStroke = FALSE;
pPageObjs->InsertObject(pPageObjs->GetLastObjectPosition(),pPathObj);
}
FX_BOOL CDWriteExt::DwRendingString(void* renderTarget,
CFX_ClipRgn* pClipRgn,
FX_RECT& stringRect,
CFX_Matrix* pMatrix,
void* font,
FX_FLOAT font_size,
FX_ARGB text_color,
int glyph_count,
unsigned short* glyph_indices,
FX_FLOAT baselineOriginX,
FX_FLOAT baselineOriginY,
void* glyph_offsets,
FX_FLOAT* glyph_advances) {
if (!renderTarget) {
return TRUE;
}
CDwGdiTextRenderer* pTextRenderer = (CDwGdiTextRenderer*)renderTarget;
DWRITE_MATRIX transform;
DWRITE_GLYPH_RUN glyphRun;
HRESULT hr = S_OK;
if (pMatrix) {
transform.m11 = pMatrix->a;
transform.m12 = pMatrix->b;
transform.m21 = pMatrix->c;
transform.m22 = pMatrix->d;
transform.dx = pMatrix->e;
transform.dy = pMatrix->f;
}
glyphRun.fontFace = (IDWriteFontFace*)font;
glyphRun.fontEmSize = font_size;
glyphRun.glyphCount = glyph_count;
glyphRun.glyphIndices = glyph_indices;
glyphRun.glyphAdvances = glyph_advances;
glyphRun.glyphOffsets = (DWRITE_GLYPH_OFFSET*)glyph_offsets;
glyphRun.isSideways = FALSE;
glyphRun.bidiLevel = 0;
hr = pTextRenderer->DrawGlyphRun(
stringRect, pClipRgn, pMatrix ? &transform : nullptr, baselineOriginX,
baselineOriginY, DWRITE_MEASURING_MODE_NATURAL, &glyphRun,
RGB(FXARGB_R(text_color), FXARGB_G(text_color), FXARGB_B(text_color)));
return SUCCEEDED(hr);
}
void CPDF_ImageRenderer::CalculateDrawImage(CFX_FxgeDevice* pBitmapDevice1,
CFX_FxgeDevice* pBitmapDevice2,
const CFX_DIBSource* pDIBSource,
CFX_Matrix* pNewMatrix,
const FX_RECT& rect) const {
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_pContext, pBitmapDevice2, nullptr,
nullptr, nullptr, nullptr, nullptr, 0,
m_pRenderStatus->m_bDropObjects, nullptr, true);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, pDIBSource, 0xffffffff, 255,
pNewMatrix, m_Flags, true, FXDIB_BLEND_NORMAL)) {
image_render.Continue(nullptr);
}
if (m_Loader.m_MatteColor == 0xffffffff)
return;
int matte_r = FXARGB_R(m_Loader.m_MatteColor);
int matte_g = FXARGB_G(m_Loader.m_MatteColor);
int matte_b = FXARGB_B(m_Loader.m_MatteColor);
for (int row = 0; row < rect.Height(); row++) {
uint8_t* dest_scan =
const_cast<uint8_t*>(pBitmapDevice1->GetBitmap()->GetScanline(row));
const uint8_t* mask_scan = pBitmapDevice2->GetBitmap()->GetScanline(row);
for (int col = 0; col < rect.Width(); col++) {
int alpha = *mask_scan++;
if (!alpha) {
dest_scan += 4;
continue;
}
int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
*dest_scan++ = std::min(std::max(orig, 0), 255);
orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
*dest_scan++ = std::min(std::max(orig, 0), 255);
orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
*dest_scan++ = std::min(std::max(orig, 0), 255);
dest_scan++;
}
}
}
FX_BOOL CPDF_ImageRenderer::DrawMaskedImage() {
if (m_pRenderStatus->m_bPrint &&
!(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
m_Result = FALSE;
return FALSE;
}
FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
if (rect.IsEmpty()) {
return FALSE;
}
CFX_AffineMatrix new_matrix = m_ImageMatrix;
new_matrix.TranslateI(-rect.left, -rect.top);
int width = rect.Width();
int height = rect.Height();
CFX_FxgeDevice bitmap_device1;
if (!bitmap_device1.Create(width, height, FXDIB_Rgb32)) {
return TRUE;
}
bitmap_device1.GetBitmap()->Clear(0xffffff);
{
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, NULL,
NULL, NULL, NULL, NULL, 0,
m_pRenderStatus->m_bDropObjects, NULL, TRUE);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix,
m_Flags, TRUE)) {
image_render.Continue(NULL);
}
}
{
CFX_FxgeDevice bitmap_device2;
if (!bitmap_device2.Create(width, height, FXDIB_8bppRgb)) {
return TRUE;
}
bitmap_device2.GetBitmap()->Clear(0);
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, NULL,
NULL, NULL, NULL, NULL, 0,
m_pRenderStatus->m_bDropObjects, NULL, TRUE);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255,
&new_matrix, m_Flags, TRUE)) {
image_render.Continue(NULL);
}
if (m_Loader.m_MatteColor != 0xffffffff) {
int matte_r = FXARGB_R(m_Loader.m_MatteColor);
int matte_g = FXARGB_G(m_Loader.m_MatteColor);
int matte_b = FXARGB_B(m_Loader.m_MatteColor);
for (int row = 0; row < height; row++) {
uint8_t* dest_scan =
(uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
for (int col = 0; col < width; col++) {
int alpha = *mask_scan++;
if (alpha) {
int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
dest_scan++;
} else {
dest_scan += 4;
}
}
}
}
bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
if (m_BitmapAlpha < 255) {
bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
}
}
m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left,
rect.top, m_BlendType);
return FALSE;
}
void CPDF_DIBTransferFunc::TranslateScanline(uint8_t* dest_buf,
const uint8_t* src_buf) const {
int i;
FX_BOOL bSkip = FALSE;
switch (m_pSrc->GetFormat()) {
case FXDIB_1bppRgb: {
int r0 = m_RampR[0], g0 = m_RampG[0], b0 = m_RampB[0];
int r1 = m_RampR[255], g1 = m_RampG[255], b1 = m_RampB[255];
for (i = 0; i < m_Width; i++) {
if (src_buf[i / 8] & (1 << (7 - i % 8))) {
*dest_buf++ = b1;
*dest_buf++ = g1;
*dest_buf++ = r1;
} else {
*dest_buf++ = b0;
*dest_buf++ = g0;
*dest_buf++ = r0;
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
dest_buf++;
#endif
}
break;
}
case FXDIB_1bppMask: {
int m0 = m_RampR[0], m1 = m_RampR[255];
for (i = 0; i < m_Width; i++) {
if (src_buf[i / 8] & (1 << (7 - i % 8))) {
*dest_buf++ = m1;
} else {
*dest_buf++ = m0;
}
}
break;
}
case FXDIB_8bppRgb: {
FX_ARGB* pPal = m_pSrc->GetPalette();
for (i = 0; i < m_Width; i++) {
if (pPal) {
FX_ARGB src_argb = pPal[*src_buf];
*dest_buf++ = m_RampB[FXARGB_R(src_argb)];
*dest_buf++ = m_RampG[FXARGB_G(src_argb)];
*dest_buf++ = m_RampR[FXARGB_B(src_argb)];
} else {
FX_DWORD src_byte = *src_buf;
*dest_buf++ = m_RampB[src_byte];
*dest_buf++ = m_RampG[src_byte];
*dest_buf++ = m_RampR[src_byte];
}
src_buf++;
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
dest_buf++;
#endif
}
break;
}
case FXDIB_8bppMask:
for (i = 0; i < m_Width; i++) {
*dest_buf++ = m_RampR[*(src_buf++)];
}
break;
case FXDIB_Rgb:
for (i = 0; i < m_Width; i++) {
*dest_buf++ = m_RampB[*(src_buf++)];
*dest_buf++ = m_RampG[*(src_buf++)];
*dest_buf++ = m_RampR[*(src_buf++)];
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
dest_buf++;
#endif
}
break;
case FXDIB_Rgb32:
bSkip = TRUE;
case FXDIB_Argb:
for (i = 0; i < m_Width; i++) {
*dest_buf++ = m_RampB[*(src_buf++)];
*dest_buf++ = m_RampG[*(src_buf++)];
*dest_buf++ = m_RampR[*(src_buf++)];
if (!bSkip) {
*dest_buf++ = *src_buf;
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
else {
dest_buf++;
}
#endif
src_buf++;
}
break;
default:
break;
}
}
FX_BOOL CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device)
{
if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
m_Result = FALSE;
return FALSE;
}
FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
if (rect.IsEmpty()) {
return FALSE;
}
CFX_AffineMatrix new_matrix = m_ImageMatrix;
new_matrix.TranslateI(-rect.left, -rect.top);
int width = rect.Width();
int height = rect.Height();
CFX_FxgeDevice bitmap_device1;
if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32)) {
return TRUE;
}
bitmap_device1.GetBitmap()->Clear(0xffffff);
{
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_Level + 1, m_pRenderStatus->m_pContext, &bitmap_device1, NULL, NULL,
NULL, NULL, &m_pRenderStatus->m_Options, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
CFX_Matrix patternDevice = *pObj2Device;
patternDevice.Translate((FX_FLOAT) - rect.left, (FX_FLOAT) - rect.top);
if(m_pPattern->m_PatternType == PATTERN_TILING) {
bitmap_render.DrawTilingPattern((CPDF_TilingPattern*)m_pPattern, m_pImageObject, &patternDevice, FALSE);
} else {
bitmap_render.DrawShadingPattern((CPDF_ShadingPattern*)m_pPattern, m_pImageObject, &patternDevice, FALSE);
}
}
{
CFX_FxgeDevice bitmap_device2;
if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb)) {
return TRUE;
}
bitmap_device2.GetBitmap()->Clear(0);
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_Level + 1, m_pRenderStatus->m_pContext, &bitmap_device2, NULL, NULL,
NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255, &new_matrix, m_Flags, TRUE)) {
image_render.Continue(NULL);
}
if (m_Loader.m_MatteColor != 0xffffffff) {
int matte_r = FXARGB_R(m_Loader.m_MatteColor);
int matte_g = FXARGB_G(m_Loader.m_MatteColor);
int matte_b = FXARGB_B(m_Loader.m_MatteColor);
for (int row = 0; row < height; row ++) {
FX_LPBYTE dest_scan = (FX_LPBYTE)bitmap_device1.GetBitmap()->GetScanline(row);
FX_LPCBYTE mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
for (int col = 0; col < width; col ++) {
int alpha = *mask_scan ++;
if (alpha) {
int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
dest_scan ++;
} else {
dest_scan += 4;
}
}
}
}
bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
bitmap_device1.GetBitmap()->MultiplyAlpha(255);
}
m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
return FALSE;
}
FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
FX_ARGB argb,
int dest_left,
int dest_top,
int dest_width,
int dest_height,
const FX_RECT* clipRect,
FX_DWORD flags,
int alphaFlag ,
void* iccTransform ,
int blend_type)
{
SaveState();
if (clipRect) {
CGContextBeginPath(_context);
CGRect rect_clip = CGRectMake(clipRect->left, clipRect->top, clipRect->Width(), clipRect->Height());
rect_clip = CGRectApplyAffineTransform(rect_clip, _foxitDevice2User);
CGContextAddRect(_context, rect_clip);
CGContextClip(_context);
}
CGRect rect = CGRectMake(dest_left, dest_top, dest_width, dest_height);
rect = CGRectApplyAffineTransform(rect, _foxitDevice2User);
if (FXDIB_BICUBIC_INTERPOL == flags) {
CGContextSetInterpolationQuality(_context, kCGInterpolationHigh);
} else if (FXDIB_DOWNSAMPLE == flags) {
CGContextSetInterpolationQuality(_context, kCGInterpolationNone);
} else {
CGContextSetInterpolationQuality(_context, kCGInterpolationMedium);
}
CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height);
CFX_DIBitmap* pBitmap1 = NULL;
if (pBitmap->IsAlphaMask()) {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
pBitmap1->GetBuffer(),
pBitmap1->GetPitch() * pBitmap1->GetHeight(),
NULL);
CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
CGImageRef pImage = CGImageCreate(pBitmap1->GetWidth(),
pBitmap1->GetHeight(),
pBitmap1->GetBPP(),
pBitmap1->GetBPP(),
pBitmap1->GetPitch(),
pColorSpace,
bitmapInfo,
pBitmapProvider, NULL, true,
kCGRenderingIntentDefault);
CGContextClipToMask(_context, rect, pImage);
CGContextSetRGBFillColor(_context,
FXARGB_R(argb) / 255.f,
FXARGB_G(argb) / 255.f,
FXARGB_B(argb) / 255.f,
FXARGB_A(argb) / 255.f);
CGContextFillRect(_context, rect);
CGImageRelease(pImage);
CGColorSpaceRelease(pColorSpace);
CGDataProviderRelease(pBitmapProvider);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
if (pBitmap->GetBPP() < 32) {
pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
} else {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
if (pBitmap1->HasAlpha()) {
if (pBitmap1 == pBitmap) {
pBitmap1 = pBitmap->Clone();
if (!pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
}
for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
FX_LPBYTE pScanline = (FX_LPBYTE)pBitmap1->GetScanline(row);
for (int col = 0; col < pBitmap1->GetWidth(); col ++) {
pScanline[0] = (FX_BYTE)(pScanline[0] * pScanline[3] / 255.f + .5f);
pScanline[1] = (FX_BYTE)(pScanline[1] * pScanline[3] / 255.f + .5f);
pScanline[2] = (FX_BYTE)(pScanline[2] * pScanline[3] / 255.f + .5f);
pScanline += 4;
}
}
}
CGContextRef ctx = createContextWithBitmap(pBitmap1);
CGImageRef image = CGBitmapContextCreateImage(ctx);
CGContextDrawImage(_context, rect, image);
CGImageRelease(image);
CGContextRelease(ctx);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
FX_ARGB argb,
const FX_RECT* srcRect,
int dest_left,
int dest_top,
int blendType,
int alphaFlag ,
void* iccTransform )
{
SaveState();
CGFloat src_left, src_top, src_width, src_height;
if (srcRect) {
src_left = srcRect->left;
src_top = srcRect->top;
src_width = srcRect->Width();
src_height = srcRect->Height();
} else {
src_left = src_top = 0;
src_width = pBitmap->GetWidth();
src_height = pBitmap->GetHeight();
}
CGAffineTransform ctm = CGContextGetCTM(_context);
CGFloat scale_x = FXSYS_fabs(ctm.a);
CGFloat scale_y = FXSYS_fabs(ctm.d);
src_left /= scale_x;
src_top /= scale_y;
src_width /= scale_x;
src_height /= scale_y;
CGRect rect_fx = CGRectMake(dest_left, dest_top, src_width, src_height);
CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, _foxitDevice2User);
CGContextBeginPath(_context);
CGContextAddRect(_context, rect_usr);
CGContextClip(_context);
rect_usr.size = CGSizeMake(pBitmap->GetWidth() / scale_x, pBitmap->GetHeight() / scale_y);
rect_usr = CGRectOffset(rect_usr, -src_left, -src_top);
CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
CFX_DIBitmap* pBitmap1 = NULL;
if (pBitmap->IsAlphaMask()) {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
pBitmap1->GetBuffer(),
pBitmap1->GetPitch() * pBitmap1->GetHeight(),
NULL);
CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
CGImageRef pImage = CGImageCreate(pBitmap1->GetWidth(),
pBitmap1->GetHeight(),
pBitmap1->GetBPP(),
pBitmap1->GetBPP(),
pBitmap1->GetPitch(),
pColorSpace,
bitmapInfo,
pBitmapProvider, NULL, true,
kCGRenderingIntentDefault);
CGContextClipToMask(_context, rect_usr, pImage);
CGContextSetRGBFillColor(_context,
FXARGB_R(argb) / 255.f,
FXARGB_G(argb) / 255.f,
FXARGB_B(argb) / 255.f,
FXARGB_A(argb) / 255.f);
CGContextFillRect(_context, rect_usr);
CGImageRelease(pImage);
CGColorSpaceRelease(pColorSpace);
CGDataProviderRelease(pBitmapProvider);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
if (pBitmap->GetBPP() < 32) {
pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
} else {
if (pBitmap->GetBuffer()) {
pBitmap1 = (CFX_DIBitmap*)pBitmap;
} else {
pBitmap1 = pBitmap->Clone();
}
}
if (NULL == pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
if (pBitmap1->HasAlpha()) {
if (pBitmap1 == pBitmap) {
pBitmap1 = pBitmap->Clone();
if (!pBitmap1) {
RestoreState(FALSE);
return FALSE;
}
}
for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
FX_LPBYTE pScanline = (FX_LPBYTE)pBitmap1->GetScanline(row);
for (int col = 0; col < pBitmap1->GetWidth(); col ++) {
pScanline[0] = (FX_BYTE)(pScanline[0] * pScanline[3] / 255.f + .5f);
pScanline[1] = (FX_BYTE)(pScanline[1] * pScanline[3] / 255.f + .5f);
pScanline[2] = (FX_BYTE)(pScanline[2] * pScanline[3] / 255.f + .5f);
pScanline += 4;
}
}
}
CGContextRef ctx = createContextWithBitmap(pBitmap1);
CGImageRef image = CGBitmapContextCreateImage(ctx);
int blend_mode = blendType;
if (FXDIB_BLEND_HARDLIGHT == blendType) {
blend_mode = kCGBlendModeSoftLight;
} else if (FXDIB_BLEND_SOFTLIGHT == blendType) {
blend_mode = kCGBlendModeHardLight;
} else if (blendType >= FXDIB_BLEND_NONSEPARABLE && blendType <= FXDIB_BLEND_LUMINOSITY) {
blend_mode = blendType - 9;
} else if (blendType > FXDIB_BLEND_LUMINOSITY || blendType < 0) {
blend_mode = kCGBlendModeNormal;
}
CGContextSetBlendMode(_context, (CGBlendMode)blend_mode);
CGContextDrawImage(_context, rect_usr, image);
CGImageRelease(image);
CGContextRelease(ctx);
if (pBitmap1 != pBitmap) {
delete pBitmap1;
}
RestoreState(FALSE);
return TRUE;
}
void CPDF_DIBTransferFunc::TranslateScanline(
const uint8_t* src_buf,
std::vector<uint8_t>* dest_buf) const {
bool bSkip = false;
switch (m_pSrc->GetFormat()) {
case FXDIB_1bppRgb: {
int r0 = m_RampR[0];
int g0 = m_RampG[0];
int b0 = m_RampB[0];
int r1 = m_RampR[255];
int g1 = m_RampG[255];
int b1 = m_RampB[255];
int index = 0;
for (int i = 0; i < m_Width; i++) {
if (src_buf[i / 8] & (1 << (7 - i % 8))) {
(*dest_buf)[index++] = b1;
(*dest_buf)[index++] = g1;
(*dest_buf)[index++] = r1;
} else {
(*dest_buf)[index++] = b0;
(*dest_buf)[index++] = g0;
(*dest_buf)[index++] = r0;
}
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
index++;
#endif
}
break;
}
case FXDIB_1bppMask: {
int m0 = m_RampR[0];
int m1 = m_RampR[255];
int index = 0;
for (int i = 0; i < m_Width; i++) {
if (src_buf[i / 8] & (1 << (7 - i % 8)))
(*dest_buf)[index++] = m1;
else
(*dest_buf)[index++] = m0;
}
break;
}
case FXDIB_8bppRgb: {
FX_ARGB* pPal = m_pSrc->GetPalette();
int index = 0;
for (int i = 0; i < m_Width; i++) {
if (pPal) {
FX_ARGB src_argb = pPal[*src_buf];
(*dest_buf)[index++] = m_RampB[FXARGB_R(src_argb)];
(*dest_buf)[index++] = m_RampG[FXARGB_G(src_argb)];
(*dest_buf)[index++] = m_RampR[FXARGB_B(src_argb)];
} else {
uint32_t src_byte = *src_buf;
(*dest_buf)[index++] = m_RampB[src_byte];
(*dest_buf)[index++] = m_RampG[src_byte];
(*dest_buf)[index++] = m_RampR[src_byte];
}
src_buf++;
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
index++;
#endif
}
break;
}
case FXDIB_8bppMask: {
int index = 0;
for (int i = 0; i < m_Width; i++) {
(*dest_buf)[index++] = m_RampR[*(src_buf++)];
}
break;
}
case FXDIB_Rgb: {
int index = 0;
for (int i = 0; i < m_Width; i++) {
(*dest_buf)[index++] = m_RampB[*(src_buf++)];
(*dest_buf)[index++] = m_RampG[*(src_buf++)];
(*dest_buf)[index++] = m_RampR[*(src_buf++)];
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
index++;
#endif
}
break;
}
case FXDIB_Rgb32:
bSkip = true;
case FXDIB_Argb: {
int index = 0;
for (int i = 0; i < m_Width; i++) {
(*dest_buf)[index++] = m_RampB[*(src_buf++)];
(*dest_buf)[index++] = m_RampG[*(src_buf++)];
(*dest_buf)[index++] = m_RampR[*(src_buf++)];
if (!bSkip) {
(*dest_buf)[index++] = *src_buf;
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
} else {
index++;
#endif
}
src_buf++;
}
break;
}
default:
break;
}
}
bool CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
if (m_pRenderStatus->m_bPrint &&
!(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
m_Result = false;
return false;
}
FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect();
rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
if (rect.IsEmpty()) {
return false;
}
CFX_Matrix new_matrix = m_ImageMatrix;
new_matrix.TranslateI(-rect.left, -rect.top);
int width = rect.Width();
int height = rect.Height();
CFX_FxgeDevice bitmap_device1;
if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32, nullptr))
return true;
bitmap_device1.GetBitmap()->Clear(0xffffff);
{
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1,
nullptr, nullptr, nullptr, nullptr,
&m_pRenderStatus->m_Options, 0,
m_pRenderStatus->m_bDropObjects, nullptr, true);
CFX_Matrix patternDevice = *pObj2Device;
patternDevice.Translate((FX_FLOAT)-rect.left, (FX_FLOAT)-rect.top);
if (CPDF_TilingPattern* pTilingPattern = m_pPattern->AsTilingPattern()) {
bitmap_render.DrawTilingPattern(pTilingPattern, m_pImageObject,
&patternDevice, false);
} else if (CPDF_ShadingPattern* pShadingPattern =
m_pPattern->AsShadingPattern()) {
bitmap_render.DrawShadingPattern(pShadingPattern, m_pImageObject,
&patternDevice, false);
}
}
{
CFX_FxgeDevice bitmap_device2;
if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
nullptr)) {
return true;
}
bitmap_device2.GetBitmap()->Clear(0);
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2,
nullptr, nullptr, nullptr, nullptr, nullptr, 0,
m_pRenderStatus->m_bDropObjects, nullptr, true);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255,
&new_matrix, m_Flags, true)) {
image_render.Continue(nullptr);
}
if (m_Loader.m_MatteColor != 0xffffffff) {
int matte_r = FXARGB_R(m_Loader.m_MatteColor);
int matte_g = FXARGB_G(m_Loader.m_MatteColor);
int matte_b = FXARGB_B(m_Loader.m_MatteColor);
for (int row = 0; row < height; row++) {
uint8_t* dest_scan =
(uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
for (int col = 0; col < width; col++) {
int alpha = *mask_scan++;
if (alpha) {
int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
if (orig < 0) {
orig = 0;
} else if (orig > 255) {
orig = 255;
}
*dest_scan++ = orig;
dest_scan++;
} else {
dest_scan += 4;
}
}
}
}
bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
bitmap_device1.GetBitmap()->MultiplyAlpha(255);
}
m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
return false;
}