/** @brief setup @a cr for usage @param cr cairo context for @a widget @param widget to be drawn upon @return */ static void _e2_gesture_dialog_cairo_setup (cairo_t *cr, GtkWidget *widget) { GdkRGBA *color; GtkStyleContext *context; cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); //enable display of dots ? cairo_set_line_width (cr, 1.0); //approx 1 pixel cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); context = gtk_widget_get_style_context (widget); gtk_style_context_get (context, GTK_STATE_NORMAL, GTK_STYLE_PROPERTY_COLOR, &color, NULL); cairo_set_source_rgb (cr, color->red, color->green, color->blue); gdk_rgba_free (color); }
static PyObject * pycairo_set_line_join (PycairoContext *o, PyObject *args) { cairo_line_join_t line_join; if (!PyArg_ParseTuple (args, "i:Context.set_line_join", &line_join)) return NULL; cairo_set_line_join (o->ctx, line_join); if (Pycairo_Check_Status (cairo_status (o->ctx))) return NULL; Py_RETURN_NONE; }
static void set_linejoin(DiaRenderer *self, LineJoin mode) { DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self); DIAG_NOTE(g_message("set_join %d", mode)); switch(mode) { case LINEJOIN_MITER: cairo_set_line_join (renderer->cr, CAIRO_LINE_JOIN_MITER); break; case LINEJOIN_ROUND: cairo_set_line_join (renderer->cr, CAIRO_LINE_JOIN_ROUND); break; case LINEJOIN_BEVEL: cairo_set_line_join (renderer->cr, CAIRO_LINE_JOIN_BEVEL); break; default: g_warning("DiaCairoRenderer : Unsupported join mode specified!\n"); } DIAG_STATE(renderer->cr) }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetLineJoin (JNIEnv *env, jobject obj, jint join) { struct graphics2d *gr = NULL; gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj); g_assert (gr != NULL); if (gr->debug) printf ("cairo_set_line_join %d\n", join); switch ((enum java_awt_basic_stroke_join_rule) join) { case java_awt_basic_stroke_JOIN_MITER: cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_MITER); break; case java_awt_basic_stroke_JOIN_ROUND: cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_ROUND); break; case java_awt_basic_stroke_JOIN_BEVEL: cairo_set_line_join (gr->cr, CAIRO_LINE_JOIN_BEVEL); break; } }
static void ig_cairo_draw_bound (GnmItemGrid *ig, cairo_t* cr, int x0, int y0, int x1, int y1) { double width = ig->pane_divider_width; cairo_set_line_width (cr, width); cairo_set_dash (cr, NULL, 0, 0.); cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER); gdk_cairo_set_source_rgba (cr, &ig->pane_divider_color); cairo_move_to (cr, x0 - width / 2, y0 - width / 2); cairo_line_to (cr, x1 - width / 2, y1 - width / 2); cairo_stroke (cr); }
static void settings_set (cairo_t *cr, const settings_t *settings) { cairo_set_operator (cr, settings->op); cairo_set_tolerance (cr, settings->tolerance); cairo_set_fill_rule (cr, settings->fill_rule); cairo_set_line_width (cr, settings->line_width); cairo_set_line_cap (cr, settings->line_cap); cairo_set_line_join (cr, settings->line_join); cairo_set_miter_limit (cr, settings->miter_limit); cairo_set_matrix (cr, &settings->matrix); cairo_set_dash (cr, settings->dash, 5, settings->dash_offset); }
void gt_graphics_cairo_initialize(GtGraphics *gg, GtGraphicsOutType type, unsigned int width, unsigned int height) { GtGraphicsCairo *g = gt_graphics_cairo_cast(gg); g->outbuf = gt_str_new(); switch (type) { case GT_GRAPHICS_PDF: #ifdef CAIRO_HAS_PDF_SURFACE g->surf = cairo_pdf_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_PS: #ifdef CAIRO_HAS_PS_SURFACE g->surf = cairo_ps_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_SVG: #ifdef CAIRO_HAS_SVG_SURFACE g->surf = cairo_svg_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_PNG: default: g->surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); break; } gt_assert(g->surf && cairo_surface_status(g->surf) == CAIRO_STATUS_SUCCESS); g->cr = cairo_create(g->surf); gt_assert(cairo_status(g->cr) == CAIRO_STATUS_SUCCESS); /* set background default to transparent */ g->bg_color.red = g->bg_color.green = 0.0; g->bg_color.blue = g->bg_color.alpha = 0.0; g->width = width; g->height = height; g->margin_x = g->margin_y = 20; cairo_set_line_join(g->cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap(g->cr, CAIRO_LINE_CAP_ROUND); cairo_select_font_face(g->cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); g->type = type; }
int ca_setup_stroke(caskbench_context_t *ctx) { cairo_t *cr = ctx->cairo_cr; line_length = 60; element_spacing = sqrt( ((double)ctx->canvas_width * ctx->canvas_height) / ctx->size); num_x_elements = ctx->canvas_width / element_spacing; num_y_elements = ctx->canvas_height / element_spacing; cairo_set_line_width(cr,ctx->shape_defaults.stroke_width?ctx->shape_defaults.stroke_width:5); cairo_set_line_cap(cr,ctx->shape_defaults.cap_style?(cairo_line_cap_t)(ctx->shape_defaults.cap_style % 3):CAIRO_LINE_CAP_BUTT); cairo_set_line_join(cr,ctx->shape_defaults.join_style?(cairo_line_join_t)(ctx->shape_defaults.join_style % 3):CAIRO_LINE_JOIN_MITER); cairo_set_dash (cr, dashes, sizeof (dashes) / sizeof (dashes[0]), 0); return 1; }
static void draw_joins (cairo_t *cr) { cairo_save (cr); cairo_translate (cr, PAD, PAD); make_path (cr); cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL); cairo_stroke (cr); cairo_translate (cr, SIZE + PAD, 0.); make_path (cr); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_stroke (cr); cairo_translate (cr, SIZE + PAD, 0.); make_path (cr); cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER); cairo_stroke (cr); cairo_translate (cr, SIZE + PAD, 0.); cairo_restore (cr); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { /* First draw a checkered background */ cairo_test_paint_checkered (cr); /* Then draw the original caps-joins test but with a bit of alphs thrown in. */ cairo_set_line_width (cr, LINE_WIDTH); cairo_set_source_rgba (cr, 1.0, 0.0, 0.0, 0.5); /* 50% red */ cairo_translate (cr, PAD, PAD); make_path (cr); cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL); cairo_stroke (cr); cairo_set_source_rgba (cr, 0.0, 1.0, 0.0, 0.5); /* 50% green */ cairo_translate (cr, SIZE + PAD, 0.); make_path (cr); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_stroke (cr); cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 0.5); /* 50% blue */ cairo_translate (cr, SIZE + PAD, 0.); make_path (cr); cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER); cairo_stroke (cr); return CAIRO_TEST_SUCCESS; }
void gimp_display_shell_set_tool_fg_style (GimpDisplayShell *shell, cairo_t *cr, gboolean highlight) { g_return_if_fail (cr != NULL); cairo_set_line_width (cr, 1.0); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); if (highlight) gimp_cairo_set_source_rgba (cr, &tool_fg_highlight); else gimp_cairo_set_source_rgba (cr, &tool_fg); }
void wxSVGCanvasPathCairo::ApplyStrokeStyle(cairo_t* cr, const wxCSSStyleDeclaration& style) { cairo_set_line_width(cr, style.GetStrokeWidth()); switch (style.GetStrokeLinecap()) { case wxCSS_VALUE_ROUND: cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND); break; case wxCSS_VALUE_SQUARE: cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE); break; case wxCSS_VALUE_BUTT: default: cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT); break; } switch (style.GetStrokeLinejoin()) { case wxCSS_VALUE_BEVEL: cairo_set_line_join(cr, CAIRO_LINE_JOIN_BEVEL); break; case wxCSS_VALUE_ROUND: cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); break; case wxCSS_VALUE_MITER: default: cairo_set_line_join(cr, CAIRO_LINE_JOIN_MITER); break; } if (style.GetStrokeDasharray().GetLength() > 0) { double* dashed = new double[style.GetStrokeDasharray().GetLength()]; for (int i = 0; i < style.GetStrokeDasharray().GetLength(); i++) { dashed[i] = style.GetStrokeDasharray().Item(i).GetFloatValue(); } cairo_set_dash(cr, dashed, style.GetStrokeDasharray().GetLength(), 0.0); delete dashed; } else cairo_set_dash(cr, NULL, 0, 0); }
/*================================================================================== pspltrgn - subroutine to set which small plot region to use This routine is called by pschem in psvdraw_new in order to plot multiple ternary chemographies on a single page. Each page can hold MAXPLOTSPERPAGE. If another is requested, then a new document will be created with a name similar to that of the first, and the process will begin again. This overrides any settings made in psssc2, and assumes that x and y (real-unit) bounds are 0.0-1.0. Note that if this routine is called, then plot_aspect_ratio will be ignored. Note that plotnum is a zero-based index ==================================================================================*/ void pspltrgn_ (int *plotnum) { char *outFileName = malloc((strlen(dmh_fileNameRoot)+50) * sizeof(char)); int plotPosition = *plotnum % MAXPLOTSPERPAGE; int pageNum = *plotnum / MAXPLOTSPERPAGE; int boxEdge, rowNum, colNum; DEBUGPRINT(("In pspltrgn. Plotnum = %i, plotPosition = %i, pageNum = %i\n", *plotnum, plotPosition, pageNum)); if (plotPosition == 0 && pageNum > 0) { /* we need to start a new page, so let's close the current one, and start a new one with a related name */ DEBUGPRINT(("In pspltrgn. Closing current page and starting a new one with\n page number=%i and file type=%i\n", pageNum, dmh_outputFileType)); closeSurface(); // close existing surface switch(dmh_outputFileType) { case PDFTYPE: sprintf(outFileName, "%s_%i.%s", dmh_fileNameRoot, pageNum, "pdf"); dmh_surf = cairo_pdf_surface_create (outFileName, dmh_pageWidth, dmh_pageHeight); break; case PSTYPE: sprintf(outFileName, "%s_%i.%s", dmh_fileNameRoot, pageNum, "ps"); dmh_surf = cairo_ps_surface_create (outFileName, dmh_pageWidth, dmh_pageHeight); cairo_ps_surface_set_eps (dmh_surf, 1); break; case SVGTYPE: sprintf(outFileName, "%s_%i.%s", dmh_fileNameRoot, pageNum, "svg"); dmh_surf = cairo_svg_surface_create (outFileName, dmh_pageWidth, dmh_pageHeight); break; } dmh_cr = cairo_create (dmh_surf); cairo_identity_matrix(dmh_cr); cairo_set_line_join(dmh_cr, CAIRO_LINE_JOIN_ROUND); dmh_min_tracked_x = DBL_MAX; } /* Set the location on the page for the small plot */ dmh_aspectRatio = 1.0; /* Ignores plot_aspect_ratio. */ boxEdge = (dmh_pageWidth - LEFTMARGIN - RIGHTMARGIN - MULTIPLOTGUTTER) / 2; rowNum = plotPosition / 2; colNum = plotPosition % 2; dmh_xoffset = LEFTMARGIN + ((boxEdge + MULTIPLOTGUTTER) * colNum); dmh_yoffset = (dmh_pageHeight * 0.5) + (boxEdge * 1.5) + MULTIPLOTGUTTER - (boxEdge * (rowNum+1)) - (MULTIPLOTGUTTER * rowNum); dmh_xscale = boxEdge; dmh_yscale = boxEdge; DEBUGPRINT(("End pspltrgn. boxEdge=%i; r,c=(%i,%i); scale=(%f, %f); offset=(%f, %f); DevPtRange=(%f,%f)-(%f,%f).\n", boxEdge, rowNum, colNum, dmh_xscale, dmh_yscale, dmh_xoffset, dmh_yoffset,deviceX(0), deviceY(0), deviceX(1), deviceY(1))); }
static void gtk_css_image_builtin_draw_arrow (GtkCssImage *image, cairo_t *cr, double width, double height, GtkCssImageBuiltinType image_type) { GtkCssImageBuiltin *builtin = GTK_CSS_IMAGE_BUILTIN (image); double line_width; double size; size = MIN (width, height); cairo_translate (cr, width / 2.0, height / 2.0); switch (image_type) { case GTK_CSS_IMAGE_BUILTIN_ARROW_UP: break; case GTK_CSS_IMAGE_BUILTIN_ARROW_DOWN: cairo_rotate (cr, G_PI); break; case GTK_CSS_IMAGE_BUILTIN_ARROW_LEFT: cairo_rotate (cr, 3 * G_PI / 2); break; case GTK_CSS_IMAGE_BUILTIN_ARROW_RIGHT: cairo_rotate (cr, G_PI / 2); break; default: g_assert_not_reached (); break; } line_width = size / 3.0 / sqrt (2); cairo_set_line_width (cr, line_width); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); cairo_scale (cr, (size / (size + line_width)), (size / (size + line_width))); cairo_move_to (cr, -size / 2.0, size / 4.0); cairo_rel_line_to (cr, size / 2.0, -size / 2.0); cairo_rel_line_to (cr, size / 2.0, size / 2.0); gdk_cairo_set_source_rgba (cr, &builtin->fg_color); cairo_stroke (cr); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_translate (cr, PAD, PAD); /* First compress the pen to a vertical line. */ cairo_rectangle (cr, 0, 0, SIZE, SIZE); cairo_curve_to (cr, SIZE / 2, 0, SIZE, SIZE / 2, SIZE, SIZE); cairo_save (cr); { cairo_scale (cr, 0.000001, 1.0); cairo_stroke (cr); } cairo_restore (cr); cairo_translate (cr, PAD + SIZE, 0); /* Then compress the pen to a horizontal line. */ cairo_rectangle (cr, 0, 0, SIZE, SIZE); cairo_curve_to (cr, SIZE / 2, 0, SIZE, SIZE / 2, SIZE, SIZE); cairo_save (cr); { cairo_scale (cr, 1.0, 0.000001); cairo_stroke (cr); } cairo_restore (cr); cairo_translate (cr, PAD + SIZE, 0); /* Finally a line at an angle. */ cairo_rectangle (cr, 0, 0, SIZE, SIZE); cairo_curve_to (cr, SIZE / 2, 0, SIZE, SIZE / 2, SIZE, SIZE); cairo_save (cr); { cairo_rotate (cr, M_PI / 4.0); cairo_scale (cr, 0.000001, 1.0); cairo_stroke (cr); } cairo_restore (cr); return CAIRO_TEST_SUCCESS; }
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 node_store_print_items (NodeStore *store, cairo_t *cr, SchematicPrintContext *ctx) { GList *list; ItemData *data; g_return_if_fail (store != NULL); g_return_if_fail (IS_NODE_STORE (store)); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); for (list = store->items; list; list = list->next) { data = ITEM_DATA (list->data); item_data_print (data, cr, ctx); } g_hash_table_foreach (store->nodes, (GHFunc)draw_dot, cr); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { const double dashes[] = { 25, 25 }; cairo_line_join_t joins[] = { CAIRO_LINE_JOIN_ROUND, CAIRO_LINE_JOIN_MITER, CAIRO_LINE_JOIN_BEVEL }; cairo_line_cap_t caps[] = { CAIRO_LINE_CAP_ROUND, CAIRO_LINE_CAP_SQUARE, CAIRO_LINE_CAP_BUTT, }; int i, j; cairo_set_source_rgb (cr, 1,1,1); cairo_paint (cr); cairo_set_source_rgb (cr, 1, 0, 0); cairo_set_dash (cr, dashes, 2, 0.); cairo_set_line_width (cr, 10); cairo_translate (cr, 5 + PAD, 5 + PAD); for (i = 0; i < ARRAY_LENGTH (joins); i++) { cairo_set_line_join (cr, joins[i]); cairo_save (cr); for (j = 0; j < ARRAY_LENGTH (caps); j++) { cairo_set_line_cap (cr, caps[j]); cairo_move_to (cr, 0, 0); cairo_line_to (cr, 50, 0); cairo_line_to (cr, 50,50); cairo_stroke (cr); cairo_translate (cr, 75, 0); } cairo_restore (cr); cairo_translate (cr, 0, 75); } return CAIRO_TEST_SUCCESS; }
void gimp_display_shell_set_pen_style (GimpDisplayShell *shell, cairo_t *cr, const GimpRGB *color, gint width) { g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); g_return_if_fail (cr != NULL); g_return_if_fail (color != NULL); cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); cairo_set_line_width (cr, width); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); gimp_cairo_set_source_rgb (cr, color); }
static void _adg_apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr) { AdgLineStylePrivate *data = ((AdgLineStyle *) style)->data; adg_entity_apply_dress(entity, data->color_dress, cr); cairo_set_line_width(cr, data->width); cairo_set_line_cap(cr, data->cap); cairo_set_line_join(cr, data->join); cairo_set_miter_limit(cr, data->miter_limit); cairo_set_antialias(cr, data->antialias); if (data->dash != NULL) { cairo_set_dash(cr, adg_dash_get_dashes(data->dash), adg_dash_get_num_dashes(data->dash), adg_dash_get_offset(data->dash)); } }
void GraphicsContext::setLineJoin(LineJoin lineJoin) { if (paintingDisabled()) return; cairo_line_join_t cairoJoin = CAIRO_LINE_JOIN_MITER; switch (lineJoin) { case MiterJoin: // no-op break; case RoundJoin: cairoJoin = CAIRO_LINE_JOIN_ROUND; break; case BevelJoin: cairoJoin = CAIRO_LINE_JOIN_BEVEL; break; } cairo_set_line_join(platformContext()->cr(), cairoJoin); }
GtGraphics* gt_graphics_cairo_new_from_context(cairo_t *context, unsigned int width, unsigned int height) { GtGraphics *g; GtGraphicsCairo *gc; g = gt_graphics_create(gt_graphics_cairo_class()); gc = gt_graphics_cairo_cast(g); gc->width = width; gc->height = height; gc->margin_x = gc->margin_y = 20; gc->from_context = true; gc->cr = context; cairo_set_line_join(context, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap(context, CAIRO_LINE_CAP_ROUND); cairo_select_font_face(context, "sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); return g; }
void draw_roads(struct ScreenContext *screenContext) { struct Item *anEntry; struct RGBO fillColor; fillColor.red = 255; fillColor.green = 255; fillColor.blue = 255; fillColor.opacity = 255; cairo_set_line_join(screenContext->cr_on_canvas, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap(screenContext->cr_on_canvas, CAIRO_LINE_CAP_BUTT); anEntry = screenContext->roads.head; while(anEntry != NULL) { draw_single_road(screenContext, screenContext->cr_on_canvas, anEntry->datap, &fillColor); anEntry = anEntry->next; } }
void draw_stroke(caskbench_context_t *ctx, kinetics_t *particles) { int i, r,j; int w, h; double x,y; cairo_t *cr = ctx->cairo_cr; for (j=0; j<num_y_elements; j++) { y = particles?particles->y : j * element_spacing; cairo_set_line_join(cr,(cairo_line_join_t)(j % 3)); for (i=0; i<num_x_elements; i++) { x = particles?particles->x : i * element_spacing; cairo_set_line_cap(cr,(cairo_line_cap_t)(i % 3)); cairoRandomizeColor(ctx); drawShape(ctx,x,y); cairo_stroke (cr); } } }
/* At one point, an optimization was proposed for cairo in which a * curve_to would be optimized as a line_to. The initial (buggy) * implementation verified that the slopes of several segments of the * spline's control polygon were identical, but left open the * possibility of an anti-parallel slope for one segment. * * For example, given a spline with collinear control points (A,B,C,D) * positioned as follows: * * C--A--B--D * * The code verified identical slopes for AB, CD, and AD. The missing * check for the BC segment allowed it to be anti-parallel to the * others as above, and hence invalid to replace this spline with the * AD line segment. */ static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */ cairo_paint (cr); cairo_set_line_width (cr, 1.0); cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL); cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ cairo_translate (cr, 0, 1.0); /* The CABD spline as described above. We ensure that the spline * folds over on itself outside the bounds of the image to avoid * the reference image having the curved portion of that fold, * (which would just be harder to match in all the backends than * we really want). */ cairo_move_to (cr, 10.5, 0.5); cairo_curve_to (cr, 11.5, 0.5, -25.0, 0.5, 31.0, 0.5); cairo_stroke (cr); cairo_translate (cr, 0, 2.0); /* A reflected version: DBAC */ cairo_move_to (cr, 19.5, 0.5); cairo_curve_to (cr, 18.5, 0.5, 55.0, 0.5, -1.0, 0.5); cairo_stroke (cr); return CAIRO_TEST_SUCCESS; }
void xor_gate_glyph(cairo_t *cr) { static cairo_pattern_t *pat = 0; cairo_save(cr); cairo_translate(cr,0.04,0); cairo_scale(cr,0.8,0.8); if(pat == 0) { pat = cairo_pattern_create_radial (0.35, 0.3, 0.08, 0.2, 0.35, 0.6); cairo_pattern_add_color_stop_rgb (pat, 0, 0.9, 0.9, 0.9); cairo_pattern_add_color_stop_rgb (pat, 1, 0.68, 0.68, 1.0); } cairo_new_path(cr); cairo_move_to(cr,0,0); cairo_arc(cr,-0.5,0.5,sqrt(2.0)/2,-M_PI/4,M_PI/4); cairo_line_to(cr,0.5,1.0); cairo_save(cr); cairo_scale(cr,0.85,2.0); double angle = asin(3.0/4); cairo_arc_negative(cr,0.5,-0.5,1.0,M_PI/2,angle); cairo_arc_negative(cr,0.5,1.0,1.0,-angle,-M_PI/2); cairo_restore(cr); cairo_close_path(cr); cairo_set_source (cr, pat); cairo_fill_preserve (cr); cairo_set_source_rgb(cr,0.0,0.0,0.0); cairo_set_line_width(cr,0.07); cairo_set_line_join(cr,CAIRO_LINE_JOIN_ROUND); cairo_stroke(cr); cairo_new_path(cr); cairo_move_to(cr,-0.12,0); cairo_arc(cr,-0.62,0.5,sqrt(2.0)/2,-M_PI/4,M_PI/4); cairo_set_line_cap(cr,CAIRO_LINE_CAP_ROUND); cairo_stroke(cr); cairo_restore(cr); }
void crossover_cell_glyph(cairo_t *cr) { static cairo_pattern_t *pat = 0; cairo_save(cr); cairo_scale(cr,0.8,0.8); if(pat == 0) { pat = cairo_pattern_create_radial (0.27, 0.3, 0.08, 0.2, 0.35, 0.6); cairo_pattern_add_color_stop_rgb (pat, 0, 0.9, 0.9, 0.9); cairo_pattern_add_color_stop_rgb (pat, 1, 0.8, 0.5, 0.8); } cairo_new_path(cr); #ifdef CROSSOVER_DIAMOND cairo_move_to(cr,0.5,0.0); cairo_line_to(cr,0.0,0.5); cairo_line_to(cr,0.5,1.0); cairo_line_to(cr,1.0,0.5); #else cairo_arc(cr,0.5,0.5,0.5,0,M_PI*2); #endif cairo_close_path(cr); cairo_set_source (cr, pat); cairo_fill_preserve (cr); cairo_set_source_rgb(cr,0.0,0.0,0.0); cairo_set_line_width(cr,0.07); cairo_set_line_join(cr,CAIRO_LINE_JOIN_ROUND); cairo_stroke(cr); #ifndef CROSSOVER_DIAMOND cairo_move_to(cr,0.5+sqrt(2.0)/4.0,0.5+sqrt(2.0)/4.0); cairo_line_to(cr,0.5-sqrt(2.0)/4.0,0.5-sqrt(2.0)/4.0); cairo_move_to(cr,0.5-sqrt(2.0)/4.0,0.5+sqrt(2.0)/4.0); cairo_line_to(cr,0.5+sqrt(2.0)/4.0,0.5-sqrt(2.0)/4.0); cairo_stroke(cr); #endif cairo_restore(cr); }
void draw_overlay(cairo_surface_t *cs,float *data){ int i; cairo_t *c = cairo_create(cs); cairo_set_source_rgba(c,COLOR); cairo_set_line_cap(c,CAIRO_LINE_CAP_ROUND); cairo_set_line_join(c,CAIRO_LINE_JOIN_ROUND); cairo_set_line_width(c,LINE_WIDTH); for(i=0;i<W;i++){ double y = data[i]*WH+CR; if(i==0) cairo_move_to(c,i,y); else cairo_line_to(c,i,y); } cairo_stroke(c); cairo_destroy(c); }
static void pens(const char *cmd) { cairo_surface_t *buf, *cbuf, *t; cairo_t *ctx; char str[CURSOR_STRING_MAX]; Theme q; sscanf(cmd, "%*s %lf %lf %lf %lf %lf %s\n", &q.R, &q.G, &q.B, &q.A, &q.e, str); XWarpPointer(dpy, None, wshow, 0, 0, 0, 0, sw/2, sh/2); /* create duplicate buffers */ t = cairo_xlib_surface_create(dpy, wshow, vis, sw, sh); buf = cairo_surface_create_similar(t, CAIRO_CONTENT_COLOR, sw, sh); cbuf = cairo_surface_create_similar(t, CAIRO_CONTENT_COLOR, sw, sh); ctx = cairo_create(cbuf); cairo_set_source_surface(ctx, t, 0, 0); cairo_paint(ctx); cairo_destroy(ctx); ctx = cairo_create(buf); cairo_set_source_surface(ctx, t, 0, 0); cairo_paint(ctx); cairo_surface_destroy(t); /* set drawing parameters */ cairo_set_line_join(ctx, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap(ctx, CAIRO_LINE_CAP_ROUND); cairo_set_source_rgba(ctx, q.R, q.G, q.B, q.A); cairo_set_line_width(ctx, q.e); // set font cairo_set_font_size(ctx, q.e); grab_mouse(); /* call appropriate sub function */ cairo_move_to(ctx, sw/2, sh/2); if (strncasecmp(cmd,"pen",3)==0) pen(ctx, buf, cbuf, &q); else if (strncasecmp(cmd,"dot",3)==0) dot(ctx, buf, cbuf, &q); else if (strncasecmp(cmd,"cust",4)==0) custom(ctx, buf, cbuf, &q, str); else if (strncasecmp(cmd,"zoom",4)==0) zoom(ctx, buf, cbuf, &q); /* clean up */ XUngrabPointer(dpy, CurrentTime); cairo_surface_destroy(buf); cairo_surface_destroy(cbuf); cairo_destroy(ctx); XDefineCursor(dpy, wshow, invisible_cursor); }
void Figure::paint (cairo_t * cr, bool fill, bool crop) { double real_h = w() * (top()-bottom()) / (right()-left()); double wd = right()-left(), mid_x = (right()+left())/2; double ht = top()-bottom(), mid_y = (top()+bottom())/2; double scale_x = w()/wd, scale_y = (crop ? real_h : h())/ht; double scale = std::min(scale_x,scale_y); if (ortho) scale_x = scale_y = scale; basewidth = 1.0/scale; if (fill) { cairo_save(cr); cairo_set_source_rgb (cr, 1,1,1); cairo_paint(cr); cairo_restore(cr); } cairo_save(cr); cairo_translate (cr, w()/2, (crop ? real_h : h())/2); cairo_scale (cr, scale_x*.98, -scale_y*.98); // A tiny margin for stoke width. cairo_translate (cr, -mid_x,-mid_y); cairo_set_line_width (cr, basewidth); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); for (const auto & i : contents) { cairo_save(cr); cairo_set_source_rgb (cr, i->p.c.r/255.0, i->p.c.g/255.0, i->p.c.b/255.0); cairo_set_line_width (cr, basewidth * i->p.w); i->draw(cr); if (i->p.ff) { cairo_stroke_preserve(cr); cairo_set_source_rgba (cr, i->p.f.r/255.0, i->p.f.g/255.0, i->p.f.b/255.0, i->p.f.a/255.0); cairo_fill(cr); } cairo_stroke(cr); cairo_restore(cr); } cairo_restore(cr); }