Mercurial > geeqie.yaz

comparison src/ui_fileops.c @ 1448:89dedc61b1bd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gint -> gboolean.
author zas_
date Sun, 15 Mar 2009 20:16:20 +0000
parents a3d3208b0c50
children 70f94d61b1aa
comparison
equal deleted inserted replaced
1447:a10d70ae85e9 1448:89dedc61b1bd
48 g_free(text_l); 48 g_free(text_l);
49 } 49 }
50 50
51 static void encoding_dialog(const gchar *path); 51 static void encoding_dialog(const gchar *path);
52 52
53 static gint encoding_dialog_idle(gpointer data) 53 static gboolean encoding_dialog_idle(gpointer data)
54 { 54 {
55 gchar *path = data; 55 gchar *path = data;
56 56
57 encoding_dialog(path); 57 encoding_dialog(path);
58 g_free(path); 58 g_free(path);
299 } 299 }
300 300
301 return trash_dir; 301 return trash_dir;
302 } 302 }
303 303
304 gint stat_utf8(const gchar *s, struct stat *st) 304 gboolean stat_utf8(const gchar *s, struct stat *st)
305 { 305 {
306 gchar *sl; 306 gchar *sl;
307 gint ret; 307 gboolean ret;
308 308
309 if (!s) return FALSE; 309 if (!s) return FALSE;
310 sl = path_from_utf8(s); 310 sl = path_from_utf8(s);
311 ret = (stat(sl, st) == 0); 311 ret = (stat(sl, st) == 0);
312 g_free(sl); 312 g_free(sl);
313 313
314 return ret; 314 return ret;
315 } 315 }
316 316
317 gint lstat_utf8(const gchar *s, struct stat *st) 317 gboolean lstat_utf8(const gchar *s, struct stat *st)
318 { 318 {
319 gchar *sl; 319 gchar *sl;
320 gint ret; 320 gboolean ret;
321 321
322 if (!s) return FALSE; 322 if (!s) return FALSE;
323 sl = path_from_utf8(s); 323 sl = path_from_utf8(s);
324 ret = (lstat(sl, st) == 0); 324 ret = (lstat(sl, st) == 0);
325 g_free(sl); 325 g_free(sl);
326 326
327 return ret; 327 return ret;
328 } 328 }
329 329
330 /* extension must contain only ASCII characters */ 330 /* extension must contain only ASCII characters */
331 gint stat_utf8_case_insensitive_ext(GString *base, const gchar *ext, struct stat *st) 331 gboolean stat_utf8_case_insensitive_ext(GString *base, const gchar *ext, struct stat *st)
332 { 332 {
333 gchar *sl; 333 gchar *sl;
334 gchar *extl; 334 gchar *extl;
335 gint ret = 0; 335 gboolean ret = FALSE;
336 gint ext_len; 336 gint ext_len;
337 gint base_len = strlen(base->str); 337 gint base_len = strlen(base->str);
338 338
339 g_string_append(base, ext); 339 g_string_append(base, ext);
340 sl = path_from_utf8(base->str); 340 sl = path_from_utf8(base->str);
370 g_free(sl); 370 g_free(sl);
371 371
372 return ret; 372 return ret;
373 } 373 }
374 374
375 gint isname(const gchar *s) 375 gboolean isname(const gchar *s)
376 { 376 {
377 struct stat st; 377 struct stat st;
378 378
379 return stat_utf8(s, &st); 379 return stat_utf8(s, &st);
380 } 380 }
381 381
382 gint isfile(const gchar *s) 382 gboolean isfile(const gchar *s)
383 { 383 {
384 struct stat st; 384 struct stat st;
385 385
386 return (stat_utf8(s, &st) && S_ISREG(st.st_mode)); 386 return (stat_utf8(s, &st) && S_ISREG(st.st_mode));
387 } 387 }
388 388
389 gint isdir(const gchar *s) 389 gboolean isdir(const gchar *s)
390 { 390 {
391 struct stat st; 391 struct stat st;
392 392
393 return (stat_utf8(s, &st) && S_ISDIR(st.st_mode)); 393 return (stat_utf8(s, &st) && S_ISDIR(st.st_mode));
394 } 394 }
395 395
396 gint islink(const gchar *s) 396 gboolean islink(const gchar *s)
397 { 397 {
398 struct stat st; 398 struct stat st;
399 399
400 return (lstat_utf8(s, &st) && S_ISLNK(st.st_mode)); 400 return (lstat_utf8(s, &st) && S_ISLNK(st.st_mode));
401 } 401 }
414 414
415 if (!stat_utf8(s, &st)) return 0; 415 if (!stat_utf8(s, &st)) return 0;
416 return st.st_mtime; 416 return st.st_mtime;
417 } 417 }
418 418
419 gint filetime_set(const gchar *s, time_t tval) 419 gboolean filetime_set(const gchar *s, time_t tval)
420 { 420 {
421 gboolean ret = FALSE; 421 gboolean ret = FALSE;
422 422
423 if (tval > 0) 423 if (tval > 0)
424 { 424 {
439 { 439 {
440 if (!s || !s[0] || !isfile(s)) return FALSE; 440 if (!s || !s[0] || !isfile(s)) return FALSE;
441 return access_file(s, R_OK); 441 return access_file(s, R_OK);
442 } 442 }
443 443
444 gint access_file(const gchar *s, gint mode) 444 gboolean access_file(const gchar *s, gint mode)
445 { 445 {
446 gchar *sl; 446 gchar *sl;
447 gint ret; 447 gint ret;
448 448
449 if (!s || !s[0]) return FALSE; 449 if (!s || !s[0]) return FALSE;
453 g_free(sl); 453 g_free(sl);
454 454
455 return ret; 455 return ret;
456 } 456 }
457 457
458 gint unlink_file(const gchar *s) 458 gboolean unlink_file(const gchar *s)
459 { 459 {
460 gchar *sl; 460 gchar *sl;
461 gint ret; 461 gboolean ret;
462 462
463 if (!s) return FALSE; 463 if (!s) return FALSE;
464 464
465 sl = path_from_utf8(s); 465 sl = path_from_utf8(s);
466 ret = (unlink(sl) == 0); 466 ret = (unlink(sl) == 0);
467 g_free(sl); 467 g_free(sl);
468 468
469 return ret; 469 return ret;
470 } 470 }
471 471
472 gint symlink_utf8(const gchar *source, const gchar *target) 472 gboolean symlink_utf8(const gchar *source, const gchar *target)
473 { 473 {
474 gchar *sl; 474 gchar *sl;
475 gchar *tl; 475 gchar *tl;
476 gint ret; 476 gboolean ret;
477 477
478 if (!source || !target) return FALSE; 478 if (!source || !target) return FALSE;
479 479
480 sl = path_from_utf8(source); 480 sl = path_from_utf8(source);
481 tl = path_from_utf8(target); 481 tl = path_from_utf8(target);
486 g_free(tl); 486 g_free(tl);
487 487
488 return ret; 488 return ret;
489 } 489 }
490 490
491 gint mkdir_utf8(const gchar *s, gint mode) 491 gboolean mkdir_utf8(const gchar *s, gint mode)
492 { 492 {
493 gchar *sl; 493 gchar *sl;
494 gint ret; 494 gboolean ret;
495 495
496 if (!s) return FALSE; 496 if (!s) return FALSE;
497 497
498 sl = path_from_utf8(s); 498 sl = path_from_utf8(s);
499 ret = (mkdir(sl, mode) == 0); 499 ret = (mkdir(sl, mode) == 0);
500 g_free(sl); 500 g_free(sl);
501 return ret; 501 return ret;
502 } 502 }
503 503
504 gint rmdir_utf8(const gchar *s) 504 gboolean rmdir_utf8(const gchar *s)
505 { 505 {
506 gchar *sl; 506 gchar *sl;
507 gint ret; 507 gboolean ret;
508 508
509 if (!s) return FALSE; 509 if (!s) return FALSE;
510 510
511 sl = path_from_utf8(s); 511 sl = path_from_utf8(s);
512 ret = (rmdir(sl) == 0); 512 ret = (rmdir(sl) == 0);
513 g_free(sl); 513 g_free(sl);
514 514
515 return ret; 515 return ret;
516 } 516 }
517 517
518 gint copy_file_attributes(const gchar *s, const gchar *t, gint perms, gint mtime) 518 gboolean copy_file_attributes(const gchar *s, const gchar *t, gint perms, gint mtime)
519 { 519 {
520 struct stat st; 520 struct stat st;
521 gchar *sl, *tl; 521 gchar *sl, *tl;
522 gboolean ret = FALSE; 522 gboolean ret = FALSE;
523 523
547 547
548 return ret; 548 return ret;
549 } 549 }
550 550
551 /* paths are in filesystem encoding */ 551 /* paths are in filesystem encoding */
552 static gint hard_linked(const gchar *a, const gchar *b) 552 static gboolean hard_linked(const gchar *a, const gchar *b)
553 { 553 {
554 struct stat sta; 554 struct stat sta;
555 struct stat stb; 555 struct stat stb;
556 556
557 if (stat(a, &sta) != 0 || stat(b, &stb) != 0) return FALSE; 557 if (stat(a, &sta) != 0 || stat(b, &stb) != 0) return FALSE;
558 558
559 return (sta.st_dev == stb.st_dev && 559 return (sta.st_dev == stb.st_dev &&
560 sta.st_ino == stb.st_ino); 560 sta.st_ino == stb.st_ino);
561 } 561 }
562 562
563 gint copy_file(const gchar *s, const gchar *t) 563 gboolean copy_file(const gchar *s, const gchar *t)
564 { 564 {
565 FILE *fi = NULL; 565 FILE *fi = NULL;
566 FILE *fo = NULL; 566 FILE *fo = NULL;
567 gchar *sl, *tl; 567 gchar *sl, *tl;
568 gchar buf[4096]; 568 gchar buf[4096];
610 copy_file_attributes(s, t, TRUE, TRUE); 610 copy_file_attributes(s, t, TRUE, TRUE);
611 611
612 return TRUE; 612 return TRUE;
613 } 613 }
614 614
615 gint move_file(const gchar *s, const gchar *t) 615 gboolean move_file(const gchar *s, const gchar *t)
616 { 616 {
617 gchar *sl, *tl; 617 gchar *sl, *tl;
618 gboolean ret = TRUE; 618 gboolean ret = TRUE;
619 619
620 if (!s || !t) return FALSE; 620 if (!s || !t) return FALSE;
642 g_free(tl); 642 g_free(tl);
643 643
644 return ret; 644 return ret;
645 } 645 }
646 646
647 gint rename_file(const gchar *s, const gchar *t) 647 gboolean rename_file(const gchar *s, const gchar *t)
648 { 648 {
649 gchar *sl, *tl; 649 gchar *sl, *tl;
650 gint ret; 650 gboolean ret;
651 651
652 if (!s || !t) return FALSE; 652 if (!s || !t) return FALSE;
653 653
654 sl = path_from_utf8(s); 654 sl = path_from_utf8(s);
655 tl = path_from_utf8(t); 655 tl = path_from_utf8(t);
694 } 694 }
695 695
696 return g_list_reverse(new_list); 696 return g_list_reverse(new_list);
697 } 697 }
698 698
699 gchar *unique_filename(const gchar *path, const gchar *ext, const gchar *divider, gint pad) 699 gchar *unique_filename(const gchar *path, const gchar *ext, const gchar *divider, gboolean pad)
700 { 700 {
701 gchar *unique; 701 gchar *unique;
702 gint n = 1; 702 gint n = 1;
703 703
704 if (!ext) ext = ""; 704 if (!ext) ext = "";
789 { 789 {
790 if (!path) return NULL; 790 if (!path) return NULL;
791 return strrchr(path, '.'); 791 return strrchr(path, '.');
792 } 792 }
793 793
794 gint file_extension_match(const gchar *path, const gchar *ext) 794 gboolean file_extension_match(const gchar *path, const gchar *ext)
795 { 795 {
796 gint p; 796 gint p;
797 gint e; 797 gint e;
798 798
799 if (!path) return FALSE; 799 if (!path) return FALSE;
861 if (t == 0 && path[t] == G_DIR_SEPARATOR) t++; 861 if (t == 0 && path[t] == G_DIR_SEPARATOR) t++;
862 if (t > 1 && path[t-1] == G_DIR_SEPARATOR) t--; 862 if (t > 1 && path[t-1] == G_DIR_SEPARATOR) t--;
863 path[t] = '\0'; 863 path[t] = '\0';
864 } 864 }
865 865
866 gint file_in_path(const gchar *name) 866 gboolean file_in_path(const gchar *name)
867 { 867 {
868 gchar *path; 868 gchar *path;
869 gchar *namel; 869 gchar *namel;
870 gint p, l; 870 gint p, l;
871 gboolean ret = FALSE; 871 gboolean ret = FALSE;