//pen dash
static void do_drawing(cairo_t *cr)
{
cairo_set_source_rgba(cr, 0, 0, 0, 1);
static const double dashed1[] = {4.0, 21.0, 2.0};
static int len1 = sizeof(dashed1) / sizeof(dashed1[0]);
static const double dashed2[] = {14.0, 6.0};
static int len2 = sizeof(dashed2) / sizeof(dashed2[0]);
static const double dashed3[] = {1.0};
cairo_set_line_width(cr, 1.5);
cairo_set_dash(cr, dashed1, len1, 0);
cairo_move_to(cr, 40, 30);
cairo_line_to(cr, 200, 30);
cairo_stroke(cr);
cairo_set_dash(cr, dashed2, len2, 1);
cairo_move_to(cr, 40, 50);
cairo_line_to(cr, 200, 50);
cairo_stroke(cr);
cairo_set_dash(cr, dashed3, 1, 0);
cairo_move_to(cr, 40, 70);
cairo_line_to(cr, 200, 70);
cairo_stroke(cr);
}
/**
* uber_line_graph_stylize_line:
* @graph: A #UberLineGraph.
*
* XXX
*
* Returns: None.
* Side effects: None.
*/
static void
uber_line_graph_stylize_line (UberLineGraph *graph, /* IN */
LineInfo *info, /* IN */
cairo_t *cr) /* IN */
{
UberLineGraphPrivate *priv;
g_return_if_fail(UBER_IS_LINE_GRAPH(graph));
g_return_if_fail(info != NULL);
priv = graph->priv;
if (info->dashes) {
cairo_set_dash(cr, info->dashes, info->num_dashes, info->dash_offset);
} else {
cairo_set_dash(cr, NULL, 0, 0);
}
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_width(cr, info->width);
cairo_set_antialias(cr, priv->antialias);
cairo_set_source_rgba(cr,
info->color.red / 65535.,
info->color.green / 65535.,
info->color.blue / 65535.,
info->alpha);
}
void iupDrawPolygon(IdrawCanvas* dc, int* points, int count, unsigned char r, unsigned char g, unsigned char b, int style)
{
int i;
cairo_set_source_rgba(dc->image_cr, iupCOLOR8ToDouble(r),
iupCOLOR8ToDouble(g),
iupCOLOR8ToDouble(b),
1.0);
if (style!=IUP_DRAW_FILL)
{
if (style==IUP_DRAW_STROKE_DASH)
{
double dashes[2];
dashes[0] = 6.0; dashes[1] = 2.0;
cairo_set_dash(dc->image_cr, dashes, 2, 0);
}
else
cairo_set_dash(dc->image_cr, 0, 0, 0);
}
cairo_move_to(dc->image_cr, points[0], points[1]);
for (i=0; i<count; i++)
cairo_line_to(dc->image_cr, points[2*i], points[2*i+1]);
if (style==IUP_DRAW_FILL)
cairo_fill(dc->image_cr);
else
cairo_stroke(dc->image_cr);
}
int renderLineCairo(imageObj *img, shapeObj *p, strokeStyleObj *stroke) {
int i,j;
cairo_renderer *r = CAIRO_RENDERER(img);
assert(stroke->color);
cairo_new_path(r->cr);
msCairoSetSourceColor(r->cr,stroke->color);
for(i=0;i<p->numlines;i++) {
lineObj *l = &(p->line[i]);
cairo_move_to(r->cr,l->point[0].x,l->point[0].y);
for(j=1;j<l->numpoints;j++) {
cairo_line_to(r->cr,l->point[j].x,l->point[j].y);
}
}
if(stroke->patternlength>0) {
cairo_set_dash(r->cr,stroke->pattern,stroke->patternlength,0);
}
switch(stroke->linecap) {
case MS_CJC_BUTT:
cairo_set_line_cap(r->cr,CAIRO_LINE_CAP_BUTT);
break;
case MS_CJC_SQUARE:
cairo_set_line_cap(r->cr,CAIRO_LINE_CAP_SQUARE);
break;
case MS_CJC_ROUND:
case MS_CJC_NONE:
default:
cairo_set_line_cap(r->cr,CAIRO_LINE_CAP_ROUND);
}
cairo_set_line_width (r->cr, stroke->width);
cairo_stroke (r->cr);
if(stroke->patternlength>0) {
cairo_set_dash(r->cr,stroke->pattern,0,0);
}
return MS_SUCCESS;
}
void draw_links(struct ScreenContext *screenContext)
{
struct Item *anEntry;
struct RGBO fillColor;
double dashes[]={4.0, 4.0};
int ndash = sizeof(dashes)/sizeof(dashes[0]);
double offset = -10.0;
fillColor.red = 255;
fillColor.green = 0;
fillColor.blue = 0;
fillColor.opacity = 255;
cairo_set_line_join(screenContext->cr_on_screen, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap(screenContext->cr_on_screen, CAIRO_LINE_CAP_BUTT);
cairo_set_dash(screenContext->cr_on_screen, dashes, ndash, offset);
anEntry = screenContext->links.head;
while(anEntry != NULL) {
draw_single_road(screenContext, screenContext->cr_on_screen, anEntry->datap, &fillColor);
anEntry = anEntry->next;
}
cairo_set_dash(screenContext->cr_on_screen, dashes, 0, offset);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
double dashes[2] = {20, 20};
int a=0, b=0, c=0;
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_paint (cr);
for (a=0; a<4; a++)
for (b=0; b<5; b++)
for (c=0; c<5; c++) {
cairo_move_to (cr, ((b*5)+c)*60+10, a*60+10);
cairo_rel_line_to (cr, 0, b*10);
cairo_rel_line_to (cr, c*10, 0);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_set_line_width (cr, 8);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
cairo_set_dash (cr, dashes, 2, a*10);
cairo_stroke_preserve (cr);
cairo_set_source_rgb (cr, 0, 0.5, 1);
cairo_set_line_width (cr, 2);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
cairo_set_dash (cr, 0, 0, 0);
cairo_stroke (cr);
}
return CAIRO_TEST_SUCCESS;
}
void GraphicsContext::setPlatformStrokeStyle(StrokeStyle strokeStyle)
{
static double dashPattern[] = {5.0, 5.0};
static double dotPattern[] = {1.0, 1.0};
if (paintingDisabled())
return;
switch (strokeStyle) {
case NoStroke:
// FIXME: is it the right way to emulate NoStroke?
cairo_set_line_width(platformContext()->cr(), 0);
break;
case SolidStroke:
#if ENABLE(CSS3_TEXT_DECORATION)
case DoubleStroke:
case WavyStroke: // FIXME: https://bugs.webkit.org/show_bug.cgi?id=94110 - Needs platform support.
#endif // CSS3_TEXT_DECORATION
cairo_set_dash(platformContext()->cr(), 0, 0, 0);
break;
case DottedStroke:
cairo_set_dash(platformContext()->cr(), dotPattern, 2, 0);
break;
case DashedStroke:
cairo_set_dash(platformContext()->cr(), dashPattern, 2, 0);
break;
}
}
void
gnm_style_border_set_dash (GnmStyleBorderType const i,
cairo_t *context)
{
GdkLineStyle style = GDK_LINE_SOLID;
int w;
g_return_if_fail (context != NULL);
g_return_if_fail (i >= GNM_STYLE_BORDER_NONE);
g_return_if_fail (i < GNM_STYLE_BORDER_MAX);
if (style_border_data[i].pattern != NULL)
style = GDK_LINE_ON_OFF_DASH;
w = style_border_data[i].width;
if (w == 0)
w = 1;
cairo_set_line_width (context,((double) w));
if (style_border_data[i].pattern != NULL) {
struct LineDotPattern const * const pat =
style_border_data[i].pattern;
cairo_set_dash (context, pat->pattern_d, pat->elements,
style_border_data[i].offset);
} else
cairo_set_dash (context, NULL, 0, 0);
}
void iupDrawRectangle(IdrawCanvas* dc, int x1, int y1, int x2, int y2, unsigned char r, unsigned char g, unsigned char b, int style)
{
cairo_set_source_rgba(dc->image_cr, iupCOLOR8ToDouble(r),
iupCOLOR8ToDouble(g),
iupCOLOR8ToDouble(b),
1.0);
if (style==IUP_DRAW_FILL)
{
cairo_rectangle(dc->image_cr, x1, y1, x2-x1+1, y2-y1+1);
cairo_fill(dc->image_cr);
}
else
{
if (style==IUP_DRAW_STROKE_DASH)
{
double dashes[2];
dashes[0] = 6.0; dashes[1] = 2.0;
cairo_set_dash(dc->image_cr, dashes, 2, 0);
}
else
cairo_set_dash(dc->image_cr, 0, 0, 0);
cairo_rectangle(dc->image_cr, x1, y1, x2-x1, y2-y1); /* outlined rectangle is actually of size w+1,h+1 */
cairo_stroke(dc->image_cr);
}
}
void GraphicsContext::setPlatformStrokeStyle(const StrokeStyle& strokeStyle)
{
static double dashPattern[] = {5.0, 5.0};
static double dotPattern[] = {1.0, 1.0};
if (paintingDisabled())
return;
switch (strokeStyle) {
case NoStroke:
// FIXME: is it the right way to emulate NoStroke?
cairo_set_line_width(m_data->cr, 0);
break;
case SolidStroke:
cairo_set_dash(m_data->cr, 0, 0, 0);
break;
case DottedStroke:
cairo_set_dash(m_data->cr, dotPattern, 2, 0);
break;
case DashedStroke:
cairo_set_dash(m_data->cr, dashPattern, 2, 0);
break;
default:
notImplemented();
break;
}
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const double dashes_1[] = { 10, 0 };
const double dashes_2[] = { 10, 0, 10, 10};
const double dashes_3[] = { 10, 0, 10, 0};
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, 6);
cairo_set_dash (cr, NULL, 0, 0);
cairo_rectangle (cr, 10, 10, 30, 30);
cairo_stroke (cr);
cairo_translate (cr, 50, 0);
cairo_set_dash (cr, dashes_1, 2, 0);
cairo_rectangle (cr, 10, 10, 30, 30);
cairo_stroke (cr);
cairo_translate (cr, 0, 50);
cairo_set_dash (cr, dashes_2, 4, 0);
cairo_rectangle (cr, 10, 10, 30, 30);
cairo_stroke (cr);
cairo_translate (cr, -50, 0);
cairo_set_dash (cr, dashes_3, 4, 0);
cairo_rectangle (cr, 10, 10, 30, 30);
cairo_stroke (cr);
return CAIRO_TEST_SUCCESS;
}
void render_track_crossing(sem_render_context* ctx, sem_coordinate coord, sem_track* track) {
render_track_path(ctx, coord, track);
cairo_set_line_width(ctx->cr, ctx->style->track_crossing_width);
const double dash[] = {0.2, 0.1};
cairo_set_dash(ctx->cr, dash, 2, -0.1);
cairo_stroke(ctx->cr);
cairo_set_dash(ctx->cr, dash, 0, 0);
}
static void
overlay_draw (GtkDrawingArea *da,
cairo_t *cr,
int width,
int height,
gpointer data)
{
GtkWidget *widget = GTK_WIDGET (da);
PangoLayout *layout;
const double dashes[] = { 6, 18 };
GtkAllocation label_allocation;
GtkRequisition minimum_size, natural_size;
GtkWidget *label = data;
gint x, y;
cairo_translate (cr, -0.5, -0.5);
cairo_set_line_width (cr, 1);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_rectangle (cr, 0, 0, width, height);
cairo_fill (cr);
gtk_widget_translate_coordinates (label, widget, 0, 0, &x, &y);
layout = gtk_widget_create_pango_layout (widget, "");
gtk_widget_get_preferred_size (label, &minimum_size, &natural_size);
pango_layout_set_markup (layout,
"<span color='#c33'>\342\227\217 requisition</span>\n"
"<span color='#3c3'>\342\227\217 natural size</span>\n"
"<span color='#33c'>\342\227\217 allocation</span>", -1);
pango_cairo_show_layout (cr, layout);
g_object_unref (layout);
gtk_widget_get_allocation (label, &label_allocation);
cairo_rectangle (cr,
x + 0.5 * (label_allocation.width - minimum_size.width),
y + 0.5 * (label_allocation.height - minimum_size.height),
minimum_size.width, minimum_size.height);
cairo_set_source_rgb (cr, 0.8, 0.2, 0.2);
cairo_set_dash (cr, NULL, 0, 0);
cairo_stroke (cr);
cairo_rectangle (cr, x, y, label_allocation.width, label_allocation.height);
cairo_set_source_rgb (cr, 0.2, 0.2, 0.8);
cairo_set_dash (cr, dashes, 2, 0.5);
cairo_stroke (cr);
cairo_rectangle (cr,
x + 0.5 * (label_allocation.width - natural_size.width),
y + 0.5 * (label_allocation.height - natural_size.height),
natural_size.width, natural_size.height);
cairo_set_source_rgb (cr, 0.2, 0.8, 0.2);
cairo_set_dash (cr, dashes, 2, 12.5);
cairo_stroke (cr);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
double dashes[] = { 1 };
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
cairo_set_line_width (cr, 2);
/* Basic 1-1 dash pattern */
cairo_set_dash (cr, dashes, 1, 0.);
cairo_move_to (cr, 1, 2);
cairo_line_to (cr, 18, 2);
cairo_stroke (cr);
/* Adjust path by 0.5. Ideally this would give a constant 50%
* gray, (but does not due to the location of the regular sample
* grid points. */
cairo_move_to (cr, 1.5, 5);
cairo_line_to (cr, 18., 5);
cairo_stroke (cr);
/* Offset dash by 0.5, rather than the path */
cairo_set_dash (cr, dashes, 1, 0.5);
cairo_move_to (cr, 1, 8);
cairo_line_to (cr, 18, 8);
cairo_stroke (cr);
/* Now, similar tests with negative dash offsets. */
/* Basic 1-1 dash pattern dashing */
cairo_set_dash (cr, dashes, 1, -4);
cairo_move_to (cr, 1, 11);
cairo_line_to (cr, 18, 11);
cairo_stroke (cr);
/* Adjust path by 0.5 */
cairo_move_to (cr, 1.5, 14);
cairo_line_to (cr, 18., 14);
cairo_stroke (cr);
/* Offset dash by 0.5 */
cairo_set_dash (cr, dashes, 1, -3.5);
cairo_move_to (cr, 1, 17);
cairo_line_to (cr, 18, 17);
cairo_stroke (cr);
return CAIRO_TEST_SUCCESS;
}
void distance_get_linestyle ( Distance d, cairo_t *draw )
{
if ( d.style == DASH ) {
const double dashes[1] = { 4 };
cairo_set_dash ( draw, dashes, 1, 0.0 );
}
else {
cairo_set_dash ( draw, NULL, 0, 0.0 );
}
}
void
Grid::PostRender (Context *ctx, Region *region, bool skip_children)
{
// render our chidren if we need to
if (!skip_children) {
VisualTreeWalker walker = VisualTreeWalker (this, ZForward, false);
while (UIElement *child = walker.Step ())
child->DoRender (ctx, region);
}
if (GetShowGridLines () && ctx->IsMutable ()) {
double offset = 0;
double dash = 4;
ColumnDefinitionCollection *cols = GetColumnDefinitionsNoAutoCreate ();
RowDefinitionCollection *rows = GetRowDefinitionsNoAutoCreate ();
cairo_t *cr = ctx->Cairo ();
int col_count = cols ? cols->GetCount () : 0;
int row_count = rows ? rows->GetCount () : 0;
cairo_save (cr);
RenderLayoutClip (cr);
cairo_set_line_width(cr, 1.0);
// Initially render a blue color
cairo_set_dash (cr, &dash, 1, offset);
cairo_set_source_rgb (cr, 0.4, 0.4, 1.0);
cairo_new_path (cr);
// Draw gridlines between each pair of columns/rows
for (int count = 0; count < 2; count++) {
for (int i = 0, offset = 0; i < col_count - 1; i++) {
ColumnDefinition *def = cols->GetValueAt (i)->AsColumnDefinition ();
offset += def->GetActualWidth ();
cairo_move_to (cr, offset, 0);
cairo_line_to (cr, offset, GetActualHeight ());
}
for (int i = 0, offset = 0; i < row_count - 1; i++) {
RowDefinition *def = rows->GetValueAt (i)->AsRowDefinition ();
offset += def->GetActualHeight ();
cairo_move_to (cr, 0, offset);
cairo_line_to (cr, GetActualWidth (), offset);
}
cairo_stroke (cr);
// For the second pass render a yellow color in the gaps between the previous dashes
cairo_set_dash (cr, &dash, 1, dash);
cairo_set_source_rgb (cr, 1.0, 1.0, 0.3);
}
cairo_restore (cr);
}
// Chain up, but skip children since we've already rendered them here.
UIElement::PostRender (ctx, region, true);
}
void iupDrawArc(IdrawCanvas* dc, int x1, int y1, int x2, int y2, double a1, double a2, unsigned char r, unsigned char g, unsigned char b, int style)
{
int xc, yc, w, h;
cairo_set_source_rgba(dc->image_cr, iupCOLOR8ToDouble(r),
iupCOLOR8ToDouble(g),
iupCOLOR8ToDouble(b),
1.0);
if (style!=IUP_DRAW_FILL)
{
if (style==IUP_DRAW_STROKE_DASH)
{
double dashes[2];
dashes[0] = 6.0; dashes[1] = 2.0;
cairo_set_dash(dc->image_cr, dashes, 2, 0);
}
else
cairo_set_dash(dc->image_cr, 0, 0, 0);
}
w = x2-x1+1;
h = y2-y1+1;
xc = x1 + w/2;
yc = y1 + h/2;
if (w == h)
{
cairo_arc(dc->image_cr, xc, yc, 0.5*w, a1, a2);
if (style==IUP_DRAW_FILL)
cairo_fill(dc->image_cr);
else
cairo_stroke(dc->image_cr);
}
else /* Ellipse: change the scale to create from the circle */
{
cairo_save(dc->image_cr); /* save to use the local transform */
cairo_translate(dc->image_cr, xc, yc);
cairo_scale(dc->image_cr, w/h, 1.0);
cairo_translate(dc->image_cr, -xc, -yc);
cairo_arc(dc->image_cr, xc, yc, 0.5*h, a1, a2);
if (style==IUP_DRAW_FILL)
cairo_fill(dc->image_cr);
else
cairo_stroke(dc->image_cr);
cairo_restore(dc->image_cr); /* restore from local */
}
}
static void
draw_crosses(cairo_t *cr, gint width, gint height)
{
gint x, y;
gdouble dash[4] = { 7., grid_height - 7., 7., grid_width - 7. };
cairo_set_dash (cr, dash, 2, 4.5 - grid_top);
for (x = grid_left % grid_width; x < width; x += grid_width)
draw_line(cr, x, 1, x, height);
cairo_set_dash (cr, dash+2, 2, 4.5 - grid_left);
for (y = grid_top % grid_height; y < height; y += grid_height)
draw_line(cr, 1, y, width, y);
}
static int
VGUI_begin(void) {
//printf("VGUI_begin\n");
if (vdevice.bgnmode == VLINE) {
/* Dash transfer was shamelessly copied from the VOGL X11.c driver... */
//65535=solid
if (VGUI.line_style != 0xffff) {
double dashes[16];
int i, n, a, b;
for (i = 0; i < 16; i++) dashes[i] = 0;
for (i = 0; i < 16; i++) /* Over 16 bits */
if ((VGUI.line_style & (1 << i))) break;
#define ON 1
#define OFF 0
a = b = OFF;
if (VGUI.line_style & (1 << 0)) a = b = ON;
n = 0;
for (i = 0; i < 16; i++) { /* Over 16 bits */
if (VGUI.line_style & (1 << i)) a = ON;
else a = OFF;
if (a != b) {
b = a;
n++;
}
dashes[n]++;
}
n++;
#undef ON
#undef OFF
cairo_set_dash (VGUI.cr,dashes,n,0);
} else {
/* Solid lines are the default anyway */
gdk_threads_enter();
cairo_set_dash (VGUI.cr,NULL,0,0);
gdk_threads_leave();
}
gdk_cairo_set_source_rgba(VGUI.cr,&VGUI.palette[VGUI.fg]);
cairo_set_line_width(VGUI.cr,VGUI.line_width);
VGUI.draw_lastx=VGUI.draw_lasty= -1;
}
return (1);
};
static void cairogen_set_penstyle(GVJ_t *job, cairo_t *cr)
{
obj_state_t *obj = job->obj;
if (obj->pen == PEN_DASHED) {
cairo_set_dash (cr, dashed, dashed_len, 0.0);
} else if (obj->pen == PEN_DOTTED) {
cairo_set_dash (cr, dotted, dotted_len, 0.0);
} else {
cairo_set_dash (cr, dashed, 0, 0.0);
}
cairo_set_line_width (cr, obj->penwidth);
}
static int ui_set_dash(lua_State *L)
{
struct context *c = lua_touserdata(L, 1);
// TODO expand api
if (lua_tonumber(L, 2)) {
double dashes[2] = { lua_tonumber(L, 2), lua_tonumber(L, 2) };
cairo_set_dash(c->cr, dashes, 2, 0);
}
else {
cairo_set_dash(c->cr, NULL, 0, 0);
}
return 0;
}
static VALUE
cr_set_dash (int argc, VALUE *argv, VALUE self)
{
VALUE dash_array, rb_offset;
double offset;
cairo_bool_t is_num;
rb_scan_args(argc, argv, "11", &dash_array, &rb_offset);
is_num = rb_cairo__is_kind_of (dash_array, rb_cNumeric);
if (!(NIL_P (dash_array) || is_num))
{
Check_Type (dash_array, T_ARRAY);
}
if (NIL_P (rb_offset))
offset = 0.0;
else
offset = NUM2DBL (rb_offset);
if (is_num)
{
double values[1];
values[0] = NUM2DBL (dash_array);
cairo_set_dash (_SELF, values, 1, offset);
}
else if (NIL_P (dash_array) || RARRAY_LEN (dash_array) == 0)
{
cairo_set_dash (_SELF, NULL, 0, offset);
}
else
{
int i, length;
double *values;
length = RARRAY_LEN (dash_array);
values = ALLOCA_N (double, length);
if (!values)
{
rb_cairo_check_status (CAIRO_STATUS_NO_MEMORY);
}
for (i = 0; i < length; i++)
{
values[i] = NUM2DBL (RARRAY_PTR (dash_array)[i]);
}
cairo_set_dash (_SELF, values, length, offset);
}
cr_check_status (_SELF);
return self;
}
static void
ganv_circle_draw(GanvItem* item,
cairo_t* cr, double cx, double cy, double cw, double ch)
{
GanvNode* node = GANV_NODE(item);
GanvCircle* circle = GANV_CIRCLE(item);
GanvCircleImpl* impl = circle->impl;
double r, g, b, a;
double x = impl->coords.x;
double y = impl->coords.y;
ganv_item_i2w(item, &x, &y);
double dash_length, border_color, fill_color;
ganv_node_get_draw_properties(
&circle->node, &dash_length, &border_color, &fill_color);
cairo_arc(cr,
x,
y,
impl->coords.radius,
0, 2 * G_PI);
// Fill
color_to_rgba(fill_color, &r, &g, &b, &a);
cairo_set_source_rgba(cr, r, g, b, a);
cairo_fill_preserve(cr);
// Border
color_to_rgba(border_color, &r, &g, &b, &a);
cairo_set_source_rgba(cr, r, g, b, a);
cairo_set_line_width(cr, impl->coords.width);
if (dash_length > 0) {
cairo_set_dash(cr, &dash_length, 1, circle->node.impl->dash_offset);
} else {
cairo_set_dash(cr, &dash_length, 0, 0);
}
cairo_stroke(cr);
// Draw label
if (node->impl->label) {
GanvItem* label_item = GANV_ITEM(node->impl->label);
if (label_item->object.flags & GANV_ITEM_VISIBLE) {
GANV_ITEM_GET_CLASS(label_item)->draw(
label_item, cr, cx, cy, cw, ch);
}
}
}
void render_depot(sem_render_context* ctx, sem_coordinate coord, sem_track* track) {
render_track_path(ctx, coord, track);
cairo_set_source_rgb(ctx->cr, 0.0, 0.0, 0.0);
cairo_set_line_width(ctx->cr, ctx->style->depot_back_width);
cairo_stroke_preserve(ctx->cr);
cairo_set_source(ctx->cr, ctx->style->canvas);
cairo_set_line_width(ctx->cr, ctx->style->depot_front_width);
const double dash[] = {0.233, 0.1};
cairo_set_dash(ctx->cr, dash, 2, -0.05);
cairo_stroke(ctx->cr);
cairo_set_dash(ctx->cr, dash, 0, 0);
render_track(ctx, coord, track);
}
static void
set_stroke_params_from_gc(cairo_t *cairo, struct graphics_gc_priv *gc)
{
set_drawing_color(cairo, gc->c);
cairo_set_dash(cairo, gc->dashes, gc->ndashes, gc->offset);
cairo_set_line_width(cairo, gc->linewidth);
}
void LcCairoPainter::set_dash(const double* dashes, const int num_dashes, double offset, bool scaled) {
if (scaled) {
double scaledDashes[num_dashes];
memcpy(&scaledDashes, dashes, num_dashes * sizeof(double));
double _scale = scale();
for (unsigned short c = 0; c < num_dashes; c++) {
scaledDashes[c] = scaledDashes[c] / _scale;
}
cairo_set_dash(_cr, scaledDashes, num_dashes, offset);
} else {
cairo_set_dash(_cr, dashes, num_dashes, offset);
}
}
static gboolean
preview_expose(GtkWidget *widget, GdkEventExpose *event)
{
cairo_t *cr;
gint width = preview_get_width (widget);
gint height = preview_get_height (widget);
cr = gdk_cairo_create (event->window);
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
cairo_set_line_width (cr, 1.);
draw_grid (cr, width, height);
draw_shapes (cr);
if (_tmp_obj)
{
/* this is a bit of a hack */
gdouble dash = 4.;
_tmp_obj->selected |= 4;
cairo_set_source_rgb (cr, 1., 0., 1.);
cairo_set_dash (cr, &dash, 1, dash);
object_draw (_tmp_obj, cr);
}
cairo_destroy (cr);
return FALSE;
}
static PyObject *
pycairo_set_dash (PycairoContext *o, PyObject *args)
{
double *dashes, offset = 0;
int ndash, i;
PyObject *py_dashes;
if (!PyArg_ParseTuple (args, "O|d:Context.set_dash", &py_dashes, &offset))
return NULL;
py_dashes = PySequence_Fast (py_dashes,
"first argument must be a sequence");
if (!py_dashes)
return NULL;
ndash = PySequence_Fast_GET_SIZE(py_dashes);
dashes = malloc (ndash * sizeof(double));
for (i = 0; i < ndash; i++) {
PyObject *item = PySequence_Fast_GET_ITEM(py_dashes, i);
dashes[i] = PyFloat_AsDouble(item);
if (PyErr_Occurred()) {
free (dashes);
Py_DECREF(py_dashes);
return NULL;
}
}
Py_DECREF(py_dashes);
cairo_set_dash (o->ctx, dashes, ndash, offset);
free (dashes);
if (Pycairo_Check_Status (cairo_status (o->ctx)))
return NULL;
Py_RETURN_NONE;
}
void WayRenderer::stroke(cairo_t* cr, AssetCache& cache)
{
if (s->width <= 0.0)
return;
addWayPath(cr);
cairo_save(cr);
setLineCap(cr, s->linecap);
setLineJoin(cr, s->linejoin);
cairo_set_source_rgba(cr, COLOR2RGBA(s->color));
const string& image = s->image.str();
cairo_pattern_t* pattern = NULL;
if (!image.empty()) {
pattern = cairo_pattern_create_for_surface(cache.getImage(image));
cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
cairo_set_source(cr, pattern);
}
if (s->dashes.size() > 0)
cairo_set_dash(cr, s->dashes.data(), s->dashes.size(), 0.0);
cairo_set_line_width(cr, s->width);
cairo_stroke(cr);
if (pattern != NULL)
cairo_pattern_destroy(pattern);
cairo_restore(cr);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
double total;
size_t i, j, k;
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, 2);
total = 0.0;
for (k = 0; k < ARRAY_SIZE(dashes); ++k) {
total += dashes[k];
for (i = 0; i < ARRAY_SIZE(frac_offset); ++i) {
for (j = 0; j < ARRAY_SIZE(int_offset); ++j) {
cairo_set_dash (cr, dashes, k + 1, frac_offset[i] + total * int_offset[j]);
cairo_move_to (cr, (STROKE_LENGTH + PAD) * k + PAD, PAD * (i + j + ARRAY_SIZE(frac_offset) * j + 1));
cairo_line_to (cr, (STROKE_LENGTH + PAD) * (k + 1), PAD * (i + j + ARRAY_SIZE(frac_offset) * j + 1));
cairo_stroke (cr);
}
}
}
return CAIRO_TEST_SUCCESS;
}
