void GraphicsContext::drawFocusRing(const Color& color)
{
if (paintingDisabled())
return;
float radius = (focusRingWidth() - 1) / 2.0f;
int offset = radius + focusRingOffset();
CGColorRef colorRef = color.isValid() ? cgColor(color) : 0;
CGMutablePathRef focusRingPath = CGPathCreateMutable();
const Vector<IntRect>& rects = focusRingRects();
unsigned rectCount = rects.size();
for (unsigned i = 0; i < rectCount; i++)
CGPathAddRect(focusRingPath, 0, CGRectInset(rects[i], -offset, -offset));
CGContextRef context = platformContext();
CGContextSaveGState(context);
CGContextBeginPath(context);
CGContextAddPath(context, focusRingPath);
wkDrawFocusRing(context, colorRef, radius);
CGColorRelease(colorRef);
CGPathRelease(focusRingPath);
CGContextRestoreGState(context);
}
void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color, float alpha)
{
state().m_shadowOffset = FloatSize(width, height);
state().m_shadowBlur = blur;
state().m_shadowColor = color;
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
RGBA32 rgba = CSSParser::parseColor(color);
const CGFloat components[4] = {
((rgba >> 16) & 0xFF) / 255.0f,
((rgba >> 8) & 0xFF) / 255.0f,
(rgba & 0xFF) / 255.0f,
alpha
};
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGColorRef shadowColor = CGColorCreate(colorSpace, components);
CGColorSpaceRelease(colorSpace);
CGContextSetShadowWithColor(c->platformContext(), CGSizeMake(width, height), blur, shadowColor);
CGColorRelease(shadowColor);
#endif
}
OSStatus
TextViewSetBGAlpha( HIViewRef textView, float alpha )
{
OSStatus status = paramErr;
SInt32 unused;
CGColorRef prevColor = NULL;
CGColorRef newColor = NULL;
status = HITextViewCopyBackgroundColor( textView, &prevColor );
require_noerr( status, FAIL );
// make a new copy with alpha
newColor = CGColorCreateCopyWithAlpha( prevColor, alpha );
require_action( newColor != NULL, FAIL, status = paramErr );
// reset the new color with alpha
status = HITextViewSetBackgroundColor( textView, newColor );
if( newColor != NULL )
CGColorRelease( newColor );
FAIL:
return status;
}
void drawTextWithFeature(CGContextRef context, CTFontDescriptorRef fontDescriptor, CFStringRef feature, int value, CGPoint location)
{
CGFloat fontSize = 25;
CGContextSetTextMatrix(context, CGAffineTransformScale(CGAffineTransformIdentity, 1, 1));
CGContextSetTextPosition(context, location.x, location.y);
CFNumberRef featureValue = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &value);
CFTypeRef featureDictionaryKeys[] = { kCTFontOpenTypeFeatureTag, kCTFontOpenTypeFeatureValue };
CFTypeRef featureDictionaryValues[] = { feature, featureValue };
CFDictionaryRef featureDictionary = CFDictionaryCreate(kCFAllocatorDefault, featureDictionaryKeys, featureDictionaryValues, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(featureValue);
CFTypeRef featureSettingsValues[] = { featureDictionary };
CFArrayRef fontFeatureSettings = CFArrayCreate(kCFAllocatorDefault, featureSettingsValues, 1, &kCFTypeArrayCallBacks);
CFRelease(featureDictionary);
CFTypeRef fontDescriptorKeys[] = { kCTFontFeatureSettingsAttribute };
CFTypeRef fontDescriptorValues[] = { fontFeatureSettings };
CFDictionaryRef fontDescriptorAttributes = CFDictionaryCreate(kCFAllocatorDefault, fontDescriptorKeys, fontDescriptorValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFRelease(fontFeatureSettings);
CTFontDescriptorRef modifiedFontDescriptor = CTFontDescriptorCreateCopyWithAttributes(fontDescriptor, fontDescriptorAttributes);
CFRelease(fontDescriptorAttributes);
CTFontRef font = CTFontCreateWithFontDescriptor(modifiedFontDescriptor, fontSize, nullptr);
CFRelease(modifiedFontDescriptor);
CFMutableStringRef string = CFStringCreateMutable(kCFAllocatorDefault, 0);
CFStringAppend(string, feature);
CFStringAppend(string, value ? CFSTR(" (on)") : CFSTR(" (off)"));
CFStringAppend(string, CFSTR(": ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
CGColorRef red = CGColorCreateGenericRGB(1, 0, 0, 1);
CFTypeRef lineKeys[] = { kCTForegroundColorAttributeName };
CFTypeRef lineValues[] = { red };
CFDictionaryRef lineAttributes = CFDictionaryCreate(kCFAllocatorDefault, lineKeys, lineValues, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CGColorRelease(red);
CFAttributedStringRef attributedString = CFAttributedStringCreate(kCFAllocatorDefault, string, lineAttributes);
CFRelease(lineAttributes);
CFRelease(string);
CFMutableAttributedStringRef mutableAttributedString = CFAttributedStringCreateMutableCopy(kCFAllocatorDefault, 0, attributedString);
CFRelease(attributedString);
CTFontRef monospaceFont = CTFontCreateWithName(CFSTR("Courier"), fontSize, nullptr);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(0, 12), kCTFontAttributeName, monospaceFont);
CFRelease(monospaceFont);
CFAttributedStringSetAttribute(mutableAttributedString, CFRangeMake(12, 52), kCTFontAttributeName, font);
CFRelease(font);
CTLineRef line = CTLineCreateWithAttributedString(mutableAttributedString);
CFRelease(mutableAttributedString);
CTLineDraw(line, context);
CFRelease(line);
}
void WKCACFLayerRenderer::createRenderer()
{
if (m_triedToCreateD3DRenderer)
return;
m_triedToCreateD3DRenderer = true;
D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
if (!d3d() || !::IsWindow(m_hostWindow))
return;
// D3D doesn't like to make back buffers for 0 size windows. We skirt this problem if we make the
// passed backbuffer width and height non-zero. The window will necessarily get set to a non-zero
// size eventually, and then the backbuffer size will get reset.
RECT rect;
GetClientRect(m_hostWindow, &rect);
if (rect.left-rect.right == 0 || rect.bottom-rect.top == 0) {
parameters.BackBufferWidth = 1;
parameters.BackBufferHeight = 1;
}
if (FAILED(d3d()->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hostWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE, ¶meters, &m_d3dDevice)))
return;
D3DXMATRIXA16 projection;
D3DXMatrixOrthoOffCenterRH(&projection, rect.left, rect.right, rect.top, rect.bottom, -1.0f, 1.0f);
m_d3dDevice->SetTransform(D3DTS_PROJECTION, &projection);
m_context.adoptCF(CACFContextCreate(0));
windowsForContexts().set(m_context.get(), this);
m_renderContext = static_cast<CARenderContext*>(CACFContextGetRenderContext(m_context.get()));
m_renderer = CARenderOGLNew(wkqcCARenderOGLCallbacks(wkqckCARenderDX9Callbacks), m_d3dDevice.get(), 0);
// Create the root hierarchy
m_rootLayer = WKCACFLayer::create(WKCACFLayer::Layer);
m_rootLayer->setName("WKCACFLayerRenderer rootLayer");
m_scrollLayer = WKCACFLayer::create(WKCACFLayer::Layer);
m_scrollLayer->setName("WKCACFLayerRenderer scrollLayer");
m_rootLayer->addSublayer(m_scrollLayer);
m_scrollLayer->setMasksToBounds(true);
m_scrollLayer->setAnchorPoint(CGPointMake(0, 1));
#ifndef NDEBUG
CGColorRef debugColor = createCGColor(Color(255, 0, 0, 204));
m_rootLayer->setBackgroundColor(debugColor);
CGColorRelease(debugColor);
#endif
if (IsWindow(m_hostWindow))
m_rootLayer->setFrame(bounds());
if (m_context)
m_rootLayer->becomeRootLayerForContext(m_context.get());
}
void CGContextSetShadowWithColor_wrap2(CGContext *con, float x, float y, float blur,
float r, float g, float b, float a) {
float comps[] = {r, g, b, a};
CGColorSpaceRef cs = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
CGColorRef c = CGColorCreate( cs, comps );
CGContextSetShadowWithColor(con, CGSizeMake(x, y), blur, c);
CGColorRelease(c);
CGColorSpaceRelease(cs);
}
//---------------------------------------------------------------------
// Sets the alpha of an HITextView to the specified value
//
OSStatus TextViewSetAlpha(HIViewRef textView, float alpha)
{
CGColorRef prevColor, newColor;
OSStatus status;
status = HITextViewCopyBackgroundColor(textView, &prevColor);
require_noerr( status, CantGetBackgroundColor );
newColor = CGColorCreateCopyWithAlpha(prevColor, alpha);
require( (newColor != NULL), CantCreateNewColor );
status = HITextViewSetBackgroundColor(textView, newColor);
check_noerr( status );
CGColorRelease(newColor);
CantCreateNewColor:
CGColorRelease(prevColor);
CantGetBackgroundColor:
return status;
}
WKCACFLayerRenderer::WKCACFLayerRenderer(WKCACFLayerRendererClient* client)
: m_client(client)
, m_mightBeAbleToCreateDeviceLater(true)
, m_rootLayer(WKCACFRootLayer::create(this))
, m_scrollLayer(WKCACFLayer::create(WKCACFLayer::Layer))
, m_clipLayer(WKCACFLayer::create(WKCACFLayer::Layer))
, m_context(AdoptCF, CACFContextCreate(0))
, m_renderContext(static_cast<CARenderContext*>(CACFContextGetRenderContext(m_context.get())))
, m_renderer(0)
, m_hostWindow(0)
, m_renderTimer(this, &WKCACFLayerRenderer::renderTimerFired)
, m_scrollPosition(0, 0)
, m_scrollSize(1, 1)
, m_backingStoreDirty(false)
, m_mustResetLostDeviceBeforeRendering(false)
{
windowsForContexts().set(m_context.get(), this);
// Under the root layer, we have a clipping layer to clip the content,
// that contains a scroll layer that we use for scrolling the content.
// The root layer is the size of the client area of the window.
// The clipping layer is the size of the WebView client area (window less the scrollbars).
// The scroll layer is the size of the root child layer.
// Resizing the window will change the bounds of the rootLayer and the clip layer and will not
// cause any repositioning.
// Scrolling will affect only the position of the scroll layer without affecting the bounds.
m_rootLayer->setName("WKCACFLayerRenderer rootLayer");
m_clipLayer->setName("WKCACFLayerRenderer clipLayer");
m_scrollLayer->setName("WKCACFLayerRenderer scrollLayer");
m_rootLayer->addSublayer(m_clipLayer);
m_clipLayer->addSublayer(m_scrollLayer);
m_clipLayer->setMasksToBounds(true);
m_rootLayer->setAnchorPoint(CGPointMake(0, 0));
m_scrollLayer->setAnchorPoint(CGPointMake(0, 1));
m_clipLayer->setAnchorPoint(CGPointMake(0, 1));
#ifndef NDEBUG
CGColorRef debugColor = createCGColor(Color(255, 0, 0, 204));
m_rootLayer->setBackgroundColor(debugColor);
CGColorRelease(debugColor);
#endif
if (m_context)
m_rootLayer->becomeRootLayerForContext(m_context.get());
#ifndef NDEBUG
char* printTreeFlag = getenv("CA_PRINT_TREE");
m_printTree = printTreeFlag && atoi(printTreeFlag);
#endif
}
void QuartzWindow::close() {
if (!is_open())
return;
CGrafPtr gp = GetWindowPort(my_window());
if (gp != NULL) // already closed by std handler
QDEndCGContext( gp, &myContext );
CGColorRelease((CGColorRef) _red);
CGColorRelease((CGColorRef) _yellow);
CGColorRelease((CGColorRef) _black);
CGColorRelease((CGColorRef) _gray);
CGColorRelease((CGColorRef) _white);
CGColorSpaceRelease(_color_space);
WindowSet::rm_window(my_window());
if (gp != NULL)
DisposeWindow(my_window());
_is_open = false;
DisposeEventHandlerUPP(_my_event_handler_upp);
DisposeEventHandlerUPP(_my_spy_event_handler_upp);
_my_event_handler = NULL;
_my_spy_event_handler = NULL;
_quartz_win = NULL;
}
void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)
{
state().m_shadowOffset = FloatSize(width, height);
state().m_shadowBlur = blur;
state().m_shadowColor = "";
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
const CGFloat components[4] = { r, g, b, a };
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGColorRef shadowColor = CGColorCreate(colorSpace, components);
CGColorSpaceRelease(colorSpace);
CGContextSetShadowWithColor(c->platformContext(), adjustedShadowSize(width, -height), blur, shadowColor);
CGColorRelease(shadowColor);
#endif
}
void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
{
state().m_shadowOffset = FloatSize(width, height);
state().m_shadowBlur = blur;
state().m_shadowColor = "";
GraphicsContext* dc = drawingContext();
if (!dc)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
const CGFloat components[5] = { c, m, y, k, a };
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceCMYK();
CGColorRef shadowColor = CGColorCreate(colorSpace, components);
CGColorSpaceRelease(colorSpace);
CGContextSetShadowWithColor(dc->platformContext(), CGSizeMake(width, height), blur, shadowColor);
CGColorRelease(shadowColor);
#endif
}
void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)
{
state().m_shadowOffset = FloatSize(width, height);
state().m_shadowBlur = blur;
state().m_shadowColor = "";
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
const CGFloat components[2] = { grayLevel, alpha };
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
CGColorRef color = CGColorCreate(colorSpace, components);
CGColorSpaceRelease(colorSpace);
CGContextSetShadowWithColor(c->platformContext(), CGSizeMake(width, height), blur, color);
CGColorRelease(color);
#endif
}
WKCACFLayerRenderer::WKCACFLayerRenderer(WKCACFLayerRendererClient* client)
: m_client(client)
, m_mightBeAbleToCreateDeviceLater(true)
, m_rootLayer(PlatformCALayer::create(PlatformCALayer::LayerTypeRootLayer, 0))
, m_context(wkCACFContextCreate())
, m_hostWindow(0)
, m_renderTimer(this, &WKCACFLayerRenderer::renderTimerFired)
, m_backingStoreDirty(false)
, m_mustResetLostDeviceBeforeRendering(false)
, m_syncLayerChanges(false)
{
// Point the CACFContext to this
wkCACFContextSetUserData(m_context, this);
// Under the root layer, we have a clipping layer to clip the content,
// that contains a scroll layer that we use for scrolling the content.
// The root layer is the size of the client area of the window.
// The clipping layer is the size of the WebView client area (window less the scrollbars).
// The scroll layer is the size of the root child layer.
// Resizing the window will change the bounds of the rootLayer and the clip layer and will not
// cause any repositioning.
// Scrolling will affect only the position of the scroll layer without affecting the bounds.
m_rootLayer->setName("WKCACFLayerRenderer rootLayer");
m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
m_rootLayer->setGeometryFlipped(true);
#ifndef NDEBUG
CGColorRef debugColor = CGColorCreateGenericRGB(1, 0, 0, 0.8);
m_rootLayer->setBackgroundColor(debugColor);
CGColorRelease(debugColor);
#endif
if (m_context)
wkCACFContextSetLayer(m_context, m_rootLayer->platformLayer());
#ifndef NDEBUG
char* printTreeFlag = getenv("CA_PRINT_TREE");
m_printTree = printTreeFlag && atoi(printTreeFlag);
#endif
}
void GraphicsContext::setShadow(const IntSize& size, int blur, const Color& color)
{
// Extreme "blur" values can make text drawing crash or take crazy long times, so clamp
blur = min(blur, 1000);
if (paintingDisabled())
return;
// Check for an invalid color, as this means that the color was not set for the shadow
// and we should therefore just use the default shadow color.
CGContextRef context = platformContext();
if (!color.isValid())
CGContextSetShadow(context, CGSizeMake(size.width(), -size.height()), blur); // y is flipped.
else {
CGColorRef colorCG = cgColor(color);
CGContextSetShadowWithColor(context,
CGSizeMake(size.width(), -size.height()), // y is flipped.
blur,
colorCG);
CGColorRelease(colorCG);
}
}
void CanvasRenderingContext2D::applyShadow()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
RGBA32 rgba = state().m_shadowColor.isEmpty() ? 0 : CSSParser::parseColor(state().m_shadowColor);
const CGFloat components[4] = {
((rgba >> 16) & 0xFF) / 255.0f,
((rgba >> 8) & 0xFF) / 255.0f,
(rgba & 0xFF) / 255.0f,
((rgba >> 24) & 0xFF) / 255.0f
};
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGColorRef color = CGColorCreate(colorSpace, components);
CGColorSpaceRelease(colorSpace);
CGContextSetShadowWithColor(c->platformContext(), state().m_shadowOffset, state().m_shadowBlur, color);
CGColorRelease(color);
#endif
}
void CACFLayerTreeHost::initialize()
{
// Point the CACFContext to this
initializeContext(this, m_rootLayer.get());
// Under the root layer, we have a clipping layer to clip the content,
// that contains a scroll layer that we use for scrolling the content.
// The root layer is the size of the client area of the window.
// The clipping layer is the size of the WebView client area (window less the scrollbars).
// The scroll layer is the size of the root child layer.
// Resizing the window will change the bounds of the rootLayer and the clip layer and will not
// cause any repositioning.
// Scrolling will affect only the position of the scroll layer without affecting the bounds.
m_rootLayer->setName("CACFLayerTreeHost rootLayer");
m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
m_rootLayer->setGeometryFlipped(true);
#ifndef NDEBUG
CGColorRef debugColor = CGColorCreateGenericRGB(1, 0, 0, 0.8);
m_rootLayer->setBackgroundColor(debugColor);
CGColorRelease(debugColor);
#endif
}
bool FBVLC_Mac::onCoreGraphicsDraw(FB::CoreGraphicsDraw *evt, FB::PluginWindowMacCG*)
{
boost::lock_guard<boost::mutex> lock( m_frameGuard );
FB::Rect bounds(evt->bounds);
//FB::Rect clip(evt->clip);
short width = bounds.right - bounds.left, height = bounds.bottom - bounds.top;
CGContextRef cgContext(evt->context);
CGContextSaveGState(cgContext);
CGContextTranslateCTM(cgContext, 0.0, height);
CGContextScaleCTM(cgContext, 1.0, -1.0);
CGColorSpaceRef cSpace = CGColorSpaceCreateDeviceRGB();
CGContextSetFillColorSpace(cgContext, cSpace);
CGColorRef bgColor = CGColorCreate(cSpace, m_bgComponents);
CGContextSetFillColorWithColor(cgContext, bgColor);
if ( 0 != m_media_width && 0 != m_media_height ) {
CGRect imgRect = {
{ (width - m_media_width) / 2, (height - m_media_height) / 2 },
{ m_media_width, m_media_height }
};
const std::vector<char>& fb = vlc::vmem::frame_buf();
CGContextRef frameBmpCtx =
CGBitmapContextCreate( (void*)&fb[0], m_media_width, m_media_height, 8,
m_media_width * vlc::DEF_PIXEL_BYTES, cSpace,
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little );
CGImageRef frameImage = CGBitmapContextCreateImage( frameBmpCtx );
CGContextDrawImage( cgContext, imgRect, frameImage );
CGImageRelease( frameImage );
CGContextRelease( frameBmpCtx );
if( m_media_width < width ) {
CGRect bgLeft = {
{ 0, 0 },
{ imgRect.origin.x, height }
};
CGContextFillRect(cgContext, bgLeft);
CGRect bgRight = {
{ imgRect.origin.x + imgRect.size.width, 0 },
{ width - (imgRect.origin.x + imgRect.size.width), height }
};
CGContextFillRect(cgContext, bgRight);
} else if( m_media_height < height ){
CGRect bgTop = {
{ 0, 0 },
{ width, imgRect.origin.y }
};
CGContextFillRect(cgContext, bgTop);
CGRect bgBottom = {
{ 0, imgRect.origin.y + imgRect.size.height },
{ width, height - (imgRect.origin.y + imgRect.size.height) }
};
CGContextFillRect(cgContext, bgBottom);
}
} else {
CGRect cgBounds = {
{ 0, 0 },
{ width, height }
};
CGContextFillRect(cgContext, cgBounds);
}
CGColorRelease(bgColor);
CGColorSpaceRelease(cSpace);
CGContextRestoreGState(cgContext);
return true; // This is handled
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const TransformationMatrix& patternTransform,
const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect)
{
if (!nativeImageForCurrentFrame())
return;
ASSERT(patternTransform.isInvertible());
if (!patternTransform.isInvertible())
// Avoid a hang under CGContextDrawTiledImage on release builds.
return;
CGContextRef context = ctxt->platformContext();
ctxt->save();
CGContextClipToRect(context, destRect);
ctxt->setCompositeOperation(op);
CGContextTranslateCTM(context, destRect.x(), destRect.y() + destRect.height());
CGContextScaleCTM(context, 1, -1);
// Compute the scaled tile size.
float scaledTileHeight = tileRect.height() * narrowPrecisionToFloat(patternTransform.d());
// We have to adjust the phase to deal with the fact we're in Cartesian space now (with the bottom left corner of destRect being
// the origin).
float adjustedX = phase.x() - destRect.x() + tileRect.x() * narrowPrecisionToFloat(patternTransform.a()); // We translated the context so that destRect.x() is the origin, so subtract it out.
float adjustedY = destRect.height() - (phase.y() - destRect.y() + tileRect.y() * narrowPrecisionToFloat(patternTransform.d()) + scaledTileHeight);
CGImageRef tileImage = nativeImageForCurrentFrame();
float h = CGImageGetHeight(tileImage);
CGImageRef subImage;
if (tileRect.size() == size())
subImage = tileImage;
else {
// Copying a sub-image out of a partially-decoded image stops the decoding of the original image. It should never happen
// because sub-images are only used for border-image, which only renders when the image is fully decoded.
ASSERT(h == height());
subImage = CGImageCreateWithImageInRect(tileImage, tileRect);
}
#ifndef BUILDING_ON_TIGER
// Leopard has an optimized call for the tiling of image patterns, but we can only use it if the image has been decoded enough that
// its buffer is the same size as the overall image. Because a partially decoded CGImageRef with a smaller width or height than the
// overall image buffer needs to tile with "gaps", we can't use the optimized tiling call in that case.
// FIXME: Could create WebKitSystemInterface SPI for CGCreatePatternWithImage2 and probably make Tiger tile faster as well.
// FIXME: We cannot use CGContextDrawTiledImage with scaled tiles on Leopard, because it suffers from rounding errors. Snow Leopard is ok.
float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());
float w = CGImageGetWidth(tileImage);
#ifdef BUILDING_ON_LEOPARD
if (w == size().width() && h == size().height() && scaledTileWidth == tileRect.width() && scaledTileHeight == tileRect.height())
#else
if (w == size().width() && h == size().height())
#endif
CGContextDrawTiledImage(context, FloatRect(adjustedX, adjustedY, scaledTileWidth, scaledTileHeight), subImage);
else {
#endif
// On Leopard, this code now only runs for partially decoded images whose buffers do not yet match the overall size of the image.
// On Tiger this code runs all the time. This code is suboptimal because the pattern does not reference the image directly, and the
// pattern is destroyed before exiting the function. This means any decoding the pattern does doesn't end up cached anywhere, so we
// redecode every time we paint.
static const CGPatternCallbacks patternCallbacks = { 0, drawPatternCallback, NULL };
CGAffineTransform matrix = CGAffineTransformMake(narrowPrecisionToCGFloat(patternTransform.a()), 0, 0, narrowPrecisionToCGFloat(patternTransform.d()), adjustedX, adjustedY);
matrix = CGAffineTransformConcat(matrix, CGContextGetCTM(context));
// The top of a partially-decoded image is drawn at the bottom of the tile. Map it to the top.
matrix = CGAffineTransformTranslate(matrix, 0, size().height() - h);
CGPatternRef pattern = CGPatternCreate(subImage, CGRectMake(0, 0, tileRect.width(), tileRect.height()),
matrix, tileRect.width(), tileRect.height(),
kCGPatternTilingConstantSpacing, true, &patternCallbacks);
if (pattern == NULL) {
if (subImage != tileImage)
CGImageRelease(subImage);
ctxt->restore();
return;
}
CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(NULL);
CGFloat alpha = 1;
CGColorRef color = CGColorCreateWithPattern(patternSpace, pattern, &alpha);
CGContextSetFillColorSpace(context, patternSpace);
CGColorSpaceRelease(patternSpace);
CGPatternRelease(pattern);
// FIXME: Really want a public API for this. It is just CGContextSetBaseCTM(context, CGAffineTransformIdentiy).
wkSetPatternBaseCTM(context, CGAffineTransformIdentity);
CGContextSetPatternPhase(context, CGSizeZero);
CGContextSetFillColorWithColor(context, color);
CGContextFillRect(context, CGContextGetClipBoundingBox(context));
CGColorRelease(color);
#ifndef BUILDING_ON_TIGER
}
#endif
if (subImage != tileImage)
CGImageRelease(subImage);
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void draw__delete_color(draw__Color color) {
CGColorRelease(color);
}
static void setLayerBackgroundColor(WKCACFLayer* layer, const Color& color)
{
CGColorRef bgColor = createCGColor(color);
layer->setBackgroundColor(bgColor);
CGColorRelease(bgColor);
}
static void setLayerBorderColor(WKCACFLayer* layer, const Color& color)
{
CGColorRef borderColor = createCGColor(color);
layer->setBorderColor(borderColor);
CGColorRelease(borderColor);
}
