// A helper which quickly fills a rectangle with a simple color fill. static inline void fillRectWithColor(cairo_t* cr, const FloatRect& rect, const Color& color) { if (!color.alpha() && cairo_get_operator(cr) == CAIRO_OPERATOR_OVER) return; setSourceRGBAFromColor(cr, color); cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height()); cairo_fill(cr); }
static int cairo_get_operator_l( lua_State* L ) { lua_cairo_t* lc = lua_cairo_check( L, 1 ); lua_pushstring( L, cairo_operator_lst[cairo_get_operator( lc->cairo )] ); return( 1 ); }
void plotstuff_clear(plot_args_t* pargs) { cairo_operator_t op; assert(pargs->cairo); op = cairo_get_operator(pargs->cairo); cairo_set_operator(pargs->cairo, CAIRO_OPERATOR_CLEAR); cairo_paint(pargs->cairo); cairo_set_operator(pargs->cairo, op); }
gboolean draw_update_macro_exposure (cairo_t *cairoTarget, cairo_operator_t clearOperator, cairo_operator_t darkOperator, gdouble exposureSetting){ if (exposureSetting == 0.0) { cairo_set_operator (cairoTarget, clearOperator); } else if (exposureSetting == 1.0) { cairo_set_operator (cairoTarget, darkOperator); } else if (exposureSetting == 2.0) { /* reverse current exposure setting */ cairo_operator_t currentOperator = cairo_get_operator (cairoTarget); if (currentOperator == clearOperator) { cairo_set_operator (cairoTarget, darkOperator); } else { cairo_set_operator (cairoTarget, clearOperator); } } return TRUE; }
static int settings_get (cairo_t *cr, settings_t *settings) { int count; settings->op = cairo_get_operator (cr); settings->tolerance = cairo_get_tolerance (cr); settings->fill_rule = cairo_get_fill_rule (cr); settings->line_width = cairo_get_line_width (cr); settings->line_cap = cairo_get_line_cap (cr); settings->line_join = cairo_get_line_join (cr); settings->miter_limit = cairo_get_miter_limit (cr); cairo_get_matrix (cr, &settings->matrix); count = cairo_get_dash_count (cr); if (count != 5) return -1; cairo_get_dash (cr, settings->dash, &settings->dash_offset); return 0; }
int draw_image_to_cairo_target (cairo_t *cairoTarget, gerbv_image_t *image, gdouble pixelWidth, enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo, gerbv_render_info_t *renderInfo, gboolean allowOptimization, gerbv_user_transformation_t transform, gboolean pixelOutput) { const int hole_cross_inc_px = 8; struct gerbv_net *net, *polygonStartNet=NULL; double x1, y1, x2, y2, cp_x=0, cp_y=0; gdouble *p, p0, p1, dx, dy, lineWidth, r; gerbv_netstate_t *oldState; gerbv_layer_t *oldLayer; cairo_operator_t drawOperatorClear, drawOperatorDark; gboolean invertPolarity = FALSE, oddWidth = FALSE; gdouble minX=0, minY=0, maxX=0, maxY=0; gdouble criticalRadius; gdouble scaleX = transform.scaleX; gdouble scaleY = transform.scaleY; gboolean limitLineWidth = TRUE; gboolean displayPixel = TRUE; /* If we are scaling the image at all, ignore the line width checks * since scaled up lines can still be visible */ if ((scaleX != 1)||(scaleY != 1)){ limitLineWidth = FALSE; } if (transform.mirrorAroundX) scaleY *= -1; if (transform.mirrorAroundY) scaleX *= -1; cairo_translate (cairoTarget, transform.translateX, transform.translateY); cairo_scale (cairoTarget, scaleX, scaleY); cairo_rotate (cairoTarget, transform.rotation); gboolean useOptimizations = allowOptimization; /* If the user is using any transformations for this layer, then don't * bother using rendering optimizations */ if ((fabs(transform.translateX) > 0.00001) || (fabs(transform.translateY) > 0.00001) || (fabs(transform.scaleX - 1) > 0.00001) || (fabs(transform.scaleY - 1) > 0.00001) || (fabs(transform.rotation) > 0.00001) || transform.mirrorAroundX || transform.mirrorAroundY) useOptimizations = FALSE; if (useOptimizations && pixelOutput) { minX = renderInfo->lowerLeftX; minY = renderInfo->lowerLeftY; maxX = renderInfo->lowerLeftX + (renderInfo->displayWidth / renderInfo->scaleFactorX); maxY = renderInfo->lowerLeftY + (renderInfo->displayHeight / renderInfo->scaleFactorY); } /* do initial justify */ cairo_translate (cairoTarget, image->info->imageJustifyOffsetActualA, image->info->imageJustifyOffsetActualB); /* set the fill rule so aperture holes are cleared correctly */ cairo_set_fill_rule (cairoTarget, CAIRO_FILL_RULE_EVEN_ODD); /* offset image */ cairo_translate (cairoTarget, image->info->offsetA, image->info->offsetB); /* do image rotation */ cairo_rotate (cairoTarget, image->info->imageRotation); /* load in polarity operators depending on the image polarity */ invertPolarity = transform.inverted; if (image->info->polarity == GERBV_POLARITY_NEGATIVE) invertPolarity = !invertPolarity; if (drawMode == DRAW_SELECTIONS) invertPolarity = FALSE; if (invertPolarity) { drawOperatorClear = CAIRO_OPERATOR_OVER; drawOperatorDark = CAIRO_OPERATOR_CLEAR; cairo_set_operator (cairoTarget, CAIRO_OPERATOR_OVER); cairo_paint (cairoTarget); cairo_set_operator (cairoTarget, CAIRO_OPERATOR_CLEAR); } else { drawOperatorClear = CAIRO_OPERATOR_CLEAR; drawOperatorDark = CAIRO_OPERATOR_OVER; } /* next, push two cairo states to simulate the first layer and netstate translations (these will be popped when another layer or netstate is started */ cairo_save (cairoTarget); cairo_save (cairoTarget); /* store the current layer and netstate so we know when they change */ oldLayer = image->layers; oldState = image->states; for (net = image->netlist->next; net != NULL; net = gerbv_image_return_next_renderable_object(net)) { /* check if this is a new layer */ if (net->layer != oldLayer){ /* it's a new layer, so recalculate the new transformation matrix for it */ cairo_restore (cairoTarget); cairo_restore (cairoTarget); cairo_save (cairoTarget); /* do any rotations */ cairo_rotate (cairoTarget, net->layer->rotation); /* handle the layer polarity */ if ((net->layer->polarity == GERBV_POLARITY_CLEAR)^invertPolarity) { cairo_set_operator (cairoTarget, CAIRO_OPERATOR_CLEAR); drawOperatorClear = CAIRO_OPERATOR_OVER; drawOperatorDark = CAIRO_OPERATOR_CLEAR; } else { cairo_set_operator (cairoTarget, CAIRO_OPERATOR_OVER); drawOperatorClear = CAIRO_OPERATOR_CLEAR; drawOperatorDark = CAIRO_OPERATOR_OVER; } /* Draw any knockout areas */ gerbv_knockout_t *ko = &net->layer->knockout; if (ko->firstInstance == TRUE) { cairo_operator_t oldOperator = cairo_get_operator (cairoTarget); if (ko->polarity == GERBV_POLARITY_CLEAR) { cairo_set_operator (cairoTarget, drawOperatorClear); } else { cairo_set_operator (cairoTarget, drawOperatorDark); } cairo_new_path (cairoTarget); cairo_rectangle (cairoTarget, ko->lowerLeftX - ko->border, ko->lowerLeftY - ko->border, ko->width + 2*ko->border, ko->height + 2*ko->border); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_set_operator (cairoTarget, oldOperator); } /* Finally, reapply old netstate transformation */ cairo_save (cairoTarget); draw_apply_netstate_transformation (cairoTarget, net->state); oldLayer = net->layer; } /* check if this is a new netstate */ if (net->state != oldState){ /* pop the transformation matrix back to the "pre-state" state and resave it */ cairo_restore (cairoTarget); cairo_save (cairoTarget); /* it's a new state, so recalculate the new transformation matrix for it */ draw_apply_netstate_transformation (cairoTarget, net->state); oldState = net->state; } /* if we are only drawing from the selection buffer, search if this net is in the buffer */ if (drawMode == DRAW_SELECTIONS) { /* this flag makes sure we don't draw any unintentional polygons... if we've successfully entered a polygon (the first net matches, and we don't want to check the nets inside the polygon) then polygonStartNet will be set */ if (!polygonStartNet) { if (!draw_net_is_in_selection_buffer_remove (net, selectionInfo, FALSE)) continue; } } /* step and repeat */ gerbv_step_and_repeat_t *sr = &net->layer->stepAndRepeat; int ix, iy; for (ix = 0; ix < sr->X; ix++) { for (iy = 0; iy < sr->Y; iy++) { double sr_x = ix * sr->dist_X; double sr_y = iy * sr->dist_Y; if (useOptimizations && pixelOutput && ((net->boundingBox.right+sr_x < minX) || (net->boundingBox.left+sr_x > maxX) || (net->boundingBox.top+sr_y < minY) || (net->boundingBox.bottom+sr_y > maxY))) { continue; } x1 = net->start_x + sr_x; y1 = net->start_y + sr_y; x2 = net->stop_x + sr_x; y2 = net->stop_y + sr_y; /* translate circular x,y data as well */ if (net->cirseg) { cp_x = net->cirseg->cp_x + sr_x; cp_y = net->cirseg->cp_y + sr_y; } /* render any labels attached to this net */ /* NOTE: this is currently only used on PNP files, so we may make some assumptions here... */ if (net->label) { cairo_set_font_size (cairoTarget, 0.05); cairo_save (cairoTarget); cairo_move_to (cairoTarget, x1, y1); cairo_scale (cairoTarget, 1, -1); cairo_show_text (cairoTarget, net->label->str); cairo_restore (cairoTarget); } /* Polygon area fill routines */ switch (net->interpolation) { case GERBV_INTERPOLATION_PAREA_START : draw_render_polygon_object (net, cairoTarget, sr_x, sr_y, image, drawMode, selectionInfo, pixelOutput); continue; case GERBV_INTERPOLATION_DELETED: continue; default : break; } /* * If aperture state is off we allow use of undefined apertures. * This happens when gerber files starts, but hasn't decided on * which aperture to use. */ if (image->aperture[net->aperture] == NULL) continue; switch (net->aperture_state) { case GERBV_APERTURE_STATE_ON : /* if the aperture width is truly 0, then render as a 1 pixel width line. 0 diameter apertures are used by some programs to draw labels, etc, and they are rendered by other programs as 1 pixel wide */ /* NOTE: also, make sure all lines are at least 1 pixel wide, so they always show up at low zoom levels */ if (limitLineWidth&&((image->aperture[net->aperture]->parameter[0] < pixelWidth)&& (pixelOutput))) criticalRadius = pixelWidth/2.0; else criticalRadius = image->aperture[net->aperture]->parameter[0]/2.0; lineWidth = criticalRadius*2.0; // convert to a pixel integer cairo_user_to_device_distance (cairoTarget, &lineWidth, &x1); if (pixelOutput) { lineWidth = round(lineWidth); if ((int)lineWidth % 2) { oddWidth = TRUE; } else { oddWidth = FALSE; } } cairo_device_to_user_distance (cairoTarget, &lineWidth, &x1); cairo_set_line_width (cairoTarget, lineWidth); switch (net->interpolation) { case GERBV_INTERPOLATION_x10 : case GERBV_INTERPOLATION_LINEARx01 : case GERBV_INTERPOLATION_LINEARx001 : case GERBV_INTERPOLATION_LINEARx1 : cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); /* weed out any lines that are * obviously not going to * render on the visible screen */ switch (image->aperture[net->aperture]->type) { case GERBV_APTYPE_CIRCLE : if (renderInfo->show_cross_on_drill_holes && image->layertype == GERBV_LAYERTYPE_DRILL) { /* Draw center crosses on slot hole */ cairo_set_line_width (cairoTarget, pixelWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); r = image->aperture[net->aperture]->parameter[0]/2.0 + hole_cross_inc_px*pixelWidth; draw_cairo_cross (cairoTarget, x1, y1, r); draw_cairo_cross (cairoTarget, x2, y2, r); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); cairo_set_line_width (cairoTarget, lineWidth); } draw_cairo_move_to (cairoTarget, x1, y1, oddWidth, pixelOutput); draw_cairo_line_to (cairoTarget, x2, y2, oddWidth, pixelOutput); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; case GERBV_APTYPE_RECTANGLE : dx = image->aperture[net->aperture]->parameter[0]/2; dy = image->aperture[net->aperture]->parameter[1]/2; if(x1 > x2) dx = -dx; if(y1 > y2) dy = -dy; cairo_new_path(cairoTarget); draw_cairo_move_to (cairoTarget, x1 - dx, y1 - dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x1 - dx, y1 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 - dx, y2 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 + dx, y2 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 + dx, y2 - dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x1 + dx, y1 - dy, FALSE, pixelOutput); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); break; /* TODO: for now, just render ovals or polygons like a circle */ case GERBV_APTYPE_OVAL : case GERBV_APTYPE_POLYGON : draw_cairo_move_to (cairoTarget, x1,y1, oddWidth, pixelOutput); draw_cairo_line_to (cairoTarget, x2,y2, oddWidth, pixelOutput); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; /* macros can only be flashed, so ignore any that might be here */ default: GERB_COMPILE_WARNING(_("Skipped aperture type \"%s\""), _(aperture_names[image->aperture[net->aperture]->type])); break; } break; case GERBV_INTERPOLATION_CW_CIRCULAR : case GERBV_INTERPOLATION_CCW_CIRCULAR : /* cairo doesn't have a function to draw oval arcs, so we must * draw an arc and stretch it by scaling different x and y values */ cairo_new_path(cairoTarget); if (image->aperture[net->aperture]->type == GERBV_APTYPE_RECTANGLE) { cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); } else { cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); } cairo_save (cairoTarget); cairo_translate(cairoTarget, cp_x, cp_y); cairo_scale (cairoTarget, net->cirseg->width, net->cirseg->height); if (net->cirseg->angle2 > net->cirseg->angle1) { cairo_arc (cairoTarget, 0.0, 0.0, 0.5, DEG2RAD(net->cirseg->angle1), DEG2RAD(net->cirseg->angle2)); } else { cairo_arc_negative (cairoTarget, 0.0, 0.0, 0.5, DEG2RAD(net->cirseg->angle1), DEG2RAD(net->cirseg->angle2)); } cairo_restore (cairoTarget); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; default : GERB_COMPILE_WARNING(_("Skipped interpolation type %d"), net->interpolation); break; } break; case GERBV_APERTURE_STATE_OFF : break; case GERBV_APERTURE_STATE_FLASH : p = image->aperture[net->aperture]->parameter; cairo_save (cairoTarget); draw_cairo_translate_adjust(cairoTarget, x2, y2, pixelOutput); switch (image->aperture[net->aperture]->type) { case GERBV_APTYPE_CIRCLE : if (renderInfo->show_cross_on_drill_holes && image->layertype == GERBV_LAYERTYPE_DRILL) { /* Draw center cross on drill hole */ cairo_set_line_width (cairoTarget, pixelWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); r = p[0]/2.0 + hole_cross_inc_px*pixelWidth; draw_cairo_cross (cairoTarget, 0, 0, r); cairo_set_line_width (cairoTarget, lineWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); } gerbv_draw_circle(cairoTarget, p[0]); gerbv_draw_aperture_hole (cairoTarget, p[1], p[2], pixelOutput); break; case GERBV_APTYPE_RECTANGLE : // some CAD programs use very thin flashed rectangles to compose // logos/images, so we must make sure those display here displayPixel = pixelOutput; p0 = p[0]; p1 = p[1]; if (limitLineWidth && (p[0] < pixelWidth) && pixelOutput) { p0 = pixelWidth; displayPixel = FALSE; } if (limitLineWidth && (p[1] < pixelWidth) && pixelOutput) { p1 = pixelWidth; displayPixel = FALSE; } gerbv_draw_rectangle(cairoTarget, p0, p1, displayPixel); gerbv_draw_aperture_hole (cairoTarget, p[2], p[3], displayPixel); break; case GERBV_APTYPE_OVAL : gerbv_draw_oblong(cairoTarget, p[0], p[1]); gerbv_draw_aperture_hole (cairoTarget, p[2], p[3], pixelOutput); break; case GERBV_APTYPE_POLYGON : gerbv_draw_polygon(cairoTarget, p[0], p[1], p[2]); gerbv_draw_aperture_hole (cairoTarget, p[3], p[4], pixelOutput); break; case GERBV_APTYPE_MACRO : gerbv_draw_amacro(cairoTarget, drawOperatorClear, drawOperatorDark, image->aperture[net->aperture]->simplified, (gint)p[0], pixelWidth, drawMode, selectionInfo, image, net); break; default : GERB_MESSAGE(_("Unknown aperture type")); return 0; } /* and finally fill the path */ draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_restore (cairoTarget); break; default: GERB_MESSAGE(_("Unknown aperture state")); return 0; } } } } /* restore the initial two state saves (one for layer, one for netstate)*/ cairo_restore (cairoTarget); cairo_restore (cairoTarget); return 1; }
int gerbv_draw_amacro(cairo_t *cairoTarget, cairo_operator_t clearOperator, cairo_operator_t darkOperator, gerbv_simplified_amacro_t *s, gint usesClearPrimative, gdouble pixelWidth, enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo, gerbv_image_t *image, struct gerbv_net *net) { int handled = 1; gerbv_simplified_amacro_t *ls = s; dprintf("Drawing simplified aperture macros:\n"); if (usesClearPrimative) cairo_push_group (cairoTarget); while (ls != NULL) { /* * This handles the exposure thing in the aperture macro * The exposure is always the first element on stack independent * of aperture macro. */ cairo_save (cairoTarget); cairo_new_path(cairoTarget); cairo_operator_t oldOperator = cairo_get_operator (cairoTarget); switch (ls->type) { case GERBV_APTYPE_MACRO_CIRCLE: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[CIRCLE_EXPOSURE])) { cairo_translate (cairoTarget, ls->parameter[CIRCLE_CENTER_X], ls->parameter[CIRCLE_CENTER_Y]); gerbv_draw_circle (cairoTarget, ls->parameter[CIRCLE_DIAMETER]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_OUTLINE: { int pointCounter,numberOfPoints; /* Number of points parameter seems to not include the start point, * so we add one to include the start point. */ numberOfPoints = (int) ls->parameter[OUTLINE_NUMBER_OF_POINTS] + 1; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[OUTLINE_EXPOSURE])) { cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[2*(numberOfPoints - 1) + OUTLINE_ROTATION])); cairo_move_to (cairoTarget, ls->parameter[OUTLINE_FIRST_X], ls->parameter[OUTLINE_FIRST_Y]); for (pointCounter=0; pointCounter < numberOfPoints; pointCounter++) { cairo_line_to (cairoTarget, ls->parameter[pointCounter * 2 + OUTLINE_FIRST_X], ls->parameter[pointCounter * 2 + OUTLINE_FIRST_Y]); } /* although the gerber specs allow for an open outline, I interpret it to mean the outline should be closed by the rendering softare automatically, since there is no dimension for line thickness. */ draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } case GERBV_APTYPE_MACRO_POLYGON: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[POLYGON_EXPOSURE])) { cairo_translate (cairoTarget, ls->parameter[POLYGON_CENTER_X], ls->parameter[POLYGON_CENTER_Y]); gerbv_draw_polygon(cairoTarget, ls->parameter[POLYGON_DIAMETER], ls->parameter[POLYGON_NUMBER_OF_POINTS], ls->parameter[POLYGON_ROTATION]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_MOIRE: { gdouble diameter, diameterDifference; int circleIndex; cairo_translate (cairoTarget, ls->parameter[MOIRE_CENTER_X], ls->parameter[MOIRE_CENTER_Y]); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[MOIRE_ROTATION])); diameter = ls->parameter[MOIRE_OUTSIDE_DIAMETER] - ls->parameter[MOIRE_CIRCLE_THICKNESS]; diameterDifference = 2*(ls->parameter[MOIRE_GAP_WIDTH] + ls->parameter[MOIRE_CIRCLE_THICKNESS]); cairo_set_line_width (cairoTarget, ls->parameter[MOIRE_CIRCLE_THICKNESS]); for (circleIndex = 0; circleIndex < (int)ls->parameter[MOIRE_NUMBER_OF_CIRCLES]; circleIndex++) { gdouble currentDiameter = diameter - diameterDifference * (float) circleIndex; if (currentDiameter >= 0) { gerbv_draw_circle (cairoTarget, currentDiameter); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); } } gdouble crosshairRadius = ls->parameter[MOIRE_CROSSHAIR_LENGTH] / 2.0; cairo_set_line_width (cairoTarget, ls->parameter[MOIRE_CROSSHAIR_THICKNESS]); cairo_move_to (cairoTarget, -crosshairRadius, 0); cairo_line_to (cairoTarget, crosshairRadius, 0); cairo_move_to (cairoTarget, 0, -crosshairRadius); cairo_line_to (cairoTarget, 0, crosshairRadius); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; } case GERBV_APTYPE_MACRO_THERMAL: { gint i; gdouble startAngle1, startAngle2, endAngle1, endAngle2; cairo_translate (cairoTarget, ls->parameter[THERMAL_CENTER_X], ls->parameter[THERMAL_CENTER_Y]); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[THERMAL_ROTATION])); startAngle1 = asin (ls->parameter[THERMAL_CROSSHAIR_THICKNESS]/ls->parameter[THERMAL_INSIDE_DIAMETER]); endAngle1 = M_PI_2 - startAngle1; endAngle2 = asin (ls->parameter[THERMAL_CROSSHAIR_THICKNESS]/ls->parameter[THERMAL_OUTSIDE_DIAMETER]); startAngle2 = M_PI_2 - endAngle2; for (i = 0; i < 4; i++) { cairo_arc (cairoTarget, 0, 0, ls->parameter[THERMAL_INSIDE_DIAMETER]/2.0, startAngle1, endAngle1); cairo_arc_negative (cairoTarget, 0, 0, ls->parameter[THERMAL_OUTSIDE_DIAMETER]/2.0, startAngle2, endAngle2); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_rotate (cairoTarget, M_PI_2); } break; } case GERBV_APTYPE_MACRO_LINE20: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE20_EXPOSURE])) { gdouble cParameter = ls->parameter[LINE20_LINE_WIDTH]; if (cParameter < pixelWidth) cParameter = pixelWidth; cairo_set_line_width (cairoTarget, cParameter); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_BUTT); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE20_ROTATION])); cairo_move_to (cairoTarget, ls->parameter[LINE20_START_X], ls->parameter[LINE20_START_Y]); cairo_line_to (cairoTarget, ls->parameter[LINE20_END_X], ls->parameter[LINE20_END_Y]); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_LINE21: { gdouble halfWidth, halfHeight; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE21_EXPOSURE])) { halfWidth = ls->parameter[LINE21_WIDTH] / 2.0; halfHeight = ls->parameter[LINE21_HEIGHT] / 2.0; if (halfWidth < pixelWidth) halfWidth = pixelWidth; if (halfHeight < pixelWidth) halfHeight = pixelWidth; cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE21_ROTATION])); cairo_translate (cairoTarget, ls->parameter[LINE21_CENTER_X], ls->parameter[LINE21_CENTER_Y]); cairo_rectangle (cairoTarget, -halfWidth, -halfHeight, ls->parameter[LINE21_WIDTH], ls->parameter[LINE21_HEIGHT]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } case GERBV_APTYPE_MACRO_LINE22: { gdouble halfWidth, halfHeight; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE22_EXPOSURE])) { halfWidth = ls->parameter[LINE22_WIDTH] / 2.0; halfHeight = ls->parameter[LINE22_HEIGHT] / 2.0; if (halfWidth < pixelWidth) halfWidth = pixelWidth; if (halfHeight < pixelWidth) halfHeight = pixelWidth; cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE22_ROTATION])); cairo_translate (cairoTarget, ls->parameter[LINE22_LOWER_LEFT_X], ls->parameter[LINE22_LOWER_LEFT_Y]); cairo_rectangle (cairoTarget, 0, 0, ls->parameter[LINE22_WIDTH], ls->parameter[LINE22_HEIGHT]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } default: handled = 0; } cairo_set_operator (cairoTarget, oldOperator); cairo_restore (cairoTarget); ls = ls->next; } if (usesClearPrimative) { cairo_pop_group_to_source (cairoTarget); cairo_paint (cairoTarget); } return handled; }
int lime_cairo_get_operator (value handle) { return cairo_get_operator ((cairo_t*)val_data (handle)); }
int lime_cairo_get_operator (double handle) { return cairo_get_operator ((cairo_t*)(intptr_t)handle); }
static PyObject * pycairo_get_operator (PycairoContext *o) { return PyInt_FromLong(cairo_get_operator (o->ctx)); }
int32_t Context::getOperator() { return static_cast<int32_t>( cairo_get_operator( mCairo ) ); }
/* Query functions */ static VALUE cr_get_operator (VALUE self) { return INT2FIX (cairo_get_operator (_SELF)); }
gfxContext::GraphicsOperator gfxContext::CurrentOperator() const { return (GraphicsOperator)cairo_get_operator(mCairo); }
static int cr_get_operator (lua_State *L) { cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT); return operator_to_lua(L, cairo_get_operator(*obj)); }
/** * Try the direct path. * @param status the status returned by the callback, if we took the direct path * @return True if we took the direct path */ static cairo_bool_t _draw_with_xlib_direct (cairo_t *cr, Display *default_display, cairo_xlib_drawing_callback callback, void *closure, int bounds_width, int bounds_height, cairo_xlib_drawing_support_t capabilities) { cairo_surface_t *target; Drawable d; cairo_matrix_t matrix; short offset_x, offset_y; cairo_bool_t needs_clip; XRectangle rectangles[MAX_STATIC_CLIP_RECTANGLES]; int rect_count; double device_offset_x, device_offset_y; int max_rectangles; Screen *screen; Visual *visual; cairo_bool_t have_rectangular_clip; target = cairo_get_group_target (cr); cairo_surface_get_device_offset (target, &device_offset_x, &device_offset_y); d = cairo_xlib_surface_get_drawable (target); cairo_get_matrix (cr, &matrix); /* Check that the matrix is a pure translation */ /* XXX test some approximation to == 1.0 here? */ if (matrix.xx != 1.0 || matrix.yy != 1.0 || matrix.xy != 0.0 || matrix.yx != 0.0) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: matrix not a pure translation\n"); return False; } /* Check that the matrix translation offsets (adjusted for device offset) are integers */ if (!_convert_coord_to_short (matrix.x0 + device_offset_x, &offset_x) || !_convert_coord_to_short (matrix.y0 + device_offset_y, &offset_y)) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: non-integer offset\n"); return False; } max_rectangles = 0; if (capabilities & CAIRO_XLIB_DRAWING_SUPPORTS_CLIP_RECT) { max_rectangles = 1; } if (capabilities & CAIRO_XLIB_DRAWING_SUPPORTS_CLIP_LIST) { max_rectangles = MAX_STATIC_CLIP_RECTANGLES; } /* Check that the clip is rectangular and aligned on unit boundaries. */ /* Temporarily set the matrix for _get_rectangular_clip. It's basically the identity matrix, but we must adjust for the fact that our offset-rect is in device coordinates. */ cairo_identity_matrix (cr); cairo_translate (cr, -device_offset_x, -device_offset_y); have_rectangular_clip = _get_rectangular_clip (cr, offset_x, offset_y, bounds_width, bounds_height, &needs_clip, rectangles, max_rectangles, &rect_count); cairo_set_matrix (cr, &matrix); if (!have_rectangular_clip) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: unsupported clip\n"); return False; } /* Stop now if everything is clipped out */ if (needs_clip && rect_count == 0) { CAIRO_XLIB_DRAWING_NOTE("TAKING FAST PATH: all clipped\n"); return True; } /* Check that the operator is OVER */ if (cairo_get_operator (cr) != CAIRO_OPERATOR_OVER) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: non-OVER operator\n"); return False; } /* Check that the offset is supported */ if (!(capabilities & CAIRO_XLIB_DRAWING_SUPPORTS_OFFSET) && (offset_x != 0 || offset_y != 0)) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: unsupported offset\n"); return False; } /* Check that the target surface is an xlib surface. Do this late because we might complete early above when when the object to be drawn is completely clipped out. */ if (!d) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: non-X surface\n"); return False; } /* Check that the display is supported */ screen = cairo_xlib_surface_get_screen (target); if (!(capabilities & CAIRO_XLIB_DRAWING_SUPPORTS_ALTERNATE_SCREEN) && screen != DefaultScreenOfDisplay (default_display)) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: non-default display\n"); return False; } /* Check that there is a visual */ visual = cairo_xlib_surface_get_visual (target); if (!visual) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: no Visual for surface\n"); return False; } /* Check that the visual is supported */ if (!(capabilities & CAIRO_XLIB_DRAWING_SUPPORTS_NONDEFAULT_VISUAL) && DefaultVisualOfScreen (screen) != visual) { CAIRO_XLIB_DRAWING_NOTE("TAKING SLOW PATH: non-default visual\n"); return False; } /* we're good to go! */ CAIRO_XLIB_DRAWING_NOTE("TAKING FAST PATH\n"); cairo_surface_flush (target); callback (closure, screen, d, visual, offset_x, offset_y, rectangles, needs_clip ? rect_count : 0); cairo_surface_mark_dirty (target); return True; }