bool GiCanvasIos::drawCachedBitmap2(const GiCanvas* p, float x, float y, bool secondBmp)
{
bool ret = false;
if (p && p->getCanvasType() == getCanvasType()) {
GiCanvasIos* gs = (GiCanvasIos*)p;
int index = secondBmp ? 1 : 0;
CGImageRef image = gs->m_draw->_cacheserr[index] ? NULL : gs->m_draw->_caches[index];
CGContextRef context = m_draw->getContext();
if (context && image) {
CGRect rect = CGRectMake(x, y, m_draw->width(), m_draw->height());
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, m_draw->height());
CGContextConcatCTM(context, af);
CGInterpolationQuality oldQuality = CGContextGetInterpolationQuality(context);
CGContextSetInterpolationQuality(context, kCGInterpolationNone);
CGContextDrawImage(context, rect, image);
CGContextSetInterpolationQuality(context, oldQuality);
CGContextConcatCTM(context, CGAffineTransformInvert(af));
ret = true;
}
}
return ret;
}
CGImageRef GiCanvasIos::cachedBitmap(bool invert)
{
CGImageRef image = m_draw->_caches[0];
if (!image || !invert)
return image; // 调用者不能释放图像
size_t w = CGImageGetWidth(image); // 图像宽度，像素单位，不是点单位
size_t h = CGImageGetHeight(image);
CGImageRef newimg = NULL;
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGContextRef context = CGBitmapContextCreate(NULL, w, h, 8, w * 4,
colorSpace, kCGImageAlphaPremultipliedLast);
CGColorSpaceRelease(colorSpace);
if (context) {
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, h);
CGContextConcatCTM(context, af); // 图像是朝上的，上下文坐标系朝下，上下颠倒显示
CGContextDrawImage(context, CGRectMake(0, 0, w, h), image);
CGContextConcatCTM(context, CGAffineTransformInvert(af));
newimg = CGBitmapContextCreateImage(context); // 得到上下颠倒的新图像
CGContextRelease(context);
}
return newimg; // 由调用者释放图像, CGImageRelease
}
bool GiCanvasIos::drawImage(CGImageRef image, const Point2d& centerM, bool autoScale)
{
CGContextRef context = m_draw->getContext();
bool ret = false;
if (context && image) {
Point2d ptD = centerM * m_draw->xf().modelToDisplay();
float w = CGImageGetWidth(image);
float h = CGImageGetHeight(image);
if (autoScale) {
w *= m_draw->xf().getViewScale();
h *= m_draw->xf().getViewScale();
}
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, m_draw->height());
af = CGAffineTransformTranslate(af, ptD.x - w * 0.5f,
m_draw->height() - (ptD.y + h * 0.5f));
CGContextConcatCTM(context, af);
CGContextDrawImage(context, CGRectMake(0, 0, w, h), image);
CGContextConcatCTM(context, CGAffineTransformInvert(af));
ret = true;
}
return ret;
}
void GiCanvasIos::endPaint(bool draw)
{
if (m_draw->getContext())
{
if (draw && m_draw->_buffctx && m_draw->_context) {
CGContextRef context = m_draw->_context;
CGImageRef image = CGBitmapContextCreateImage(m_draw->_buffctx);
CGRect rect = CGRectMake(0, 0, m_draw->width(), m_draw->height()); // 逻辑宽高点数
if (image) {
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, m_draw->height());
CGContextConcatCTM(context, af); // 图像是朝上的，上下文坐标系朝下，上下颠倒显示
CGInterpolationQuality old = CGContextGetInterpolationQuality(context);
CGContextSetInterpolationQuality(context, kCGInterpolationNone);
CGContextDrawImage(context, rect, image);
CGContextSetInterpolationQuality(context, old);
CGContextConcatCTM(context, CGAffineTransformInvert(af)); // 恢复成坐标系朝下
CGImageRelease(image);
}
}
if (m_draw->_buffctx) {
CGContextRelease(m_draw->_buffctx);
m_draw->_buffctx = NULL;
}
m_draw->_context = NULL;
if (owner())
owner()->_endPaint();
}
}
void ImageBuffer::putByteArray(Multiply multiplied, Uint8ClampedArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem coordinateSystem)
{
if (!context().isAcceleratedContext()) {
IntRect scaledSourceRect = sourceRect;
IntSize scaledSourceSize = sourceSize;
if (coordinateSystem == LogicalCoordinateSystem) {
scaledSourceRect.scale(m_resolutionScale);
scaledSourceSize.scale(m_resolutionScale);
}
m_data.putData(source, scaledSourceSize, scaledSourceRect, destPoint, internalSize(), false, multiplied == Unmultiplied, 1);
return;
}
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
// Make a copy of the source to ensure the bits don't change before being drawn
IntSize sourceCopySize(sourceRect.width(), sourceRect.height());
// FIXME (149431): Should this ImageBuffer be unconditionally unaccelerated? Making it match the context seems to break putData().
std::unique_ptr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, Unaccelerated, 1, ColorSpaceDeviceRGB);
if (!sourceCopy)
return;
sourceCopy->m_data.putData(source, sourceSize, sourceRect, IntPoint(-sourceRect.x(), -sourceRect.y()), sourceCopy->internalSize(), sourceCopy->context().isAcceleratedContext(), multiplied == Unmultiplied, 1);
// Set up context for using drawImage as a direct bit copy
CGContextRef destContext = context().platformContext();
CGContextSaveGState(destContext);
if (coordinateSystem == LogicalCoordinateSystem)
CGContextConcatCTM(destContext, AffineTransform(wkGetUserToBaseCTM(destContext)).inverse());
else
CGContextConcatCTM(destContext, AffineTransform(CGContextGetCTM(destContext)).inverse());
CGContextResetClip(destContext);
CGContextSetInterpolationQuality(destContext, kCGInterpolationNone);
CGContextSetAlpha(destContext, 1.0);
CGContextSetBlendMode(destContext, kCGBlendModeCopy);
CGContextSetShadowWithColor(destContext, CGSizeZero, 0, 0);
// Draw the image in CG coordinate space
FloatSize scaledDestSize = scaleSizeToUserSpace(coordinateSystem == LogicalCoordinateSystem ? logicalSize() : internalSize(), m_data.backingStoreSize, internalSize());
IntPoint destPointInCGCoords(destPoint.x() + sourceRect.x(), scaledDestSize.height() - (destPoint.y() + sourceRect.y()) - sourceRect.height());
IntRect destRectInCGCoords(destPointInCGCoords, sourceCopySize);
CGContextClipToRect(destContext, destRectInCGCoords);
RetainPtr<CGImageRef> sourceCopyImage = sourceCopy->copyNativeImage();
FloatRect backingStoreInDestRect = FloatRect(FloatPoint(destPointInCGCoords.x(), destPointInCGCoords.y() + sourceCopySize.height() - (int)CGImageGetHeight(sourceCopyImage.get())), FloatSize(CGImageGetWidth(sourceCopyImage.get()), CGImageGetHeight(sourceCopyImage.get())));
CGContextDrawImage(destContext, backingStoreInDestRect, sourceCopyImage.get());
CGContextRestoreGState(destContext);
#endif
}
void drawSkewedCoordinateSystem(CGContextRef context)
{
// alpha is 22.5 degrees and beta is 15 degrees.
float alpha = M_PI/8, beta = M_PI/12;
CGAffineTransform skew;
// Create a rectangle that is 72 units on a side
// with its origin at (0,0).
CGRect r = CGRectMake(0, 0, 72, 72);
CGContextTranslateCTM(context, 144, 144);
// Draw the coordinate axes untransformed.
drawCoordinateAxes(context);
// Fill the rectangle.
CGContextFillRect(context, r);
// Create an affine transform that skews the coordinate system,
// skewing the x-axis by alpha radians and the y-axis by beta radians.
skew = CGAffineTransformMake(1, tan(alpha), tan(beta), 1, 0, 0);
// Apply that transform to the context coordinate system.
CGContextConcatCTM(context, skew);
// Set the fill and stroke color to a dark blue.
CGContextSetRGBStrokeColor(context, 0.11, 0.208, 0.451, 1);
CGContextSetRGBFillColor(context, 0.11, 0.208, 0.451, 1);
// Draw the coordinate axes again, now transformed.
drawCoordinateAxes(context);
// Set the fill color again but with a partially transparent alpha.
CGContextSetRGBFillColor(context, 0.11, 0.208, 0.451, 0.7);
// Fill the rectangle in the transformed coordinate system.
CGContextFillRect(context, r);
}
void doRotatedEllipses(CGContextRef context)
{
int i, totreps = 144;
float tint = 1.0, tintIncrement = 1.0/totreps;
// Create a new transform consisting of a 45 degrees rotation.
CGAffineTransform theTransform = CGAffineTransformMakeRotation(M_PI/4);
// Apply a scale to the transform just created.
theTransform = CGAffineTransformScale(theTransform, 1, 2);
// Place the first ellipse at a good location.
CGContextTranslateCTM(context, 100., 100.);
for(i=0 ; i < totreps ; i++){
// Make a snapshot the coordinate system.
CGContextSaveGState(context);
// Set up the coordinate system for the rotated ellipse.
CGContextConcatCTM(context, theTransform);
CGContextBeginPath(context);
CGContextAddArc(context, 0., 0., 45., 0., 2*M_PI, 0);
// Set the fill color for this instance of the ellipse.
CGContextSetRGBFillColor(context, tint, 0., 0., 1.0);
CGContextDrawPath(context, kCGPathFill);
// Restore the coordinate system to that of the snapshot.
CGContextRestoreGState(context);
// Compute the next tint color.
tint -= tintIncrement;
// Move over by 1 unit in x for the next ellipse.
CGContextTranslateCTM(context, 1.0, 0.0);
}
}
DRAW_TEST_F(CGImageDrawing, DrawAContextIntoAnImage, UIKitMimicTest<>) {
// This test will create a bitmap context, draw some entity into the context, then create a image out of the bitmap context.
// Thereafter it will draw the image into the Canvas context
static woc::unique_cf<CGColorSpaceRef> rgbColorSpace(CGColorSpaceCreateDeviceRGB());
// Create a bitmap context to draw the Image into
woc::unique_cf<CGContextRef> contextImage(CGBitmapContextCreate(
nullptr, 10, 10, 8, 4 * 10 /* bytesPerRow = bytesPerPixel*width*/, rgbColorSpace.get(), kCGImageAlphaPremultipliedFirst));
ASSERT_NE(contextImage, nullptr);
CGContextSetRGBFillColor(contextImage.get(), 1.0, 0.0, 0.0, 1.0);
CGContextFillRect(contextImage.get(), { 0, 0, 10, 10 });
// Create the image out of the bitmap context
woc::unique_cf<CGImageRef> image(CGBitmapContextCreateImage(contextImage.get()));
ASSERT_NE(image, nullptr);
CGContextRef context = GetDrawingContext();
CGRect bounds = GetDrawingBounds();
CGAffineTransform flip = CGAffineTransformMakeScale(1, -1);
CGAffineTransform shift = CGAffineTransformTranslate(flip, 0, bounds.size.height * -1);
CGContextConcatCTM(context, shift);
// draw the image
CGContextDrawImage(context, bounds, image.get());
}
void ImageBuffer::putByteArray(Multiply multiplied, ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
{
if (!m_context->isAcceleratedContext()) {
m_data.putData(source, sourceSize, sourceRect, destPoint, internalSize(), m_context->isAcceleratedContext(), multiplied == Unmultiplied);
return;
}
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
// Make a copy of the source to ensure the bits don't change before being drawn
IntSize sourceCopySize(sourceRect.width(), sourceRect.height());
OwnPtr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, 1, ColorSpaceDeviceRGB, Unaccelerated);
if (!sourceCopy)
return;
sourceCopy->m_data.putData(source, sourceSize, sourceRect, IntPoint(-sourceRect.x(), -sourceRect.y()), sourceCopy->internalSize(), sourceCopy->context()->isAcceleratedContext(), multiplied == Unmultiplied);
// Set up context for using drawImage as a direct bit copy
CGContextRef destContext = context()->platformContext();
CGContextSaveGState(destContext);
CGContextConcatCTM(destContext, AffineTransform(CGContextGetCTM(destContext)).inverse());
wkCGContextResetClip(destContext);
CGContextSetInterpolationQuality(destContext, kCGInterpolationNone);
CGContextSetAlpha(destContext, 1.0);
CGContextSetBlendMode(destContext, kCGBlendModeCopy);
CGContextSetShadowWithColor(destContext, CGSizeZero, 0, 0);
// Draw the image in CG coordinate space
IntPoint destPointInCGCoords(destPoint.x() + sourceRect.x(), internalSize().height() - (destPoint.y()+sourceRect.y()) - sourceRect.height());
IntRect destRectInCGCoords(destPointInCGCoords, sourceCopySize);
RetainPtr<CGImageRef> sourceCopyImage(AdoptCF, sourceCopy->copyNativeImage());
CGContextDrawImage(destContext, destRectInCGCoords, sourceCopyImage.get());
CGContextRestoreGState(destContext);
#endif
}
void GraphicsContext::concatCTM(const AffineTransform& transform)
{
if (paintingDisabled())
return;
CGContextConcatCTM(platformContext(), transform);
m_data->concatCTM(transform);
}
static void TransformHIViewToCG(CGContextRef ctx, HIViewRef theView)
{
// Undo the HIView coordinate flipping
HIRect bounds;
HIViewGetBounds(theView, &bounds);
CGContextConcatCTM(ctx, CGAffineTransformMake(1, 0, 0, -1, 0, bounds.size.height));
}
void GraphicsContext::fillPath(const Path& path)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextBeginPath(context);
CGContextAddPath(context, path.platformPath());
if (m_state.fillGradient) {
CGContextSaveGState(context);
if (fillRule() == RULE_EVENODD)
CGContextEOClip(context);
else
CGContextClip(context);
CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
m_state.fillGradient->paint(this);
CGContextRestoreGState(context);
return;
}
if (m_state.fillPattern)
applyFillPattern();
fillPathWithFillRule(context, fillRule());
}
void pathForArc(CGContextRef context, CGRect r, int startAngle, int arcAngle)
{
float start, end;
CGAffineTransform matrix;
// Save the context's state because we are going to scale it
CGContextSaveGState(context);
// Create a transform to scale the context so that a radius of 1 maps to the bounds
// of the rectangle, and transform the origin of the context to the center of
// the bounding rectangle.
matrix = CGAffineTransformMake(r.size.width/2, 0,
0, r.size.height/2,
r.origin.x + r.size.width/2,
r.origin.y + r.size.height/2);
// Apply the transform to the context
CGContextConcatCTM(context, matrix);
// Calculate the start and ending angles
if (arcAngle > 0) {
start = (90 - startAngle - arcAngle) * M_PI / 180;
end = (90 - startAngle) * M_PI / 180;
} else {
start = (90 - startAngle) * M_PI / 180;
end = (90 - startAngle - arcAngle) * M_PI / 180;
}
// Add the Arc to the path
CGContextAddArc(context, 0, 0, 1, start, end, false);
// Restore the context's state. This removes the translation and scaling
// but leaves the path, since the path is not part of the graphics state.
CGContextRestoreGState(context);
}
//-----------------------------------------------------------------------------
void CGDrawContext::fillLinearGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& startPoint, const CPoint& endPoint, bool evenOdd, CGraphicsTransform* t)
{
QuartzGraphicsPath* path = dynamic_cast<QuartzGraphicsPath*> (_path);
if (path == 0)
return;
const QuartzGradient* cgGradient = dynamic_cast<const QuartzGradient*> (&gradient);
if (cgGradient == 0)
return;
CGContextRef cgContext = beginCGContext (true, currentState.drawMode.integralMode ());
if (cgContext)
{
if (t)
{
CGContextSaveGState (cgContext);
CGAffineTransform transform = QuartzGraphicsPath::createCGAfflineTransform (*t);
CGContextConcatCTM (cgContext, transform);
CGContextAddPath (cgContext, path->getCGPathRef ());
CGContextRestoreGState (cgContext);
}
else
CGContextAddPath (cgContext, path->getCGPathRef ());
if (evenOdd)
CGContextEOClip (cgContext);
else
CGContextClip (cgContext);
CGContextDrawLinearGradient (cgContext, *cgGradient, CGPointMake (startPoint.x, startPoint.y), CGPointMake (endPoint.x, endPoint.y), kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
releaseCGContext (cgContext);
}
}
void GraphicsContext::fillRect(const FloatRect& rect)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
if (m_state.fillGradient) {
CGContextSaveGState(context);
CGContextConcatCTM(context, m_state.fillGradient->gradientSpaceTransform());
if (hasShadow()) {
CGLayerRef layer = CGLayerCreateWithContext(context, CGSizeMake(rect.width(), rect.height()), 0);
CGContextRef layerContext = CGLayerGetContext(layer);
m_state.fillGradient->paint(layerContext);
CGContextDrawLayerAtPoint(context, CGPointMake(rect.left(), rect.top()), layer);
CGLayerRelease(layer);
} else {
CGContextClipToRect(context, rect);
m_state.fillGradient->paint(this);
}
CGContextRestoreGState(context);
return;
}
if (m_state.fillPattern)
applyFillPattern();
CGContextFillRect(context, rect);
}
void addOvalToPath(CGContextRef context, CGRect r)
{
CGAffineTransform matrix;
// Save the context's state because we are going to transform and scale it
CGContextSaveGState(context);
// Create a transform to scale the context so that a radius of 1
// is equal to the bounds of the rectangle, and transform the origin
// of the context to the center of the bounding rectangle. The
// center of the bounding rectangle will now be the center of
// the oval.
matrix = CGAffineTransformMake((r.size.width)/2, 0,
0, (r.size.height)/2,
r.origin.x + (r.size.width)/2,
r.origin.y + (r.size.height)/2);
// Apply the transform to the context
CGContextConcatCTM(context, matrix);
// Signal the start of a path
CGContextBeginPath(context);
// Add a circle to the path. After the circle is transformed by the
// context's transformation matrix, it will become an oval lying
// just inside the bounding rectangle.
CGContextAddArc(context, 0, 0, 1, 0, 2*pi, true);
// Restore the context's state. This removes the translation and scaling but leaves
// the path, since the path is not part of the graphics state.
CGContextRestoreGState(context);
}
void SVGPaintServerGradient::handleBoundingBoxModeAndGradientTransformation(GraphicsContext* context, const FloatRect& targetRect) const
{
CGContextRef contextRef = context->platformContext();
if (boundingBoxMode()) {
// Choose default gradient bounding box
CGRect gradientBBox = CGRectMake(0.0, 0.0, 1.0, 1.0);
// Generate a transform to map between both bounding boxes
CGAffineTransform gradientIntoObjectBBox = CGAffineTransformMakeMapBetweenRects(gradientBBox, CGRect(targetRect));
CGContextConcatCTM(contextRef, gradientIntoObjectBBox);
}
// Apply the gradient's own transform
CGAffineTransform transform = gradientTransform();
CGContextConcatCTM(contextRef, transform);
}
void GraphicsContext::concatCTM(const AffineTransform& transform)
{
if (paintingDisabled())
return;
CGContextConcatCTM(platformContext(), transform);
m_data->concatCTM(transform);
m_data->m_userToDeviceTransformKnownToBeIdentity = false;
}
void updateHandle(Handle hndl, const SkMatrix& ctm, const SkIRect& clip) override {
CGContextRef cg = (CGContextRef)hndl;
CGContextRestoreGState(cg);
CGContextSaveGState(cg);
CGContextClipToRect(cg, CGRectMake(clip.x(), clip.y(), clip.width(), clip.height()));
CGContextConcatCTM(cg, matrix_to_transform(cg, ctm));
}
FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData* pathData,
const CFX_AffineMatrix* matrix,
const CFX_GraphStateData* graphState,
FX_DWORD fillArgb,
FX_DWORD strokeArgb,
int fillMode,
int alpha_flag,
void* pIccTransform,
int blend_type
)
{
SaveState();
CGBlendMode mode = GetCGBlendMode(blend_type);
if (mode != kCGBlendModeNormal) {
CGContextSetBlendMode(_context, mode);
}
CGAffineTransform m = CGAffineTransformIdentity;
if (matrix) {
m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(), matrix->GetD(), matrix->GetE(), matrix->GetF());
}
m = CGAffineTransformConcat(m, _foxitDevice2User);
CGContextConcatCTM(_context, m);
int pathMode = 0;
if (graphState && strokeArgb) {
CGContextSetMiterLimit(_context, graphState->m_MiterLimit);
FX_FLOAT lineWidth = getLineWidth(graphState, m);
setStrokeInfo(graphState, strokeArgb, lineWidth);
pathMode |= 4;
}
if (fillMode && fillArgb) {
setFillInfo(fillArgb);
if ((fillMode & 3) == FXFILL_WINDING) {
pathMode |= 1;
} else if ((fillMode & 3) == FXFILL_ALTERNATE) {
pathMode |= 2;
}
}
setPathToContext(pathData);
if (fillMode & FXFILL_FULLCOVER) {
CGContextSetShouldAntialias(_context, false);
}
if (pathMode == 4) {
CGContextStrokePath(_context);
} else if (pathMode == 1) {
CGContextFillPath(_context);
} else if (pathMode == 2) {
CGContextEOFillPath(_context);
} else if (pathMode == 5) {
CGContextDrawPath(_context, kCGPathFillStroke);
} else if (pathMode == 6) {
CGContextDrawPath(_context, kCGPathEOFillStroke);
}
RestoreState(FALSE);
return TRUE;
}
bool GiCanvasIos::drawImage(CGImageRef image, const Box2d& rectM)
{
CGContextRef context = m_draw->getContext();
bool ret = false;
if (context && image) {
Point2d ptD = rectM.center() * m_draw->xf().modelToDisplay();
Box2d rect = rectM * m_draw->xf().modelToDisplay();
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, m_draw->height());
af = CGAffineTransformTranslate(af, ptD.x - rect.width() * 0.5f,
m_draw->height() - (ptD.y + rect.height() * 0.5f));
CGContextConcatCTM(context, af);
CGContextDrawImage(context, CGRectMake(0, 0, rect.width(), rect.height()), image);
CGContextConcatCTM(context, CGAffineTransformInvert(af));
ret = true;
}
return ret;
}
//-----------------------------------------------------------------------------
void CGDrawContext::drawGraphicsPath (CGraphicsPath* _path, PathDrawMode mode, CGraphicsTransform* t)
{
QuartzGraphicsPath* path = dynamic_cast<QuartzGraphicsPath*> (_path);
if (path == 0)
return;
CGContextRef context = beginCGContext (true, getDrawMode ().integralMode ());
if (context)
{
CGPathDrawingMode cgMode;
switch (mode)
{
case kPathFilledEvenOdd:
{
cgMode = kCGPathEOFill;
break;
}
case kPathStroked:
{
cgMode = kCGPathStroke;
applyLineStyle (context);
break;
}
default:
{
cgMode = kCGPathFill;
break;
}
}
if (getDrawMode ().integralMode ())
{
applyLineWidthCTM (context);
path->pixelAlign (this, t);
CGContextAddPath (context, path->getCGPathRef ());
}
else if (t)
{
CGContextSaveGState (context);
CGAffineTransform transform = QuartzGraphicsPath::createCGAffineTransform (*t);
CGContextConcatCTM (context, transform);
CGContextAddPath (context, path->getCGPathRef ());
CGContextRestoreGState (context);
}
else
CGContextAddPath (context, path->getCGPathRef ());
CGContextDrawPath (context, cgMode);
releaseCGContext (context);
}
}
//-----------------------------------------------------------------------------
CGDrawContext::CGDrawContext (CGBitmap* _bitmap)
: COffscreenContext (new CBitmap (_bitmap))
, cgContext (_bitmap->createCGContext ())
, scaleFactor (_bitmap->getScaleFactor ())
{
if (scaleFactor != 1.)
{
CGContextConcatCTM (cgContext, CGAffineTransformMakeScale (static_cast<CGFloat> (scaleFactor), static_cast<CGFloat> (scaleFactor)));
}
init ();
bitmap->forget ();
}
CGContextRef BitLockerSkia::cgContext()
{
SkDevice* device = m_canvas->getDevice();
ASSERT(device);
if (!device)
return 0;
releaseIfNeeded();
const SkBitmap& bitmap = device->accessBitmap(true);
bitmap.lockPixels();
void* pixels = bitmap.getPixels();
m_cgContext = CGBitmapContextCreate(pixels, device->width(),
device->height(), 8, bitmap.rowBytes(), CGColorSpaceCreateDeviceRGB(),
kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
// Apply device matrix.
CGAffineTransform contentsTransform = CGAffineTransformMakeScale(1, -1);
contentsTransform = CGAffineTransformTranslate(contentsTransform, 0, -device->height());
CGContextConcatCTM(m_cgContext, contentsTransform);
// Apply clip in device coordinates.
CGMutablePathRef clipPath = CGPathCreateMutable();
SkRegion::Iterator iter(m_canvas->getTotalClip());
for (; !iter.done(); iter.next()) {
IntRect rect = iter.rect();
CGPathAddRect(clipPath, 0, rect);
}
CGContextAddPath(m_cgContext, clipPath);
CGContextClip(m_cgContext);
CGPathRelease(clipPath);
// Apply content matrix.
const SkMatrix& skMatrix = m_canvas->getTotalMatrix();
CGAffineTransform affine = SkMatrixToCGAffineTransform(skMatrix);
CGContextConcatCTM(m_cgContext, affine);
return m_cgContext;
}
bool GiCanvasIos::drawCachedBitmap(float x, float y, bool secondBmp)
{
int index = secondBmp ? 1 : 0;
CGImageRef image = m_draw->_cacheserr[index] ? NULL : m_draw->_caches[index];
CGContextRef context = m_draw->getContext();
bool ret = false;
if (context && image) {
CGRect rect = CGRectMake(x, y, m_draw->width(), m_draw->height());
CGAffineTransform af = CGAffineTransformMake(1, 0, 0, -1, 0, m_draw->height());
CGContextConcatCTM(context, af); // 图像是朝上的，上下文坐标系朝下，上下颠倒显示
CGInterpolationQuality oldQuality = CGContextGetInterpolationQuality(context);
CGContextSetInterpolationQuality(context, kCGInterpolationNone);
CGContextDrawImage(context, rect, image);
CGContextSetInterpolationQuality(context, oldQuality);
CGContextConcatCTM(context, CGAffineTransformInvert(af)); // 恢复成坐标系朝下
ret = true;
}
return ret;
}
CGImageRef CreatePDFPageImage(CGPDFPageRef page, CGFloat scale, bool transparentBackground)
{
CGSize pageSize = PDFPageGetSize(page, kCGPDFCropBox);
size_t width = scale * floorf(pageSize.width);
size_t height = scale * floorf(pageSize.height);
size_t bytesPerLine = width * 4;
uint64_t size = (uint64_t)height * (uint64_t)bytesPerLine;
if ((size == 0) || (size > SIZE_MAX))
return NULL;
void *bitmapData = malloc(size);
if (!bitmapData)
return NULL;
#if TARGET_OS_IPHONE
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
#else
CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(&kCGColorSpaceSRGB ? kCGColorSpaceSRGB : kCGColorSpaceGenericRGB);
#endif
CGContextRef context = CGBitmapContextCreate(bitmapData, width, height, 8, bytesPerLine, colorSpace, kCGImageAlphaPremultipliedFirst);
if (transparentBackground)
{
CGContextClearRect(context, CGRectMake(0, 0, width, height));
}
else
{
CGContextSetRGBFillColor(context, 1, 1, 1, 1); // white
CGContextFillRect(context, CGRectMake(0, 0, width, height));
}
// CGPDFPageGetDrawingTransform unfortunately does not upscale, see http://lists.apple.com/archives/quartz-dev/2005/Mar/msg00112.html
CGAffineTransform drawingTransform = PDFPageGetDrawingTransform(page, kCGPDFCropBox, scale);
CGContextConcatCTM(context, drawingTransform);
CGContextDrawPDFPage(context, page);
CGImageRef pdfImage = CGBitmapContextCreateImage(context);
CGContextRelease(context);
CGColorSpaceRelease(colorSpace);
free(bitmapData);
return pdfImage;
}
DRAW_TEST_F(CGImageDrawing, DrawAnImage, UIKitMimicTest<>) {
// Load an Image and draw it into the canvas context
auto drawingConfig = DrawingTestConfig::Get();
woc::unique_cf<CFStringRef> testFilename{ _CFStringCreateWithStdString(drawingConfig->GetResourcePath("jpg1.jpg")) };
woc::unique_cf<CGImageRef> image{ _CGImageCreateFromJPEGFile(testFilename.get()) };
ASSERT_NE(image, nullptr);
CGContextRef context = GetDrawingContext();
CGRect bounds = GetDrawingBounds();
CGAffineTransform flip = CGAffineTransformMakeScale(1, -1);
CGAffineTransform shift = CGAffineTransformTranslate(flip, 0, bounds.size.height * -1);
CGContextConcatCTM(context, shift);
CGContextDrawImage(context, bounds, image.get());
}
//-----------------------------------------------------------------------------
void CGDrawContext::fillLinearGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& startPoint, const CPoint& endPoint, bool evenOdd, CGraphicsTransform* t)
{
QuartzGraphicsPath* path = dynamic_cast<QuartzGraphicsPath*> (_path);
if (path == 0)
return;
const QuartzGradient* cgGradient = dynamic_cast<const QuartzGradient*> (&gradient);
if (cgGradient == 0)
return;
CGContextRef context = beginCGContext (true, getDrawMode ().integralMode ());
if (context)
{
CGPoint start = CGPointFromCPoint (startPoint);
CGPoint end = CGPointFromCPoint (endPoint);
if (getDrawMode ().integralMode ())
{
path->pixelAlign (this, t);
applyLineWidthCTM (context);
CGContextAddPath (context, path->getCGPathRef ());
start = pixelAlligned (start);
end = pixelAlligned (end);
}
else if (t)
{
CGContextSaveGState (context);
CGAffineTransform transform = QuartzGraphicsPath::createCGAffineTransform (*t);
CGContextConcatCTM (context, transform);
CGContextAddPath (context, path->getCGPathRef ());
CGContextRestoreGState (context);
}
else
CGContextAddPath (context, path->getCGPathRef ());
if (evenOdd)
CGContextEOClip (context);
else
CGContextClip (context);
CGContextDrawLinearGradient (context, *cgGradient, start, end, kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
releaseCGContext (context);
}
}
FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData* pathData,
const CFX_AffineMatrix* matrix,
const CFX_GraphStateData* graphState )
{
SaveState();
CGAffineTransform m = CGAffineTransformIdentity;
if (matrix) {
m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(), matrix->GetD(), matrix->GetE(), matrix->GetF());
}
m = CGAffineTransformConcat(m, _foxitDevice2User);
CGContextConcatCTM(_context, m);
FX_FLOAT lineWidth = getLineWidth(graphState, m);
setStrokeInfo(graphState, 0xFF000000, lineWidth);
setPathToContext(pathData);
CGContextReplacePathWithStrokedPath(_context);
RestoreState(FALSE);
CGContextClip(_context);
return TRUE;
}
//-----------------------------------------------------------------------------
void CGDrawContext::drawCGImageRef (CGContextRef context, CGImageRef image, CGLayerRef layer, double bitmapScaleFactor, const CRect& inRect, const CPoint& inOffset, float alpha, CBitmap* bitmap)
{
CRect rect (inRect);
CPoint offset (inOffset);
CGContextSetAlpha (context, (CGFloat)alpha*currentState.globalAlpha);
CGRect dest;
dest.origin.x = static_cast<CGFloat> (rect.left - offset.x);
dest.origin.y = static_cast<CGFloat> (-(rect.top) - (bitmap->getHeight () - offset.y));
dest.size.width = static_cast<CGFloat> (bitmap->getWidth ());
dest.size.height = static_cast<CGFloat> (bitmap->getHeight ());
CGRect clipRect;
clipRect.origin.x = static_cast<CGFloat> (rect.left);
clipRect.origin.y = static_cast<CGFloat> (-(rect.top) - rect.getHeight ());
clipRect.size.width = static_cast<CGFloat> (rect.getWidth ());
clipRect.size.height = static_cast<CGFloat> (rect.getHeight ());
if (bitmapScaleFactor != 1.)
{
CGContextConcatCTM (context, CGAffineTransformMakeScale (static_cast<CGFloat> (1./bitmapScaleFactor), static_cast<CGFloat> (1./bitmapScaleFactor)));
CGAffineTransform transform = CGAffineTransformMakeScale (static_cast<CGFloat> (bitmapScaleFactor), static_cast<CGFloat> (bitmapScaleFactor));
clipRect.origin = CGPointApplyAffineTransform (clipRect.origin, transform);
clipRect.size = CGSizeApplyAffineTransform (clipRect.size, transform);
dest.origin = CGPointApplyAffineTransform (dest.origin, transform);
dest.size = CGSizeApplyAffineTransform (dest.size, transform);
}
dest = pixelAlligned (dest);
clipRect = pixelAlligned (clipRect);
CGContextClipToRect (context, clipRect);
if (layer)
{
CGContextDrawLayerInRect (context, dest, layer);
}
else
{
CGContextDrawImage (context, dest, image);
}
}
