Mercurial > geeqie.yaz
annotate src/ui_fileops.c @ 990:070bfc3591bc
Drop redundant variable affectation.
author | zas_ |
---|---|
date | Sun, 24 Aug 2008 14:14:37 +0000 |
parents | 50e1f5e54c1a |
children | d2701a5864c5 |
rev | line source |
---|---|
9 | 1 /* |
2 * (SLIK) SimpLIstic sKin functions | |
69
31759d770628
Fri Oct 13 10:27:22 2006 John Ellis <johne@verizon.net>
gqview
parents:
40
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 #ifdef HAVE_CONFIG_H | |
14 # include "config.h" | |
15 #endif | |
16 | |
17 #include <pwd.h> | |
18 #include <stdio.h> | |
19 #include <stdlib.h> | |
20 #include <string.h> | |
21 #include <unistd.h> | |
22 #include <sys/param.h> | |
23 #include <dirent.h> | |
24 #include <utime.h> | |
25 | |
26 #include <glib.h> | |
27 #include <gtk/gtk.h> /* for locale warning dialog */ | |
28 | |
281 | 29 #include "main.h" |
9 | 30 #include "ui_fileops.h" |
31 | |
32 #include "ui_utildlg.h" /* for locale warning dialog */ | |
33 | |
34 /* | |
35 *----------------------------------------------------------------------------- | |
36 * generic file information and manipulation routines (public) | |
37 *----------------------------------------------------------------------------- | |
442 | 38 */ |
9 | 39 |
40 | |
41 | |
42 void print_term(const gchar *text_utf8) | |
43 { | |
44 gchar *text_l; | |
45 | |
46 text_l = g_locale_from_utf8(text_utf8, -1, NULL, NULL, NULL); | |
759 | 47 fputs((text_l) ? text_l : text_utf8, stdout); |
9 | 48 g_free(text_l); |
49 } | |
50 | |
51 static void encoding_dialog(const gchar *path); | |
52 | |
53 static gint encoding_dialog_idle(gpointer data) | |
54 { | |
55 gchar *path = data; | |
56 | |
57 encoding_dialog(path); | |
58 g_free(path); | |
59 | |
60 return FALSE; | |
61 } | |
62 | |
63 static gint encoding_dialog_delay(gpointer data) | |
64 { | |
65 g_idle_add(encoding_dialog_idle, data); | |
66 | |
67 return 0; | |
68 } | |
69 | |
70 static void encoding_dialog(const gchar *path) | |
71 { | |
72 static gint warned_user = FALSE; | |
73 GenericDialog *gd; | |
74 GString *string; | |
75 const gchar *lc; | |
76 const gchar *bf; | |
77 | |
78 /* check that gtk is initialized (loop is level > 0) */ | |
79 if (gtk_main_level() == 0) | |
80 { | |
81 /* gtk not initialized */ | |
82 gtk_init_add(encoding_dialog_delay, g_strdup(path)); | |
83 return; | |
84 } | |
85 | |
86 if (warned_user) return; | |
87 warned_user = TRUE; | |
88 | |
89 lc = getenv("LANG"); | |
90 bf = getenv("G_BROKEN_FILENAMES"); | |
91 | |
92 string = g_string_new(""); | |
989
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
93 g_string_append(string, _("One or more filenames are not encoded with the preferred locale character set.\n")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
94 g_string_append_printf(string, _("Operations on, and display of these files with %s may not succeed.\n"), PACKAGE); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
95 g_string_append(string, "\n"); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
96 g_string_append(string, _("If your filenames are not encoded in utf-8, try setting the environment variable G_BROKEN_FILENAMES=1\n")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
97 if (bf) |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
98 g_string_append_printf(string, _("It appears G_BROKEN_FILENAMES is set to %s\n"), bf); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
99 else |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
100 g_string_append(string, _("It appears G_BROKEN_FILENAMES is not set\n")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
101 g_string_append(string, "\n"); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
102 g_string_append_printf(string, _("The locale appears to be set to \"%s\"\n(set by the LANG environment variable)\n"), (lc) ? lc : "undefined"); |
9 | 103 if (lc && (strstr(lc, "UTF-8") || strstr(lc, "utf-8"))) |
104 { | |
105 gchar *name; | |
106 name = g_convert(path, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); | |
989
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
107 string = g_string_append(string, _("\nPreferred encoding appears to be UTF-8, however the file:\n")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
108 g_string_append_printf(string, "\"%s\"\n", (name) ? name : _("[name not displayable]")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
109 |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
110 if (g_utf8_validate(path, -1, NULL)) |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
111 g_string_append_printf(string, _("\"%s\" is encoded in valid UTF-8."), (name) ? name : _("[name not displayable]")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
112 else |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
113 g_string_append_printf(string, _("\"%s\" is not encoded in valid UTF-8."), (name) ? name : _("[name not displayable]")); |
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
114 g_string_append(string, "\n"); |
9 | 115 g_free(name); |
116 } | |
117 | |
989
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
118 gd = generic_dialog_new(_("Filename encoding locale mismatch"), |
254
9faf34f047b1
Make the wmclass value unique among the code by defining
zas_
parents:
138
diff
changeset
|
119 GQ_WMCLASS, "locale warning", NULL, TRUE, NULL, NULL); |
9 | 120 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE); |
121 | |
122 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING, | |
989
50e1f5e54c1a
Fix untranslated messages. French translation and POTFILES.in were updated.
zas_
parents:
983
diff
changeset
|
123 _("Filename encoding locale mismatch"), string->str); |
9 | 124 |
125 gtk_widget_show(gd->dialog); | |
126 | |
127 g_string_free(string, TRUE); | |
128 } | |
129 | |
130 gchar *path_to_utf8(const gchar *path) | |
131 { | |
132 gchar *utf8; | |
133 GError *error = NULL; | |
134 | |
135 if (!path) return NULL; | |
136 | |
137 utf8 = g_filename_to_utf8(path, -1, NULL, NULL, &error); | |
138 if (error) | |
139 { | |
673
fbebf5cf4a55
Do not use printf() directly but use new wrapper function log_printf() instead.
zas_
parents:
671
diff
changeset
|
140 log_printf("Unable to convert filename to UTF-8:\n%s\n%s\n", path, error->message); |
9 | 141 g_error_free(error); |
142 encoding_dialog(path); | |
143 } | |
144 if (!utf8) | |
145 { | |
146 /* just let it through, but bad things may happen */ | |
147 utf8 = g_strdup(path); | |
148 } | |
149 | |
150 return utf8; | |
151 } | |
152 | |
153 gchar *path_from_utf8(const gchar *utf8) | |
154 { | |
155 gchar *path; | |
156 GError *error = NULL; | |
157 | |
158 if (!utf8) return NULL; | |
159 | |
160 path = g_filename_from_utf8(utf8, -1, NULL, NULL, &error); | |
161 if (error) | |
162 { | |
673
fbebf5cf4a55
Do not use printf() directly but use new wrapper function log_printf() instead.
zas_
parents:
671
diff
changeset
|
163 log_printf("Unable to convert filename to locale from UTF-8:\n%s\n%s\n", utf8, error->message); |
9 | 164 g_error_free(error); |
165 } | |
166 if (!path) | |
167 { | |
168 /* if invalid UTF-8, text probaby still in original form, so just copy it */ | |
169 path = g_strdup(utf8); | |
170 } | |
171 | |
172 return path; | |
173 } | |
174 | |
175 /* first we try the HOME environment var, if that doesn't work, we try getpwuid(). */ | |
176 const gchar *homedir(void) | |
177 { | |
178 static gchar *home = NULL; | |
179 | |
180 if (!home) | |
181 { | |
182 home = path_to_utf8(getenv("HOME")); | |
183 } | |
184 if (!home) | |
185 { | |
186 struct passwd *pw = getpwuid(getuid()); | |
187 if (pw) home = path_to_utf8(pw->pw_dir); | |
188 } | |
189 | |
190 return home; | |
191 } | |
192 | |
193 gint stat_utf8(const gchar *s, struct stat *st) | |
194 { | |
195 gchar *sl; | |
196 gint ret; | |
197 | |
198 if (!s) return FALSE; | |
199 sl = path_from_utf8(s); | |
200 ret = (stat(sl, st) == 0); | |
201 g_free(sl); | |
202 | |
203 return ret; | |
204 } | |
205 | |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
206 gint lstat_utf8(const gchar *s, struct stat *st) |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
207 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
208 gchar *sl; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
209 gint ret; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
210 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
211 if (!s) return FALSE; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
212 sl = path_from_utf8(s); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
213 ret = (lstat(sl, st) == 0); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
214 g_free(sl); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
215 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
216 return ret; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
217 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
218 |
9 | 219 gint isname(const gchar *s) |
220 { | |
221 struct stat st; | |
222 | |
223 return stat_utf8(s, &st); | |
224 } | |
225 | |
226 gint isfile(const gchar *s) | |
227 { | |
228 struct stat st; | |
229 | |
230 return (stat_utf8(s, &st) && S_ISREG(st.st_mode)); | |
231 } | |
232 | |
233 gint isdir(const gchar *s) | |
234 { | |
235 struct stat st; | |
442 | 236 |
9 | 237 return (stat_utf8(s ,&st) && S_ISDIR(st.st_mode)); |
238 } | |
239 | |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
240 gint islink(const gchar *s) |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
241 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
242 struct stat st; |
442 | 243 |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
244 return (lstat_utf8(s ,&st) && S_ISLNK(st.st_mode)); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
245 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
246 |
9 | 247 gint64 filesize(const gchar *s) |
248 { | |
249 struct stat st; | |
442 | 250 |
9 | 251 if (!stat_utf8(s, &st)) return 0; |
983 | 252 return st.st_size; |
9 | 253 } |
254 | |
255 time_t filetime(const gchar *s) | |
256 { | |
442 | 257 struct stat st; |
9 | 258 |
259 if (!stat_utf8(s, &st)) return 0; | |
260 return st.st_mtime; | |
261 } | |
262 | |
263 gint filetime_set(const gchar *s, time_t tval) | |
264 { | |
265 gint ret = FALSE; | |
266 | |
267 if (tval > 0) | |
268 { | |
269 struct utimbuf ut; | |
270 gchar *sl; | |
271 | |
272 ut.actime = ut.modtime = tval; | |
273 | |
274 sl = path_from_utf8(s); | |
275 ret = (utime(sl, &ut) == 0); | |
276 g_free(sl); | |
277 } | |
278 | |
279 return ret; | |
280 } | |
281 | |
282 gint access_file(const gchar *s, int mode) | |
283 { | |
284 gchar *sl; | |
285 gint ret; | |
286 | |
287 if (!s) return FALSE; | |
288 | |
289 sl = path_from_utf8(s); | |
290 ret = (access(sl, mode) == 0); | |
291 g_free(sl); | |
292 | |
293 return ret; | |
294 } | |
295 | |
296 gint unlink_file(const gchar *s) | |
297 { | |
298 gchar *sl; | |
299 gint ret; | |
300 | |
301 if (!s) return FALSE; | |
302 | |
303 sl = path_from_utf8(s); | |
304 ret = (unlink(sl) == 0); | |
305 g_free(sl); | |
306 | |
307 return ret; | |
308 } | |
309 | |
310 gint symlink_utf8(const gchar *source, const gchar *target) | |
311 { | |
312 gchar *sl; | |
313 gchar *tl; | |
314 gint ret; | |
315 | |
316 if (!source || !target) return FALSE; | |
317 | |
318 sl = path_from_utf8(source); | |
319 tl = path_from_utf8(target); | |
320 | |
321 ret = (symlink(sl, tl) == 0); | |
322 | |
323 g_free(sl); | |
324 g_free(tl); | |
325 | |
326 return ret; | |
327 } | |
328 | |
329 gint mkdir_utf8(const gchar *s, int mode) | |
330 { | |
331 gchar *sl; | |
332 gint ret; | |
333 | |
334 if (!s) return FALSE; | |
335 | |
336 sl = path_from_utf8(s); | |
337 ret = (mkdir(sl, mode) == 0); | |
338 g_free(sl); | |
339 return ret; | |
340 } | |
341 | |
342 gint rmdir_utf8(const gchar *s) | |
343 { | |
344 gchar *sl; | |
345 gint ret; | |
346 | |
347 if (!s) return FALSE; | |
348 | |
349 sl = path_from_utf8(s); | |
350 ret = (rmdir(sl) == 0); | |
351 g_free(sl); | |
352 | |
353 return ret; | |
354 } | |
355 | |
356 gint copy_file_attributes(const gchar *s, const gchar *t, gint perms, gint mtime) | |
357 { | |
358 struct stat st; | |
359 gchar *sl, *tl; | |
360 gint ret = FALSE; | |
361 | |
362 if (!s || !t) return FALSE; | |
363 | |
364 sl = path_from_utf8(s); | |
365 tl = path_from_utf8(t); | |
366 | |
367 if (stat(sl, &st) == 0) | |
368 { | |
369 struct utimbuf tb; | |
370 | |
371 ret = TRUE; | |
372 | |
373 /* set the dest file attributes to that of source (ignoring errors) */ | |
374 | |
375 if (perms && chown(tl, st.st_uid, st.st_gid) < 0) ret = FALSE; | |
376 if (perms && chmod(tl, st.st_mode) < 0) ret = FALSE; | |
377 | |
378 tb.actime = st.st_atime; | |
379 tb.modtime = st.st_mtime; | |
380 if (mtime && utime(tl, &tb) < 0) ret = FALSE; | |
381 } | |
382 | |
383 g_free(sl); | |
384 g_free(tl); | |
385 | |
386 return ret; | |
387 } | |
388 | |
389 /* paths are in filesystem encoding */ | |
390 static gint hard_linked(const gchar *a, const gchar *b) | |
391 { | |
392 struct stat sta; | |
393 struct stat stb; | |
394 | |
395 if (stat(a, &sta) != 0 || stat(b, &stb) != 0) return FALSE; | |
396 | |
397 return (sta.st_dev == stb.st_dev && | |
398 sta.st_ino == stb.st_ino); | |
399 } | |
400 | |
401 gint copy_file(const gchar *s, const gchar *t) | |
402 { | |
403 FILE *fi = NULL; | |
404 FILE *fo = NULL; | |
405 gchar *sl, *tl; | |
406 gchar buf[4096]; | |
704
839525c4e85f
Use size_t instead of gint, it silents a signed vs unsigned warning.
zas_
parents:
703
diff
changeset
|
407 size_t b; |
9 | 408 |
409 sl = path_from_utf8(s); | |
410 tl = path_from_utf8(t); | |
411 | |
412 if (hard_linked(sl, tl)) | |
413 { | |
414 g_free(sl); | |
415 g_free(tl); | |
416 return TRUE; | |
417 } | |
418 | |
419 fi = fopen(sl, "rb"); | |
420 if (fi) | |
421 { | |
422 fo = fopen(tl, "wb"); | |
423 if (!fo) | |
424 { | |
425 fclose(fi); | |
426 fi = NULL; | |
427 } | |
428 } | |
429 | |
430 g_free(sl); | |
431 g_free(tl); | |
432 | |
433 if (!fi || !fo) return FALSE; | |
434 | |
516 | 435 while ((b = fread(buf, sizeof(char), sizeof(buf), fi)) && b != 0) |
9 | 436 { |
437 if (fwrite(buf, sizeof(char), b, fo) != b) | |
438 { | |
439 fclose(fi); | |
440 fclose(fo); | |
441 return FALSE; | |
442 } | |
443 } | |
444 | |
445 fclose(fi); | |
446 fclose(fo); | |
447 | |
448 copy_file_attributes(s, t, TRUE, TRUE); | |
449 | |
450 return TRUE; | |
451 } | |
452 | |
453 gint move_file(const gchar *s, const gchar *t) | |
454 { | |
455 gchar *sl, *tl; | |
456 gint ret = TRUE; | |
457 | |
458 if (!s || !t) return FALSE; | |
459 | |
460 sl = path_from_utf8(s); | |
461 tl = path_from_utf8(t); | |
462 if (rename(sl, tl) < 0) | |
463 { | |
464 /* this may have failed because moving a file across filesystems | |
465 was attempted, so try copy and delete instead */ | |
466 if (copy_file(s, t)) | |
467 { | |
468 if (unlink(sl) < 0) | |
469 { | |
470 /* err, now we can't delete the source file so return FALSE */ | |
471 ret = FALSE; | |
472 } | |
473 } | |
474 else | |
475 { | |
476 ret = FALSE; | |
477 } | |
478 } | |
479 g_free(sl); | |
480 g_free(tl); | |
481 | |
482 return ret; | |
483 } | |
484 | |
485 gint rename_file(const gchar *s, const gchar *t) | |
486 { | |
487 gchar *sl, *tl; | |
488 gint ret; | |
489 | |
490 if (!s || !t) return FALSE; | |
491 | |
492 sl = path_from_utf8(s); | |
493 tl = path_from_utf8(t); | |
494 ret = (rename(sl, tl) == 0); | |
495 g_free(sl); | |
496 g_free(tl); | |
497 | |
498 return ret; | |
499 } | |
500 | |
501 gchar *get_current_dir(void) | |
502 { | |
503 gchar *pathl; | |
504 gchar *path8; | |
505 | |
506 pathl = g_get_current_dir(); | |
507 path8 = path_to_utf8(pathl); | |
508 g_free(pathl); | |
509 | |
510 return path8; | |
511 } | |
512 | |
576
9dc0513837b5
dropped path_list functions, use filelist functions everywhere
nadvornik
parents:
545
diff
changeset
|
513 void string_list_free(GList *list) |
9 | 514 { |
515 g_list_foreach(list, (GFunc)g_free, NULL); | |
516 g_list_free(list); | |
517 } | |
518 | |
576
9dc0513837b5
dropped path_list functions, use filelist functions everywhere
nadvornik
parents:
545
diff
changeset
|
519 GList *string_list_copy(GList *list) |
9 | 520 { |
521 GList *new_list = NULL; | |
522 GList *work; | |
523 | |
524 work = list; | |
525 while (work) | |
526 { | |
527 gchar *path; | |
442 | 528 |
9 | 529 path = work->data; |
530 work = work->next; | |
442 | 531 |
9 | 532 new_list = g_list_prepend(new_list, g_strdup(path)); |
533 } | |
442 | 534 |
9 | 535 return g_list_reverse(new_list); |
536 } | |
537 | |
538 gchar *unique_filename(const gchar *path, const gchar *ext, const gchar *divider, gint pad) | |
539 { | |
540 gchar *unique; | |
541 gint n = 1; | |
542 | |
543 if (!ext) ext = ""; | |
544 if (!divider) divider = ""; | |
545 | |
546 unique = g_strconcat(path, ext, NULL); | |
547 while (isname(unique)) | |
548 { | |
549 g_free(unique); | |
550 if (pad) | |
551 { | |
552 unique = g_strdup_printf("%s%s%03d%s", path, divider, n, ext); | |
553 } | |
554 else | |
555 { | |
556 unique = g_strdup_printf("%s%s%d%s", path, divider, n, ext); | |
557 } | |
558 n++; | |
559 if (n > 999) | |
560 { | |
561 /* well, we tried */ | |
562 g_free(unique); | |
563 return NULL; | |
564 } | |
565 } | |
566 | |
567 return unique; | |
568 } | |
569 | |
570 gchar *unique_filename_simple(const gchar *path) | |
571 { | |
572 gchar *unique; | |
573 const gchar *name; | |
574 const gchar *ext; | |
575 | |
576 if (!path) return NULL; | |
577 | |
578 name = filename_from_path(path); | |
579 if (!name) return NULL; | |
580 | |
581 ext = extension_from_path(name); | |
582 | |
583 if (!ext) | |
584 { | |
585 unique = unique_filename(path, NULL, "_", TRUE); | |
586 } | |
587 else | |
588 { | |
589 gchar *base; | |
590 | |
591 base = remove_extension_from_path(path); | |
592 unique = unique_filename(base, ext, "_", TRUE); | |
593 g_free(base); | |
594 } | |
595 | |
596 return unique; | |
597 } | |
598 | |
599 const gchar *filename_from_path(const gchar *path) | |
600 { | |
601 const gchar *base; | |
602 | |
603 if (!path) return NULL; | |
604 | |
701 | 605 base = strrchr(path, G_DIR_SEPARATOR); |
9 | 606 if (base) return base + 1; |
607 | |
608 return path; | |
609 } | |
610 | |
611 gchar *remove_level_from_path(const gchar *path) | |
612 { | |
543 | 613 gint p = 0, n = -1; |
9 | 614 |
615 if (!path) return NULL; | |
616 | |
543 | 617 while (path[p]) |
618 { | |
701 | 619 if (path[p] == G_DIR_SEPARATOR) n = p; |
543 | 620 p++; |
621 } | |
622 if (n <= 0) n++; | |
623 | |
624 return g_strndup(path, (gsize) n); | |
9 | 625 } |
626 | |
627 const gchar *extension_from_path(const gchar *path) | |
628 { | |
629 if (!path) return NULL; | |
630 return strrchr(path, '.'); | |
631 } | |
632 | |
633 gint file_extension_match(const gchar *path, const gchar *ext) | |
634 { | |
635 gint p; | |
636 gint e; | |
637 | |
638 if (!path) return FALSE; | |
639 if (!ext) return TRUE; | |
640 | |
641 p = strlen(path); | |
642 e = strlen(ext); | |
643 | |
605
651ae2be1031
Use g_ascii_strncasecmp() instead of strncasecmp() where applicable.
zas_
parents:
576
diff
changeset
|
644 /* FIXME: utf8 */ |
9 | 645 return (p > e && strncasecmp(path + p - e, ext, e) == 0); |
646 } | |
647 | |
648 gchar *remove_extension_from_path(const gchar *path) | |
649 { | |
544 | 650 gint p = 0, n = -1; |
9 | 651 |
652 if (!path) return NULL; | |
653 | |
544 | 654 while (path[p]) |
655 { | |
656 if (path[p] == '.') n = p; | |
657 p++; | |
658 } | |
659 if (n < 0) n = p; | |
660 | |
661 return g_strndup(path, (gsize) n); | |
9 | 662 } |
663 | |
664 void parse_out_relatives(gchar *path) | |
665 { | |
666 gint s, t; | |
667 | |
668 if (!path) return; | |
669 | |
670 s = t = 0; | |
671 | |
672 while (path[s] != '\0') | |
673 { | |
919 | 674 if (path[s] == G_DIR_SEPARATOR && path[s+1] == '.') |
9 | 675 { |
919 | 676 /* /. occurence, let's see more */ |
677 gint p = s + 2; | |
678 | |
679 if (path[p] == G_DIR_SEPARATOR || path[p] == '\0') | |
680 { | |
681 /* /./ or /., just skip this part */ | |
682 s = p; | |
683 continue; | |
684 } | |
685 else if (path[p] == '.' && (path[p+1] == G_DIR_SEPARATOR || path[p+1] == '\0')) | |
686 { | |
687 /* /../ or /.., remove previous part, ie. /a/b/../ becomes /a/ */ | |
688 s = p + 1; | |
689 if (t > 0) t--; | |
690 while (path[t] != G_DIR_SEPARATOR && t > 0) t--; | |
691 continue; | |
692 } | |
9 | 693 } |
919 | 694 |
695 if (s != t) path[t] = path[s]; | |
696 t++; | |
697 s++; | |
9 | 698 } |
919 | 699 |
701 | 700 if (t == 0 && path[t] == G_DIR_SEPARATOR) t++; |
701 if (t > 1 && path[t-1] == G_DIR_SEPARATOR) t--; | |
9 | 702 path[t] = '\0'; |
703 } | |
704 | |
705 gint file_in_path(const gchar *name) | |
706 { | |
707 gchar *path; | |
708 gchar *namel; | |
709 gint p, l; | |
710 gint ret = FALSE; | |
711 | |
712 if (!name) return FALSE; | |
713 path = g_strdup(getenv("PATH")); | |
714 if (!path) return FALSE; | |
715 namel = path_from_utf8(name); | |
716 | |
717 p = 0; | |
718 l = strlen(path); | |
719 while (p < l && !ret) | |
720 { | |
721 gchar *f; | |
722 gint e = p; | |
723 while (path[e] != ':' && path[e] != '\0') e++; | |
724 path[e] = '\0'; | |
725 e++; | |
703 | 726 f = g_build_filename(path + p, namel, NULL); |
9 | 727 if (isfile(f)) ret = TRUE; |
728 g_free(f); | |
729 p = e; | |
730 } | |
731 g_free(namel); | |
732 g_free(path); | |
733 | |
734 return ret; | |
735 } |