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));
}
}
static void
render_pixmap (cairo_t *cr, gint width, gint height)
{
cairo_scale (cr, (double) width, (double) height);
cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 0.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_pattern_t *pat;
cairo_set_line_width(cr, 0.05);
pat = cairo_pattern_create_linear (0.0, 0.0, 0.0, 1.0);
cairo_pattern_add_color_stop_rgba (pat, 0.5, 1.0, 1.0, 1.0, 1);
cairo_pattern_add_color_stop_rgba (pat, 1, 0.8, 0.8, 0.8, 1);
cairo_rectangle (cr, 0, 0.5, 1, 1);
cairo_set_source(cr, pat);
cairo_fill(cr);
cairo_pattern_destroy(pat);
}
/**
* awn_cairo_pattern_add_color_stop_color:
* @pattern: A cairo pattern.
* @offset: An offset in the range [0.0 .. 1.0].
* @color: The source color.
*
* A convenience function which wraps #cairo_pattern_add_color_stop_rgba by
* using the values from the @color parameter.
*/
void
awn_cairo_pattern_add_color_stop_color (cairo_pattern_t *pattern,
double offset,
DesktopAgnosticColor *color)
{
g_return_if_fail (color);
double red, green, blue, alpha;
desktop_agnostic_color_get_cairo_color (color, &red, &green, &blue, &alpha);
cairo_pattern_add_color_stop_rgba (pattern, offset, red, green, blue, alpha);
}
void dtgtk_cairo_paint_modulegroup_tone(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 */
cairo_pattern_t *pat = NULL;
pat = cairo_pattern_create_linear(0, 0, 1, 0);
cairo_pattern_add_color_stop_rgba(pat, 0, 1 ,1 ,1, 1);
cairo_pattern_add_color_stop_rgba(pat, 1, 1, 1, 1, 0);
cairo_set_source(cr, pat);
cairo_arc(cr, 0.5, 0.5, 0.40, -M_PI, M_PI);
cairo_fill(cr);
}
static void
draw_gradient (cairo_t *cr,
int x,
int y,
int size,
double r1_offset,
double r1_radius,
double r2_offset,
double r2_radius,
cairo_extend_t extend)
{
cairo_pattern_t *pattern;
cairo_save (cr);
pattern = cairo_pattern_create_radial (x + size/2.0 + r1_offset,
y + size/2.0 + r1_offset,
r1_radius,
x + size/2.0 + r2_offset,
y + size/2.0 + r2_offset,
r2_radius);
cairo_pattern_add_color_stop_rgba (pattern, 0.0,
1.0, 0.0, 0.0, 1.0);
cairo_pattern_add_color_stop_rgba (pattern, sqrt (1.0 / 2.0),
0.0, 1.0, 0.0, 0.0);
cairo_pattern_add_color_stop_rgba (pattern, 1.0,
0.0, 0.0, 1.0, 0.5);
cairo_pattern_set_extend (pattern, extend);
cairo_rectangle (cr, x, y, size, size);
cairo_clip (cr);
cairo_set_source (cr, pattern);
cairo_paint (cr);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
}
void dtgtk_cairo_paint_masks_gradient(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.0) - (s / 2.0), y + (h / 2.0) - (s / 2.0));
cairo_scale(cr, s, s);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
if(flags & CPF_ACTIVE)
cairo_set_line_width(cr, 0.25);
else
cairo_set_line_width(cr, 0.125);
cairo_rectangle(cr, 0.0, 0.0, 1.0, 1.0);
cairo_stroke_preserve(cr);
cairo_pattern_t *pat = NULL;
pat = cairo_pattern_create_linear(0.5, 0.0, 0.5, 1.0);
cairo_pattern_add_color_stop_rgba(pat, 0.0, 0.6, 0.6, 0.6, 1.0);
cairo_pattern_add_color_stop_rgba(pat, 1.0, 0.2, 0.2, 0.2, 1.0);
cairo_rectangle(cr, 0.1, 0.1, 0.8, 0.8);
cairo_set_source(cr, pat);
cairo_fill(cr);
cairo_pattern_destroy(pat);
cairo_identity_matrix(cr);
}
static int cairo_pattern_add_color_stop_rgba_l( lua_State* L )
{
lua_cairo_pattern_t* lcp = lua_cairo_pattern_check( L, 1 );
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( lcp->pattern, offset, red, green, blue, alpha );
return( 0 );
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_pattern_t *gradient;
gradient = cairo_pattern_create_linear (0, -height,
0, height);
cairo_pattern_add_color_stop_rgba (gradient, 0.0,
1.0, 0.0, 0.0,
1.0);
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;
}
/**
* shell_global_create_horizontal_gradient:
* @left: the color on the left
* @right: the color on the right
*
* Creates a horizontal gradient actor.
*
* Return value: (transfer none): a #ClutterCairoTexture actor with the
* gradient. The texture actor is floating, hence (transfer none).
*/
ClutterCairoTexture *
shell_global_create_horizontal_gradient (ClutterColor *left,
ClutterColor *right)
{
ClutterCairoTexture *texture;
cairo_t *cr;
cairo_pattern_t *pattern;
/* Draw the gradient on an 8x1 pixel texture. Because the gradient is drawn
* from the left to the right column, after stretching 1/16 of the
* texture width has the left side color and 1/16 has the right side color.
* There is no reason to use the 8 pixel height that would be similar to the
* reason we are using the 8 pixel width for the vertical gradient, so we
* are just using the 1 pixel height instead.
*/
texture = CLUTTER_CAIRO_TEXTURE (clutter_cairo_texture_new (8, 1));
cr = clutter_cairo_texture_create (texture);
pattern = cairo_pattern_create_linear (0, 0, 8, 0);
cairo_pattern_add_color_stop_rgba (pattern, 0,
left->red / 255.,
left->green / 255.,
left->blue / 255.,
left->alpha / 255.);
cairo_pattern_add_color_stop_rgba (pattern, 1,
right->red / 255.,
right->green / 255.,
right->blue / 255.,
right->alpha / 255.);
cairo_set_source (cr, pattern);
cairo_paint (cr);
cairo_pattern_destroy (pattern);
cairo_destroy (cr);
return texture;
}
cairo_pattern_t *
dv_get_color_radial_pattern(double radius, double alpha) {
char ** stops = (char **) DV_RADIAL_PATTERN_STOPS;
int n = DV_RADIAL_PATTERN_STOPS_NUM;
cairo_pattern_t * pat = cairo_pattern_create_radial(0.0, 0.0, 0.0, 0.0, 0.0, radius);
double step = 1.0 / (n - 1);
int i;
for (i = 0; i < n; i++) {
GdkRGBA color;
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 draw_vlinear(cairo_t *cr, gint x, gint y, gint w, gint h, gboolean top_to_buttom)
{
gint r = 0;
cairo_save(cr);
// Translate y coordinate, otherwise y is too big for LinearGradient cause render bug.
cairo_translate(cr, 0, y);
cairo_pattern_t *linear = NULL;
if(top_to_buttom)
linear = cairo_pattern_create_linear(0, 0, 0, h);
else
linear = cairo_pattern_create_linear(0, h, 0, 0);
cairo_pattern_add_color_stop_rgba(linear, 0, 0, 0, 0, 0);
cairo_pattern_add_color_stop_rgba(linear, 0.66, 0, 0, 0, 0.2);
cairo_pattern_add_color_stop_rgba(linear, 1, 0, 0, 0, 0.33);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_set_source(cr, linear);
draw_round_rectangle(cr, x, 0, w, h, r);
cairo_fill(cr);
cairo_restore(cr);
cairo_pattern_destroy(linear);
}
/**
* shell_global_create_vertical_gradient:
* @top: the color at the top
* @bottom: the color at the bottom
*
* Creates a vertical gradient actor.
*
* Return value: (transfer none): a #ClutterCairoTexture actor with the
* gradient. The texture actor is floating, hence (transfer none).
*/
ClutterCairoTexture *
shell_global_create_vertical_gradient (ClutterColor *top,
ClutterColor *bottom)
{
ClutterCairoTexture *texture;
cairo_t *cr;
cairo_pattern_t *pattern;
/* Draw the gradient on an 8x8 pixel texture. Because the gradient is drawn
* from the uppermost to the lowermost row, after stretching 1/16 of the
* texture height has the top color and 1/16 has the bottom color. The 8
* pixel width is chosen for reasons related to graphics hardware internals.
*/
texture = CLUTTER_CAIRO_TEXTURE (clutter_cairo_texture_new (8, 8));
cr = clutter_cairo_texture_create (texture);
pattern = cairo_pattern_create_linear (0, 0, 0, 8);
cairo_pattern_add_color_stop_rgba (pattern, 0,
top->red / 255.,
top->green / 255.,
top->blue / 255.,
top->alpha / 255.);
cairo_pattern_add_color_stop_rgba (pattern, 1,
bottom->red / 255.,
bottom->green / 255.,
bottom->blue / 255.,
bottom->alpha / 255.);
cairo_set_source (cr, pattern);
cairo_paint (cr);
cairo_pattern_destroy (pattern);
cairo_destroy (cr);
return texture;
}
cairo_pattern_t *
dv_create_color_linear_pattern(int * stops, int n, double w, double alpha) {
if (n == 0 || n == 1)
return NULL;
cairo_pattern_t * pat = cairo_pattern_create_linear(0.0, 0.0, w, 0.0);
double step = 1.0 / (n - 1);
double r, g, b, a;
int i;
for (i = 0; i < n; i++) {
dv_lookup_color_value(stops[i], &r, &g, &b, &a);
a *= alpha;
cairo_pattern_add_color_stop_rgba(pat, i * step, r, g, b, a);
}
return pat;
}
/**
* awn_cairo_pattern_add_color_stop_color_with_alpha_multiplier:
* @pattern: A cairo pattern.
* @offset: An offset in the range [0.0 .. 1.0].
* @color: The source color.
* @multiplier: The number (between 0 and 1.0 inclusive) that the alpha value
* is multiplied by.
*
* Similar to #awn_cairo_pattern_add_color_stop_color, except for the
* @multiplier parameter.
*/
void
awn_cairo_pattern_add_color_stop_color_with_alpha_multiplier (cairo_pattern_t *pattern,
double offset,
DesktopAgnosticColor *color,
gdouble multiplier)
{
g_return_if_fail (color);
g_return_if_fail (multiplier >= 0 && multiplier <= 1.0);
double red, green, blue, alpha;
desktop_agnostic_color_get_cairo_color (color, &red, &green, &blue, &alpha);
cairo_pattern_add_color_stop_rgba (pattern, offset, red, green, blue,
alpha * multiplier);
}
static GdkPixbuf *
logged_in_pixbuf (GdkPixbuf *pixbuf, gint scale)
{
cairo_format_t format;
cairo_surface_t *surface;
cairo_pattern_t *pattern;
cairo_t *cr;
gint width, height;
GdkRGBA color;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
g_return_val_if_fail (width > 15 && height > 15, pixbuf);
format = gdk_pixbuf_get_has_alpha (pixbuf) ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24;
surface = cairo_image_surface_create (format, width, height);
cr = cairo_create (surface);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
/* Draw pattern */
cairo_rectangle (cr, 0, 0, width, height);
pattern = cairo_pattern_create_radial (width - 9.5 * scale, height - 10 * scale, 0,
width - 8.5 * scale, height - 7.5 * scale, 7.7 * scale);
cairo_pattern_add_color_stop_rgb (pattern, 0, 0.4, 0.9, 0);
cairo_pattern_add_color_stop_rgb (pattern, 0.7, 0.3, 0.6, 0);
cairo_pattern_add_color_stop_rgb (pattern, 0.8, 0.4, 0.4, 0.4);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, 0, 0, 0, 0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
/* Draw border */
cairo_set_line_width (cr, 0.9 * scale);
cairo_arc (cr, width - 8.5 * scale, height - 8.5 * scale, 6 * scale, 0, 2 * G_PI);
gdk_rgba_parse (&color, "#ffffff");
gdk_cairo_set_source_rgba (cr, &color);
cairo_stroke (cr);
pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height);
cairo_surface_finish (surface);
cairo_destroy (cr);
return pixbuf;
}
static Eina_Bool
_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
{
Ector_Renderer_Generic_Gradient_Radial_Data *grd;
Ector_Renderer_Generic_Gradient_Data *gd;
unsigned int i;
eo_do_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS, ector_renderer_prepare());
if (pd->pat) return EINA_FALSE;
grd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
if (!grd || !gd) return EINA_FALSE;
USE(obj, cairo_pattern_create_radial, EINA_FALSE);
USE(obj, cairo_pattern_add_color_stop_rgba, EINA_FALSE);
pd->pat = cairo_pattern_create_radial(grd->focal.x, grd->focal.y, 0,
grd->radial.x, grd->radial.y, grd->radius);
int r,g,b,a;
for (i = 0; i < gd->colors_count; i++)
{
r = gd->colors[i].r;
g = gd->colors[i].g;
b = gd->colors[i].b;
a = gd->colors[i].a;
ector_color_argb_unpremul(a, &r, &g, &b);
cairo_pattern_add_color_stop_rgba(pd->pat, gd->colors[i].offset, r/255.0, g/255.0, b/255.0, a/255.0);
}
USE(obj, cairo_pattern_set_extend, EINA_FALSE);
cairo_pattern_set_extend(pd->pat, _ector_cairo_extent_get(gd->s));
if (!pd->parent)
{
Eo *parent;
eo_do(obj, parent = eo_parent_get());
if (!parent) return EINA_FALSE;
pd->parent = eo_data_xref(parent, ECTOR_CAIRO_SURFACE_CLASS, obj);
}
return EINA_FALSE;
}
