src/pan-view/pan-util.cc

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "pan-util.h"
  23
  24 #include "ui-fileops.h"
  25
  26
  27 /*
  28  *-----------------------------------------------------------------------------
  29  * date functions
  30  *-----------------------------------------------------------------------------
  31  */
  32
  33 gboolean pan_date_compare(time_t a, time_t b, PanDateLengthType length)
  34 {
  35         struct tm ta;
  36         struct tm tb;
  37
  38         if (length == PAN_DATE_LENGTH_EXACT) return (a == b);
  39
  40         if (!localtime_r(&a, &ta) ||
  41             !localtime_r(&b, &tb)) return FALSE;
  42
  43         if (ta.tm_year != tb.tm_year) return FALSE;
  44         if (length == PAN_DATE_LENGTH_YEAR) return TRUE;
  45
  46         if (ta.tm_mon != tb.tm_mon) return FALSE;
  47         if (length == PAN_DATE_LENGTH_MONTH) return TRUE;
  48
  49         if (length == PAN_DATE_LENGTH_WEEK) return (ta.tm_yday / 7 == tb.tm_yday / 7);
  50
  51         if (ta.tm_mday != tb.tm_mday) return FALSE;
  52         if (length == PAN_DATE_LENGTH_DAY) return TRUE;
  53
  54         return (ta.tm_hour == tb.tm_hour);
  55 }
  56
  57 gint pan_date_value(time_t d, PanDateLengthType length)
  58 {
  59         struct tm td;
  60
  61         if (!localtime_r(&d, &td)) return -1;
  62
  63         switch (length)
  64                 {
  65                 case PAN_DATE_LENGTH_DAY:
  66                         return td.tm_mday;
  67                         break;
  68                 case PAN_DATE_LENGTH_WEEK:
  69                         return td.tm_wday;
  70                         break;
  71                 case PAN_DATE_LENGTH_MONTH:
  72                         return td.tm_mon + 1;
  73                         break;
  74                 case PAN_DATE_LENGTH_YEAR:
  75                         return td.tm_year + 1900;
  76                         break;
  77                 case PAN_DATE_LENGTH_EXACT:
  78                 default:
  79                         break;
  80                 }
  81
  82         return -1;
  83 }
  84
  85 #if defined(__GLIBC_PREREQ)
  86 # if __GLIBC_PREREQ(2, 27)
  87 #  define HAS_GLIBC_STRFTIME_EXTENSIONS
  88 # endif
  89 #endif
  90
  91 gchar *pan_date_value_string(time_t d, PanDateLengthType length)
  92 {
  93         struct tm td;
  94         gchar buf[128];
  95         const gchar *format = nullptr;
  96
  97         if (!localtime_r(&d, &td)) return g_strdup("");
  98
  99         switch (length)
 100                 {
 101                 case PAN_DATE_LENGTH_DAY:
 102                         return g_strdup_printf("%d", td.tm_mday);
 103                         break;
 104                 case PAN_DATE_LENGTH_WEEK:
 105                         format = "%A %e";
 106                         break;
 107                 case PAN_DATE_LENGTH_MONTH:
 108 #if defined(HAS_GLIBC_STRFTIME_EXTENSIONS) || defined(__FreeBSD__)
 109                         format = "%OB %Y";
 110 #else
 111                         format = "%B %Y";
 112 #endif
 113                         break;
 114                 case PAN_DATE_LENGTH_YEAR:
 115                         return g_strdup_printf("%d", td.tm_year + 1900);
 116                         break;
 117                 case PAN_DATE_LENGTH_EXACT:
 118                 default:
 119                         return g_strdup(text_from_time(d));
 120                         break;
 121                 }
 122
 123
 124         if (format && strftime(buf, sizeof(buf), format, &td) > 0)
 125                 {
 126                 gchar *ret = g_locale_to_utf8(buf, -1, nullptr, nullptr, nullptr);
 127                 if (ret) return ret;
 128                 }
 129
 130         return g_strdup("");
 131 }
 132
 133 time_t pan_date_to_time(gint year, gint month, gint day)
 134 {
 135         struct tm lt;
 136
 137         lt.tm_sec = 0;
 138         lt.tm_min = 0;
 139         lt.tm_hour = 0;
 140         lt.tm_mday = (day >= 1 && day <= 31) ? day : 1;
 141         lt.tm_mon = (month >= 1 && month <= 12) ? month - 1 : 0;
 142         lt.tm_year = year - 1900;
 143         lt.tm_isdst = 0;
 144
 145         return mktime(&lt);
 146 }
 147
 148
 149 /*
 150  *-----------------------------------------------------------------------------
 151  * folder validation
 152  *-----------------------------------------------------------------------------
 153  */
 154
 155 gboolean pan_is_link_loop(const gchar *s)
 156 {
 157         gchar *sl;
 158         struct stat st;
 159         gboolean ret = FALSE;
 160
 161         sl = path_from_utf8(s);
 162
 163         if (lstat(sl, &st) == 0 && S_ISLNK(st.st_mode))
 164                 {
 165                 gchar *buf;
 166                 gint l;
 167
 168                 buf = static_cast<gchar *>(g_malloc(st.st_size + 1));
 169                 l = readlink(sl, buf, st.st_size);
 170                 if (l == st.st_size)
 171                         {
 172                         buf[l] = '\0';
 173
 174                         parse_out_relatives(buf);
 175                         l = strlen(buf);
 176
 177                         parse_out_relatives(sl);
 178
 179                         if (buf[0] == G_DIR_SEPARATOR)
 180                                 {
 181                                 if (strncmp(sl, buf, l) == 0 &&
 182                                     (sl[l] == '\0' || sl[l] == G_DIR_SEPARATOR || l == 1)) ret = TRUE;
 183                                 }
 184                         else
 185                                 {
 186                                 gchar *link_path;
 187
 188                                 link_path = g_build_filename(sl, buf, NULL);
 189                                 parse_out_relatives(link_path);
 190
 191                                 if (strncmp(sl, link_path, l) == 0 &&
 192                                     (sl[l] == '\0' || sl[l] == G_DIR_SEPARATOR || l == 1)) ret = TRUE;
 193
 194                                 g_free(link_path);
 195                                 }
 196                         }
 197
 198                 g_free(buf);
 199                 }
 200
 201         g_free(sl);
 202
 203         return ret;
 204 }
 205
 206 gboolean pan_is_ignored(const gchar *s, gboolean ignore_symlinks)
 207 {
 208         struct stat st;
 209         const gchar *n;
 210
 211         if (!lstat_utf8(s, &st)) return TRUE;
 212
 213 #if 0
 214         /* normal filesystems have directories with some size or block allocation,
 215          * special filesystems (like linux /proc) set both to zero.
 216          * enable this check if you enable listing the root "/" folder
 217          */
 218         if (st.st_size == 0 && st.st_blocks == 0) return TRUE;
 219 #endif
 220
 221         if (S_ISLNK(st.st_mode) && (ignore_symlinks || pan_is_link_loop(s))) return TRUE;
 222
 223         n = filename_from_path(s);
 224         if (n && strcmp(n, GQ_RC_DIR) == 0) return TRUE;
 225
 226         return FALSE;
 227 }
 228
 229 GList *pan_list_tree(FileData *dir_fd, SortType sort, gboolean ascend, gboolean case_sensitive,
 230                      gboolean ignore_symlinks)
 231 {
 232         GList *flist;
 233         GList *dlist;
 234         GList *result;
 235         GList *folders;
 236
 237         filelist_read(dir_fd, &flist, &dlist);
 238         if (sort != SORT_NONE)
 239                 {
 240                 flist = filelist_sort(flist, sort, ascend, case_sensitive);
 241                 dlist = filelist_sort(dlist, sort, ascend, case_sensitive);
 242                 }
 243
 244         result = flist;
 245         folders = dlist;
 246         while (folders)
 247                 {
 248                 FileData *fd;
 249
 250                 fd = static_cast<FileData *>(folders->data);
 251                 folders = g_list_remove(folders, fd);
 252
 253                 if (!pan_is_ignored(fd->path, ignore_symlinks) &&
 254                     filelist_read(fd, &flist, &dlist))
 255                         {
 256                         if (sort != SORT_NONE)
 257                                 {
 258                                 flist = filelist_sort(flist, sort, ascend, case_sensitive);
 259                                 dlist = filelist_sort(dlist, sort, ascend, case_sensitive);
 260                                 }
 261
 262                         result = g_list_concat(result, flist);
 263                         folders = g_list_concat(dlist, folders);
 264                         }
 265
 266                 file_data_unref(fd);
 267                 }
 268
 269         return result;
 270 }
 271 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */