Mercurial > geeqie.yaz
annotate src/editors.c @ 1276:4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
author | zas_ |
---|---|
date | Tue, 03 Feb 2009 08:41:21 +0000 |
parents | 8fcdfacce91d |
children | c5852c543775 |
rev | line source |
---|---|
9 | 1 /* |
196 | 2 * Geeqie |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
3 * (C) 2006 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
9 | 5 * |
6 * Author: John Ellis | |
7 * | |
8 * This software is released under the GNU General Public License (GNU GPL). | |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
11 */ | |
12 | |
13 | |
281 | 14 #include "main.h" |
9 | 15 #include "editors.h" |
16 | |
669 | 17 #include "filedata.h" |
18 #include "filefilter.h" | |
1022
9962b24b6b43
Move miscellaneous functions to their own files (new misc.[ch]).
zas_
parents:
1000
diff
changeset
|
19 #include "misc.h" |
9 | 20 #include "ui_fileops.h" |
21 #include "ui_spinner.h" | |
22 #include "ui_utildlg.h" | |
1022
9962b24b6b43
Move miscellaneous functions to their own files (new misc.[ch]).
zas_
parents:
1000
diff
changeset
|
23 #include "utilops.h" |
9 | 24 |
25 #include <errno.h> | |
26 | |
27 | |
28 #define EDITOR_WINDOW_WIDTH 500 | |
29 #define EDITOR_WINDOW_HEIGHT 300 | |
30 | |
31 | |
32 | |
33 typedef struct _EditorVerboseData EditorVerboseData; | |
34 struct _EditorVerboseData { | |
35 GenericDialog *gd; | |
36 GtkWidget *button_close; | |
37 GtkWidget *button_stop; | |
38 GtkWidget *text; | |
39 GtkWidget *progress; | |
40 GtkWidget *spinner; | |
140 | 41 }; |
42 | |
43 typedef struct _EditorData EditorData; | |
44 struct _EditorData { | |
45 gint flags; | |
46 GPid pid; | |
47 GList *list; | |
9 | 48 gint count; |
49 gint total; | |
140 | 50 gboolean stopping; |
51 EditorVerboseData *vd; | |
52 EditorCallback callback; | |
53 gpointer data; | |
1272 | 54 const EditorDescription *editor; |
9 | 55 }; |
56 | |
57 | |
140 | 58 static void editor_verbose_window_progress(EditorData *ed, const gchar *text); |
59 static gint editor_command_next_start(EditorData *ed); | |
60 static gint editor_command_next_finish(EditorData *ed, gint status); | |
61 static gint editor_command_done(EditorData *ed); | |
1272 | 62 static gint editor_command_parse(const EditorDescription *editor, GList *list, gchar **output); |
9 | 63 |
64 /* | |
65 *----------------------------------------------------------------------------- | |
66 * external editor routines | |
67 *----------------------------------------------------------------------------- | |
68 */ | |
69 | |
1272 | 70 GHashTable *editors = NULL; |
71 | |
72 #ifdef G_KEY_FILE_DESKTOP_GROUP | |
73 #define DESKTOP_GROUP G_KEY_FILE_DESKTOP_GROUP | |
74 #else | |
75 #define DESKTOP_GROUP "Desktop Entry" | |
76 #endif | |
77 | |
78 void editor_description_free(EditorDescription *editor) | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
79 { |
1272 | 80 if (!editor) return; |
81 | |
82 g_free(editor->key); | |
83 g_free(editor->name); | |
84 g_free(editor->exec); | |
85 g_free(editor->menu_path); | |
86 g_free(editor->hotkey); | |
87 string_list_free(editor->ext_list); | |
88 g_free(editor->icon); | |
89 g_free(editor->file); | |
90 g_free(editor); | |
91 } | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
92 |
1272 | 93 static GList *editor_mime_types_to_extensions(gchar **mime_types) |
94 { | |
95 /* FIXME: this should be rewritten to use the shared mime database, as soon as we switch to gio */ | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
96 |
1272 | 97 static const gchar *conv_table[][2] = { |
98 {"application/x-ufraw", "%raw"}, | |
99 {"image/*", "*"}, | |
100 {"image/bmp", ".bmp"}, | |
101 {"image/gif", ".gif"}, | |
102 {"image/jpeg", ".jpeg;.jpg"}, | |
103 {"image/jpg", ".jpg;.jpeg"}, | |
104 {"image/pcx", ".pcx"}, | |
105 {"image/png", ".png"}, | |
106 {"image/svg", ".svg"}, | |
107 {"image/svg+xml", ".svg"}, | |
108 {"image/svg+xml-compressed", ".svg"}, | |
109 {"image/tiff", ".tiff;.tif"}, | |
110 {"image/x-bmp", ".bmp"}, | |
111 {"image/x-canon-crw", ".crw"}, | |
112 {"image/x-cr2", ".cr2"}, | |
113 {"image/x-dcraw", "%raw"}, | |
114 {"image/x-ico", ".ico"}, | |
115 {"image/x-mrw", ".mrw"}, | |
116 {"image/x-MS-bmp", ".bmp"}, | |
117 {"image/x-nef", ".nef"}, | |
118 {"image/x-orf", ".orf"}, | |
119 {"image/x-pcx", ".pcx"}, | |
120 {"image/xpm", ".xpm"}, | |
121 {"image/x-png", ".png"}, | |
122 {"image/x-portable-anymap", ".pam"}, | |
123 {"image/x-portable-bitmap", ".pbm"}, | |
124 {"image/x-portable-graymap", ".pgm"}, | |
125 {"image/x-portable-pixmap", ".ppm"}, | |
126 {"image/x-psd", ".psd"}, | |
127 {"image/x-raf", ".raf"}, | |
128 {"image/x-sgi", ".sgi"}, | |
129 {"image/x-tga", ".tga"}, | |
130 {"image/x-xbitmap", ".xbm"}, | |
131 {"image/x-xcf", ".xcf"}, | |
132 {"image/x-xpixmap", ".xpm"}, | |
133 {"image/x-x3f", ".x3f"}, | |
134 {NULL, NULL}}; | |
135 | |
136 gint i, j; | |
137 GList *list = NULL; | |
138 | |
139 for (i = 0; mime_types[i]; i++) | |
140 for (j = 0; conv_table[j][0]; j++) | |
141 if (strcmp(mime_types[i], conv_table[j][0]) == 0) | |
142 list = g_list_concat(list, filter_to_list(conv_table[j][1])); | |
143 | |
144 return list; | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
145 } |
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
146 |
1272 | 147 static gboolean editor_read_desktop_file(const gchar *path) |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
148 { |
1272 | 149 GKeyFile *key_file; |
150 EditorDescription *editor; | |
151 gchar *extensions; | |
152 const gchar *key = filename_from_path(path); | |
153 gchar **categories, **only_show_in, **not_show_in; | |
1274 | 154 gchar *try_exec; |
1272 | 155 |
156 if (g_hash_table_lookup(editors, key)) return FALSE; /* the file found earlier wins */ | |
157 | |
158 key_file = g_key_file_new(); | |
159 if (!g_key_file_load_from_file(key_file, path, 0, NULL)) | |
160 { | |
161 g_key_file_free(key_file); | |
162 return FALSE; | |
163 } | |
164 | |
165 editor = g_new0(EditorDescription, 1); | |
166 | |
167 editor->key = g_strdup(key); | |
168 editor->file = g_strdup(path); | |
169 | |
170 g_hash_table_insert(editors, editor->key, editor); | |
171 | |
172 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Hidden", NULL)) editor->hidden = TRUE; | |
173 | |
174 categories = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "Categories", NULL, NULL); | |
175 if (categories) | |
176 { | |
177 gboolean found = FALSE; | |
178 gint i; | |
179 for (i = 0; categories[i]; i++) | |
180 /* IMHO "Graphics" is exactly the category that we are interested in, so this does not have to be configurable */ | |
181 if (strcmp(categories[i], "Graphics") == 0 || | |
182 strcmp(categories[i], "X-Geeqie") == 0) | |
183 { | |
184 found = TRUE; | |
185 break; | |
186 } | |
187 if (!found) editor->hidden = TRUE; | |
188 g_strfreev(categories); | |
189 } | |
190 else | |
191 { | |
192 editor->hidden = TRUE; | |
193 } | |
194 | |
195 only_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "OnlyShowIn", NULL, NULL); | |
196 if (only_show_in) | |
197 { | |
198 gboolean found = FALSE; | |
199 gint i; | |
200 for (i = 0; only_show_in[i]; i++) | |
201 if (strcmp(only_show_in[i], "X-Geeqie") == 0) | |
202 { | |
203 found = TRUE; | |
204 break; | |
205 } | |
206 if (!found) editor->hidden = TRUE; | |
207 g_strfreev(only_show_in); | |
208 } | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
209 |
1272 | 210 not_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "NotShowIn", NULL, NULL); |
211 if (not_show_in) | |
212 { | |
213 gboolean found = FALSE; | |
214 gint i; | |
215 for (i = 0; not_show_in[i]; i++) | |
216 if (strcmp(not_show_in[i], "X-Geeqie") == 0) | |
217 { | |
218 found = TRUE; | |
219 break; | |
220 } | |
221 if (found) editor->hidden = TRUE; | |
222 g_strfreev(not_show_in); | |
223 } | |
224 | |
1274 | 225 |
226 try_exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "TryExec", NULL); | |
227 if (try_exec && !editor->hidden) | |
228 { | |
229 gchar *try_exec_res = g_find_program_in_path(try_exec); | |
230 if (!try_exec_res) editor->hidden = TRUE; | |
231 g_free(try_exec_res); | |
232 g_free(try_exec); | |
233 } | |
234 | |
1272 | 235 if (editor->hidden) |
236 { | |
237 /* hidden editors will be deleted, no need to parse the rest */ | |
238 g_key_file_free(key_file); | |
239 return TRUE; | |
240 } | |
241 | |
242 editor->name = g_key_file_get_locale_string(key_file, DESKTOP_GROUP, "Name", NULL, NULL); | |
243 editor->icon = g_key_file_get_string(key_file, DESKTOP_GROUP, "Icon", NULL); | |
244 | |
245 editor->exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "Exec", NULL); | |
246 | |
247 /* we take only editors that accept parameters, FIXME: the test can be improved */ | |
248 if (!strchr(editor->exec, '%')) editor->hidden = TRUE; | |
249 | |
250 editor->menu_path = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Menu-Path", NULL); | |
251 if (!editor->menu_path) editor->menu_path = g_strdup("EditMenu/ExternalMenu"); | |
252 | |
253 editor->hotkey = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Hotkey", NULL); | |
254 | |
255 extensions = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-File-Extensions", NULL); | |
256 if (extensions) | |
257 editor->ext_list = filter_to_list(extensions); | |
258 else | |
259 { | |
260 gchar **mime_types = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "MimeType", NULL, NULL); | |
261 if (mime_types) | |
262 { | |
263 editor->ext_list = editor_mime_types_to_extensions(mime_types); | |
264 g_strfreev(mime_types); | |
265 if (!editor->ext_list) editor->hidden = TRUE; | |
266 } | |
267 | |
268 } | |
269 | |
270 | |
271 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Keep-Fullscreen", NULL)) editor->flags |= EDITOR_KEEP_FS; | |
272 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose", NULL)) editor->flags |= EDITOR_VERBOSE; | |
273 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose-Multi", NULL)) editor->flags |= EDITOR_VERBOSE_MULTI; | |
274 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Filter", NULL)) editor->flags |= EDITOR_DEST; | |
275 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Terminal", NULL)) editor->flags |= EDITOR_TERMINAL; | |
276 | |
277 | |
278 editor->flags |= editor_command_parse(editor, NULL, NULL); | |
279 g_key_file_free(key_file); | |
280 | |
281 return TRUE; | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
282 } |
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
283 |
1272 | 284 static gboolean editor_remove_desktop_file_cb(gpointer key, gpointer value, gpointer user_data) |
285 { | |
286 EditorDescription *editor = value; | |
287 return editor->hidden; | |
288 } | |
289 | |
290 static void editor_read_desktop_dir(const gchar *path) | |
9 | 291 { |
1272 | 292 DIR *dp; |
293 struct dirent *dir; | |
294 gchar *pathl; | |
295 | |
296 pathl = path_from_utf8(path); | |
297 dp = opendir(pathl); | |
298 g_free(pathl); | |
299 if (!dp) | |
300 { | |
301 /* dir not found */ | |
302 return; | |
303 } | |
304 while ((dir = readdir(dp)) != NULL) | |
305 { | |
306 gchar *namel = dir->d_name; | |
307 size_t len = strlen(namel); | |
308 | |
309 if (len > 8 && strncasecmp(namel + len - 8, ".desktop", 8) == 0) | |
310 { | |
311 gchar *name = path_to_utf8(namel); | |
312 gchar *dpath = g_build_filename(path, name, NULL); | |
313 editor_read_desktop_file(dpath); | |
314 g_free(dpath); | |
315 g_free(name); | |
316 } | |
317 } | |
318 closedir(dp); | |
319 } | |
320 | |
321 void editor_load_descriptions(void) | |
322 { | |
323 gchar *path; | |
324 gchar *xdg_data_dirs; | |
325 gchar *all_dirs; | |
326 gchar **split_dirs; | |
9 | 327 gint i; |
1272 | 328 |
329 if (!editors) | |
330 { | |
331 editors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify)editor_description_free); | |
332 } | |
9 | 333 |
1272 | 334 xdg_data_dirs = getenv("XDG_DATA_DIRS"); |
335 if (xdg_data_dirs && xdg_data_dirs[0]) | |
336 xdg_data_dirs = path_to_utf8(xdg_data_dirs); | |
337 else | |
338 xdg_data_dirs = g_strdup("/usr/share"); | |
339 | |
1274 | 340 all_dirs = g_strconcat(get_rc_dir(), ":", GQ_APP_DIR, ":", xdg_data_home_get(), ":", xdg_data_dirs, NULL); |
1272 | 341 |
342 g_free(xdg_data_dirs); | |
343 | |
344 split_dirs = g_strsplit(all_dirs, ":", 0); | |
345 | |
346 g_free(all_dirs); | |
347 | |
348 for (i = 0; split_dirs[i]; i++) | |
9 | 349 { |
1272 | 350 path = g_build_filename(split_dirs[i], "applications", NULL); |
351 editor_read_desktop_dir(path); | |
352 g_free(path); | |
9 | 353 } |
1272 | 354 |
355 g_strfreev(split_dirs); | |
356 | |
357 g_hash_table_foreach_remove(editors, editor_remove_desktop_file_cb, NULL); | |
9 | 358 } |
359 | |
1272 | 360 static void editor_list_add_cb(gpointer key, gpointer value, gpointer data) |
361 { | |
362 GList **listp = data; | |
363 EditorDescription *editor = value; | |
364 | |
365 /* do not show the special commands in any list, they are called explicitelly */ | |
366 if (strcmp(editor->key, CMD_COPY) == 0 || | |
367 strcmp(editor->key, CMD_MOVE) == 0 || | |
368 strcmp(editor->key, CMD_RENAME) == 0 || | |
369 strcmp(editor->key, CMD_DELETE) == 0 || | |
370 strcmp(editor->key, CMD_FOLDER) == 0) return; | |
371 | |
372 *listp = g_list_prepend(*listp, editor); | |
373 } | |
374 | |
1276
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
375 static gint editor_sort(gconstpointer a, gconstpointer b) |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
376 { |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
377 const EditorDescription *ea = a; |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
378 const EditorDescription *eb = b; |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
379 int ret; |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
380 |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
381 ret = strcmp(ea->menu_path, eb->menu_path); |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
382 if (ret != 0) return ret; |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
383 |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
384 return g_utf8_collate(ea->name, eb->name); |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
385 } |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
386 |
1272 | 387 GList *editor_list_get(void) |
388 { | |
389 GList *editors_list = NULL; | |
390 g_hash_table_foreach(editors, editor_list_add_cb, &editors_list); | |
1276
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
391 editors_list = g_list_sort(editors_list, editor_sort); |
4177057ca11b
editor_list_get() now returns a sorted list, this way items appear in the same order in all menus.
zas_
parents:
1274
diff
changeset
|
392 |
1272 | 393 return editors_list; |
394 } | |
395 | |
396 /* ------------------------------ */ | |
397 | |
398 | |
140 | 399 static void editor_verbose_data_free(EditorData *ed) |
400 { | |
401 if (!ed->vd) return; | |
402 g_free(ed->vd); | |
403 ed->vd = NULL; | |
404 } | |
405 | |
406 static void editor_data_free(EditorData *ed) | |
407 { | |
408 editor_verbose_data_free(ed); | |
409 g_free(ed); | |
410 } | |
411 | |
9 | 412 static void editor_verbose_window_close(GenericDialog *gd, gpointer data) |
413 { | |
140 | 414 EditorData *ed = data; |
9 | 415 |
416 generic_dialog_close(gd); | |
140 | 417 editor_verbose_data_free(ed); |
418 if (ed->pid == -1) editor_data_free(ed); /* the process has already terminated */ | |
9 | 419 } |
420 | |
421 static void editor_verbose_window_stop(GenericDialog *gd, gpointer data) | |
422 { | |
140 | 423 EditorData *ed = data; |
424 ed->stopping = TRUE; | |
425 ed->count = 0; | |
426 editor_verbose_window_progress(ed, _("stopping...")); | |
9 | 427 } |
428 | |
429 static void editor_verbose_window_enable_close(EditorVerboseData *vd) | |
430 { | |
431 vd->gd->cancel_cb = editor_verbose_window_close; | |
432 | |
433 spinner_set_interval(vd->spinner, -1); | |
434 gtk_widget_set_sensitive(vd->button_stop, FALSE); | |
435 gtk_widget_set_sensitive(vd->button_close, TRUE); | |
436 } | |
437 | |
140 | 438 static EditorVerboseData *editor_verbose_window(EditorData *ed, const gchar *text) |
9 | 439 { |
440 EditorVerboseData *vd; | |
441 GtkWidget *scrolled; | |
442 GtkWidget *hbox; | |
443 gchar *buf; | |
444 | |
445 vd = g_new0(EditorVerboseData, 1); | |
446 | |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
447 vd->gd = file_util_gen_dlg(_("Edit command results"), "editor_results", |
9 | 448 NULL, FALSE, |
140 | 449 NULL, ed); |
9 | 450 buf = g_strdup_printf(_("Output of %s"), text); |
451 generic_dialog_add_message(vd->gd, NULL, buf, NULL); | |
452 g_free(buf); | |
453 vd->button_stop = generic_dialog_add_button(vd->gd, GTK_STOCK_STOP, NULL, | |
454 editor_verbose_window_stop, FALSE); | |
455 gtk_widget_set_sensitive(vd->button_stop, FALSE); | |
456 vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, NULL, | |
457 editor_verbose_window_close, TRUE); | |
458 gtk_widget_set_sensitive(vd->button_close, FALSE); | |
459 | |
460 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
461 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
462 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
463 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
464 gtk_box_pack_start(GTK_BOX(vd->gd->vbox), scrolled, TRUE, TRUE, 5); | |
465 gtk_widget_show(scrolled); | |
466 | |
467 vd->text = gtk_text_view_new(); | |
468 gtk_text_view_set_editable(GTK_TEXT_VIEW(vd->text), FALSE); | |
469 gtk_widget_set_size_request(vd->text, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_HEIGHT); | |
470 gtk_container_add(GTK_CONTAINER(scrolled), vd->text); | |
471 gtk_widget_show(vd->text); | |
472 | |
473 hbox = gtk_hbox_new(FALSE, 0); | |
474 gtk_box_pack_start(GTK_BOX(vd->gd->vbox), hbox, FALSE, FALSE, 0); | |
475 gtk_widget_show(hbox); | |
476 | |
477 vd->progress = gtk_progress_bar_new(); | |
478 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vd->progress), 0.0); | |
479 gtk_box_pack_start(GTK_BOX(hbox), vd->progress, TRUE, TRUE, 0); | |
480 gtk_widget_show(vd->progress); | |
481 | |
482 vd->spinner = spinner_new(NULL, SPINNER_SPEED); | |
483 gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0); | |
484 gtk_widget_show(vd->spinner); | |
442 | 485 |
9 | 486 gtk_widget_show(vd->gd->dialog); |
487 | |
140 | 488 ed->vd = vd; |
9 | 489 return vd; |
490 } | |
491 | |
492 static void editor_verbose_window_fill(EditorVerboseData *vd, gchar *text, gint len) | |
493 { | |
494 GtkTextBuffer *buffer; | |
495 GtkTextIter iter; | |
496 | |
497 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(vd->text)); | |
498 gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1); | |
499 gtk_text_buffer_insert(buffer, &iter, text, len); | |
500 } | |
501 | |
140 | 502 static void editor_verbose_window_progress(EditorData *ed, const gchar *text) |
9 | 503 { |
140 | 504 if (!ed->vd) return; |
505 | |
506 if (ed->total) | |
9 | 507 { |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
508 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ed->vd->progress), (gdouble)ed->count / ed->total); |
9 | 509 } |
510 | |
140 | 511 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ed->vd->progress), (text) ? text : ""); |
9 | 512 } |
513 | |
514 static gboolean editor_verbose_io_cb(GIOChannel *source, GIOCondition condition, gpointer data) | |
515 { | |
140 | 516 EditorData *ed = data; |
9 | 517 gchar buf[512]; |
518 gsize count; | |
519 | |
140 | 520 if (condition & G_IO_IN) |
9 | 521 { |
140 | 522 while (g_io_channel_read_chars(source, buf, sizeof(buf), &count, NULL) == G_IO_STATUS_NORMAL) |
523 { | |
524 if (!g_utf8_validate(buf, count, NULL)) | |
9 | 525 { |
140 | 526 gchar *utf8; |
444 | 527 |
140 | 528 utf8 = g_locale_to_utf8(buf, count, NULL, NULL, NULL); |
529 if (utf8) | |
9 | 530 { |
140 | 531 editor_verbose_window_fill(ed->vd, utf8, -1); |
532 g_free(utf8); | |
9 | 533 } |
534 else | |
535 { | |
288
d1f74154463e
Replace occurences of Geeqie / geeqie by constants defined in main.h.
zas_
parents:
283
diff
changeset
|
536 editor_verbose_window_fill(ed->vd, "Error converting text to valid utf8\n", -1); |
9 | 537 } |
538 } | |
140 | 539 else |
540 { | |
541 editor_verbose_window_fill(ed->vd, buf, count); | |
542 } | |
543 } | |
9 | 544 } |
545 | |
140 | 546 if (condition & (G_IO_ERR | G_IO_HUP)) |
9 | 547 { |
140 | 548 g_io_channel_shutdown(source, TRUE, NULL); |
9 | 549 return FALSE; |
550 } | |
551 | |
552 return TRUE; | |
553 } | |
554 | |
138 | 555 typedef enum { |
556 PATH_FILE, | |
1272 | 557 PATH_FILE_URL, |
140 | 558 PATH_DEST |
138 | 559 } PathType; |
560 | |
561 | |
1272 | 562 static gchar *editor_command_path_parse(const FileData *fd, PathType type, const EditorDescription *editor) |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
563 { |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
564 GString *string; |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
565 gchar *pathl; |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
566 const gchar *p = NULL; |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
567 |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
568 string = g_string_new(""); |
442 | 569 |
1272 | 570 if (type == PATH_FILE || type == PATH_FILE_URL) |
138 | 571 { |
1272 | 572 GList *work = editor->ext_list; |
442 | 573 |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
574 if (!work) |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
575 p = fd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
576 else |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
577 { |
516 | 578 while (work) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
579 { |
444 | 580 GList *work2; |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
581 gchar *ext = work->data; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
582 work = work->next; |
442 | 583 |
584 if (strcmp(ext, "*") == 0 || | |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
585 strcasecmp(ext, fd->extension) == 0) |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
586 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
587 p = fd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
588 break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
589 } |
442 | 590 |
444 | 591 work2 = fd->sidecar_files; |
516 | 592 while (work2) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
593 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
594 FileData *sfd = work2->data; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
595 work2 = work2->next; |
442 | 596 |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
597 if (strcasecmp(ext, sfd->extension) == 0) |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
598 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
599 p = sfd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
600 break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
601 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
602 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
603 if (p) break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
604 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
605 if (!p) return NULL; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
606 } |
138 | 607 } |
140 | 608 else if (type == PATH_DEST) |
138 | 609 { |
610 if (fd->change && fd->change->dest) | |
611 p = fd->change->dest; | |
612 else | |
613 p = ""; | |
614 } | |
444 | 615 |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
616 while (*p != '\0') |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
617 { |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
618 /* must escape \, ", `, and $ to avoid problems, |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
619 * we assume system shell supports bash-like escaping |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
620 */ |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
621 if (strchr("\\\"`$", *p) != NULL) |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
622 { |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
623 string = g_string_append_c(string, '\\'); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
624 } |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
625 string = g_string_append_c(string, *p); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
626 p++; |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
627 } |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
628 |
1272 | 629 if (type == PATH_FILE_URL) g_string_prepend(string, "file://"); |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
630 pathl = path_from_utf8(string->str); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
631 g_string_free(string, TRUE); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
632 |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
633 return pathl; |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
634 } |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
635 |
9 | 636 |
1272 | 637 static gint editor_command_parse(const EditorDescription *editor, GList *list, gchar **output) |
9 | 638 { |
140 | 639 gint flags = 0; |
1272 | 640 const gchar *p; |
140 | 641 GString *result = NULL; |
442 | 642 |
140 | 643 if (output) |
644 result = g_string_new(""); | |
645 | |
1272 | 646 if (editor->exec[0] == '\0') |
140 | 647 { |
648 flags |= EDITOR_ERROR_EMPTY; | |
649 goto err; | |
650 } | |
669 | 651 |
1272 | 652 p = editor->exec; |
669 | 653 /* skip leading whitespaces if any */ |
654 while (g_ascii_isspace(*p)) p++; | |
442 | 655 |
140 | 656 /* command */ |
442 | 657 |
140 | 658 while (*p) |
659 { | |
660 if (*p != '%') | |
661 { | |
662 if (output) result = g_string_append_c(result, *p); | |
663 } | |
664 else /* *p == '%' */ | |
665 { | |
666 gchar *pathl = NULL; | |
9 | 667 |
140 | 668 p++; |
442 | 669 |
670 switch (*p) | |
140 | 671 { |
1272 | 672 case 'f': /* single file */ |
673 case 'u': /* single url */ | |
140 | 674 flags |= EDITOR_FOR_EACH; |
675 if (flags & EDITOR_SINGLE_COMMAND) | |
676 { | |
677 flags |= EDITOR_ERROR_INCOMPATIBLE; | |
678 goto err; | |
679 } | |
680 if (output) | |
681 { | |
682 /* use the first file from the list */ | |
442 | 683 if (!list || !list->data) |
140 | 684 { |
685 flags |= EDITOR_ERROR_NO_FILE; | |
686 goto err; | |
687 } | |
669 | 688 pathl = editor_command_path_parse((FileData *)list->data, |
1272 | 689 (*p == 'f') ? PATH_FILE : PATH_FILE_URL, |
690 editor); | |
442 | 691 if (!pathl) |
140 | 692 { |
693 flags |= EDITOR_ERROR_NO_FILE; | |
694 goto err; | |
695 } | |
696 result = g_string_append_c(result, '"'); | |
697 result = g_string_append(result, pathl); | |
698 g_free(pathl); | |
699 result = g_string_append_c(result, '"'); | |
700 } | |
442 | 701 break; |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
702 |
1272 | 703 case 'F': |
704 case 'U': | |
140 | 705 flags |= EDITOR_SINGLE_COMMAND; |
706 if (flags & (EDITOR_FOR_EACH | EDITOR_DEST)) | |
707 { | |
708 flags |= EDITOR_ERROR_INCOMPATIBLE; | |
709 goto err; | |
710 } | |
711 | |
712 if (output) | |
713 { | |
714 /* use whole list */ | |
715 GList *work = list; | |
716 gboolean ok = FALSE; | |
444 | 717 |
140 | 718 while (work) |
719 { | |
720 FileData *fd = work->data; | |
1272 | 721 pathl = editor_command_path_parse(fd, (*p == 'F') ? PATH_FILE : PATH_FILE_URL, editor); |
140 | 722 |
723 if (pathl) | |
724 { | |
725 ok = TRUE; | |
726 if (work != list) g_string_append_c(result, ' '); | |
727 result = g_string_append_c(result, '"'); | |
728 result = g_string_append(result, pathl); | |
729 g_free(pathl); | |
730 result = g_string_append_c(result, '"'); | |
731 } | |
732 work = work->next; | |
733 } | |
442 | 734 if (!ok) |
140 | 735 { |
736 flags |= EDITOR_ERROR_NO_FILE; | |
737 goto err; | |
738 } | |
739 } | |
442 | 740 break; |
1272 | 741 case 'i': |
742 if (output) | |
743 { | |
744 result = g_string_append(result, editor->icon); | |
745 } | |
746 break; | |
747 case 'c': | |
748 if (output) | |
749 { | |
750 result = g_string_append(result, editor->name); | |
751 } | |
752 break; | |
753 case 'k': | |
754 if (output) | |
755 { | |
756 result = g_string_append(result, editor->file); | |
757 } | |
758 break; | |
669 | 759 case '%': |
760 /* %% = % escaping */ | |
761 if (output) result = g_string_append_c(result, *p); | |
762 break; | |
1272 | 763 case 'd': |
764 case 'D': | |
765 case 'n': | |
766 case 'N': | |
767 case 'v': | |
768 case 'm': | |
769 /* deprecated according to spec, ignore */ | |
770 break; | |
140 | 771 default: |
772 flags |= EDITOR_ERROR_SYNTAX; | |
773 goto err; | |
774 } | |
775 } | |
776 p++; | |
9 | 777 } |
778 | |
140 | 779 if (output) *output = g_string_free(result, FALSE); |
780 return flags; | |
781 | |
442 | 782 |
140 | 783 err: |
442 | 784 if (output) |
9 | 785 { |
140 | 786 g_string_free(result, TRUE); |
787 *output = NULL; | |
788 } | |
789 return flags; | |
790 } | |
791 | |
1272 | 792 |
140 | 793 static void editor_child_exit_cb (GPid pid, gint status, gpointer data) |
794 { | |
795 EditorData *ed = data; | |
796 g_spawn_close_pid(pid); | |
797 ed->pid = -1; | |
442 | 798 |
140 | 799 editor_command_next_finish(ed, status); |
800 } | |
801 | |
802 | |
1272 | 803 static gint editor_command_one(const EditorDescription *editor, GList *list, EditorData *ed) |
140 | 804 { |
805 gchar *command; | |
806 FileData *fd = list->data; | |
807 GPid pid; | |
442 | 808 gint standard_output; |
809 gint standard_error; | |
140 | 810 gboolean ok; |
811 | |
812 ed->pid = -1; | |
1272 | 813 ed->flags = editor->flags | editor_command_parse(editor, list, &command); |
140 | 814 |
815 ok = !(ed->flags & EDITOR_ERROR_MASK); | |
816 | |
817 if (ok) | |
818 { | |
737
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
819 ok = (options->shell.path && *options->shell.path); |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
820 if (!ok) log_printf("ERROR: empty shell command\n"); |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
821 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
822 if (ok) |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
823 { |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
824 ok = (access(options->shell.path, X_OK) == 0); |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
825 if (!ok) log_printf("ERROR: cannot execute shell command '%s'\n", options->shell.path); |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
826 } |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
827 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
828 if (!ok) ed->flags |= EDITOR_ERROR_CANT_EXEC; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
829 } |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
830 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
831 if (ok) |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
832 { |
443 | 833 gchar *working_directory; |
834 gchar *args[4]; | |
737
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
835 guint n = 0; |
443 | 836 |
837 working_directory = remove_level_from_path(fd->path); | |
737
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
838 args[n++] = options->shell.path; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
839 if (options->shell.options && *options->shell.options) |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
840 args[n++] = options->shell.options; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
841 args[n++] = command; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
842 args[n] = NULL; |
443 | 843 |
1272 | 844 if ((ed->flags & EDITOR_DEST) && fd->change && fd->change->dest) /* FIXME: error handling */ |
845 { | |
846 setenv("GEEQIE_DESTINATION", fd->change->dest, TRUE); | |
847 } | |
848 else | |
849 { | |
850 unsetenv("GEEQIE_DESTINATION"); | |
851 } | |
852 | |
442 | 853 ok = g_spawn_async_with_pipes(working_directory, args, NULL, |
140 | 854 G_SPAWN_DO_NOT_REAP_CHILD, /* GSpawnFlags */ |
442 | 855 NULL, NULL, |
856 &pid, | |
857 NULL, | |
858 ed->vd ? &standard_output : NULL, | |
859 ed->vd ? &standard_error : NULL, | |
140 | 860 NULL); |
443 | 861 |
862 g_free(working_directory); | |
442 | 863 |
140 | 864 if (!ok) ed->flags |= EDITOR_ERROR_CANT_EXEC; |
865 } | |
866 | |
442 | 867 if (ok) |
140 | 868 { |
869 g_child_watch_add(pid, editor_child_exit_cb, ed); | |
870 ed->pid = pid; | |
871 } | |
442 | 872 |
140 | 873 if (ed->vd) |
874 { | |
875 if (!ok) | |
9 | 876 { |
140 | 877 gchar *buf; |
878 | |
1272 | 879 buf = g_strdup_printf(_("Failed to run command:\n%s\n"), editor->file); |
140 | 880 editor_verbose_window_fill(ed->vd, buf, strlen(buf)); |
881 g_free(buf); | |
882 | |
883 } | |
442 | 884 else |
140 | 885 { |
886 GIOChannel *channel_output; | |
887 GIOChannel *channel_error; | |
444 | 888 |
140 | 889 channel_output = g_io_channel_unix_new(standard_output); |
890 g_io_channel_set_flags(channel_output, G_IO_FLAG_NONBLOCK, NULL); | |
926 | 891 g_io_channel_set_encoding(channel_output, NULL, NULL); |
140 | 892 |
893 g_io_add_watch_full(channel_output, G_PRIORITY_HIGH, G_IO_IN | G_IO_ERR | G_IO_HUP, | |
894 editor_verbose_io_cb, ed, NULL); | |
895 g_io_channel_unref(channel_output); | |
896 | |
897 channel_error = g_io_channel_unix_new(standard_error); | |
898 g_io_channel_set_flags(channel_error, G_IO_FLAG_NONBLOCK, NULL); | |
926 | 899 g_io_channel_set_encoding(channel_error, NULL, NULL); |
140 | 900 |
901 g_io_add_watch_full(channel_error, G_PRIORITY_HIGH, G_IO_IN | G_IO_ERR | G_IO_HUP, | |
902 editor_verbose_io_cb, ed, NULL); | |
903 g_io_channel_unref(channel_error); | |
904 } | |
905 } | |
442 | 906 |
140 | 907 g_free(command); |
908 | |
909 return ed->flags & EDITOR_ERROR_MASK; | |
910 } | |
911 | |
912 static gint editor_command_next_start(EditorData *ed) | |
913 { | |
914 if (ed->vd) editor_verbose_window_fill(ed->vd, "\n", 1); | |
915 | |
916 if (ed->list && ed->count < ed->total) | |
917 { | |
918 FileData *fd; | |
919 gint error; | |
920 | |
921 fd = ed->list->data; | |
922 | |
923 if (ed->vd) | |
924 { | |
925 editor_verbose_window_progress(ed, (ed->flags & EDITOR_FOR_EACH) ? fd->path : _("running...")); | |
926 } | |
927 ed->count++; | |
928 | |
1272 | 929 error = editor_command_one(ed->editor, ed->list, ed); |
140 | 930 if (!error && ed->vd) |
931 { | |
932 gtk_widget_set_sensitive(ed->vd->button_stop, (ed->list != NULL) ); | |
933 if (ed->flags & EDITOR_FOR_EACH) | |
9 | 934 { |
140 | 935 editor_verbose_window_fill(ed->vd, fd->path, strlen(fd->path)); |
936 editor_verbose_window_fill(ed->vd, "\n", 1); | |
9 | 937 } |
938 } | |
140 | 939 |
442 | 940 if (!error) |
140 | 941 return 0; |
942 else | |
943 /* command was not started, call the finish immediately */ | |
944 return editor_command_next_finish(ed, 0); | |
945 } | |
442 | 946 |
140 | 947 /* everything is done */ |
237
404629011caa
Add missing return at the end of editor_command_next_start().
zas_
parents:
196
diff
changeset
|
948 return editor_command_done(ed); |
140 | 949 } |
950 | |
951 static gint editor_command_next_finish(EditorData *ed, gint status) | |
952 { | |
953 gint cont = ed->stopping ? EDITOR_CB_SKIP : EDITOR_CB_CONTINUE; | |
954 | |
955 if (status) | |
956 ed->flags |= EDITOR_ERROR_STATUS; | |
957 | |
958 if (ed->flags & EDITOR_FOR_EACH) | |
959 { | |
960 /* handle the first element from the list */ | |
961 GList *fd_element = ed->list; | |
444 | 962 |
140 | 963 ed->list = g_list_remove_link(ed->list, fd_element); |
964 if (ed->callback) | |
911 | 965 { |
140 | 966 cont = ed->callback(ed->list ? ed : NULL, ed->flags, fd_element, ed->data); |
911 | 967 if (ed->stopping && cont == EDITOR_CB_CONTINUE) cont = EDITOR_CB_SKIP; |
968 } | |
140 | 969 filelist_free(fd_element); |
9 | 970 } |
971 else | |
972 { | |
140 | 973 /* handle whole list */ |
974 if (ed->callback) | |
975 cont = ed->callback(NULL, ed->flags, ed->list, ed->data); | |
976 filelist_free(ed->list); | |
977 ed->list = NULL; | |
978 } | |
9 | 979 |
140 | 980 if (cont == EDITOR_CB_SUSPEND) |
981 return ed->flags & EDITOR_ERROR_MASK; | |
982 else if (cont == EDITOR_CB_SKIP) | |
983 return editor_command_done(ed); | |
984 else | |
985 return editor_command_next_start(ed); | |
986 } | |
9 | 987 |
140 | 988 static gint editor_command_done(EditorData *ed) |
989 { | |
990 gint flags; | |
9 | 991 |
140 | 992 if (ed->vd) |
993 { | |
444 | 994 const gchar *text; |
995 | |
140 | 996 if (ed->count == ed->total) |
9 | 997 { |
140 | 998 text = _("done"); |
9 | 999 } |
1000 else | |
1001 { | |
140 | 1002 text = _("stopped by user"); |
9 | 1003 } |
140 | 1004 editor_verbose_window_progress(ed, text); |
1005 editor_verbose_window_enable_close(ed->vd); | |
1006 } | |
1007 | |
1008 /* free the not-handled items */ | |
1009 if (ed->list) | |
1010 { | |
1011 ed->flags |= EDITOR_ERROR_SKIPPED; | |
1012 if (ed->callback) ed->callback(NULL, ed->flags, ed->list, ed->data); | |
1013 filelist_free(ed->list); | |
1014 ed->list = NULL; | |
1015 } | |
9 | 1016 |
140 | 1017 ed->count = 0; |
1018 | |
1019 flags = ed->flags & EDITOR_ERROR_MASK; | |
1020 | |
1021 if (!ed->vd) editor_data_free(ed); | |
1022 | |
1023 return flags; | |
1024 } | |
1025 | |
1026 void editor_resume(gpointer ed) | |
1027 { | |
1028 editor_command_next_start(ed); | |
1029 } | |
443 | 1030 |
140 | 1031 void editor_skip(gpointer ed) |
1032 { | |
442 | 1033 editor_command_done(ed); |
9 | 1034 } |
1035 | |
1272 | 1036 static gint editor_command_start(const EditorDescription *editor, const gchar *text, GList *list, EditorCallback cb, gpointer data) |
140 | 1037 { |
1038 EditorData *ed; | |
1272 | 1039 gint flags = editor->flags; |
442 | 1040 |
140 | 1041 if (flags & EDITOR_ERROR_MASK) return flags & EDITOR_ERROR_MASK; |
1042 | |
1043 ed = g_new0(EditorData, 1); | |
1044 ed->list = filelist_copy(list); | |
1045 ed->flags = flags; | |
1272 | 1046 ed->editor = editor; |
140 | 1047 ed->total = (flags & EDITOR_SINGLE_COMMAND) ? 1 : g_list_length(list); |
1048 ed->count = 0; | |
1049 ed->stopping = FALSE; | |
1050 ed->callback = cb; | |
1051 ed->data = data; | |
442 | 1052 |
140 | 1053 if ((flags & EDITOR_VERBOSE_MULTI) && list && list->next) |
1054 flags |= EDITOR_VERBOSE; | |
442 | 1055 |
140 | 1056 if (flags & EDITOR_VERBOSE) |
1057 editor_verbose_window(ed, text); | |
442 | 1058 |
1059 editor_command_next_start(ed); | |
140 | 1060 /* errors from editor_command_next_start will be handled via callback */ |
1061 return flags & EDITOR_ERROR_MASK; | |
1062 } | |
1063 | |
1272 | 1064 gboolean is_valid_editor_command(const gchar *key) |
444 | 1065 { |
1272 | 1066 if (!key) return FALSE; |
1067 return g_hash_table_lookup(editors, key) != NULL; | |
444 | 1068 } |
1069 | |
1272 | 1070 gint start_editor_from_filelist_full(const gchar *key, GList *list, EditorCallback cb, gpointer data) |
9 | 1071 { |
140 | 1072 gint error; |
1272 | 1073 EditorDescription *editor; |
1074 if (!key) return FALSE; | |
1075 | |
1076 editor = g_hash_table_lookup(editors, key); | |
9 | 1077 |
444 | 1078 if (!list) return FALSE; |
1272 | 1079 if (!editor) return FALSE; |
1080 | |
1081 error = editor_command_start(editor, editor->name, list, cb, data); | |
9 | 1082 |
1272 | 1083 if (error & EDITOR_ERROR_MASK) |
669 | 1084 { |
1272 | 1085 gchar *text = g_strdup_printf(_("%s\n\"%s\""), editor_get_error_str(error), editor->file); |
669 | 1086 |
1087 file_util_warning_dialog(_("Invalid editor command"), text, GTK_STOCK_DIALOG_ERROR, NULL); | |
1088 g_free(text); | |
1089 } | |
1090 | |
140 | 1091 return error; |
9 | 1092 } |
1093 | |
1272 | 1094 gint start_editor_from_filelist(const gchar *key, GList *list) |
140 | 1095 { |
1272 | 1096 return start_editor_from_filelist_full(key, list, NULL, NULL); |
140 | 1097 } |
1098 | |
1272 | 1099 gint start_editor_from_file_full(const gchar *key, FileData *fd, EditorCallback cb, gpointer data) |
9 | 1100 { |
1101 GList *list; | |
140 | 1102 gint error; |
9 | 1103 |
138 | 1104 if (!fd) return FALSE; |
9 | 1105 |
138 | 1106 list = g_list_append(NULL, fd); |
1272 | 1107 error = start_editor_from_filelist_full(key, list, cb, data); |
9 | 1108 g_list_free(list); |
140 | 1109 return error; |
9 | 1110 } |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1111 |
1272 | 1112 gint start_editor_from_file(const gchar *key, FileData *fd) |
136 | 1113 { |
1272 | 1114 return start_editor_from_file_full(key, fd, NULL, NULL); |
136 | 1115 } |
1116 | |
1272 | 1117 gint editor_window_flag_set(const gchar *key) |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1118 { |
1272 | 1119 EditorDescription *editor; |
1120 if (!key) return TRUE; | |
1121 | |
1122 editor = g_hash_table_lookup(editors, key); | |
1123 if (!editor) return TRUE; | |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1124 |
1272 | 1125 return (editor->flags & EDITOR_KEEP_FS); |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1126 } |
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1127 |
1272 | 1128 gint editor_is_filter(const gchar *key) |
753 | 1129 { |
1272 | 1130 EditorDescription *editor; |
1131 if (!key) return TRUE; | |
1132 | |
1133 editor = g_hash_table_lookup(editors, key); | |
1134 if (!editor) return TRUE; | |
753 | 1135 |
1272 | 1136 return (editor->flags & EDITOR_DEST); |
753 | 1137 } |
1138 | |
140 | 1139 const gchar *editor_get_error_str(gint flags) |
1140 { | |
1141 if (flags & EDITOR_ERROR_EMPTY) return _("Editor template is empty."); | |
1142 if (flags & EDITOR_ERROR_SYNTAX) return _("Editor template has incorrect syntax."); | |
1143 if (flags & EDITOR_ERROR_INCOMPATIBLE) return _("Editor template uses incompatible macros."); | |
1144 if (flags & EDITOR_ERROR_NO_FILE) return _("Can't find matching file type."); | |
1145 if (flags & EDITOR_ERROR_CANT_EXEC) return _("Can't execute external editor."); | |
1146 if (flags & EDITOR_ERROR_STATUS) return _("External editor returned error status."); | |
1147 if (flags & EDITOR_ERROR_SKIPPED) return _("File was skipped."); | |
1148 return _("Unknown error."); | |
1149 } | |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1150 |
1272 | 1151 const gchar *editor_get_name(const gchar *key) |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1152 { |
1272 | 1153 EditorDescription *editor = g_hash_table_lookup(editors, key); |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1154 |
1272 | 1155 if (!editor) return NULL; |
1156 | |
1157 return editor->name; | |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1158 } |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1022
diff
changeset
|
1159 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |