示例#1
0
/***********************************************
 * ge_cairo_linear_shade_gradient_pattern - 
 *  
 *   Create A Linear Shade Gradient Pattern
 *   Aka Smooth Shade Gradient, from/to gradient
 *   With End points defined as shades of the
 *   base color
 ***********************************************/
CairoPattern *
ge_cairo_linear_shade_gradient_pattern(CairoColor *base, 
                                       gdouble shade1, 
                                       gdouble shade2, 
                                       gboolean vertical)
{
	CairoPattern * result = g_new0(CairoPattern, 1);

	if (vertical)
	{
		result->scale = GE_DIRECTION_VERTICAL;

		result->handle = cairo_pattern_create_linear(0, 0, 1, 0);
	}
	else
	{
		result->scale = GE_DIRECTION_HORIZONTAL;

		result->handle = cairo_pattern_create_linear(0, 0, 0, 1);
	}

	result->translate = GE_DIRECTION_BOTH;
	result->operator = CAIRO_OPERATOR_SOURCE;

	ge_cairo_pattern_add_color_stop_shade(result->handle, 0, base, shade1);
	ge_cairo_pattern_add_color_stop_shade(result->handle, 1, base, shade2);

	return result;
}
/***********************************************
 * ge_cairo_linear_shade_gradient_pattern - 
 *  
 *   Create A Linear Shade Gradient Pattern
 *   Aka Smooth Shade Gradient, from/to gradient
 *   With End points defined as shades of the
 *   base color
 ***********************************************/
CairoPattern *
ge_cairo_linear_shade_gradient_pattern(CairoColor *base, 
						gdouble shade1, 
						gdouble shade2, 
						gboolean vertical)
{
	CairoPattern * result = g_new0(CairoPattern, 1);
	
	#if  ((CAIRO_VERSION_MAJOR < 1) || ((CAIRO_VERSION_MAJOR == 1) && (CAIRO_VERSION_MINOR < 2)))
		result->type = CAIRO_PATTERN_TYPE_LINEAR;
	#endif

	if (vertical)
	{
		result->scale = GE_DIRECTION_VERTICAL;

		result->handle = cairo_pattern_create_linear(0, 0, 1, 0);
	}
	else
	{
		result->scale = GE_DIRECTION_HORIZONTAL;

		result->handle = cairo_pattern_create_linear(0, 0, 0, 1);
	}

	result->translate = GE_DIRECTION_BOTH;
	result->operator = CAIRO_OPERATOR_SOURCE;

	ge_cairo_pattern_add_color_stop_shade(result->handle, 0, base, shade1);
	ge_cairo_pattern_add_color_stop_shade(result->handle, 1, base, shade2);

	return result;
}
示例#3
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_pattern_t *pattern;

    cairo_set_source_rgb (cr, 0, 0, 0);
    cairo_paint (cr);

    /* with alpha */
    pattern = cairo_pattern_create_linear (0, 0, 0, height);
    cairo_pattern_add_color_stop_rgba (pattern, 0, 1, 1, 1, .5);
    cairo_pattern_add_color_stop_rgba (pattern, 1, 1, 1, 1, .5);
    cairo_set_source (cr, pattern);
    cairo_pattern_destroy (pattern);
    cairo_rectangle (cr, 0, 0, width/2, height);
    cairo_fill (cr);

    /* without alpha */
    pattern = cairo_pattern_create_linear (0, 0, 0, height);
    cairo_pattern_add_color_stop_rgb (pattern, 0, 1, 1, 1);
    cairo_pattern_add_color_stop_rgb (pattern, 1, 1, 1, 1);
    cairo_set_source (cr, pattern);
    cairo_pattern_destroy (pattern);
    cairo_rectangle (cr, width/2, 0, width/2, height);
    cairo_fill (cr);

    return CAIRO_TEST_SUCCESS;
}
示例#4
0
void _ttk_draw_button_hover(cairo_t * cr, int x, int y, int width, int height) {
	cairo_save(cr);

	cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
	cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);

	cairo_rounded_rectangle(cr, 2 + x, 2 + y, width - 4, height - 4, 2.0);
	cairo_set_source_rgba(cr, 44.0/255.0, 71.0/255.0, 91.0/255.0, 29.0/255.0);
	cairo_set_line_width(cr, 4);
	cairo_stroke(cr);

	cairo_rounded_rectangle(cr, 2 + x, 2 + y, width - 4, height - 4, 2.0);
	cairo_set_source_rgba(cr, 158.0/255.0, 169.0/255.0, 177.0/255.0, 1.0);
	cairo_set_line_width(cr, 2);
	cairo_stroke(cr);

	{
		cairo_pattern_t * pat = cairo_pattern_create_linear(2 + x, 2 + y, 2 + x, 2 + y + height - 4);
		cairo_pattern_add_color_stop_rgba(pat, 0, 1, 1, 1, 1);
		cairo_pattern_add_color_stop_rgba(pat, 1, 229.0/255.0, 229.0/255.0, 246.0/255.0, 1);
		cairo_rounded_rectangle(cr, 2 + x, 2 + y, width - 4, height - 4, 2.0);
		cairo_set_source(cr, pat);
		cairo_fill(cr);
		cairo_pattern_destroy(pat);
	}

	{
		cairo_pattern_t * pat = cairo_pattern_create_linear(3 + x, 3 + y, 3 + x, 3 + y + height - 4);
		cairo_pattern_add_color_stop_rgba(pat, 0, 252.0/255.0, 252.0/255.0, 254.0/255.0, 1);
		cairo_pattern_add_color_stop_rgba(pat, 1, 212.0/255.0, 223.0/255.0, 251.0/255.0, 1);
		cairo_rounded_rectangle(cr, 3 + x, 3 + y, width - 5, height - 5, 2.0);
		cairo_set_source(cr, pat);
		cairo_fill(cr);
		cairo_pattern_destroy(pat);
	}

	{
		cairo_surface_t * surface = cairo_get_target(cr);
		gfx_context_t fake_context = {
			.width = cairo_image_surface_get_width(surface),
			.height = cairo_image_surface_get_height(surface),
			.depth = 32,
			.buffer = NULL,
			.backbuffer = cairo_image_surface_get_data(surface)
		};

		set_font_face(FONT_SANS_SERIF);
		set_font_size(13);

		char * title = "Button with Hover Highlight";
		int str_width = draw_string_width(title);
		draw_string(&fake_context, (width - str_width) / 2 + x, y + (height) / 2 + 4, rgb(49,49,49), title);
	}

	cairo_restore(cr);
	
}
static void
clearlooks_glossy_draw_progressbar_trough (cairo_t *cr,
                                    const ClearlooksColors *colors,
                                    const WidgetParameters *params,
                                    int x, int y, int width, int height)
{
	const CairoColor *border = &colors->shade[6];
	CairoColor        shadow;
	cairo_pattern_t  *pattern;
	double           radius = MIN (params->radius, MIN ((height-2.0) / 2.0, (width-2.0) / 2.0));
	
	cairo_save (cr);

	cairo_set_line_width (cr, 1.0);
	
	/* Fill with bg color */
	ge_cairo_set_color (cr, &colors->bg[params->state_type]);
	
	cairo_rectangle (cr, x, y, width, height);
	cairo_fill (cr);

	/* Create trough box */
	ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
	ge_cairo_set_color (cr, &colors->shade[2]);
	cairo_fill (cr);

	/* Draw border */
	ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width-1, height-1, radius, params->corners);
	clearlooks_set_mixed_color (cr, border, &colors->shade[2], 0.3);
	cairo_stroke (cr);

	/* clip the corners of the shadows */
	ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
	cairo_clip (cr);

	ge_shade_color (border, 0.92, &shadow);

	/* Top shadow */
	cairo_rectangle (cr, x+1, y+1, width-2, 4);
	pattern = cairo_pattern_create_linear (x, y, x, y+4);
	cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
	cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
	cairo_set_source (cr, pattern);
	cairo_fill (cr);
	cairo_pattern_destroy (pattern);

	/* Left shadow */
	cairo_rectangle (cr, x+1, y+1, 4, height-2);
	pattern = cairo_pattern_create_linear (x, y, x+4, y);
	cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
	cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
	cairo_set_source (cr, pattern);
	cairo_fill (cr);
	cairo_pattern_destroy (pattern);

	cairo_restore (cr);
}
示例#6
0
/*
 * Function resposible for drawing the plot background based on the settings
 * defined at CP_Context *ctx
 * 		@ctx:
 * 			CP_Context which point to the plot context.
 *
 * This function uses the following settings:
 * 	- bgGradient: pointer to a CP_Gradient structure. This structure defines
 * 	the gradient settings.
 * 	- bgColor: pointer to a CP_Color structure. This structure defines the flat
 * 	color to be used in the background
 *
 * If both pointers point to some contents C-CairoPlot will prefer to use a
 * Gradient over a flat color.
 * If none color is supported (neither flat or gradient) this function draws a
 * default background.
 *
 */
void cp_drawBackground(CP_Context *ctx)
{
	// Gradient Color
	if (ctx->bgGradient != NULL)
	{
		// TODO: Gradients should let users define the "orientation"
		// (left to right, right to left, up to down ou down to up) and the
		// gradient type (liner, radial or mesh)
		// mesh demo: https://gist.github.com/3159434
		cairo_pattern_t *pat;
		CP_Gradient *iter;
		pat = cairo_pattern_create_linear(0.5, 0.0, 0.5, 1);
		
		for (iter=ctx->bgGradient; iter; iter=iter->next)
			cairo_pattern_add_color_stop_rgba(pat, iter->position,
					iter->color->red, iter->color->green,
					iter->color->blue, iter->color->alpha);

		cairo_rectangle(ctx->cr, 0.0, 0.0, 1.0, 1.0);
		cairo_set_source(ctx->cr, pat);
		cairo_fill(ctx->cr);
		cairo_pattern_destroy(pat);
		return;
	}
	// Flat color
	else if (ctx->bgColor != NULL)
	{
		cairo_set_source_rgba(ctx->cr, ctx->bgColor->red,
				ctx->bgColor->green, ctx->bgColor->blue,
				ctx->bgColor->alpha);
		cairo_rectangle(ctx->cr, 0, 0, 1, 1);
		cairo_fill(ctx->cr);
	}
	else
	{
		// Default Color
		cairo_pattern_t *pat;
		pat = cairo_pattern_create_linear(0.5, 0.0, 0.5, 1);
		cairo_pattern_add_color_stop_rgba(pat, 0.0, 1.0, 1.0, 1.0, 1.0);
		cairo_pattern_add_color_stop_rgba(pat, 1.0, 0.9, 0.9, 0.9, 1.0);
		cairo_rectangle(ctx->cr, 0.0, 0.0, 1.0, 1.0);
		cairo_set_source(ctx->cr, pat);
		cairo_fill(ctx->cr);
		cairo_pattern_destroy(pat);
		return;
	}

}
示例#7
0
static void
update_background (ClutterActor       *tex,
                   const ClutterColor *color,
                   gfloat              width,
                   gfloat              height)
{
  cairo_t *cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (tex));
  cairo_pattern_t *pat;
  gfloat x, y;

#define BG_ROUND_RADIUS         12

  x = y = 0;

  cairo_move_to (cr, BG_ROUND_RADIUS, y);
  cairo_line_to (cr, width - BG_ROUND_RADIUS, y);
  cairo_curve_to (cr, width, y, width, y, width, BG_ROUND_RADIUS);
  cairo_line_to (cr, width, height - BG_ROUND_RADIUS);
  cairo_curve_to (cr, width, height, width, height, width - BG_ROUND_RADIUS, height);
  cairo_line_to (cr, BG_ROUND_RADIUS, height);
  cairo_curve_to (cr, x, height, x, height, x, height - BG_ROUND_RADIUS);
  cairo_line_to (cr, x, BG_ROUND_RADIUS);
  cairo_curve_to (cr, x, y, x, y, BG_ROUND_RADIUS, y);

  cairo_close_path (cr);

  clutter_cairo_set_source_color (cr, color);
  cairo_stroke (cr);

  x += 4;
  y += 4;
  width -= 4;
  height -= 4;

  cairo_move_to (cr, BG_ROUND_RADIUS, y);
  cairo_line_to (cr, width - BG_ROUND_RADIUS, y);
  cairo_curve_to (cr, width, y, width, y, width, BG_ROUND_RADIUS);
  cairo_line_to (cr, width, height - BG_ROUND_RADIUS);
  cairo_curve_to (cr, width, height, width, height, width - BG_ROUND_RADIUS, height);
  cairo_line_to (cr, BG_ROUND_RADIUS, height);
  cairo_curve_to (cr, x, height, x, height, x, height - BG_ROUND_RADIUS);
  cairo_line_to (cr, x, BG_ROUND_RADIUS);
  cairo_curve_to (cr, x, y, x, y, BG_ROUND_RADIUS, y);

  cairo_close_path (cr);

  pat = cairo_pattern_create_linear (0, 0, 0, height);
  cairo_pattern_add_color_stop_rgba (pat, 1, .85, .85, .85, 1);
  cairo_pattern_add_color_stop_rgba (pat, .95, 1, 1, 1, 1);
  cairo_pattern_add_color_stop_rgba (pat, .05, 1, 1, 1, 1);
  cairo_pattern_add_color_stop_rgba (pat, 0, .85, .85, .85, 1);

  cairo_set_source (cr, pat);
  cairo_fill (cr);

  cairo_pattern_destroy (pat);
  cairo_destroy (cr);

#undef BG_ROUND_RADIUS
}
示例#8
0
void Taskbar::Draw(cairo_t *cr)
{
    static double start_colour = 0.8;
    static double end_colour = 0.7;
    int m_colour = 0xf0f0f0;

    cairo_pattern_t     *pattern;
    double              red = ((m_colour >> 16) & 0xff) / 255.0;
    double              green = ((m_colour >> 8) & 0xff) / 255.0;
    double              blue = ((m_colour) & 0xff) / 255.0;

    cairo_rectangle(cr, 0.5, 0.5, m_draw_size.m_width-1.0, m_draw_size.m_height-1.0);

    pattern = cairo_pattern_create_linear(0, 0, 0, m_draw_size.m_height);
    cairo_pattern_add_color_stop_rgb(pattern, 0.0, start_colour*red, start_colour*green, start_colour*blue);
    cairo_pattern_add_color_stop_rgb(pattern, 1.0, end_colour*red, end_colour*green, end_colour*blue);

    /* Fill with our pattern */
    cairo_set_source(cr, pattern);
    cairo_fill(cr);

    /* Destroy the pattern */
    cairo_pattern_destroy(pattern);

    // Now draw a line at the bottom
    const double bound_colour = 0.5;
    cairo_set_source_rgb(cr, bound_colour, bound_colour, bound_colour);
    cairo_set_line_width(cr, 1.0);
    cairo_move_to(cr, 0.5, m_draw_size.m_height-0.5);
    cairo_line_to(cr, m_draw_size.m_width-0.5, m_draw_size.m_height-0.5);
    cairo_stroke(cr);

    drawChild(cr);
}
static void
clearlooks_inverted_draw_menubaritem (cairo_t *cr,
                          const ClearlooksColors          *colors,
                          const WidgetParameters          *widget,
                          int x, int y, int width, int height)
{
	CairoColor *fill = (CairoColor*)&colors->spot[1];
	CairoColor fill_shade;
	CairoColor border = colors->spot[2];
	cairo_pattern_t *pattern;
	
	ge_shade_color (&border, 1.05, &border);
	ge_shade_color (fill, 0.85, &fill_shade);
	
	cairo_set_line_width (cr, 1.0);
	ge_cairo_rounded_rectangle (cr, x + 0.5, y + 0.5, width - 1, height, widget->radius, widget->corners);

	pattern = cairo_pattern_create_linear (x, y, x, y + height);
	cairo_pattern_add_color_stop_rgb (pattern, 0, fill_shade.r, fill_shade.g, fill_shade.b);
	cairo_pattern_add_color_stop_rgb (pattern, 1.0,   fill->r, fill->g, fill->b);

	cairo_set_source (cr, pattern);
	cairo_fill_preserve  (cr);
	cairo_pattern_destroy (pattern);

	ge_cairo_set_color (cr, &border);
	cairo_stroke_preserve (cr);
}
示例#10
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_pattern_t *pattern;

    cairo_set_source_rgb (cr, 0.5, 0.5, 0.5);
    cairo_paint (cr);

    cairo_save (cr);

    pattern = cairo_pattern_create_linear (0, 0, 10.0, 0);

    cairo_pattern_add_color_stop_rgb (pattern, 0.0,
				      0.0, 0.0, 1.0);
    cairo_pattern_add_color_stop_rgb (pattern, 1.0,
				      1.0, 0.0, 0.0);
    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REFLECT);

    cairo_set_source (cr, pattern);
    cairo_pattern_destroy (pattern);
    cairo_rectangle (cr, 0.0, 0.0, WIDTH, HEIGHT);
    cairo_fill (cr);

    cairo_restore (cr);

    return CAIRO_TEST_SUCCESS;
}
static void
terranova_draw_candy_selected_cell (cairo_t                  *cr,
                                    const terranovaColors   *colors,
                                    const WidgetParameters   *params,
                                    int x, int y, int width, int height)
{
    cairo_save (cr);

    cairo_translate (cr, x, y);

    cairo_pattern_t *pattern;

    CairoColor fill = colors->bg[params->state_type];
    CairoColor shade1, shade2;
    tn_shade_color (&fill, 0.96, &shade1);
    tn_shade_color (&fill, 1.10, &shade2);

    pattern	= cairo_pattern_create_linear (0, 0, 0, height);
    cairo_pattern_add_color_stop_rgb (pattern, 0.00, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.35, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.65, shade2.r, shade2.g, shade2.b);
    cairo_pattern_add_color_stop_rgb (pattern, 1.00, shade2.r, shade2.g, shade2.b);

    cairo_set_source (cr, pattern);
    cairo_rectangle  (cr, 0, 0, width, height);
    cairo_fill       (cr);
    cairo_pattern_destroy (pattern);

    cairo_restore (cr);
}
static void
terranova_draw_candy_list_view_header (cairo_t *cr,
                                       const terranovaColors          *colors,
                                       const WidgetParameters          *params,
                                       const ListViewHeaderParameters  *header,
                                       int x, int y, int width, int height)
{
    const CairoColor *fill = &colors->bg[GTK_STATE_NORMAL];
    cairo_pattern_t *pattern;

    cairo_translate (cr, x, y);

    CairoColor shade1, shade2;
    tn_shade_color (fill, 0.96, &shade1);
    tn_shade_color (fill, 1.10, &shade2);

    pattern	= cairo_pattern_create_linear (0, 0, 0, height);
    cairo_pattern_add_color_stop_rgb (pattern, 0.00, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.35, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.65, shade2.r, shade2.g, shade2.b);
    cairo_pattern_add_color_stop_rgb (pattern, 1.00, shade2.r, shade2.g, shade2.b);
    cairo_set_source (cr, pattern);
    cairo_rectangle (cr, 0, 0, width, height);
    cairo_fill (cr);
    cairo_pattern_destroy (pattern);

}
示例#13
0
文件: icon.c 项目: Keruspe/eventd
static void
_eventd_nd_cairo_image_and_icon_draw_background(cairo_t *cr, cairo_surface_t *image, cairo_surface_t *icon, EventdNdStyle *style, gint width, gint height)
{
    gint padding;

    padding = eventd_nd_style_get_bubble_padding(style);

    if ( image != NULL )
        _eventd_nd_cairo_surface_draw(cr, image, padding, padding);

    if ( icon != NULL )
    {
        gint x1, x2, y;
        cairo_pattern_t *mask;

        x2 = width - padding;
        x1 = x2 - cairo_image_surface_get_width(icon);
        y = _eventd_nd_cairo_get_valign(eventd_nd_style_get_icon_anchor(style), height, padding, cairo_image_surface_get_height(icon));

        mask = cairo_pattern_create_linear(x1, 0, x2, 0);
        cairo_pattern_add_color_stop_rgba(mask, 0, 0, 0, 0, 0);
        cairo_pattern_add_color_stop_rgba(mask, eventd_nd_style_get_icon_fade_width(style), 0, 0, 0, 1);

        cairo_set_source_surface(cr, icon, x1, y);
        cairo_mask(cr, mask);
        cairo_surface_destroy(icon);
    }
}
/* Fill background */
static void
fill_background(GtkWidget *widget, WindowData *windata, cairo_t *cr)
{
	float alpha;
	if (windata->enable_transparency)
		alpha = BACKGROUND_OPACITY;
	else
		alpha = 1.0;

	cairo_pattern_t *pattern;
	pattern = cairo_pattern_create_linear (0, 0, 0, windata->height);
	cairo_pattern_add_color_stop_rgba (pattern, 0, 
        19/255.0, 19/255.0, 19/255.0, alpha);
	cairo_pattern_add_color_stop_rgba (pattern, GRADIENT_CENTER, 
        19/255.0, 19/255.0, 19/255.0, alpha);
	cairo_pattern_add_color_stop_rgba (pattern, 1, 
        19/255.0, 19/255.0, 19/255.0, alpha);
	cairo_set_source (cr, pattern);
	cairo_pattern_destroy (pattern);
	
    nodoka_rounded_rectangle (cr, 0, 8, windata->width-8,
        windata->height-8, 6);

	cairo_fill (cr);	
}
示例#15
0
static gboolean
on_draw(JoyBubble *image, cairo_t *cr, G_GNUC_UNUSED gpointer data)
{
	gint width = joy_bubble_get_width(image) - 2;
	gint height = joy_bubble_get_height(image) - 2;
	double aspect = 0.75;
	double corner_radius = height / 30.;
	double radius = corner_radius / aspect;
	double degrees = M_PI / 180.;
	cairo_translate(cr, 1., 1.);
	/* background */
	cairo_arc(cr, width - radius, radius, radius, -90 * degrees, 0);
	cairo_arc(cr, width - radius, height - radius, radius, 0,
			90 * degrees);
	cairo_arc(cr, radius, height - radius, radius, 90 * degrees,
			180 * degrees);
	cairo_arc(cr, radius, radius, radius, 180 * degrees, 270 * degrees);
	cairo_close_path(cr);
	cairo_pattern_t *pat = cairo_pattern_create_linear(0, 0, 0, height);
	cairo_pattern_add_color_stop_rgba(pat, 0., 1., 1., 1., 0.85);
	cairo_pattern_add_color_stop_rgba(pat, 0.25, 0.39, 0.58, 0.93, 0.85);
	cairo_set_source(cr, pat);
	cairo_pattern_destroy(pat);
	cairo_fill_preserve(cr);
	/* outline */
	cairo_set_source_rgba(cr, 1., 1., 1., 1.);
	cairo_set_line_width(cr, 2.);
	cairo_stroke(cr);
	return TRUE;
}
示例#16
0
static void _draw_mode_toggle(cairo_t *cr, float x, float y, float width, float height, int type)
{
  cairo_save(cr);
  cairo_translate(cr, x, y);

  // border
  float border = MIN(width*.1, height*.1);
  cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.4);
  cairo_rectangle(cr, border, border, width-2.0*border, height-2.0*border);
  cairo_fill_preserve(cr);
  cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.5);
  cairo_set_line_width(cr, border);
  cairo_stroke(cr);

  // icon
  cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.5);
  cairo_move_to(cr, 2.0*border, height-2.0*border);
  switch(type)
  {
    case DT_DEV_HISTOGRAM_LINEAR:
      cairo_line_to(cr, width-2.0*border, 2.0*border);
      cairo_stroke(cr);
      break;
    case DT_DEV_HISTOGRAM_LOGARITHMIC:
      cairo_curve_to(cr, 2.0*border, 0.33*height, 0.66*width, 2.0*border, width-2.0*border, 2.0*border);
      cairo_stroke(cr);
      break;
    case DT_DEV_HISTOGRAM_WAVEFORM:
    {
      cairo_pattern_t *pattern;
      pattern = cairo_pattern_create_linear(0.0, 1.5*border, 0.0, height-3.0*border);

      cairo_pattern_add_color_stop_rgba(pattern, 0.0, 0.0, 0.0, 0.0, 0.5);
      cairo_pattern_add_color_stop_rgba(pattern, 0.2, 0.2, 0.2, 0.2, 0.5);
      cairo_pattern_add_color_stop_rgba(pattern, 0.5, 1.0, 1.0, 1.0, 0.5);
      cairo_pattern_add_color_stop_rgba(pattern, 0.6, 1.0, 1.0, 1.0, 0.5);
      cairo_pattern_add_color_stop_rgba(pattern, 1.0, 0.2, 0.2, 0.2, 0.5);

      cairo_rectangle(cr, 1.5*border, 1.5*border, (width-3.0*border)*0.3, height-3.0*border);
      cairo_set_source(cr, pattern);
      cairo_fill(cr);

      cairo_save(cr);
      cairo_scale(cr, 1, -1);
      cairo_translate(cr, 0, -height);
      cairo_rectangle(cr, 1.5*border + (width-3.0*border)*0.2, 1.5*border, (width-3.0*border)*0.6, height-3.0*border);
      cairo_set_source(cr, pattern);
      cairo_fill(cr);
      cairo_restore(cr);

      cairo_rectangle(cr, 1.5*border + (width-3.0*border)*0.7, 1.5*border, (width-3.0*border)*0.3, height-3.0*border);
      cairo_set_source(cr, pattern);
      cairo_fill(cr);

      cairo_pattern_destroy(pattern);
      break;
    }
  }
 cairo_restore(cr);
}
示例#17
0
/**
 * uber_heat_map_render:
 * @graph: A #UberGraph.
 *
 * XXX
 *
 * Returns: None.
 * Side effects: None.
 */
static void
uber_heat_map_render (UberGraph    *graph, /* IN */
                      cairo_t      *cr,    /* IN */
                      GdkRectangle *area)  /* IN */
{
#if 0
    UberGraphPrivate *priv;
    cairo_pattern_t *cp;

    g_return_if_fail(UBER_IS_HEAT_MAP(graph));

    priv = graph->priv;
    /*
     * XXX: Temporarily draw a nice little gradient to test sliding.
     */
    cp = cairo_pattern_create_linear(0, 0, area->width, 0);
    cairo_pattern_add_color_stop_rgb(cp, 0, .1, .1, .1);
    cairo_pattern_add_color_stop_rgb(cp, .2, .3, .3, .5);
    cairo_pattern_add_color_stop_rgb(cp, .4, .2, .7, .4);
    cairo_pattern_add_color_stop_rgb(cp, .7, .6, .2, .1);
    cairo_pattern_add_color_stop_rgb(cp, .8, .6, .8, .1);
    cairo_pattern_add_color_stop_rgb(cp, 1., .3, .8, .5);
    gdk_cairo_rectangle(cr, area);
    cairo_set_source(cr, cp);
    cairo_fill(cr);
    cairo_pattern_destroy(cp);
#endif
}
static void
terranova_draw_candy_icon_view_item (cairo_t *cr,
                                     const terranovaColors *colors,
                                     const WidgetParameters *params,
                                     int x, int y, int width, int height)
{
    const CairoColor *fill = &colors->bg[GTK_STATE_SELECTED];

    cairo_save (cr);

    cairo_translate (cr, x, y);

    cairo_pattern_t *pattern;

    CairoColor shade1, shade2;
    tn_shade_color (fill, 0.94, &shade1);
    tn_shade_color (fill, 1.00, &shade2);

    pattern	= cairo_pattern_create_linear (0, 1, 0, height);
    cairo_pattern_add_color_stop_rgb (pattern, 0.00, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.35, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.65, shade2.r, shade2.g, shade2.b);
    cairo_pattern_add_color_stop_rgb (pattern, 1.00, shade2.r, shade2.g, shade2.b);

    cairo_set_source (cr, pattern);
    tn_cairo_rounded_rectangle  (cr, 0, 0, width, height, params->radius, CR_CORNER_ALL);

    cairo_fill (cr);
    cairo_pattern_destroy (pattern);

    cairo_restore (cr);
}
static void
clearlooks_glossy_draw_menubaritem (cairo_t                   *cr,
                                    const ClearlooksColors    *colors,
                                    const WidgetParameters    *params,
                                    int x, int y, int width, int height)
{
	const CairoColor *fill = &colors->spot[1];
	const CairoColor *border = &colors->spot[2];
	CairoColor shade1, shade2, shade3;
	cairo_pattern_t *pattern;

	ge_shade_color (fill, 1.16, &shade1);
	ge_shade_color (fill, 1.08, &shade2);
	ge_shade_color (fill, 1.08, &shade3);
	cairo_set_line_width (cr, 1.0);

	ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width - 1, height - 1, params->radius, params->corners);

	pattern = cairo_pattern_create_linear (x, y, x, y + height);
	cairo_pattern_add_color_stop_rgb (pattern, 0,   shade1.r, shade1.g, shade1.b);
	cairo_pattern_add_color_stop_rgb (pattern, 0.5,	shade2.r, shade2.g, shade2.b);
	cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r,  fill->g,  fill->b);
	cairo_pattern_add_color_stop_rgb (pattern, 1,	shade3.r, shade3.g, shade3.b);

	cairo_set_source (cr, pattern);
	cairo_fill_preserve  (cr);
	cairo_pattern_destroy (pattern);

	ge_cairo_set_color (cr, border);
	cairo_stroke (cr);
}
static void
terranova_draw_candy_menubaritem (cairo_t *cr,
                                  const terranovaColors          *colors,
                                  const WidgetParameters *params,
                                  int x, int y, int width, int height)
{
    const CairoColor *fill = &colors->bg[GTK_STATE_SELECTED];
    CairoColor border = colors->spot[2];
    cairo_pattern_t *pattern;

    tn_shade_color (&border, 1.00, &border);

    CairoColor shade1, shade2;
    tn_shade_color (fill, 0.96, &shade1);
    tn_shade_color (fill, 1.10, &shade2);

    pattern	= cairo_pattern_create_linear (x, y, x, y + height);
    cairo_pattern_add_color_stop_rgb (pattern, 0.00, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.35, shade1.r, shade1.g, shade1.b);
    cairo_pattern_add_color_stop_rgb (pattern, 0.65, shade2.r, shade2.g, shade2.b);
    cairo_pattern_add_color_stop_rgb (pattern, 1.00, shade2.r, shade2.g, shade2.b);

    cairo_set_source (cr, pattern);
    tn_cairo_rounded_rectangle (cr, x+0.75, y+0.75, width - 1, height - 1, params->radius, params->corners);
    cairo_fill_preserve (cr);
    cairo_pattern_destroy (pattern);

    tn_cairo_set_color (cr, &border);
    cairo_stroke_preserve (cr);
}
static void
clearlooks_draw_glossy_gradient (cairo_t         *cr,
                                 double x, double y, int width, int height,
                                 const CairoColor *color,
                                 gboolean disabled, gboolean radius, CairoCorners corners)
{
	CairoColor a, b, c, d;
	cairo_pattern_t *pt;

	ge_shade_color (color, disabled? 1.06 : 1.16, &a);
	ge_shade_color (color, disabled? 1.02 : 1.08, &b);
	ge_shade_color (color, disabled? 0.98 : 1.00, &c);
	ge_shade_color (color, disabled? 1.02 : 1.08, &d);

	pt = cairo_pattern_create_linear (x, y, x, y+height);
	cairo_pattern_add_color_stop_rgb (pt, 0.0, a.r, a.g, a.b);
	cairo_pattern_add_color_stop_rgb (pt, 0.5, b.r, b.g, b.b);
	cairo_pattern_add_color_stop_rgb (pt, 0.5, c.r, c.g, c.b);
	cairo_pattern_add_color_stop_rgb (pt, 1.0, d.r, d.g, d.b);

	cairo_set_source (cr, pt);
	ge_cairo_rounded_rectangle (cr, x, y, width, height, radius, corners);
	cairo_fill (cr);
	
	cairo_pattern_destroy (pt);
}
示例#22
0
cairo_pattern_t* Gradient::platformGradient()
{
    if (m_gradient)
        return m_gradient;

    if (m_radial)
        m_gradient = cairo_pattern_create_radial(m_p0.x(), m_p0.y(), m_r0, m_p1.x(), m_p1.y(), m_r1);
    else
        m_gradient = cairo_pattern_create_linear(m_p0.x(), m_p0.y(), m_p1.x(), m_p1.y());

    Vector<ColorStop>::iterator stopIterator = m_stops.begin();
    while (stopIterator != m_stops.end()) {
        cairo_pattern_add_color_stop_rgba(m_gradient, stopIterator->stop, stopIterator->red, stopIterator->green, stopIterator->blue, stopIterator->alpha);
        ++stopIterator;
    }

    switch (m_spreadMethod) {
    case SpreadMethodPad:
        cairo_pattern_set_extend(m_gradient, CAIRO_EXTEND_PAD);
        break;
    case SpreadMethodReflect:
        cairo_pattern_set_extend(m_gradient, CAIRO_EXTEND_REFLECT);
        break;
    case SpreadMethodRepeat:
        cairo_pattern_set_extend(m_gradient, CAIRO_EXTEND_REPEAT);
        break;
    }

    cairo_matrix_t matrix = m_gradientSpaceTransformation;
    cairo_matrix_invert(&matrix);
    cairo_pattern_set_matrix(m_gradient, &matrix);

    return m_gradient;
}
示例#23
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_pattern_t *gradient;

    gradient = cairo_pattern_create_linear (0, 0,
					    0, height);
    cairo_pattern_add_color_stop_rgba (gradient, 0.0,
				       1.0, 0.0, 0.0,
				       0.5);
    cairo_pattern_add_color_stop_rgba (gradient, 0.0,
				       0.0, 1.0, 0.0,
				       0.5);
    cairo_pattern_add_color_stop_rgba (gradient, 1.0,
				       0.0, 0.0, 1.0,
				       0.5);

    cairo_set_source (cr, gradient);

    cairo_paint (cr);

    cairo_pattern_destroy (gradient);

    return CAIRO_TEST_SUCCESS;
}
示例#24
0
文件: paint.c 项目: ksyz/darktable
void dtgtk_cairo_paint_modulegroup_color(cairo_t *cr, gint x, gint y, gint w, gint h, gint flags)
{
  gint s=w<h?w:h;
  cairo_translate(cr, x+(w/2.)-(s/2.), y+(h/2.)-(s/2.));
  cairo_scale(cr, s, s);
  cairo_set_line_cap(cr,CAIRO_LINE_CAP_ROUND);
  cairo_set_line_width(cr,0.1);

  /* draw circle */
  cairo_arc(cr, 0.5, 0.5, 0.40, -M_PI, M_PI);
  cairo_stroke(cr);

  /* fill circle */
  float a = 0.6;
  cairo_pattern_t *pat = NULL;
  pat = cairo_pattern_create_linear(0, 0, 1, 0);
  cairo_pattern_add_color_stop_rgba(pat, 0.0, 1 ,0 ,0, a);
  cairo_pattern_add_color_stop_rgba(pat, 0.1, 1 ,0 ,0, a);
  cairo_pattern_add_color_stop_rgba(pat, 0.5, 0, 1, 0, a);
  cairo_pattern_add_color_stop_rgba(pat, 0.9, 0 ,0 ,1, a);
  cairo_pattern_add_color_stop_rgba(pat, 1.0, 0, 0, 1, a);
  cairo_set_source(cr, pat);
  cairo_arc(cr, 0.5, 0.5, 0.40, -M_PI, M_PI);
  cairo_fill(cr);


}
示例#25
0
static cairo_pattern_t *
fade_pattern (cairo_pattern_t *pattern,
              double           opacity)
{
  double x0, y0, x1, y1, r0, r1;
  cairo_pattern_t *result;
  int i, n;

  switch (cairo_pattern_get_type (pattern))
    {
    case CAIRO_PATTERN_TYPE_LINEAR:
      cairo_pattern_get_linear_points (pattern, &x0, &y0, &x1, &y1);
      result = cairo_pattern_create_linear (x0, y0, x1, y1);
      break;
    case CAIRO_PATTERN_TYPE_RADIAL:
      cairo_pattern_get_radial_circles (pattern, &x0, &y0, &r0, &x1, &y1, &r1);
      result = cairo_pattern_create_radial (x0, y0, r0, x1, y1, r1);
      break;
    default:
      g_return_val_if_reached (NULL);
    }

  cairo_pattern_get_color_stop_count (pattern, &n);
  for (i = 0; i < n; i++)
    {
      double o, r, g, b, a;

      cairo_pattern_get_color_stop_rgba (pattern, i, &o, &r, &g, &b, &a);
      cairo_pattern_add_color_stop_rgba (result, o, r, g, b, a * opacity);
    }

  return result;
}
static void
draw_border(GtkWidget *widget, WindowData *windata, cairo_t *cr)
{
	float alpha;
	if (windata->enable_transparency)
		alpha = BACKGROUND_OPACITY;
	else
		alpha = 1.0;

	cairo_pattern_t *pattern;
	pattern = cairo_pattern_create_linear (0, 0, 0, windata->height);
	cairo_pattern_add_color_stop_rgba (pattern, 0, 0.62, 0.584, 0.341, alpha);
	cairo_pattern_add_color_stop_rgba (pattern, 1, 0.776, 0.757, 0.596, alpha);
	cairo_set_source (cr, pattern);
	cairo_pattern_destroy (pattern);
	
	if (windata->arrow.has_arrow)
		nodoka_rounded_rectangle_with_arrow (cr, 0.5, 0.5, 
			windata->width -1, windata->height -1, 6, & (windata->arrow));
	else
		nodoka_rounded_rectangle (cr, 0.5, 0.5, windata->width -1, 
			windata->height -1, 6);

	cairo_set_line_width (cr, 1.0);
	cairo_stroke (cr);	
}
/* Fill background */
static void
fill_background(GtkWidget *widget, WindowData *windata, cairo_t *cr)
{
	float alpha;
	if (windata->enable_transparency)
		alpha = BACKGROUND_OPACITY;
	else
		alpha = 1.0;

	cairo_pattern_t *pattern;
	pattern = cairo_pattern_create_linear (0, 0, 0, windata->height);
	cairo_pattern_add_color_stop_rgba (pattern, 0, 0.996, 0.996, 0.89, alpha);
	cairo_pattern_add_color_stop_rgba (pattern, GRADIENT_CENTER, 0.988, 0.988, 0.714, alpha);
	cairo_pattern_add_color_stop_rgba (pattern, 1, 0.984, 0.984, 0.663, alpha);
	cairo_set_source (cr, pattern);
	cairo_pattern_destroy (pattern);
	
	if (windata->arrow.has_arrow)
		nodoka_rounded_rectangle_with_arrow (cr, 0, 0, 
			windata->width, windata->height, 6, & (windata->arrow));
	else
		nodoka_rounded_rectangle (cr, 0, 0, windata->width, 
			windata->height, 6);
	cairo_fill (cr);	
}
示例#28
0
cairo_pattern_t *
_gtk_gradient_resolve_full (GtkGradient             *gradient,
                            GtkStyleProviderPrivate *provider,
                            GtkCssComputedValues    *values,
                            GtkCssComputedValues    *parent_values,
                            GtkCssDependencies      *dependencies)
{
  cairo_pattern_t *pattern;
  guint i;

  g_return_val_if_fail (gradient != NULL, NULL);
  g_return_val_if_fail (GTK_IS_STYLE_PROVIDER (provider), NULL);
  g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
  g_return_val_if_fail (parent_values == NULL || GTK_IS_CSS_COMPUTED_VALUES (parent_values), NULL);
  g_return_val_if_fail (*dependencies == 0, NULL);

  if (gradient->radius0 == 0 && gradient->radius1 == 0)
    pattern = cairo_pattern_create_linear (gradient->x0, gradient->y0,
                                           gradient->x1, gradient->y1);
  else
    pattern = cairo_pattern_create_radial (gradient->x0, gradient->y0,
                                           gradient->radius0,
                                           gradient->x1, gradient->y1,
                                           gradient->radius1);

  for (i = 0; i < gradient->stops->len; i++)
    {
      ColorStop *stop;
      GtkCssValue *val;
      GdkRGBA rgba;
      GtkCssDependencies stop_deps;

      stop = &g_array_index (gradient->stops, ColorStop, i);

      /* if color resolving fails, assume transparency */
      val = _gtk_css_color_value_resolve (_gtk_symbolic_color_get_css_value (stop->color),
                                          provider,
                                          _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_COLOR),
                                          GTK_CSS_DEPENDS_ON_COLOR,
                                          &stop_deps,
                                          NULL);
      if (val)
        {
          rgba = *_gtk_css_rgba_value_get_rgba (val);
          *dependencies = _gtk_css_dependencies_union (*dependencies, stop_deps);
          _gtk_css_value_unref (val);
        }
      else
        {
          rgba.red = rgba.green = rgba.blue = rgba.alpha = 0.0;
        }

      cairo_pattern_add_color_stop_rgba (pattern, stop->offset,
                                         rgba.red, rgba.green,
                                         rgba.blue, rgba.alpha);
    }

  return pattern;
}
static void 
clearlooks_glossy_draw_toolbar (cairo_t *cr,
                         const ClearlooksColors          *colors,
                         const WidgetParameters          *widget,
                         const ToolbarParameters         *toolbar,
                         int x, int y, int width, int height)
{
	const CairoColor *fill  = &colors->bg[GTK_STATE_NORMAL];
	const CairoColor *dark  = &colors->shade[3];
	CairoColor light;
	ge_shade_color (fill, 1.1, &light);
	
	cairo_set_line_width (cr, 1.0);
	cairo_translate (cr, x, y);
	
	if (toolbar->style == 1) /* Enable Extra features */
	{ 
		cairo_pattern_t *pattern;
		CairoColor shade1, shade2, shade3;
		
		ge_shade_color (fill, 1.08, &shade1);
		ge_shade_color (fill, 1.04, &shade2);
		ge_shade_color (fill, 1.04, &shade3);

		/* Draw the fill */
		pattern = cairo_pattern_create_linear (0, 0, 0, height);
		cairo_pattern_add_color_stop_rgb (pattern, 0.0, shade1.r, shade1.g, shade1.b);
		cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
		cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r, fill->g, fill->b);
		cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);

		cairo_set_source (cr, pattern);
		cairo_rectangle (cr, 0, 0, width, height);
		cairo_fill (cr);

		cairo_pattern_destroy (pattern);
	}
	else /* Flat */
	{ 
		ge_cairo_set_color (cr, fill);
		cairo_paint (cr);

		if (!toolbar->topmost) 
		{
			/* Draw highlight */
			cairo_move_to       (cr, 0, 0.5);
			cairo_line_to       (cr, width-1, 0.5);
			ge_cairo_set_color  (cr, &light);
			cairo_stroke        (cr);
		}	
	}

	/* Draw shadow */
	cairo_move_to       (cr, 0, height-0.5);
	cairo_line_to       (cr, width-1, height-0.5);
	ge_cairo_set_color  (cr, dark);
	cairo_stroke        (cr);
}
示例#30
0
static void
i7_node_init(I7Node *self)
{
	I7_NODE_USE_PRIVATE;
	priv->id = g_strdup_printf("node-%p", self);
	self->gnode = g_node_new(self);
	self->tree_item = NULL;
	self->tree_points = goo_canvas_points_new(4);

	priv->blessed = FALSE;
	priv->match = I7_NODE_CANT_COMPARE;
	priv->transcript_diffs = NULL;
	priv->transcript_pango_string = NULL;
	priv->expected_diffs = NULL;
	priv->expected_pango_string = NULL;

	/* Create the cairo gradients */
	/* Label */
	priv->label_pattern = cairo_pattern_create_linear(0.0, 0.0, 0.0, 1.0);
	cairo_pattern_add_color_stop_rgba(priv->label_pattern, 1.0, 0.0, 0.33, 0.0, 0.3);
	cairo_pattern_add_color_stop_rgba(priv->label_pattern, 0.67, 0.73, 0.84, 0.73, 0.1);
	cairo_pattern_add_color_stop_rgba(priv->label_pattern, 0.0, 0.5, 0.85, 0.5, 0.0);
	/* Node, unplayed, without blessed transcript text: Tango Chameleon 3 */
	priv->node_pattern[NODE_UNPLAYED_UNBLESSED] = create_node_pattern(0.31, 0.60, 0.02);
	/* Node, unplayed, with blessed transcript text: Tango Chameleon 1 */
	priv->node_pattern[NODE_UNPLAYED_BLESSED] = create_node_pattern(0.54, 0.87, 0.2);
	/* Node, played, without blessed transcript text: Tango Butter 3 */
	priv->node_pattern[NODE_PLAYED_UNBLESSED] = create_node_pattern(0.77, 0.63, 0.0);
	/* Node, played, with blessed transcript text: Tango Butter 1 */
	priv->node_pattern[NODE_PLAYED_BLESSED] = create_node_pattern(0.99, 0.91, 0.31);

	/* Create the canvas items, though some of them can't be drawn yet */
	priv->command_shape_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "",
		"stroke-pattern", NULL,
		"fill-pattern", priv->node_pattern[NODE_UNPLAYED_UNBLESSED],
		NULL);
	priv->label_shape_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "",
		"stroke-pattern", NULL,
		"fill-pattern", priv->label_pattern,
		NULL);
	priv->command_item = goo_canvas_text_model_new(GOO_CANVAS_ITEM_MODEL(self), "", 0.0, 0.0, -1, GTK_ANCHOR_CENTER, NULL);
	priv->label_item = goo_canvas_text_model_new(GOO_CANVAS_ITEM_MODEL(self), "", 0.0, 0.0, -1, GTK_ANCHOR_CENTER, NULL);
	priv->badge_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "",
	  "fill-color", "red",
	  "line-width", 0,
	  "visibility", GOO_CANVAS_ITEM_HIDDEN,
	  NULL);
	g_object_set_data(G_OBJECT(priv->badge_item), "path-drawn", NULL);
	g_object_set_data(G_OBJECT(priv->badge_item), "node-part", GINT_TO_POINTER(I7_NODE_PART_DIFFERS_BADGE));
	/* Avoid drawing the differs badges unless they're actually needed, otherwise
	it really slows down the story startup */

	priv->x = 0.0;
	priv->command_width = -1.0;
	priv->command_height = -1.0;
	priv->label_width = -1.0;
	priv->label_height = -1.0;
}