static int cairo_get_antialias_l( lua_State* L )
{
lua_cairo_t* lc = lua_cairo_check( L, 1 );
lua_pushstring( L, cairo_antialias_lst[cairo_get_antialias( lc->cairo )] );
return( 1 );
}
gfxContext::AntialiasMode
gfxContext::CurrentAntialiasMode() const
{
cairo_antialias_t aa = cairo_get_antialias(mCairo);
if (aa == CAIRO_ANTIALIAS_NONE)
return MODE_ALIASED;
return MODE_COVERAGE;
}
void copyContextProperties(cairo_t* srcCr, cairo_t* dstCr)
{
cairo_set_antialias(dstCr, cairo_get_antialias(srcCr));
size_t dashCount = cairo_get_dash_count(srcCr);
Vector<double> dashes(dashCount);
double offset;
cairo_get_dash(srcCr, dashes.data(), &offset);
cairo_set_dash(dstCr, dashes.data(), dashCount, offset);
cairo_set_line_cap(dstCr, cairo_get_line_cap(srcCr));
cairo_set_line_join(dstCr, cairo_get_line_join(srcCr));
cairo_set_line_width(dstCr, cairo_get_line_width(srcCr));
cairo_set_miter_limit(dstCr, cairo_get_miter_limit(srcCr));
cairo_set_fill_rule(dstCr, cairo_get_fill_rule(srcCr));
}
void GraphicsContext::clip(const FloatRect& rect)
{
if (paintingDisabled())
return;
cairo_t* cr = platformContext()->cr();
cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height());
cairo_fill_rule_t savedFillRule = cairo_get_fill_rule(cr);
cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING);
// The rectangular clip function is traditionally not expected to
// antialias. If we don't force antialiased clipping here,
// edge fringe artifacts may occur at the layer edges
// when a transformation is applied to the GraphicsContext
// while drawing the transformed layer.
cairo_antialias_t savedAntialiasRule = cairo_get_antialias(cr);
cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
cairo_clip(cr);
cairo_set_fill_rule(cr, savedFillRule);
cairo_set_antialias(cr, savedAntialiasRule);
m_data->clip(rect);
}
void GraphicsContext::clipConvexPolygon(size_t numPoints, const FloatPoint* points, bool antialiased)
{
if (paintingDisabled())
return;
if (numPoints <= 1)
return;
cairo_t* cr = platformContext()->cr();
cairo_new_path(cr);
cairo_fill_rule_t savedFillRule = cairo_get_fill_rule(cr);
cairo_antialias_t savedAntialiasRule = cairo_get_antialias(cr);
cairo_set_antialias(cr, antialiased ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE);
cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING);
addConvexPolygonToContext(cr, numPoints, points);
cairo_clip(cr);
cairo_set_antialias(cr, savedAntialiasRule);
cairo_set_fill_rule(cr, savedFillRule);
}
void
draw_render_polygon_object (gerbv_net_t *oldNet, cairo_t *cairoTarget,
gdouble sr_x, gdouble sr_y, gerbv_image_t *image,
enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo,
gboolean pixelOutput)
{
gerbv_net_t *currentNet, *polygonStartNet;
int haveDrawnFirstFillPoint = 0;
gdouble x2,y2,cp_x=0,cp_y=0;
haveDrawnFirstFillPoint = FALSE;
/* save the first net in the polygon as the "ID" net pointer
in case we are saving this net to the selection array */
polygonStartNet = oldNet;
cairo_new_path(cairoTarget);
for (currentNet = oldNet->next; currentNet!=NULL;
currentNet = currentNet->next) {
x2 = currentNet->stop_x + sr_x;
y2 = currentNet->stop_y + sr_y;
/* translate circular x,y data as well */
if (currentNet->cirseg) {
cp_x = currentNet->cirseg->cp_x + sr_x;
cp_y = currentNet->cirseg->cp_y + sr_y;
}
if (!haveDrawnFirstFillPoint) {
draw_cairo_move_to (cairoTarget, x2, y2, FALSE, pixelOutput);
haveDrawnFirstFillPoint=TRUE;
continue;
}
switch (currentNet->interpolation) {
case GERBV_INTERPOLATION_x10 :
case GERBV_INTERPOLATION_LINEARx01 :
case GERBV_INTERPOLATION_LINEARx001 :
case GERBV_INTERPOLATION_LINEARx1 :
draw_cairo_line_to (cairoTarget, x2, y2, FALSE, pixelOutput);
break;
case GERBV_INTERPOLATION_CW_CIRCULAR :
case GERBV_INTERPOLATION_CCW_CIRCULAR :
if (currentNet->cirseg->angle2 > currentNet->cirseg->angle1) {
cairo_arc (cairoTarget, cp_x, cp_y, currentNet->cirseg->width/2.0,
DEG2RAD(currentNet->cirseg->angle1),
DEG2RAD(currentNet->cirseg->angle2));
} else {
cairo_arc_negative (cairoTarget, cp_x, cp_y, currentNet->cirseg->width/2.0,
DEG2RAD(currentNet->cirseg->angle1),
DEG2RAD(currentNet->cirseg->angle2));
}
break;
case GERBV_INTERPOLATION_PAREA_END :
cairo_close_path(cairoTarget);
/* turn off anti-aliasing for polygons, since it shows seams
with adjacent polygons (usually on PCB ground planes) */
cairo_antialias_t oldAlias = cairo_get_antialias (cairoTarget);
cairo_set_antialias (cairoTarget, CAIRO_ANTIALIAS_NONE);
draw_fill (cairoTarget, drawMode, selectionInfo, image, polygonStartNet);
cairo_set_antialias (cairoTarget, oldAlias);
return;
default :
break;
}
}
}
int lime_cairo_get_antialias (value handle) {
return cairo_get_antialias ((cairo_t*)val_data (handle));
}
int lime_cairo_get_antialias (double handle) {
return cairo_get_antialias ((cairo_t*)(intptr_t)handle);
}
static PyObject *
pycairo_get_antialias (PycairoContext *o)
{
return PyInt_FromLong (cairo_get_antialias (o->ctx));
}
int32_t Context::getAntiAlias()
{
return static_cast<int32_t>( cairo_get_antialias( mCairo ) );
}
IoObject *IoCairoContext_getAntialias(IoCairoContext *self, IoObject *locals, IoMessage *m)
{
return IONUMBER(cairo_get_antialias(CONTEXT(self)));
}
static VALUE
cr_get_antialias(VALUE self)
{
return INT2NUM (cairo_get_antialias (_SELF));
}
static int
cr_get_antialias (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
return antialias_to_lua(L, cairo_get_antialias(*obj));
}