CacheLoader *cache_loader_new(FileData *fd, CacheDataType load_mask,
CacheLoaderDoneFunc done_func, gpointer done_data)
{
CacheLoader *cl;
gchar *found;
if (!fd || !isfile(fd->path)) return NULL;
cl = g_new0(CacheLoader, 1);
cl->fd = file_data_ref(fd);
cl->done_func = done_func;
cl->done_data = done_data;
found = cache_find_location(CACHE_TYPE_SIM, cl->fd->path);
if (found && filetime(found) == filetime(cl->fd->path))
{
cl->cd = cache_sim_data_load(found);
}
g_free(found);
if (!cl->cd) cl->cd = cache_sim_data_new();
cl->todo_mask = load_mask;
cl->done_mask = CACHE_LOADER_NONE;
cl->il = NULL;
cl->idle_id = g_idle_add(cache_loader_idle_cb, cl);
cl->error = FALSE;
return cl;
}
gboolean metadata_write_queue_confirm(gboolean force_dialog, FileUtilDoneFunc done_func, gpointer done_data)
{
GList *work;
GList *to_approve = NULL;
work = metadata_write_queue;
while (work)
{
FileData *fd = work->data;
work = work->next;
if (!isname(fd->path))
{
/* ignore deleted files */
metadata_write_queue_remove(fd);
continue;
}
if (fd->change) continue; /* another operation in progress, skip this file for now */
to_approve = g_list_prepend(to_approve, file_data_ref(fd));
}
file_util_write_metadata(NULL, to_approve, NULL, force_dialog, done_func, done_data);
return (metadata_write_queue != NULL);
}
static void view_dir_list_do(ViewWindow *vw, GList *list, gboolean skip, gboolean recurse)
{
GList *work;
view_window_set_list(vw, NULL);
work = list;
while (work)
{
FileData *fd = work->data;
work = work->next;
if (isdir(fd->path))
{
if (!skip)
{
GList *list = NULL;
if (recurse)
{
list = filelist_recursive(fd);
}
else
{ /*FIXME */
filelist_read(fd, &list, NULL);
list = filelist_sort_path(list);
list = filelist_filter(list, FALSE);
}
if (list) vw->list = g_list_concat(vw->list, list);
}
}
else
{
/* FIXME: no filtering here */
vw->list = g_list_append(vw->list, file_data_ref(fd));
}
}
if (vw->list)
{
FileData *fd;
vw->list_pointer = vw->list;
fd = vw->list->data;
image_change_fd(vw->imd, fd, image_zoom_get_default(vw->imd));
work = vw->list->next;
if (options->image.enable_read_ahead && work)
{
fd = work->data;
image_prebuffer_set(vw->imd, fd);
}
}
else
{
image_change_fd(vw->imd, NULL, image_zoom_get_default(vw->imd));
}
}
static void bar_pane_gps_set_fd(GtkWidget *bar, FileData *fd)
{
PaneGPSData *pgd;
pgd = g_object_get_data(G_OBJECT(bar), "pane_data");
if (!pgd) return;
file_data_unref(pgd->fd);
pgd->fd = file_data_ref(fd);
bar_pane_gps_update(pgd);
}
void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
{
PaneExifData *ped;
ped = g_object_get_data(G_OBJECT(widget), "pane_data");
if (!ped) return;
file_data_unref(ped->fd);
ped->fd = file_data_ref(fd);
bar_pane_exif_update(ped);
}
void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
{
PaneKeywordsData *pkd;
pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
if (!pkd) return;
file_data_unref(pkd->fd);
pkd->fd = file_data_ref(fd);
bar_pane_keywords_update(pkd);
}
static void bar_pane_comment_set_fd(GtkWidget *bar, FileData *fd)
{
PaneCommentData *pcd;
pcd = g_object_get_data(G_OBJECT(bar), "pane_data");
if (!pcd) return;
file_data_unref(pcd->fd);
pcd->fd = file_data_ref(fd);
bar_pane_comment_update(pcd);
}
static GList *view_window_get_fd_list(ViewWindow *vw)
{
GList *list = NULL;
ImageWindow *imd = view_window_active_image(vw);
if (imd)
{
FileData *fd = image_get_fd(imd);
if (fd) list = g_list_append(NULL, file_data_ref(fd));
}
return list;
}
void bar_set_fd(GtkWidget *bar, FileData *fd)
{
BarData *bd;
bd = g_object_get_data(G_OBJECT(bar), "bar_data");
if (!bd) return;
file_data_unref(bd->fd);
bd->fd = file_data_ref(fd);
gtk_container_foreach(GTK_CONTAINER(bd->vbox), bar_pane_set_fd_cb, fd);
gtk_label_set_text(GTK_LABEL(bd->label_file_name), (bd->fd) ? bd->fd->name : "");
}
CollectInfo *collection_info_new(FileData *fd, struct stat *st, GdkPixbuf *pixbuf)
{
CollectInfo *ci;
if (!fd) return NULL;
ci = g_new0(CollectInfo, 1);
ci->fd = file_data_ref(fd);
ci->pixbuf = pixbuf;
if (ci->pixbuf) g_object_ref(ci->pixbuf);
return ci;
}
GList *collection_list_to_filelist(GList *list)
{
GList *filelist = NULL;
GList *work = list;
while (work)
{
CollectInfo *info = work->data;
filelist = g_list_prepend(filelist, file_data_ref(info->fd));
work = work->next;
}
filelist = g_list_reverse(filelist);
return filelist;
}
gboolean vdtree_set_fd(ViewDir *vd, FileData *dir_fd)
{
FileData *fd;
GtkTreeIter iter;
if (!dir_fd) return FALSE;
if (vd->dir_fd == dir_fd) return TRUE;
file_data_unref(vd->dir_fd);
vd->dir_fd = file_data_ref(dir_fd);;
fd = vdtree_populate_path(vd, vd->dir_fd, TRUE, FALSE);
if (!fd) return FALSE;
if (vd_find_row(vd, fd, &iter))
{
GtkTreeModel *store;
GtkTreePath *tpath, *old_tpath;
GtkTreeSelection *selection;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
/* hack, such that selection is only allowed to be changed from here */
selection_is_ok = TRUE;
gtk_tree_selection_select_iter(selection, &iter);
selection_is_ok = FALSE;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
tpath = gtk_tree_model_get_path(store, &iter);
if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
{
/* setting the cursor scrolls the view; do not do that unless it is necessary */
gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
/* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
does not work (switch from dir_list to dir_tree) */
tree_view_row_make_visible(GTK_TREE_VIEW(vd->view), &iter, TRUE);
}
gtk_tree_path_free(tpath);
gtk_tree_path_free(old_tpath);
}
return TRUE;
}
GList*
file_data_list_dup (GList *list)
{
GList *new_list = NULL, *scan;
if (list == NULL)
return NULL;
for (scan = list; scan; scan = scan->next) {
FileData *data = scan->data;
file_data_ref (data);
new_list = g_list_prepend (new_list, data);
}
return g_list_reverse (new_list);
}
CollectionData *collection_from_dnd_data(const gchar *data, GList **list, GList **info_list)
{
CollectionData *cd;
gint collection_number;
const gchar *ptr;
if (list) *list = NULL;
if (info_list) *info_list = NULL;
if (strncmp(data, "COLLECTION:", 11) != 0) return NULL;
ptr = data + 11;
collection_number = atoi(ptr);
cd = collection_from_number(collection_number);
if (!cd) return NULL;
if (!list && !info_list) return cd;
while (*ptr != '\0' && *ptr != '\n' ) ptr++;
if (*ptr == '\0') return cd;
ptr++;
while (*ptr != '\0')
{
guint item_number;
CollectInfo *info;
item_number = (guint) atoi(ptr);
while (*ptr != '\n' && *ptr != '\0') ptr++;
if (*ptr == '\0')
break;
else
while (*ptr == '\n') ptr++;
info = g_list_nth_data(cd->list, item_number);
if (!info) continue;
if (list) *list = g_list_append(*list, file_data_ref(info->fd));
if (info_list) *info_list = g_list_append(*info_list, info);
}
return cd;
}
static void metadata_write_queue_add(FileData *fd)
{
if (!g_list_find(metadata_write_queue, fd))
{
metadata_write_queue = g_list_prepend(metadata_write_queue, fd);
file_data_ref(fd);
layout_util_status_update_write_all();
}
if (metadata_write_idle_id)
{
g_source_remove(metadata_write_idle_id);
metadata_write_idle_id = 0;
}
if (options->metadata.confirm_after_timeout)
{
metadata_write_idle_id = g_timeout_add(options->metadata.confirm_timeout * 1000, metadata_write_queue_idle_cb, NULL);
}
}
void pan_calendar_update(PanWindow *pw, PanItem *pi_day)
{
PanItem *pbox;
PanItem *pi;
GList *list;
GList *work;
gint x1, y1, x2, y2, x3, y3;
gint x, y, w, h;
gint grid;
gint column;
while ((pi = pan_item_find_by_key(pw, PAN_ITEM_NONE, "day_bubble"))) pan_item_remove(pw, pi);
if (!pi_day || pi_day->type != PAN_ITEM_BOX ||
!pi_day->key || strcmp(pi_day->key, "day") != 0) return;
list = pan_layout_intersect(pw, pi_day->x, pi_day->y, pi_day->width, pi_day->height);
work = list;
while (work)
{
PanItem *dot;
GList *node;
dot = work->data;
node = work;
work = work->next;
if (dot->type != PAN_ITEM_BOX || !dot->fd ||
!dot->key || strcmp(dot->key, "dot") != 0)
{
list = g_list_delete_link(list, node);
}
}
#if 0
if (!list) return;
#endif
grid = (gint)(sqrt(g_list_length(list)) + 0.5);
x = pi_day->x + pi_day->width + 4;
y = pi_day->y;
#if 0
if (y + grid * (PAN_THUMB_SIZE + PAN_THUMB_GAP) + PAN_BOX_BORDER * 4 > pw->pr->image_height)
{
y = pw->pr->image_height - (grid * (PAN_THUMB_SIZE + PAN_THUMB_GAP) + PAN_BOX_BORDER * 4);
}
#endif
pbox = pan_item_box_new(pw, NULL, x, y, PAN_BOX_BORDER, PAN_BOX_BORDER,
PAN_CAL_POPUP_BORDER,
PAN_CAL_POPUP_COLOR, PAN_CAL_POPUP_ALPHA,
PAN_CAL_POPUP_BORDER_COLOR, PAN_CAL_POPUP_ALPHA);
pan_item_set_key(pbox, "day_bubble");
if (pi_day->fd)
{
PanItem *plabel;
gchar *buf;
buf = pan_date_value_string(pi_day->fd->date, PAN_DATE_LENGTH_WEEK);
plabel = pan_item_text_new(pw, x, y, buf, PAN_TEXT_ATTR_BOLD | PAN_TEXT_ATTR_HEADING,
PAN_TEXT_BORDER_SIZE,
PAN_CAL_POPUP_TEXT_COLOR, 255);
pan_item_set_key(plabel, "day_bubble");
g_free(buf);
pan_item_size_by_item(pbox, plabel, 0);
y += plabel->height;
}
if (list)
{
column = 0;
x += PAN_BOX_BORDER;
y += PAN_BOX_BORDER;
work = list;
while (work)
{
PanItem *dot;
dot = work->data;
work = work->next;
if (dot->fd)
{
PanItem *pimg;
pimg = pan_item_thumb_new(pw, file_data_ref(dot->fd), x, y);
pan_item_set_key(pimg, "day_bubble");
pan_item_size_by_item(pbox, pimg, PAN_BOX_BORDER);
column++;
if (column < grid)
{
x += PAN_THUMB_SIZE + PAN_THUMB_GAP;
}
else
{
column = 0;
x = pbox->x + PAN_BOX_BORDER;
y += PAN_THUMB_SIZE + PAN_THUMB_GAP;
}
}
}
}
x1 = pi_day->x + pi_day->width - 8;
y1 = pi_day->y + 8;
x2 = pbox->x + 1;
y2 = pbox->y + MIN(42, pbox->height);
x3 = pbox->x + 1;
y3 = MAX(pbox->y, y2 - 30);
util_clip_triangle(x1, y1, x2, y2, x3, y3,
&x, &y, &w, &h);
pi = pan_item_tri_new(pw, NULL, x, y, w, h,
x1, y1, x2, y2, x3, y3,
PAN_CAL_POPUP_COLOR, PAN_CAL_POPUP_ALPHA);
pan_item_tri_border(pi, PAN_BORDER_1 | PAN_BORDER_3, PAN_CAL_POPUP_BORDER_COLOR, PAN_CAL_POPUP_ALPHA);
pan_item_set_key(pi, "day_bubble");
pan_item_added(pw, pi);
pan_item_box_shadow(pbox, PAN_SHADOW_OFFSET * 2, PAN_SHADOW_FADE * 2);
pan_item_added(pw, pbox);
pan_layout_resize(pw);
}
static void
gth_file_list_update_next_thumb (GthFileList *file_list)
{
FileData *fd = NULL;
int first_pos, last_pos;
int pos = -1;
GList *list, *scan;
int new_pos = -1;
if (file_list->priv->stop_it || (file_list->priv->queue != NULL)) {
g_idle_add (update_thumbs_stopped, file_list);
return;
}
/* Find first visible undone. */
first_pos = gth_file_view_get_first_visible (file_list->view);
last_pos = gth_file_view_get_last_visible (file_list->view);
pos = first_pos;
if ((pos == -1) || (last_pos < first_pos)) {
gth_file_list_done (file_list);
return;
}
list = gth_file_view_get_list (file_list->view);
scan = g_list_nth (list, pos);
if (scan == NULL) {
file_data_list_free (list);
gth_file_list_done (file_list);
return;
}
/* Find a not loaded thumbnail among the visible images. */
while (pos <= last_pos) {
fd = scan->data;
if (! fd->thumb_loaded && ! fd->error) {
new_pos = pos;
break;
}
else {
pos++;
scan = scan->next;
}
}
if (! file_list->priv->ignore_hidden_thumbs) {
/* Find a not created thumbnail among the not-visible images. */
/* start from the one after the last visible image... */
if (new_pos == -1) {
pos = last_pos + 1;
scan = g_list_nth (list, pos);
while (scan) {
fd = scan->data;
if (! fd->thumb_created && ! fd->error) {
new_pos = pos;
break;
}
pos++;
scan = scan->next;
}
}
/* ...continue from the one before the first visible upward to
* the first one */
if (new_pos == -1) {
pos = first_pos - 1;
scan = g_list_nth (list, pos);
while (scan) {
fd = scan->data;
if (! fd->thumb_created && ! fd->error) {
new_pos = pos;
break;
}
pos--;
scan = scan->prev;
}
}
}
if (new_pos != -1)
fd = file_data_ref (fd);
file_data_list_free (list);
if (new_pos == -1) {
gth_file_list_done (file_list);
return;
}
/* We create thumbnail files for all images in the folder, but we only
load the visible ones (and 25 before and 25 after the visible range),
to minimize memory consumption in large folders. */
file_list->priv->update_thumb_in_image_list = (new_pos >= (first_pos - 25)) &&
(new_pos <= (last_pos + 25));
file_list->priv->thumb_pos = new_pos;
file_list->priv->thumbs_num++;
file_data_unref (file_list->priv->thumb_fd);
file_list->priv->thumb_fd = fd; /* already ref-ed above */
gth_file_list_update_current_thumb (file_list);
}
static gboolean view_window_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
ViewWindow *vw = data;
ImageWindow *imd;
gint stop_signal;
GtkWidget *menu;
gint x = 0;
gint y = 0;
imd = view_window_active_image(vw);
stop_signal = TRUE;
switch (event->keyval)
{
case GDK_KEY_Left: case GDK_KEY_KP_Left:
x -= 1;
break;
case GDK_KEY_Right: case GDK_KEY_KP_Right:
x += 1;
break;
case GDK_KEY_Up: case GDK_KEY_KP_Up:
y -= 1;
break;
case GDK_KEY_Down: case GDK_KEY_KP_Down:
y += 1;
break;
default:
stop_signal = FALSE;
break;
}
if (x != 0 || y!= 0)
{
if (event->state & GDK_SHIFT_MASK)
{
x *= 3;
y *= 3;
}
keyboard_scroll_calc(&x, &y, event);
image_scroll(imd, x, y);
}
if (stop_signal) return stop_signal;
if (event->state & GDK_CONTROL_MASK)
{
stop_signal = TRUE;
switch (event->keyval)
{
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '0':
break;
case 'C': case 'c':
file_util_copy(image_get_fd(imd), NULL, NULL, imd->widget);
break;
case 'M': case 'm':
file_util_move(image_get_fd(imd), NULL, NULL, imd->widget);
break;
case 'R': case 'r':
file_util_rename(image_get_fd(imd), NULL, imd->widget);
break;
case 'D': case 'd':
file_util_delete(image_get_fd(imd), NULL, imd->widget);
break;
case 'W': case 'w':
view_window_close(vw);
break;
default:
stop_signal = FALSE;
break;
}
}
else if (event->state & GDK_SHIFT_MASK)
{
stop_signal = TRUE;
switch (event->keyval)
{
case 'R': case 'r':
image_alter_orientation(imd, ALTER_ROTATE_180);
break;
case 'M': case 'm':
image_alter_orientation(imd, ALTER_MIRROR);
break;
case 'F': case 'f':
image_alter_orientation(imd, ALTER_FLIP);
break;
case 'G': case 'g':
image_set_desaturate(imd, !image_get_desaturate(imd));
break;
case 'P': case 'p':
{
FileData *fd;
view_fullscreen_toggle(vw, TRUE);
imd = view_window_active_image(vw);
fd = image_get_fd(imd);
print_window_new(fd,
fd ? g_list_append(NULL, file_data_ref(fd)) : NULL,
filelist_copy(vw->list), vw->window);
}
break;
default:
stop_signal = FALSE;
break;
}
}
else
{
stop_signal = TRUE;
switch (event->keyval)
{
case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up:
case GDK_KEY_BackSpace:
case 'B': case 'b':
view_step_prev(vw);
break;
case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down:
case GDK_KEY_space:
case 'N': case 'n':
view_step_next(vw);
break;
case GDK_KEY_Home: case GDK_KEY_KP_Home:
view_step_to_end(vw, FALSE);
break;
case GDK_KEY_End: case GDK_KEY_KP_End:
view_step_to_end(vw, TRUE);
break;
case '+': case '=': case GDK_KEY_KP_Add:
image_zoom_adjust(imd, get_zoom_increment());
break;
case '-': case GDK_KEY_KP_Subtract:
image_zoom_adjust(imd, -get_zoom_increment());
break;
case 'X': case 'x': case GDK_KEY_KP_Multiply:
image_zoom_set(imd, 0.0);
break;
case 'Z': case 'z': case GDK_KEY_KP_Divide: case '1':
image_zoom_set(imd, 1.0);
break;
case '2':
image_zoom_set(imd, 2.0);
break;
case '3':
image_zoom_set(imd, 3.0);
break;
case '4':
image_zoom_set(imd, 4.0);
break;
case '7':
image_zoom_set(imd, -4.0);
break;
case '8':
image_zoom_set(imd, -3.0);
break;
case '9':
image_zoom_set(imd, -2.0);
break;
case 'W': case 'w':
image_zoom_set_fill_geometry(imd, FALSE);
break;
case 'H': case 'h':
image_zoom_set_fill_geometry(imd, TRUE);
break;
case 'R': case 'r':
image_reload(imd);
break;
case 'S': case 's':
if (vw->ss)
{
view_slideshow_stop(vw);
}
else
{
view_slideshow_start(vw);
}
break;
case 'P': case 'p':
slideshow_pause_toggle(vw->ss);
break;
case 'F': case 'f':
case 'V': case 'v':
case GDK_KEY_F11:
view_fullscreen_toggle(vw, FALSE);
break;
case 'I': case 'i':
view_overlay_toggle(vw);
break;
case ']':
image_alter_orientation(imd, ALTER_ROTATE_90);
break;
case '[':
image_alter_orientation(imd, ALTER_ROTATE_90_CC);
break;
case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
if (options->file_ops.enable_delete_key)
{
file_util_delete(image_get_fd(imd), NULL, imd->widget);
}
break;
case GDK_KEY_Escape:
if (vw->fs)
{
view_fullscreen_toggle(vw, TRUE);
}
else
{
view_window_close(vw);
}
break;
case GDK_KEY_Menu:
case GDK_KEY_F10:
menu = view_popup_menu(vw);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
view_window_menu_pos_cb, vw, 0, GDK_CURRENT_TIME);
break;
default:
stop_signal = FALSE;
break;
}
}
return stop_signal;
}
