关于gtk控件显示与截图的一个问题

headmaster_1

小弟现在在eclipse下做一个GUI开发的插件，就是通过拖拽编辑图形界面，最终生成一个GTK的图形界面应用，类似于glade的功能，但是图形编辑的代码是在eclipse下用java写的。

1. 
   
2. <P style="LINE-HEIGHT: 30px; TEXT-INDENT: 2em">
   
3. <BLOCKQUOTE>static GdkPixmap* copyPixmap(GdkPixmap *source, gint width, gint height) {
   
4. if (source) {
   
5. GdkPixmap* pixmap = gdk_pixmap_new(source, width, height, -1);
   
6. GdkGC *gc = gdk_gc_new(source);
   
7. gdk_draw_drawable(pixmap, gc, source, 0, 0, 0, 0, -1, -1);
   
8. g_object_unref(gc);
   
9. g_object_unref(source);
   
10. return pixmap;
    
11. }
    
12. return NULL;
    
13. }
    
14. JNIEnv *m_envir;
    
15. jobject m_callback;
    
16. jmethodID m_IScreenshotCallback_storeImage;
    
17. //
    
18. typedef struct _GdkWindowPaint GdkWindowPaint;
    
19. struct _GdkWindowPaint {
    
20. GdkRegion *region;
    
21. GdkPixmap *pixmap;
    
22. gint x_offset;
    
23. gint y_offset;
    
24. };
    
25. static void exposeAllWidgetsCallback(GtkWidget *widget, gpointer data);
    
26. //
    
27. #define PREPARE_EVENT \
    
28. GdkEventExpose ev;\
    
29. ev.type = GDK_EXPOSE;\
    
30. ev.send_event = TRUE;\
    
31. ev.area.x = 0;\
    
32. ev.area.y = 0;\
    
33. ev.count = 0;
    
34. #define UPDATE_EVENT \
    
35. gdk_window_get_geometry(ev.window, NULL, NULL, &ev.area.width, &ev.area.height, NULL);\
    
36. ev.region = gdk_region_rectangle(&ev.area);
    
37. static void exposeWidget(GtkWidget *widget) {
    
38. GdkWindow *window = widget->window;
    
39. if (!GTK_WIDGET_REALIZED(widget)) {
    
40. return;
    
41. }
    
42. // g_warning ("type = %s", G_OBJECT_TYPE_NAME (widget));
    
43. if (GTK_IS_SPIN_BUTTON(widget)) {
    
44. // spin button
    
45. GtkWidgetClass *clazz = (GtkWidgetClass *)GTK_SPIN_BUTTON_GET_CLASS(widget);
    
46. GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
    
47. {
    
48. PREPARE_EVENT
    
49. ev.window = spin->panel;
    
50. UPDATE_EVENT
    
51. clazz->expose_event(widget, &ev);
    
52. }
    
53. // spin button also contains GtkEntry, so give a chance to expose it too, so no 'else' statement
    
54. }
    
55. if (GTK_IS_ENTRY(widget)) {
    
56. // single text
    
57. GtkWidgetClass *clazz = (GtkWidgetClass *)GTK_ENTRY_GET_CLASS(widget);
    
58. {
    
59. PREPARE_EVENT
    
60. ev.window = window;
    
61. UPDATE_EVENT
    
62. clazz->expose_event(widget, &ev);
    
63. }
    
64. //
    
65. {
    
66. PREPARE_EVENT
    
67. ev.window = ((GtkEntry*)widget)->text_area;
    
68. UPDATE_EVENT
    
69. clazz->expose_event(widget, &ev);
    
70. }
    
71. } else if (GTK_IS_TEXT_VIEW(widget)) {
    
72. // multi-line text
    
73. {
    
74. PREPARE_EVENT
    
75. ev.window = gtk_text_view_get_window((GtkTextView *)widget, GTK_TEXT_WINDOW_TEXT);
    
76. UPDATE_EVENT
    
77. gtk_widget_send_expose(widget, (GdkEvent*)&ev);
    
78. }
    
79. } else if (GTK_IS_TREE_VIEW(widget)) {
    
80. // tree
    
81. GtkWidgetClass *clazz = (GtkWidgetClass *)GTK_TREE_VIEW_GET_CLASS(widget);
    
82. GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
    
83. {
    
84. PREPARE_EVENT
    
85. ev.window = gtk_tree_view_get_bin_window(tree_view);
    
86. UPDATE_EVENT
    
87. clazz->expose_event(widget, &ev);
    
88. }
    
89. } else {
    
90. // everything else
    
91. {
    
92. PREPARE_EVENT
    
93. ev.window = window;
    
94. UPDATE_EVENT
    
95. gtk_widget_send_expose(widget, (GdkEvent*)&ev);
    
96. }
    
97. }
    
98. }
    
99. static void exposeAllWidgets(GtkWidget *widget) {
    
100. if (!GTK_IS_WIDGET(widget)) {
     
101. return;
     
102. }
     
103. exposeWidget(widget);
     
104. if (!GTK_IS_CONTAINER(widget)) {
     
105. return;
     
106. }
     
107. GtkContainer *container = GTK_CONTAINER(widget);
     
108. gtk_container_forall(container, exposeAllWidgetsCallback, 0);
     
109. }
     
110. static GdkPixmap* getPixmap(GdkWindow *window, int shouldCallback) {
     
111. if (!gdk_window_is_visible(window)) {
     
112. // don't deal with unmapped windows
     
113. return NULL;
     
114. }
     
115. gint width, height;
     
116. gdk_window_get_geometry(window, NULL, NULL, &width, &height, NULL);
     
117. //
     
118. GdkRectangle rect;
     
119. rect.x = 0; rect.y = 0; rect.width = width; rect.height = height;
     
120. //
     
121. GdkRegion *region = gdk_region_rectangle(&rect);
     
122. gdk_window_begin_paint_region(window, region);
     
123. //
     
124. region = gdk_region_rectangle(&rect);
     
125. gdk_window_invalidate_region(window, region, TRUE);
     
126. //
     
127. gpointer widget = NULL;
     
128. gdk_window_get_user_data(window, &widget);
     
129. if (widget != NULL) {
     
130. exposeAllWidgets((GtkWidget*)widget);
     
131. }
     
132. //
     
133. gdk_window_process_updates(window, TRUE);
     
134. //
     
135. GdkWindowObject *private = (GdkWindowObject *)(window);
     
136. GdkPixmap *internalPixmap = ((GdkWindowPaint *)private->paint_stack->data)->pixmap;
     
137. if (internalPixmap == NULL) {
     
138. return NULL;
     
139. }
     
140. //
     
141. g_object_ref(internalPixmap);
     
142. GdkPixmap *pixmap = copyPixmap(internalPixmap, width, height);
     
143. gdk_window_end_paint(window);
     
144. //
     
145. if (shouldCallback) {
     
146. (*m_envir)->CallVoidMethod(m_envir, m_callback, m_IScreenshotCallback_storeImage, wrap_pointer(m_envir, widget), wrap_pointer(m_envir, pixmap));
     
147. }
     
148. //
     
149. return pixmap;
     
150. }
     
151. static GdkPixmap* traverse(GdkWindow *window, int shouldCallback){
     
152. gint depth;
     
153. gdk_window_get_geometry(window, NULL, NULL, NULL, NULL, &depth);
     
154. // strange window
     
155. if (depth == 0) {
     
156. return NULL;
     
157. }
     
158. //
     
159. GdkPixmap *pixmap = getPixmap(window, shouldCallback);
     
160. if (pixmap == NULL) {
     
161. return NULL;
     
162. }
     
163. //
     
164. GdkGC *gc = gdk_gc_new(pixmap);
     
165. GList *children = gdk_window_get_children(window);
     
166. guint length = g_list_length(children);
     
167. //
     
168. guint i;
     
169. for (i = 0; i < length; i++) {
     
170. GdkWindow *win = g_list_nth_data(children, i);
     
171. GdkPixmap* pix = traverse(win, shouldCallback);
     
172. if (pix == NULL) {
     
173. continue;
     
174. }
     
175. gint x, y, width, height;
     
176. gdk_window_get_geometry(win, &x, &y, &width, &height, NULL);
     
177. gdk_draw_drawable(pixmap, gc, pix, 0, 0, x, y, width, height);
     
178. if (!shouldCallback) {
     
179. g_object_unref(pix);
     
180. }
     
181. }
     
182. g_object_unref(gc);
     
183. return pixmap;
     
184. }
     
185. static void exposeAllWidgetsCallback(GtkWidget *widget, gpointer data) {
     
186. exposeAllWidgets(widget);
     
187. }
     
188. static GdkPixmap* makeShot(GtkWidget* shellWidget) {
     
189. GdkWindow *window = shellWidget->window;
     
190. return traverse(window, m_callback != NULL);
     
191. }
     
192. JNIEXPORT JHANDLE JNICALL OS_NATIVE(_1makeShot)(
     
193. JNIEnv *envir, jobject that, JHANDLE widgetHandle, jobject callback) {
     
194. m_envir = envir;
     
195. if (callback != NULL) {
     
196. m_callback = (*envir)->NewGlobalRef(envir, callback);
     
197. jclass clazz = (*envir)->GetObjectClass(envir, m_callback);
     
198. m_IScreenshotCallback_storeImage = (*envir)->GetMethodID(envir, clazz, "storeImage", CALLBACK_SIG);
     
199. }
     
200. // make shot
     
201. GdkPixmap* pixmap = makeShot((GtkWidget*)unwrap_pointer(envir, widgetHandle));
     
202. // clean up
     
203. if (callback != NULL) {
     
204. (*envir)->DeleteGlobalRef(envir, m_callback);
     
205. }
     
206. m_callback = NULL;
     
207. return (JHANDLE)wrap_pointer(envir, pixmap);
     
208. }
     

复制代码

为了使图形编辑时控件的图形尽可能逼真，我采取了这样一个方案：在后台运行起一个GTK的程序，这个GTK程序是由java代码控制运行起来的（实际是java代码通过JNI调用C代码运行起来）。假设现在这个GTK程序有三个Widget：一个Window，一个Fixed，一个Button。我在创建了这个Button并调用gtk_widget_show()方法显示出这个Button后，马上调用了一段“截图”的代码，代码如下：

代码最下方的_1makeShot是提供给java代码调用的C接口，这个接口再调用了倒数第二个函数 static GdkPixmap* makeShot(GtkWidget* shellWidget)开始截图。也就是说这段截图的代码是通过把指向GtkWidget的指针作为参数，最终获取的返回结果是GdkPixmap*，即这个Widget的图形数据。java代码获取到这个图形数据后，再将其显示在我们的GUI开发工具上

但是现在遇到了一个问题：我调用上述截图代码截到的图有点“滞后”了，我每次在新创建一个控件后马上截到的图是空白，而过一会截到的图才是正确的图。

即

button = gtk_button_new();

gtk_widget_show(button);

makeShot(button);

这样一个逻辑最终截到的控件的图是空白。

如果我不将makeShot(button)紧跟在gtk_widget_show(button)的后面，过一会再调用makeShot(button)（比如在线程中睡一会）是可以截到正确的button的图的。

我在网上看到有人说gtk_widget_show()这个函数本身是异步的，它只是发了一个信号，具体的控件绘制工作会在后台进行。再根据我做的实验（即上一段所说的在调用gtk_widget_show()后睡一会再截图就能截到），出现这个现象的原因似乎就是由于控件的绘制是异步的，使得我截图的逻辑在控件绘制前就完成了。

但是我这个项目本身具备特殊性，需要我必须实时地去截控件的图。例如用户在编辑控件时改变了控件的大小，这时控件的图形必然发生了变化，我需要马上改变后台控件的大小，并马上截下这个改变了大小的控件的图并将其绘制在前端的窗口上。基本就是用户的操作导致了GUI编辑窗口的重绘，后台运行的GTK窗口也要发生变化，GUI应用要马上截控件的图并反映在图形编辑窗口上。

我曾经试过编写expose事件的回调函数，即

g_signal_connect(button, "expose_event", G_CALLBACK(callback), NULL)

我以为在调用expose_event的回调时控件的绘制已经完成了，所以这时应该可以正常截图。但是我关联了这个回调之后，发现控件根本绘制不出来了。看来是我对expose_event回调理解有误。

现在的问题是：

1、gtk_widget_show()实现控件绘制是异步的吗？

2、如果gtk_widget_show()是异步的，有没有什么方法能让控件的绘制变成同步的吗？

3、为什么编写expose_event的回调会让控件根本不再绘制？难道是这个事件本身有默认的回调函数，在这个默认的回调中会进行控件绘制，而我关联了自己的回调函数就没有调用控件绘制的代码，是这样吗？

各位大神帮帮忙~~~

headmaster_1

代码这块不知道怎么格式化啊，看上去不太好看

ACTom

gtk_widget_show() 确实是异步的。