Cairo & C语言 & GTK+3.0 & Linux

本人的一些相关帖子！
下面的帖子是关于Linux的安装，以BIOS+MBR为基准做的教程;使用UEFI+GPT的，请自行量力而行。
本贴教程仅供懂装操作系统基础的人参考;新手请慎重使用,最好请高手或专业人员帮你做。
免责声明，因使用"Linux桌面版与Win双系统完美方案"教程造成的硬盘数据丢失，一概无本人无关，本人不承担你的任何损失！
http://tieba.baidu.com/p/3859727480

下贴是关于Linux桌面发行版下C语言Cairo,GTK+3.0等下安装。
在Ubuntu下安装GTK+-3.0安装命令 sudo apt-get install gtk+-3.0
http://tieba.baidu.com/p/3865148159

#本贴使用的两个脚本程序,看楼上的图片
#放到Linux /bin目录
#文件权限 chmod 755 zzcairo.sh
#*******************************
#第一个脚本：zzcairo.sh
# for bash:
# export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
#
# for csh:
# setenv PKG_CONFIG_PATH /usr/local/lib/pkgconfig
#
if [ ! -n "$1" ]; then
echo
echo "cairo 编译脚本操作示范:"
echo
echo " " $0 "mypro.c"
echo " " $0 "mypro.c myout.o"
echo
else
if [ ! -n "$2" ]; then
gcc $1 `pkg-config --cflags --libs cairo`
else
gcc $1 -o $2 `pkg-config --cflags --libs cairo`
fi
fi
#******************************
#第二个脚本：zzgtkcairo.sh
# for bash:
# export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
#
# for csh:
# setenv PKG_CONFIG_PATH /usr/local/lib/pkgconfig
#
if [ ! -n "$1" ]; then
echo
echo "cairo gtk编译脚本操作示范:"
echo
echo " " $0 "mypro.c"
echo " " $0 "mypro.c myout.o"
echo
else
if [ ! -n "$2" ]; then
gcc $1 `pkg-config --cflags --libs cairo gtk+-3.0`
else
gcc $1 -o $2 `pkg-config --cflags --libs cairo gtk+-3.0`
fi
fi

/* cairo002.c 生成pdf格式文件 */

/* cairo PDF IMAGE */
#include <cairo.h>
#include <cairo-pdf.h>
#include <stdlib.h>
#include <string.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
int df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
cr = cairo_create (surface);
cairo_select_font_face (cr, "serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, 52.0);
cairo_set_source_rgb (cr, 0.15, 0.20, 0.17);
cairo_move_to (cr, 10.0, 70.0);
cairo_show_text (cr, "世界，你好！");
cairo_set_font_size (cr, 52.0);
cairo_set_line_width (cr, 20.0);
cairo_set_source_rgb (cr, 0.27, 0.73, 0.49);
cairo_move_to (cr, 12, 68.0);
cairo_show_text (cr, "世界，你好！");
switch (pcanvas -> type)
{
case CAIRO_SURFACE_TYPE_IMAGE:
cairo_surface_write_to_png (surface, pcanvas -> filename);
break;
case CAIRO_SURFACE_TYPE_PDF:
cairo_show_page(cr);
break;
}
cairo_destroy (cr);
}
int df_init_canvas (struct df_canvas const *pcanvas)
{
switch (pcanvas -> type)
{
case CAIRO_SURFACE_TYPE_IMAGE:
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
break;
case CAIRO_SURFACE_TYPE_PDF:
surface = cairo_pdf_surface_create (pcanvas -> filename, pcanvas -> width, pcanvas -> height);
break;
}
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.pdf",28);
canvas -> type = CAIRO_SURFACE_TYPE_PDF;
canvas -> width = 320.0;
canvas -> height = 240.0;
/* printf("%d %f %f %s \n",canvas -> type, canvas -> width, canvas -> height, canvas -> filename); */
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo003.c 生成svg格式文件 */

/* cairo SVG PDF IMAGE */
#include <cairo.h>
#include <cairo-pdf.h>
#include <cairo-svg.h>
#include <stdlib.h>
#include <string.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
int df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
cr = cairo_create (surface);
cairo_select_font_face (cr, "serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, 52.0);
cairo_set_source_rgb (cr, 0.15, 0.20, 0.17);
cairo_move_to (cr, 10.0, 70.0);
cairo_show_text (cr, "世界，你好！");
cairo_set_font_size (cr, 52.0);
cairo_set_line_width (cr, 20.0);
cairo_set_source_rgb (cr, 0.27, 0.73, 0.49);
cairo_move_to (cr, 12, 68.0);
cairo_show_text (cr, "世界，你好！");
switch (pcanvas -> type)
{
case CAIRO_SURFACE_TYPE_IMAGE:
cairo_surface_write_to_png (surface, pcanvas -> filename);
break;
case CAIRO_SURFACE_TYPE_PDF:
cairo_show_page(cr);
break;
}
cairo_destroy (cr);
}
int df_init_canvas (struct df_canvas const *pcanvas)
{
switch (pcanvas -> type)
{
case CAIRO_SURFACE_TYPE_IMAGE:
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
break;
case CAIRO_SURFACE_TYPE_PDF:
surface = cairo_pdf_surface_create (pcanvas -> filename, pcanvas -> width, pcanvas -> height);
break;
case CAIRO_SURFACE_TYPE_SVG:
surface = cairo_svg_surface_create (pcanvas -> filename, pcanvas -> width, pcanvas -> height);
break;
}
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.svg",28);
canvas -> type = CAIRO_SURFACE_TYPE_SVG;
canvas -> width = 320.0;
canvas -> height = 240.0;
/* printf("%d %f %f %s \n",canvas -> type, canvas -> width, canvas -> height, canvas -> filename); */
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo004.c 弧arc 反弧arc_negative*/
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
int df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc, radius, angle1, angle2;
cr = cairo_create (surface);
xc = 320;
yc = 198;
radius = 100;
angle1 = 0.0 * (M_PI / 180.0); /* 角度转弧度 */
angle2 = 225.0 * (M_PI / 180.0);
cairo_set_line_width (cr, 20.0); /* 线宽度： 20像素 */
/* 弧： 圆心坐标为(160,198)，半径为100, 起始角度0度,终止角度225度 */
cairo_arc (cr, xc - 160, yc, radius, angle1, angle2);
cairo_stroke (cr);
/* 反弧： 圆心坐标为(480,198)，半径为100, 起始角度0度,终止角度225度 */
cairo_arc_negative (cr, xc + 160, yc, radius, angle1, angle2);
cairo_stroke (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
cairo_destroy (cr);
}
int df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.png",28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 640.0;
canvas -> height = 396.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo005.c 圆弧arc 虚线dash */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
int df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc, radius, angle1, angle2;
cr = cairo_create (surface);
xc = 320;
yc = 198;
radius = 100;
angle1 = 0.0 * (M_PI / 180.0); /* 角度转弧度 */
angle2 = 2 * M_PI; /* angle2角度为360度 */
cairo_set_line_width (cr, 10.0); /* 线宽度： 10像素 */
/* 圆弧： 圆心坐标为(160,198)，半径为100, 起始角度0度,终止角度360度 */
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); /* 红色 */
cairo_arc (cr, xc - 160, yc, radius, angle1, angle2);
cairo_stroke (cr);
/* 圆弧点：圆心坐标为(320,198)，半径为5, 起始角度0度,终止角度360度 */
cairo_set_source_rgb (cr, 0.0, 1.0, 0.0); /* 绿色 */
cairo_arc (cr, xc, yc, 5, angle1, angle2);
cairo_stroke (cr);
/* 虚线圆弧： 圆心坐标为(480,198)，半径为100, 起始角度0度,终止角度360度 */
cairo_set_source_rgb (cr, 0.0, 0.0, 1.0); /* 蓝色 */
double dashes[] = {30,10,10,10}; /* 虚线dashes 连 断 连 断 */
int ndash = sizeof (dashes) / sizeof (dashes[0]);
cairo_set_dash (cr, dashes, ndash, -5 );
cairo_arc (cr, xc + 160, yc, radius, angle1, angle2);
cairo_stroke (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
cairo_destroy (cr);
}
int df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.png",28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 640.0;
canvas -> height = 396.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo006.c 弧形填充fill */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
int df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc, radius, angle1, angle2;
cr = cairo_create (surface);
xc = 320;
yc = 198;
radius = 100;
angle1 = 0.0;
angle2 = 145.0 * (M_PI / 180);
cairo_set_line_width (cr, 10);
cairo_set_source_rgb (cr, 0.0, 0.9, 0.0); /* 绿色弧线 */
cairo_arc (cr, xc - 160, yc, radius, angle1, angle2);
cairo_stroke_preserve (cr);
cairo_set_source_rgb (cr, 0.9, 0.0, 0.0); /* 红色填充 */
cairo_fill (cr);
double dashes[] = {20,10};
int ndash = sizeof (dashes) /sizeof (dashes[0]);
cairo_set_dash (cr, dashes, ndash, 0);
cairo_set_source_rgb (cr, 0.9, 0.0, 0.0); /* 红色虚线圆弧 */
cairo_arc (cr, xc + 160, yc, radius, angle1, 2 * M_PI);
cairo_stroke_preserve (cr);
cairo_set_source_rgb (cr, 0.9, 0.9, 0.0); /* 黄色填充 */
cairo_fill (cr);
cairo_stroke (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
cairo_destroy (cr);
}
int df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 640.0;
canvas -> height = 396.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

向日葵盘列图;我以前用其他编程语言写过，这次用C语言的Cairo库重写一次！

/* cairo007.c df_draw_sunflower 画向日葵 */
/* 在Linux桌面系统下调用数学库中的三角函数sin(), cos() 时，
* gcc需要添加 -lm 调用参数，否则会出错。
* 完整命令如下:
* gcc myfile.c -Wall -lm `pkg-config --cflags --libs cairo`
*/
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
/* df_draw_sunflower 画向日葵
* x,y 向日葵圆心坐标
* radius 向日葵半径
* angle 向日葵两点间的夹角 (黄金分割角 360 * 0.618)
* space 向日葵圈与圈的间距
*/
void df_draw_sunflower (double x, double y, double radius, double angle, double space)
{
cairo_t *cr;
int j;
double x1, y1, angle1, radius1;
cr = cairo_create (surface);
cairo_set_line_width (cr, 2.0); /* 线宽2像素 */
cairo_set_source_rgb (cr, 0.9, 0.9, 0.0); /* 黄色 */
if (! space) space = 1;
angle1 = 0; /* 起始角度0,每次循环递增+angle */
radius1 = 0; /* 起始半径0,循环递增+space直至radius */
do
{
/* 已知起始坐标，半径，角度，求点未知坐标 */
y1 = y + radius1 * sin(angle1 * (M_PI / 180));
x1 = x + radius1 * cos(angle1 * (M_PI / 180));
cairo_arc (cr, x1, y1, 1, 0, 2 * M_PI); /* 画黄色圆点 */
cairo_stroke (cr);
angle1 += angle; /* 递增算出下一个点的角度 */
if (angle1 > j * 360) /* 画完一圈，半径递增+space */
{
radius1 += space;
++j;
}
}while (radius >= radius1);
cairo_destroy (cr);
}
void clear_surface (void)
{
cairo_t *cr;
cr = cairo_create (surface);
cairo_set_source_rgb (cr, 0, 0, 0); /* 黑色 */
cairo_paint (cr);
cairo_destroy (cr);
}
void df_draw_brush (struct df_canvas const *pcanvas)
{
double xc, yc, radius, angle, space;
xc = 300;
yc = 300;
radius = 280;
angle = 360.0 * 0.618; /* 360度角的黄金分割 */
space = 1.0;
clear_surface();/* 设置黑色背景色 */
df_draw_sunflower (xc, yc, radius, angle, space); /* 画向日葵 */
cairo_surface_write_to_png (surface, pcanvas -> filename); /*保存png图片 */
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.png",28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 600.0;
df_init_canvas (canvas); /* 画布surface初始化 */
df_draw_brush (canvas); /* 绘制图形 */
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo009.c 线帽 line cap */
/* * gcc myfile.c -Wall -lm `pkg-config --cflags --libs cairo` */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
void df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc, radius, angle;
int i, linecap[3];
cr = cairo_create (surface);
xc = 300.0;
yc = 120.0;
radius = 100;
angle = 220 * (M_PI / 180);
/* 三种线帽 */
linecap [0] = CAIRO_LINE_CAP_BUTT; /* 缺省值 */
linecap [1] = CAIRO_LINE_CAP_ROUND;
linecap [2] = CAIRO_LINE_CAP_SQUARE;
cairo_set_line_width (cr, 60);
/* 绘制三种类型的线帽 */
for (i = 0; i < 3; ++i)
{
cairo_set_line_cap (cr, linecap [i]);
cairo_arc (cr, xc, yc + i * 300, radius, 0, angle);
cairo_stroke (cr);
}
/* 在原基础上绘制红色半透明缺省线帽 */
cairo_set_source_rgba (cr, 1.0, 0.0, 0.0, 0.4); /* 红色半透明 */
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
for (i = 0; i < 3; ++i)
{
cairo_arc (cr, xc, yc + i * 300, radius, 0, angle);
cairo_stroke (cr);
}
cairo_destroy (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas *) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 900.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo010.c 直线line */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
void df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc;
int i, linecap[3];
cr = cairo_create (surface);
xc = 80.0;
yc = 60.0;
linecap [0] = CAIRO_LINE_CAP_BUTT; /* 缺省值 */
linecap [1] = CAIRO_LINE_CAP_ROUND;
linecap [2] = CAIRO_LINE_CAP_SQUARE;
cairo_set_line_width (cr, 40);
/* 绘制三种类型的线帽 */
for (i = 0; i < 3; i++)
{
cairo_set_line_cap (cr, linecap[i]);
cairo_move_to (cr, xc + i * 100, yc);
cairo_line_to (cr, xc + i * 100, yc + 250);
cairo_stroke (cr);
}
/* 在原基础上绘制红色半透明缺省线帽 */
cairo_set_source_rgba (cr, 1.0, 0.0, 0.0, 0.4);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
for (i = 0; i < 3; i++)
{
cairo_move_to (cr, xc + i * 100, yc);
cairo_line_to (cr, xc + i * 100, yc +250);
}
cairo_stroke (cr);
/* 虚线 */
double dashes[] = {30,10,10,10};
int ndash = sizeof (dashes) / sizeof (dashes [0]);
cairo_set_dash (cr, dashes, ndash, 0);
cairo_move_to (cr, xc + 300, yc);
cairo_line_to (cr, xc + 500, yc + 250);
cairo_stroke (cr);
cairo_destroy (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas *) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 370.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo011.c 线与线的连接样式 cairo_set_line_join */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
void df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc;
int i, linejoin[3];
cr = cairo_create (surface);
xc = 40.0;
yc = 320.0;
linejoin [0] = CAIRO_LINE_JOIN_MITER; /* 缺省值 */
linejoin [1] = CAIRO_LINE_JOIN_BEVEL;
linejoin [2] = CAIRO_LINE_JOIN_ROUND;
cairo_set_line_width (cr, 40);
/* 绘制三种线与线的连接样式 */
for (i = 0; i < 3; i++)
{
cairo_set_line_join (cr, linejoin [i]);
cairo_move_to (cr, xc + i * 200, yc); /* 起始点 A */
cairo_line_to (cr, xc + 60 + i * 200, yc - 200); /* 连接点 B */
cairo_line_to (cr, xc + 120 + i * 200, yc); /* 终结点 C */
cairo_stroke (cr);
}
xc = 100;
yc = 500;
/* 绘制半弧与线的连接样式 */
for (i = 0; i < 3; i++)
{
cairo_arc (cr, xc + i * 200, yc, 60, 0, M_PI);
cairo_set_line_join (cr, linejoin [i]);
cairo_line_to (cr, xc + i * 200, yc -100);
cairo_stroke (cr);
}
cairo_destroy (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas *) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 640.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo012.c 线区域填充 */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
void df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double xc, yc;
cr = cairo_create (surface);
xc = 100.0;
yc = 300.0;
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 30);
/* 绘制三角形 */
cairo_move_to (cr, xc, yc); /* A点(100,300) */
cairo_line_to (cr, xc, yc - 200.0); /* B点(100,100) */
cairo_line_to (cr, xc +124.0, yc); /* C点(224,300) */
cairo_close_path (cr);
/* 绘制D型 */
cairo_move_to (cr, 360, 100); /* D型左上角点 */
cairo_rel_line_to (cr, 100, 0); /* 以当前坐标(360,100)为圆点画线 */
cairo_rel_line_to (cr, 50, 50); /* 以当前坐标(460,100)为圆点画线 */
cairo_rel_line_to (cr, 0, 100); /* 以当前坐标(510,150)为圆点画线 */
cairo_rel_line_to (cr, -50, 50);
cairo_rel_line_to (cr, -100, 0);
cairo_close_path (cr);
/* 填充颜色 */
cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 0.4); /* 蓝色半透明 */
cairo_fill_preserve (cr);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* 黑色边框 */
cairo_stroke (cr);
cairo_destroy (cr);
cairo_surface_write_to_png (surface, pcanvas -> filename);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas *) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 370.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

五角星图，同一圆心绘制两次！

下图是原始五角星图，蓝色是长半径，绿色是短半径

/* cairo013.c 绘制多角型 */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
/* df_draw_star 画多角型
* point 角的个数 (五角星五个角)
* ratio 短半径与长半径的比率
* x,y 角中心坐标
* radius 长半径
* 角的起始角度
*/
void df_draw_star (int point, double ratio, double x, double y, double radius, double angle)
{
cairo_t *cr;
double xc, yc, radius1, radius2, angle1, angle2;
int i;
cr = cairo_create (surface);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 20);
radius1 = radius * ratio; /* 根据比率计算短半径长度 */
angle1 = angle * (M_PI / 180); /* 起始角度转弧度 */
angle2 = (360 / (point * 2)) * (M_PI / 180); /* 五角星有10个点连接而成,均分360度角 */
/* 计算起始点坐标 */
xc = x + radius * cos(angle1);
yc = y + radius * sin(angle1);
cairo_move_to (cr, xc, yc);
radius2 = radius1; /* radius2 做临时变量 */
angle1 += angle2; /* 第二个点角度 */
/* 开始画多角形 */
for (i = 0; i < point * 2 -1; i++)
{
xc = x + radius2 * cos(angle1);
yc = y + radius2 * sin(angle1);
cairo_line_to (cr, xc, yc);
angle1 += angle2;
radius2 = (i % 2 == 0) ? radius: radius1;
}
cairo_close_path (cr);
cairo_set_source_rgba (cr, 1.0, 1.0, 0.0, 0.6); /* 黄色半透明填充 */
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr, 1.0, 0.0, 0.0, 0.6); /* 红色半透明边框 */
cairo_stroke (cr);
cairo_destroy (cr);
}
void df_draw_brush (struct df_canvas const *pcanvas)
{
int point;
double ratio, x, y, radius, angle;
point = 5;
ratio = 0.382;
x = 300.0;
y = 300.0;
radius = 200.0;
angle = -18;
df_draw_star (point, ratio, x, y, radius, angle); /* 绘制五角星 */
df_draw_star (point, ratio, x, y, radius - 100, angle);
cairo_surface_write_to_png (surface, pcanvas -> filename);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas *) malloc (sizeof (struct df_canvas));
strncpy (canvas -> filename, "hello.png", 28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 600.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}

/* cairo 四边形 rectangle */
#include <cairo.h>
#include <stdlib.h>
#include <string.h>
static cairo_surface_t *surface = NULL;
struct df_canvas
{
char filename[28];
int type;
double width;
double height;
};
void df_draw_brush (struct df_canvas const *pcanvas)
{
cairo_t *cr;
double width, height;
int i, linejoin[3];
cr = cairo_create (surface);
linejoin [0] = CAIRO_LINE_JOIN_MITER; /* 缺省值 */
linejoin [1] = CAIRO_LINE_JOIN_BEVEL;
linejoin [2] = CAIRO_LINE_JOIN_ROUND;
cairo_set_line_width (cr, 40);
cairo_set_source_rgba (cr, 0.0, 0.0, 0.1, 0.8);
width = 120.0;
height = 120.0;
/* 三种线条样式画四边形 */
for (i = 0; i < 3; i ++)
{
cairo_set_line_join (cr, linejoin [i]); /* 设置边框样式 */
cairo_rectangle (cr, 40 + i * (width + 80), 100, width, height);
cairo_stroke (cr);
}
cairo_set_line_width (cr, 8);
width = 80.0;
height = 180.0;
/* 渐变透明度画四边形 */
for (i = 0; i < 6; i ++)
{
cairo_rectangle (cr, 20 + i * (width + 16), 340, width, height);
cairo_set_source_rgba (cr, 0.8, 0.5, 0.2, 0.18 * (i + 1)); /* 渐变色 */
cairo_fill_preserve (cr);
cairo_set_source_rgb (cr, 0.9, 0.7, 0.4); /* 边框色 */
cairo_stroke (cr);
}
cairo_surface_write_to_png (surface, pcanvas -> filename);
cairo_destroy (cr);
}
void df_init_canvas (struct df_canvas const *pcanvas)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, (int) pcanvas -> width, (int) pcanvas -> height);
}
int main (int argc, char *argv[])
{
struct df_canvas *canvas;
canvas = (struct df_canvas*) malloc (sizeof (struct df_canvas));
strncpy(canvas -> filename, "hello.png",28);
canvas -> type = CAIRO_SURFACE_TYPE_IMAGE;
canvas -> width = 600.0;
canvas -> height = 600.0;
df_init_canvas (canvas);
df_draw_brush (canvas);
free (canvas);
if (surface != NULL) cairo_surface_destroy (surface);
return 0;
}