static inline int
SCREENabs (cairo_t *cr, double dist)
{
double dummy = 0;
cairo_user_to_device_distance (cr, &dist, &dummy);
return rint (dist);
}
gfxSize
gfxContext::UserToDevice(const gfxSize& size) const
{
gfxSize ret = size;
cairo_user_to_device_distance(mCairo, &ret.width, &ret.height);
return ret;
}
gfxRect gfxContext::UserToDevice(gfxRect rect) const
{
gfxRect ret = rect;
cairo_user_to_device(mCairo, &ret.pos.x, &ret.pos.y);
cairo_user_to_device_distance(mCairo, &ret.size.width, &ret.size.height);
return ret;
}
static int
cr_user_to_device_distance (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
double x = luaL_checknumber(L, 2), y = luaL_checknumber(L, 3);
cairo_user_to_device_distance(*obj, &x, &y);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
return 2;
}
static void
compute_hinting_scale (cairo_t *cr,
double x, double y,
double *scale, double *inv)
{
cairo_user_to_device_distance (cr, &x, &y);
*scale = x == 0 ? y : y == 0 ? x :sqrt (x*x + y*y);
*inv = 1 / *scale;
}
void rala_glyph_set_arrow_cb_night(void* v, affine_t t) {
struct cl* cl = (struct cl*)(((set_cell_cb_t*)v)->cl);
cairo_t *cr = cl->cr;
static cairo_pattern_t* memoized_pattern[ARROW_TYPE_MAX];
static int cell_width, cell_height; //in pixels
static cairo_matrix_t scale_matrix;
//Make sure width and height are the same as before
double temp_width = 1.0, temp_height = 1.0;
cairo_user_to_device_distance(cr, &temp_width, &temp_height);
if((int)temp_width != cell_width || (int)temp_height != cell_height) {
cell_width = (int)temp_width;
cell_height = (int)temp_height;
memset(memoized_pattern, 0, sizeof(cairo_pattern_t*)*ARROW_TYPE_MAX);
cairo_matrix_init_scale(&scale_matrix, temp_width, temp_height);
}
//Mark dirty
if(cl->w == 0) {
cl->x = 2*t.wx-1;
cl->y = -(2*t.wy)-1;
cl->w = 3;
cl->h = 3;
} else {
cl->w = -1;
}
cairo_save(cr);
cairo_translate(cr,2*t.wx, -2*t.wy);
setup_arrow(cr,arrow_rotate(t, ((set_arrow_cb_t*)v)->arrow_dir));
arrow_type_t arrow_type = ((set_arrow_cb_t*)v)->arrow_type;
if(!memoized_pattern[arrow_type]) {
cairo_surface_t* memoizer_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, cell_width, cell_height);
cairo_t* m_cr = cairo_create(memoizer_surface);
cairo_scale(m_cr, cell_width, cell_height);
switch(arrow_type) {
case ARROW_TYPE_NONE:
arrow_none_glyph_night(m_cr);
break;
case ARROW_TYPE_X:
arrow_x_glyph_night(m_cr);
break;
case ARROW_TYPE_0:
arrow_0_glyph_night(m_cr);
break;
case ARROW_TYPE_1:
arrow_1_glyph_night(m_cr);
break;
}
memoized_pattern[arrow_type] = cairo_pattern_create_for_surface(memoizer_surface);
cairo_pattern_set_matrix(memoized_pattern[arrow_type], &scale_matrix);
}
cairo_set_source(cr, memoized_pattern[arrow_type]);
cairo_paint(cr);
cairo_restore(cr);
}
CAMLprim value
ml_cairo_user_to_device_distance (value cr, value p)
{
double x, y;
x = Double_field (p, 0);
y = Double_field (p, 1);
cairo_user_to_device_distance (cairo_t_val (cr), &x, &y);
check_cairo_status (cr);
return ml_cairo_point (x, y);
}
static inline int
screen_width (cairo_t *cr, double width)
{
double dummy = 0;
cairo_user_to_device_distance (cr, &width, &dummy);
if (width < 1)
width = 1;
return rint (width);
}
static VALUE
cr_user_to_device_distance (VALUE self, VALUE dx, VALUE dy)
{
double pair[2];
pair[0] = NUM2DBL (dx);
pair[1] = NUM2DBL (dy);
cairo_user_to_device_distance (_SELF, pair, pair + 1);
cr_check_status (_SELF);
return rb_cairo__float_array (pair, 2);
}
static PyObject *
pycairo_user_to_device_distance (PycairoContext *o, PyObject *args) {
double dx, dy;
if (!PyArg_ParseTuple (args, "dd:Context.user_to_device_distance",
&dx, &dy))
return NULL;
cairo_user_to_device_distance (o->ctx, &dx, &dy);
RETURN_NULL_IF_CAIRO_CONTEXT_ERROR(o->ctx);
return Py_BuildValue("(dd)", dx, dy);
}
static void
_rounded_rect (DiaRenderer *self,
Point *topleft, Point *bottomright,
Color *color, real radius,
gboolean fill)
{
DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self);
double rv[2];
radius = MIN(radius, (bottomright->x - topleft->x)/2);
radius = MIN(radius, (bottomright->y - topleft->y)/2);
/* ignore radius if it is smaller than the device unit, avoids anti-aliasing artifacts */
rv[0] = radius;
rv[1] = 0.0;
cairo_user_to_device_distance (renderer->cr, &rv[0], &rv[1]);
if (rv[0] < 1.0 && rv[1] < 1.0) {
_rect (self, topleft, bottomright, color, fill);
return;
}
DIAG_NOTE(g_message("%s_rounded_rect %f,%f -> %f,%f, %f",
fill ? "fill" : "draw",
topleft->x, topleft->y, bottomright->x, bottomright->y, radius));
cairo_set_source_rgba (renderer->cr, color->red, color->green, color->blue, 1.0);
cairo_new_path (renderer->cr);
cairo_move_to (renderer->cr, /* north-west */
topleft->x + radius, topleft->y);
cairo_line_to (renderer->cr, /* north-east */
bottomright->x - radius, topleft->y);
cairo_arc (renderer->cr,
bottomright->x - radius, topleft->y + radius, radius, -G_PI_2, 0);
cairo_line_to (renderer->cr, /* south-east */
bottomright->x, bottomright->y - radius);
cairo_arc (renderer->cr,
bottomright->x - radius, bottomright->y - radius, radius, 0, G_PI_2);
cairo_line_to (renderer->cr, /* south-west */
topleft->x + radius, bottomright->y);
cairo_arc (renderer->cr,
topleft->x + radius, bottomright->y - radius, radius, G_PI_2, G_PI);
cairo_line_to (renderer->cr, /* north-west */
topleft->x, topleft->y + radius);
cairo_arc (renderer->cr,
topleft->x + radius, topleft->y + radius, radius, G_PI, -G_PI_2);
if (fill)
cairo_fill (renderer->cr);
else
cairo_stroke (renderer->cr);
DIAG_STATE(renderer->cr)
}
static PyObject *
pycairo_user_to_device_distance (PycairoContext *o, PyObject *args)
{
double dx, dy;
if (!PyArg_ParseTuple (args, "dd:Context.user_to_device_distance",
&dx, &dy))
return NULL;
cairo_user_to_device_distance (o->ctx, &dx, &dy);
if (Pycairo_Check_Status (cairo_status (o->ctx)))
return NULL;
return Py_BuildValue("(dd)", dx, dy);
}
/** Draw the rectangle _centered_ at current Cairo coordinates.
@param width Width of the rectangle.
@param height Height of the rectangle.
@param pixelOutput Round width and height to pixels.
*/
static void
gerbv_draw_rectangle(cairo_t *cairoTarget, gdouble width, gdouble height,
gboolean pixelOutput)
{
if (pixelOutput) {
cairo_user_to_device_distance (cairoTarget, &width, &height);
width -= (int)round(width) % 2;
height -= (int)round(height) % 2;
cairo_device_to_user_distance (cairoTarget, &width, &height);
}
cairo_rectangle (cairoTarget, -width/2.0, -height/2.0, width, height);
return;
}
void
lsm_cairo_box_user_to_device (cairo_t *cairo, LsmBox *to, const LsmBox *from)
{
if (to == NULL)
return;
if (from == NULL || cairo == NULL) {
to->x = 0;
to->y = 0;
to->width = 0;
to->height = 0;
}
*to = *from;
cairo_user_to_device (cairo, &to->x, &to->y);
cairo_user_to_device_distance (cairo, &to->width, &to->height);
}
FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& frect)
{
FloatRect result;
double x = frect.x();
double y = frect.y();
cairo_t* cr = m_data->cr;
cairo_user_to_device(cr, &x, &y);
x = round(x);
y = round(y);
cairo_device_to_user(cr, &x, &y);
result.setX(static_cast<float>(x));
result.setY(static_cast<float>(y));
x = frect.width();
y = frect.height();
cairo_user_to_device_distance(cr, &x, &y);
x = round(x);
y = round(y);
cairo_device_to_user_distance(cr, &x, &y);
result.setWidth(static_cast<float>(x));
result.setHeight(static_cast<float>(y));
return result;
}
FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& frect, RoundingMode)
{
FloatRect result;
double x = frect.x();
double y = frect.y();
cairo_t* cr = platformContext()->cr();
cairo_user_to_device(cr, &x, &y);
x = round(x);
y = round(y);
cairo_device_to_user(cr, &x, &y);
result.setX(narrowPrecisionToFloat(x));
result.setY(narrowPrecisionToFloat(y));
// We must ensure width and height are at least 1 (or -1) when
// we're given float values in the range between 0 and 1 (or -1 and 0).
double width = frect.width();
double height = frect.height();
cairo_user_to_device_distance(cr, &width, &height);
if (width > -1 && width < 0)
width = -1;
else if (width > 0 && width < 1)
width = 1;
else
width = round(width);
if (height > -1 && width < 0)
height = -1;
else if (height > 0 && height < 1)
height = 1;
else
height = round(height);
cairo_device_to_user_distance(cr, &width, &height);
result.setWidth(narrowPrecisionToFloat(width));
result.setHeight(narrowPrecisionToFloat(height));
return result;
}
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;
}
void LcCairoPainter::user_to_device_distance(double* dx, double* dy) {
cairo_user_to_device_distance(_cr, dx, dy);
}
void Context::userToDeviceDistance( double *dx, double *dy )
{
cairo_user_to_device_distance( mCairo, dx, dy );
}
void rala_glyph_set_cell_cb_day(void* v, affine_t t) {
struct cl* cl = (struct cl*)(((set_cell_cb_t*)v)->cl);
cairo_t *cr = cl->cr;
static cairo_pattern_t* memoized_pattern[CELL_TYPE_MAX];
static int cell_width, cell_height; //in pixels
static cairo_matrix_t scale_matrix;
//Make sure width and height are the same as before
double temp_width = 1.0, temp_height = 1.0;
cairo_user_to_device_distance(cr, &temp_width, &temp_height);
if((int)temp_width != cell_width || (int)temp_height != cell_height) {
cell_width = (int)temp_width;
cell_height = (int)temp_height;
memset(memoized_pattern, 0, sizeof(cairo_pattern_t*)*CELL_TYPE_MAX);
cairo_matrix_init_scale(&scale_matrix, temp_width, temp_height);
}
//Mark dirty
if(cl->w == 0) {
cl->x = 2*t.wx-1;
cl->y = -(2*t.wy)-1;
cl->w = 3;
cl->h = 3;
} else {
cl->w = -1;
}
cairo_save(cr);
cairo_translate(cr,2*t.wx, -2*t.wy);
cell_type_t cell_type = ((set_cell_cb_t*)v)->cell_type;
if(!memoized_pattern[cell_type]) {
cairo_surface_t* memoizer_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, cell_width, cell_height);
cairo_t* m_cr = cairo_create(memoizer_surface);
cairo_scale(m_cr, cell_width, cell_height);
switch(cell_type) {
case CELL_TYPE_BLANK:
break;
case CELL_TYPE_STEM:
stem_cell_glyph_day(m_cr);
break;
case CELL_TYPE_AND:
and_gate_glyph_day(m_cr);
break;
case CELL_TYPE_OR:
or_gate_glyph_day(m_cr);
break;
case CELL_TYPE_XOR:
xor_gate_glyph_day(m_cr);
break;
case CELL_TYPE_NAND:
nand_gate_glyph_day(m_cr);
break;
case CELL_TYPE_WIRE:
wire_cell_glyph_day(m_cr);
break;
case CELL_TYPE_CROSSOVER:
crossover_cell_glyph_day(m_cr);
break;
case CELL_TYPE_COPY_E:
copy_cell_glyph_day(m_cr,2);
break;
case CELL_TYPE_COPY_N:
copy_cell_glyph_day(m_cr,3);
break;
case CELL_TYPE_COPY_W:
copy_cell_glyph_day(m_cr,0);
break;
case CELL_TYPE_COPY_S:
copy_cell_glyph_day(m_cr,1);
break;
case CELL_TYPE_DELETE_E:
delete_cell_glyph_day(m_cr,2);
break;
case CELL_TYPE_DELETE_N:
delete_cell_glyph_day(m_cr,3);
break;
case CELL_TYPE_DELETE_W:
delete_cell_glyph_day(m_cr,0);
break;
case CELL_TYPE_DELETE_S:
delete_cell_glyph_day(m_cr,1);
break;
}
memoized_pattern[cell_type] = cairo_pattern_create_for_surface(memoizer_surface);
cairo_pattern_set_matrix(memoized_pattern[cell_type], &scale_matrix);
}
cairo_set_source(cr, memoized_pattern[cell_type]);
cairo_paint(cr);
cairo_restore(cr);
}
void MediaPlayerPrivateEA::paint(GraphicsContext* context, const IntRect& r)
{
if (!context)
return;
// Can get a NULL platform context so need to verify. Seems that UpdateControlTints does what is called a "fake" paint
// with a null platform context just to get an invalidate.
PlatformContextCairo* pPlatformContext = context->platformContext();
if (!pPlatformContext)
return;
cairo_t* cr = context->platformContext()->cr();
if (!cr)
return;
MediaUpdateInfo& info = GetMediaUpdateInfo();
const FrameView* pFV = mpWebCorePlayer->frameView();
if (!pFV)
return;
// Convert and store movie rect to device coords using the graphic context.
double x = (double) r.x();
double y = (double) r.y();
double w = (double) r.width();
double h = (double) r.height();
cairo_user_to_device (cr, &x, &y);
cairo_user_to_device_distance(cr, &w, &h);
const IntRect rect((int) x, (int) y, (int) w, (int) h);
// The intersection of frameView contents and the movie is used as clip rect for we just want to know what part of the movie is visible.
IntRect clip = pFV->windowClipRect(true);
clip.intersect(rect);
// Find controls intersection
HTMLMediaElement* element = static_cast<HTMLMediaElement*>(mpWebCorePlayer->mediaPlayerClient());
if(element && element->controls())
{
MediaControls* pControls = element->mediaControls();
bool hideControls = pControls->shouldHideControls();
if (!hideControls)
{
const int kControlHeight = 16; // EAWebKitTODO: Consider finding a way to extract this info directly from the controls or pass as a theme param.
IntRect boundingRect = pControls->getRect();
x = (double) boundingRect.x();
y = (double) boundingRect.y();
w = (double) boundingRect.width();
h = (double) (boundingRect.height() - kControlHeight);
cairo_user_to_device (cr, &x, &y);
cairo_user_to_device_distance(cr, &w, &h);
const IntRect ctrlRect((int) x, (int) y, (int) w, (int) h);
clip.intersect(ctrlRect);
}
}
if ((rect != mMovieRect) || (clip != mWindowRect))
{
mMovieRect = rect; // Store copy locally to detect changes.
mWindowRect = clip;
info.mMovieRect = rect;
info.mWindowRect = clip;
ClientUpdate(MediaUpdateInfo::kWindowSize);
}
ClientUpdate(MediaUpdateInfo::kPaint);
if (info.mReturnData)
{
// Draw surface to view
#ifndef NDEBUG
static bool sAssertChecked = false;
if(!sAssertChecked)
{
EAW_ASSERT(!info.mReturnData);
sAssertChecked = true;
}
#endif
context->save();
RefPtr<cairo_surface_t> cairoSurface = adoptRef(cairo_image_surface_create_for_data((unsigned char*) info.mReturnData, CAIRO_FORMAT_ARGB32, w, h, w * sizeof(uint32_t)));
EAW_ASSERT(cairo_surface_status(cairoSurface.get()) == CAIRO_STATUS_SUCCESS);
cairo_set_source_surface(cr, cairoSurface.get(), rect.x(), rect.y());
cairo_paint(cr);
context->restore();
}
else
{
// Draw a default black background.
context->save();
context->setStrokeStyle(NoStroke);
context->setFillColor(Color::black, ColorSpaceDeviceRGB);
context->drawRect(r);
context->restore();
}
}
