static cairo_status_t
twin_scaled_font_render_glyph (cairo_scaled_font_t *scaled_font,
unsigned long glyph,
cairo_t *cr,
cairo_text_extents_t *metrics)
{
double x1, y1, x2, y2, x3, y3;
const int8_t *b = _cairo_twin_outlines +
_cairo_twin_charmap[glyph >= ARRAY_LENGTH (_cairo_twin_charmap) ? 0 : glyph];
const int8_t *g = twin_glyph_draw(b);
struct {
cairo_bool_t snap;
int snap_x;
int snap_y;
int n_snap_x;
int n_snap_y;
} info = {FALSE};
cairo_set_line_width (cr, 0.06);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
for (;;) {
switch (*g++) {
case 'M':
cairo_close_path (cr);
/* fall through */
case 'm':
x1 = FX(*g++);
y1 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
}
cairo_move_to (cr, x1, y1);
continue;
case 'L':
cairo_close_path (cr);
/* fall through */
case 'l':
x1 = FX(*g++);
y1 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
}
cairo_line_to (cr, x1, y1);
continue;
case 'C':
cairo_close_path (cr);
/* fall through */
case 'c':
x1 = FX(*g++);
y1 = FY(*g++);
x2 = FX(*g++);
y2 = FY(*g++);
x3 = FX(*g++);
y3 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
x2 = SNAPX (x2);
y2 = SNAPY (y2);
x3 = SNAPX (x3);
y3 = SNAPY (y3);
}
cairo_curve_to (cr, x1, y1, x2, y2, x3, y3);
continue;
case 'E':
cairo_close_path (cr);
/* fall through */
case 'e':
cairo_stroke (cr);
break;
case 'X':
/* filler */
continue;
}
break;
}
metrics->x_advance = FX(twin_glyph_right(b)) + cairo_get_line_width (cr);
metrics->x_advance += cairo_get_line_width (cr)/* XXX 2*x.margin */;
if (info.snap)
metrics->x_advance = SNAPI (SNAPX (metrics->x_advance));
return CAIRO_STATUS_SUCCESS;
}
void Context::quadTo( double x1, double y1, double x2, double y2 )
{
double x0, y0;
cairo_get_current_point( mCairo, &x0, &y0 );
cairo_curve_to( mCairo, x0 + (x1 - x0) / 3.0f * 2.0f, y0 + (y1 - y0) / 3.0f * 2.0f, x1 + (x2 - x1) / 3.0f, y1 + (y2 - y1) / 3.0f, x2, y2 );
}
static ClutterActor *
make_background (const ClutterColor *color,
gfloat width,
gfloat height)
{
ClutterActor *tex = clutter_cairo_texture_new (width, 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
return tex;
}
void Drawer::DrawCurveDebug(const Point& aPrevPoint, const Point& aStartPoint, const Point& aEndPoint, const Point& aNextPoint, double& aCoef)
{
if (aCoef < 0.0)
aCoef = 0.0;
else if (aCoef > 1.0)
aCoef = 1.0;
Point PrevPointLocal = aPrevPoint;
Point StartPointLocal = aStartPoint;
Point EndPointLocal = aEndPoint;
Point NextPointLocal = aNextPoint;
Point TanStartPointLocalCas1(0.0,0.0);
Point TanStartPointLocalCas1R1(0.0,0.0);
Point TanEndPointLocalCas1(0.0,0.0);
Point TanEndPointLocalCas1R2(0.0,0.0);
Point TanStartPointLocalCas2(0.0,0.0);
Point TanStartPointLocalCas2R1(0.0,0.0);
Point TanEndPointLocalCas2(0.0,0.0);
Point TanEndPointLocalCas2R2(0.0,0.0);
Point TanStartPointLocalCas3(0.0,0.0);
Point TanStartPointLocalCas3R1(0.0,0.0);
Point TanEndPointLocalCas3(0.0,0.0);
Point TanEndPointLocalCas3R2(0.0,0.0);
Point TanStartPointLocalCas4(0.0,0.0);
Point TanEndPointLocalCas4(0.0,0.0);
/* DEBUG
std::cout << "PrevPointLocal = (" << PrevPointLocal.X << "," << PrevPointLocal.Y << ")" << std::endl;
std::cout << "StartPointLocal = (" << StartPointLocal.X << "," << StartPointLocal.Y << ")" << std::endl;
std::cout << "EndPointLocal = (" << EndPointLocal.X << "," << EndPointLocal.Y << ")" << std::endl;
std::cout << "NextPointLocal = (" << NextPointLocal.X << "," << NextPointLocal.Y << ")" << std::endl << std::endl; */
Point StartPointTan(0,0);
Point EndPointTan(0,0);
double DistTan12 = 0.0;
double DistTan34 = 0.0;
double MinDistTan = 0.0;
double AngleRadianR1 = 0.0;
cairo_matrix_t TranslateMatrixR0toR1;
cairo_matrix_t RotateMatrixR0toR1;
Point StartPointLocalR1 = StartPointLocal;
Point EndPointR1(0,0);
Point StartPointTanR1(0,0);
double AngleRadianR2 = 0.0;
cairo_matrix_t TranslateMatrixR0toR2;
cairo_matrix_t RotateMatrixR0toR2;
Point StartPointLocalR2(0,0);
Point EndPointR2 = EndPointLocal;
Point EndPointTanR2(0,0);
// Il faut que 'aPrevPoint' et 'aStartPoint' soit non confondu et 'aEndPoint' et 'aNextPoint' aussi
if ((PrevPointLocal != StartPointLocal) && (EndPointLocal != NextPointLocal))
{
// Calcul de l'angle de rotation du nouveau repère R1 (aPrevPoint/aStartPoint)
AngleRadianR1 = atan2 (StartPointLocal.Y - PrevPointLocal.Y, StartPointLocal.X - PrevPointLocal.X);
/* DEBUG
std::cout << "AngleRadianR1 = " << AngleRadianR1 << std::endl << std::endl;*/
SetColor(0,0,0);
MoveTo(PrevPointLocal);
DrawLine(StartPointLocal,1);
//DrawArc (PrevPointLocal,30, AngleRadianR1,1);
// Translation du repère au point 'aPrevPoint'
cairo_matrix_init_translate(&TranslateMatrixR0toR1, PrevPointLocal.X, PrevPointLocal.Y);
// cairo_transform(mCairoDC, &TranslateMatrixR1);
// Rotation du repère d'angle 'AngleRadianR1'
cairo_matrix_init_rotate(&RotateMatrixR0toR1, AngleRadianR1);
// cairo_transform(mCairoDC, &RotateMatrixR1);
// Calcul des coordonnées des points StartPointLocal, EndPointLocal, TanStartPointLocal dans le repère R1
// Point B et C R0 => Point B et C R1
cairo_matrix_invert(&TranslateMatrixR0toR1);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &EndPointLocal.X, &EndPointLocal.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &StartPointLocalR1.X, &StartPointLocalR1.Y);
cairo_matrix_invert(&RotateMatrixR0toR1);
cairo_matrix_transform_point(&RotateMatrixR0toR1, &EndPointLocal.X, &EndPointLocal.Y);
cairo_matrix_transform_point(&RotateMatrixR0toR1, &StartPointLocalR1.X, &StartPointLocalR1.Y);
EndPointR1 = EndPointLocal;
// Reset du EndPointLocal
EndPointLocal = aEndPoint;
/* DEBUG
std::cout << "EndPointR1 = (" << EndPointR1.X << "," << EndPointR1.Y << ")" << std::endl;*/
// DrawRepere(0.0,0.0,0.6);
// Coordonnées de StartPointTan dans le repère R1
StartPointTanR1.X = EndPointR1.X;
StartPointTanR1.Y = 0.0;
// Sauvegarde de la distance du point pour le tracer de la tangente
DistTan12 = abs(StartPointTanR1.X - StartPointLocalR1.X);
MinDistTan = DistTan12;
/* DEBUG
std::cout << "StartPointTanR1= (" << StartPointTanR1.X << "," << StartPointTanR1.Y << ")" << std::endl << std::endl;*/
// MoveTo(StartPointTanR1);
// DrawLine(EndPointR1,1);
// Calcul des coordonnées de StartPointTan dans le repère R0 (Origine)
// StartPointTan = StartPointTanR1;
// cairo_matrix_invert(&RotateMatrixR1);
// cairo_matrix_transform_point(&RotateMatrixR1, &StartPointTan.X, &StartPointTan.Y);
// cairo_matrix_invert(&TranslateMatrixR1);
// cairo_matrix_transform_point(&TranslateMatrixR1, &StartPointTan.X, &StartPointTan.Y);
// cairo_identity_matrix(mCairoDC);
/* DEBUG
std::cout << "StartPointTan = (" << StartPointTan.X << "," << StartPointTan.Y << ")" << std::endl << std::endl << std::endl;*/
// SetColor(0,0,0);
// DrawPoint(StartPointTan,3);
/////////////
// Calcul de l'angle de rotation du nouveau repère R1 (aPrevPoint/aStartPoint)
AngleRadianR2 = atan2 (EndPointLocal.Y - NextPointLocal.Y, EndPointLocal.X - NextPointLocal.X);
/* DEBUG
std::cout << "AngleRadianR1 = " << AngleRadianR1 << std::endl << std::endl;*/
// SetColor(0,0,0);
// MoveTo(NextPointLocal);
// DrawLine(EndPointLocal,1);
//DrawArc (NextPointLocal,30, AngleRadianR2,1);
// Translation du repère au point 'aNextPoint'
cairo_matrix_init_translate(&TranslateMatrixR0toR2, NextPointLocal.X, NextPointLocal.Y);
// cairo_transform(mCairoDC, &TranslateMatrixR2);
// Rotation du repère d'angle 'AngleRadianR2'
cairo_matrix_init_rotate(&RotateMatrixR0toR2, AngleRadianR2);
// cairo_transform(mCairoDC, &RotateMatrixR2);
// Calcul des coordonnées du Point StartPointLocal dans le repère R2
// Point B et C R0 => Point B et C R2
cairo_matrix_invert(&TranslateMatrixR0toR2);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &StartPointLocal.X, &StartPointLocal.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &EndPointR2.X, &EndPointR2.Y);
cairo_matrix_invert(&RotateMatrixR0toR2);
cairo_matrix_transform_point(&RotateMatrixR0toR2, &StartPointLocal.X, &StartPointLocal.Y);
cairo_matrix_transform_point(&RotateMatrixR0toR2, &EndPointR2.X, &EndPointR2.Y);
StartPointLocalR2 = StartPointLocal;
// Reset du StartPointLocal
StartPointLocal = aStartPoint;
/* DEBUG
std::cout << "StartPointLocalR2 = (" << StartPointLocalR2.X << "," << StartPointLocalR2.Y << ")" << std::endl;*/
// DrawRepere(0.0,0.0,0.6);
// Coordonnées de EndPointTan dans le repère R2
EndPointTanR2.X = StartPointLocalR2.X;
EndPointTanR2.Y = 0.0;
// Sauvegarde de la distance du point pour le tracer de la tangente
DistTan34 = abs(EndPointTanR2.X - EndPointR2.X);
if(DistTan34 < MinDistTan)
MinDistTan = DistTan34;
/* DEBUG
std::cout << "EndPointTanR2 = (" << EndPointTanR2.X << "," << EndPointTanR2.Y << ")" << std::endl << std::endl;*/
// MoveTo(EndPointTanR2);
// DrawLine(StartPointLocalR2,1);
// Calcul des coordonnées de EndPointTan dans le repère R0 (Origine)
// EndPointTan = EndPointTanR2;
// cairo_matrix_invert(&RotateMatrixR2);
// cairo_matrix_transform_point(&RotateMatrixR2, &EndPointTan.X, &EndPointTan.Y);
// cairo_matrix_invert(&TranslateMatrixR2);
// cairo_matrix_transform_point(&TranslateMatrixR2, &EndPointTan.X, &EndPointTan.Y);
// cairo_identity_matrix(mCairoDC);
/* DEBUG
std::cout << "EndPointTan = (" << EndPointTan.X << "," << EndPointTan.Y << ")" << std::endl;
std::cout << "MinDistTan = " << MinDistTan << std::endl << std::endl << std::endl;*/
// DrawPoint(EndPointTan,3);
/* DEBUG
std::cout << "Valeurs : " << std::endl;
std::cout << "DistTan (1->2) = " << DistTan12 << std::endl;
std::cout << "DistTan (3->4) = " << DistTan34 << std::endl;
std::cout << "MinDistTan = " << MinDistTan << std::endl << std::endl;*/
cairo_matrix_invert(&RotateMatrixR0toR1);
cairo_matrix_invert(&TranslateMatrixR0toR1);
cairo_matrix_invert(&RotateMatrixR0toR2);
cairo_matrix_invert(&TranslateMatrixR0toR2);
// 1er cas : (12) <=> DistTan12 et (34) <=> DistTan34
// Coordonnées de TanStartPointLocal dans le repère R1
TanStartPointLocalCas1R1.X = StartPointLocalR1.X + DistTan12 * aCoef;
TanStartPointLocalCas1R1.Y = 0.0;
TanStartPointLocalCas1 = TanStartPointLocalCas1R1;
cairo_matrix_transform_point(&RotateMatrixR0toR1, &TanStartPointLocalCas1.X, &TanStartPointLocalCas1.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &TanStartPointLocalCas1.X, &TanStartPointLocalCas1.Y);
// Coordonnées de TanEndPointLocal dans le repère R1
TanEndPointLocalCas1R2.X = EndPointR2.X + DistTan34 * aCoef;
TanEndPointLocalCas1R2.Y = 0.0;
TanEndPointLocalCas1 = TanEndPointLocalCas1R2;
cairo_matrix_transform_point(&RotateMatrixR0toR2, &TanEndPointLocalCas1.X, &TanEndPointLocalCas1.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &TanEndPointLocalCas1.X, &TanEndPointLocalCas1.Y);
SetColor(1,0,0);
DrawPoint(TanStartPointLocalCas1,3);
DrawPoint(TanEndPointLocalCas1,3);
cairo_move_to(mCairoDC, aStartPoint.X, aStartPoint.Y);
cairo_curve_to(mCairoDC, TanStartPointLocalCas1.X,TanStartPointLocalCas1.Y, TanEndPointLocalCas1.X, TanEndPointLocalCas1.Y, aEndPoint.X, aEndPoint.Y);
cairo_set_line_width(mCairoDC, 3);
cairo_stroke(mCairoDC);
// 2eme cas : (12) <=> DistTan12 / 2 et (34) <=> DistTan34 / 2
// Coordonnées de TanStartPointLocal dans le repère R1
TanStartPointLocalCas2R1.X = StartPointLocalR1.X + DistTan12 * 0.5 * aCoef;
TanStartPointLocalCas2R1.Y = 0.0;
TanStartPointLocalCas2 = TanStartPointLocalCas2R1;
cairo_matrix_transform_point(&RotateMatrixR0toR1, &TanStartPointLocalCas2.X, &TanStartPointLocalCas2.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &TanStartPointLocalCas2.X, &TanStartPointLocalCas2.Y);
// Coordonnées de TanEndPointLocal dans le repère R1
TanEndPointLocalCas2R2.X = EndPointR2.X + DistTan34 * 0.5 * aCoef;
TanEndPointLocalCas2R2.Y = 0.0;
TanEndPointLocalCas2 = TanEndPointLocalCas2R2;
cairo_matrix_transform_point(&RotateMatrixR0toR2, &TanEndPointLocalCas2.X, &TanEndPointLocalCas2.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &TanEndPointLocalCas2.X, &TanEndPointLocalCas2.Y);
SetColor(0,1,0);
DrawPoint(TanStartPointLocalCas2,3);
DrawPoint(TanEndPointLocalCas2,3);
cairo_move_to(mCairoDC, aStartPoint.X, aStartPoint.Y);
cairo_curve_to(mCairoDC, TanStartPointLocalCas2.X,TanStartPointLocalCas2.Y, TanEndPointLocalCas2.X, TanEndPointLocalCas2.Y, aEndPoint.X, aEndPoint.Y);
cairo_set_line_width(mCairoDC, 3);
cairo_stroke(mCairoDC);
// 3ème cas : (12) <=> MinDistTan et (34) <=> MinDistTan
// Coordonnées de TanStartPointLocal dans le repère R1
TanStartPointLocalCas3.X = StartPointLocalR1.X + MinDistTan * aCoef;
TanStartPointLocalCas3.Y = 0.0;
cairo_matrix_transform_point(&RotateMatrixR0toR1, &TanStartPointLocalCas3.X, &TanStartPointLocalCas3.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &TanStartPointLocalCas3.X, &TanStartPointLocalCas3.Y);
// Coordonnées de TanEndPointLocal dans le repère R1
TanEndPointLocalCas3.X = EndPointR2.X + MinDistTan * aCoef;
TanEndPointLocalCas3.Y = 0.0;
cairo_matrix_transform_point(&RotateMatrixR0toR2, &TanEndPointLocalCas3.X, &TanEndPointLocalCas3.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &TanEndPointLocalCas3.X, &TanEndPointLocalCas3.Y);
SetColor(0,0,1);
DrawPoint(TanStartPointLocalCas3,3);
DrawPoint(TanEndPointLocalCas3,3);
cairo_move_to(mCairoDC, aStartPoint.X, aStartPoint.Y);
cairo_curve_to(mCairoDC, TanStartPointLocalCas3.X,TanStartPointLocalCas3.Y, TanEndPointLocalCas3.X, TanEndPointLocalCas3.Y, aEndPoint.X, aEndPoint.Y);
cairo_set_line_width(mCairoDC, 3);
cairo_stroke(mCairoDC);
// 4ème cas : (12) <=> MinDistTan / 2 et (34) <=> MinDistTan / 2
// Coordonnées de TanStartPointLocal dans le repère R1
TanStartPointLocalCas4.X = StartPointLocalR1.X + MinDistTan * 0.5 * aCoef;
TanStartPointLocalCas4.Y = 0.0;
cairo_matrix_transform_point(&RotateMatrixR0toR1, &TanStartPointLocalCas4.X, &TanStartPointLocalCas4.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &TanStartPointLocalCas4.X, &TanStartPointLocalCas4.Y);
// Coordonnées de TanEndPointLocal dans le repère R1
TanEndPointLocalCas4.X = EndPointR2.X + MinDistTan * 0.5 * aCoef;
TanEndPointLocalCas4.Y = 0.0;
cairo_matrix_transform_point(&RotateMatrixR0toR2, &TanEndPointLocalCas4.X, &TanEndPointLocalCas4.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &TanEndPointLocalCas4.X, &TanEndPointLocalCas4.Y);
SetColor(0,1,1);
DrawPoint(TanStartPointLocalCas4,3);
DrawPoint(TanEndPointLocalCas4,3);
cairo_move_to(mCairoDC, aStartPoint.X, aStartPoint.Y);
cairo_curve_to(mCairoDC, TanStartPointLocalCas4.X,TanStartPointLocalCas4.Y, TanEndPointLocalCas4.X, TanEndPointLocalCas4.Y, aEndPoint.X, aEndPoint.Y);
cairo_set_line_width(mCairoDC, 3);
cairo_stroke(mCairoDC);
}
}
/*
Sets gadget's background
*/
gboolean
libgadget_sidegadget_on_expose_event (GtkWidget *widget, GdkEventExpose *event, sidegadget_core_s *sidegadget)
{
cairo_t *cr;
double x0 = 5.0;
double y0 = sidegadget->y_shape;
double rect_width = sidegadget->width_sidebar - 10;
double rect_height = sidegadget->height;
double radius = 20;
double x1, y1;
cr = gdk_cairo_create (widget->window);
x1 = x0 + rect_width;
y1 = y0 + rect_height;
if (!rect_width || !rect_height)
return;
if ((rect_width/2) < radius) {
if ((rect_height / 2) < radius) {
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
} else {
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, y1- radius);
}
}
else {
if (rect_height/2<radius) {
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
}
else {
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, y1- radius);
}
}
cairo_close_path (cr);
cairo_set_source_rgba (cr,
(float) sidegadget->color_gadget.red / 65535,
(float) sidegadget->color_gadget.green / 65535,
(float) sidegadget->color_gadget.blue / 65535,
sidegadget->transparency_gadget);
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.5);
cairo_set_line_width (cr, 0.0);
cairo_stroke (cr);
cairo_destroy(cr);
return FALSE;
}
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);
}
static void
marlin_text_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
MarlinTextRenderer *text_renderer = MARLIN_TEXT_RENDERER (cell);
GtkStyleContext *context;
GtkStateFlags state;
gint x0, x1, y0, y1;
gint text_width;
gint text_height;
gint x_offset;
gint y_offset;
gint xpad, ypad;
gfloat xalign, yalign;
gboolean selected;
/* setup the new widget */
marlin_text_renderer_set_widget (text_renderer, widget);
state = gtk_widget_get_state_flags (widget);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
state |= GTK_STATE_FLAG_SELECTED;
}
else if ((flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT
&& gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT)
{
state = GTK_STATE_PRELIGHT;
}
else
{
state = gtk_widget_get_sensitive (widget) ? GTK_STATE_FLAG_NORMAL : GTK_STATE_INSENSITIVE;
}
/* render small/normal text depending on the zoom_level */
if (text_renderer->zoom_level < MARLIN_ZOOM_LEVEL_NORMAL)
{
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small ());
} else {
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, NULL);
}
/* setup the wrapping */
if (text_renderer->wrap_width < 0)
{
pango_layout_set_width (text_renderer->layout, -1);
pango_layout_set_wrap (text_renderer->layout, PANGO_WRAP_CHAR);
}
else
{
pango_layout_set_width (text_renderer->layout, text_renderer->wrap_width * PANGO_SCALE);
pango_layout_set_wrap (text_renderer->layout, text_renderer->wrap_mode);
}
/* ellipsize to max lines except for selected or prelit items */
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_END);
pango_layout_set_height (text_renderer->layout, -3);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED ||
(flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT) {
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_NONE);
}
gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
if (xalign == 0.5f)
pango_layout_set_alignment (text_renderer->layout, PANGO_ALIGN_CENTER);
pango_layout_set_text (text_renderer->layout, text_renderer->text, -1);
/* calculate the real text dimension */
pango_layout_get_pixel_size (text_renderer->layout, &text_width, &text_height);
/* take into account the state indicator (required for calculation) */
if (text_renderer->follow_state)
{
text_width += 2 * text_renderer->focus_width;
text_height += 2 * text_renderer->focus_width;
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
/* calculate the real x-offset */
x_offset = ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ? (1.0 - xalign) : xalign)
* (cell_area->width - text_width - (2 * xpad));
x_offset = MAX (x_offset, 0);
/* calculate the real y-offset */
y_offset = yalign * (cell_area->height - text_height - (2 * ypad));
y_offset = MAX (y_offset, 0);
context = gtk_widget_get_style_context (gtk_widget_get_parent (widget));
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
selected = ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED && text_renderer->follow_state);
/* render the state indicator */
if (selected || text_renderer->background != NULL)
{
/* calculate the text bounding box (including the focus padding/width) */
x0 = cell_area->x + x_offset;
y0 = cell_area->y + y_offset;
x1 = x0 + text_width;
y1 = y0 + text_height;
cairo_move_to (cr, x0 + 5, y0);
cairo_line_to (cr, x1 - 5, y0);
cairo_curve_to (cr, x1 - 5, y0, x1, y0, x1, y0 + 5);
cairo_line_to (cr, x1, y1 - 5);
cairo_curve_to (cr, x1, y1 - 5, x1, y1, x1 - 5, y1);
cairo_line_to (cr, x0 + 5, y1);
cairo_curve_to (cr, x0 + 5, y1, x0, y1, x0, y1 - 5);
cairo_line_to (cr, x0, y0 + 5);
cairo_curve_to (cr, x0, y0 + 5, x0, y0, x0 + 5, y0);
GdkRGBA color;
if(text_renderer->background != NULL && !selected)
{
if(!gdk_rgba_parse(&color, text_renderer->background))
{
g_critical("Can't parse this color value: %s", text_renderer->background);
gtk_style_context_get_background_color (context, state, &color);
}
}
else
{
gtk_style_context_get_background_color (context, state, &color);
}
gdk_cairo_set_source_rgba (cr, &color);
cairo_fill (cr);
}
/* draw the focus indicator */
if (text_renderer->follow_state && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
{
gtk_render_focus (context, cr, cell_area->x + x_offset, cell_area->y + y_offset, text_width, text_height);
}
/* get proper sizing for the layout drawing */
if (text_renderer->follow_state)
{
text_width -= 2 * text_renderer->focus_width;
text_height -= 2 * text_renderer->focus_width;
x_offset += text_renderer->focus_width;
y_offset += text_renderer->focus_width;
}
/* draw the text */
if (xalign == 0.5f)
x_offset = (cell_area->width - text_renderer->wrap_width)/2;
gtk_render_layout (context, cr,
cell_area->x + x_offset + xpad,
cell_area->y + y_offset + ypad,
text_renderer->layout);
gtk_style_context_restore (context);
}
/**
* uber_line_graph_render:
* @graph: A #UberGraph.
* @cr: A #cairo_t context.
* @area: Full area to render contents within.
* @line: The line to render.
*
* Render a particular line to the graph.
*
* Returns: None.
* Side effects: None.
*/
static void
uber_line_graph_render_line (UberLineGraph *graph, /* IN */
cairo_t *cr, /* IN */
GdkRectangle *area, /* IN */
LineInfo *line, /* IN */
guint epoch, /* IN */
gfloat each) /* IN */
{
UberLineGraphPrivate *priv;
UberRange pixel_range;
GdkRectangle vis;
guint x;
guint last_x;
gdouble y;
gdouble last_y;
gdouble val;
gint i;
g_return_if_fail(UBER_IS_LINE_GRAPH(graph));
priv = graph->priv;
uber_graph_get_content_area(UBER_GRAPH(graph), &vis);
pixel_range.begin = area->y + 1;
pixel_range.end = area->y + area->height;
pixel_range.range = pixel_range.end - pixel_range.begin;
/*
* Prepare cairo settings.
*/
uber_line_graph_stylize_line(graph, line, cr);
/*
* Force a new path.
*/
cairo_new_path(cr);
/*
* Draw the line contents as bezier curves.
*/
for (i = 0; i < line->raw_data->len; i++) {
/*
* Retrieve data point.
*/
val = g_ring_get_index(line->raw_data, gdouble, i);
/*
* Once we get to -INFINITY, we must be at the end of the data
* sequence. This may not always be true in the future.
*/
if (val == -INFINITY) {
break;
}
/*
* Translate value to coordinate system.
*/
if (!priv->scale(&priv->range, &pixel_range, &val, priv->scale_data)) {
break;
}
/*
* Calculate X/Y coordinate.
*/
y = (gint)(RECT_BOTTOM(*area) - val) - .5;
x = epoch - (each * i);
if (i == 0) {
/*
* Just move to the right position on first entry.
*/
cairo_move_to(cr, x, y);
goto next;
} else {
/*
* Draw curve to data point using the last X/Y positions as
* control points.
*/
cairo_curve_to(cr,
last_x - (each / 2.),
last_y,
last_x - (each / 2.),
y, x, y);
}
next:
last_y = y;
last_x = x;
}
/*
* Stroke the line content.
*/
cairo_stroke(cr);
}
/**
* uber_line_graph_render_fast:
* @graph: A #UberGraph.
*
* XXX
*
* Returns: None.
* Side effects: None.
*/
static void
uber_line_graph_render_fast (UberGraph *graph, /* IN */
cairo_t *cr, /* IN */
GdkRectangle *rect, /* IN */
guint epoch, /* IN */
gfloat each) /* IN */
{
UberLineGraphPrivate *priv;
UberRange pixel_range;
LineInfo *line;
gdouble last_y;
gdouble y;
gint i;
g_return_if_fail(UBER_IS_LINE_GRAPH(graph));
g_return_if_fail(cr != NULL);
g_return_if_fail(rect != NULL);
priv = UBER_LINE_GRAPH(graph)->priv;
pixel_range.begin = rect->y + 1;
pixel_range.end = rect->y + rect->height;
pixel_range.range = pixel_range.end - pixel_range.begin;
/*
* Render most recent data point for each line.
*/
for (i = 0; i < priv->lines->len; i++) {
line = &g_array_index(priv->lines, LineInfo, i);
uber_line_graph_stylize_line(UBER_LINE_GRAPH(graph), line, cr);
/*
* Calculate positions.
*/
y = g_ring_get_index(line->raw_data, gdouble, 0);
last_y = g_ring_get_index(line->raw_data, gdouble, 1);
/*
* Don't try to draw before we have real values.
*/
if ((isnan(y) || isinf(y)) || (isnan(last_y) || isinf(last_y))) {
continue;
}
/*
* Translate to coordinate scale.
*/
if (!priv->scale(&priv->range, &pixel_range, &y, priv->scale_data) ||
!priv->scale(&priv->range, &pixel_range, &last_y, priv->scale_data)) {
continue;
}
/*
* Translate position from bottom right corner.
*/
y = (gint)(RECT_BOTTOM(*rect) - y) - .5;
last_y = (gint)(RECT_BOTTOM(*rect) - last_y) - .5;
/*
* Convert relative position to fixed from bottom pixel.
*/
cairo_new_path(cr);
cairo_move_to(cr, epoch, y);
cairo_curve_to(cr,
epoch - (each / 2.),
y,
epoch - (each / 2.),
last_y,
epoch - each,
last_y);
cairo_stroke(cr);
}
}
static gboolean
screen_saver_floater_do_draw (ScreenSaver *screen_saver,
ScreenSaverFloater *floater,
cairo_t *context)
{
gint size;
CachedSource *source;
size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->scale),
FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
source = g_hash_table_lookup (screen_saver->cached_sources, GINT_TO_POINTER (size));
if (source == NULL)
{
GdkPixbuf *pixbuf;
GError *error;
pixbuf = NULL;
error = NULL;
pixbuf = gdk_pixbuf_new_from_file_at_size (screen_saver->filename, size, -1,
&error);
if (pixbuf == NULL)
{
g_assert (error != NULL);
g_printerr ("%s", _(error->message));
g_error_free (error);
return FALSE;
}
if (gdk_pixbuf_get_has_alpha (pixbuf))
gamma_correct (pixbuf);
gdk_cairo_set_source_pixbuf (context, pixbuf, 0.0, 0.0);
source = cached_source_new (cairo_get_source (context),
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
g_object_unref (pixbuf);
g_hash_table_insert (screen_saver->cached_sources, GINT_TO_POINTER (size),
source);
}
cairo_save (context);
if (screen_saver->should_do_rotations && (abs (floater->angle) > G_MINDOUBLE))
{
floater->bounds.width = G_SQRT2 * source->width + 2;
floater->bounds.height = G_SQRT2 * source->height + 2;
floater->bounds.x = (int) (floater->position.x - .5 * G_SQRT2 * source->width) - 1;
floater->bounds.y = (int) (floater->position.y - .5 * G_SQRT2 * source->height) - 1;
cairo_translate (context,
trunc (floater->position.x),
trunc (floater->position.y));
cairo_rotate (context, floater->angle);
cairo_translate (context,
-trunc (floater->position.x),
-trunc (floater->position.y));
}
else
{
floater->bounds.width = source->width + 2;
floater->bounds.height = source->height + 2;
floater->bounds.x = (int) (floater->position.x - .5 * source->width) - 1;
floater->bounds.y = (int) (floater->position.y - .5 * source->height) - 1;
}
cairo_translate (context,
trunc (floater->position.x - .5 * source->width),
trunc (floater->position.y - .5 * source->height));
cairo_set_source (context, source->pattern);
cairo_rectangle (context,
trunc (.5 * (source->width - floater->bounds.width)),
trunc (.5 * (source->height - floater->bounds.height)),
floater->bounds.width, floater->bounds.height);
cairo_clip (context);
cairo_paint_with_alpha (context, floater->opacity);
cairo_restore (context);
if (screen_saver->should_show_paths && (floater->path != NULL))
{
gdouble dash_pattern[] = { 5.0 };
gint size;
size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->path_start_scale),
FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);
cairo_save (context);
cairo_set_source_rgba (context, 1.0, 1.0, 1.0, .2 * floater->opacity);
cairo_move_to (context,
floater->path->start_point.x,
floater->path->start_point.y);
cairo_curve_to (context,
floater->path->start_control_point.x,
floater->path->start_control_point.y,
floater->path->end_control_point.x,
floater->path->end_control_point.y,
floater->path->end_point.x,
floater->path->end_point.y);
cairo_set_line_cap (context, CAIRO_LINE_CAP_ROUND);
cairo_stroke (context);
cairo_set_source_rgba (context, 1.0, 0.0, 0.0, .5 * floater->opacity);
cairo_rectangle (context,
floater->path->start_point.x - 3,
floater->path->start_point.y - 3,
6, 6);
cairo_fill (context);
cairo_set_source_rgba (context, 0.0, 0.5, 0.0, .5 * floater->opacity);
cairo_arc (context,
floater->path->start_control_point.x,
floater->path->start_control_point.y,
3, 0.0, 2.0 * G_PI);
cairo_stroke (context);
cairo_set_source_rgba (context, 0.5, 0.0, 0.5, .5 * floater->opacity);
cairo_arc (context,
floater->path->end_control_point.x,
floater->path->end_control_point.y,
3, 0.0, 2.0 * G_PI);
cairo_stroke (context);
cairo_set_source_rgba (context, 0.0, 0.0, 1.0, .5 * floater->opacity);
cairo_rectangle (context,
floater->path->end_point.x - 3,
floater->path->end_point.y - 3,
6, 6);
cairo_fill (context);
cairo_set_dash (context, dash_pattern, G_N_ELEMENTS (dash_pattern), 0);
cairo_set_source_rgba (context, .5, .5, .5, .2 * floater->scale);
cairo_move_to (context, floater->path->start_point.x,
floater->path->start_point.y);
cairo_line_to (context, floater->path->start_control_point.x,
floater->path->start_control_point.y);
cairo_stroke (context);
cairo_move_to (context, floater->path->end_point.x,
floater->path->end_point.y);
cairo_line_to (context, floater->path->end_control_point.x,
floater->path->end_control_point.y);
cairo_stroke (context);
cairo_restore (context);
}
return TRUE;
}
void ofCairoRenderer::drawPath(const ofShape & path,bool is_subpath){
if(!surface || !cr) return;
const vector<ofShape::Command> & commands = path.getCommands();
if(is_subpath)
cairo_new_sub_path(cr);
else
cairo_new_path(cr);
for(int i=0; i<(int)commands.size(); i++){
switch(commands[i].type){
case ofShape::Command::lineTo:
curvePoints.clear();
cairo_line_to(cr,commands[i].to.x,commands[i].to.y);
break;
case ofShape::Command::curveTo:
curvePoints.push_back(commands[i].to);
//code adapted from ofxVectorGraphics to convert catmull rom to bezier
if(curvePoints.size()==4){
ofPoint p1=curvePoints[0];
ofPoint p2=curvePoints[1];
ofPoint p3=curvePoints[2];
ofPoint p4=curvePoints[3];
//SUPER WEIRD MAGIC CONSTANT = 1/6 (this works 100% can someone explain it?)
ofPoint cp1 = p2 + ( p3 - p1 ) * (1.0/6);
ofPoint cp2 = p3 + ( p2 - p4 ) * (1.0/6);
cairo_curve_to( cr, cp1.x, cp1.y, cp2.x, cp2.y, p3.x, p3.y );
curvePoints.pop_front();
}
break;
case ofShape::Command::bezierTo:
curvePoints.clear();
cairo_curve_to(cr,commands[i].cp1.x,commands[i].cp1.y,commands[i].cp2.x,commands[i].cp2.y,commands[i].to.x,commands[i].to.y);
break;
case ofShape::Command::quadBezierTo:
curvePoints.clear();
cairo_curve_to(cr,commands[i].cp1.x,commands[i].cp1.y,commands[i].cp2.x,commands[i].cp2.y,commands[i].to.x,commands[i].to.y);
break;
case ofShape::Command::arc:
curvePoints.clear();
// elliptic arcs not directly supported in cairo, lets scale y
if(commands[i].radiusX!=commands[i].radiusY){
float ellipse_ratio = commands[i].radiusY/commands[i].radiusX;
pushMatrix();
translate(0,-commands[i].to.y*ellipse_ratio);
scale(1,ellipse_ratio);
translate(0,commands[i].to.y*1/ellipse_ratio);
cairo_arc(cr,commands[i].to.x,commands[i].to.y,commands[i].radiusX,commands[i].angleBegin,commands[i].angleEnd);
//cairo_set_matrix(cr,&stored_matrix);
popMatrix();
}else{
cairo_arc(cr,commands[i].to.x,commands[i].to.y,commands[i].radiusX,commands[i].angleBegin,commands[i].angleEnd);
}
break;
}
}
if(path.isClosed()){
cairo_close_path(cr);
}
const vector<ofShape> &subpaths = path.getSubShapes();
for(int i=0;i<(int)subpaths.size();i++){
drawPath(subpaths[i],true);
}
cairo_fill_rule_t cairo_poly_mode;
if(path.getWindingMode()==OF_POLY_WINDING_ODD) cairo_poly_mode=CAIRO_FILL_RULE_EVEN_ODD;
else cairo_poly_mode=CAIRO_FILL_RULE_WINDING;
cairo_set_fill_rule(cr,cairo_poly_mode);
if(path.getStrokeWidth()>0){
ofColor c = path.getStrokeColor() * ofGetStyle().color;
c.a = path.getStrokeColor().a/255. * ofGetStyle().color.a;
cairo_set_source_rgba(cr, (float)c.r/255.0, (float)c.g/255.0, (float)c.b/255.0, (float)c.a/255.0);
cairo_set_line_width( cr, path.getStrokeWidth() );
if(path.isFilled())
cairo_stroke_preserve( cr );
else
cairo_stroke( cr );
}
if(path.isFilled()){
ofColor c = path.getFillColor() * ofGetStyle().color;
c.a = path.getFillColor().a/255. * ofGetStyle().color.a;
cairo_set_source_rgba(cr, (float)c.r/255.0, (float)c.g/255.0, (float)c.b/255.0, (float)c.a/255.0);
cairo_fill( cr );
}
}
static void
gtk_css_image_builtin_draw_check (GtkCssImage *image,
cairo_t *cr,
double width,
double height,
gboolean checked,
gboolean inconsistent)
{
GtkCssImageBuiltin *builtin = GTK_CSS_IMAGE_BUILTIN (image);
gint x, y, exterior_size, interior_size, thickness, pad;
exterior_size = MIN (width, height);
if (exterior_size % 2 == 0) /* Ensure odd */
exterior_size -= 1;
/* FIXME: thickness */
thickness = 1;
pad = thickness + MAX (1, (exterior_size - 2 * thickness) / 9);
interior_size = MAX (1, exterior_size - 2 * pad);
if (interior_size < 7)
{
interior_size = 7;
pad = MAX (0, (exterior_size - interior_size) / 2);
}
x = - (1 + exterior_size - (gint) width) / 2;
y = - (1 + exterior_size - (gint) height) / 2;
if (builtin->border_width > 0)
{
cairo_set_line_width (cr, builtin->border_width);
cairo_rectangle (cr, x + 0.5, y + 0.5, exterior_size - 1, exterior_size - 1);
gdk_cairo_set_source_rgba (cr, &builtin->bg_color);
cairo_fill_preserve (cr);
gdk_cairo_set_source_rgba (cr, &builtin->border_color);
cairo_stroke (cr);
}
gdk_cairo_set_source_rgba (cr, &builtin->fg_color);
if (inconsistent)
{
int line_thickness = MAX (1, (3 + interior_size * 2) / 7);
cairo_rectangle (cr,
x + pad,
y + pad + (1 + interior_size - line_thickness) / 2,
interior_size,
line_thickness);
cairo_fill (cr);
}
else
{
if (checked)
{
cairo_translate (cr,
x + pad, y + pad);
cairo_scale (cr, interior_size / 7., interior_size / 7.);
cairo_rectangle (cr, 0, 0, 7, 7);
cairo_clip (cr);
cairo_move_to (cr, 7.0, 0.0);
cairo_line_to (cr, 7.5, 1.0);
cairo_curve_to (cr, 5.3, 2.0,
4.3, 4.0,
3.5, 7.0);
cairo_curve_to (cr, 3.0, 5.7,
1.3, 4.7,
0.0, 4.7);
cairo_line_to (cr, 0.2, 3.5);
cairo_curve_to (cr, 1.1, 3.5,
2.3, 4.3,
3.0, 5.0);
cairo_curve_to (cr, 1.0, 3.9,
2.4, 4.1,
3.2, 4.9);
cairo_curve_to (cr, 3.5, 3.1,
5.2, 2.0,
7.0, 0.0);
cairo_fill (cr);
}
}
}
/*
Set gadget's background
*/
gboolean
on_expose_event (GtkWidget *widget, GdkEventExpose *event, temp_notifier_gadget_s *core)
{
cairo_t *cr;
double x0 = 5.0;
double y0 = 15.0;
double rect_width = core->width - 10;
double rect_height = core->height - 25;
double radius = 40;
double x1,y1;
cr = gdk_cairo_create (widget->window);
/* Set gadget background transparent */
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
x1 = x0 + rect_width;
y1 = y0 + rect_height;
if (!rect_width || !rect_height)
return;
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
cairo_close_path (cr);
cairo_set_source_rgba (cr,
(float) core->gadget.red / 65535.0,
(float) core->gadget.green / 65535.0,
(float) core->gadget.blue / 65535.0,
1);
cairo_fill_preserve (cr);
switch (core->border_value)
{
case 1:
gdk_color_parse ("#CC4400", &core->border);
break;
case 2:
gdk_color_parse ("#CC6600", &core->border);
break;
case 3:
gdk_color_parse ("#CCBB00", &core->border);
break;
case 4:
gdk_color_parse ("#CCDD00", &core->border);
break;
case 5:
gdk_color_parse ("#99DD00", &core->border);
break;
case 6:
gdk_color_parse ("#00EE44", &core->border);
break;
case 7: /* Super green */
gdk_color_parse ("#00BB44", &core->border);
break;
case -1: /* Super red */
gdk_color_parse ("#002200", &core->border);
break;
default:
gdk_color_parse ("#CCCCCC", &core->border);
break;
}
cairo_set_source_rgba (cr,
(float) core->border.red / 65535.0,
(float) core->border.green / 65535.0,
(float) core->border.blue / 65535.0,
core->border_transparency);
cairo_set_line_width (cr, 3.0);
cairo_stroke (cr);
cairo_destroy(cr);
return FALSE;
}
static void
schgui_cairo_path_draw(SchGUICairoDrawItem *item, cairo_t *cairo)
{
if (cairo != NULL)
{
SchGUICairoPathPrivate *privat = SCHGUI_CAIRO_PATH_GET_PRIVATE(item);
if (privat != NULL)
{
GSList *node;
SchPathCommand *command;
cairo_set_source_rgba(cairo, privat->red, privat->green, privat->blue, privat->alpha);
cairo_set_line_width(cairo, privat->line_width);
node = privat->commands;
while (node != NULL)
{
command = SCH_PATH_COMMAND(node->data);
switch (command->type)
{
case SCH_PATH_COMMAND_INVALID:
g_debug("SchGUICairoPath: invalid path command");
break;
case SCH_PATH_COMMAND_CLOSEPATH:
cairo_close_path(cairo);
break;
case SCH_PATH_COMMAND_CURVETO_ABS:
cairo_curve_to(
cairo,
command->curveto.x[0], command->curveto.y[0],
command->curveto.x[1], command->curveto.y[1],
command->curveto.x[2], command->curveto.y[2]
);
break;
case SCH_PATH_COMMAND_CURVETO_REL:
cairo_rel_curve_to(
cairo,
command->curveto.x[0], command->curveto.y[0],
command->curveto.x[1], command->curveto.y[1],
command->curveto.x[2], command->curveto.y[2]
);
break;
case SCH_PATH_COMMAND_LINETO_ABS:
cairo_line_to(cairo, command->lineto.x, command->lineto.y);
break;
case SCH_PATH_COMMAND_LINETO_REL:
cairo_rel_line_to(cairo, command->lineto.x, command->lineto.y);
break;
case SCH_PATH_COMMAND_MOVETO_ABS:
cairo_move_to(cairo, command->moveto.x, command->moveto.y);
break;
case SCH_PATH_COMMAND_MOVETO_REL:
cairo_rel_move_to(cairo, command->moveto.x, command->moveto.y);
break;
default:
g_debug("SchGUICairoPath: unknown path command");
}
node = g_slist_next(node);
}
if (privat->solid)
{
cairo_fill_preserve(cairo);
}
cairo_stroke(cairo);
}
}
}
/*
* Can be called recursively.
* If optimize_stroke == false, the view Rect is not used.
*/
static void
feed_curve_to_cairo(cairo_t *cr, Geom::Curve const &c, Geom::Affine const & trans, Geom::Rect view, bool optimize_stroke)
{
if( is_straight_curve(c) )
{
Geom::Point end_tr = c.finalPoint() * trans;
if (!optimize_stroke) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
Geom::Rect swept(c.initialPoint()*trans, end_tr);
if (swept.intersects(view)) {
cairo_line_to(cr, end_tr[0], end_tr[1]);
} else {
cairo_move_to(cr, end_tr[0], end_tr[1]);
}
}
}
else if(Geom::QuadraticBezier const *quadratic_bezier = dynamic_cast<Geom::QuadraticBezier const*>(&c)) {
std::vector<Geom::Point> points = quadratic_bezier->points();
points[0] *= trans;
points[1] *= trans;
points[2] *= trans;
Geom::Point b1 = points[0] + (2./3) * (points[1] - points[0]);
Geom::Point b2 = b1 + (1./3) * (points[2] - points[0]);
if (!optimize_stroke) {
cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
} else {
Geom::Rect swept(points[0], points[2]);
swept.expandTo(points[1]);
if (swept.intersects(view)) {
cairo_curve_to(cr, b1[0], b1[1], b2[0], b2[1], points[2][0], points[2][1]);
} else {
cairo_move_to(cr, points[2][0], points[2][1]);
}
}
}
else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
std::vector<Geom::Point> points = cubic_bezier->points();
//points[0] *= trans; // don't do this one here for fun: it is only needed for optimized strokes
points[1] *= trans;
points[2] *= trans;
points[3] *= trans;
if (!optimize_stroke) {
cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
} else {
points[0] *= trans; // didn't transform this point yet
Geom::Rect swept(points[0], points[3]);
swept.expandTo(points[1]);
swept.expandTo(points[2]);
if (swept.intersects(view)) {
cairo_curve_to(cr, points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1]);
} else {
cairo_move_to(cr, points[3][0], points[3][1]);
}
}
}
// else if(Geom::SVGEllipticalArc const *svg_elliptical_arc = dynamic_cast<Geom::SVGEllipticalArc *>(c)) {
// //TODO: get at the innards and spit them out to cairo
// }
else {
//this case handles sbasis as well as all other curve types
Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
//recurse to convert the new path resulting from the sbasis to svgd
for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
feed_curve_to_cairo(cr, *iter, trans, view, optimize_stroke);
}
}
}
void CanvasCairo::pathCubicTo(float x1, float y1, float x2, float y2, float x3, float y3) {
cairo_curve_to(_context, x1, y1, x2, y2, x3, y3);
}
void gfxContext::CurveTo(gfxPoint pt1, gfxPoint pt2, gfxPoint pt3)
{
cairo_curve_to(mCairo, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y);
}
static void
clearlooks_glossy_draw_checkbox (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const CheckboxParameters *checkbox,
int x, int y, int width, int height)
{
const CairoColor *border;
const CairoColor *dot;
gboolean inconsistent = FALSE;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
if (widget->disabled)
{
border = &colors->shade[5];
dot = &colors->shade[6];
}
else
{
if (widget->prelight)
border = &colors->spot[2];
else
border = &colors->shade[6];
dot = &colors->text[GTK_STATE_NORMAL];
}
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
if (widget->xthickness > 2 && widget->ythickness > 2)
{
widget->style_functions->draw_inset (cr, &widget->parentbg, 0, 0,
width, height, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
else
{
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
if (!widget->disabled)
{
if (widget->prelight)
clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
else
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
if (draw_bullet)
{
if (inconsistent) /* Inconsistent */
{
cairo_set_line_width (cr, 2.0);
cairo_move_to (cr, 3, height*0.5);
cairo_line_to (cr, width-3, height*0.5);
}
else
{
cairo_set_line_width (cr, 1.7);
cairo_move_to (cr, 0.5 + (width*0.2), (height*0.5));
cairo_line_to (cr, 0.5 + (width*0.4), (height*0.7));
cairo_curve_to (cr, 0.5 + (width*0.4), (height*0.7),
0.5 + (width*0.5), (height*0.4),
0.5 + (width*0.70), (height*0.25));
}
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
}
static cairo_status_t
twin_scaled_font_render_glyph (cairo_scaled_font_t *scaled_font,
unsigned long glyph,
cairo_t *cr,
cairo_text_extents_t *metrics)
{
double x1, y1, x2, y2, x3, y3;
double marginl;
twin_scaled_properties_t *props;
twin_snap_info_t info;
const int8_t *b;
const int8_t *g;
int8_t w;
double gw;
props = cairo_scaled_font_get_user_data (scaled_font, &twin_properties_key);
/* Save glyph space, we need it when stroking */
cairo_save (cr);
/* center the pen */
cairo_translate (cr, props->penx * .5, -props->peny * .5);
/* small-caps */
if (props->face_props->smallcaps && glyph >= 'a' && glyph <= 'z') {
glyph += 'A' - 'a';
/* 28 and 42 are small and capital letter heights of the glyph data */
cairo_scale (cr, 1, 28. / 42);
}
/* slant */
if (props->face_props->slant != CAIRO_FONT_SLANT_NORMAL) {
cairo_matrix_t shear = { 1, 0, -.2, 1, 0, 0};
cairo_transform (cr, &shear);
}
b = _cairo_twin_outlines +
_cairo_twin_charmap[unlikely (glyph >= ARRAY_LENGTH (_cairo_twin_charmap)) ? 0 : glyph];
g = twin_glyph_draw(b);
w = twin_glyph_right(b);
gw = F(w);
marginl = props->marginl;
/* monospace */
if (props->face_props->monospace) {
double monow = F(24);
double extra = props->penx + props->marginl + props->marginr;
cairo_scale (cr, (monow + extra) / (gw + extra), 1);
gw = monow;
/* resnap margin for new transform */
{
double x, y, x_scale, x_scale_inv;
x = 1; y = 0;
compute_hinting_scale (cr, x, y, &x_scale, &x_scale_inv);
marginl = SNAPXI (marginl);
}
}
cairo_translate (cr, marginl, 0);
/* stretch */
cairo_scale (cr, props->stretch, 1);
if (props->snap)
twin_compute_snap (cr, &info, b);
else
info.n_snap_x = info.n_snap_y = 0;
/* advance width */
metrics->x_advance = gw * props->stretch + props->penx + props->marginl + props->marginr;
/* glyph shape */
for (;;) {
switch (*g++) {
case 'M':
cairo_close_path (cr);
/* fall through */
case 'm':
x1 = SNAPX(*g++);
y1 = SNAPY(*g++);
cairo_move_to (cr, x1, y1);
continue;
case 'L':
cairo_close_path (cr);
/* fall through */
case 'l':
x1 = SNAPX(*g++);
y1 = SNAPY(*g++);
cairo_line_to (cr, x1, y1);
continue;
case 'C':
cairo_close_path (cr);
/* fall through */
case 'c':
x1 = SNAPX(*g++);
y1 = SNAPY(*g++);
x2 = SNAPX(*g++);
y2 = SNAPY(*g++);
x3 = SNAPX(*g++);
y3 = SNAPY(*g++);
cairo_curve_to (cr, x1, y1, x2, y2, x3, y3);
continue;
case 'E':
cairo_close_path (cr);
/* fall through */
case 'e':
cairo_restore (cr); /* restore glyph space */
cairo_set_tolerance (cr, 0.01);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
cairo_set_line_width (cr, 1);
cairo_scale (cr, props->penx, props->peny);
cairo_stroke (cr);
break;
case 'X':
/* filler */
continue;
}
break;
}
return CAIRO_STATUS_SUCCESS;
}
void wxSVGCanvasPathCairo::CurveToCubicImpl(double x1, double y1, double x2,
double y2, double x, double y) {
cairo_curve_to(m_cr, x1, y1, x2, y2, x, y);
}
void Drawer::DrawCurve(const Point& aPrevPoint, const Point& aStartPoint, const Point& aEndPoint, const Point& aNextPoint, double& aCoef)
{
if (aCoef < 0.0)
aCoef = 0.0;
else if (aCoef > 1.0)
aCoef = 1.0;
double AngleRadianR0toR1 = 0.0;
cairo_matrix_t TranslateMatrixR0toR1;
cairo_matrix_t RotateMatrixR0toR1;
Point StartPointInR1 = aStartPoint;
Point EndPointInR1 = aEndPoint;
double AngleRadianR0toR2 = 0.0;
cairo_matrix_t TranslateMatrixR0toR2;
cairo_matrix_t RotateMatrixR0toR2;
Point StartPointInR2 = aStartPoint;
Point EndPointInR2 = aEndPoint;
double DistTanStart = 0.0;
double DistTanEnd = 0.0;
Point StartTanPoint(0.0,0.0);
Point StartTanPointInR1(0,0);
Point EndTanPoint(0.0,0.0);
Point EndTanPointInR2(0,0);
// Il faut que 'aPrevPoint' et 'aStartPoint' soit non confondu et 'aEndPoint' et 'aNextPoint' aussi
if ((aPrevPoint != aStartPoint) && (aEndPoint != aNextPoint))
{
// Calcul de l'angle de rotation du nouveau repère R1 (aPrevPoint/aStartPoint)
AngleRadianR0toR1 = atan2 (aStartPoint.Y - aPrevPoint.Y, aStartPoint.X - aPrevPoint.X);
// Translation du repère au point 'aPrevPoint'
cairo_matrix_init_translate(&TranslateMatrixR0toR1, aPrevPoint.X, aPrevPoint.Y);
// Rotation du repère d'angle 'AngleRadianR1'
cairo_matrix_init_rotate(&RotateMatrixR0toR1, AngleRadianR0toR1);
// Calcul des coordonnées des points aStartPoint, aEndPoint, TanStartPointLocal dans le repère R1
// Point B et C R0 => Point B et C R1
cairo_matrix_invert(&TranslateMatrixR0toR1);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &EndPointInR1.X, &EndPointInR1.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &StartPointInR1.X, &StartPointInR1.Y);
cairo_matrix_invert(&RotateMatrixR0toR1);
cairo_matrix_transform_point(&RotateMatrixR0toR1, &EndPointInR1.X, &EndPointInR1.Y);
cairo_matrix_transform_point(&RotateMatrixR0toR1, &StartPointInR1.X, &StartPointInR1.Y);
// Coordonnées de StartPointTan dans le repère R1
StartTanPointInR1.X = EndPointInR1.X;
StartTanPointInR1.Y = 0.0;
// Sauvegarde de la distance du point pour le tracer de la tangente
DistTanStart = abs(StartTanPointInR1.X - StartPointInR1.X);
/////////////
// Calcul de l'angle de rotation du nouveau repère R1 (aPrevPoint/aStartPoint)
AngleRadianR0toR2 = atan2 (aEndPoint.Y - aNextPoint.Y, aEndPoint.X - aNextPoint.X);
// Translation du repère au point 'aNextPoint'
cairo_matrix_init_translate(&TranslateMatrixR0toR2, aNextPoint.X, aNextPoint.Y);
// Rotation du repère d'angle 'AngleRadianR0toR2'
cairo_matrix_init_rotate(&RotateMatrixR0toR2, AngleRadianR0toR2);
// Calcul des coordonnées du Point aStartPoint dans le repère R2
// Point B et C R0 => Point B et C R2
cairo_matrix_invert(&TranslateMatrixR0toR2);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &StartPointInR2.X, &StartPointInR2.Y);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &EndPointInR2.X, &EndPointInR2.Y);
cairo_matrix_invert(&RotateMatrixR0toR2);
cairo_matrix_transform_point(&RotateMatrixR0toR2, &StartPointInR2.X, &StartPointInR2.Y);
cairo_matrix_transform_point(&RotateMatrixR0toR2, &EndPointInR2.X, &EndPointInR2.Y);
// Coordonnées de EndPointTan dans le repère R2
EndTanPointInR2.X = StartPointInR2.X;
EndTanPointInR2.Y = 0.0;
// Sauvegarde de la distance du point pour le tracer de la tangente
DistTanEnd = abs(EndTanPointInR2.X - EndPointInR2.X);
// Cas : (12) <=> DistTan12 / 2 et (34) <=> DistTan34 / 2
// Coordonnées de TanStartPoint dans le repère R1
StartTanPoint.X = StartPointInR1.X + DistTanStart * 0.5 * aCoef;
StartTanPoint.Y = 0.0;
cairo_matrix_invert(&RotateMatrixR0toR1);
cairo_matrix_transform_point(&RotateMatrixR0toR1, &StartTanPoint.X, &StartTanPoint.Y);
cairo_matrix_invert(&TranslateMatrixR0toR1);
cairo_matrix_transform_point(&TranslateMatrixR0toR1, &StartTanPoint.X, &StartTanPoint.Y);
// Coordonnées de TanEndPoint dans le repère R1
EndTanPoint.X = EndPointInR2.X + DistTanEnd * 0.5 * aCoef;
EndTanPoint.Y = 0.0;
cairo_matrix_invert(&RotateMatrixR0toR2);
cairo_matrix_transform_point(&RotateMatrixR0toR2, &EndTanPoint.X, &EndTanPoint.Y);
cairo_matrix_invert(&TranslateMatrixR0toR2);
cairo_matrix_transform_point(&TranslateMatrixR0toR2, &EndTanPoint.X, &EndTanPoint.Y);
cairo_move_to(mCairoDC, aStartPoint.X, aStartPoint.Y);
cairo_curve_to(mCairoDC, StartTanPoint.X,StartTanPoint.Y, EndTanPoint.X, EndTanPoint.Y, aEndPoint.X, aEndPoint.Y);
cairo_set_line_width(mCairoDC, 3);
cairo_stroke(mCairoDC);
}
}
/*
Set gadget's background
*/
gboolean
on_expose_event (GtkWidget *widget, GdkEventExpose *event, block_notes_core_s *core)
{
cairo_t *cr;
double x0 = 5.0;
double y0 = 12.0;
double rect_width = core->width - 10;
double rect_height = core->height - 15;
double radius = 30;
double x1,y1;
cr = gdk_cairo_create (widget->window);
/* settaggi per rendere trasparente lo sfondo */
cairo_set_source_rgba (cr, 1.0f, 1.0f, 1.0f, 0.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
x1 = x0 + rect_width;
y1 = y0 + rect_height;
if (!rect_width || !rect_height)
return;
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, y1- radius);
cairo_close_path (cr);
cairo_set_source_rgba (cr,
(float) core->gadget.red / 65535.0,
(float) core->gadget.green / 65535.0,
(float) core->gadget.blue / 65535.0,
1.0);
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr,
1.0,
1.0,
1.0,
0.7);
cairo_set_source_rgba (cr,
(float) core->border.red / 65535.0,
(float) core->border.green / 65535.0,
(float) core->border.blue / 65535.0,
core->border_transparency);
cairo_set_line_width (cr, 3.0);
cairo_stroke (cr);
cairo_destroy (cr);
return FALSE;
}
void ofCairoRenderer::draw(ofSubPath & path){
if(!surface || !cr) return;
const vector<ofSubPath::Command> & commands = path.getCommands();
cairo_new_sub_path(cr);
for(int i=0; i<(int)commands.size(); i++){
switch(commands[i].type){
case ofSubPath::Command::lineTo:
curvePoints.clear();
cairo_line_to(cr,commands[i].to.x,commands[i].to.y);
break;
case ofSubPath::Command::curveTo:
curvePoints.push_back(commands[i].to);
//code adapted from ofxVectorGraphics to convert catmull rom to bezier
if(curvePoints.size()==4){
ofPoint p1=curvePoints[0];
ofPoint p2=curvePoints[1];
ofPoint p3=curvePoints[2];
ofPoint p4=curvePoints[3];
//SUPER WEIRD MAGIC CONSTANT = 1/6 (this works 100% can someone explain it?)
ofPoint cp1 = p2 + ( p3 - p1 ) * (1.0/6);
ofPoint cp2 = p3 + ( p2 - p4 ) * (1.0/6);
cairo_curve_to( cr, cp1.x, cp1.y, cp2.x, cp2.y, p3.x, p3.y );
curvePoints.pop_front();
}
break;
case ofSubPath::Command::bezierTo:
curvePoints.clear();
cairo_curve_to(cr,commands[i].cp1.x,commands[i].cp1.y,commands[i].cp2.x,commands[i].cp2.y,commands[i].to.x,commands[i].to.y);
break;
case ofSubPath::Command::quadBezierTo:
curvePoints.clear();
cairo_curve_to(cr,commands[i].cp1.x,commands[i].cp1.y,commands[i].cp2.x,commands[i].cp2.y,commands[i].to.x,commands[i].to.y);
break;
case ofSubPath::Command::arc:
curvePoints.clear();
// elliptic arcs not directly supported in cairo, lets scale y
if(commands[i].radiusX!=commands[i].radiusY){
float ellipse_ratio = commands[i].radiusY/commands[i].radiusX;
pushMatrix();
translate(0,-commands[i].to.y*ellipse_ratio);
scale(1,ellipse_ratio);
translate(0,commands[i].to.y/ellipse_ratio);
cairo_arc(cr,commands[i].to.x,commands[i].to.y,commands[i].radiusX,commands[i].angleBegin,commands[i].angleEnd);
//cairo_set_matrix(cr,&stored_matrix);
popMatrix();
}else{
cairo_arc(cr,commands[i].to.x,commands[i].to.y,commands[i].radiusX,commands[i].angleBegin,commands[i].angleEnd);
}
break;
}
}
if(path.isClosed()){
cairo_close_path(cr);
}
}
/*
Refresh gadget's background if needed
*/
gboolean
refresh_background (block_notes_core_s *core)
{
GdkColor color;
cairo_t *cr;
double x0 = 5.0;
double y0 = 12.0;
double rect_width = core->width - 10;
double rect_height = core->height - 12;
double radius = 40;
double x1,y1;
cr = gdk_cairo_create (core->window->window);
/* Set gadget's background transparent */
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
x1 = x0 + rect_width;
y1 = y0 + rect_height;
if (!rect_width || !rect_height)
return;
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
cairo_close_path (cr);
cairo_set_source_rgba (cr,
(float) core->gadget.red / 65535.0,
(float) core->gadget.green / 65535.0,
(float) core->gadget.blue / 65535.0,
1.0);
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr,
(float) core->border.red / 65535.0,
(float) core->border.green / 65535.0,
(float) core->border.blue / 65535.0,
core->border_transparency);
cairo_set_line_width (cr, 3.0);
cairo_stroke (cr);
cairo_destroy (cr);
gtk_widget_modify_base (core->view, GTK_STATE_NORMAL, &core->gadget);
/* Reset textview font */
gtk_widget_modify_font (core->view, core->font_pango);
/* Reset font color */
gtk_widget_modify_text (core->view, GTK_STATE_NORMAL, &core->text);
/* Resize window */
gtk_window_resize (GTK_WINDOW(core->window), core->width, core->height);
/* Reset buttons */
gtk_fixed_move (GTK_FIXED(core->fixed), core->button_setting, core->width - 40, 0);
gtk_fixed_move (GTK_FIXED(core->fixed), core->button_move, core->width - 30, 0);
gtk_fixed_move (GTK_FIXED(core->fixed), core->button_close, core->width - 20, 0);
gtk_widget_set_size_request (core->view, core->width - 27, core->height - 30);
return FALSE;
}
void cairo_context::curve_to(double ct1_x, double ct1_y, double ct2_x, double ct2_y, double end_x, double end_y)
{
cairo_curve_to(cairo_.get(), ct1_x,ct1_y,ct2_x,ct2_y,end_x,end_y);
check_object_status_and_throw_exception(*this);
}
void
dt_view_image_expose(
dt_view_image_over_t *image_over,
uint32_t imgid,
cairo_t *cr,
int32_t width,
int32_t height,
int32_t zoom,
int32_t px,
int32_t py)
{
cairo_save (cr);
float bgcol = 0.4, fontcol = 0.425, bordercol = 0.1, outlinecol = 0.2;
int selected = 0, altered = 0, imgsel;
DT_CTL_GET_GLOBAL(imgsel, lib_image_mouse_over_id);
// if(img->flags & DT_IMAGE_SELECTED) selected = 1;
/* clear and reset statements */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.have_history);
/* bind imgid to prepared statments */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.is_selected, 1, imgid);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.have_history, 1, imgid);
/* lets check if imgid is selected */
if(sqlite3_step(darktable.view_manager->statements.is_selected) == SQLITE_ROW)
selected = 1;
/* lets check if imgid has history */
if(sqlite3_step(darktable.view_manager->statements.have_history) == SQLITE_ROW)
altered = 1;
const dt_image_t *img = dt_image_cache_read_testget(darktable.image_cache, imgid);
if(selected == 1)
{
outlinecol = 0.4;
bgcol = 0.6;
fontcol = 0.5;
}
if(imgsel == imgid)
{
bgcol = 0.8; // mouse over
fontcol = 0.7;
outlinecol = 0.6;
// if the user points at this image, we really want it:
if(!img)
img = dt_image_cache_read_get(darktable.image_cache, imgid);
}
float imgwd = 0.90f;
if(zoom == 1)
{
imgwd = .97f;
// cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
}
else
{
double x0 = 1, y0 = 1, rect_width = width-2, rect_height = height-2, radius = 5;
double x1, y1, off, off1;
x1=x0+rect_width;
y1=y0+rect_height;
off=radius*0.666;
off1 = radius-off;
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0, y0+off1, x0+off1 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1-off1, y0, x1, y0+off1, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1-off1, x1-off1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0+off1, y1, x0, y1-off1, x0, y1- radius);
cairo_close_path (cr);
cairo_set_source_rgb(cr, bgcol, bgcol, bgcol);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 0.005*width);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_stroke(cr);
if(img)
{
const char *ext = img->filename + strlen(img->filename);
while(ext > img->filename && *ext != '.') ext--;
ext++;
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .25*width);
cairo_move_to (cr, .01*width, .24*height);
cairo_show_text (cr, ext);
}
}
float scale = 1.0;
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip =
dt_mipmap_cache_get_matching_size(
darktable.mipmap_cache,
imgwd*width, imgwd*height);
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
imgid,
mip,
0);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf.buf, CAIRO_FORMAT_RGB24, buf.width, buf.height, stride);
if(zoom == 1)
{
scale = fminf(
fminf(darktable.thumbnail_width, width) / (float)buf.width,
fminf(darktable.thumbnail_height, height) / (float)buf.height
);
}
else scale = fminf(width*imgwd/(float)buf.width, height*imgwd/(float)buf.height);
}
// draw centered and fitted:
cairo_save(cr);
cairo_translate(cr, width/2.0, height/2.0f);
cairo_scale(cr, scale, scale);
if(buf.buf)
{
cairo_translate(cr, -.5f*buf.width, -.5f*buf.height);
cairo_set_source_surface (cr, surface, 0, 0);
if(buf.width <= 8 && buf.height <= 8)
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_fill(cr);
cairo_surface_destroy (surface);
if(zoom == 1) cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_BEST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
}
// border around image
const float border = zoom == 1 ? 16/scale : 2/scale;
cairo_set_source_rgb(cr, bordercol, bordercol, bordercol);
if(buf.buf && selected)
{
cairo_set_line_width(cr, 1./scale);
if(zoom == 1)
{
// draw shadow around border
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_stroke(cr);
// cairo_new_path(cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
float alpha = 1.0f;
for(int k=0; k<16; k++)
{
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -k/scale, -k/scale, buf.width+2.*k/scale, buf.height+2.*k/scale);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
}
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -border, -border, buf.width+2.*border, buf.height+2.*border);
cairo_stroke_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_fill(cr);
}
}
else if(buf.buf)
{
cairo_set_line_width(cr, 1);
cairo_stroke(cr);
}
cairo_restore(cr);
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
const float fscale = fminf(width, height);
if(imgsel == imgid)
{
// draw mouseover hover effects, set event hook for mouse button down!
*image_over = DT_VIEW_DESERT;
cairo_set_line_width(cr, 1.5);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
float r1, r2;
if(zoom != 1)
{
r1 = 0.05*width;
r2 = 0.022*width;
}
else
{
r1 = 0.015*fscale;
r2 = 0.007*fscale;
}
float x, y;
if(zoom != 1) y = 0.90*height;
else y = .12*fscale;
if(img) for(int k=0; k<5; k++)
{
if(zoom != 1) x = (0.41+k*0.12)*width;
else x = (.08+k*0.04)*fscale;
if((img->flags & 0x7) != 6) //if rejected: draw no stars
{
dt_view_star(cr, x, y, r1, r2);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_STAR_1 + k;
cairo_fill(cr);
}
else if((img->flags & 0x7) > k)
{
cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
}
else cairo_stroke(cr);
}
}
//Image rejected?
if(zoom !=1) x = 0.11*width;
else x = .04*fscale;
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_REJECT; //mouse sensitive
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
}
else if (img && ((img->flags & 0x7) == 6))
{
cairo_set_source_rgb(cr, 1., 0., 0.);
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
cairo_set_line_width(cr, 2.5);
}
//reject cross:
cairo_move_to(cr, x-r2, y-r2);
cairo_line_to(cr, x+r2, y+r2);
cairo_move_to(cr, x+r2, y-r2);
cairo_line_to(cr, x-r2, y+r2);
cairo_close_path(cr);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_width(cr, 1.5);
// image altered?
if(altered)
{
// align to right
float s = (r1+r2)*.5;
if(zoom != 1)
{
x = width*0.9;
y = height*0.1;
}
else x = (.04+7*0.04)*fscale;
dt_view_draw_altered(cr, x, y, s);
//g_print("px = %d, x = %.4f, py = %d, y = %.4f\n", px, x, py, y);
if(img && abs(px-x) <= 1.2*s && abs(py-y) <= 1.2*s) // mouse hovers over the altered-icon -> history tooltip!
{
darktable.gui->center_tooltip = 1;
}
}
}
// kill all paths, in case img was not loaded yet, or is blocked:
cairo_new_path(cr);
// TODO: make mouse sensitive, just as stars!
// TODO: cache in image struct!
{
// color labels:
const float x = zoom == 1 ? (0.07)*fscale : .21*width;
const float y = zoom == 1 ? 0.17*fscale: 0.1*height;
const float r = zoom == 1 ? 0.01*fscale : 0.03*width;
/* clear and reset prepared statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_color);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_color);
/* setup statement and iterate rows */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_color, 1, imgid);
while(sqlite3_step(darktable.view_manager->statements.get_color) == SQLITE_ROW)
{
cairo_save(cr);
int col = sqlite3_column_int(darktable.view_manager->statements.get_color, 0);
// see src/dtgtk/paint.c
dtgtk_cairo_paint_label(cr, x+(3*r*col)-5*r, y-r, r*2, r*2, col);
cairo_restore(cr);
}
}
if(img && (zoom == 1))
{
// some exif data
cairo_set_source_rgb(cr, .7, .7, .7);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .025*fscale);
cairo_move_to (cr, .02*fscale, .04*fscale);
// cairo_show_text(cr, img->filename);
cairo_text_path(cr, img->filename);
char exifline[50];
cairo_move_to (cr, .02*fscale, .08*fscale);
dt_image_print_exif(img, exifline, 50);
cairo_text_path(cr, exifline);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 1.0);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_stroke(cr);
}
if(img) dt_image_cache_read_release(darktable.image_cache, img);
cairo_restore(cr);
// if(zoom == 1) cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
}
void Context::curveTo( double x1, double y1, double x2, double y2, double x3, double y3 )
{
cairo_curve_to( mCairo, x1, y1, x2, y2, x3, y3 );
}
void ofCairoRenderer::draw(const ofPath::Command & command) const{
if(!surface || !cr) return;
ofCairoRenderer * mut_this = const_cast<ofCairoRenderer*>(this);
switch(command.type){
case ofPath::Command::moveTo:
curvePoints.clear();
cairo_move_to(cr,command.to.x,command.to.y);
break;
case ofPath::Command::lineTo:
curvePoints.clear();
cairo_line_to(cr,command.to.x,command.to.y);
break;
case ofPath::Command::curveTo:
curvePoints.push_back(command.to);
//code adapted from ofxVectorGraphics to convert catmull rom to bezier
if(curvePoints.size()==4){
ofPoint p1=curvePoints[0];
ofPoint p2=curvePoints[1];
ofPoint p3=curvePoints[2];
ofPoint p4=curvePoints[3];
//SUPER WEIRD MAGIC CONSTANT = 1/6 (this works 100% can someone explain it?)
ofPoint cp1 = p2 + ( p3 - p1 ) * (1.0f/6.f);
ofPoint cp2 = p3 + ( p2 - p4 ) * (1.0f/6.f);
cairo_curve_to( cr, cp1.x, cp1.y, cp2.x, cp2.y, p3.x, p3.y );
curvePoints.pop_front();
}
break;
case ofPath::Command::bezierTo:
curvePoints.clear();
cairo_curve_to(cr,command.cp1.x,command.cp1.y,command.cp2.x,command.cp2.y,command.to.x,command.to.y);
break;
case ofPath::Command::quadBezierTo:
curvePoints.clear();
cairo_curve_to(cr,command.cp1.x,command.cp1.y,command.cp2.x,command.cp2.y,command.to.x,command.to.y);
break;
case ofPath::Command::arc:
curvePoints.clear();
// elliptic arcs not directly supported in cairo, lets scale y
if(command.radiusX!=command.radiusY){
float ellipse_ratio = command.radiusY/command.radiusX;
mut_this->pushMatrix();
mut_this->translate(0,-command.to.y*ellipse_ratio);
mut_this->scale(1,ellipse_ratio);
mut_this->translate(0,command.to.y/ellipse_ratio);
cairo_arc(cr,command.to.x,command.to.y,command.radiusX,command.angleBegin*DEG_TO_RAD,command.angleEnd*DEG_TO_RAD);
//cairo_set_matrix(cr,&stored_matrix);
mut_this->popMatrix();
}else{
cairo_arc(cr,command.to.x,command.to.y,command.radiusX,command.angleBegin*DEG_TO_RAD,command.angleEnd*DEG_TO_RAD);
}
break;
case ofPath::Command::arcNegative:
curvePoints.clear();
// elliptic arcs not directly supported in cairo, lets scale y
if(command.radiusX!=command.radiusY){
float ellipse_ratio = command.radiusY/command.radiusX;
mut_this->pushMatrix();
mut_this->translate(0,-command.to.y*ellipse_ratio);
mut_this->scale(1,ellipse_ratio);
mut_this->translate(0,command.to.y/ellipse_ratio);
cairo_arc_negative(cr,command.to.x,command.to.y,command.radiusX,command.angleBegin*DEG_TO_RAD,command.angleEnd*DEG_TO_RAD);
//cairo_set_matrix(cr,&stored_matrix);
mut_this->popMatrix();
}else{
cairo_arc_negative(cr,command.to.x,command.to.y,command.radiusX,command.angleBegin*DEG_TO_RAD,command.angleEnd*DEG_TO_RAD);
}
break;
case ofPath::Command::close:
cairo_close_path(cr);
break;
}
}
void
terranova_draw_button_effect(cairo_t *cr, const WidgetParameters *params,
const terranovaColors *colors, int width, int height)
{
const CairoColor *stripe_fill = &colors->bg[GTK_STATE_SELECTED];
CairoColor hilight, middle, shadow;
cairo_pattern_t *pattern;
if (params->button_effect == 1)
{
tn_shade_color (stripe_fill, 1.10, &middle);
tn_shade_color (stripe_fill, 0.90, &shadow);
tn_shade_color (stripe_fill, 1.35, &hilight);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.25, hilight.r, hilight.g, hilight.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.05, middle.r, middle.g, middle.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.75, shadow.r, shadow.g, shadow.b);
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_move_to (cr, 1, 1);
cairo_line_to (cr, width, 1);
cairo_curve_to (cr, width, 1, 1, 1, 1, height);
cairo_close_path(cr);
cairo_fill(cr);
}
else if (params->button_effect == 2)
{
tn_shade_color (stripe_fill, 1.10, &middle);
tn_shade_color (stripe_fill, 0.90, &shadow);
tn_shade_color (stripe_fill, 1.35, &hilight);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.25, hilight.r, hilight.g, hilight.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.05, middle.r, middle.g, middle.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.75, shadow.r, shadow.g, shadow.b);
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_move_to (cr, 3, height-20);
cairo_line_to (cr, 3, height-3);
cairo_line_to (cr, 20, height-3);
cairo_line_to (cr, 8, height-9);
cairo_line_to (cr, 3, height-20);
cairo_close_path(cr);
cairo_fill(cr);
cairo_move_to (cr, width-20, 3);
cairo_line_to (cr, width-3, 3);
cairo_line_to (cr, width-3, 20);
cairo_line_to (cr, width-8, 9);
cairo_line_to (cr, width-20, 3);
cairo_close_path(cr);
cairo_fill(cr);
}
}
static void
snippet(cairo_t *cr, int i)
{
if (1)
{
cairo_save(cr);
cairo_rotate (cr, i * 0.002);
/* a custom shape that could be wrapped in a function */
double x0 = 25.6, /* parameters like cairo_rectangle */
y0 = 25.6,
rect_width = 204.8,
rect_height = 204.8,
radius = 102.4; /* and an approximate curvature radius */
double x1,y1;
x1=x0+rect_width;
y1=y0+rect_height;
if (rect_width/2<radius) {
if (rect_height/2<radius) {
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
} else {
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0)/2, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, y1- radius);
}
} else {
if (rect_height/2<radius) {
cairo_move_to (cr, x0, (y0 + y1)/2);
cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1)/2);
cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1)/2);
} else {
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0, y1, x0, y1, x0, y1- radius);
}
}
cairo_close_path (cr);
cairo_set_source_rgb (cr, 0.5, 0.5, 1);
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr, 0.5, 0, 0, 0.5);
cairo_set_line_width (cr, 10.0);
cairo_stroke (cr);
cairo_restore(cr);
}
if (1)
{
double xc = 128.0;
double yc = 128.0;
double radius = 100.0;
double angle1 = (45.0 + i * 5) * (M_PI/180.0); /* angles are specified */
double angle2 = (180.0 + i * 5) * (M_PI/180.0); /* in radians */
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
cairo_set_line_width (cr, 10.0);
cairo_arc (cr, xc, yc, radius, angle1, angle2);
cairo_stroke (cr);
/* draw helping lines */
cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6);
cairo_set_line_width (cr, 6.0);
cairo_arc (cr, xc, yc, 10.0, 0, 2*M_PI);
cairo_fill (cr);
cairo_arc (cr, xc, yc, radius, angle1, angle1);
cairo_line_to (cr, xc, yc);
cairo_arc (cr, xc, yc, radius, angle2, angle2);
cairo_line_to (cr, xc, yc);
cairo_stroke (cr);
}
}
