GList *pan_list_tree(const gchar *path, SortType sort, gint ascend,
gint ignore_symlinks)
{
GList *flist = NULL;
GList *dlist = NULL;
GList *result;
GList *folders;
filelist_read(path, &flist, &dlist);
if (sort != SORT_NONE)
{
flist = filelist_sort(flist, sort, ascend);
dlist = filelist_sort(dlist, sort, ascend);
}
result = flist;
folders = dlist;
while (folders)
{
FileData *fd;
fd = folders->data;
folders = g_list_remove(folders, fd);
if (!pan_is_ignored(fd->path, ignore_symlinks) &&
filelist_read(fd->path, &flist, &dlist))
{
if (sort != SORT_NONE)
{
flist = filelist_sort(flist, sort, ascend);
dlist = filelist_sort(dlist, sort, ascend);
}
result = g_list_concat(result, flist);
folders = g_list_concat(dlist, folders);
}
file_data_free(fd);
}
return result;
}
/* Outputs a sorted list of files/directories matching the mask,
* to idx.
*/
static void filedb_ls(FILE *fdb, int idx, char *mask, int showall)
{
int ok = 0, cnt = 0, is = 0;
char s1[81], *p = NULL;
struct flag_record user = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
filedb_entry *fdbe = NULL;
filelist_t *flist = NULL;
flist = filelist_new();
filedb_readtop(fdb, NULL);
fdbe = filedb_getfile(fdb, ftell(fdb), GET_FULL);
while (fdbe) {
ok = 1;
if (fdbe->stat & FILE_UNUSED)
ok = 0;
if (ok && (fdbe->stat & FILE_DIR) && fdbe->flags_req) {
/* Check permissions */
struct flag_record req = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
break_down_flags(fdbe->flags_req, &req, NULL);
get_user_flagrec(dcc[idx].user, &user, dcc[idx].u.file->chat->con_chan);
if (!flagrec_ok(&req, &user)) {
ok = 0;
}
}
if (ok)
is = 1;
if (ok && !wild_match_file(mask, fdbe->filename))
ok = 0;
if (ok && (fdbe->stat & FILE_HIDDEN) && !(showall))
ok = 0;
if (ok) {
/* Display it! */
if (cnt == 0) {
dprintf(idx, FILES_LSHEAD1);
dprintf(idx, FILES_LSHEAD2);
}
filelist_add(flist, fdbe->filename);
if (fdbe->stat & FILE_DIR) {
char *s2 = NULL, *s3 = NULL;
/* Too long? */
if (strlen(fdbe->filename) > 45) {
/* Display the filename on its own line. */
s2 = nmalloc(strlen(fdbe->filename) + 3);
sprintf(s2, "%s/\n", fdbe->filename);
filelist_addout(flist, s2);
my_free(s2);
} else {
s2 = nmalloc(strlen(fdbe->filename) + 2);
sprintf(s2, "%s/", fdbe->filename);
}
/* Note: You have to keep the sprintf and the nmalloc statements
* in sync, i.e. always check that you allocate enough
* memory.
*/
if ((fdbe->flags_req) && (user.global &(USER_MASTER | USER_JANITOR))) {
s3 = nmalloc(42 + strlen(s2 ? s2 : "") + 6 +
strlen(FILES_REQUIRES) + strlen(fdbe->flags_req) + 1 +
strlen(fdbe->chan ? fdbe->chan : "") + 1);
sprintf(s3, "%-30s <DIR%s> (%s %s%s%s)\n", s2,
fdbe->stat & FILE_SHARE ?
" SHARE" : "", FILES_REQUIRES, fdbe->flags_req,
fdbe->chan ? " " : "", fdbe->chan ? fdbe->chan : "");
} else {
s3 = nmalloc(38 + strlen(s2 ? s2 : ""));
sprintf(s3, "%-30s <DIR>\n", s2 ? s2 : "");
}
if (s2)
my_free(s2);
filelist_addout(flist, s3);
my_free(s3);
} else {
char s2[41], t[50], *s3 = NULL, *s4;
s2[0] = 0;
if (showall) {
if (fdbe->stat & FILE_SHARE)
strcat(s2, " (shr)");
if (fdbe->stat & FILE_HIDDEN)
strcat(s2, " (hid)");
}
egg_strftime(t, 10, "%d%b%Y", localtime(&fdbe->uploaded));
if (fdbe->size < 1024)
sprintf(s1, "%5d", fdbe->size);
else
sprintf(s1, "%4dk", (int) (fdbe->size / 1024));
if (fdbe->sharelink)
strcpy(s1, " ");
/* Too long? */
if (strlen(fdbe->filename) > 30) {
s3 = nmalloc(strlen(fdbe->filename) + 2);
sprintf(s3, "%s\n", fdbe->filename);
filelist_addout(flist, s3);
my_free(s3);
/* Causes filename to be displayed on its own line */
} else
malloc_strcpy(s3, fdbe->filename);
s4 = nmalloc(69 + strlen(s3 ? s3 : "") + strlen(s1) +
strlen(fdbe->uploader) + strlen(t) + strlen(s2));
sprintf(s4, "%-30s %s %-9s (%s) %6d%s\n", s3 ? s3 : "", s1,
fdbe->uploader, t, fdbe->gots, s2);
if (s3)
my_free(s3);
filelist_addout(flist, s4);
my_free(s4);
if (fdbe->sharelink) {
s4 = nmalloc(9 + strlen(fdbe->sharelink));
sprintf(s4, " --> %s\n", fdbe->sharelink);
filelist_addout(flist, s4);
my_free(s4);
}
}
if (fdbe->desc) {
p = strchr(fdbe->desc, '\n');
while (p != NULL) {
*p = 0;
if ((fdbe->desc)[0]) {
char *sd;
sd = nmalloc(strlen(fdbe->desc) + 5);
sprintf(sd, " %s\n", fdbe->desc);
filelist_addout(flist, sd);
my_free(sd);
}
strcpy(fdbe->desc, p + 1);
p = strchr(fdbe->desc, '\n');
}
if ((fdbe->desc)[0]) {
char *sd;
sd = nmalloc(strlen(fdbe->desc) + 5);
sprintf(sd, " %s\n", fdbe->desc);
filelist_addout(flist, sd);
my_free(sd);
}
}
cnt++;
}
free_fdbe(&fdbe);
fdbe = filedb_getfile(fdb, ftell(fdb), GET_FULL);
}
if (is == 0)
dprintf(idx, FILES_NOFILES);
else if (cnt == 0)
dprintf(idx, FILES_NOMATCH);
else {
filelist_sort(flist);
filelist_idxshow(flist, idx);
dprintf(idx, "--- %d file%s.\n", cnt, cnt != 1 ? "s" : "");
}
filelist_free(flist);
}
void filelist_from_main(struct FileList *filelist)
{
ID *id;
struct direntry *files, *firstlib = NULL;
ListBase *lb;
int a, fake, idcode, ok, totlib, totbl;
// filelist->type = FILE_MAIN; // XXXXX TODO: add modes to filebrowser
if (filelist->dir[0]=='/') filelist->dir[0]= 0;
if (filelist->dir[0]) {
idcode= groupname_to_code(filelist->dir);
if (idcode==0) filelist->dir[0]= 0;
}
if ( filelist->dir[0]==0) {
/* make directories */
filelist->numfiles= 24;
filelist->filelist= (struct direntry *)malloc(filelist->numfiles * sizeof(struct direntry));
for (a=0; a<filelist->numfiles; a++) {
memset( &(filelist->filelist[a]), 0 , sizeof(struct direntry));
filelist->filelist[a].type |= S_IFDIR;
}
filelist->filelist[0].relname= BLI_strdup("..");
filelist->filelist[2].relname= BLI_strdup("Scene");
filelist->filelist[3].relname= BLI_strdup("Object");
filelist->filelist[4].relname= BLI_strdup("Mesh");
filelist->filelist[5].relname= BLI_strdup("Curve");
filelist->filelist[6].relname= BLI_strdup("Metaball");
filelist->filelist[7].relname= BLI_strdup("Material");
filelist->filelist[8].relname= BLI_strdup("Texture");
filelist->filelist[9].relname= BLI_strdup("Image");
filelist->filelist[10].relname= BLI_strdup("Ika");
filelist->filelist[11].relname= BLI_strdup("Wave");
filelist->filelist[12].relname= BLI_strdup("Lattice");
filelist->filelist[13].relname= BLI_strdup("Lamp");
filelist->filelist[14].relname= BLI_strdup("Camera");
filelist->filelist[15].relname= BLI_strdup("Ipo");
filelist->filelist[16].relname= BLI_strdup("World");
filelist->filelist[17].relname= BLI_strdup("Screen");
filelist->filelist[18].relname= BLI_strdup("VFont");
filelist->filelist[19].relname= BLI_strdup("Text");
filelist->filelist[20].relname= BLI_strdup("Armature");
filelist->filelist[21].relname= BLI_strdup("Action");
filelist->filelist[22].relname= BLI_strdup("NodeTree");
filelist->filelist[23].relname= BLI_strdup("Speaker");
filelist_sort(filelist, FILE_SORT_ALPHA);
}
else {
/* make files */
idcode= groupname_to_code(filelist->dir);
lb= which_libbase(G.main, idcode );
if (lb == NULL) return;
id= lb->first;
filelist->numfiles= 0;
while (id) {
if (!filelist->hide_dot || id->name[2] != '.') {
filelist->numfiles++;
}
id= id->next;
}
/* XXXXX TODO: if databrowse F4 or append/link filelist->hide_parent has to be set */
if (!filelist->hide_parent) filelist->numfiles+= 1;
filelist->filelist= filelist->numfiles > 0 ? (struct direntry *)malloc(filelist->numfiles * sizeof(struct direntry)) : NULL;
files = filelist->filelist;
if (!filelist->hide_parent) {
memset( &(filelist->filelist[0]), 0 , sizeof(struct direntry));
filelist->filelist[0].relname= BLI_strdup("..");
filelist->filelist[0].type |= S_IFDIR;
files++;
}
id= lb->first;
totlib= totbl= 0;
while (id) {
ok = 1;
if (ok) {
if (!filelist->hide_dot || id->name[2] != '.') {
memset( files, 0 , sizeof(struct direntry));
if (id->lib==NULL)
files->relname= BLI_strdup(id->name+2);
else {
files->relname= MEM_mallocN(FILE_MAX+32, "filename for lib");
sprintf(files->relname, "%s | %s", id->lib->name, id->name+2);
}
files->type |= S_IFREG;
#if 0 // XXXXX TODO show the selection status of the objects
if (!filelist->has_func) { /* F4 DATA BROWSE */
if (idcode==ID_OB) {
if ( ((Object *)id)->flag & SELECT) files->selflag |= SELECTED_FILE;
}
else if (idcode==ID_SCE) {
if ( ((Scene *)id)->r.scemode & R_BG_RENDER) files->selflag |= SELECTED_FILE;
}
}
#endif
files->nr= totbl+1;
files->poin= id;
fake= id->flag & LIB_FAKEUSER;
if (idcode == ID_MA || idcode == ID_TE || idcode == ID_LA || idcode == ID_WO || idcode == ID_IM) {
files->flags |= IMAGEFILE;
}
if (id->lib && fake) BLI_snprintf(files->extra, sizeof(files->extra), "LF %d", id->us);
else if (id->lib) BLI_snprintf(files->extra, sizeof(files->extra), "L %d", id->us);
else if (fake) BLI_snprintf(files->extra, sizeof(files->extra), "F %d", id->us);
else BLI_snprintf(files->extra, sizeof(files->extra), " %d", id->us);
if (id->lib) {
if (totlib==0) firstlib= files;
totlib++;
}
files++;
}
totbl++;
}
id= id->next;
}
/* only qsort of library blocks */
if (totlib>1) {
qsort(firstlib, totlib, sizeof(struct direntry), compare_name);
}
}
filelist->filter = 0;
filelist_filter(filelist);
}
void filelist_from_library(struct FileList* filelist)
{
LinkNode *l, *names, *previews;
struct ImBuf* ima;
int ok, i, nprevs, nnames, idcode;
char filename[FILE_MAX];
char dir[FILE_MAX], group[GROUP_MAX];
/* name test */
ok= filelist_islibrary(filelist, dir, group);
if (!ok) {
/* free */
if (filelist->libfiledata) BLO_blendhandle_close(filelist->libfiledata);
filelist->libfiledata= NULL;
return;
}
BLI_strncpy(filename, G.main->name, sizeof(filename));
/* there we go */
/* for the time being only read filedata when libfiledata==0 */
if (filelist->libfiledata == NULL) {
filelist->libfiledata= BLO_blendhandle_from_file(dir, NULL);
if (filelist->libfiledata == NULL) return;
}
idcode= groupname_to_code(group);
/* memory for strings is passed into filelist[i].relname
* and freed in freefilelist */
if (idcode) {
previews= BLO_blendhandle_get_previews(filelist->libfiledata, idcode, &nprevs);
names= BLO_blendhandle_get_datablock_names(filelist->libfiledata, idcode, &nnames);
/* ugh, no rewind, need to reopen */
BLO_blendhandle_close(filelist->libfiledata);
filelist->libfiledata= BLO_blendhandle_from_file(dir, NULL);
}
else {
previews= NULL;
nprevs= 0;
names= BLO_blendhandle_get_linkable_groups(filelist->libfiledata);
nnames= BLI_linklist_length(names);
}
filelist->numfiles= nnames + 1;
filelist->filelist= malloc(filelist->numfiles * sizeof(*filelist->filelist));
memset(filelist->filelist, 0, filelist->numfiles * sizeof(*filelist->filelist));
filelist->filelist[0].relname= BLI_strdup("..");
filelist->filelist[0].type |= S_IFDIR;
for (i=0, l= names; i<nnames; i++, l= l->next) {
char *blockname= l->link;
filelist->filelist[i + 1].relname= BLI_strdup(blockname);
if (idcode) {
filelist->filelist[i + 1].type |= S_IFREG;
}
else {
filelist->filelist[i + 1].type |= S_IFDIR;
}
}
if (previews && (nnames != nprevs)) {
printf("filelist_from_library: error, found %d items, %d previews\n", nnames, nprevs);
}
else if (previews) {
for (i=0, l= previews; i<nnames; i++, l= l->next) {
PreviewImage *img= l->link;
if (img) {
unsigned int w = img->w[ICON_SIZE_PREVIEW];
unsigned int h = img->h[ICON_SIZE_PREVIEW];
unsigned int *rect = img->rect[ICON_SIZE_PREVIEW];
/* first allocate imbuf for copying preview into it */
if (w > 0 && h > 0 && rect) {
ima = IMB_allocImBuf(w, h, 32, IB_rect);
memcpy(ima->rect, rect, w*h*sizeof(unsigned int));
filelist->filelist[i + 1].image = ima;
filelist->filelist[i + 1].flags = IMAGEFILE;
}
}
}
}
BLI_linklist_free(names, free);
if (previews) BLI_linklist_free(previews, BKE_previewimg_freefunc);
filelist_sort(filelist, FILE_SORT_ALPHA);
BLI_strncpy(G.main->name, filename, sizeof(filename)); // prevent G.main->name to change
filelist->filter = 0;
filelist_filter(filelist);
}
void pan_calendar_compute(PanWindow *pw, const gchar *path, gint *width, gint *height)
{
GList *list;
GList *work;
gint x, y;
time_t tc;
gint count;
gint day_max;
gint day_width;
gint day_height;
gint grid;
gint year = 0;
gint month = 0;
gint end_year = 0;
gint end_month = 0;
list = pan_list_tree(path, SORT_NONE, TRUE, pw->ignore_symlinks);
if (pw->cache_list && pw->exif_date_enable)
{
pw->cache_list = filelist_sort(pw->cache_list, SORT_NAME, TRUE);
list = filelist_sort(list, SORT_NAME, TRUE);
pan_cache_sync_date(pw, list);
}
pw->cache_list = filelist_sort(pw->cache_list, SORT_TIME, TRUE);
list = filelist_sort(list, SORT_TIME, TRUE);
day_max = 0;
count = 0;
tc = 0;
work = list;
while (work)
{
FileData *fd;
fd = work->data;
work = work->next;
if (!pan_date_compare(fd->date, tc, PAN_DATE_LENGTH_DAY))
{
count = 0;
tc = fd->date;
}
else
{
count++;
if (day_max < count) day_max = count;
}
}
if (debug) printf("biggest day contains %d images\n", day_max);
grid = (gint)(sqrt((double)day_max) + 0.5) * (PAN_THUMB_SIZE + PAN_SHADOW_OFFSET * 2 + PAN_THUMB_GAP);
day_width = MAX(PAN_CAL_DAY_WIDTH, grid);
day_height = MAX(PAN_CAL_DAY_HEIGHT, grid);
if (list)
{
FileData *fd = list->data;
year = pan_date_value(fd->date, PAN_DATE_LENGTH_YEAR);
month = pan_date_value(fd->date, PAN_DATE_LENGTH_MONTH);
}
work = g_list_last(list);
if (work)
{
FileData *fd = work->data;
end_year = pan_date_value(fd->date, PAN_DATE_LENGTH_YEAR);
end_month = pan_date_value(fd->date, PAN_DATE_LENGTH_MONTH);
}
*width = PAN_BOX_BORDER * 2;
*height = PAN_BOX_BORDER * 2;
x = PAN_BOX_BORDER;
y = PAN_BOX_BORDER;
work = list;
while (work && (year < end_year || (year == end_year && month <= end_month)))
{
PanItem *pi_month;
PanItem *pi_text;
gint day;
gint days;
gint col;
gint row;
time_t dt;
gchar *buf;
/* figure last second of this month */
dt = pan_date_to_time((month == 12) ? year + 1 : year, (month == 12) ? 1 : month + 1, 1);
dt -= 60 * 60 * 24;
/* anything to show this month? */
if (!pan_date_compare(((FileData *)(work->data))->date, dt, PAN_DATE_LENGTH_MONTH))
{
month ++;
if (month > 12)
{
year++;
month = 1;
}
continue;
}
days = pan_date_value(dt, PAN_DATE_LENGTH_DAY);
dt = pan_date_to_time(year, month, 1);
col = pan_date_value(dt, PAN_DATE_LENGTH_WEEK);
row = 1;
x = PAN_BOX_BORDER;
pi_month = pan_item_box_new(pw, NULL, x, y, PAN_CAL_DAY_WIDTH * 7, PAN_CAL_DAY_HEIGHT / 4,
PAN_CAL_MONTH_BORDER,
PAN_CAL_MONTH_COLOR, PAN_CAL_MONTH_ALPHA,
PAN_CAL_MONTH_BORDER_COLOR, PAN_CAL_MONTH_ALPHA);
buf = pan_date_value_string(dt, PAN_DATE_LENGTH_MONTH);
pi_text = pan_item_text_new(pw, x, y, buf,
PAN_TEXT_ATTR_BOLD | PAN_TEXT_ATTR_HEADING,
PAN_TEXT_BORDER_SIZE,
PAN_CAL_MONTH_TEXT_COLOR, 255);
g_free(buf);
pi_text->x = pi_month->x + (pi_month->width - pi_text->width) / 2;
pi_month->height = pi_text->y + pi_text->height - pi_month->y;
x = PAN_BOX_BORDER + col * PAN_CAL_DAY_WIDTH;
y = pi_month->y + pi_month->height + PAN_BOX_BORDER;
for (day = 1; day <= days; day++)
{
FileData *fd;
PanItem *pi_day;
gint dx, dy;
gint n = 0;
dt = pan_date_to_time(year, month, day);
fd = g_new0(FileData, 1);
/* path and name must be non NULL, so make them an invalid filename */
fd->path = g_strdup("//");
fd->name = path;
fd->date = dt;
pi_day = pan_item_box_new(pw, fd, x, y, PAN_CAL_DAY_WIDTH, PAN_CAL_DAY_HEIGHT,
PAN_CAL_DAY_BORDER,
PAN_CAL_DAY_COLOR, PAN_CAL_DAY_ALPHA,
PAN_CAL_DAY_BORDER_COLOR, PAN_CAL_DAY_ALPHA);
pan_item_set_key(pi_day, "day");
dx = x + PAN_CAL_DOT_GAP * 2;
dy = y + PAN_CAL_DOT_GAP * 2;
fd = (work) ? work->data : NULL;
while (fd && pan_date_compare(fd->date, dt, PAN_DATE_LENGTH_DAY))
{
PanItem *pi;
pi = pan_item_box_new(pw, fd, dx, dy, PAN_CAL_DOT_SIZE, PAN_CAL_DOT_SIZE,
0,
PAN_CAL_DOT_COLOR, PAN_CAL_DOT_ALPHA,
0, 0, 0, 0);
pan_item_set_key(pi, "dot");
dx += PAN_CAL_DOT_SIZE + PAN_CAL_DOT_GAP;
if (dx + PAN_CAL_DOT_SIZE > pi_day->x + pi_day->width - PAN_CAL_DOT_GAP * 2)
{
dx = x + PAN_CAL_DOT_GAP * 2;
dy += PAN_CAL_DOT_SIZE + PAN_CAL_DOT_GAP;
}
if (dy + PAN_CAL_DOT_SIZE > pi_day->y + pi_day->height - PAN_CAL_DOT_GAP * 2)
{
/* must keep all dots within respective day even if it gets ugly */
dy = y + PAN_CAL_DOT_GAP * 2;
}
n++;
work = work->next;
fd = (work) ? work->data : NULL;
}
if (n > 0)
{
PanItem *pi;
pi_day->color_r = MAX(pi_day->color_r - 61 - n * 3, 80);
pi_day->color_g = pi_day->color_r;
buf = g_strdup_printf("( %d )", n);
pi = pan_item_text_new(pw, x, y, buf, PAN_TEXT_ATTR_NONE,
PAN_TEXT_BORDER_SIZE,
PAN_CAL_DAY_TEXT_COLOR, 255);
g_free(buf);
pi->x = pi_day->x + (pi_day->width - pi->width) / 2;
pi->y = pi_day->y + (pi_day->height - pi->height) / 2;
}
buf = g_strdup_printf("%d", day);
pan_item_text_new(pw, x + 4, y + 4, buf, PAN_TEXT_ATTR_BOLD | PAN_TEXT_ATTR_HEADING,
PAN_TEXT_BORDER_SIZE,
PAN_CAL_DAY_TEXT_COLOR, 255);
g_free(buf);
pan_item_size_coordinates(pi_day, PAN_BOX_BORDER, width, height);
col++;
if (col > 6)
{
col = 0;
row++;
x = PAN_BOX_BORDER;
y += PAN_CAL_DAY_HEIGHT;
}
else
{
x += PAN_CAL_DAY_WIDTH;
}
}
if (col > 0) y += PAN_CAL_DAY_HEIGHT;
y += PAN_BOX_BORDER * 2;
month ++;
if (month > 12)
{
year++;
month = 1;
}
}
*width += grid;
*height = MAX(*height, grid + PAN_BOX_BORDER * 2 * 2);
g_list_free(list);
}
static gboolean vdlist_populate(ViewDir *vd, gboolean clear)
{
GtkListStore *store;
GList *work;
GtkTreeIter iter;
gboolean valid;
gchar *filepath;
GList *old_list;
gboolean ret;
FileData *fd;
SortType sort_type = SORT_NAME;
gboolean sort_ascend = TRUE;
old_list = VDLIST(vd)->list;
ret = filelist_read(vd->dir_fd, NULL, &VDLIST(vd)->list);
VDLIST(vd)->list = filelist_sort(VDLIST(vd)->list, sort_type, sort_ascend);
/* add . and .. */
if (options->file_filter.show_parent_directory && strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) != 0)
{
filepath = g_build_filename(vd->dir_fd->path, "..", NULL);
fd = file_data_new_dir(filepath);
VDLIST(vd)->list = g_list_prepend(VDLIST(vd)->list, fd);
g_free(filepath);
}
if (options->file_filter.show_dot_directory)
{
filepath = g_build_filename(vd->dir_fd->path, ".", NULL);
fd = file_data_new_dir(filepath);
VDLIST(vd)->list = g_list_prepend(VDLIST(vd)->list, fd);
g_free(filepath);
}
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
if (clear) gtk_list_store_clear(store);
valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &iter, NULL);
work = VDLIST(vd)->list;
while (work)
{
gint match;
GdkPixbuf *pixbuf;
const gchar *date = "";
gboolean done = FALSE;
fd = work->data;
if (access_file(fd->path, R_OK | X_OK) && fd->name)
{
if (fd->name[0] == '.' && fd->name[1] == '\0')
{
pixbuf = vd->pf->open;
}
else if (fd->name[0] == '.' && fd->name[1] == '.' && fd->name[2] == '\0')
{
pixbuf = vd->pf->parent;
}
else
{
pixbuf = vd->pf->close;
if (vd->layout && vd->layout->options.show_directory_date)
date = text_from_time(fd->date);
}
}
else
{
pixbuf = vd->pf->deny;
}
while (!done)
{
FileData *old_fd = NULL;
if (valid)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
DIR_COLUMN_POINTER, &old_fd,
-1);
if (fd == old_fd)
{
match = 0;
}
else
{
match = filelist_sort_compare_filedata_full(fd, old_fd, sort_type, sort_ascend);
if (match == 0) g_warning("multiple fd for the same path");
}
}
else
{
match = -1;
}
if (match < 0)
{
GtkTreeIter new;
if (valid)
{
gtk_list_store_insert_before(store, &new, &iter);
}
else
{
gtk_list_store_append(store, &new);
}
gtk_list_store_set(store, &new,
DIR_COLUMN_POINTER, fd,
DIR_COLUMN_ICON, pixbuf,
DIR_COLUMN_NAME, fd->name,
DIR_COLUMN_DATE, date,
-1);
done = TRUE;
}
else if (match > 0)
void pan_timeline_compute(PanWindow *pw, const gchar *path, gint *width, gint *height)
{
GList *list;
GList *work;
gint x, y;
time_t tc;
gint total;
gint count;
PanItem *pi_month = NULL;
PanItem *pi_day = NULL;
gint month_start;
gint day_start;
gint x_width;
gint y_height;
list = pan_list_tree(path, SORT_NONE, TRUE, pw->ignore_symlinks);
if (pw->cache_list && pw->exif_date_enable)
{
pw->cache_list = filelist_sort(pw->cache_list, SORT_NAME, TRUE);
list = filelist_sort(list, SORT_NAME, TRUE);
pan_cache_sync_date(pw, list);
}
pw->cache_list = filelist_sort(pw->cache_list, SORT_TIME, TRUE);
list = filelist_sort(list, SORT_TIME, TRUE);
*width = PAN_BOX_BORDER * 2;
*height = PAN_BOX_BORDER * 2;
x = 0;
y = 0;
month_start = y;
day_start = month_start;
x_width = 0;
y_height = 0;
tc = 0;
total = 0;
count = 0;
work = list;
while (work)
{
FileData *fd;
PanItem *pi;
fd = work->data;
work = work->next;
if (!pan_date_compare(fd->date, tc, PAN_DATE_LENGTH_DAY))
{
GList *needle;
gchar *buf;
if (!pan_date_compare(fd->date, tc, PAN_DATE_LENGTH_MONTH))
{
pi_day = NULL;
if (pi_month)
{
x = pi_month->x + pi_month->width + PAN_BOX_BORDER;
}
else
{
x = PAN_BOX_BORDER;
}
y = PAN_BOX_BORDER;
buf = pan_date_value_string(fd->date, PAN_DATE_LENGTH_MONTH);
pi = pan_item_text_new(pw, x, y, buf,
PAN_TEXT_ATTR_BOLD | PAN_TEXT_ATTR_HEADING,
PAN_TEXT_BORDER_SIZE,
PAN_TEXT_COLOR, 255);
g_free(buf);
y += pi->height;
pi_month = pan_item_box_new(pw, file_data_new_simple(fd->path),
x, y, 0, 0,
PAN_BOX_OUTLINE_THICKNESS,
PAN_BOX_COLOR, PAN_BOX_ALPHA,
PAN_BOX_OUTLINE_COLOR, PAN_BOX_OUTLINE_ALPHA);
x += PAN_BOX_BORDER;
y += PAN_BOX_BORDER;
month_start = y;
}
if (pi_day) x = pi_day->x + pi_day->width + PAN_BOX_BORDER;
tc = fd->date;
total = 1;
count = 0;
needle = work;
while (needle)
{
FileData *nfd;
nfd = needle->data;
if (pan_date_compare(nfd->date, tc, PAN_DATE_LENGTH_DAY))
{
needle = needle->next;
total++;
}
else
{
needle = NULL;
}
}
buf = pan_date_value_string(fd->date, PAN_DATE_LENGTH_WEEK);
pi = pan_item_text_new(pw, x, y, buf, PAN_TEXT_ATTR_NONE,
PAN_TEXT_BORDER_SIZE,
PAN_TEXT_COLOR, 255);
g_free(buf);
y += pi->height;
pi_day = pan_item_box_new(pw, file_data_new_simple(fd->path), x, y, 0, 0,
PAN_BOX_OUTLINE_THICKNESS,
PAN_BOX_COLOR, PAN_BOX_ALPHA,
PAN_BOX_OUTLINE_COLOR, PAN_BOX_OUTLINE_ALPHA);
x += PAN_BOX_BORDER;
y += PAN_BOX_BORDER;
day_start = y;
}
if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE)
{
pi = pan_item_image_new(pw, fd, x, y, 10, 10);
if (pi->width > x_width) x_width = pi->width;
y_height = pi->height;
}
else
{
pi = pan_item_thumb_new(pw, fd, x, y);
x_width = PAN_THUMB_SIZE;
y_height = PAN_THUMB_SIZE;
}
pan_item_size_by_item(pi_day, pi, PAN_BOX_BORDER);
pan_item_size_by_item(pi_month, pi_day, PAN_BOX_BORDER);
total--;
count++;
if (total > 0 && count < PAN_GROUP_MAX)
{
y += y_height + PAN_THUMB_GAP;
}
else
{
x += x_width + PAN_THUMB_GAP;
x_width = 0;
count = 0;
if (total > 0)
y = day_start;
else
y = month_start;
}
pan_item_size_coordinates(pi_month, PAN_BOX_BORDER, width, height);
}
g_list_free(list);
}
