g_spawn_command_line_sync 这个函数 怎么理解

heyj6969

g_spawn_command_line_sync  这个函数 怎么理解   
谢谢！！！

没本

难道楼主都只用百度么？
http://tadeboro.blogspot.com/200 ... ses-using-glib.html

1. 
   
2. /*
   
3. * Compile me with:
   
4. *   gcc -o spawn spawn.c $(pkg-config --cflags --libs gtk+-2.0)
   
5. */
   
6. #include <gtk/gtk.h>
   
7. 
   
8. typedef struct _Data Data;
   
9. struct _Data {
   
10.     /*
    
11.      * Buffers that will display output
    
12.      */
    
13.     GtkTextBuffer  *out;
    
14.     GtkTextBuffer  *err;
    
15. 
    
16.     /*
    
17.      * Progress bar that will be updated
    
18.      */
    
19.     GtkProgressBar *progress;
    
20. 
    
21.     /*
    
22.      * Timeout source id
    
23.      */
    
24.     gint            timeout_id;
    
25. };
    
26. 
    
27. static void
    
28. cb_child_watch(GPid pid, gint status, Data * data)
    
29. {
    
30.     /*
    
31.      * Remove timeout callback
    
32.      */
    
33.     g_source_remove(data->timeout_id);
    
34. 
    
35.     /*
    
36.      * Close pid
    
37.      */
    
38.     g_spawn_close_pid(pid);
    
39. }
    
40. 
    
41. static          gboolean
    
42. cb_out_watch(GIOChannel * channel, GIOCondition cond, Data * data)
    
43. {
    
44.     gchar          *string;
    
45.     gsize           size;
    
46. 
    
47.     if (cond == G_IO_HUP) {
    
48.         g_io_channel_unref(channel);
    
49.         return (FALSE);
    
50.     }
    
51. 
    
52.     g_io_channel_read_line(channel, &string, &size, NULL, NULL);
    
53.     gtk_text_buffer_insert_at_cursor(data->out, string, -1);
    
54.     g_free(string);
    
55. 
    
56.     return (TRUE);
    
57. }
    
58. 
    
59. static          gboolean
    
60. cb_err_watch(GIOChannel * channel, GIOCondition cond, Data * data)
    
61. {
    
62.     gchar          *string;
    
63.     gsize           size;
    
64. 
    
65.     if (cond == G_IO_HUP) {
    
66.         g_io_channel_unref(channel);
    
67.         return (FALSE);
    
68.     }
    
69. 
    
70.     g_io_channel_read_line(channel, &string, &size, NULL, NULL);
    
71.     gtk_text_buffer_insert_at_cursor(data->err, string, -1);
    
72.     g_free(string);
    
73. 
    
74.     return (TRUE);
    
75. }
    
76. 
    
77. static          gboolean
    
78. cb_timeout(Data * data)
    
79. {
    
80.     /*
    
81.      * Bounce progress bar
    
82.      */
    
83.     gtk_progress_bar_pulse(data->progress);
    
84. 
    
85.     return (TRUE);
    
86. }
    
87. 
    
88. static void
    
89. cb_execute(GtkButton * button, Data * data)
    
90. {
    
91.     GPid            pid;
    
92.     gchar          *argv[] = { "./helper", NULL };
    
93.     gint            out,
    
94.                     err;
    
95.     GIOChannel     *out_ch,
    
96.                    *err_ch;
    
97.     gboolean        ret;
    
98. 
    
99.     /*
    
100.      * Spawn child process
     
101.      */
     
102.     ret = g_spawn_async_with_pipes(NULL, argv, NULL,
     
103.                                    G_SPAWN_DO_NOT_REAP_CHILD, NULL,
     
104.                                    NULL, &pid, NULL, &out, &err, NULL);
     
105.     if (!ret) {
     
106.         g_error("SPAWN FAILED");
     
107.         return;
     
108.     }
     
109. 
     
110.     /*
     
111.      * Add watch function to catch termination of the process. This
     
112.      * function * will clean any remnants of process.
     
113.      */
     
114.     g_child_watch_add(pid, (GChildWatchFunc) cb_child_watch, data);
     
115. 
     
116.     /*
     
117.      * Create channels that will be used to read data from pipes.
     
118.      */
     
119. #ifdef G_OS_WIN32
     
120.     out_ch = g_io_channel_win32_new_fd(out);
     
121.     err_ch = g_io_channel_win32_new_fd(err);
     
122. #else
     
123.     out_ch = g_io_channel_unix_new(out);
     
124.     err_ch = g_io_channel_unix_new(err);
     
125. #endif
     
126. 
     
127.     /*
     
128.      * Add watches to channels
     
129.      */
     
130.     g_io_add_watch(out_ch, G_IO_IN | G_IO_HUP, (GIOFunc) cb_out_watch,
     
131.                    data);
     
132.     g_io_add_watch(err_ch, G_IO_IN | G_IO_HUP, (GIOFunc) cb_err_watch,
     
133.                    data);
     
134. 
     
135.     /*
     
136.      * Install timeout fnction that will move the progress bar
     
137.      */
     
138.     data->timeout_id = g_timeout_add(100, (GSourceFunc) cb_timeout, data);
     
139. }
     
140. 
     
141. int
     
142. main(int argc, char **argv)
     
143. {
     
144.     GtkWidget      *window,
     
145.                    *table,
     
146.                    *button,
     
147.                    *progress,
     
148.                    *text;
     
149.     Data           *data;
     
150. 
     
151.     data = g_slice_new(Data);
     
152. 
     
153.     gtk_init(&argc, &argv);
     
154. 
     
155.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     
156.     gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
     
157.     g_signal_connect(G_OBJECT(window), "destroy",
     
158.                      G_CALLBACK(gtk_main_quit), NULL);
     
159. 
     
160.     table = gtk_table_new(2, 2, FALSE);
     
161.     gtk_table_set_row_spacings(GTK_TABLE(table), 6);
     
162.     gtk_table_set_col_spacings(GTK_TABLE(table), 6);
     
163.     gtk_container_add(GTK_CONTAINER(window), table);
     
164. 
     
165.     button = gtk_button_new_from_stock(GTK_STOCK_EXECUTE);
     
166.     g_signal_connect(G_OBJECT(button), "clicked",
     
167.                      G_CALLBACK(cb_execute), data);
     
168.     gtk_table_attach(GTK_TABLE(table), button, 0, 1, 0, 1,
     
169.                      GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
     
170. 
     
171.     progress = gtk_progress_bar_new();
     
172.     data->progress = GTK_PROGRESS_BAR(progress);
     
173.     gtk_table_attach(GTK_TABLE(table), progress, 1, 2, 0, 1,
     
174.                      GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
     
175. 
     
176.     text = gtk_text_view_new();
     
177.     data->out = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
     
178.     gtk_table_attach(GTK_TABLE(table), text, 0, 1, 1, 2,
     
179.                      GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
     
180. 
     
181.     text = gtk_text_view_new();
     
182.     data->err = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
     
183.     gtk_table_attach(GTK_TABLE(table), text, 1, 2, 1, 2,
     
184.                      GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
     
185. 
     
186.     gtk_widget_show_all(window);
     
187. 
     
188.     gtk_main();
     
189. 
     
190.     g_slice_free(Data, data);
     
191. 
     
192.     return (0);
     
193. }
     

复制代码

gothicane

类似system函数吧