//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 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 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;
}