void SVGPaintServer::clipToFillPath(CGContextRef context, const RenderPath* path) const
{
if (path->style()->svgStyle()->fillRule() == RULE_EVENODD)
CGContextEOClip(context);
else
CGContextClip(context);
}
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 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::clip(const Path& path)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextBeginPath(context);
CGContextAddPath(context, path.platformPath());
CGContextClip(context);
m_data->clip(path);
}
void MacDock::overlay(const QString& text)
{
if (text.isEmpty()) {
overlayed = false;
RestoreApplicationDockTileImage();
return;
}
// Create the context
CGContextRef context = BeginCGContextForApplicationDockTile();
if (!overlayed) {
overlayed = true;
// Add some subtle drop down shadow
// FIXME: Disabled because 10.2 doesn't support it
//CGSize s = { 2.0, -4.0 };
//CGContextSetShadow(context,s,5.0);
}
// Draw a circle
CGContextBeginPath(context);
CGContextAddArc(context, 95.0, 95.0, 25.0, 0.0, 2 * M_PI, true);
CGContextClosePath(context);
CGContextSetRGBFillColor(context, 1, 0.0, 0.0, 1);
CGContextFillPath(context);
// Set the clipping path to the same circle
CGContextBeginPath(context);
CGContextAddArc(context, 95.0, 95.0, 25.0, 0.0, 2 * M_PI, true);
CGContextClip(context);
// Remove drop shadow
// FIXME: Disabled because 10.2 doesn't support it
//CGSize s = { 0.0, -0.0 };
//CGContextSetShadowWithColor(context, s, 0, NULL);
// Select the appropriate font
CGContextSelectFont(context,DOCK_FONT_NAME, DOCK_FONT_SIZE, kCGEncodingMacRoman);
CGContextSetRGBFillColor(context, 1, 1, 1, 1);
// Draw the text invisible
CGPoint begin = CGContextGetTextPosition(context);
CGContextSetTextDrawingMode(context, kCGTextInvisible);
CGContextShowTextAtPoint(context, begin.x, begin.y, text.toStdString().c_str(), text.length());
CGPoint end = CGContextGetTextPosition(context);
// Draw the text
CGContextSetTextDrawingMode(context, kCGTextFill);
CGContextShowTextAtPoint(context, 95 - (end.x - begin.x)/2, 95 - 8, text.toStdString().c_str(), text.length());
// Cleanup
CGContextFlush(context);
EndCGContextForApplicationDockTile(context);
}
void CanvasRenderingContext2D::fill()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
CGContextBeginPath(c->platformContext());
CGContextAddPath(c->platformContext(), state().m_path.platformPath());
if (!state().m_path.isEmpty())
willDraw(CGContextGetPathBoundingBox(c->platformContext()));
if (state().m_fillStyle->gradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_fillStyle->gradient()->platformShading());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillPath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = state().m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
willDraw(path->controlPointRect());
if (state().m_fillStyle->gradient()) {
p->fillPath(*path, QBrush(*(state().m_fillStyle->gradient()->platformShading())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillPath(*path, p->brush());
}
#elif PLATFORM(CAIRO)
cairo_t* pathCr = state().m_path.platformPath()->m_cr;
cairo_t* cr = c->platformContext();
cairo_save(cr);
willDraw(state().m_path.boundingRect());
if (state().m_fillStyle->gradient()) {
cairo_set_source(cr, state().m_fillStyle->gradient()->platformShading());
c->addPath(state().m_path);
cairo_fill(cr);
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
c->addPath(state().m_path);
cairo_fill(cr);
}
cairo_restore(cr);
#endif
clearPathForDashboardBackwardCompatibilityMode();
}
void CanvasRenderingContext2D::fill()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
c->beginPath();
c->addPath(m_path);
if (!m_path.isEmpty())
willDraw(m_path.boundingRect());
#if PLATFORM(CG)
if (state().m_fillStyle->canvasGradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_fillStyle->canvasGradient()->gradient().platformGradient());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillPath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_fillStyle->canvasGradient()) {
p->fillPath(*path, QBrush(*(state().m_fillStyle->canvasGradient()->gradient().platformGradient())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillPath(*path, p->brush());
}
#elif PLATFORM(CAIRO) && !PLATFORM(BAL)
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_fillStyle->canvasGradient()) {
cairo_set_source(cr, state().m_fillStyle->canvasGradient()->gradient().platformGradient());
cairo_fill(cr);
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
cairo_fill(cr);
}
cairo_restore(cr);
#elif PLATFORM(BAL)
//FIXME
notImplemented();
#endif
#if ENABLE(DASHBOARD_SUPPORT)
clearPathForDashboardBackwardCompatibilityMode();
#endif
}
void GraphicsContext::addRoundedRectClip(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
const IntSize& bottomLeft, const IntSize& bottomRight)
{
if (paintingDisabled())
return;
// Need sufficient width and height to contain these curves. Sanity check our
// corner radii and our width/height values to make sure the curves can all fit.
if (static_cast<unsigned>(rect.width()) < static_cast<unsigned>(topLeft.width()) + static_cast<unsigned>(topRight.width()) ||
static_cast<unsigned>(rect.width()) < static_cast<unsigned>(bottomLeft.width()) + static_cast<unsigned>(bottomRight.width()) ||
static_cast<unsigned>(rect.height()) < static_cast<unsigned>(topLeft.height()) + static_cast<unsigned>(bottomLeft.height()) ||
static_cast<unsigned>(rect.height()) < static_cast<unsigned>(topRight.height()) + static_cast<unsigned>(bottomRight.height()))
return;
// Clip to our rect.
clip(rect);
// OK, the curves can fit.
CGContextRef context = platformContext();
// Add the four ellipses to the path. Technically this really isn't good enough, since we could end up
// not clipping the other 3/4 of the ellipse we don't care about. We're relying on the fact that for
// normal use cases these ellipses won't overlap one another (or when they do the curvature of one will
// be subsumed by the other).
CGContextAddEllipseInRect(context, CGRectMake(rect.x(), rect.y(), topLeft.width() * 2, topLeft.height() * 2));
CGContextAddEllipseInRect(context, CGRectMake(rect.right() - topRight.width() * 2, rect.y(),
topRight.width() * 2, topRight.height() * 2));
CGContextAddEllipseInRect(context, CGRectMake(rect.x(), rect.bottom() - bottomLeft.height() * 2,
bottomLeft.width() * 2, bottomLeft.height() * 2));
CGContextAddEllipseInRect(context, CGRectMake(rect.right() - bottomRight.width() * 2,
rect.bottom() - bottomRight.height() * 2,
bottomRight.width() * 2, bottomRight.height() * 2));
// Now add five rects (one for each edge rect in between the rounded corners and one for the interior).
CGContextAddRect(context, CGRectMake(rect.x() + topLeft.width(), rect.y(),
rect.width() - topLeft.width() - topRight.width(),
max(topLeft.height(), topRight.height())));
CGContextAddRect(context, CGRectMake(rect.x() + bottomLeft.width(),
rect.bottom() - max(bottomLeft.height(), bottomRight.height()),
rect.width() - bottomLeft.width() - bottomRight.width(),
max(bottomLeft.height(), bottomRight.height())));
CGContextAddRect(context, CGRectMake(rect.x(), rect.y() + topLeft.height(),
max(topLeft.width(), bottomLeft.width()), rect.height() - topLeft.height() - bottomLeft.height()));
CGContextAddRect(context, CGRectMake(rect.right() - max(topRight.width(), bottomRight.width()),
rect.y() + topRight.height(),
max(topRight.width(), bottomRight.width()), rect.height() - topRight.height() - bottomRight.height()));
CGContextAddRect(context, CGRectMake(rect.x() + max(topLeft.width(), bottomLeft.width()),
rect.y() + max(topLeft.height(), topRight.height()),
rect.width() - max(topLeft.width(), bottomLeft.width()) - max(topRight.width(), bottomRight.width()),
rect.height() - max(topLeft.height(), topRight.height()) - max(bottomLeft.height(), bottomRight.height())));
CGContextClip(context);
}
void CanvasRenderingContext2D::stroke()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
CGContextBeginPath(c->platformContext());
CGContextAddPath(c->platformContext(), state().m_path.platformPath());
if (!state().m_path.isEmpty()) {
float lineWidth = state().m_lineWidth;
float inset = -lineWidth / 2;
CGRect boundingRect = CGRectInset(CGContextGetPathBoundingBox(c->platformContext()), inset, inset);
willDraw(boundingRect);
}
if (state().m_strokeStyle->gradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextReplacePathWithStrokedPath(c->platformContext());
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_strokeStyle->gradient()->platformShading());
c->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
CGContextStrokePath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = state().m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
willDraw(path->controlPointRect());
if (state().m_strokeStyle->gradient()) {
p->save();
p->setBrush(*(state().m_strokeStyle->gradient()->platformShading()));
p->strokePath(*path, p->pen());
p->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
p->strokePath(*path, p->pen());
}
#endif
clearPathForDashboardBackwardCompatibilityMode();
}
void GraphicsContext::clip(const Path& path)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
// CGContextClip does nothing if the path is empty, so in this case, we
// instead clip against a zero rect to reduce the clipping region to
// nothing - which is the intended behavior of clip() if the path is empty.
if (path.isEmpty())
CGContextClipToRect(context, CGRectZero);
else {
CGContextBeginPath(context);
CGContextAddPath(context, path.platformPath());
CGContextClip(context);
}
m_data->clip(path);
}
void GraphicsContext::clipPath(const Path& path, WindRule clipRule)
{
if (paintingDisabled())
return;
if (path.isEmpty())
return;
CGContextRef context = platformContext();
CGContextBeginPath(platformContext());
CGContextAddPath(platformContext(), path.platformPath());
if (clipRule == RULE_EVENODD)
CGContextEOClip(context);
else
CGContextClip(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 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 QMacWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
Q_UNUSED(offset);
// Get a context for the widget.
#ifndef QT_MAC_USE_COCOA
CGContextRef context;
CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
QDBeginCGContext(port, &context);
#else
extern CGContextRef qt_mac_graphicsContextFor(QWidget *);
CGContextRef context = qt_mac_graphicsContextFor(widget);
#endif
CGContextRetain(context);
CGContextSaveGState(context);
// Flip context.
CGContextTranslateCTM(context, 0, widget->height());
CGContextScaleCTM(context, 1, -1);
// Clip to region.
const QVector<QRect> &rects = rgn.rects();
for (int i = 0; i < rects.size(); ++i) {
const QRect &rect = rects.at(i);
CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
}
CGContextClip(context);
// Draw the image onto the window.
const CGRect dest = CGRectMake(0, 0, widget->width(), widget->height());
const CGImageRef image = d_ptr->device.toMacCGImageRef();
qt_mac_drawCGImage(context, &dest, image);
CFRelease(image);
// Restore context.
CGContextRestoreGState(context);
#ifndef QT_MAC_USE_COCOA
QDEndCGContext(port, &context);
#else
CGContextFlush(context);
#endif
CGContextRelease(context);
}
FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData* pathData,
const CFX_AffineMatrix* matrix,
int fillMode )
{
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);
setPathToContext(pathData);
RestoreState(FALSE);
if ((fillMode & 3) == FXFILL_WINDING) {
CGContextClip(_context);
} else {
CGContextEOClip(_context);
}
return TRUE;
}
void TIPGradientAxialFillPath( CGContextRef theContext, TIPGradientRef theGradient, CGPathRef thePath, float angle)
{
CGRect boundingRect = CGPathGetBoundingBox(thePath);
CGPoint startPoint;
CGPoint endPoint;
TIPGradientFindEndpointsForRotation(boundingRect,angle,&startPoint,&endPoint);
// CoreGraphics Calls
CGContextSaveGState(theContext);
CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
CGShadingRef myCGShading = CGShadingCreateAxial(colorSpace,startPoint,endPoint,theGradient->gradientFunction,FALSE,FALSE);
CGContextAddPath(theContext,thePath);
CGContextClip(theContext);
CGContextDrawShading(theContext,myCGShading);
CGShadingRelease(myCGShading);
CGColorSpaceRelease(colorSpace);
CGContextRestoreGState(theContext);
}
//-----------------------------------------------------------------------------
void CGDrawContext::fillRadialGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& center, CCoord radius, const CPoint& originOffset, 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)
{
if (getDrawMode ().integralMode ())
{
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 ());
if (evenOdd)
CGContextEOClip (context);
else
CGContextClip (context);
CPoint startCenter = center + originOffset;
CGContextDrawRadialGradient (context, *cgGradient, CGPointFromCPoint (startCenter), 0, CGPointFromCPoint (center), static_cast<CGFloat> (radius), kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
releaseCGContext (context);
}
}
void GraphicsContext::clipPath(const Path& path, WindRule clipRule)
{
if (paintingDisabled())
return;
// FIXME: Why does this method ignore empty paths?
if (path.isEmpty())
return;
wxGraphicsContext* gc = m_data->context->GetGraphicsContext();
#if wxUSE_CAIRO
cairo_t* cr = (cairo_t*)gc->GetNativeContext();
cairo_path_t* nativePath = (cairo_path_t*)path.platformPath()->GetNativePath();
cairo_new_path(cr);
cairo_append_path(cr, nativePath);
cairo_set_fill_rule(cr, clipRule == RULE_EVENODD ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);
cairo_clip(cr);
#elif __WXMAC__
CGContextRef context = (CGContextRef)gc->GetNativeContext();
CGPathRef nativePath = (CGPathRef)path.platformPath()->GetNativePath();
CGContextBeginPath(context);
CGContextAddPath(context, nativePath);
if (clipRule == RULE_EVENODD)
CGContextEOClip(context);
else
CGContextClip(context);
#elif __WXMSW__
Gdiplus::Graphics* g = (Gdiplus::Graphics*)gc->GetNativeContext();
Gdiplus::GraphicsPath* nativePath = (Gdiplus::GraphicsPath*)path.platformPath()->GetNativePath();
if (clipRule == RULE_EVENODD)
nativePath->SetFillMode(Gdiplus::FillModeAlternate);
else
nativePath->SetFillMode(Gdiplus::FillModeWinding);
g->SetClip(nativePath);
#endif
}
void GraphicsContext::strokeRect(const FloatRect& r, float lineWidth)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
if (m_state.strokeGradient) {
CGContextSaveGState(context);
setStrokeThickness(lineWidth);
CGContextAddRect(context, r);
CGContextReplacePathWithStrokedPath(context);
CGContextClip(context);
m_state.strokeGradient->paint(this);
CGContextRestoreGState(context);
return;
}
if (m_state.strokePattern)
applyStrokePattern();
CGContextStrokeRectWithWidth(context, r, lineWidth);
}
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;
}
void GraphicsContext::strokePath(const Path& path)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextBeginPath(context);
CGContextAddPath(context, path.platformPath());
if (m_state.strokeGradient) {
CGContextSaveGState(context);
CGContextReplacePathWithStrokedPath(context);
CGContextClip(context);
CGContextConcatCTM(context, m_state.strokeGradient->gradientSpaceTransform());
m_state.strokeGradient->paint(this);
CGContextRestoreGState(context);
return;
}
if (m_state.strokePattern)
applyStrokePattern();
CGContextStrokePath(context);
}
void CanvasRenderingContext2D::stroke()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
c->beginPath();
c->addPath(m_path);
if (!m_path.isEmpty()) {
// FIXME: This is insufficient, need to use CGContextReplacePathWithStrokedPath to expand to required bounds
float lineWidth = state().m_lineWidth;
float inset = lineWidth / 2;
FloatRect boundingRect = m_path.boundingRect();
boundingRect.inflate(inset);
willDraw(boundingRect);
}
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
if (state().m_strokeStyle->canvasGradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextReplacePathWithStrokedPath(c->platformContext());
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_strokeStyle->canvasGradient()->gradient().platformGradient());
c->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
CGContextStrokePath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_strokeStyle->canvasGradient()) {
p->save();
p->setBrush(*(state().m_strokeStyle->canvasGradient()->gradient().platformGradient()));
p->strokePath(*path, p->pen());
p->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
p->strokePath(*path, p->pen());
}
#elif PLATFORM(CAIRO) && !PLATFORM(BAL)
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_strokeStyle->canvasGradient()) {
cairo_set_source(cr, state().m_strokeStyle->canvasGradient()->gradient().platformGradient());
c->addPath(m_path);
cairo_stroke(cr);
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
c->addPath(m_path);
cairo_stroke(cr);
}
cairo_restore(cr);
#elif PLATFORM(BAL)
//FIXME
notImplemented();
#endif
#if ENABLE(DASHBOARD_SUPPORT)
clearPathForDashboardBackwardCompatibilityMode();
#endif
}
void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
Q_D(QRasterWindowSurface);
// Not ready for painting yet, bail out. This can happen in
// QWidget::create_sys()
if (!d->image)
return;
#ifdef Q_WS_WIN
QRect br = rgn.boundingRect();
#ifndef Q_OS_WINCE
if (!qt_widget_private(window())->isOpaque && d->canUseLayeredWindow) {
QRect r = window()->frameGeometry();
QPoint frameOffset = qt_widget_private(window())->frameStrut().topLeft();
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
Q_BLENDFUNCTION blend = {AC_SRC_OVER, 0, (int)(255.0 * window()->windowOpacity()), Q_AC_SRC_ALPHA};
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
Q_UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, d->image->hdc, &ptSrc, 0, &blend, Q_ULW_ALPHA, &dirty};
(*ptrUpdateLayeredWindowIndirect)(window()->internalWinId(), &info);
} else
#endif
{
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
HDC widget_dc = widget->getDC();
QRect wbr = br.translated(-wOffset);
BitBlt(widget_dc, wbr.x(), wbr.y(), wbr.width(), wbr.height(),
d->image->hdc, br.x() + offset.x(), br.y() + offset.y(), SRCCOPY);
widget->releaseDC(widget_dc);
}
#ifndef QT_NO_DEBUG
static bool flush = !qgetenv("QT_FLUSH_WINDOWSURFACE").isEmpty();
if (flush) {
SelectObject(qt_win_display_dc(), GetStockObject(BLACK_BRUSH));
Rectangle(qt_win_display_dc(), 0, 0, d->image->width() + 2, d->image->height() + 2);
BitBlt(qt_win_display_dc(), 1, 1, d->image->width(), d->image->height(),
d->image->hdc, 0, 0, SRCCOPY);
}
#endif
#endif
#ifdef Q_WS_X11
extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
extern QWidgetData* qt_widget_data(QWidget *);
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
if (widget->window() != window()) {
XFreeGC(X11->display, d_ptr->gc);
d_ptr->gc = XCreateGC(X11->display, widget->handle(), 0, 0);
}
QRegion wrgn(rgn);
if (!wOffset.isNull())
wrgn.translate(-wOffset);
QRect wbr = wrgn.boundingRect();
int num;
XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
XSetClipRectangles(X11->display, d_ptr->gc, 0, 0, rects, num, YXBanded);
QRect br = rgn.boundingRect().translated(offset);
#ifndef QT_NO_MITSHM
if (d_ptr->image->xshmpm) {
XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
br.x(), br.y(), br.width(), br.height(), wbr.x(), wbr.y());
XSync(X11->display, False);
} else
#endif
{
const QImage &src = d->image->image;
br = br.intersected(src.rect());
if (src.format() != QImage::Format_RGB32) {
QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
data->xinfo = widget->x11Info();
data->fromImage(src, Qt::AutoColor);
QPixmap pm = QPixmap(data);
XCopyArea(X11->display, pm.handle(), widget->handle(), d_ptr->gc, br.x() , br.y() , br.width(), br.height(), wbr.x(), wbr.y());
} else {
// qpaintengine_x11.cpp
extern void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image, Drawable hd, GC gc, Display *dpy, Visual *visual, int depth);
qt_x11_drawImage(br, wbr.topLeft(), src, widget->handle(), d_ptr->gc, X11->display, (Visual *)widget->x11Info().visual(), widget->x11Info().depth());
}
}
#endif // FALCON
#ifdef Q_WS_MAC
// qDebug() << "Flushing" << widget << rgn << offset;
// d->image->image.save("flush.png");
// Get a context for the widget.
#ifndef QT_MAC_USE_COCOA
CGContextRef context;
CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
QDBeginCGContext(port, &context);
#else
extern CGContextRef qt_mac_graphicsContextFor(QWidget *);
CGContextRef context = qt_mac_graphicsContextFor(widget);
#endif
CGContextSaveGState(context);
// Flip context.
CGContextTranslateCTM(context, 0, widget->height());
CGContextScaleCTM(context, 1, -1);
// Clip to region.
const QVector<QRect> &rects = rgn.rects();
for (int i = 0; i < rects.size(); ++i) {
const QRect &rect = rects.at(i);
CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
}
CGContextClip(context);
QRect r = rgn.boundingRect();
const CGRect area = CGRectMake(r.x(), r.y(), r.width(), r.height());
CGImageRef image = CGBitmapContextCreateImage(d->image->cg);
CGImageRef subImage = CGImageCreateWithImageInRect(image, area);
qt_mac_drawCGImage(context, &area, subImage);
CGImageRelease(subImage);
CGImageRelease(image);
// CGSize size = { d->image->image.width(), d->image->image.height() };
// CGLayerRef layer = CGLayerCreateWithContext(d->image->cg, size, 0);
// CGPoint pt = { 0, 0 };
// CGContextDrawLayerAtPoint(context, pt, layer);
// CGLayerRelease(layer);
// Restore context.
CGContextRestoreGState(context);
#ifndef QT_MAC_USE_COCOA
QDEndCGContext(port, &context);
#else
CGContextFlush(context);
#endif
#endif
}
void SVGPaintServer::clipToStrokePath(CGContextRef context, const RenderPath*) const
{
CGContextReplacePathWithStrokedPath(context);
CGContextClip(context);
}
void UIFrameBufferQuartz2D::paintEvent(QPaintEvent *aEvent)
{
/* If the machine is NOT in 'running' state,
* the link between framebuffer and video memory
* is broken, we should go fallback now... */
if (m_fUsesGuestVRAM &&
!m_pMachineView->uisession()->isRunning() &&
!m_pMachineView->uisession()->isPaused() &&
/* Online snapshotting: */
m_pMachineView->uisession()->machineState() != KMachineState_Saving)
{
/* Simulate fallback through fake resize-event: */
UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, 640, 480);
resizeEvent(&event);
}
/* For debugging /Developer/Applications/Performance Tools/Quartz
* Debug.app is a nice tool to see which parts of the screen are
* updated.*/
Assert(m_image);
QWidget* viewport = m_pMachineView->viewport();
Assert(VALID_PTR(viewport));
/* Get the dimensions of the viewport */
CGRect viewRect = ::darwinToCGRect(viewport->geometry());
/* Get the context of this window from Qt */
CGContextRef ctx = ::darwinToCGContextRef(viewport);
Assert(VALID_PTR(ctx));
/* Flip the context */
CGContextTranslateCTM(ctx, 0, viewRect.size.height);
CGContextScaleCTM(ctx, 1.0, -1.0);
/* We handle the seamless mode as a special case. */
if (m_pMachineLogic->visualStateType() == UIVisualStateType_Seamless)
{
/* Clear the background (make the rect fully transparent): */
CGContextClearRect(ctx, viewRect);
#ifdef OVERLAY_CLIPRECTS
/* Enable overlay above the seamless mask: */
CGContextSetRGBFillColor(ctx, 0.0, 0.0, 5.0, 0.7);
CGContextFillRect(ctx, viewRect);
#endif /* OVERLAY_CLIPRECTS */
#ifdef COMP_WITH_SHADOW
/* Enable shadows: */
CGContextSetShadow(ctx, CGSizeMake (10, -10), 10);
CGContextBeginTransparencyLayer(ctx, NULL);
#endif /* COMP_WITH_SHADOW */
/* Determine current visible region: */
RegionRects *pRgnRcts = ASMAtomicXchgPtrT(&mRegion, NULL, RegionRects*);
if (pRgnRcts)
{
/* If visible region is determined: */
if (pRgnRcts->used > 0)
{
/* Add the clipping rects all at once (they are defined in SetVisibleRegion): */
CGContextBeginPath(ctx);
CGContextAddRects(ctx, pRgnRcts->rcts, pRgnRcts->used);
/* Now convert the path to a clipping path: */
CGContextClip(ctx);
}
/* Put back the visible region, free if we cannot (2+ SetVisibleRegion calls): */
if ( !ASMAtomicCmpXchgPtr(&mRegion, pRgnRcts, NULL)
&& !ASMAtomicCmpXchgPtr(&mRegionUnused, pRgnRcts, NULL))
{
RTMemFree(pRgnRcts);
pRgnRcts = NULL;
}
}
/* If visible region is still determined: */
if (pRgnRcts && pRgnRcts->used > 0)
{
/* Create a subimage of the current view.
* Currently this subimage is the whole screen. */
CGImageRef subImage;
if (!m_pMachineView->pauseShot().isNull())
{
CGImageRef pauseImg = ::darwinToCGImageRef(&m_pMachineView->pauseShot());
subImage = CGImageCreateWithImageInRect(pauseImg, CGRectMake(m_pMachineView->contentsX(), m_pMachineView->contentsY(), m_pMachineView->visibleWidth(), m_pMachineView->visibleHeight()));
CGImageRelease(pauseImg);
}
else
{
#ifdef RT_ARCH_AMD64
/* Not sure who to blame, but it seems on 64bit there goes
* something terrible wrong (on a second monitor) when directly
* using CGImageCreateWithImageInRect without making a copy. We saw
* something like this already with the scale mode. */
CGImageRef tmpImage = CGImageCreateWithImageInRect(m_image, CGRectMake(m_pMachineView->contentsX(), m_pMachineView->contentsY(), m_pMachineView->visibleWidth(), m_pMachineView->visibleHeight()));
subImage = CGImageCreateCopy(tmpImage);
CGImageRelease(tmpImage);
#else /* RT_ARCH_AMD64 */
subImage = CGImageCreateWithImageInRect(m_image, CGRectMake(m_pMachineView->contentsX(), m_pMachineView->contentsY(), m_pMachineView->visibleWidth(), m_pMachineView->visibleHeight()));
#endif /* !RT_ARCH_AMD64 */
}
Assert(VALID_PTR(subImage));
/* In any case clip the drawing to the view window: */
CGContextClipToRect(ctx, viewRect);
/* At this point draw the real vm image: */
CGContextDrawImage(ctx, ::darwinFlipCGRect(viewRect, viewRect.size.height), subImage);
/* Release the subimage: */
CGImageRelease(subImage);
}
#ifdef COMP_WITH_SHADOW
CGContextEndTransparencyLayer(ctx);
#endif /* COMP_WITH_SHADOW */
#ifdef OVERLAY_CLIPRECTS
if (pRgnRcts && pRgnRcts->used > 0)
{
CGContextBeginPath(ctx);
CGContextAddRects(ctx, pRgnRcts->rcts, pRgnRcts->used);
CGContextSetRGBStrokeColor(ctx, 1.0, 0.0, 0.0, 0.7);
CGContextDrawPath(ctx, kCGPathStroke);
}
CGContextSetRGBStrokeColor(ctx, 0.0, 1.0, 0.0, 0.7);
CGContextStrokeRect(ctx, viewRect);
#endif /* OVERLAY_CLIPRECTS */
}
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;
}
void doClippedEllipse(CGContextRef context)
{
CGPoint theCenterPoint = { 120., 120. };
CGSize theEllipseSize = { 100., 200. };
float dash[1] = { 2 };
static CGColorRef opaqueBrownColor = NULL, opaqueOrangeColor = NULL;
// Initialize the CGColorRefs if necessary.
if(opaqueBrownColor == NULL){
// The initial value of the color array is an
// opaque brown in an RGB color space.
float color[4] = { 0.325, 0.208, 0.157, 1.0 };
CGColorSpaceRef theColorSpace = getTheCalibratedRGBColorSpace();
// Create a CGColorRef for opaque brown.
opaqueBrownColor = CGColorCreate(theColorSpace, color);
// Make the color array correspond to an opaque orange.
color[0] = 0.965 ; color[1] = 0.584; color[2] = 0.059;
// Create another CGColorRef for opaque orange.
opaqueOrangeColor = CGColorCreate(theColorSpace, color);
}
// Draw two ellipses centered about the same point, one
// rotated 45 degrees from the other.
CGContextSaveGState(context);
// Ellipse 1
createEllipsePath(context, theCenterPoint, theEllipseSize);
CGContextSetFillColorWithColor(context, opaqueBrownColor);
CGContextFillPath(context);
// Translate and rotate about the center point of the ellipse.
CGContextTranslateCTM(context, theCenterPoint.x, theCenterPoint.y);
// Rotate by 45 degrees.
CGContextRotateCTM(context, DEGREES_TO_RADIANS(45));
// Ellipse 2
// CGPointZero is a pre-defined Quartz point corresponding to
// the coordinate (0,0).
createEllipsePath(context, CGPointZero, theEllipseSize);
CGContextSetFillColorWithColor(context, opaqueOrangeColor);
CGContextFillPath(context);
CGContextRestoreGState(context);
CGContextTranslateCTM(context, 170., 0.);
// Now use the first ellipse as a clipping area prior to
// painting the second ellipse.
CGContextSaveGState(context);
// Ellipse 3
createEllipsePath(context, theCenterPoint, theEllipseSize);
CGContextSetStrokeColorWithColor(context, opaqueBrownColor);
CGContextSetLineDash(context, 0, dash, 1);
// Stroke the path with a dash.
CGContextStrokePath(context);
// Ellipse 4
createEllipsePath(context, theCenterPoint, theEllipseSize);
// Clip to the elliptical path.
CGContextClip(context);
CGContextTranslateCTM(context, theCenterPoint.x, theCenterPoint.y);
// Rotate by 45 degrees.
CGContextRotateCTM(context, DEGREES_TO_RADIANS(45));
// Ellipse 5
createEllipsePath(context, CGPointZero, theEllipseSize);
CGContextSetFillColorWithColor(context, opaqueOrangeColor);
CGContextFillPath(context);
CGContextRestoreGState(context);
}
/*
Handle events of kEventClassControl that get sent to the Frame
*/
OSStatus HandleStarFrameControlEvents(
EventHandlerCallRef inCallRef,
EventRef inEvent,
StarFrameData* frameData)
{
OSStatus retVal = eventNotHandledErr;
switch(GetEventKind(inEvent)) {
case kEventControlInitialize :
retVal = HandleStarFrameInitialize(inCallRef, inEvent, frameData);
break;
case kEventControlOwningWindowChanged : {
// We only want the star-shaped opaque area of our frame view to
// draw. Everything else should be transparent. To accomplish that
// we change the features of the owning window so that only the
// content we draw shows up on screen
WindowRef newWindow = GetControlOwner(frameData->hiSelf);
HIWindowChangeFeatures(newWindow, 0, kWindowIsOpaque);
} break;
case kEventControlBoundsChanged : {
retVal = HandleStarFrameBoundsChanged(inCallRef, inEvent, frameData);
} break;
case kEventControlDraw : {
HIRect bounds;
CGContextRef cgContext;
HIViewGetBounds(frameData->hiSelf, &bounds);
float radius = fmin(CGRectGetWidth(bounds) / 2.0, CGRectGetHeight(bounds) / 2.0);
GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(cgContext), NULL, &cgContext );
if(NULL != cgContext) {
HIThemeMenuDrawInfo drawInfo;
CGPathRef starPath = CreatePathForStarFrame(frameData, radius);
drawInfo.version = 0;
drawInfo.menuType = frameData->menuType;
// HIThemeDrawMenuBackground is designed to draw the pin striped background
// of standard menus. Our menu is a star and so HIThemeDrawMenuBackground may not be
// appropriate in this case. Nevertheless, we'll draw the standard menu background for
// this menu and clip it to a star.
CGContextClearRect(cgContext, bounds);
CGContextSaveGState(cgContext);
CGContextTranslateCTM(cgContext, radius, radius);
CGContextAddPath(cgContext, starPath);
CGContextClip(cgContext);
CGContextTranslateCTM(cgContext, -radius, -radius);
HIThemeDrawMenuBackground(&bounds, &drawInfo, cgContext, kHIThemeOrientationNormal);
CGContextRestoreGState(cgContext);
// The pin striping looks a bit odd sort of floating out by itself. We'll also add
// a lovely gray line to help emphasize the boundary
CGContextTranslateCTM(cgContext, radius, radius);
CGContextAddPath(cgContext, starPath);
CGContextSetRGBStrokeColor(cgContext, 0.8, 0.8, 0.8, 1.0);
CGContextSetLineWidth(cgContext, 1.0);
CGContextStrokePath(cgContext);
CGPathRelease(starPath);
starPath = NULL;
}
retVal = noErr;
} break;
// Mac OS X v10.4 introduced a Window Manager bug.
// The workaround is to implement the kEventControlGetFrameMetrics handler.
// Even after the bug is fixed, the workaround will not be harmful.
case kEventControlGetFrameMetrics: {
HIViewRef contentView = NULL;
// If we can find our content view, ask it for our metrics
verify_noerr(HIViewFindByID(frameData->hiSelf, kHIViewWindowContentID, &contentView));
if(NULL != contentView) {
retVal = SendEventToEventTargetWithOptions( inEvent, GetControlEventTarget( contentView ), kEventTargetDontPropagate );
}
} break;
default:
break;
}
return retVal;
}
void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
Q_D(QRasterWindowSurface);
// Not ready for painting yet, bail out. This can happen in
// QWidget::create_sys()
if (!d->image || rgn.rectCount() == 0)
return;
#ifdef Q_WS_WIN
QRect br = rgn.boundingRect();
if (!qt_widget_private(window())->isOpaque
&& window()->testAttribute(Qt::WA_TranslucentBackground)
&& (qt_widget_private(window())->data.window_flags & Qt::FramelessWindowHint))
{
QRect r = window()->frameGeometry();
QPoint frameOffset = qt_widget_private(window())->frameStrut().topLeft();
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (BYTE)(255.0 * window()->windowOpacity()), Q_AC_SRC_ALPHA};
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
Q_UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, d->image->hdc, &ptSrc, 0, &blend, Q_ULW_ALPHA, &dirty};
ptrUpdateLayeredWindowIndirect(window()->internalWinId(), &info);
} else
{
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
HDC widget_dc = widget->getDC();
QRect wbr = br.translated(-wOffset);
BitBlt(widget_dc, wbr.x(), wbr.y(), wbr.width(), wbr.height(),
d->image->hdc, br.x() + offset.x(), br.y() + offset.y(), SRCCOPY);
widget->releaseDC(widget_dc);
}
#ifndef QT_NO_DEBUG
static bool flush = !qgetenv("QT_FLUSH_WINDOWSURFACE").isEmpty();
if (flush) {
SelectObject(qt_win_display_dc(), GetStockObject(BLACK_BRUSH));
Rectangle(qt_win_display_dc(), 0, 0, d->image->width() + 2, d->image->height() + 2);
BitBlt(qt_win_display_dc(), 1, 1, d->image->width(), d->image->height(),
d->image->hdc, 0, 0, SRCCOPY);
}
#endif
#endif
#ifdef Q_WS_X11
extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
extern QWidgetData* qt_widget_data(QWidget *);
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
if (widget->window() != window()) {
XFreeGC(X11->display, d_ptr->gc);
d_ptr->gc = XCreateGC(X11->display, widget->handle(), 0, 0);
}
QRegion wrgn(rgn);
if (!wOffset.isNull())
wrgn.translate(-wOffset);
if (wrgn.rectCount() != 1) {
int num;
XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
XSetClipRectangles(X11->display, d_ptr->gc, 0, 0, rects, num, YXBanded);
}
QPoint widgetOffset = offset + wOffset;
QRect clipRect = widget->rect().translated(widgetOffset).intersected(d_ptr->image->image.rect());
QRect br = rgn.boundingRect().translated(offset).intersected(clipRect);
QPoint wpos = br.topLeft() - widgetOffset;
#ifndef QT_NO_MITSHM
if (d_ptr->image->xshmpm) {
XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
br.x(), br.y(), br.width(), br.height(), wpos.x(), wpos.y());
d_ptr->needsSync = true;
} else if (d_ptr->image->xshmimg) {
XShmPutImage(X11->display, widget->handle(), d_ptr->gc, d_ptr->image->xshmimg,
br.x(), br.y(), wpos.x(), wpos.y(), br.width(), br.height(), False);
d_ptr->needsSync = true;
} else
#endif
{
int depth = widget->x11Info().depth();
const QImage &src = d->image->image;
if (src.format() != QImage::Format_RGB32 || depth < 24 || X11->bppForDepth.value(depth) != 32) {
Q_ASSERT(src.depth() >= 16);
const QImage sub_src(src.scanLine(br.y()) + br.x() * (uint(src.depth()) / 8),
br.width(), br.height(), src.bytesPerLine(), src.format());
QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
data->xinfo = widget->x11Info();
data->fromImage(sub_src, Qt::NoOpaqueDetection);
QPixmap pm = QPixmap(data);
XCopyArea(X11->display, pm.handle(), widget->handle(), d_ptr->gc, 0 , 0 , br.width(), br.height(), wpos.x(), wpos.y());
} else {
// qpaintengine_x11.cpp
extern void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image, Drawable hd, GC gc, Display *dpy, Visual *visual, int depth);
qt_x11_drawImage(br, wpos, src, widget->handle(), d_ptr->gc, X11->display, (Visual *)widget->x11Info().visual(), depth);
}
}
if (wrgn.rectCount() != 1)
XSetClipMask(X11->display, d_ptr->gc, XNone);
#endif // FALCON
#ifdef Q_WS_MAC
Q_UNUSED(offset);
// This is mainly done for native components like native "open file" dialog.
if (widget->testAttribute(Qt::WA_DontShowOnScreen)) {
return;
}
#ifdef QT_MAC_USE_COCOA
this->needsFlush = true;
this->regionToFlush += rgn;
// The actual flushing will be processed in [view drawRect:rect]
qt_mac_setNeedsDisplay(widget);
#else
// Get a context for the widget.
CGContextRef context;
CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
QDBeginCGContext(port, &context);
CGContextRetain(context);
CGContextSaveGState(context);
// Flip context.
CGContextTranslateCTM(context, 0, widget->height());
CGContextScaleCTM(context, 1, -1);
// Clip to region.
const QVector<QRect> &rects = rgn.rects();
for (int i = 0; i < rects.size(); ++i) {
const QRect &rect = rects.at(i);
CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
}
CGContextClip(context);
QRect r = rgn.boundingRect().intersected(d->image->image.rect());
const CGRect area = CGRectMake(r.x(), r.y(), r.width(), r.height());
CGImageRef image = CGBitmapContextCreateImage(d->image->cg);
CGImageRef subImage = CGImageCreateWithImageInRect(image, area);
qt_mac_drawCGImage(context, &area, subImage);
CGImageRelease(subImage);
CGImageRelease(image);
QDEndCGContext(port, &context);
// Restore context.
CGContextRestoreGState(context);
CGContextRelease(context);
#endif // QT_MAC_USE_COCOA
#endif // Q_WS_MAC
}
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;
}
