/**
@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);
}
