怎样用cairo来制作动画，并且不干扰用户交互

realtang

该文主要参考
http://cairographics.org/threaded_animation_with_cairo/
我做的改进的地方是用了，GThread而不用pthread。
主要的思路是，当显示比较耗费处理器的动画时，可以把动画显示部分放在单独的线程里处理。
假设代码所保存的文件名称为cairoanim.c ，可以用以下命令编译。
gcc -g cairoanim.c -o cairoanim `pkg-config --cflags --libs gtk+-2.0 gthread-2.0`
在windows mingw下编译，测试通过。

2. #include <gtk/gtk.h>
4. //the global pixmap that will serve as our buffer
5. static GdkPixmap *pixmap = NULL;
6. static guint timer_id = 0;
8. gboolean on_window_delete( GtkWidget *wgt, GdkEvent  *event, gpointer data)
9. {
10.         if( timer_id)
11.         g_source_remove( timer_id);
12.         gtk_main_quit();
13.         return FALSE;
14. }
16. gboolean on_window_configure_event(GtkWidget * da, GdkEventConfigure * event, gpointer user_data)
17. {
18.         static int oldw = 0;
19.         static int oldh = 0;
20.         //make our selves a properly sized pixmap if our window has been resized
21.         if (oldw != event->width || oldh != event->height){
22.                 g_object_unref(pixmap);
23.                 //create our new pixmap with the correct size.
24.                 pixmap = gdk_pixmap_new(da->window, event->width,  event->height, -1);
25.         }
26.         oldw = event->width;
27.         oldh = event->height;
28.         return TRUE;
29. }
31. gboolean on_window_expose_event(GtkWidget * da, GdkEventExpose * event, gpointer user_data)
32. {
33.         gdk_draw_drawable(da->window,
34.         da->style->fg_gc[GTK_WIDGET_STATE(da)], pixmap,
35.         // Only copy the area that was exposed.
36.         event->area.x, event->area.y,
37.         event->area.x, event->area.y,
38.         event->area.width, event->area.height);
39.         return TRUE;
40. }
43. static int currently_drawing = 0;
44. //do_draw will be executed in a separate thread whenever we would like to update
45. //our animation
46. void *do_draw(void *ptr)
47. {
49.         currently_drawing = 1;
51.         int width, height;
52.         gdk_threads_enter();
53.         gdk_drawable_get_size(pixmap, &width, &height);
54.         gdk_threads_leave();
56.         //create a gtk-independant surface to draw on
57.         cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
58.         cairo_t *cr = cairo_create(cst);
60.         //do some time-consuming drawing
61.         static int i = 0;
62.         ++i; i = i % 300;   //give a little movement to our animation
63.         cairo_set_source_rgb (cr, .5, .5, .5);
64.         cairo_paint(cr);
65.         int j;
66.         for(j=0; j < 1000; ++j){
67.                 cairo_set_source_rgb (cr, (double)j/1000.0, (double)j/1000.0, 1.0 - (double)j/1000.0);
68.                 cairo_move_to(cr, i,j/2);
69.                 cairo_line_to(cr, i+100,j/2);
70.                 cairo_stroke(cr);
71.         }
72.         cairo_destroy(cr);
75.         //When dealing with gdkPixmap's, we need to make sure not to
76.         //access them from outside gtk_main().
77.         gdk_threads_enter();
79.         cairo_t *cr_pixmap = gdk_cairo_create(pixmap);
80.         cairo_set_source_surface (cr_pixmap, cst, 0, 0);
81.         cairo_paint(cr_pixmap);
82.         cairo_destroy(cr_pixmap);
84.         gdk_threads_leave();
86.         cairo_surface_destroy(cst);
88.         currently_drawing = 0;
90.         return NULL;
91. }
93. gboolean timer_exe(GtkWidget * window)
94. {
96.         static gboolean first_execution = TRUE;
98.         //use a safe function to get the value of currently_drawing so
99.         //we don't run into the usual multithreading issues
100.         int drawing_status = g_atomic_int_get(&currently_drawing);
102.         //if we are not currently drawing anything, launch a thread to
103.         //update our pixmap
104.         if(drawing_status == 0){
105.                 static GThread *thread_info = NULL;
106.                 int  iret;
107.                 if(first_execution != TRUE){
108.                         g_thread_join( thread_info);
109.                 }
110.                 thread_info = g_thread_create_full( (GThreadFunc)do_draw,
111.                 NULL,
112.                 0,
113.                 TRUE,
114.                 FALSE,
115.                 (GThreadPriority)0,
116.                 NULL);
117.         }
119.         //tell our window it is time to draw our animation.
120.         int width, height;
121.         gdk_drawable_get_size(pixmap, &width, &height);
122.         gtk_widget_queue_draw_area(window, 0, 0, width, height);
124.         first_execution = FALSE;
126.         return TRUE;
128. }
131. int main (int argc, char *argv[])
132. {
134.         //we need to initialize all these functions so that gtk knows
135.         //to be thread-aware
136.         if (!g_thread_supported ()){ g_thread_init(NULL); }
137.         gdk_threads_init();
138.         gdk_threads_enter();
140.         gtk_init(&argc, &argv);
142.         GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
143.         g_signal_connect(window, "delete-event", G_CALLBACK(on_window_delete), NULL);
144.         g_signal_connect(window, "expose_event", G_CALLBACK(on_window_expose_event), NULL);
145.         g_signal_connect(window, "configure_event", G_CALLBACK(on_window_configure_event), NULL);
147.         //this must be done before we define our pixmap so that it can reference
148.         //the colour depth and such
149.         gtk_widget_show_all(window);
151.         //set up our pixmap so it is ready for drawing
152.         pixmap = gdk_pixmap_new(window->window,100,100,-1);
153.         //because we will be painting our pixmap manually during expose events
154.         //we can turn off gtk's automatic painting and double buffering routines.
155.         gtk_widget_set_app_paintable(window, TRUE);
156.         gtk_widget_set_double_buffered(window, FALSE);
158.         (void)g_timeout_add(33, (GSourceFunc)timer_exe, window);
161.         gtk_main();
162.         gdk_threads_leave();
164.         return 0;
165. }

复制代码