C++ cairo_pattern_add_color_stop_rgba函数代码示例

cairo_pattern_t* BenchCairo::createLinearGradient(
  double x0, double y0,
  double x1, double y1,
  const Fog::Argb32& c0, const Fog::Argb32& c1, const Fog::Argb32& c2)
{
  cairo_pattern_t* pattern = cairo_pattern_create_linear(x0, y0, x1, y1);

  if (pattern == NULL)
    return NULL;

  cairo_pattern_set_extend(pattern, CAIRO_EXTEND_PAD);

  cairo_pattern_add_color_stop_rgba(pattern, 0.0, double(c0.r) * sc, double(c0.g) * sc, double(c0.b) * sc, double(c0.a) * sc);
  cairo_pattern_add_color_stop_rgba(pattern, 0.5, double(c1.r) * sc, double(c1.g) * sc, double(c1.b) * sc, double(c1.a) * sc);
  cairo_pattern_add_color_stop_rgba(pattern, 1.0, double(c2.r) * sc, double(c2.g) * sc, double(c2.b) * sc, double(c2.a) * sc);

  return pattern;
}

static void drone_render(GpsdViewerOsd *self, OsmGpsMap *map)
{
    GpsdViewerOsdUAV *drone = self->priv->drone;
    cairo_pattern_t *pat=NULL;
    cairo_t *cr = NULL;

    if(!drone->surface || !drone->need_render)
    {
      g_assert(drone->surface);
		cr = cairo_create(drone->surface);
		cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
		cairo_set_source_rgba(cr, 1.0, 1.0, 0.0, 0.0);
		cairo_paint(cr);
		cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
		drone->need_render = FALSE;
    }
    else
    {
		// **** fill with transparency
		g_assert(drone->surface);
		cr = cairo_create(drone->surface);
		cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
		cairo_set_source_rgba(cr, 1.0, 1.0, 0.0, 0.0);
		cairo_paint(cr);
		cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
    
		cairo_set_line_width (cr, 1);
		cairo_arc (cr, GPSD_VIEWER_OSD_UAV_W/2, GPSD_VIEWER_OSD_COORDINATES_H/2, GPSD_VIEWER_OSD_UAV_RADIUS, 0, 2*M_PI);
		pat = cairo_pattern_create_radial (GPSD_VIEWER_OSD_UAV_W/2-1, GPSD_VIEWER_OSD_COORDINATES_H/2-1, GPSD_VIEWER_OSD_UAV_RADIUS*0.2,
														GPSD_VIEWER_OSD_UAV_W/2, GPSD_VIEWER_OSD_COORDINATES_H/2, GPSD_VIEWER_OSD_UAV_RADIUS);
		cairo_pattern_add_color_stop_rgba (pat,0, 0.8, 0.8, 1.0,0.8);
		cairo_pattern_add_color_stop_rgba (pat,1, 0.0, 0.0, 0.65,0.8);
		cairo_set_source (cr, pat);
		cairo_fill_preserve(cr);
		cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0);
		cairo_stroke (cr);
		
		cairo_pattern_destroy (pat);    
		drone->need_render = FALSE;
	}
	cairo_destroy(cr);
}

static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_surface_t *mask;
    cairo_pattern_t *pattern;
    cairo_t *cr2;

    mask = cairo_surface_create_similar (cairo_get_group_target (cr),
				         CAIRO_CONTENT_ALPHA,
					 width, height);
    cr2 = cairo_create (mask);
    cairo_surface_destroy (mask);

    cairo_save (cr2); {
	cairo_set_operator (cr2, CAIRO_OPERATOR_CLEAR);
	cairo_paint (cr2);
    } cairo_restore (cr2);

    pattern = cairo_pattern_create_linear (0, 0, width, height);
    cairo_pattern_add_color_stop_rgba (pattern, 0.00, 0., 0., 0., 0.);
    cairo_pattern_add_color_stop_rgba (pattern, 0.25, 1., 1., 1., 1.);
    cairo_pattern_add_color_stop_rgba (pattern, 0.50, 1., 1., 1., .5);
    cairo_pattern_add_color_stop_rgba (pattern, 0.75, 1., 1., 1., 1.);
    cairo_pattern_add_color_stop_rgba (pattern, 1.00, 0., 0., 0., 0.);
    cairo_set_source (cr2, pattern);
    cairo_pattern_destroy (pattern);

    cairo_paint (cr2);

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

    pattern = cairo_pattern_create_radial (
	    0.5 * width, 0.5 * height, 0,
	    0.5 * width, 0.5 * height, 0.5 *height);
    cairo_pattern_add_color_stop_rgba (pattern, 0.00, 0., 0., 0., 0.);
    cairo_pattern_add_color_stop_rgba (pattern, 0.25, 1., 0., 0., 1.);
    cairo_pattern_add_color_stop_rgba (pattern, 0.50, 1., 0., 0., .5);
    cairo_pattern_add_color_stop_rgba (pattern, 1.00, 1., 0., 0., 1.);
    cairo_set_source (cr, pattern);
    cairo_pattern_destroy (pattern);

    cairo_mask_surface (cr, cairo_get_target (cr2), 0, 0);
    cairo_destroy (cr2);

    return CAIRO_TEST_SUCCESS;
}

static int m_cairo_pattern_add_color_stop_rgba(lua_State * L)
{
	cairo_pattern_t ** pattern = luaL_checkudata(L, 1, MT_NAME_CAIRO_PATTERN);
	double offset = luaL_checknumber(L, 2);
	double red = luaL_checknumber(L, 3);
	double green = luaL_checknumber(L, 4);
	double blue = luaL_checknumber(L, 5);
	double alpha = luaL_checknumber(L, 6);
	cairo_pattern_add_color_stop_rgba(*pattern, offset, red, green, blue, alpha);
	return 0;
}

static PyObject *
gradient_add_color_stop_rgba (PycairoGradient *o, PyObject *args) {
  double offset, red, green, blue, alpha;
  if (!PyArg_ParseTuple(args, "ddddd:Gradient.add_color_stop_rgba",
			&offset, &red, &green, &blue, &alpha))
    return NULL;
  cairo_pattern_add_color_stop_rgba (o->pattern, offset, red,
				     green, blue, alpha);
  RETURN_NULL_IF_CAIRO_PATTERN_ERROR(o->pattern);
  Py_RETURN_NONE;
}

cairo_pattern_t *
dv_get_color_linear_pattern(dv_view_t * V, double w, double alpha, long long remark) {
  cairo_pattern_t * pat = cairo_pattern_create_linear(0.0, 0.0, w, 0.0);

  dv_dag_t * g = (dv_dag_t *) V->D->g;
  int a[DV_MAX_NUM_REMARKS];
  int n = 0;
  long v = 0;
  int i;
  for (i = 0; i < g->nr; i++) {
    if (dv_get_bit(remark, i)) {
      v = g->ar[i];
      a[n++] = v;
    }
  }

  double step;
  GdkRGBA color;
  if (n > 0) {
    /* Remark colors */
    step = 1.0 / (n - 1 + 1);
    for (i=0; i<n; i++) {
      v = a[i];
      dv_lookup_color_value(v, &color.red, &color.green, &color.blue, &color.alpha);
      cairo_pattern_add_color_stop_rgba(pat, i * step, color.red, color.green, color.blue, color.alpha);
    }
    gdk_rgba_parse(&color, "white");
    cairo_pattern_add_color_stop_rgba(pat, n * step, color.red, color.green, color.blue, color.alpha);
  } else {
    /* Mixed */
    char ** stops = (char **) DV_LINEAR_PATTERN_STOPS;
    n = DV_LINEAR_PATTERN_STOPS_NUM;
    step = 1.0 / (n - 1);
    for (i = 0; i < n; i++) {
      gdk_rgba_parse(&color, stops[i]);
      cairo_pattern_add_color_stop_rgba(pat, i * step, color.red, color.green, color.blue, color.alpha * alpha);
    }
  }
  
  return pat;
}

  void LinearGradient::render(Context& cairo) const
  {
    Cairo::RefPtr<Cairo::LinearGradient> gradient;
    Vector v = m_vector;
    double fx0, fy0, fx1, fy1, w, h;
    
    if ( v.has_percent() )
    {
      if ( cairo.is_flag_set(RENDER_HINT_STROKE) )
        cairo->get_stroke_extents( fx0, fy0, fx1, fy1 );
      else
        cairo->get_fill_extents( fx0, fy0, fx1, fy1 );
      w = fx1 - fx0;
      h = fy1 - fy0;
      if ( v[0].quantity_x==PERCENT ) v[0].x = fx0 + w * v[0].x;
      if ( v[0].quantity_y==PERCENT ) v[0].y = fy0 + h * v[0].y;
      if ( v[1].quantity_x==PERCENT ) v[1].x = fx0 + w * v[1].x;
      if ( v[1].quantity_y==PERCENT ) v[1].y = fy0 + h * v[1].y;
    }
    
    // Get the units using the accessor to potentially climb the parent chain
//     GradientUnits units = this->units();
//     switch ( units )
//     {
//       case GRADIENT_UNITS_NONE:
//       case GRADIENT_UNITS_OBJECT:
//           std::cout << "Gradient fill extents: " << fx0 << ", " << fy0 << ", " << fx1 << ", " << fy1 << std::endl;
//           break;
//       case GRADIENT_UNITS_USER_SPACE:
//           break;
//     }
    
    gradient = Cairo::LinearGradient::create( v[0].x, v[0].y, v[1].x, v[1].y );
    
    // Get the stops reference using the accessor to potentially climb the parent chain
    const Stops& stops = this->stops();
    Stops::const_iterator siter;
    
    for ( siter = stops.begin(); siter != stops.end(); siter++ )
    {
      cairo_pattern_add_color_stop_rgba( gradient->cobj(), siter->offset(), siter->red(), siter->green(), siter->blue(), siter->alpha() );
    }
    
    // Get the spread using the accessor to potentially climb the parent chain
    GradientSpread spread = this->spread();
    
    if ( spread == GRADIENT_SPREAD_NONE )
      cairo_pattern_set_extend( gradient->cobj(), (cairo_extend_t)GRADIENT_SPREAD_PAD );
    else
      cairo_pattern_set_extend( gradient->cobj(), (cairo_extend_t)spread );
    
    cairo->set_source(gradient);
  }

static PyObject *
_cairo_pattern_add_color_stop_rgba(PyObject *self, PyObject *args)
{
    cairo_pattern_t * pattern;
    double offset, r, g, b, a;

    if (!PyArg_ParseTuple(args, "lddddd", &pattern, &offset, &r, &g, &b, &a))
        return NULL;

    cairo_pattern_add_color_stop_rgba(pattern, offset, r, g, b, a);
    Py_RETURN_NONE;
}

static void set_report_gradient (struct chart *chart, int report,
				 double x, double y, double w, double h)
{
    struct color color;
    cairo_pattern_t *p;

    hsv_to_rgb (6. / chart->num_reports * report, .7, .7, &color);

    p = cairo_pattern_create_linear (x, 0, x+w, 0);
    cairo_pattern_add_color_stop_rgba (p, 0.0,
				       color.red, color.green, color.blue,
				       .50);
    cairo_pattern_add_color_stop_rgba (p, 0.5,
				       color.red, color.green, color.blue,
				       .50);
    cairo_pattern_add_color_stop_rgba (p, 1.0,
				       color.red, color.green, color.blue,
				       1.0);
    cairo_set_source (chart->cr, p);
    cairo_pattern_destroy (p);
}

	virtual bool render(
		cairo_t*       c,
		cairo_glyph_t* glyph,
		unsigned int   width,
		unsigned int   height
	) {
		if(cairo_status(c) || !glyph) return false;

		cairo_set_line_width(c, 1.5f);
		cairo_glyph_path(c, glyph, 1);

		cairo_pattern_t* lp = cairo_pattern_create_linear(width / 2.0f, 0.0f, width / 2.0f, height);

		cairo_pattern_add_color_stop_rgba(lp, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
		cairo_pattern_add_color_stop_rgba(lp, 0.8f, 0.0f, 1.0f, 0.0f, 0.0f);
		cairo_set_source(c, lp);
		cairo_fill(c);
		cairo_pattern_destroy(lp);

		return true;
	}

gboolean scroller_draw(GtkWidget *widget, GdkEventExpose *event, gpointer scrolled_window){
	cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(gtk_widget_get_window(scrolled_window)));
	cairo_pattern_t* pattern;
	GtkAdjustment* adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrolled_window));
	const double minimum_bar_h = 7;
	const double outeralpha = 0.1098;
	const double inneralpha = 0.2392;
	const double bar_gradw = 8;
	const double bar_offx = 2, bar_buffy=1;
	const double cornerw=6;
	const double span = GTK_WIDGET(scrolled_window)->allocation.height - 2*bar_buffy;
	double scroll = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_lower(adj);
	double page = gtk_adjustment_get_page_size(adj);
	double barh = page/scroll * (span);
	if(barh<minimum_bar_h) barh = minimum_bar_h;
	double cornerx = GTK_WIDGET(scrolled_window)->allocation.x + GTK_WIDGET(scrolled_window)->allocation.width - bar_offx - scroller_data.clickzone.width;
	double cornery = GTK_WIDGET(scrolled_window)->allocation.y + bar_buffy + (gtk_adjustment_get_value(adj)/(scroll-page))*(span - barh);
	pub->sd.clickzone.x = cornerx;
	pub->sd.clickzone.y = cornery;
	pub->sd.clickzone.width = scroller_data.clickzone.width;
	pub->sd.clickzone.height = car_w;
	pattern = cairo_pattern_create_linear(cornerx+scroller_data.clickzone.width-bar_gradw,0,cornerx+scroller_data.clickzone.width,0);
	cairo_pattern_add_color_stop_rgba(pattern, 0, 0,0,0, inneralpha);
	cairo_pattern_add_color_stop_rgba(pattern, 1, 0,0,0, outeralpha);
	cairo_set_source(cr,pattern);
	gdk_window_invalidate_rectangle(
	if(leafpad 
	if(barh < cornerw*2.5){ //no corners to be drawn, flat;
		cairo_rectangle(cr, cornerx , cornery, barh, scroller_data.clickzone.width);
	}else{
		cairo_move_to(cr, cornerx, cornery+cornerw);
		cairo_arc(cr, cornerx+cornerw, cornery+cornerw, cornerw, M_PI, (M_PI*3)/2);
		cairo_line_to(cr, cornerx+scroller_data.clickzone.width, cornery);
		cairo_line_to(cr, cornerx+scroller_data.clickzone.width, cornery+barh);
		cairo_line_to(cr, cornerx+cornerw, cornery+barh);
		cairo_arc(cr, cornerx+cornerw, cornery+barh-cornerw, cornerw,  M_PI/2, M_PI);
		cairo_close_path(cr);
	}
	cairo_fill(cr);
}

void
WallScreen::drawHighlight ()
{
    cairo_t         *cr;
    cairo_pattern_t *pattern;
    int             width, height;
    float           r, g, b, a;
    float           outline = 2.0f;

    destroyCairoContext (highlightContext);
    setupCairoContext (highlightContext);

    cr = highlightContext.cr;
    clearCairoLayer (cr);

    width  = highlightContext.width - outline;
    height = highlightContext.height - outline;

    cairo_translate (cr, outline / 2.0f, outline / 2.0f);

    pattern = cairo_pattern_create_linear (0, 0, width, height);
    getColorRGBA (ThumbHighlightGradientBaseColor);
    cairo_pattern_add_color_stop_rgba (pattern, 0.0f, r, g, b, a);
    getColorRGBA (ThumbHighlightGradientShadowColor);
    cairo_pattern_add_color_stop_rgba (pattern, 1.0f, r, g, b, a);

    /* apply the pattern for thumb background */
    cairo_set_source (cr, pattern);
    cairo_rectangle (cr, 0, 0, width, height);
    cairo_fill_preserve (cr);

    cairo_set_line_width (cr, outline);
    getColorRGBA (OutlineColor);
    cairo_set_source_rgba (cr, r, g, b, a);
    cairo_stroke (cr);

    cairo_pattern_destroy (pattern);

    cairo_restore (cr);
}

static int m_pattern_add_color_stop(lua_State * L)
{
	struct lpattern_t * pattern = luaL_checkudata(L, 1, MT_PATTERN);
	double offset = luaL_checknumber(L, 2);
	double red = luaL_checknumber(L, 3);
	double green = luaL_checknumber(L, 4);
	double blue = luaL_checknumber(L, 5);
	double alpha = luaL_optnumber(L, 6, 1);
	cairo_pattern_add_color_stop_rgba(pattern->pattern, offset, red, green, blue, alpha);
	lua_pushlightuserdata(L, pattern);
	luaL_setmetatable(L, MT_PATTERN);
	return 1;
}

static void
progressbar_draw (kk_widget_t *widget, cairo_t *ctx)
{
  kk_progressbar_t *progressbar = (kk_progressbar_t *) widget;

  cairo_pattern_t *pat;

  pat = cairo_pattern_create_linear (
      (double) 0.0,
      (double) 0.0,
      (double) progressbar->widget.width,
      (double) 0.0);

  if (cairo_pattern_status (pat) != CAIRO_STATUS_SUCCESS)
    return;

  cairo_pattern_add_color_stop_rgba (pat, 0.0, 0.75, 0.00, 0.98, 0.5);
  cairo_pattern_add_color_stop_rgba (pat, 0.5, 0.92, 0.03, 0.41, 0.5);
  cairo_pattern_add_color_stop_rgba (pat, 1.0, 0.18, 0.09, 0.21, 0.5);

  cairo_rectangle (ctx,
      (double) progressbar->widget.x,
      (double) progressbar->widget.y,
      (double) progressbar->widget.width,
      (double) progressbar->widget.height);

  cairo_set_source_rgb (ctx, 0.0, 0.0, 0.0);
  cairo_fill_preserve (ctx);
  cairo_set_source (ctx, pat);
  cairo_fill (ctx);
  cairo_pattern_destroy (pat);
  cairo_set_source_rgb (ctx, 0.0, 0.0, 0.0);
  cairo_rectangle (ctx,
      (double) progressbar->widget.x + ((double) progressbar->widget.width * progressbar->progress),
      (double) progressbar->widget.y,
      (double) progressbar->widget.width * 1.0 - (double) progressbar->progress,
      (double) progressbar->widget.height);
  cairo_fill (ctx);
}

void
hippo_cairo_pattern_add_stop_rgba32(cairo_pattern_t *pattern,
                                    double           offset,
                                    guint32          color)
{
    if ((color & 0xff) == 0xff) {
        cairo_pattern_add_color_stop_rgb(pattern, offset,
                                         HIPPO_GET_RED(color), HIPPO_GET_GREEN(color), HIPPO_GET_BLUE(color));
    } else {
        cairo_pattern_add_color_stop_rgba(pattern, offset,
                                          HIPPO_GET_RED(color), HIPPO_GET_GREEN(color), HIPPO_GET_BLUE(color), HIPPO_GET_ALPHA(color));
    }
}