Mercurial > geeqie
annotate src/editors.c @ 1478:3cc98d5c6907
Improve editors through .desktop files implementation:
- stricter Exec parameters detection
- correct Icon key handling (absolute file vs name and --icon prefix)
- improved escape, single, double quotes handling and escaping
author | zas_ |
---|---|
date | Thu, 26 Mar 2009 21:49:20 +0000 |
parents | e9f9d3da3f43 |
children | d062522699dc |
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 |
1284 | 4 * Copyright (C) 2008 - 2009 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 { | |
1405 | 45 EditorFlags flags; |
140 | 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); |
1405 | 59 static EditorFlags editor_command_next_start(EditorData *ed); |
60 static EditorFlags editor_command_next_finish(EditorData *ed, gint status); | |
61 static EditorFlags editor_command_done(EditorData *ed); | |
9 | 62 |
63 /* | |
64 *----------------------------------------------------------------------------- | |
65 * external editor routines | |
66 *----------------------------------------------------------------------------- | |
67 */ | |
68 | |
1272 | 69 GHashTable *editors = NULL; |
70 | |
71 #ifdef G_KEY_FILE_DESKTOP_GROUP | |
72 #define DESKTOP_GROUP G_KEY_FILE_DESKTOP_GROUP | |
73 #else | |
74 #define DESKTOP_GROUP "Desktop Entry" | |
75 #endif | |
76 | |
77 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
|
78 { |
1272 | 79 if (!editor) return; |
80 | |
81 g_free(editor->key); | |
82 g_free(editor->name); | |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
83 g_free(editor->icon); |
1272 | 84 g_free(editor->exec); |
85 g_free(editor->menu_path); | |
86 g_free(editor->hotkey); | |
1468 | 87 g_free(editor->comment); |
1272 | 88 string_list_free(editor->ext_list); |
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 |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
147 static gboolean editor_accepts_parameters(EditorDescription *editor) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
148 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
149 const gchar *p = editor->exec; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
150 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
151 if (!p) return FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
152 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
153 while (*p) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
154 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
155 if (*p == '%' && p[1]) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
156 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
157 switch (p[1]) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
158 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
159 case 'F': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
160 case 'f': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
161 case 'U': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
162 case 'u': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
163 case 'i': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
164 case 'k': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
165 case 'c': |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
166 return TRUE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
167 default: |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
168 break; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
169 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
170 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
171 p++; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
172 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
173 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
174 return FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
175 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
176 |
1272 | 177 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
|
178 { |
1272 | 179 GKeyFile *key_file; |
180 EditorDescription *editor; | |
181 gchar *extensions; | |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
182 gchar *type; |
1272 | 183 const gchar *key = filename_from_path(path); |
184 gchar **categories, **only_show_in, **not_show_in; | |
1274 | 185 gchar *try_exec; |
1272 | 186 |
187 if (g_hash_table_lookup(editors, key)) return FALSE; /* the file found earlier wins */ | |
188 | |
189 key_file = g_key_file_new(); | |
190 if (!g_key_file_load_from_file(key_file, path, 0, NULL)) | |
191 { | |
192 g_key_file_free(key_file); | |
193 return FALSE; | |
194 } | |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
195 |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
196 type = g_key_file_get_string(key_file, DESKTOP_GROUP, "Type", NULL); |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
197 if (!type || strcmp(type, "Application") != 0) |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
198 { |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
199 /* We only consider desktop entries of Application type */ |
1409 | 200 g_key_file_free(key_file); |
1463
25168240a247
added function to reload external editors at any time
nadvornik
parents:
1409
diff
changeset
|
201 g_free(type); |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
202 return FALSE; |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
203 } |
1463
25168240a247
added function to reload external editors at any time
nadvornik
parents:
1409
diff
changeset
|
204 g_free(type); |
1272 | 205 |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
206 editor = g_new0(EditorDescription, 1); |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
207 |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
208 editor->key = g_strdup(key); |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
209 editor->file = g_strdup(path); |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
210 |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
211 g_hash_table_insert(editors, editor->key, editor); |
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
212 |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
213 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Hidden", NULL) |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
214 || g_key_file_get_boolean(key_file, DESKTOP_GROUP, "NoDisplay", NULL)) |
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
215 { |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
216 editor->hidden = TRUE; |
1278
c5852c543775
Add support for NoDisplay (entry is then hidden) and Type (only Application type is valid here) keys.
zas_
parents:
1276
diff
changeset
|
217 } |
1272 | 218 |
219 categories = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "Categories", NULL, NULL); | |
220 if (categories) | |
221 { | |
222 gboolean found = FALSE; | |
223 gint i; | |
224 for (i = 0; categories[i]; i++) | |
225 /* IMHO "Graphics" is exactly the category that we are interested in, so this does not have to be configurable */ | |
226 if (strcmp(categories[i], "Graphics") == 0 || | |
227 strcmp(categories[i], "X-Geeqie") == 0) | |
228 { | |
229 found = TRUE; | |
230 break; | |
231 } | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
232 if (!found) editor->hidden = TRUE; |
1272 | 233 g_strfreev(categories); |
234 } | |
235 else | |
236 { | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
237 editor->hidden = TRUE; |
1272 | 238 } |
239 | |
240 only_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "OnlyShowIn", NULL, NULL); | |
241 if (only_show_in) | |
242 { | |
243 gboolean found = FALSE; | |
244 gint i; | |
245 for (i = 0; only_show_in[i]; i++) | |
246 if (strcmp(only_show_in[i], "X-Geeqie") == 0) | |
247 { | |
248 found = TRUE; | |
249 break; | |
250 } | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
251 if (!found) editor->hidden = TRUE; |
1272 | 252 g_strfreev(only_show_in); |
253 } | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
254 |
1272 | 255 not_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "NotShowIn", NULL, NULL); |
256 if (not_show_in) | |
257 { | |
258 gboolean found = FALSE; | |
259 gint i; | |
260 for (i = 0; not_show_in[i]; i++) | |
261 if (strcmp(not_show_in[i], "X-Geeqie") == 0) | |
262 { | |
263 found = TRUE; | |
264 break; | |
265 } | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
266 if (found) editor->hidden = TRUE; |
1272 | 267 g_strfreev(not_show_in); |
268 } | |
269 | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
270 |
1274 | 271 try_exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "TryExec", NULL); |
272 if (try_exec && !editor->hidden) | |
273 { | |
274 gchar *try_exec_res = g_find_program_in_path(try_exec); | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
275 if (!try_exec_res) editor->hidden = TRUE; |
1274 | 276 g_free(try_exec_res); |
277 g_free(try_exec); | |
278 } | |
279 | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
280 if (editor->hidden) |
1272 | 281 { |
282 /* hidden editors will be deleted, no need to parse the rest */ | |
283 g_key_file_free(key_file); | |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
284 return TRUE; |
1272 | 285 } |
286 | |
287 editor->name = g_key_file_get_locale_string(key_file, DESKTOP_GROUP, "Name", NULL, NULL); | |
288 editor->icon = g_key_file_get_string(key_file, DESKTOP_GROUP, "Icon", NULL); | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
289 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
290 /* Icon key can be either a full path (absolute with file name extension) or an icon name (without extension) */ |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
291 if (editor->icon && !g_path_is_absolute(editor->icon)) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
292 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
293 gchar *ext = strrchr(editor->icon, '.'); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
294 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
295 if (ext && strlen(ext) == 4 && |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
296 (!strcmp(ext, ".png") || !strcmp(ext, ".xpm") || !strcmp(ext, ".svg"))) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
297 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
298 log_printf(_("Desktop file '%s' should not include extension in Icon key: '%s'\n"), |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
299 editor->file, editor->icon); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
300 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
301 // drop extension |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
302 *ext = '\0'; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
303 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
304 } |
1272 | 305 |
306 editor->exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "Exec", NULL); | |
307 | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
308 /* we take only editors that accept parameters */ |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
309 if (!editor_accepts_parameters(editor)) editor->hidden = TRUE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
310 |
1272 | 311 editor->menu_path = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Menu-Path", NULL); |
312 if (!editor->menu_path) editor->menu_path = g_strdup("EditMenu/ExternalMenu"); | |
313 | |
314 editor->hotkey = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Hotkey", NULL); | |
315 | |
1468 | 316 editor->comment = g_key_file_get_string(key_file, DESKTOP_GROUP, "Comment", NULL); |
317 | |
1272 | 318 extensions = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-File-Extensions", NULL); |
319 if (extensions) | |
320 editor->ext_list = filter_to_list(extensions); | |
321 else | |
322 { | |
323 gchar **mime_types = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "MimeType", NULL, NULL); | |
324 if (mime_types) | |
325 { | |
326 editor->ext_list = editor_mime_types_to_extensions(mime_types); | |
327 g_strfreev(mime_types); | |
328 if (!editor->ext_list) editor->hidden = TRUE; | |
329 } | |
330 } | |
331 | |
332 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Keep-Fullscreen", NULL)) editor->flags |= EDITOR_KEEP_FS; | |
333 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose", NULL)) editor->flags |= EDITOR_VERBOSE; | |
334 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose-Multi", NULL)) editor->flags |= EDITOR_VERBOSE_MULTI; | |
335 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Filter", NULL)) editor->flags |= EDITOR_DEST; | |
336 if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Terminal", NULL)) editor->flags |= EDITOR_TERMINAL; | |
337 | |
338 editor->flags |= editor_command_parse(editor, NULL, NULL); | |
339 g_key_file_free(key_file); | |
340 | |
341 return TRUE; | |
768
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
342 } |
ff51413f098d
Use functions to set editors name and command and ensure they are
zas_
parents:
766
diff
changeset
|
343 |
1272 | 344 static gboolean editor_remove_desktop_file_cb(gpointer key, gpointer value, gpointer user_data) |
345 { | |
346 EditorDescription *editor = value; | |
347 return editor->hidden; | |
348 } | |
349 | |
350 static void editor_read_desktop_dir(const gchar *path) | |
9 | 351 { |
1272 | 352 DIR *dp; |
353 struct dirent *dir; | |
354 gchar *pathl; | |
355 | |
356 pathl = path_from_utf8(path); | |
357 dp = opendir(pathl); | |
358 g_free(pathl); | |
359 if (!dp) | |
360 { | |
361 /* dir not found */ | |
362 return; | |
363 } | |
364 while ((dir = readdir(dp)) != NULL) | |
365 { | |
366 gchar *namel = dir->d_name; | |
367 | |
1402 | 368 if (g_str_has_suffix(namel, ".desktop")) |
1272 | 369 { |
370 gchar *name = path_to_utf8(namel); | |
371 gchar *dpath = g_build_filename(path, name, NULL); | |
372 editor_read_desktop_file(dpath); | |
373 g_free(dpath); | |
374 g_free(name); | |
375 } | |
376 } | |
377 closedir(dp); | |
378 } | |
379 | |
380 void editor_load_descriptions(void) | |
381 { | |
382 gchar *path; | |
383 gchar *xdg_data_dirs; | |
384 gchar *all_dirs; | |
385 gchar **split_dirs; | |
9 | 386 gint i; |
1272 | 387 |
1463
25168240a247
added function to reload external editors at any time
nadvornik
parents:
1409
diff
changeset
|
388 if (editors) |
1272 | 389 { |
1463
25168240a247
added function to reload external editors at any time
nadvornik
parents:
1409
diff
changeset
|
390 g_hash_table_destroy(editors); |
1272 | 391 } |
1463
25168240a247
added function to reload external editors at any time
nadvornik
parents:
1409
diff
changeset
|
392 editors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify)editor_description_free); |
9 | 393 |
1272 | 394 xdg_data_dirs = getenv("XDG_DATA_DIRS"); |
395 if (xdg_data_dirs && xdg_data_dirs[0]) | |
396 xdg_data_dirs = path_to_utf8(xdg_data_dirs); | |
397 else | |
398 xdg_data_dirs = g_strdup("/usr/share"); | |
399 | |
1274 | 400 all_dirs = g_strconcat(get_rc_dir(), ":", GQ_APP_DIR, ":", xdg_data_home_get(), ":", xdg_data_dirs, NULL); |
1272 | 401 |
402 g_free(xdg_data_dirs); | |
403 | |
404 split_dirs = g_strsplit(all_dirs, ":", 0); | |
405 | |
406 g_free(all_dirs); | |
407 | |
408 for (i = 0; split_dirs[i]; i++) | |
9 | 409 { |
1272 | 410 path = g_build_filename(split_dirs[i], "applications", NULL); |
411 editor_read_desktop_dir(path); | |
412 g_free(path); | |
9 | 413 } |
1272 | 414 |
415 g_strfreev(split_dirs); | |
416 | |
417 g_hash_table_foreach_remove(editors, editor_remove_desktop_file_cb, NULL); | |
9 | 418 } |
419 | |
1272 | 420 static void editor_list_add_cb(gpointer key, gpointer value, gpointer data) |
421 { | |
422 GList **listp = data; | |
423 EditorDescription *editor = value; | |
424 | |
1402 | 425 /* do not show the special commands in any list, they are called explicitly */ |
1272 | 426 if (strcmp(editor->key, CMD_COPY) == 0 || |
427 strcmp(editor->key, CMD_MOVE) == 0 || | |
428 strcmp(editor->key, CMD_RENAME) == 0 || | |
429 strcmp(editor->key, CMD_DELETE) == 0 || | |
430 strcmp(editor->key, CMD_FOLDER) == 0) return; | |
431 | |
432 *listp = g_list_prepend(*listp, editor); | |
433 } | |
434 | |
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
|
435 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
|
436 { |
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
|
437 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
|
438 const EditorDescription *eb = b; |
1402 | 439 gint ret; |
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
|
440 |
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
|
441 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
|
442 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
|
443 |
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
|
444 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
|
445 } |
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
|
446 |
1272 | 447 GList *editor_list_get(void) |
448 { | |
449 GList *editors_list = NULL; | |
450 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
|
451 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
|
452 |
1272 | 453 return editors_list; |
454 } | |
455 | |
456 /* ------------------------------ */ | |
457 | |
458 | |
140 | 459 static void editor_verbose_data_free(EditorData *ed) |
460 { | |
461 if (!ed->vd) return; | |
462 g_free(ed->vd); | |
463 ed->vd = NULL; | |
464 } | |
465 | |
466 static void editor_data_free(EditorData *ed) | |
467 { | |
468 editor_verbose_data_free(ed); | |
469 g_free(ed); | |
470 } | |
471 | |
9 | 472 static void editor_verbose_window_close(GenericDialog *gd, gpointer data) |
473 { | |
140 | 474 EditorData *ed = data; |
9 | 475 |
476 generic_dialog_close(gd); | |
140 | 477 editor_verbose_data_free(ed); |
478 if (ed->pid == -1) editor_data_free(ed); /* the process has already terminated */ | |
9 | 479 } |
480 | |
481 static void editor_verbose_window_stop(GenericDialog *gd, gpointer data) | |
482 { | |
140 | 483 EditorData *ed = data; |
484 ed->stopping = TRUE; | |
485 ed->count = 0; | |
486 editor_verbose_window_progress(ed, _("stopping...")); | |
9 | 487 } |
488 | |
489 static void editor_verbose_window_enable_close(EditorVerboseData *vd) | |
490 { | |
491 vd->gd->cancel_cb = editor_verbose_window_close; | |
492 | |
493 spinner_set_interval(vd->spinner, -1); | |
494 gtk_widget_set_sensitive(vd->button_stop, FALSE); | |
495 gtk_widget_set_sensitive(vd->button_close, TRUE); | |
496 } | |
497 | |
140 | 498 static EditorVerboseData *editor_verbose_window(EditorData *ed, const gchar *text) |
9 | 499 { |
500 EditorVerboseData *vd; | |
501 GtkWidget *scrolled; | |
502 GtkWidget *hbox; | |
503 gchar *buf; | |
504 | |
505 vd = g_new0(EditorVerboseData, 1); | |
506 | |
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
|
507 vd->gd = file_util_gen_dlg(_("Edit command results"), "editor_results", |
9 | 508 NULL, FALSE, |
140 | 509 NULL, ed); |
9 | 510 buf = g_strdup_printf(_("Output of %s"), text); |
511 generic_dialog_add_message(vd->gd, NULL, buf, NULL); | |
512 g_free(buf); | |
513 vd->button_stop = generic_dialog_add_button(vd->gd, GTK_STOCK_STOP, NULL, | |
514 editor_verbose_window_stop, FALSE); | |
515 gtk_widget_set_sensitive(vd->button_stop, FALSE); | |
516 vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, NULL, | |
517 editor_verbose_window_close, TRUE); | |
518 gtk_widget_set_sensitive(vd->button_close, FALSE); | |
519 | |
520 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
521 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
522 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
523 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); | |
524 gtk_box_pack_start(GTK_BOX(vd->gd->vbox), scrolled, TRUE, TRUE, 5); | |
525 gtk_widget_show(scrolled); | |
526 | |
527 vd->text = gtk_text_view_new(); | |
528 gtk_text_view_set_editable(GTK_TEXT_VIEW(vd->text), FALSE); | |
529 gtk_widget_set_size_request(vd->text, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_HEIGHT); | |
530 gtk_container_add(GTK_CONTAINER(scrolled), vd->text); | |
531 gtk_widget_show(vd->text); | |
532 | |
533 hbox = gtk_hbox_new(FALSE, 0); | |
534 gtk_box_pack_start(GTK_BOX(vd->gd->vbox), hbox, FALSE, FALSE, 0); | |
535 gtk_widget_show(hbox); | |
536 | |
537 vd->progress = gtk_progress_bar_new(); | |
538 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vd->progress), 0.0); | |
539 gtk_box_pack_start(GTK_BOX(hbox), vd->progress, TRUE, TRUE, 0); | |
540 gtk_widget_show(vd->progress); | |
541 | |
542 vd->spinner = spinner_new(NULL, SPINNER_SPEED); | |
543 gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0); | |
544 gtk_widget_show(vd->spinner); | |
442 | 545 |
9 | 546 gtk_widget_show(vd->gd->dialog); |
547 | |
140 | 548 ed->vd = vd; |
9 | 549 return vd; |
550 } | |
551 | |
552 static void editor_verbose_window_fill(EditorVerboseData *vd, gchar *text, gint len) | |
553 { | |
554 GtkTextBuffer *buffer; | |
555 GtkTextIter iter; | |
556 | |
557 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(vd->text)); | |
558 gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1); | |
559 gtk_text_buffer_insert(buffer, &iter, text, len); | |
560 } | |
561 | |
140 | 562 static void editor_verbose_window_progress(EditorData *ed, const gchar *text) |
9 | 563 { |
140 | 564 if (!ed->vd) return; |
565 | |
566 if (ed->total) | |
9 | 567 { |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
568 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ed->vd->progress), (gdouble)ed->count / ed->total); |
9 | 569 } |
570 | |
140 | 571 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ed->vd->progress), (text) ? text : ""); |
9 | 572 } |
573 | |
574 static gboolean editor_verbose_io_cb(GIOChannel *source, GIOCondition condition, gpointer data) | |
575 { | |
140 | 576 EditorData *ed = data; |
9 | 577 gchar buf[512]; |
578 gsize count; | |
579 | |
140 | 580 if (condition & G_IO_IN) |
9 | 581 { |
140 | 582 while (g_io_channel_read_chars(source, buf, sizeof(buf), &count, NULL) == G_IO_STATUS_NORMAL) |
583 { | |
584 if (!g_utf8_validate(buf, count, NULL)) | |
9 | 585 { |
140 | 586 gchar *utf8; |
444 | 587 |
140 | 588 utf8 = g_locale_to_utf8(buf, count, NULL, NULL, NULL); |
589 if (utf8) | |
9 | 590 { |
140 | 591 editor_verbose_window_fill(ed->vd, utf8, -1); |
592 g_free(utf8); | |
9 | 593 } |
594 else | |
595 { | |
288
d1f74154463e
Replace occurences of Geeqie / geeqie by constants defined in main.h.
zas_
parents:
283
diff
changeset
|
596 editor_verbose_window_fill(ed->vd, "Error converting text to valid utf8\n", -1); |
9 | 597 } |
598 } | |
140 | 599 else |
600 { | |
601 editor_verbose_window_fill(ed->vd, buf, count); | |
602 } | |
603 } | |
9 | 604 } |
605 | |
140 | 606 if (condition & (G_IO_ERR | G_IO_HUP)) |
9 | 607 { |
140 | 608 g_io_channel_shutdown(source, TRUE, NULL); |
9 | 609 return FALSE; |
610 } | |
611 | |
612 return TRUE; | |
613 } | |
614 | |
138 | 615 typedef enum { |
616 PATH_FILE, | |
1272 | 617 PATH_FILE_URL, |
140 | 618 PATH_DEST |
138 | 619 } PathType; |
620 | |
621 | |
1272 | 622 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
|
623 { |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
624 GString *string; |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
625 gchar *pathl; |
1408 | 626 const gchar *p = NULL; |
123
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 string = g_string_new(""); |
442 | 629 |
1272 | 630 if (type == PATH_FILE || type == PATH_FILE_URL) |
138 | 631 { |
1272 | 632 GList *work = editor->ext_list; |
442 | 633 |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
634 if (!work) |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
635 p = fd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
636 else |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
637 { |
516 | 638 while (work) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
639 { |
444 | 640 GList *work2; |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
641 gchar *ext = work->data; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
642 work = work->next; |
442 | 643 |
644 if (strcmp(ext, "*") == 0 || | |
1307 | 645 g_ascii_strcasecmp(ext, fd->extension) == 0) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
646 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
647 p = fd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
648 break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
649 } |
442 | 650 |
444 | 651 work2 = fd->sidecar_files; |
516 | 652 while (work2) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
653 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
654 FileData *sfd = work2->data; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
655 work2 = work2->next; |
442 | 656 |
1307 | 657 if (g_ascii_strcasecmp(ext, sfd->extension) == 0) |
147
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
658 { |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
659 p = sfd->path; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
660 break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
661 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
662 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
663 if (p) break; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
664 } |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
665 if (!p) return NULL; |
b2266996fa83
added possibility to specify prefered file type for external commands
nadvornik
parents:
140
diff
changeset
|
666 } |
138 | 667 } |
140 | 668 else if (type == PATH_DEST) |
138 | 669 { |
670 if (fd->change && fd->change->dest) | |
671 p = fd->change->dest; | |
672 else | |
673 p = ""; | |
674 } | |
444 | 675 |
1407
57421a728682
Revert changeset 1502. It brokes the spec: hidden desktop files from user directory should hide files from system directory with the same name.
zas_
parents:
1406
diff
changeset
|
676 g_assert(p); |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
677 string = g_string_append(string, p); |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
678 |
1272 | 679 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
|
680 pathl = path_from_utf8(string->str); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
681 g_string_free(string, TRUE); |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
682 |
1402 | 683 if (pathl && !pathl[0]) /* empty string case */ |
684 { | |
685 g_free(pathl); | |
686 pathl = NULL; | |
687 } | |
688 | |
123
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
689 return pathl; |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
690 } |
3602a4aa7c71
Sat Dec 2 20:15:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
60
diff
changeset
|
691 |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
692 static GString *append_quoted(GString *str, const char *s, gboolean single_quotes, gboolean double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
693 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
694 const char *p; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
695 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
696 if (!single_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
697 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
698 if (!double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
699 g_string_append_c(str, '\''); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
700 else |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
701 g_string_append(str, "\"'"); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
702 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
703 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
704 for (p = s; *p != '\0'; p++) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
705 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
706 if (*p == '\'') |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
707 g_string_append(str, "'\\''"); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
708 else |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
709 g_string_append_c(str, *p); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
710 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
711 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
712 if (!single_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
713 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
714 if (!double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
715 g_string_append_c(str, '\''); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
716 else |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
717 g_string_append(str, "'\""); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
718 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
719 |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
720 return str; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
721 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
722 |
9 | 723 |
1405 | 724 EditorFlags editor_command_parse(const EditorDescription *editor, GList *list, gchar **output) |
9 | 725 { |
1405 | 726 EditorFlags flags = 0; |
1272 | 727 const gchar *p; |
140 | 728 GString *result = NULL; |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
729 gboolean escape = FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
730 gboolean single_quotes = FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
731 gboolean double_quotes = FALSE; |
442 | 732 |
140 | 733 if (output) |
734 result = g_string_new(""); | |
735 | |
1272 | 736 if (editor->exec[0] == '\0') |
140 | 737 { |
738 flags |= EDITOR_ERROR_EMPTY; | |
739 goto err; | |
740 } | |
669 | 741 |
1272 | 742 p = editor->exec; |
669 | 743 /* skip leading whitespaces if any */ |
744 while (g_ascii_isspace(*p)) p++; | |
442 | 745 |
140 | 746 /* command */ |
442 | 747 |
140 | 748 while (*p) |
749 { | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
750 if (escape) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
751 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
752 escape = FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
753 if (output) result = g_string_append_c(result, *p); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
754 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
755 else if (*p == '\\') |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
756 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
757 if (!single_quotes) escape = TRUE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
758 if (output) result = g_string_append_c(result, *p); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
759 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
760 else if (*p == '\'') |
140 | 761 { |
762 if (output) result = g_string_append_c(result, *p); | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
763 if (!single_quotes && !double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
764 single_quotes = TRUE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
765 else if (single_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
766 single_quotes = FALSE; |
140 | 767 } |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
768 else if (*p == '"') |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
769 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
770 if (output) result = g_string_append_c(result, *p); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
771 if (!single_quotes && !double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
772 double_quotes = TRUE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
773 else if (double_quotes) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
774 double_quotes = FALSE; |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
775 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
776 else if (*p == '%' && p[1]) |
140 | 777 { |
778 gchar *pathl = NULL; | |
9 | 779 |
140 | 780 p++; |
442 | 781 |
782 switch (*p) | |
140 | 783 { |
1272 | 784 case 'f': /* single file */ |
785 case 'u': /* single url */ | |
140 | 786 flags |= EDITOR_FOR_EACH; |
787 if (flags & EDITOR_SINGLE_COMMAND) | |
788 { | |
789 flags |= EDITOR_ERROR_INCOMPATIBLE; | |
790 goto err; | |
791 } | |
1399 | 792 if (list) |
1397
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
793 { |
1399 | 794 /* use the first file from the list */ |
795 if (!list->data) | |
796 { | |
797 flags |= EDITOR_ERROR_NO_FILE; | |
798 goto err; | |
799 } | |
800 pathl = editor_command_path_parse((FileData *)list->data, | |
801 (*p == 'f') ? PATH_FILE : PATH_FILE_URL, | |
802 editor); | |
803 if (!pathl) | |
804 { | |
805 flags |= EDITOR_ERROR_NO_FILE; | |
806 goto err; | |
807 } | |
808 if (output) | |
809 { | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
810 result = append_quoted(result, pathl, single_quotes, double_quotes); |
1399 | 811 } |
812 g_free(pathl); | |
1397
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
813 } |
442 | 814 break; |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
815 |
1272 | 816 case 'F': |
817 case 'U': | |
140 | 818 flags |= EDITOR_SINGLE_COMMAND; |
819 if (flags & (EDITOR_FOR_EACH | EDITOR_DEST)) | |
820 { | |
821 flags |= EDITOR_ERROR_INCOMPATIBLE; | |
822 goto err; | |
823 } | |
824 | |
1399 | 825 if (list) |
140 | 826 { |
827 /* use whole list */ | |
828 GList *work = list; | |
829 gboolean ok = FALSE; | |
444 | 830 |
140 | 831 while (work) |
832 { | |
833 FileData *fd = work->data; | |
1272 | 834 pathl = editor_command_path_parse(fd, (*p == 'F') ? PATH_FILE : PATH_FILE_URL, editor); |
140 | 835 if (pathl) |
836 { | |
837 ok = TRUE; | |
1397
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
838 |
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
839 if (output) |
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
840 { |
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
841 ok = TRUE; |
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
842 if (work != list) g_string_append_c(result, ' '); |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
843 result = append_quoted(result, pathl, single_quotes, double_quotes); |
1397
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
844 } |
140 | 845 g_free(pathl); |
846 } | |
847 work = work->next; | |
848 } | |
442 | 849 if (!ok) |
140 | 850 { |
851 flags |= EDITOR_ERROR_NO_FILE; | |
852 goto err; | |
853 } | |
854 } | |
442 | 855 break; |
1272 | 856 case 'i': |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
857 if (editor->icon && *editor->icon) |
1272 | 858 { |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
859 if (output) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
860 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
861 result = g_string_append(result, "--icon "); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
862 result = append_quoted(result, editor->icon, single_quotes, double_quotes); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
863 } |
1272 | 864 } |
865 break; | |
866 case 'c': | |
867 if (output) | |
868 { | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
869 result = append_quoted(result, editor->name, single_quotes, double_quotes); |
1272 | 870 } |
871 break; | |
872 case 'k': | |
873 if (output) | |
874 { | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
875 result = append_quoted(result, editor->file, single_quotes, double_quotes); |
1272 | 876 } |
877 break; | |
669 | 878 case '%': |
879 /* %% = % escaping */ | |
880 if (output) result = g_string_append_c(result, *p); | |
881 break; | |
1272 | 882 case 'd': |
883 case 'D': | |
884 case 'n': | |
885 case 'N': | |
886 case 'v': | |
887 case 'm': | |
888 /* deprecated according to spec, ignore */ | |
889 break; | |
140 | 890 default: |
891 flags |= EDITOR_ERROR_SYNTAX; | |
892 goto err; | |
893 } | |
894 } | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
895 else |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
896 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
897 if (output) result = g_string_append_c(result, *p); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
898 } |
140 | 899 p++; |
9 | 900 } |
901 | |
1478
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
902 if (output) |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
903 { |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
904 *output = g_string_free(result, FALSE); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
905 DEBUG_3("Editor cmd: %s", *output); |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
906 } |
3cc98d5c6907
Improve editors through .desktop files implementation:
zas_
parents:
1468
diff
changeset
|
907 |
140 | 908 return flags; |
909 | |
442 | 910 |
140 | 911 err: |
442 | 912 if (output) |
9 | 913 { |
140 | 914 g_string_free(result, TRUE); |
915 *output = NULL; | |
916 } | |
917 return flags; | |
918 } | |
919 | |
1272 | 920 |
1397
a0bd58a6535f
In various Edit context menus, only display editors that match the file types in the selection.
zas_
parents:
1367
diff
changeset
|
921 static void editor_child_exit_cb(GPid pid, gint status, gpointer data) |
140 | 922 { |
923 EditorData *ed = data; | |
924 g_spawn_close_pid(pid); | |
925 ed->pid = -1; | |
442 | 926 |
140 | 927 editor_command_next_finish(ed, status); |
928 } | |
929 | |
930 | |
1405 | 931 static EditorFlags editor_command_one(const EditorDescription *editor, GList *list, EditorData *ed) |
140 | 932 { |
933 gchar *command; | |
934 FileData *fd = list->data; | |
935 GPid pid; | |
442 | 936 gint standard_output; |
937 gint standard_error; | |
140 | 938 gboolean ok; |
939 | |
940 ed->pid = -1; | |
1405 | 941 ed->flags = editor->flags; |
942 ed->flags |= editor_command_parse(editor, list, &command); | |
140 | 943 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
944 ok = !EDITOR_ERRORS(ed->flags); |
140 | 945 |
946 if (ok) | |
947 { | |
737
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
948 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
|
949 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
|
950 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
951 if (ok) |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
952 { |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
953 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
|
954 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
|
955 } |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
956 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
957 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
|
958 } |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
959 |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
960 if (ok) |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
961 { |
443 | 962 gchar *working_directory; |
963 gchar *args[4]; | |
737
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
964 guint n = 0; |
443 | 965 |
966 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
|
967 args[n++] = options->shell.path; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
968 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
|
969 args[n++] = options->shell.options; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
970 args[n++] = command; |
8a8873e7a552
Make shell command and its option rc file options instead of hardcoded strings.
zas_
parents:
731
diff
changeset
|
971 args[n] = NULL; |
443 | 972 |
1272 | 973 if ((ed->flags & EDITOR_DEST) && fd->change && fd->change->dest) /* FIXME: error handling */ |
974 { | |
1402 | 975 g_setenv("GEEQIE_DESTINATION", fd->change->dest, TRUE); |
1272 | 976 } |
977 else | |
978 { | |
1402 | 979 g_unsetenv("GEEQIE_DESTINATION"); |
1272 | 980 } |
981 | |
442 | 982 ok = g_spawn_async_with_pipes(working_directory, args, NULL, |
140 | 983 G_SPAWN_DO_NOT_REAP_CHILD, /* GSpawnFlags */ |
442 | 984 NULL, NULL, |
985 &pid, | |
986 NULL, | |
987 ed->vd ? &standard_output : NULL, | |
988 ed->vd ? &standard_error : NULL, | |
140 | 989 NULL); |
443 | 990 |
991 g_free(working_directory); | |
442 | 992 |
140 | 993 if (!ok) ed->flags |= EDITOR_ERROR_CANT_EXEC; |
994 } | |
995 | |
442 | 996 if (ok) |
140 | 997 { |
998 g_child_watch_add(pid, editor_child_exit_cb, ed); | |
999 ed->pid = pid; | |
1000 } | |
442 | 1001 |
140 | 1002 if (ed->vd) |
1003 { | |
1004 if (!ok) | |
9 | 1005 { |
140 | 1006 gchar *buf; |
1007 | |
1272 | 1008 buf = g_strdup_printf(_("Failed to run command:\n%s\n"), editor->file); |
140 | 1009 editor_verbose_window_fill(ed->vd, buf, strlen(buf)); |
1010 g_free(buf); | |
1011 | |
1012 } | |
442 | 1013 else |
140 | 1014 { |
1015 GIOChannel *channel_output; | |
1016 GIOChannel *channel_error; | |
444 | 1017 |
140 | 1018 channel_output = g_io_channel_unix_new(standard_output); |
1019 g_io_channel_set_flags(channel_output, G_IO_FLAG_NONBLOCK, NULL); | |
926 | 1020 g_io_channel_set_encoding(channel_output, NULL, NULL); |
140 | 1021 |
1022 g_io_add_watch_full(channel_output, G_PRIORITY_HIGH, G_IO_IN | G_IO_ERR | G_IO_HUP, | |
1023 editor_verbose_io_cb, ed, NULL); | |
1024 g_io_channel_unref(channel_output); | |
1025 | |
1026 channel_error = g_io_channel_unix_new(standard_error); | |
1027 g_io_channel_set_flags(channel_error, G_IO_FLAG_NONBLOCK, NULL); | |
926 | 1028 g_io_channel_set_encoding(channel_error, NULL, NULL); |
140 | 1029 |
1030 g_io_add_watch_full(channel_error, G_PRIORITY_HIGH, G_IO_IN | G_IO_ERR | G_IO_HUP, | |
1031 editor_verbose_io_cb, ed, NULL); | |
1032 g_io_channel_unref(channel_error); | |
1033 } | |
1034 } | |
442 | 1035 |
140 | 1036 g_free(command); |
1037 | |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1038 return EDITOR_ERRORS(ed->flags); |
140 | 1039 } |
1040 | |
1405 | 1041 static EditorFlags editor_command_next_start(EditorData *ed) |
140 | 1042 { |
1043 if (ed->vd) editor_verbose_window_fill(ed->vd, "\n", 1); | |
1044 | |
1045 if (ed->list && ed->count < ed->total) | |
1046 { | |
1047 FileData *fd; | |
1405 | 1048 EditorFlags error; |
140 | 1049 |
1050 fd = ed->list->data; | |
1051 | |
1052 if (ed->vd) | |
1053 { | |
1402 | 1054 if (ed->flags & EDITOR_FOR_EACH) |
1055 editor_verbose_window_progress(ed, fd->path); | |
1056 else | |
1057 editor_verbose_window_progress(ed, _("running...")); | |
140 | 1058 } |
1059 ed->count++; | |
1060 | |
1272 | 1061 error = editor_command_one(ed->editor, ed->list, ed); |
140 | 1062 if (!error && ed->vd) |
1063 { | |
1064 gtk_widget_set_sensitive(ed->vd->button_stop, (ed->list != NULL) ); | |
1065 if (ed->flags & EDITOR_FOR_EACH) | |
9 | 1066 { |
140 | 1067 editor_verbose_window_fill(ed->vd, fd->path, strlen(fd->path)); |
1068 editor_verbose_window_fill(ed->vd, "\n", 1); | |
9 | 1069 } |
1070 } | |
140 | 1071 |
442 | 1072 if (!error) |
140 | 1073 return 0; |
1402 | 1074 |
1075 /* command was not started, call the finish immediately */ | |
1076 return editor_command_next_finish(ed, 0); | |
140 | 1077 } |
442 | 1078 |
140 | 1079 /* everything is done */ |
237
404629011caa
Add missing return at the end of editor_command_next_start().
zas_
parents:
196
diff
changeset
|
1080 return editor_command_done(ed); |
140 | 1081 } |
1082 | |
1405 | 1083 static EditorFlags editor_command_next_finish(EditorData *ed, gint status) |
140 | 1084 { |
1085 gint cont = ed->stopping ? EDITOR_CB_SKIP : EDITOR_CB_CONTINUE; | |
1086 | |
1087 if (status) | |
1088 ed->flags |= EDITOR_ERROR_STATUS; | |
1089 | |
1090 if (ed->flags & EDITOR_FOR_EACH) | |
1091 { | |
1092 /* handle the first element from the list */ | |
1093 GList *fd_element = ed->list; | |
444 | 1094 |
140 | 1095 ed->list = g_list_remove_link(ed->list, fd_element); |
1096 if (ed->callback) | |
911 | 1097 { |
140 | 1098 cont = ed->callback(ed->list ? ed : NULL, ed->flags, fd_element, ed->data); |
911 | 1099 if (ed->stopping && cont == EDITOR_CB_CONTINUE) cont = EDITOR_CB_SKIP; |
1100 } | |
140 | 1101 filelist_free(fd_element); |
9 | 1102 } |
1103 else | |
1104 { | |
140 | 1105 /* handle whole list */ |
1106 if (ed->callback) | |
1107 cont = ed->callback(NULL, ed->flags, ed->list, ed->data); | |
1108 filelist_free(ed->list); | |
1109 ed->list = NULL; | |
1110 } | |
9 | 1111 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1112 switch (cont) |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1113 { |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1114 case EDITOR_CB_SUSPEND: |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1115 return EDITOR_ERRORS(ed->flags); |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1116 case EDITOR_CB_SKIP: |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1117 return editor_command_done(ed); |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1118 } |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1119 |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1120 return editor_command_next_start(ed); |
140 | 1121 } |
9 | 1122 |
1405 | 1123 static EditorFlags editor_command_done(EditorData *ed) |
140 | 1124 { |
1405 | 1125 EditorFlags flags; |
9 | 1126 |
140 | 1127 if (ed->vd) |
1128 { | |
1129 if (ed->count == ed->total) | |
9 | 1130 { |
1402 | 1131 editor_verbose_window_progress(ed, _("done")); |
9 | 1132 } |
1133 else | |
1134 { | |
1402 | 1135 editor_verbose_window_progress(ed, _("stopped by user")); |
9 | 1136 } |
140 | 1137 editor_verbose_window_enable_close(ed->vd); |
1138 } | |
1139 | |
1140 /* free the not-handled items */ | |
1141 if (ed->list) | |
1142 { | |
1143 ed->flags |= EDITOR_ERROR_SKIPPED; | |
1144 if (ed->callback) ed->callback(NULL, ed->flags, ed->list, ed->data); | |
1145 filelist_free(ed->list); | |
1146 ed->list = NULL; | |
1147 } | |
9 | 1148 |
140 | 1149 ed->count = 0; |
1150 | |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1151 flags = EDITOR_ERRORS(ed->flags); |
140 | 1152 |
1153 if (!ed->vd) editor_data_free(ed); | |
1154 | |
1155 return flags; | |
1156 } | |
1157 | |
1158 void editor_resume(gpointer ed) | |
1159 { | |
1160 editor_command_next_start(ed); | |
1161 } | |
443 | 1162 |
140 | 1163 void editor_skip(gpointer ed) |
1164 { | |
442 | 1165 editor_command_done(ed); |
9 | 1166 } |
1167 | |
1405 | 1168 static EditorFlags editor_command_start(const EditorDescription *editor, const gchar *text, GList *list, EditorCallback cb, gpointer data) |
140 | 1169 { |
1170 EditorData *ed; | |
1405 | 1171 EditorFlags flags = editor->flags; |
442 | 1172 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1173 if (EDITOR_ERRORS(flags)) return EDITOR_ERRORS(flags); |
140 | 1174 |
1175 ed = g_new0(EditorData, 1); | |
1176 ed->list = filelist_copy(list); | |
1177 ed->flags = flags; | |
1272 | 1178 ed->editor = editor; |
140 | 1179 ed->total = (flags & EDITOR_SINGLE_COMMAND) ? 1 : g_list_length(list); |
1180 ed->callback = cb; | |
1181 ed->data = data; | |
442 | 1182 |
140 | 1183 if ((flags & EDITOR_VERBOSE_MULTI) && list && list->next) |
1184 flags |= EDITOR_VERBOSE; | |
442 | 1185 |
140 | 1186 if (flags & EDITOR_VERBOSE) |
1187 editor_verbose_window(ed, text); | |
442 | 1188 |
1189 editor_command_next_start(ed); | |
140 | 1190 /* errors from editor_command_next_start will be handled via callback */ |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1191 return EDITOR_ERRORS(flags); |
140 | 1192 } |
1193 | |
1272 | 1194 gboolean is_valid_editor_command(const gchar *key) |
444 | 1195 { |
1272 | 1196 if (!key) return FALSE; |
1197 return g_hash_table_lookup(editors, key) != NULL; | |
444 | 1198 } |
1199 | |
1405 | 1200 EditorFlags start_editor_from_filelist_full(const gchar *key, GList *list, EditorCallback cb, gpointer data) |
9 | 1201 { |
1405 | 1202 EditorFlags error; |
1272 | 1203 EditorDescription *editor; |
1204 if (!key) return FALSE; | |
1205 | |
1206 editor = g_hash_table_lookup(editors, key); | |
9 | 1207 |
444 | 1208 if (!list) return FALSE; |
1272 | 1209 if (!editor) return FALSE; |
1210 | |
1211 error = editor_command_start(editor, editor->name, list, cb, data); | |
9 | 1212 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1399
diff
changeset
|
1213 if (EDITOR_ERRORS(error)) |
669 | 1214 { |
1272 | 1215 gchar *text = g_strdup_printf(_("%s\n\"%s\""), editor_get_error_str(error), editor->file); |
669 | 1216 |
1217 file_util_warning_dialog(_("Invalid editor command"), text, GTK_STOCK_DIALOG_ERROR, NULL); | |
1218 g_free(text); | |
1219 } | |
1220 | |
140 | 1221 return error; |
9 | 1222 } |
1223 | |
1405 | 1224 EditorFlags start_editor_from_filelist(const gchar *key, GList *list) |
140 | 1225 { |
1272 | 1226 return start_editor_from_filelist_full(key, list, NULL, NULL); |
140 | 1227 } |
1228 | |
1405 | 1229 EditorFlags start_editor_from_file_full(const gchar *key, FileData *fd, EditorCallback cb, gpointer data) |
9 | 1230 { |
1231 GList *list; | |
1405 | 1232 EditorFlags error; |
9 | 1233 |
138 | 1234 if (!fd) return FALSE; |
9 | 1235 |
138 | 1236 list = g_list_append(NULL, fd); |
1272 | 1237 error = start_editor_from_filelist_full(key, list, cb, data); |
9 | 1238 g_list_free(list); |
140 | 1239 return error; |
9 | 1240 } |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1241 |
1405 | 1242 EditorFlags start_editor_from_file(const gchar *key, FileData *fd) |
136 | 1243 { |
1272 | 1244 return start_editor_from_file_full(key, fd, NULL, NULL); |
136 | 1245 } |
1246 | |
1405 | 1247 gboolean 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
|
1248 { |
1272 | 1249 EditorDescription *editor; |
1250 if (!key) return TRUE; | |
1251 | |
1252 editor = g_hash_table_lookup(editors, key); | |
1253 if (!editor) return TRUE; | |
60
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1254 |
1405 | 1255 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
|
1256 } |
9c0c402b0ef3
Mon Jun 13 17:31:46 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
1257 |
1405 | 1258 gboolean editor_is_filter(const gchar *key) |
753 | 1259 { |
1272 | 1260 EditorDescription *editor; |
1261 if (!key) return TRUE; | |
1262 | |
1263 editor = g_hash_table_lookup(editors, key); | |
1264 if (!editor) return TRUE; | |
753 | 1265 |
1405 | 1266 return !!(editor->flags & EDITOR_DEST); |
753 | 1267 } |
1268 | |
1405 | 1269 const gchar *editor_get_error_str(EditorFlags flags) |
140 | 1270 { |
1271 if (flags & EDITOR_ERROR_EMPTY) return _("Editor template is empty."); | |
1272 if (flags & EDITOR_ERROR_SYNTAX) return _("Editor template has incorrect syntax."); | |
1273 if (flags & EDITOR_ERROR_INCOMPATIBLE) return _("Editor template uses incompatible macros."); | |
1274 if (flags & EDITOR_ERROR_NO_FILE) return _("Can't find matching file type."); | |
1275 if (flags & EDITOR_ERROR_CANT_EXEC) return _("Can't execute external editor."); | |
1276 if (flags & EDITOR_ERROR_STATUS) return _("External editor returned error status."); | |
1277 if (flags & EDITOR_ERROR_SKIPPED) return _("File was skipped."); | |
1278 return _("Unknown error."); | |
1279 } | |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1280 |
1272 | 1281 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
|
1282 { |
1272 | 1283 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
|
1284 |
1272 | 1285 if (!editor) return NULL; |
1286 | |
1287 return editor->name; | |
731
fa8f7d7396cf
Introduce an helper function that returns the name of an editor.
zas_
parents:
730
diff
changeset
|
1288 } |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1022
diff
changeset
|
1289 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |