/*
- * This file was generated from ClayRGB1998.icc, DO NOT EDIT
- * http://www.argyllcms.com/ClayRGB1998.zip
- */
+ * This file was generated from ClayRGB1998.icc, DO NOT EDIT
+ * http://www.argyllcms.com/ClayRGB1998.zip
+ */
unsigned char ClayRGB1998_icc[] = {
0x00, 0x00, 0x02, 0x44, 0x61, 0x72, 0x67, 0x6c, 0x02, 0x20, 0x00, 0x00,
0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
*/
static void table_add_line_custom(GtkWidget *table, gint x, gint y,
- const gchar *text1, const gchar *text2,
- GtkWidget **label1, GtkWidget **label2)
+ const gchar *text1, const gchar *text2,
+ GtkWidget **label1, GtkWidget **label2)
{
GtkWidget *label;
gchar *buf;
text = bar_exif_validate_text(text);
if (ExifUIList[i].current == EXIF_UI_IFSET
&& (!text || !*text))
- {
+ {
gtk_widget_hide(eb->labels[i]);
gtk_widget_hide(eb->keys[i]);
continue;
GtkListStore *store;
GtkTreeIter iter;
ExifItem *item;
-
+
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(eb->listview)));
gtk_list_store_clear(store);
const gchar *text;
text = exif_get_description_by_key(ExifUIList[i].key);
- eb->labels[i] = table_add_line(table, 0, i, text, NULL,
+ eb->labels[i] = table_add_line(table, 0, i, text, NULL,
&eb->keys[i]);
}
ExifItem *item = exif_get_item(exif, comment_key);
*comment = exif_item_get_string(item, 0);
}
-
+
if (keywords)
{
ExifItem *item = exif_get_item(exif, keyword_key);
int i = 0;
GList *work = NULL;
char *kw = NULL;
-
+
while (i < count && (kw = exif_item_get_string(item, i++)))
{
work = g_list_append(work, (gpointer) kw);
}
-
+
*keywords = work;
}
-
+
exif_free(exif);
-
+
success = *comment || *keywords;
-
+
return success;
}
if (!exif) return FALSE;
ExifItem *item = exif_get_item(exif, comment_key);
-
- if (item && !(comment && comment[0]))
+
+ if (item && !(comment && comment[0]))
{
- exif_item_delete(exif, item);
+ exif_item_delete(exif, item);
item = NULL;
}
-
+
if (!item && comment && comment[0]) item = exif_add_item(exif, comment_key);
if (item) exif_item_set_string(item, comment);
{
exif_item_delete(exif, item);
}
-
+
if (work)
{
item = exif_add_item(exif, keyword_key);
-
+
while (work)
{
gchar *kw = (gchar *) work->data;
work = work->next;
-
+
exif_item_set_string(item, kw);
}
}
-
+
success = exif_write(exif);
-
+
exif_free(exif);
-
+
return success;
}
res1 = comment_xmp_read(fd, &keywords1, &comment1);
res2 = comment_legacy_read(fd, &keywords2, &comment2);
-
+
if (!res1 && !res2)
{
return FALSE;
}
-
+
if (keywords)
{
if (res1 && res2)
if (res1) string_list_free(keywords1);
if (res2) string_list_free(keywords2);
}
-
+
if (comment)
{
}
if (res1 && (!comment || *comment != comment1)) g_free(comment1);
if (res2 && (!comment || *comment != comment2)) g_free(comment2);
-
+
return TRUE;
}
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
-
+
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_bounds(buffer, &start, &end);
-
+
return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
}
ptr++;
l++;
}
-
+
/* trim starting and ending whitespaces */
while (l > 0 && g_ascii_isspace(*begin)) begin++, l--;
while (l > 0 && g_ascii_isspace(begin[l-1])) l--;
if (l > 0)
{
gchar *keyword = g_strndup(begin, l);
-
+
/* only add if not already in the list */
if (keyword_list_find(list, keyword) == FALSE)
list = g_list_append(list, keyword);
bar_info_selection(bd->vbox, 0);
bar_list = g_list_append(bar_list, bd);
-
+
return bd->vbox;
}
sd->mode = -1;
bar_sort_mode_sync(sd, bar_sort_mode_state);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), sd->mode);
-
+
return sd->vbox;
}
*-------------------------------------------------------------------
* Cache data file format:
*-------------------------------------------------------------------
- *
+ *
* SIMcache
* #coment
* Dimensions=[<width> x <height>]
* Checksum=[<value>]
* MD5sum=[<32 character ascii text digest>]
* SimilarityGrid[32 x 32]=<3072 bytes of data (1024 pixels in RGB format, 1 pixel is 24bits)>
- *
- *
+ *
+ *
* The first line (9 bytes) indicates it is a SIMcache format file. (new line char must exist)
* Comment lines starting with a # are ignored up to a new line.
* All data lines should end with a new line char.
just_done = TRUE;
still_have_a_file = FALSE;
-
+
work = list;
while (work)
{
gchar *path_buf = work->data;
gchar *dot;
-
+
dot = extension_find_dot(path_buf);
-
+
if (dot) *dot = '\0';
if ((!cm->metadata && cm->clear) ||
(strlen(path_buf) > base_length && !isfile(path_buf + base_length)) )
if (cm->list && g_list_find(cm->done_list, cm->list->data) != NULL)
{
/* check if the dir is empty */
-
+
if (cm->list->data == path && just_done)
{
if (!still_have_a_file && !dlist && cm->list->next && !rmdir_utf8(path))
cm->spinner = spinner_new(NULL, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), cm->spinner, FALSE, FALSE, 0);
gtk_widget_show(cm->spinner);
-
+
gtk_widget_show(cm->gd->dialog);
cm->idle_id = g_idle_add(cache_maintain_home_cb, cm);
{
gchar *buf;
gchar *d;
-
+
buf = cache_find_location(CACHE_TYPE_METADATA, src);
d = cache_get_location(CACHE_TYPE_METADATA, dest, TRUE, NULL);
cache_file_move(buf, d);
if (cache_ensure_dir_exists(dest_base, mode))
{
gchar *path;
-
+
path = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, TRUE, NULL);
if (!copy_file(src_cache, path))
{
if (!isdir(path))
{
warning_dialog(_("Invalid folder"),
- _("The specified folder can not be found."),
+ _("The specified folder can not be found."),
GTK_STOCK_DIALOG_WARNING, cd->gd->dialog);
}
else
next_path = cd->list->data;
cd->list = g_list_remove(cd->list, next_path);
-
+
cd->tl = thumb_loader_std_thumb_file_validate(next_path, cd->days,
cache_manager_standard_clean_valid_cb, cd);
g_free(next_path);
#define FIXED_ICON_SIZE_MAX 512
static void gqv_cell_renderer_icon_get_property(GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec);
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
static void gqv_cell_renderer_icon_set_property(GObject *object,
guint param_id,
const GValue *value,
};
cell_icon_type = g_type_register_static(GTK_TYPE_CELL_RENDERER,
- "GQvCellRendererIcon",
+ "GQvCellRendererIcon",
&cell_icon_info, 0);
}
GParamSpec *pspec)
{
GQvCellRendererIcon *cellicon = GQV_CELL_RENDERER_ICON (object);
-
+
switch (param_id)
{
case PROP_PIXBUF:
GParamSpec *pspec)
{
GQvCellRendererIcon *cellicon = GQV_CELL_RENDERER_ICON (object);
-
+
switch (param_id)
{
case PROP_PIXBUF:
/**
* gqv_cell_renderer_icon_new:
- *
+ *
* Creates a new #GQvCellRendererIcon. Adjust rendering
* parameters using object properties. Object properties can be set
* globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
* can bind the "pixbuf" property on the cell renderer to a pixbuf value
* in the model, thus rendering a different image in each row of the
* #GtkTreeView.
- *
+ *
* Return value: the new cell renderer
**/
GtkCellRenderer *
PangoLayout *layout;
PangoRectangle text_rect;
GdkRectangle pix_rect;
- GdkRectangle draw_rect;
+ GdkRectangle draw_rect;
layout = gqv_cell_renderer_icon_get_layout(cellicon, widget, TRUE);
pango_layout_get_pixel_extents(layout, NULL, &text_rect);
const gchar *path;
path = fd->dest_path;
-
+
if (!(strlen(path) > 7 && strncasecmp(path + (strlen(path) - 4), ".gqv", 4) == 0))
{
gchar *buf;
if (!path && !cd->path) return FALSE;
if (!path) path = cd->path;
-
+
if (debug) printf("collection load: append=%d flush=%d only_geometry=%d path=%s\n",
append, flush, only_geometry, path);
limit_failures = FALSE;
}
else if (strncmp(p, "#geometry:", 10 ) == 0 &&
- scan_geometry(p + 10, &cd->window_x, &cd->window_y, &cd->window_w, &cd->window_h))
+ scan_geometry(p + 10, &cd->window_x, &cd->window_y, &cd->window_w, &cd->window_h))
{
has_geometry_header = TRUE;
cd->window_read = TRUE;
if (buf)
{
gint valid;
-
+
if (!flush)
changed |= collect_manager_process_action(entry, &buf);
-
+
valid = (buf[0] == '/' && collection_add_check(cd, file_data_new_simple(buf), FALSE, TRUE));
if (debug && !valid) printf("collection invalid file: %s\n", buf);
g_free(buf);
}
if (debug) printf("collection files: total = %d fail = %d official=%d gqview=%d geometry=%d\n",
- total, fail, has_official_header, has_gqview_header, has_geometry_header);
+ total, fail, has_official_header, has_gqview_header, has_geometry_header);
fclose(f);
if (only_geometry) return has_geometry_header;
}
cd->list = collection_list_sort(cd->list, cd->sort_method);
-
+
if (!flush && changed && success)
collection_save_private(cd, path);
-
+
if (!flush)
collect_manager_entry_reset(entry);
-
+
if (!append) cd->changed = FALSE;
return success;
entry = work->data;
work = work->next;
- if (strcmp(entry->path, path) == 0)
+ if (strcmp(entry->path, path) == 0)
{
return entry;
}
{
CollectManagerAction *orig_action;
-
- entry->empty = FALSE;
-
+
+ entry->empty = FALSE;
+
if (action->oldpath == NULL)
{
/* add file */
{
return;
}
-
+
orig_action = g_hash_table_lookup(entry->newpath_hash, action->newpath);
if (orig_action)
{
{
/* new action with the same file */
CollectManagerAction *new_action = collect_manager_action_new(orig_action->oldpath, action->newpath, action->type);
-
+
if (new_action->oldpath)
{
g_hash_table_steal(entry->oldpath_hash, orig_action->oldpath);
GList *work = g_list_find(entry->add_list, orig_action);
work->data = new_action;
}
-
+
g_hash_table_steal(entry->newpath_hash, orig_action->newpath);
- if (new_action->newpath)
+ if (new_action->newpath)
{
- g_hash_table_insert(entry->newpath_hash, new_action->newpath, new_action);
+ g_hash_table_insert(entry->newpath_hash, new_action->newpath, new_action);
}
collect_manager_action_unref(orig_action);
return;
action->oldpath, entry->path);
return;
}
-
+
g_hash_table_insert(entry->oldpath_hash, action->oldpath, action);
if (action->newpath)
{
- g_hash_table_insert(entry->newpath_hash, action->newpath, action);
+ g_hash_table_insert(entry->newpath_hash, action->newpath, action);
}
collect_manager_action_ref(action);
}
{
gchar *path = *path_ptr;
CollectManagerAction *action;
-
+
if (path == NULL)
{
/* get new files */
*path_ptr = path;
return (path != NULL);
}
-
+
action = g_hash_table_lookup(entry->oldpath_hash, path);
-
+
if (action)
{
g_free(path);
{
info = work->data;
collection_table_select_util(ct, info, select);
-
+
if (work->data != end)
work = work->next;
else
GList *list;
if (!ct->click_info) return;
-
+
if (INFO_SELECTED(ct->click_info))
{
list = g_list_copy(ct->selection);
menu_item_add_stock(menu, _("_Find duplicates..."), GTK_STOCK_FIND,
G_CALLBACK(collection_table_popup_find_dupes_cb), ct);
menu_item_add_stock_sensitive(menu, _("Print..."), GTK_STOCK_PRINT, over_icon,
- G_CALLBACK(collection_table_popup_print_cb), ct);
+ G_CALLBACK(collection_table_popup_print_cb), ct);
return menu;
}
if (!ct->click_info) return;
selected = INFO_SELECTED(ct->click_info);
-
+
switch (info)
{
case TARGET_APP_COLLECTION_MEMBER:
collection_table_scroll(ct, FALSE);
}
-
+
static void collection_table_dnd_init(CollectTable *ct)
{
gtk_drag_source_set(ct->listview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
printf("collection_info_load_thumb not implemented!\n(because an instant thumb loader not implemented)");
return FALSE;
-#if 0
+#if 0
if (create_thumbnail(ci->fd->path, &ci->pixmap, &ci->mask) < 0) return FALSE;
if (ci->pixmap) gdk_pixmap_ref(ci->pixmap);
collection_list = g_list_remove(collection_list, cd);
g_hash_table_destroy(cd->existence);
-
+
g_free(cd->path);
g_free(cd->name);
if (!cw->cd->path)
{
collection_dialog_save_as(NULL, cw->cd);
- }
+ }
else if (!collection_save(cw->cd, cw->cd->path))
{
printf("failed saving to collection path: %s\n", cw->cd->path);
generic_dialog_close(gd);
if (!cw->cd->path)
- {
+ {
collection_dialog_save_close(NULL, cw->cd);
return;
}
gint rs;
gint i;
gint pixbuf_width, pixbuf_height;
-
+
pixbuf_width = gdk_pixbuf_get_width(pixbuf);
pixbuf_height = gdk_pixbuf_get_height(pixbuf);
guchar *pbuf;
pbuf = pix + ((y + i) * rs);
-
+
cmsDoTransform(cc->transform, pbuf, pbuf, w);
}
{
new_time = msec_time() - dw->setup_time;
}
-
+
if (!force &&
value != 0.0 &&
dw->setup_count > 0 &&
{
status_text = NULL;
}
- }
+ }
else
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
GdkCursor *cursor;
if (!widget->window) return;
-
+
if (icon == -1)
{
cursor = NULL;
{
cursor = gdk_cursor_new (icon);
}
-
+
gdk_window_set_cursor(widget->window, cursor);
-
+
if (cursor) gdk_cursor_unref(cursor);
}
static void dupe_match_link_clear(DupeItem *parent, gint unlink_children)
{
GList *work;
-
+
work = parent->group;
while (work)
{
list = g_list_remove(list, orphan);
}
}
-
+
rank = dupe_match_link_rank(child, parent);
dupe_match_link_clear(parent, TRUE);
dupe_match_link(child, parent, rank);
else
{
if (debug > 1) printf("unlinking %s and %s\n", child->fd->name, parent->fd->name);
-
+
dupe_match_unlink(child, parent);
}
dupe_match_rank_update(di);
list = g_list_prepend(list, di);
}
-
+
work = work->next;
}
list = dupe_match_rank_sort(dw->list);
if (debug > 1) dupe_match_print_list(list);
-
+
if (debug) printf("Similar items: %d\n", g_list_length(list));
list = dupe_match_group_trim(list, dw);
if (debug) printf("Unique groups: %d\n", g_list_length(list));
{
DupeItem *new_parent;
DupeMatch *dm;
-
+
dm = parent->group->data;
new_parent = dm->di;
dupe_match_reparent(dw, parent, new_parent);
dw->second_drop = second;
dupe_files_add(dw, NULL, NULL, fd, FALSE);
dw->second_drop = FALSE;
-
+
file_data_unref(fd);
*/
dupe_check_start(dw);
{
DupeItem *di = work->data;
- if (di->fd == fd)
+ if (di->fd == fd)
dupe_item_update(dw, di);
work = work->next;
label = gtk_label_new(text);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
-
+
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
{
GenericDialog *gd;
gchar *buf;
-
+
if (!di) return;
gd = file_util_gen_dlg("Image thumbprint debug info", GQ_WMCLASS, "thumbprint",
guchar *dp;
gint rs;
gint sp;
-
+
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
rs = gdk_pixbuf_get_rowstride(pixbuf);
d_pix = gdk_pixbuf_get_pixels(pixbuf);
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_box_pack_start(GTK_BOX(gd->vbox), image, FALSE, FALSE, 0);
gtk_widget_show(image);
-
+
gdk_pixbuf_unref(pixbuf);
}
-
+
gtk_widget_show(gd->dialog);
}
/* this overrides the low default of a GtkCellRenderer from 100 to CELL_HEIGHT_OVERRIDE, something sane for our purposes */
#define CELL_HEIGHT_OVERRIDE 512
-
+
void cell_renderer_height_override(GtkCellRenderer *renderer)
{
GParamSpec *spec;
if (!column) return;
gtk_tree_view_column_set_fixed_width(column, (thumb) ? options->thumbnails.max_width : 4);
-
+
list = gtk_tree_view_column_get_cell_renderers(column);
if (!list) return;
cell = list->data;
dw->second_set = FALSE;
dw->window = window_new(GTK_WINDOW_TOPLEVEL, "dupe", NULL, NULL, _("Find duplicates"));
-
+
geometry.min_width = 32;
geometry.min_height = 32;
geometry.base_width = DUPE_DEF_WIDTH;
gtk_window_set_default_size(GTK_WINDOW(dw->window), DUPE_DEF_WIDTH, DUPE_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(dw->window), TRUE);
- gtk_container_set_border_width (GTK_CONTAINER (dw->window), 0);
+ gtk_container_set_border_width (GTK_CONTAINER (dw->window), 0);
- g_signal_connect(G_OBJECT(dw->window), "delete_event",
+ g_signal_connect(G_OBJECT(dw->window), "delete_event",
G_CALLBACK(dupe_window_delete), dw);
g_signal_connect(G_OBJECT(dw->window), "key_press_event",
G_CALLBACK(dupe_window_keypress_cb), dw);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_table_attach_defaults(GTK_TABLE(dw->table), scrolled, 0, 2, 0, 1);
- gtk_widget_show(scrolled);
+ gtk_widget_show(scrolled);
store = gtk_list_store_new(9, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(dw->second_vbox), scrolled, TRUE, TRUE, 0);
- gtk_widget_show(scrolled);
+ gtk_widget_show(scrolled);
store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_STRING);
dw->second_listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
dupe_listview_add_column(dw, dw->second_listview, 1, _("Compare to:"), FALSE, FALSE);
gtk_container_add(GTK_CONTAINER(scrolled), dw->second_listview);
- gtk_widget_show(dw->second_listview);
+ gtk_widget_show(dw->second_listview);
dw->second_status_label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(dw->second_vbox), dw->second_status_label, FALSE, FALSE, 0);
gtk_widget_show(button);
status_box = gtk_hbox_new(FALSE, 0);
- gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
- gtk_widget_show(status_box);
+ gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
+ gtk_widget_show(status_box);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
*/
static GtkTargetEntry dupe_drag_types[] = {
- { "text/uri-list", 0, TARGET_URI_LIST },
- { "text/plain", 0, TARGET_TEXT_PLAIN }
+ { "text/uri-list", 0, TARGET_URI_LIST },
+ { "text/plain", 0, TARGET_TEXT_PLAIN }
};
static gint n_dupe_drag_types = 2;
static GtkTargetEntry dupe_drop_types[] = {
- { TARGET_APP_COLLECTION_MEMBER_STRING, 0, TARGET_APP_COLLECTION_MEMBER },
- { "text/uri-list", 0, TARGET_URI_LIST }
+ { TARGET_APP_COLLECTION_MEMBER_STRING, 0, TARGET_APP_COLLECTION_MEMBER },
+ { "text/uri-list", 0, TARGET_URI_LIST }
};
static gint n_dupe_drop_types = 2;
vd->spinner = spinner_new(NULL, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0);
gtk_widget_show(vd->spinner);
-
+
gtk_widget_show(vd->gd->dialog);
ed->vd = vd;
const gchar *p = NULL;
string = g_string_new("");
-
+
if (type == PATH_FILE)
{
GList *ext_list = filter_to_list(extensions);
GList *work = ext_list;
-
+
if (!work)
p = fd->path;
else
{
gchar *ext = work->data;
work = work->next;
-
- if (strcmp(ext, "*") == 0 ||
+
+ if (strcmp(ext, "*") == 0 ||
strcasecmp(ext, fd->extension) == 0)
{
p = fd->path;
break;
}
-
+
GList *work2 = fd->sidecar_files;
-
+
while(work2)
{
FileData *sfd = work2->data;
work2 = work2->next;
-
+
if (strcasecmp(ext, sfd->extension) == 0)
{
p = sfd->path;
const gchar *p = template;
GString *result = NULL;
gchar *extensions = NULL;
-
+
if (output)
result = g_string_new("");
- if (!template || template[0] == '\0')
+ if (!template || template[0] == '\0')
{
flags |= EDITOR_ERROR_EMPTY;
goto err;
}
-
+
/* global flags */
while (*p == '%')
{
break;
}
}
-
+
/* command */
-
+
while (*p)
{
if (*p != '%')
gchar *pathl = NULL;
p++;
-
+
/* for example "%f" or "%{.crw;.raw;.cr2}f" */
if (*p == '{')
{
flags |= EDITOR_ERROR_SYNTAX;
goto err;
}
-
+
extensions = g_strndup(p, end - p);
p = end + 1;
}
-
- switch (*p)
+
+ switch (*p)
{
case 'd':
flags |= EDITOR_DEST;
if (output)
{
/* use the first file from the list */
- if (!list || !list->data)
+ if (!list || !list->data)
{
flags |= EDITOR_ERROR_NO_FILE;
goto err;
}
pathl = editor_command_path_parse((FileData *)list->data, (*p == 'd') ? PATH_DEST : PATH_FILE, extensions);
- if (!pathl)
+ if (!pathl)
{
flags |= EDITOR_ERROR_NO_FILE;
goto err;
g_free(pathl);
result = g_string_append_c(result, '"');
}
- break;
+ break;
case 'f':
flags |= EDITOR_SINGLE_COMMAND;
}
work = work->next;
}
- if (!ok)
+ if (!ok)
{
flags |= EDITOR_ERROR_NO_FILE;
goto err;
}
}
- break;
+ break;
default:
flags |= EDITOR_ERROR_SYNTAX;
goto err;
if (output) *output = g_string_free(result, FALSE);
return flags;
-
+
err:
- if (output)
+ if (output)
{
g_string_free(result, TRUE);
*output = NULL;
EditorData *ed = data;
g_spawn_close_pid(pid);
ed->pid = -1;
-
+
editor_command_next_finish(ed, status);
}
FileData *fd = list->data;
gchar *args[4];
GPid pid;
- gint standard_output;
- gint standard_error;
+ gint standard_output;
+ gint standard_error;
gboolean ok;
ed->pid = -1;
working_directory = remove_level_from_path(fd->path);
-
+
ed->flags = editor_command_parse(template, list, &command);
ok = !(ed->flags & EDITOR_ERROR_MASK);
args[1] = COMMAND_OPT;
args[2] = command;
args[3] = NULL;
-
+
if (ok)
{
- ok = g_spawn_async_with_pipes(working_directory, args, NULL,
+ ok = g_spawn_async_with_pipes(working_directory, args, NULL,
G_SPAWN_DO_NOT_REAP_CHILD, /* GSpawnFlags */
- NULL, NULL,
- &pid,
- NULL,
- ed->vd ? &standard_output : NULL,
- ed->vd ? &standard_error : NULL,
+ NULL, NULL,
+ &pid,
+ NULL,
+ ed->vd ? &standard_output : NULL,
+ ed->vd ? &standard_error : NULL,
NULL);
-
+
if (!ok) ed->flags |= EDITOR_ERROR_CANT_EXEC;
}
- if (ok)
+ if (ok)
{
g_child_watch_add(pid, editor_child_exit_cb, ed);
ed->pid = pid;
}
-
-
+
+
if (ed->vd)
{
g_free(buf);
}
- else
+ else
{
-
+
GIOChannel *channel_output;
GIOChannel *channel_error;
channel_output = g_io_channel_unix_new(standard_output);
g_io_channel_unref(channel_error);
}
}
-
-
+
+
g_free(command);
g_free(working_directory);
}
}
- if (!error)
+ if (!error)
return 0;
else
/* command was not started, call the finish immediately */
return editor_command_next_finish(ed, 0);
}
-
+
/* everything is done */
return editor_command_done(ed);
}
}
void editor_skip(gpointer ed)
{
- editor_command_done(ed);
+ editor_command_done(ed);
}
static gint editor_command_start(const gchar *template, const gchar *text, GList *list, EditorCallback cb, gpointer data)
{
EditorData *ed;
gint flags = editor_command_parse(template, NULL, NULL);
-
+
if (flags & EDITOR_ERROR_MASK) return flags & EDITOR_ERROR_MASK;
ed = g_new0(EditorData, 1);
ed->stopping = FALSE;
ed->callback = cb;
ed->data = data;
-
+
if ((flags & EDITOR_VERBOSE_MULTI) && list && list->next)
flags |= EDITOR_VERBOSE;
-
-
+
+
if (flags & EDITOR_VERBOSE)
editor_verbose_window(ed, text);
-
- editor_command_next_start(ed);
+
+ editor_command_next_start(ed);
/* errors from editor_command_next_start will be handled via callback */
return flags & EDITOR_ERROR_MASK;
}
EDITOR_KEEP_FS = 0x00000001,
EDITOR_VERBOSE = 0x00000002,
EDITOR_VERBOSE_MULTI = 0x00000004,
-
+
EDITOR_DEST = 0x00000100,
EDITOR_FOR_EACH = 0x00000200,
EDITOR_SINGLE_COMMAND = 0x00000400,
-
+
EDITOR_ERROR_EMPTY = 0x00020000,
EDITOR_ERROR_SYNTAX = 0x00040000,
EDITOR_ERROR_INCOMPATIBLE = 0x00080000,
EDITOR_ERROR_SKIPPED = 0x00800000,
EDITOR_ERROR_MASK = 0xffff0000
-
+
};
/* return values from callback function */
EDITOR_CB_CONTINUE = 0, /* continue multiple editor execution on remaining files*/
EDITOR_CB_SKIP, /* skip the remaining files */
EDITOR_CB_SUSPEND /* suspend execution, one of editor_resume or editor_skip
- must be called later */
+ must be called later */
};
/*
-Callback is called even on skipped files, with the EDITOR_ERROR_SKIPPED flag set.
+Callback is called even on skipped files, with the EDITOR_ERROR_SKIPPED flag set.
It is a good place to call file_data_change_info_free().
ed - pointer that can be used for editor_resume/editor_skip or NULL if all files were already processed
for (i = 0; s[i] && t[i] && s[i] == t[i]; i++)
;
- if (!i)
+ if (!i)
return t;
if (s[i-1] == ' ' || !s[i])
{
static double get_crop_factor(ExifData *exif)
{
- double res_unit_tbl[] = {0.0, 25.4, 25.4, 10.0, 1.0, 0.001 };
-
- double xres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneXResolution");
- double yres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneYResolution");
- int res_unit;
- int w, h;
- double xsize, ysize, size, ratio;
-
- if (xres == 0.0 || yres == 0.0) return 0.0;
-
- if (!exif_get_integer(exif, "Exif.Photo.FocalPlaneResolutionUnit", &res_unit)) return 0.0;
- if (res_unit < 1 || res_unit > 5) return 0.0;
-
- if (!exif_get_integer(exif, "Exif.Photo.PixelXDimension", &w)) return 0.0;
- if (!exif_get_integer(exif, "Exif.Photo.PixelYDimension", &h)) return 0.0;
-
- xsize = w * res_unit_tbl[res_unit] / xres;
- ysize = h * res_unit_tbl[res_unit] / yres;
-
- ratio = xsize / ysize;
-
- if (ratio < 0.5 || ratio > 2.0) return 0.0; /* reasonable ratio */
-
- size = sqrt(xsize * xsize + ysize * ysize);
-
- if (size < 1.0 || size > 100.0) return 0.0; /* reasonable sensor size in mm */
-
- return sqrt(36*36+24*24) / size;
-
+ double res_unit_tbl[] = {0.0, 25.4, 25.4, 10.0, 1.0, 0.001 };
+
+ double xres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneXResolution");
+ double yres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneYResolution");
+ int res_unit;
+ int w, h;
+ double xsize, ysize, size, ratio;
+
+ if (xres == 0.0 || yres == 0.0) return 0.0;
+
+ if (!exif_get_integer(exif, "Exif.Photo.FocalPlaneResolutionUnit", &res_unit)) return 0.0;
+ if (res_unit < 1 || res_unit > 5) return 0.0;
+
+ if (!exif_get_integer(exif, "Exif.Photo.PixelXDimension", &w)) return 0.0;
+ if (!exif_get_integer(exif, "Exif.Photo.PixelYDimension", &h)) return 0.0;
+
+ xsize = w * res_unit_tbl[res_unit] / xres;
+ ysize = h * res_unit_tbl[res_unit] / yres;
+
+ ratio = xsize / ysize;
+
+ if (ratio < 0.5 || ratio > 2.0) return 0.0; /* reasonable ratio */
+
+ size = sqrt(xsize * xsize + ysize * ysize);
+
+ if (size < 1.0 || size > 100.0) return 0.0; /* reasonable sensor size in mm */
+
+ return sqrt(36*36+24*24) / size;
+
}
if (software[i] == ' ' && software[i+1] == ' ')
{
gint j;
-
+
for (j=1; software[i+j]; j++)
- if (software[i+j] != ' ')
+ if (software[i+j] != ' ')
break;
- memmove(software+i+1, software+i+j, strlen(software+i+j)+1);
- }
+ memmove(software+i+1, software+i+j, strlen(software+i+j)+1);
+ }
model2 = remove_common_prefix(make, model);
software2 = remove_common_prefix(model2, software);
if (n > 1.0 && (int)n - ((int)(n/10))*10 == 1) n--;
return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
- n > 1.0 ? floor(n) : 1.0 / n);
+ n > 1.0 ? floor(n) : 1.0 / n);
}
return NULL;
}
if (strcmp(key, "fFocalLength35mmFilm") == 0)
{
gint n;
- double f, c;
+ double f, c;
if (exif_get_integer(exif, "Exif.Photo.FocalLengthIn35mmFilm", &n) && n != 0)
- {
- return g_strdup_printf("%d mm", n);
- }
-
- f = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
- c = get_crop_factor(exif);
-
- if (f != 0.0 && c != 0.0)
- {
- return g_strdup_printf("%.0f mm", f * c);
- }
-
- return NULL;
+ {
+ return g_strdup_printf("%d mm", n);
+ }
+
+ f = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
+ c = get_crop_factor(exif);
+
+ if (f != 0.0 && c != 0.0)
+ {
+ return g_strdup_printf("%.0f mm", f * c);
+ }
+
+ return NULL;
}
if (strcmp(key, "fISOSpeedRating") == 0)
{
/* ColorSpace == 1 specifies sRGB per EXIF 2.2 */
if (!exif_get_integer(exif, "Exif.Photo.ColorSpace", &cs)) cs = 0;
- interop_index = exif_get_data_as_text(exif, "Exif.Iop.InteroperabilityIndex");
-
+ interop_index = exif_get_data_as_text(exif, "Exif.Iop.InteroperabilityIndex");
+
if (cs == 1)
{
name = _("sRGB");
name = _("AdobeRGB");
source = (cs == 2) ? "ColorSpace" : "Iop";
}
-
+
g_free(interop_index);
}
{
source = _("embedded");
#ifdef HAVE_LCMS
-
+
{
unsigned char *data;
guint data_len;
cmsHPROFILE profile;
-
+
data = (unsigned char *) exif_item_get_data(prof_item, &data_len);
if (data)
{
* (C) 2006 John Ellis
*
* Authors:
- * Support for Exif file format, originally written by Eric Swalens.
+ * Support for Exif file format, originally written by Eric Swalens.
* Modified by Quy Tonthat
* Reimplemented with generic data storage by John Ellis
*
* (C) 2006 John Ellis
*
* Authors:
- * Support for Exif file format, originally written by Eric Swalens.
+ * Support for Exif file format, originally written by Eric Swalens.
* Modified by Quy Tonthat
*
* Reimplemented with generic data storage by John Ellis (Nov 2003)
#include <sys/stat.h>
#include <sys/mman.h>
#include <math.h>
-
+
#include <glib.h>
#include "intl.h"
EXIF_TEXT_LIST_END
};
-/*
-Tag names should match to exiv2 keys, http://www.exiv2.org/metadata.html
+/*
+Tag names should match to exiv2 keys, http://www.exiv2.org/metadata.html
Tags that don't match are not supported by exiv2 and should not be used anywhere in the code
*/
const char *exif_item_get_format_name(ExifItem *item, gint brief)
{
- if (!item || !item->marker) return NULL;
+ if (!item || !item->marker) return NULL;
return (brief) ? ExifFormatList[item->format].short_name : ExifFormatList[item->format].description;
}
FF: 1 byte standard marker identifier
TT: 1 byte data type
SSSS: 2 bytes in Motorola byte alignment for length of the data.
- This value includes these 2 bytes in the count, making actual
- length of NN... == SSSS - 2.
+ This value includes these 2 bytes in the count, making actual
+ length of NN... == SSSS - 2.
NNN.: the data in this segment
*/
ExifItem *exif_get_first_item(ExifData *exif)
{
- if (exif->items)
+ if (exif->items)
{
ExifItem *ret = (ExifItem *)exif->items->data;
exif->current = exif->items->next;
ExifItem *exif_get_next_item(ExifData *exif)
{
- if (exif->current)
+ if (exif->current)
{
ExifItem *ret = (ExifItem *)exif->current->data;
exif->current = exif->current->next;
item = work->data;
work = work->next;
if (item->marker->key && strcmp(key, item->marker->key) == 0) return item;
- }
+ }
return NULL;
}
-#endif
+#endif
/* not HAVE_EXIV2 */
* (C) 2006 John Ellis
*
* Authors:
- * Support for Exif file format, originally written by Eric Swalens.
+ * Support for Exif file format, originally written by Eric Swalens.
* Modified by Quy Tonthat
* Reimplemented with generic data storage by John Ellis
*
fe->extensions = g_strdup(extensions);
fe->enabled = enabled;
fe->file_class = file_class;
-
+
return fe;
}
gchar **extensions;
GString *filter = NULL;
gint i;
-
+
format = work->data;
work = work->next;
filter_add_if_missing("ico", "Icon file", ".ico;.cur", FORMAT_CLASS_IMAGE, FALSE);
filter_add_if_missing("ras", "Raster", ".ras", FORMAT_CLASS_IMAGE, FALSE);
filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FORMAT_CLASS_IMAGE, FALSE);
-
+
/* non-image files that might be desirable to show */
filter_add_if_missing("xmp", "XMP sidecar", ".xmp", FORMAT_CLASS_META, TRUE);
ext = filter_to_list(fe->extensions);
if (ext) extension_list = g_list_concat(extension_list, ext);
-
+
if (fe->file_class >= 0 && fe->file_class < FILE_FORMAT_CLASSES)
{
ext = filter_to_list(fe->extensions);
{
FilterEntry *fe = work->data;
work = work->next;
-
+
gchar *extensions = escquote_value(fe->extensions);
gchar *description = escquote_value(fe->description);
ext = quoted_value(p, &p);
desc = quoted_value(p, &p);
-
+
file_class = strtol(p, NULL, 10);
-
+
if (file_class < 0 || file_class >= FILE_FORMAT_CLASSES) file_class = FORMAT_CLASS_UNKNOWN;
if (key && key[0] == '#')
}
g_list_free(sidecar_ext_list);
sidecar_ext_list = NULL;
-
+
if (quoted)
value = quoted_value(text, NULL);
else
if (value == NULL) return;
sidecar_ext_list = filter_to_list(value);
-
+
g_free(value);
}
if (strcmp(fd->name, "..") == 0)
{
- gchar *dir = remove_level_from_path(path);
+ gchar *dir = remove_level_from_path(path);
g_free(fd->path);
fd->path = remove_level_from_path(dir);
g_free(dir);
fd->name = "..";
fd->extension = fd->name + 2;
- return;
+ return;
}
else if (strcmp(fd->name, ".") == 0)
{
}
fd->extension = extension_from_path(fd->path);
- if (fd->extension == NULL)
+ if (fd->extension == NULL)
fd->extension = fd->name + strlen(fd->name);
}
{
file_data_disconnect_sidecar_file(fd, sfd);
}
-
+
file_data_check_changed_files(sfd, &st);
work = work->next;
}
FileData *fd;
if (debug) printf("file_data_new: '%s' %d\n", path_utf8, check_sidecars);
-
+
if (!file_data_pool)
file_data_pool = g_hash_table_new (g_str_hash, g_str_equal);
-
+
fd = g_hash_table_lookup(file_data_pool, path_utf8);
if (fd)
{
if (debug) printf("file_data_pool hit: '%s'\n", fd->path);
return file_data_ref(fd);
}
-
+
fd = g_new0(FileData, 1);
file_data_set_path(fd, path_utf8);
-
+
fd->original_path = g_strdup(path_utf8);
fd->size = st->st_size;
fd->date = st->st_mtime;
fd->sidecar_files = NULL;
fd->ref = 1;
fd->magick = 0x12345678;
-
+
g_hash_table_insert(file_data_pool, fd->original_path, fd);
-
- if (check_sidecars && sidecar_file_priority(fd->extension))
+
+ if (check_sidecars && sidecar_file_priority(fd->extension))
file_data_check_sidecars(fd);
return fd;
}
GString *fname = g_string_new_len(fd->path, base_len);
FileData *parent_fd = NULL;
GList *work = sidecar_ext_get_list();
- while (work)
+ while (work)
{
/* check for possible sidecar files;
the sidecar files created here are referenced only via fd->sidecar_files or fd->parent,
they have fd->ref set to 0 and file_data unref must chack and free them all together
(using fd->ref would cause loops and leaks)
*/
-
+
FileData *new_fd;
-
+
gchar *ext = work->data;
work = work->next;
-
+
if (strcmp(ext, fd->extension) == 0)
{
new_fd = fd; /* processing the original file */
struct stat nst;
g_string_truncate(fname, base_len);
g_string_append(fname, ext);
-
+
if (!stat_utf8(fname->str, &nst))
continue;
-
+
new_fd = file_data_new(fname->str, &nst, FALSE);
new_fd->ref--; /* do not use ref here */
}
-
+
if (!parent_fd)
parent_fd = new_fd; /* parent is the one with the highest prio, found first */
else
{
GList *work;
file_data_add_sidecar_file(target, source);
-
+
work = source->sidecar_files;
while (work)
{
g_list_free(source->sidecar_files);
source->sidecar_files = NULL;
- target->sidecar_files = filelist_sort(target->sidecar_files, SORT_NAME, TRUE);
+ target->sidecar_files = filelist_sort(target->sidecar_files, SORT_NAME, TRUE);
return target;
}
{
g_assert(fd->magick == 0x12345678);
g_assert(fd->ref == 0);
-
+
g_hash_table_remove(file_data_pool, fd->original_path);
g_free(fd->path);
g_assert(fd->sidecar_files == NULL); /* sidecar files must be freed before calling this */
- file_data_change_info_free(NULL, fd);
+ file_data_change_info_free(NULL, fd);
g_free(fd);
}
{
if (fd == NULL) return;
g_assert(fd->magick == 0x12345678);
-
+
fd->ref--;
if (debug) printf("file_data_unref (%d): '%s'\n", fd->ref, fd->path);
if (fd->ref == 0)
{
FileData *parent = fd->parent ? fd->parent : fd;
-
+
GList *work;
-
+
if (parent->ref > 0)
return;
-
+
work = parent->sidecar_files;
while (work)
{
return;
work = work->next;
}
-
+
/* none of parent/children is referenced, we can free everything */
-
+
if (debug) printf("file_data_unref: deleting '%s', parent '%s'\n", fd->path, parent->path);
-
+
work = parent->sidecar_files;
while (work)
{
file_data_free(sfd);
work = work->next;
}
-
+
g_list_free(parent->sidecar_files);
parent->sidecar_files = NULL;
-
+
file_data_free(parent);
-
+
}
}
if (len1 < len2) return -1;
if (len1 > len2) return 1;
-
+
return strncmp(fd1->name, fd2->name, len1);
}
{
FileDataChangeInfo *fdci;
-
+
if (fd->change) return FALSE;
-
+
fdci = g_new0(FileDataChangeInfo, 1);
fdci->type = type;
fdci->source = g_strdup(src);
else
fdci->source = g_strdup(fd->path);
-
+
if (dest)
fdci->dest = g_strdup(dest);
-
+
fd->change = fdci;
return TRUE;
}
{
if (!fdci && fd)
fdci = fd->change;
-
+
if (!fdci)
return;
-
+
g_free(fdci->source);
g_free(fdci->dest);
-
+
g_free(fdci);
-
+
if (fd)
fd->change = NULL;
}
-
+
/*
*-----------------------------------------------------------------------------
* sidecar file info struct
GList *work;
if (extension == NULL)
return 0;
-
+
work = sidecar_ext_get_list();
-
+
while (work) {
gchar *ext = work->data;
work = work->next;
if (strcmp(extension, ext) == 0) return i;
i++;
- }
+ }
return 0;
}
{
GList *work = flist;
GList *flist_filtered = NULL;
-
+
while (work)
{
FileData *fd = work->data;
work = work->next;
if (fd->parent) /* remove fd's that are children */
- file_data_unref(fd);
+ file_data_unref(fd);
else
flist_filtered = g_list_prepend(flist_filtered, fd);
}
if (options->file_filter.show_hidden_files || !ishidden(name))
{
gchar *filepath = g_strconcat(pathl, "/", name, NULL);
- if ((follow_symlinks ?
+ if ((follow_symlinks ?
stat(filepath, &ent_sbuf) :
lstat(filepath, &ent_sbuf)) >= 0)
{
while (work)
{
FileData *fd;
-
+
fd = work->data;
work = work->next;
-
+
new_list = g_list_prepend(new_list, file_data_ref(fd));
}
-
+
return g_list_reverse(new_list);
}
while (work)
{
gchar *path;
-
+
path = work->data;
work = work->next;
-
+
new_list = g_list_prepend(new_list, file_data_new_simple(path));
}
-
+
return g_list_reverse(new_list);
}
while (work)
{
FileData *fd;
-
+
fd = work->data;
work = work->next;
-
+
new_list = g_list_prepend(new_list, g_strdup(fd->path));
}
-
+
return g_list_reverse(new_list);
}
void sidecar_ext_parse(const gchar *text, gint quoted);
void sidecar_ext_write(SecureSaveInfo *ssi);
-char *sidecar_ext_to_string();
+char *sidecar_ext_to_string();
void sidecar_ext_add_defaults();
gint ishidden(const gchar *name);
*
* Code to add support for Canon CR2 and CRW files, version 0.2
*
- * Developed by Daniel M. German, dmgerman at uvic.ca
+ * Developed by Daniel M. German, dmgerman at uvic.ca
*
* you can find the sources for this patch at http://turingmachine.org/~dmg/libdcraw/gqview/
*
guint jpeg_offset;
jpeg_offset = block_offset + record_offset;
- if (len < jpeg_offset + record_length ||
+ if (len < jpeg_offset + record_length ||
record_length < 4 ||
memcmp(data + jpeg_offset, "\xff\xd8\xff\xdb", 4) != 0)
{
}
-#endif
+#endif
/* not HAVE_EXIV2 */
*
* Code to add support for Canon CR2 and CRW files, version 0.2
*
- * Developed by Daniel M. German, dmgerman at uvic.ca
+ * Developed by Daniel M. German, dmgerman at uvic.ca
*
* you can find the sources for this patch at http://turingmachine.org/~dmg/libdcraw/gqview/
*
return TRUE;
}
-#endif
+#endif
/* not HAVE_EXIV2 */
return TRUE;
}
-#endif
+#endif
/* not HAVE_EXIV2 */
}
-#endif
+#endif
/* not HAVE_EXIV2 */
/* FIXME:
* when the target is a tiff file it should be mmaped prior to format_raw_find as
* the make field data may not always be within header_data + header_len
- */
+ */
entry = format_raw_find(header_data, header_len);
if (!entry || !entry->func_parse) return FALSE;
}
#endif
-#endif
+#endif
/* not HAVE_EXIV2 */
ScreenData *sd = work->data;
work = work->next;
- g_free(sd->description);
+ g_free(sd->description);
g_free(sd);
}
if (!options) options = g_new0(ConfOptions, 1);
options->collections.rectangular_selection = FALSE;
-
+
options->color_profile.enabled = FALSE;
options->color_profile.input_type = 0;
options->color_profile.screen_file = NULL;
options->color_profile.screen_type = 0;
options->color_profile.use_image = TRUE;
-
+
options->duplicates_similarity_threshold = 99;
options->enable_metadata_dirs = FALSE;
-
+
options->file_filter.disable = FALSE;
options->file_filter.show_dot_directory = FALSE;
options->file_filter.show_hidden_files = FALSE;
-
+
options->file_ops.confirm_delete = TRUE;
options->file_ops.enable_delete_key = TRUE;
options->file_ops.enable_in_place_rename = TRUE;
options->file_ops.safe_delete_enable = FALSE;
options->file_ops.safe_delete_folder_maxsize = 128;
options->file_ops.safe_delete_path = NULL;
-
+
options->file_sort.ascending = TRUE;
options->file_sort.case_sensitive = FALSE;
options->file_sort.method = SORT_NAME;
-
+
options->fullscreen.above = FALSE;
options->fullscreen.clean_flip = FALSE;
options->fullscreen.disable_saver = TRUE;
options->fullscreen.info = NULL;
options->fullscreen.screen = -1;
options->fullscreen.show_info = TRUE;
-
+
memset(&options->image.border_color, 0, sizeof(options->image.border_color));
options->image.dither_quality = (gint)GDK_RGB_DITHER_NORMAL;
options->image.enable_read_ahead = TRUE;
options->layout.tools_hidden = FALSE;
options->layout.tools_restore_state = FALSE;
options->layout.view_as_icons = FALSE;
-
+
options->lazy_image_sync = FALSE;
options->mousewheel_scrolls = FALSE;
options->open_recent_list_maxsize = 10;
options->place_dialogs_under_mouse = FALSE;
options->progressive_key_scrolling = FALSE;
options->show_icon_names = TRUE;
-
+
options->slideshow.delay = 150;
options->slideshow.random = FALSE;
options->slideshow.repeat = FALSE;
-
+
options->startup_path_enable = FALSE;
options->startup_path = NULL;
-
+
options->thumbnails.cache_into_dirs = FALSE;
options->thumbnails.enable_caching = TRUE;
options->thumbnails.fast = TRUE;
options->thumbnails.quality = (gint)GDK_INTERP_TILES;
options->thumbnails.spec_standard = TRUE;
options->thumbnails.use_xvpics = TRUE;
-
+
options->tree_descend_subdirs = FALSE;
options->update_on_time_change = TRUE;
*/
#define HISTOGRAM_SIZE 256
-
+
struct _Histogram {
gulong histmap[HISTOGRAM_SIZE*4];
gint histogram_chan;
{
Histogram *histogram;
- histogram = g_new0(Histogram, 1);
+ histogram = g_new0(Histogram, 1);
histogram->histogram_chan = HCHAN_RGB;
histogram->histogram_logmode = 1;
if (!histogram) return NULL;
if (histogram->histogram_logmode)
- switch (histogram->histogram_chan) {
+ switch (histogram->histogram_chan)
+ {
case HCHAN_R: t1 = _("logarithmical histogram on red"); break;
- case HCHAN_G: t1 = _("logarithmical histogram on green"); break;
- case HCHAN_B: t1 = _("logarithmical histogram on blue"); break;
- case HCHAN_VAL: t1 = _("logarithmical histogram on value"); break;
- case HCHAN_RGB: t1 = _("logarithmical histogram on RGB"); break;
- case HCHAN_MAX: t1 = _("logarithmical histogram on max value"); break;
- }
- else
- switch (histogram->histogram_chan) {
- case HCHAN_R: t1 = _("linear histogram on red"); break;
- case HCHAN_G: t1 = _("linear histogram on green"); break;
- case HCHAN_B: t1 = _("linear histogram on blue"); break;
- case HCHAN_VAL: t1 = _("linear histogram on value"); break;
- case HCHAN_RGB: t1 = _("linear histogram on RGB"); break;
- case HCHAN_MAX: t1 = _("linear histogram on max value"); break;
- }
+ case HCHAN_G: t1 = _("logarithmical histogram on green"); break;
+ case HCHAN_B: t1 = _("logarithmical histogram on blue"); break;
+ case HCHAN_VAL: t1 = _("logarithmical histogram on value"); break;
+ case HCHAN_RGB: t1 = _("logarithmical histogram on RGB"); break;
+ case HCHAN_MAX: t1 = _("logarithmical histogram on max value"); break;
+ }
+ else
+ switch (histogram->histogram_chan)
+ {
+ case HCHAN_R: t1 = _("linear histogram on red"); break;
+ case HCHAN_G: t1 = _("linear histogram on green"); break;
+ case HCHAN_B: t1 = _("linear histogram on blue"); break;
+ case HCHAN_VAL: t1 = _("linear histogram on value"); break;
+ case HCHAN_RGB: t1 = _("linear histogram on RGB"); break;
+ case HCHAN_MAX: t1 = _("linear histogram on max value"); break;
+ }
return t1;
}
v[2] += histogram->histmap[ii + j + 2*HISTOGRAM_SIZE]; // b
v[3] += histogram->histmap[ii + j + 3*HISTOGRAM_SIZE]; // value, max
}
-
+
for (j=0; j<4; j++)
{
gint r = rplus;
for (k=1; k<4; k++)
if (v[k] > v[max2]) max2 = k;
-
+
switch (max2)
{
case HCHAN_R: rplus = r = 255; break;
case HCHAN_R: g = 0; b = 0; break;
case HCHAN_G: r = 0; b = 0; break;
case HCHAN_B: r = 0; g = 0; break;
- case HCHAN_RGB:
+ case HCHAN_RGB:
if (r == 255 && g == 255 && b == 255) {
- r = 0;
- g = 0;
- b = 0;
+ r = 0;
+ g = 0;
+ b = 0;
}
break;
}
pt = ((float)log(v[max2])) / logmax * (height - 1);
else
pt = ((float)v[max2])/ max * (height - 1);
- if (histogram->histogram_chan >= HCHAN_RGB
+ if (histogram->histogram_chan >= HCHAN_RGB
|| max2 == histogram->histogram_chan)
- pixbuf_draw_line(pixbuf,
+ pixbuf_draw_line(pixbuf,
x, y, width, height,
- x + i, y + height, x + i, y + height-pt,
+ x + i, y + height, x + i, y + height-pt,
r, g, b, 255);
v[max2] = -1;
}
n++;
}
g_strfreev(mime_types);
-
+
if (!scale) return;
if (width > il->requested_width || height > il->requested_height)
nw = (gdouble)nh / height * width;
if (nw < 1) nw = 1;
}
-
+
gdk_pixbuf_loader_set_size(loader, nw, nh);
il->shrunk = TRUE;
}
unsigned int offset = 0;
if (!il->loader || il->pixbuf) return FALSE;
-
+
b = read(il->load_fd, il->read_buffer, il->read_buffer_size);
if (b > 0 &&
il->loader = gdk_pixbuf_loader_new();
g_signal_connect(G_OBJECT(il->loader), "area_updated",
- G_CALLBACK(image_loader_area_cb), il);
+ G_CALLBACK(image_loader_area_cb), il);
g_signal_connect(G_OBJECT(il->loader), "size_prepared",
G_CALLBACK(image_loader_size_cb), il);
#define HIST_PREPARE(imd, lw) \
LayoutWindow *lw = NULL; \
if (imd) \
- lw = layout_find_by_image(imd);
+ lw = layout_find_by_image(imd);
void image_osd_histogram_onoff_toggle(ImageWindow *imd, gint x)
{
HIST_PREPARE(imd, lw)
- if (lw)
+ if (lw)
{
- lw->histogram_enabled = !!(x);
+ lw->histogram_enabled = !!(x);
if (lw->histogram_enabled && !lw->histogram)
lw->histogram = histogram_new();
}
void image_osd_histogram_chan_toggle(ImageWindow *imd)
{
HIST_PREPARE(imd, lw)
- if (lw && lw->histogram)
- histogram_set_channel(lw->histogram, (histogram_get_channel(lw->histogram) +1)%HCHAN_COUNT);
+ if (lw && lw->histogram)
+ histogram_set_channel(lw->histogram, (histogram_get_channel(lw->histogram) +1)%HCHAN_COUNT);
}
void image_osd_histogram_log_toggle(ImageWindow *imd)
{
HIST_PREPARE(imd,lw)
- if (lw && lw->histogram)
- histogram_set_mode(lw->histogram, !histogram_get_mode(lw->histogram));
+ if (lw && lw->histogram)
+ histogram_set_mode(lw->histogram, !histogram_get_mode(lw->histogram));
}
ExifData *exif;
if (!str || !*str) return g_strdup("");
-
+
new = g_string_new(str);
exif = exif_read_fd(imd->image_fd, FALSE);
end = strchr(start+1, delim);
if (!end)
break;
-
+
for (p = end; p > start; p--)
{
if (*p == ':' && was_digit)
g_free(data);
data = new_data;
}
-
+
g_string_erase(new, pos, end-start+1);
if (data)
g_string_insert(new, pos, data);
g_free(name);
g_free(data);
}
-
+
/* search and destroy empty lines */
end = new->str;
while ((start = strchr(end, '\n')))
if (!lw)
lw = layout_find_by_image(imd);
- if (imgpixbuf && lw->histogram && lw->histogram_enabled
- && (!imd->il || imd->il->done))
+ if (imgpixbuf && lw->histogram && lw->histogram_enabled
+ && (!imd->il || imd->il->done))
with_hist=1;
g_hash_table_insert(vars, "width", g_strdup_printf("%d", w));
g_hash_table_insert(vars, "height", g_strdup_printf("%d", h));
g_hash_table_insert(vars, "res", g_strdup_printf("%d × %d", w, h));
}
-
+
g_hash_table_insert(vars, "collection", g_strdup(ct));
g_hash_table_insert(vars, "number", g_strdup_printf("%d", n));
g_hash_table_insert(vars, "total", g_strdup_printf("%d", t));
gint mark;
gchar *text2;
- for (mark = 0; mark < FILEDATA_MARKS_SIZE; mark++)
+ for (mark = 0; mark < FILEDATA_MARKS_SIZE; mark++)
{
active_marks += fd->marks[mark];
}
if (active_marks > 0)
{
GString *buf = g_string_sized_new(FILEDATA_MARKS_SIZE * 2);
-
- for (mark = 0; mark < FILEDATA_MARKS_SIZE; mark++)
+
+ for (mark = 0; mark < FILEDATA_MARKS_SIZE; mark++)
{
g_string_append_printf(buf, fd->marks[mark] ? " <span background='#FF00FF'>%c</span>" : " %c", '1' + mark);
}
layout = gtk_widget_create_pango_layout(imd->pr, NULL);
pango_layout_set_markup(layout, text, -1);
g_free(text);
-
+
pango_layout_get_pixel_size(layout, &width, &height);
/* with empty text width is set to 0, but not height) */
if (width == 0)
pixbuf_pixel_set(pixbuf, width - 1, 0, 0, 0, 0, 0);
pixbuf_pixel_set(pixbuf, 0, height - 1, 0, 0, 0, 0);
pixbuf_pixel_set(pixbuf, width - 1, height - 1, 0, 0, 0, 0);
-
+
if (with_hist)
histogram_draw(lw->histogram, pixbuf, 5, height - HISTOGRAM_HEIGHT - 5 , width - 10, HISTOGRAM_HEIGHT);
-
+
pixbuf_draw_layout(pixbuf, layout, imd->pr, 5, 5, 0, 0, 0, 255);
}
gint width, height;
pixbuf_renderer_get_scaled_size(pr, &width, &height);
-
+
if (imd->func_drag)
{
imd->func_drag(imd, event->button, event->time,
if (imd->il && image_get_pixbuf(imd) != image_loader_get_pixbuf(imd->il)) return;
if (debug) printf("%s image load completed \"%s\" (%s)\n", get_exec_time(),
- (preload) ? (imd->read_ahead_fd ? imd->read_ahead_fd->path : "null") :
- (imd->image_fd ? imd->image_fd->path : "null"),
+ (preload) ? (imd->read_ahead_fd ? imd->read_ahead_fd->path : "null") :
+ (imd->image_fd ? imd->image_fd->path : "null"),
(preload) ? "preload" : "current");
if (!preload) imd->completed = TRUE;
input_type = COLOR_PROFILE_FILE;
input_file = options->color_profile.input_file[n];
}
- else if (imd->color_profile_input >= COLOR_PROFILE_SRGB &&
- imd->color_profile_input < COLOR_PROFILE_FILE)
+ else if (imd->color_profile_input >= COLOR_PROFILE_SRGB &&
+ imd->color_profile_input < COLOR_PROFILE_FILE)
{
input_type = imd->color_profile_input;
input_file = NULL;
/* ColorSpace == 1 specifies sRGB per EXIF 2.2 */
if (!exif_get_integer(exif, "Exif.Photo.ColorSpace", &cs)) cs = 0;
- interop_index = exif_get_data_as_text(exif, "Exif.Iop.InteroperabilityIndex");
-
+ interop_index = exif_get_data_as_text(exif, "Exif.Iop.InteroperabilityIndex");
+
if (cs == 1)
{
input_type = COLOR_PROFILE_SRGB;
if (debug) printf("Found EXIF ColorSpace of AdobeRGB\n");
}
-
+
g_free(interop_index);
}
}
guint data_len;
if (debug) printf("Found embedded color profile\n");
imd->color_profile_from_image = COLOR_PROFILE_MEM;
-
+
data = (unsigned char *) exif_item_get_data(item, &data_len);
cm = color_man_new_embedded(run_in_bg ? imd : NULL, NULL,
screen_type, screen_file);
g_free(data);
}
- else
+ else
{
cm = color_man_new(run_in_bg ? imd : NULL, NULL,
input_type, input_file,
}
imd->cm = (gpointer)cm;
-#if 0
+#if 0
if (run_in_bg) color_man_start_bg(imd->cm, image_post_process_color_cb, imd);
#endif
return TRUE;
{
gint rotate = TRUE;
- /* see http://jpegclub.org/exif_orientation.html
+ /* see http://jpegclub.org/exif_orientation.html
1 2 3 4 5 6 7 8
888888 888888 88 88 8888888888 88 88 8888888888
static void image_post_process_tile_color_cb(PixbufRenderer *pr, GdkPixbuf **pixbuf, gint x, gint y, gint w, gint h, gpointer data)
{
ImageWindow *imd = (ImageWindow *)data;
- if (imd->cm) color_man_correct_region(imd->cm, *pixbuf, x, y, w, h);
+ if (imd->cm) color_man_correct_region(imd->cm, *pixbuf, x, y, w, h);
if (imd->desaturate) pixbuf_desaturate_rect(*pixbuf, x, y, w, h);
}
const static gint mirror[] = {1, 2, 1, 4, 3, 6, 5, 8, 7};
const static gint flip[] = {1, 4, 3, 2, 1, 8, 7, 6, 5};
-
+
if (!imd || !imd->pr) return;
-
+
if (imd->orientation < 1 || imd->orientation > 8) imd->orientation = 1;
-
+
switch (type)
{
case ALTER_ROTATE_90:
}
pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, imd->orientation);
- if (imd->cm || imd->desaturate)
+ if (imd->cm || imd->desaturate)
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
else
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, NULL, NULL, TRUE);
if (fd && pixbuf)
{
imd->prev_fd = file_data_ref(fd);
-
+
g_object_ref(pixbuf);
imd->prev_pixbuf = pixbuf;
imd->prev_color_row = color_row;
gtk_paint_focus (widget->style, widget->window, GTK_STATE_ACTIVE,
area, widget, "image_window",
widget->allocation.x, widget->allocation.y,
- widget->allocation.width - 1, widget->allocation.height - 1);
+ widget->allocation.width - 1, widget->allocation.height - 1);
}
else
{
if (imd->func_scroll &&
event && event->type == GDK_SCROLL)
- {
+ {
imd->func_scroll(imd, event->direction, event->time,
event->x, event->y, event->state, imd->data_scroll);
return TRUE;
imd->orientation = imd->image_fd->user_orientation;
else if (options->image.exif_rotate_enable)
read_exif_for_orientation = TRUE;
-
+
if (read_exif_for_color_profile || read_exif_for_orientation)
{
gint orientation;
exif = exif_read_fd(imd->image_fd, read_exif_for_color_profile);
-
+
if (exif && read_exif_for_orientation)
{
if (exif_get_integer(exif, "Exif.Image.Orientation", &orientation))
}
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, NULL, NULL, FALSE);
- if (imd->cm)
+ if (imd->cm)
{
color_man_free(imd->cm);
imd->cm = NULL;
// image_state_set(imd, IMAGE_STATE_COLOR_ADJ);
}
}
-
+
exif_free(exif);
- if (imd->cm || imd->desaturate)
+ if (imd->cm || imd->desaturate)
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
-
+
image_state_set(imd, IMAGE_STATE_IMAGE);
}
imd->completed = source->completed;
imd->state = source->state;
source->state = IMAGE_STATE_NONE;
-
+
imd->orientation = source->orientation;
imd->desaturate = source->desaturate;
pixbuf_renderer_move(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
- if (imd->cm || imd->desaturate)
+ if (imd->cm || imd->desaturate)
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
else
pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, NULL, NULL, TRUE);
{
ImageWindow *imd = data;
time_t newtime;
-
+
if (!imd || !image_get_pixbuf(imd) ||
imd->il || !imd->image_fd ||
!options->update_on_time_change) return TRUE;
{
if (imd->has_frame)
{
- if (select)
+ if (select)
{
gtk_widget_set_state(imd->widget, GTK_STATE_SELECTED);
gtk_widget_set_state(imd->pr, GTK_STATE_NORMAL); /* do not propagate */
{
if (imd->has_frame)
{
- if (selectable)
+ if (selectable)
{
gtk_frame_set_shadow_type(GTK_FRAME(imd->frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (imd->frame), 4);
gboolean selectable_frame_expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
gtk_paint_flat_box(widget->style,
- widget->window,
- widget->state,
+ widget->window,
+ widget->state,
GTK_FRAME (widget)->shadow_type,
- NULL,
- widget,
- NULL,
- widget->allocation.x + 3, widget->allocation.y + 3,
- widget->allocation.width - 6, widget->allocation.height - 6);
-
-
+ NULL,
+ widget,
+ NULL,
+ widget->allocation.x + 3, widget->allocation.y + 3,
+ widget->allocation.width - 6, widget->allocation.height - 6);
+
+
return FALSE;
}
void image_set_frame(ImageWindow *imd, gboolean frame)
{
frame = !!frame;
-
+
if (frame == imd->has_frame) return;
-
+
gtk_widget_hide(imd->pr);
-
+
if (frame)
{
imd->frame = gtk_frame_new(NULL);
if (imd->has_frame != -1) gtk_container_remove(GTK_CONTAINER(imd->widget), imd->pr);
gtk_container_add(GTK_CONTAINER(imd->frame), imd->pr);
gtk_widget_unref(imd->pr);
- g_signal_connect (G_OBJECT (imd->frame), "expose_event",
- G_CALLBACK (selectable_frame_expose_cb), NULL);
+ g_signal_connect (G_OBJECT (imd->frame), "expose_event",
+ G_CALLBACK (selectable_frame_expose_cb), NULL);
GTK_WIDGET_SET_FLAGS(imd->frame, GTK_CAN_FOCUS);
g_signal_connect(G_OBJECT(imd->frame), "focus_in_event",
else
{
gtk_widget_ref(imd->pr);
- if (imd->frame)
+ if (imd->frame)
{
gtk_container_remove(GTK_CONTAINER(imd->frame), imd->pr);
gtk_widget_destroy(imd->frame);
}
gtk_widget_show(imd->pr);
-
+
imd->has_frame = frame;
}
imd->func_button = NULL;
imd->func_scroll = NULL;
-
+
imd->orientation = 1;
imd->pr = GTK_WIDGET(pixbuf_renderer_new());
image_options_set(imd);
-
+
imd->widget = gtk_vbox_new(0, 0);
image_set_frame(imd, frame);
gpointer data);
void image_set_scroll_func(ImageWindow *imd,
void (*func)(ImageWindow *, GdkScrollDirection direction, guint32 time, gdouble x, gdouble y, guint state, gpointer),
- gpointer data);
+ gpointer data);
void image_set_scroll_notify_func(ImageWindow *imd,
void (*func)(ImageWindow *imd, gint x, gint y, gint width, gint height, gpointer data),
gpointer data);
*-----------------------------------------------------------------------------
* misc
*-----------------------------------------------------------------------------
- */
+ */
static ImageWindow *view_window_active_image(ViewWindow *vw)
{
if (read_ahead_info) image_prebuffer_set(imd, read_ahead_info->fd);
}
-
+
}
static void view_collection_step_to_end(ViewWindow *vw, gint last)
break;
}
}
- else
+ else
{
stop_signal = TRUE;
switch (event->keyval)
*-----------------------------------------------------------------------------
* view window main routines
*-----------------------------------------------------------------------------
- */
+ */
static void button_cb(ImageWindow *imd, gint button, guint32 time,
gdouble x, gdouble y, guint state, gpointer data)
gtk_window_set_geometry_hints(GTK_WINDOW(vw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(vw->window), TRUE);
- gtk_container_set_border_width(GTK_CONTAINER(vw->window), 0);
+ gtk_container_set_border_width(GTK_CONTAINER(vw->window), 0);
vw->imd = image_new(FALSE);
G_CALLBACK(view_window_collection_unref_cb), cd);
}
}
- else if (isdir(fd->path))
+ else if (isdir(fd->path))
{
GList *list = NULL;
*-----------------------------------------------------------------------------
* view window menu routines and callbacks
*-----------------------------------------------------------------------------
- */
+ */
static void view_new_window_cb(GtkWidget *widget, gpointer data)
{
LayoutWindow *lw;
const gchar *path;
ImageWindow *imd;
-
+
imd = view_window_active_image(vw);
if (!imd || !imd->image_fd) return;
path = imd->image_fd->path;
if (!path) return;
-
+
lw = layout_find_by_image_fd(imd);
if (lw)
layout_set_path(lw, path);
static void view_dir_list_destroy(GtkWidget *widget, gpointer data)
{
CViewConfirmD *d = data;
- filelist_free(d->list);
- g_free(d);
+ filelist_free(d->list);
+ g_free(d);
}
static GtkWidget *view_confirm_dir_list(ViewWindow *vw, GList *list)
gtk_drag_dest_set(imd->pr,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
dnd_file_drop_types, dnd_file_drop_types_count,
- GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
+ GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->pr), "drag_data_received",
G_CALLBACK(view_window_get_dnd_data), vw);
}
t->pos = pos;
break;
}
- }
+ }
}
}
# define gettext(String) (String)
# define dgettext(Domain,String) (String)
# define dcgettext(Domain,String,Type) (String)
-# define bindtextdomain(Domain,Directory) (Domain)
+# define bindtextdomain(Domain,Directory) (Domain)
# define bind_textdomain_codeset(Domain,String) (Domain)
#endif /* ENABLE_NLS */
work = work->next;
if (lw->image->image_fd == imd->image_fd)
return lw;
-
+
}
return NULL;
layout_set_path(lw, buf);
- g_free(buf);
+ g_free(buf);
}
static void layout_path_entry_tab_cb(const gchar *path, gpointer data)
g_object_ref_sink(G_OBJECT(menu));
#endif
- /* ascending option */
+ /* ascending option */
menu_item_add_divider(menu);
menu_item_add_check(menu, _("Ascending"), lw->sort_ascend, G_CALLBACK(layout_sort_menu_ascend_cb), lw);
GtkWidget *button;
button = gtk_button_new_with_label(sort_type_get_text(lw->sort_method));
- g_signal_connect(G_OBJECT(button), "clicked",
+ g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(layout_sort_button_press_cb), lw);
- gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+ gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
- return button;
+ return button;
}
/*
vflist_set_thumb_status_func(lw->vfl, layout_list_thumb_cb, lw);
vflist_marks_set(lw->vfl, lw->marks_enabled);
-
+
return lw->vfl->widget;
}
if (lw->vfl) vflist_selection_to_mark(lw->vfl, mark, mode);
if (lw->vfi) vficon_selection_to_mark(lw->vfi, mark, mode);
-
+
layout_status_update_info(lw, NULL); /* osd in fullscreen mode */
}
gtk_window_set_resizable(GTK_WINDOW(lw->tools), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(lw->tools), 0);
-
+
new_window = TRUE;
}
else
if (lw->split_images[i])
{
gtk_widget_hide(lw->split_images[i]->widget);
- if (lw->split_images[i]->widget->parent != lw->utility_box)
+ if (lw->split_images[i]->widget->parent != lw->utility_box)
gtk_container_remove(GTK_CONTAINER(lw->split_images[i]->widget->parent), lw->split_images[i]->widget);
}
}
priority_location = layout_grid_compass(lw);
image = layout_image_setup_split(lw, lw->split_mode);
-
+
tools = layout_tools_new(lw);
files = layout_list_new(lw);
{
LayoutWindow *lw = work->data;
work = work->next;
-
+
if (!lw->image) continue;
image_background_set_color(lw->image, options->image.use_custom_border_color ? &options->image.border_color : NULL);
}
layout_bars_close(lw);
gtk_widget_destroy(lw->window);
-
+
histogram_free(lw->histogram);
g_free(lw->path);
GtkTreeIter iter;
gint valid;
gint c = 0;
-
+
store = gtk_tree_view_get_model(GTK_TREE_VIEW(lc->listview));
-
+
valid = gtk_tree_model_get_iter_first(store, &iter);
while (valid)
{
LayoutConfig *lc;
lc = g_object_get_data(G_OBJECT(widget), "layout_config");
-
+
if (lc) lc->style = GPOINTER_TO_INT(data);
}
gtk_widget_show(table);
gtk_widget_show(group);
-
+
return group;
}
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, COLUMN_TEXT, _(layout_titles[i]), COLUMN_KEY, i, -1);
}
-
+
gtk_container_add(GTK_CONTAINER(scrolled), lc->listview);
gtk_widget_show(lc->listview);
pref_label_new(lc->box, _("(drag to change order)"));
-
+
return lc->box;
}
const gchar *path;
if (!layout_valid(&lw)) return;
-
+
path = layout_image_get_path(lw);
if (path) layout_set_path(lw, path);
}
item = menu_item_add_stock(menu, _("View in _new window"), GTK_STOCK_NEW, G_CALLBACK(li_pop_menu_new_cb), lw);
if (!path || fullscreen) gtk_widget_set_sensitive(item, FALSE);
-
+
item = menu_item_add(menu, _("_Go to directory view"), G_CALLBACK(li_set_layout_path_cb), lw);
if (!path || li_check_if_current_path(lw, path)) gtk_widget_set_sensitive(item, FALSE);
}
}
else
- {
+ {
menu_item_add(menu, _("_Start slideshow"), G_CALLBACK(li_pop_menu_slide_start_cb), lw);
item = menu_item_add(menu, _("Pause slides_how"), G_CALLBACK(li_pop_menu_slide_pause_cb), lw);
gtk_widget_set_sensitive(item, FALSE);
{
LayoutWindow *lw = data;
gint i;
-
-
- for (i=0; i < MAX_SPLIT_IMAGES; i++)
+
+
+ for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i] && lw->split_images[i]->pr == widget)
break;
LayoutWindow *lw = data;
FileData *fd;
gint i;
-
-
- for (i=0; i < MAX_SPLIT_IMAGES; i++)
+
+
+ for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i] && lw->split_images[i]->pr == widget)
break;
gtk_drag_dest_set(imd->pr,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
dnd_file_drop_types, dnd_file_drop_types_count,
- GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
+ GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(imd->pr), "drag_data_received",
G_CALLBACK(layout_image_dnd_receive), lw);
}
for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
- if (lw->split_images[i] && lw->split_images[i] != lw->image && lw->connect_zoom)
+ if (lw->split_images[i] && lw->split_images[i] != lw->image && lw->connect_zoom)
image_zoom_adjust(lw->split_images[i], increment); ;
}
}
for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
- if (lw->split_images[i] && lw->split_images[i] != lw->image && lw->connect_zoom)
+ if (lw->split_images[i] && lw->split_images[i] != lw->image && lw->connect_zoom)
image_zoom_set(lw->split_images[i], zoom);
}
}
if ((index > old && (index != (gint) last->data || old != (gint) x->data))
|| (old == (gint) last->data && index == (gint) x->data))
- {
+ {
if (y->next)
newindex = (gint) y->next->data;
else
read_ahead_fd = layout_list_get_fd(lw, newindex);
}
-
+
while (x)
x = g_list_remove(x, x->data);
}
;
if (y)
{
- if (y->next)
- layout_image_set_index(lw, (gint) y->next->data);
- else
- layout_image_set_index(lw, (gint) x->data);
+ if (y->next)
+ layout_image_set_index(lw, (gint) y->next->data);
+ else
+ layout_image_set_index(lw, (gint) x->data);
}
while (x)
x = g_list_remove(x, x->data);
;
if (y)
{
- if (y->prev)
+ if (y->prev)
layout_image_set_index(lw, (gint) y->prev->data);
else
layout_image_set_index(lw, (gint) last->data);
static gint image_idx(LayoutWindow *lw, ImageWindow *imd)
{
gint i;
-
- for (i=0; i < MAX_SPLIT_IMAGES; i++)
+
+ for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i] == imd)
break;
LayoutWindow *lw = data;
gint i = image_idx(lw, imd);
-
+
if (i != -1)
{
printf("image activate scroll %d\n", i);
for (i=0; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i] && lw->split_images[i] != imd)
- if (lw->connect_scroll)
+ if (lw->connect_scroll)
{
gdouble sx, sy;
if (state & GDK_CONTROL_MASK)
{
image_get_scroll_center(imd, &sx, &sy);
}
- else
+ else
{
image_get_scroll_center(lw->split_images[i], &sx, &sy);
sx += dx;
LayoutWindow *lw = data;
GtkWidget *menu;
gint i = image_idx(lw, imd);
-
+
if (i != -1)
{
layout_image_activate(lw, i);
LayoutWindow *lw = data;
gint i = image_idx(lw, imd);
-
+
if (i != -1)
{
layout_image_activate(lw, i);
GtkWidget *layout_image_new(LayoutWindow *lw, gint i)
{
- if (!lw->split_images[i])
+ if (!lw->split_images[i])
{
lw->split_images[i] = image_new(TRUE);
void layout_image_activate(LayoutWindow *lw, gint i)
{
FileData *fd;
-
+
if (!lw->split_images[i]) return;
/* deactivate currently active */
lw->image = lw->split_images[i];
lw->active_split_image = i;
-
+
image_set_update_func(lw->image, layout_image_update_cb, lw);
layout_image_set_buttons(lw);
image_set_drag_func(lw->image, layout_image_drag_cb, lw);
fd = image_get_fd(lw->image);
- if (fd)
+ if (fd)
{
// layout_list_sync_path(lw, path);
layout_set_path(lw, fd->path);
GtkWidget *layout_image_setup_split_none(LayoutWindow *lw)
{
gint i;
-
+
lw->split_mode = SPLIT_NONE;
if (!lw->split_images[0])
image_set_frame(lw->split_images[0], (!lw->tools_float && !lw->tools_hidden));
image_set_selectable(lw->split_images[0], 0);
}
-
+
for (i=1; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i])
layout_image_activate(lw, 0);
-
+
lw->split_image_widget = lw->split_images[0]->widget;
-
+
return lw->split_image_widget;
}
gint i;
lw->split_mode = horizontal ? SPLIT_HOR : SPLIT_VERT;
-
+
if (!lw->split_images[0])
{
layout_image_new(lw, 0);
if (lw->image)
{
gdouble sx, sy;
- image_change_fd(lw->split_images[1],
+ image_change_fd(lw->split_images[1],
image_get_fd(lw->image), image_zoom_get(lw->image));
image_get_scroll_center(lw->image, &sx, &sy);
image_set_scroll_center(lw->split_images[1], sx, sy);
image_set_selectable(lw->split_images[1], 1);
}
-
+
for (i=2; i < MAX_SPLIT_IMAGES; i++)
{
if (lw->split_images[i])
}
}
- if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 1)
+ if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 1)
{
layout_image_activate(lw, 0);
}
gtk_paned_pack1 (GTK_PANED (paned), lw->split_images[0]->widget, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (paned), lw->split_images[1]->widget, TRUE, TRUE);
-
+
gtk_widget_show (lw->split_images[0]->widget);
gtk_widget_show (lw->split_images[1]->widget);
-
+
lw->split_image_widget = paned;
-
+
return lw->split_image_widget;
}
GtkWidget *vpaned1;
GtkWidget *vpaned2;
gint i;
-
+
lw->split_mode = SPLIT_QUAD;
if (!lw->split_images[0])
if (lw->image)
{
gdouble sx, sy;
- image_change_fd(lw->split_images[i],
+ image_change_fd(lw->split_images[i],
image_get_fd(lw->image), image_zoom_get(lw->image));
image_get_scroll_center(lw->image, &sx, &sy);
image_set_scroll_center(lw->split_images[i], sx, sy);
}
- if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 3)
+ if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 3)
{
layout_image_activate(lw, 0);
}
gtk_paned_pack1 (GTK_PANED (hpaned), vpaned1, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (hpaned), vpaned2, TRUE, TRUE);
-
+
for (i=0; i < 4; i++)
gtk_widget_show (lw->split_images[i]->widget);
gtk_widget_show (vpaned1);
gtk_widget_show (vpaned2);
-
+
lw->split_image_widget = hpaned;
-
+
return lw->split_image_widget;
}
{
switch (mode)
{
- case SPLIT_HOR:
+ case SPLIT_HOR:
return layout_image_setup_split_hv(lw, TRUE);
case SPLIT_VERT:
return layout_image_setup_split_hv(lw, FALSE);
* menu callbacks
*-----------------------------------------------------------------------------
*/
-
-
+
+
static GtkWidget *layout_window(LayoutWindow *lw)
{
return lw->full_screen ? lw->full_screen->window : lw->window;
layout_image_full_screen_stop(lw);
ImageSplitMode mode = gtk_radio_action_get_current_value(action);
-
+
if (mode == lw->split_mode) mode = 0; /* toggle back */
layout_split_change(lw, mode);
{
if (image_osd_histogram_onoff_status(lw->image))
{
- image_osd_histogram_onoff_toggle(lw->image, 0);
+ image_osd_histogram_onoff_toggle(lw->image, 0);
layout_image_overlay_update(lw);
}
else
*-----------------------------------------------------------------------------
* select menu
*-----------------------------------------------------------------------------
- */
+ */
static void layout_menu_select_all_cb(GtkAction *action, gpointer data)
{
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_selection_to_mark(lw, mark, STM_MODE_SET);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_selection_to_mark(lw, mark, STM_MODE_RESET);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_selection_to_mark(lw, mark, STM_MODE_TOGGLE);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_mark_to_selection(lw, mark, MTS_MODE_SET);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_mark_to_selection(lw, mark, MTS_MODE_OR);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_mark_to_selection(lw, mark, MTS_MODE_AND);
}
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
mark--;
-
+
layout_mark_to_selection(lw, mark, MTS_MODE_MINUS);
}
*-----------------------------------------------------------------------------
* go menu
*-----------------------------------------------------------------------------
- */
+ */
static void layout_menu_image_first_cb(GtkAction *action, gpointer data)
{
*-----------------------------------------------------------------------------
* edit menu
*-----------------------------------------------------------------------------
- */
+ */
static void layout_menu_edit_cb(GtkAction *action, gpointer data)
{
*-----------------------------------------------------------------------------
* menu
*-----------------------------------------------------------------------------
- */
+ */
#define CB G_CALLBACK
{ "Editor7", NULL, "editor7", NULL, NULL, CB(layout_menu_edit_cb) },
{ "Editor8", NULL, "editor8", NULL, NULL, CB(layout_menu_edit_cb) },
{ "Editor9", NULL, "editor9", NULL, NULL, CB(layout_menu_edit_cb) },
-
+
{ "RotateCW", NULL, N_("_Rotate clockwise"), "bracketright", NULL, CB(layout_menu_alter_90_cb) },
{ "RotateCCW", NULL, N_("Rotate _counterclockwise"), "bracketleft", NULL, CB(layout_menu_alter_90cc_cb) },
{ "Rotate180", NULL, N_("Rotate 1_80"), "<shift>R", NULL, CB(layout_menu_alter_180_cb) },
static GtkToggleActionEntry menu_toggle_entries[] = {
{ "Thumbnails", NULL, N_("_Thumbnails"), "T", NULL, CB(layout_menu_thumb_cb) },
- { "ShowMarks", NULL, N_("Show _Marks"), "M", NULL, CB(layout_menu_marks_cb) },
+ { "ShowMarks", NULL, N_("Show _Marks"), "M", NULL, CB(layout_menu_marks_cb) },
{ "FloatTools", NULL, N_("_Float file list"), "L", NULL, CB(layout_menu_float_cb) },
{ "HideToolbar", NULL, N_("Hide tool_bar"), NULL, NULL, CB(layout_menu_toolbar_cb) },
{ "SBarKeywords", NULL, N_("_Keywords"), "<control>K", NULL, CB(layout_menu_bar_info_cb) },
"<ui>"
" <menubar name='MainMenu'>"
" <menu action='SelectMenu'>");
-
+
for (mark = 1; mark <= FILEDATA_MARKS_SIZE; mark++)
{
layout_actions_setup_mark(lw, mark, "Mark%d", _("Mark _%d"), NULL, NULL);
*-----------------------------------------------------------------------------
* toolbar
*-----------------------------------------------------------------------------
- */
+ */
static void layout_button_thumb_cb(GtkWidget *widget, gpointer data)
{
static void layout_bar_info_new(LayoutWindow *lw)
{
if (!lw->utility_box) return;
-
+
lw->bar_info = bar_info_new(layout_image_get_fd(lw), FALSE, lw->utility_box);
bar_info_set_selection_func(lw->bar_info, layout_bar_info_list_cb, lw);
bar_info_selection(lw->bar_info, layout_selection_count(lw, NULL) - 1);
gtk_box_pack_start(GTK_BOX(lw->utility_box), lw->bar_info, FALSE, FALSE, 0);
gtk_widget_show(lw->bar_info);
}
-
+
static void layout_bar_info_close(LayoutWindow *lw)
{
if (lw->bar_info)
G_CALLBACK(layout_bar_exif_destroyed), lw);
g_signal_connect(G_OBJECT(lw->bar_exif), "size_allocate",
G_CALLBACK(layout_bar_exif_sized), lw);
- lw->bar_exif_enabled = TRUE;
+ lw->bar_exif_enabled = TRUE;
if (lw->bar_exif_size < 1) lw->bar_exif_size = SIDEBAR_WIDTH;
gtk_widget_set_size_request(lw->bar_exif, lw->bar_exif_size, -1);
bar_exif_close(lw->bar_exif);
lw->bar_exif = NULL;
}
- lw->bar_exif_enabled = FALSE;
+ lw->bar_exif_enabled = FALSE;
}
void layout_bar_exif_toggle(LayoutWindow *lw)
*-----------------------------------------------------------------------------
* misc (public)
*-----------------------------------------------------------------------------
- */
+ */
GtkWidget *window_new(GtkWindowType type, const gchar *name, const gchar *icon,
const gchar *icon_file, const gchar *subtitle)
window = gtk_window_new(type);
if (!window) return NULL;
-
+
if (subtitle)
{
title = g_strdup_printf("%s - %s", subtitle, GQ_APPNAME);
{
title = g_strdup_printf("%s", GQ_APPNAME);
}
-
+
gtk_window_set_title(GTK_WINDOW(window), title);
g_free(title);
static struct timeval delta = {0, 0};
gettimeofday(&tv, NULL);
-
+
if (start_tv.tv_sec == 0) start_tv = tv;
-
+
tv.tv_sec -= start_tv.tv_sec;
- if (tv.tv_usec >= start_tv.tv_usec)
+ if (tv.tv_usec >= start_tv.tv_usec)
tv.tv_usec -= start_tv.tv_usec;
else
{
started = 1;
g_snprintf(timestr, sizeof(timestr), "%5d.%06d (+%05d.%06d)", (int)tv.tv_sec, (int)tv.tv_usec, (int)delta.tv_sec, (int)delta.tv_usec);
-
+
return timestr;
}
*-----------------------------------------------------------------------------
* help window
*-----------------------------------------------------------------------------
- */
+ */
static GtkWidget *help_window = NULL;
{
gchar *title = g_strdup_printf("%s - %s", _("Help"), GQ_APPNAME);
help_window = help_window_new(title, GQ_WMCLASS, "help",
- GQ_HELPDIR "/README", key);
+ GQ_HELPDIR "/README", key);
g_free(title);
}
g_signal_connect(G_OBJECT(help_window), "destroy",
{ "-n", "--next", gr_image_next, FALSE, FALSE, N_("next image") },
{ "-b", "--back", gr_image_prev, FALSE, FALSE, N_("previous image") },
{ NULL, "--first", gr_image_first, FALSE, FALSE, N_("first image") },
- { NULL, "--last", gr_image_last, FALSE, FALSE, N_("last image") },
+ { NULL, "--last", gr_image_last, FALSE, FALSE, N_("last image") },
{ "-f", "--fullscreen", gr_fullscreen_toggle, FALSE, TRUE, N_("toggle full screen") },
{ "-fs","--fullscreen-start", gr_fullscreen_start, FALSE, FALSE, N_("start full screen") },
{ "-fS","--fullscreen-stop", gr_fullscreen_stop, FALSE, FALSE, N_("stop full screen") },
*-----------------------------------------------------------------------------
* command line parser (private) hehe, who needs popt anyway?
*-----------------------------------------------------------------------------
- */
+ */
static gint startup_blank = FALSE;
static gint startup_full_screen = FALSE;
static void parse_command_line_add_file(const gchar *file_path, gchar **path, gchar **file,
- GList **list, GList **collection_list)
+ GList **list, GList **collection_list)
{
gchar *path_parsed;
static void parse_command_line_process_dir(const gchar *dir, gchar **path, gchar **file,
GList **list, gchar **first_dir)
{
-
+
if (!*list && !*first_dir)
{
*first_dir = g_strdup(dir);
static void parse_command_line_process_file(const gchar *file_path, gchar **path, gchar **file,
GList **list, GList **collection_list, gchar **first_dir)
{
-
+
if (*first_dir)
{
parse_command_line_add_dir(*first_dir, path, file, list);
#endif
print_term(_(" -v, --version print version info\n"));
print_term(_(" -h, --help show this message\n\n"));
-
+
#if 0
/* these options are not officially supported!
* only for testing new features, no need to translate them */
print_term( " --alternate use alternate similarity algorithm\n");
#endif
-
+
exit (0);
}
else if (!remote_do)
if (argc > 1)
{
gint i;
-
+
for (i = 1; i < argc; i++)
{
const gchar *cmd_line = argv[i];
*-----------------------------------------------------------------------------
* startup, init, and exit
*-----------------------------------------------------------------------------
- */
+ */
#define RC_HISTORY_NAME "history"
if (!isdir(buf))
{
printf_term(_("Creating %s dir:%s\n"), GQ_APPNAME, buf);
-
+
if (!mkdir_utf8(buf, 0755))
{
printf_term(_("Could not create dir:%s\n"), buf);
/* init execution time counter*/
get_exec_time();
-
+
/* setup locale, i18n */
gtk_set_locale();
bindtextdomain(PACKAGE, GQ_LOCALEDIR);
textdomain(PACKAGE);
/* setup random seed for random slideshow */
- srand(time(NULL));
+ srand(time(NULL));
#if 1
printf("%s %s, This is an alpha release.\n", GQ_APPNAME, VERSION);
keys_load();
filter_add_defaults();
filter_rebuild();
-
+
buf = g_strconcat(homedir(), "/", GQ_RC_DIR, "/accels", NULL);
bufl = path_from_utf8(buf);
gtk_accel_map_load(bufl);
#define DEFAULT_OVERLAY_INFO "%collection%(%number%/%total%) [%zoom%] <b>%name%</b>\n" \
- "%res%|%date%|%size%\n" \
+ "%res%|%date%|%size%\n" \
"%fAperture%|%fShutterSpeed%|%fISOSpeedRating%|%fFocalLength%|%fExposureBias%\n" \
"%fCamera%|%fFlash%" \
/*
* Note: this code is harmless on little-endian machines.
*/
-static void
+static void
_byte_reverse (guchar *buf, guint32 longs)
{
guint32 t;
/**
* md5_init: Initialise an md5 context object
- * @ctx: md5 context
- *
- * Initialise an md5 buffer.
+ * @ctx: md5 context
+ *
+ * Initialise an md5 buffer.
*
**/
-void
+void
md5_init (MD5Context *ctx)
{
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
-
+
ctx->bits[0] = 0;
ctx->bits[1] = 0;
-
- if (IS_BIG_ENDIAN())
- ctx->doByteReverse = 1;
- else
- ctx->doByteReverse = 0;
+
+ if (IS_BIG_ENDIAN())
+ ctx->doByteReverse = 1;
+ else
+ ctx->doByteReverse = 0;
}
* @ctx: conetxt object used for md5 computaion
* @buf: buffer to add
* @len: buffer length
- *
+ *
* Update context to reflect the concatenation of another buffer full
* of bytes. Use this to progressively construct an md5 hash.
**/
-void
+void
md5_update (MD5Context *ctx, const guchar *buf, guint32 len)
{
guint32 t;
-
+
/* Update bitcount */
-
+
t = ctx->bits[0];
if ((ctx->bits[0] = t + ((guint32) len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
-
+
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
-
+
/* Handle any leading odd-sized chunks */
-
+
if (t) {
guchar *p = (guchar *) ctx->in + t;
-
+
t = 64 - t;
if (len < t) {
memcpy (p, buf, len);
len -= t;
}
/* Process data in 64-byte chunks */
-
+
while (len >= 64) {
memcpy (ctx->in, buf, 64);
if (ctx->doByteReverse)
buf += 64;
len -= 64;
}
-
+
/* Handle any remaining bytes of data. */
-
+
memcpy (ctx->in, buf, len);
}
/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
/**
* md5_final: copy the final md5 hash to a bufer
* @digest: 16 bytes buffer
* @ctx: context containing the calculated md5
- *
+ *
* copy the final md5 hash to a bufer
**/
-void
+void
md5_final (MD5Context *ctx, guchar digest[16])
{
guint32 count;
guchar *p;
-
+
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
-
+
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
-
+
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
-
+
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
if (ctx->doByteReverse)
_byte_reverse (ctx->in, 16);
md5_transform (ctx->buf, (guint32 *) ctx->in);
-
+
/* Now fill the next block with 56 bytes */
memset (ctx->in, 0, 56);
} else {
}
if (ctx->doByteReverse)
_byte_reverse (ctx->in, 14);
-
+
/* Append length in bits and transform */
((guint32 *) ctx->in)[14] = ctx->bits[0];
((guint32 *) ctx->in)[15] = ctx->bits[1];
-
+
md5_transform (ctx->buf, (guint32 *) ctx->in);
if (ctx->doByteReverse)
_byte_reverse ((guchar *) ctx->buf, 4);
* reflect the addition of 16 longwords of new data. md5_Update blocks
* the data and converts bytes into longwords for this routine.
*/
-static void
+static void
md5_transform (guint32 buf[4], const guint32 in[16])
{
register guint32 a, b, c, d;
-
+
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
-
+
MD5STEP (F1, a, b, c, d, in[0] + 0xd76aa478, 7);
MD5STEP (F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
MD5STEP (F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5STEP (F1, d, a, b, c, in[13] + 0xfd987193, 12);
MD5STEP (F1, c, d, a, b, in[14] + 0xa679438e, 17);
MD5STEP (F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
+
MD5STEP (F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5STEP (F2, d, a, b, c, in[6] + 0xc040b340, 9);
MD5STEP (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
MD5STEP (F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
MD5STEP (F2, c, d, a, b, in[7] + 0x676f02d9, 14);
MD5STEP (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
+
MD5STEP (F3, a, b, c, d, in[5] + 0xfffa3942, 4);
MD5STEP (F3, d, a, b, c, in[8] + 0x8771f681, 11);
MD5STEP (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
MD5STEP (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
MD5STEP (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
MD5STEP (F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
+
MD5STEP (F4, a, b, c, d, in[0] + 0xf4292244, 6);
MD5STEP (F4, d, a, b, c, in[7] + 0x432aff97, 10);
MD5STEP (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
MD5STEP (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
MD5STEP (F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
MD5STEP (F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
+
buf[0] += a;
buf[1] += b;
buf[2] += c;
* @buffer: byte buffer
* @buffer_size: buffer size (in bytes)
* @digest: 16 bytes buffer receiving the hash code.
- *
- * Get the md5 hash of a buffer. The result is put in
+ *
+ * Get the md5 hash of a buffer. The result is put in
* the 16 bytes buffer @digest .
**/
void
md5_get_digest (const guchar *buffer, gint buffer_size, guchar digest[16])
-{
+{
MD5Context ctx;
md5_init (&ctx);
md5_update (&ctx, buffer, buffer_size);
md5_final (&ctx, digest);
-
+
}
/* modified for GQView, starting here */
* @filename: file name
* @digest: 16 bytes buffer receiving the hash code.
* @return: TRUE on success
- *
- * Get the md5 hash of a file. The result is put in
+ *
+ * Get the md5 hash of a file. The result is put in
* the 16 bytes buffer @digest .
**/
gboolean md5_get_digest_from_file(const gchar *path, guchar digest[16])
-{
+{
MD5Context ctx;
guchar tmp_buf[1024];
gint nb_bytes_read;
if (!fp) return FALSE;
md5_init(&ctx);
-
+
while ((nb_bytes_read = fread (tmp_buf, sizeof (guchar), sizeof(tmp_buf), fp)) > 0)
{
md5_update (&ctx, tmp_buf, nb_bytes_read);
}
-
+
success = (ferror(fp) == 0);
fclose(fp);
if (!success) return FALSE;
*-----------------------------------------------------------------------------
* menu utils
*-----------------------------------------------------------------------------
- */
+ */
static GtkWidget *add_menu_item(GtkWidget *menu, gchar *label, GtkAccelGroup *accel_group,
guint accel_key, guint accel_mods, GCallback func, gpointer data)
*-----------------------------------------------------------------------------
* edit menu
*-----------------------------------------------------------------------------
- */
+ */
static void add_edit_items(GtkWidget *menu, GCallback func, GtkAccelGroup *accel_grp)
{
{
add_menu_item(menu, alter_type_get_text(type), accel_group,
accel_key, accel_mods, func, GINT_TO_POINTER((gint)type));
-
+
}
else
{
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 ||
char fake_path[20];
dt = pan_date_to_time(year, month, day);
-
- /*
- * Create a FileData entry that represents the given day.
+
+ /*
+ * Create a FileData entry that represents the given day.
* It does not correspond to any real file
- */
-
- g_snprintf(fake_path, sizeof(fake_path), "//%04d-%02d-%02d", year, month, day);
+ */
+
+ g_snprintf(fake_path, sizeof(fake_path), "//%04d-%02d-%02d", year, month, day);
fd = file_data_new_simple(fake_path);
fd->date = dt;
pi_day = pan_item_box_new(pw, fd, x, y, PAN_CAL_DAY_WIDTH, PAN_CAL_DAY_HEIGHT,
{
PangoAttrList *pal;
PangoAttribute *pa;
-
+
pal = pango_attr_list_new();
if (pi->text_attr & PAN_TEXT_ATTR_BOLD)
{
*-----------------------------------------------------------------------------
* misc
*-----------------------------------------------------------------------------
- */
+ */
static void pan_window_message(PanWindow *pw, const gchar *text)
{
while (needle)
{
PanCacheData *pc;
-
+
pc = needle->data;
if (pc->fd == fd)
{
gchar *text;
if (ExifUIList[i].current == EXIF_UI_OFF) continue;
-
+
text = exif_get_data_as_text(exif, ExifUIList[i].key);
text = bar_exif_validate_text(text);
if (ExifUIList[i].current == EXIF_UI_IFSET && (!text || !*text))
*-----------------------------------------------------------------------------
* main window
*-----------------------------------------------------------------------------
- */
+ */
static void button_cb(PixbufRenderer *pr, GdkEventButton *event, gpointer data)
{
gtk_window_set_geometry_hints(GTK_WINDOW(pw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(pw->window), TRUE);
- gtk_container_set_border_width(GTK_CONTAINER(pw->window), 0);
+ gtk_container_set_border_width(GTK_CONTAINER(pw->window), 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(pw->window), vbox);
group = pref_box_new(group, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
- options->thumbnails.enable_caching, &options->thumbnails.enable_caching);
+ options->thumbnails.enable_caching, &options->thumbnails.enable_caching);
button = pref_checkbox_new_int(group, _("Use shared thumbnail cache"),
options->thumbnails.spec_standard, &options->thumbnails.spec_standard);
pref_checkbox_link_sensitivity(ct_button, button);
menu_item_add_check(menu, _("_Show Exif information"), pw->info_includes_exif,
G_CALLBACK(pan_info_toggle_exif_cb), pw);
item = menu_item_add(menu, _("Show im_age"), NULL, NULL);
- submenu = gtk_menu_new();
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
+ submenu = gtk_menu_new();
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
item = menu_item_add_check(submenu, _("_None"), (pw->info_image_size == PAN_IMAGE_SIZE_THUMB_NONE),
G_CALLBACK(pan_info_toggle_image_cb), pw);
item = menu_item_add_check(submenu, _("1:10 (10%)"), (pw->info_image_size == PAN_IMAGE_SIZE_10),
G_CALLBACK(pan_info_toggle_image_cb), pw);
g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_10));
-
-
+
+
menu_item_add_divider(menu);
gtk_drag_dest_set(widget,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
dnd_file_drop_types, dnd_file_drop_types_count,
- GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
+ GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(widget), "drag_data_received",
G_CALLBACK(pan_window_get_dnd_data), pw);
}
#ifdef GQ_BUILD
#include "pixbuf_util.h"
-
+
/* for debug */
#include "main.h"
#endif
150,
100,
G_PARAM_READABLE | G_PARAM_WRITABLE));
-
+
g_object_class_install_property(gobject_class,
PROP_AUTOFIT_LIMIT,
g_param_spec_boolean("autofit_limit",
G_PARAM_READABLE | G_PARAM_WRITABLE));
- signals[SIGNAL_ZOOM] =
+ signals[SIGNAL_ZOOM] =
g_signal_new("zoom",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
- signals[SIGNAL_CLICKED] =
+ signals[SIGNAL_CLICKED] =
g_signal_new("clicked",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT);
- signals[SIGNAL_SCROLL_NOTIFY] =
+ signals[SIGNAL_SCROLL_NOTIFY] =
g_signal_new("scroll-notify",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- signals[SIGNAL_RENDER_COMPLETE] =
+ signals[SIGNAL_RENDER_COMPLETE] =
g_signal_new("render-complete",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- signals[SIGNAL_DRAG] =
+ signals[SIGNAL_DRAG] =
g_signal_new("drag",
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
}
gint pixbuf_renderer_overlay_add(PixbufRenderer *pr, GdkPixbuf *pixbuf, gint x, gint y,
- gint relative, gint always)
+ gint relative, gint always)
{
OverlayData *od;
gint id;
it->size += size;
pr->tile_cache_size += size;
}
-
- if ((pr->zoom != 1.0 || pr->source_tiles_enabled || (pr->pixbuf && gdk_pixbuf_get_has_alpha(pr->pixbuf)) ||
+
+ if ((pr->zoom != 1.0 || pr->source_tiles_enabled || (pr->pixbuf && gdk_pixbuf_get_has_alpha(pr->pixbuf)) ||
pr->orientation != EXIF_ORIENTATION_TOP_LEFT || pr->func_post_process) && !it->pixbuf)
{
GdkPixbuf *pixbuf;
* drawing
*-------------------------------------------------------------------
*/
-
+
static void pr_tile_coords_map_orientation(PixbufRenderer *pr,
- double tile_x, double tile_y, /* coordinates of the tile */
- gint image_w, gint image_h,
+ double tile_x, double tile_y, /* coordinates of the tile */
+ gint image_w, gint image_h,
double tile_w, double tile_h,
double *res_x, double *res_y)
{
/* The other values are out of range */
break;
}
-// printf("tile coord y:%f, ih:%d, th:%f ry:%f\n", tile_y, image_h, tile_h, *res_x);
-}
+// printf("tile coord y:%f, ih:%d, th:%f ry:%f\n", tile_y, image_h, tile_h, *res_x);
+}
static void pr_tile_region_map_orientation(PixbufRenderer *pr,
gint area_x, gint area_y, /* coordinates of the area inside tile */
/* The other values are out of range */
break;
}
-// printf("inside y:%d, th:%d, ah:%d ry:%d\n", area_y, tile_h, area_h, *res_x);
-}
+// printf("inside y:%d, th:%d, ah:%d ry:%d\n", area_y, tile_h, area_h, *res_x);
+}
static void pr_coords_map_orientation_reverse(PixbufRenderer *pr,
gint area_x, gint area_y,
/* The other values are out of range */
break;
}
-}
+}
static GdkPixbuf *pr_get_spare_tile(PixbufRenderer *pr)
guchar *ip, *spi, *dpi;
gint i, j;
gint tw = pr->tile_width;
-
+
srs = gdk_pixbuf_get_rowstride(src);
s_pix = gdk_pixbuf_get_pixels(src);
spi = s_pix + (x * COLOR_BYTES);
sp += COLOR_BYTES;
}
}
-
+
pr->spare_tile = src;
*tile = dest;
}
guchar *ip, *spi, *dpi;
gint i, j;
gint th = pr->tile_height;
-
+
srs = gdk_pixbuf_get_rowstride(src);
s_pix = gdk_pixbuf_get_pixels(src);
spi = s_pix + (x * COLOR_BYTES);
sp += COLOR_BYTES;
}
}
-
+
pr->spare_tile = src;
*tile = dest;
}
dp -= COLOR_BYTES;
}
}
-
+
pr->spare_tile = src;
*tile = dest;
}
double src_x, src_y;
gint pb_x, pb_y;
gint pb_w, pb_h;
- pr_tile_coords_map_orientation(pr, it->x, it->y,
- pr->image_width, pr->image_height,
+ pr_tile_coords_map_orientation(pr, it->x, it->y,
+ pr->image_width, pr->image_height,
pr->tile_width, pr->tile_height,
&src_x, &src_y);
- pr_tile_region_map_orientation(pr, x, y,
+ pr_tile_region_map_orientation(pr, x, y,
pr->tile_width, pr->tile_height,
w, h,
&pb_x, &pb_y,
}
else
{
-
-
+
+
if (pr->orientation == EXIF_ORIENTATION_TOP_LEFT && !(pr->func_post_process && !(pr->post_process_slow && fast)))
{
/* faster, simple, base orientation, no postprocessing */
else
{
gdk_pixbuf_copy_area(pr->pixbuf,
- src_x + pb_x, src_y + pb_y,
+ src_x + pb_x, src_y + pb_y,
pb_w, pb_h,
it->pixbuf,
pb_x, pb_y);
scale_x = (double)pr->width / pr->image_width;
scale_y = (double)pr->height / pr->image_height;
- pr_tile_coords_map_orientation(pr, it->x / scale_x, it->y /scale_y ,
- pr->image_width, pr->image_height,
+ pr_tile_coords_map_orientation(pr, it->x / scale_x, it->y /scale_y ,
+ pr->image_width, pr->image_height,
pr->tile_width / scale_x , pr->tile_height / scale_y,
&src_x, &src_y);
- pr_tile_region_map_orientation(pr, x, y,
+ pr_tile_region_map_orientation(pr, x, y,
pr->tile_width, pr->tile_height,
w, h,
&pb_x, &pb_y,
if (draw && it->pixbuf && !it->blank)
{
-
+
if (pr->func_post_process && !(pr->post_process_slow && fast))
pr->func_post_process(pr, &it->pixbuf, x, y, w, h, pr->post_process_user_data);
-
+
gdk_draw_pixbuf(it->pixmap,
box->style->fg_gc[GTK_WIDGET_STATE(box)],
it->pixbuf,
h = h * factor + 0.5;
scale = scale * factor;
}
-
+
if (w < 1) w = 1;
if (h < 1) h = 1;
}
void pixbuf_renderer_get_scroll_center(PixbufRenderer *pr, gdouble *x, gdouble *y)
{
gint src_x, src_y;
-
+
src_x = pr->x_scroll + pr->vis_width / 2;
src_y = pr->y_scroll + pr->vis_height / 2;
pr->subpixel_x_scroll = dst_x - (int)dst_x;
pr->subpixel_y_scroll = dst_y - (int)dst_y;
-
+
pixbuf_renderer_scroll(pr, (int)dst_x, (int)dst_y);
}
return;
}
-
+
pr_pixbuf_size_sync(pr);
pr_zoom_sync(pr, zoom, TRUE, TRUE, FALSE, 0, 0);
}
void pixbuf_renderer_set_post_process_func(PixbufRenderer *pr, PixbufRendererPostProcessFunc func, gpointer user_data, gint slow)
{
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
-
+
pr->func_post_process = func;
pr->post_process_user_data = user_data;
pr->post_process_slow = func && slow;
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
- pr_coords_map_orientation_reverse(pr,
+ pr_coords_map_orientation_reverse(pr,
src_x, src_y,
pr->image_width, pr->image_height,
src_w, src_h,
PixbufRendererTileRequestFunc func_tile_request;
PixbufRendererTileDisposeFunc func_tile_dispose;
-
+
gpointer func_tile_data;
PixbufRendererPostProcessFunc func_post_process;
GdkPixmap *overlay_buffer;
GdkPixbuf *spare_tile;
-
+
gint orientation;
};
if (bytes_per_pixel == 4) *(dp) = *(sp++); /* a */
}
}
-
+
}
static void pixbuf_copy_block(guchar *src, gint src_row_stride, gint w, gint h,
gint sw, sh, srs;
gint dw, dh, drs;
guchar *s_pix;
- guchar *d_pix;
+ guchar *d_pix;
#if 0
guchar *sp;
- guchar *dp;
+ guchar *dp;
#endif
gint i, j;
gint a;
GdkPixbuf *buffer;
- guchar *b_pix;
+ guchar *b_pix;
gint brs;
gint w, h;
gint w, h, srs;
gint drs;
guchar *s_pix;
- guchar *d_pix;
+ guchar *d_pix;
guchar *sp;
- guchar *dp;
+ guchar *dp;
gint i, j;
gint a;
prs = gdk_pixbuf_get_rowstride(pb);
p_pix = gdk_pixbuf_get_pixels(pb);
- for (i = 0; i < h; i++)
+ for (i = 0; i < h; i++)
{
pp = p_pix + (y + i) * prs + (x * (p_alpha ? 4 : 3));
for (j = 0; j < w; j++)
prs = gdk_pixbuf_get_rowstride(pb);
p_pix = gdk_pixbuf_get_pixels(pb);
- for (i = 0; i < h; i++)
+ for (i = 0; i < h; i++)
{
pp = p_pix + (y + i) * prs + (x * (p_alpha ? 4 : 3));
for (j = 0; j < w; j++)
guchar *p;
if (x < 0 || x >= gdk_pixbuf_get_width(pb) ||
- y < 0 || y >= gdk_pixbuf_get_height(pb)) return;
+ y < 0 || y >= gdk_pixbuf_get_height(pb)) return;
buf = gdk_pixbuf_get_pixels(pb);
has_alpha = gdk_pixbuf_get_has_alpha(pb);
rowstride = gdk_pixbuf_get_rowstride(pb);
- p = buf + (y * rowstride) + (x * (has_alpha ? 4 : 3));
+ p = buf + (y * rowstride) + (x * (has_alpha ? 4 : 3));
*p = r; p++;
*p = g; p++;
*p = b; p++;
static void pixbuf_draw_fade_linear(guchar *p_pix, gint prs, gint p_alpha,
gint s, gint vertical, gint border,
- gint x1, gint y1, gint x2, gint y2,
+ gint x1, gint y1, gint x2, gint y2,
guint8 r, guint8 g, guint8 b, guint8 a)
{
guchar *pp;
static void pixbuf_draw_fade_radius(guchar *p_pix, gint prs, gint p_alpha,
gint sx, gint sy, gint border,
- gint x1, gint y1, gint x2, gint y2,
+ gint x1, gint y1, gint x2, gint y2,
guint8 r, guint8 g, guint8 b, guint8 a)
{
guchar *pp;
prs = gdk_pixbuf_get_rowstride(pb);
p_pix = gdk_pixbuf_get_pixels(pb);
- for (i = 0; i < h; i++)
+ for (i = 0; i < h; i++)
{
pp = p_pix + (y + i) * prs + (x * (p_alpha ? 4 : 3));
for (j = 0; j < w; j++)
*-----------------------------------------------------------------------------
* option widget callbacks (private)
*-----------------------------------------------------------------------------
- */
+ */
static void startup_path_set_current(GtkWidget *widget, gpointer data)
{
*-----------------------------------------------------------------------------
* sync progam to config window routine (private)
*-----------------------------------------------------------------------------
- */
+ */
static void config_window_apply(void)
{
options->collections.rectangular_selection = c_options->collections.rectangular_selection;
options->image.tile_cache_max = c_options->image.tile_cache_max;
-
+
options->image.read_buffer_size = c_options->image.read_buffer_size;
options->image.idle_read_loop_count = c_options->image.idle_read_loop_count;
*-----------------------------------------------------------------------------
* config window main button callbacks (private)
*-----------------------------------------------------------------------------
- */
+ */
static void config_window_close_cb(GtkWidget *widget, gpointer data)
{
*-----------------------------------------------------------------------------
* config window setup (private)
*-----------------------------------------------------------------------------
- */
+ */
static void exif_item_cb(GtkWidget *combo, gpointer data)
{
*option = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
}
-static void exif_item(GtkWidget *table, gint column, gint row,
+static void exif_item(GtkWidget *table, gint column, gint row,
const gchar *text, gint option, gint *option_c)
{
GtkWidget *combo;
combo = gtk_combo_box_new_text();
- /* note: the order is important, it must match the values of
+ /* note: the order is important, it must match the values of
* EXIF_UI_OFF, _IFSET, _ON */
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Never"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("If set"));
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(exif_item_cb), option_c);
- gtk_table_attach(GTK_TABLE(table), combo,
+ gtk_table_attach(GTK_TABLE(table), combo,
column + 1, column + 2, row, row + 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show(combo);
buf = g_strdup_printf("%d x %d", w, h);
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), buf);
g_free(buf);
-
+
if (w == options->thumbnails.max_width && h == options->thumbnails.max_height) current = i;
}
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_ENABLE), NULL);
-
+
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_ext_edit_cb), filter_store);
if (i < GQ_EDITOR_GENERIC_SLOTS)
{
gchar *buf;
-
+
buf = g_strdup_printf("%d", i+1);
pref_table_label(table, 0, i+1, buf, 1.0);
g_free(buf);
entry = gtk_label_new(options->editor_name[i]);
gtk_misc_set_alignment(GTK_MISC(entry), 0.0, 0.5);
}
-
+
gtk_table_attach(GTK_TABLE (table), entry, 1, 2, i+1, i+2,
GTK_FILL | GTK_SHRINK, 0, 0, 0);
gtk_widget_show(entry);
gtk_container_add(GTK_CONTAINER(viewport), vbox);
gtk_widget_show(vbox);
- group = pref_group_new(vbox, FALSE, _("Exif"),
+ group = pref_group_new(vbox, FALSE, _("Exif"),
GTK_ORIENTATION_VERTICAL);
-
-
+
+
pref_spacer(group, PREF_PAD_INDENT - PREF_PAD_SPACE);
label = pref_label_new(group, _("What to show in properties dialog:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
for (i = 0; ExifUIList[i].key; i++)
{
const gchar *title;
-
- title = exif_get_description_by_key(ExifUIList[i].key);
+
+ title = exif_get_description_by_key(ExifUIList[i].key);
exif_item(table, 0, i, title, ExifUIList[i].current,
&ExifUIList[i].temp);
}
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_GAP);
spin = pref_spin_new_int(hbox, _("Maximum size:"), _("MB"),
- 0, 2048, 1, options->file_ops.safe_delete_folder_maxsize, &c_options->file_ops.safe_delete_folder_maxsize);
+ 0, 2048, 1, options->file_ops.safe_delete_folder_maxsize, &c_options->file_ops.safe_delete_folder_maxsize);
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_markup(spin, _("Set to 0 for unlimited size"));
#endif
pref_spin_new_int(group, _("Offscreen cache size (Mb per image):"), NULL,
0, 128, 1, options->image.tile_cache_max, &c_options->image.tile_cache_max);
-
+
pref_spin_new_int(group, _("Image read buffer size (bytes):"), NULL,
IMAGE_LOADER_READ_BUFFER_SIZE_MIN, IMAGE_LOADER_READ_BUFFER_SIZE_MAX, 512,
options->image.read_buffer_size, &c_options->image.read_buffer_size);
-
+
pref_spin_new_int(group, _("Image idle loop read count:"), NULL,
IMAGE_LOADER_IDLE_READ_LOOP_COUNT_MIN, IMAGE_LOADER_IDLE_READ_LOOP_COUNT_MAX, 1,
options->image.idle_read_loop_count, &c_options->image.idle_read_loop_count);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT (configwindow), "delete_event",
G_CALLBACK(config_window_delete), NULL);
- gtk_window_set_default_size(GTK_WINDOW(configwindow), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
+ gtk_window_set_default_size(GTK_WINDOW(configwindow), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(configwindow), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
*-----------------------------------------------------------------------------
* config window show (public)
*-----------------------------------------------------------------------------
- */
+ */
void show_config_window(void)
{
text[6] = '\0';
fprintf(f, text);
-}
+}
static gint print_job_ps_page_image(PrintWindow *pw, GdkPixbuf *pixbuf,
gdouble x, gdouble y, gdouble w, gdouble h,
gdouble offx, gdouble offy)
dw = (gdouble)gdk_pixbuf_get_width(pw->job_pixbuf);
dh = (gdouble)gdk_pixbuf_get_height(pw->job_pixbuf);
- if (clip_region(x, y, w, h,
- 0.0, 0.0, dw, dh,
- &rx, &ry, &rw, &rh))
- {
+ if (clip_region(x, y, w, h,
+ 0.0, 0.0, dw, dh,
+ &rx, &ry, &rw, &rh))
+ {
gdk_pixbuf_composite(pixbuf, pw->job_pixbuf, rx, ry, rw, rh,
x + offx, y + offy,
w / sw, h / sh,
}
static gint print_job_preview_page_image(PrintWindow *pw, GdkPixbuf *pixbuf,
- gdouble x, gdouble y, gdouble w, gdouble h,
- gdouble offx, gdouble offy)
+ gdouble x, gdouble y, gdouble w, gdouble h,
+ gdouble offx, gdouble offy)
{
gdouble sw, sh;
gdouble dw, dh;
x = x + icon_w / 2;
y = y + icon_h + (pw->proof_height - icon_h) / 2 + PRINT_TEXT_PADDING;
- success = (success &&
+ success = (success &&
print_job_text_image(pw, pw->job_loader->fd->path, x, y, icon_w + PRINT_PROOF_MARGIN * 2, w, h, TRUE));
if (!success)
label = pref_table_label(table, 0, 1, _("Proof size:"), 1.0);
pw->proof_group = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
pref_link_sensitivity(label, pw->proof_group);
-
+
pw->proof_width_spin = pref_spin_new(pw->proof_group, NULL, NULL,
0.0, 50.0, 0.1, 3, 0.0,
G_CALLBACK(print_proof_size_cb), pw);
*-----------------------------------------------------------------------------
* line write/parse routines (private)
*-----------------------------------------------------------------------------
- */
-
-/*
+ */
+
+/*
returns text without quotes or NULL for empty or broken string
any text up to first '"' is skipped
tail is set to point at the char after the second '"'
- or at the ending \0
-
+ or at the ending \0
+
*/
gchar *quoted_value(const gchar *text, const gchar **tail)
gint c = 0;
gint l = strlen(text);
gchar *retval = NULL;
-
+
if (tail) *tail = text;
-
+
if (l == 0) return retval;
while (c < l && text[c] !='"') c++;
if (e - c > 0)
{
gchar *substring = g_strndup(ptr, e - c);
-
+
if (substring)
{
retval = g_strcompress(substring);
gchar *escquote_value(const gchar *text)
{
gchar *e;
-
+
if (!text) return g_strdup("\"\"");
e = g_strescape(text, "");
*-----------------------------------------------------------------------------
* save configuration (public)
*-----------------------------------------------------------------------------
- */
+ */
void save_options(void)
{
g_free(rc_path);
return;
}
-
+
#define WRITE_BOOL(_name_) write_bool_option(ssi, #_name_, options->_name_)
#define WRITE_INT(_name_) write_int_option(ssi, #_name_, options->_name_)
#define WRITE_UINT(_name_) write_uint_option(ssi, #_name_, options->_name_)
WRITE_CHAR(file_ops.safe_delete_path);
WRITE_INT(file_ops.safe_delete_folder_maxsize);
-
+
WRITE_SUBTITLE("Layout Options");
WRITE_INT(layout.style);
WRITE_SUBTITLE("Image Options");
-
+
secure_fprintf(ssi, "# image.zoom_mode possible values are:\n"
"# original\n"
"# fit\n"
WRITE_BOOL(file_sort.ascending);
WRITE_BOOL(file_sort.case_sensitive);
-
+
WRITE_SUBTITLE("Fullscreen Options");
WRITE_INT(fullscreen.screen);
WRITE_SEPARATOR();
filter_write_list(ssi);
-
+
WRITE_SUBTITLE("Sidecars Options");
#ifndef HAVE_LCMS
secure_fprintf(ssi, "# NOTICE: %s was not built with support for color profiles,\n"
- "# color profile options will have no effect.\n\n", GQ_APPNAME);
+ "# color profile options will have no effect.\n\n", GQ_APPNAME);
#endif
WRITE_BOOL(color_profile.enabled);
secure_fprintf(ssi, "# end of config file #\n");
secure_fprintf(ssi, "######################################################################\n");
-
+
if (secure_close(ssi))
{
printf_term(_("error saving config file: %s\nerror: %s\n"), rc_path,
*-----------------------------------------------------------------------------
* load configuration (public)
*-----------------------------------------------------------------------------
- */
+ */
void load_options(void)
{
READ_BOOL(tree_descend_subdirs);
READ_BOOL(lazy_image_sync);
READ_BOOL(update_on_time_change);
-
+
READ_BOOL(startup_path_enable);
READ_CHAR(startup_path);
READ_BOOL(enable_metadata_dirs);
READ_BOOL(mousewheel_scrolls);
-
+
READ_INT(open_recent_list_maxsize);
READ_BOOL(place_dialogs_under_mouse);
/* image options */
if (strcasecmp(option, "image.zoom_mode") == 0)
- {
- if (strcasecmp(value, "original") == 0)
+ {
+ if (strcasecmp(value, "original") == 0)
options->image.zoom_mode = ZOOM_RESET_ORIGINAL;
- else if (strcasecmp(value, "fit") == 0)
+ else if (strcasecmp(value, "fit") == 0)
options->image.zoom_mode = ZOOM_RESET_FIT_WINDOW;
- else if (strcasecmp(value, "dont_change") == 0)
+ else if (strcasecmp(value, "dont_change") == 0)
options->image.zoom_mode = ZOOM_RESET_NONE;
- }
+ }
READ_BOOL(image.zoom_2pass);
READ_BOOL(image.zoom_to_fit_allow_expand);
READ_BOOL(image.fit_window_to_image);
READ_COLOR(image.border_color);
READ_INT_CLAMP(image.read_buffer_size, IMAGE_LOADER_READ_BUFFER_SIZE_MIN, IMAGE_LOADER_READ_BUFFER_SIZE_MAX);
READ_INT_CLAMP(image.idle_read_loop_count, IMAGE_LOADER_IDLE_READ_LOOP_COUNT_MIN, IMAGE_LOADER_IDLE_READ_LOOP_COUNT_MAX);
-
+
/* thumbnails options */
READ_INT_CLAMP(thumbnails.max_width, 16, 512);
{
sidecar_ext_parse(value_all, TRUE);
}
-
+
/* Color Profiles */
READ_BOOL(color_profile.enabled);
READ_INT(color_profile.input_type);
if (strncasecmp(option, "color_profile.input_file_", 25) == 0)
- {
- i = strtol(option + 25, NULL, 0) - 1;
+ {
+ i = strtol(option + 25, NULL, 0) - 1;
if (i >= 0 && i < COLOR_PROFILE_INPUTS)
{
read_char_option(f, option, option, value, &options->color_profile.input_file[i]);
}
}
if (strncasecmp(option, "color_profile.input_name_", 25) == 0)
- {
- i = strtol(option + 25, NULL, 0) - 1;
+ {
+ i = strtol(option + 25, NULL, 0) - 1;
if (i >= 0 && i < COLOR_PROFILE_INPUTS)
{
read_char_option(f, option, option, value, &options->color_profile.input_name[i]);
i--;
g_free(options->editor_name[i]);
g_free(options->editor_command[i]);
-
+
options->editor_name[i] = quoted_value(value_all, &ptr);
options->editor_command[i] = quoted_value(ptr, NULL);
}
for (i = 0; ExifUIList[i].key; i++)
if (0 == strcasecmp(option + 13, ExifUIList[i].key))
ExifUIList[i].current = strtol(value, NULL, 10);
- }
+ }
}
fclose(f);
sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX);
strncpy(addr.sun_path, path, sun_path_len);
if (connect(fd, &addr, sizeof(addr)) == -1)
- {
+ {
if (debug) printf("error connecting to socket: %s\n", strerror(errno));
- close(fd);
- return NULL;
- }
+ close(fd);
+ return NULL;
+ }
rc = g_new0(RemoteConnection, 1);
rc->server = FALSE;
rc->path = g_strdup(path);
/* this might fix the freezes on freebsd, solaris, etc. - completely untested */
- remote_client_send(rc, "\n");
+ remote_client_send(rc, "\n");
return rc;
}
GList *clients;
};
-
-
+
+
RemoteConnection *remote_server_open(const gchar *path);
void remote_server_subscribe(RemoteConnection *rc, RemoteReadFunc *func, gpointer data);
if (list) plist = g_list_prepend(plist, file_data_ref(mfd->fd));
}
-
+
work = work->next;
}
g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
static void sr_menu_print_cb(GtkWidget *widget, gpointer data)
{
SearchData *sd = data;
-
+
print_window_new(sd->click_fd, search_result_selection_list(sd),
search_result_get_filelist(sd), sd->window);
}
break;
}
}
-
+
return stop_signal;
}
g_signal_connect(G_OBJECT(sd->result_view), "drag_end",
G_CALLBACK(search_dnd_end), sd);
#endif
-
+
}
/*
static void search_file_load_done_cb(ImageLoader *il, gpointer data)
{
- SearchData *sd = data;
+ SearchData *sd = data;
search_file_load_process(sd, sd->img_cd);
}
value = (gint)result;
}
}
-
+
if (simval) *simval = value;
}
image_loader_free(sd->img_loader);
sd->img_loader = NULL;
}
-
+
}
sd->search_idle_id = g_idle_add(search_step_cb, sd);
* more..). */
#ifndef NO_UNIX_SOFTLINKS
if (g_lstat(ssi->file_name, &st) == 0)
-#else
+#else
if (g_stat(ssi->file_name, &st) == 0)
#endif
{
#endif
if (!alternate_enabled) return;
-
+
image_sim_channel_norm(sd->avg_r, sizeof(sd->avg_r));
image_sim_channel_norm(sd->avg_g, sizeof(sd->avg_g));
image_sim_channel_norm(sd->avg_b, sizeof(sd->avg_b));
for (i = 0; i < sizeof(sd->avg_r); i++)
{
guint8 n;
-
+
n = (guint8)((gint)(sd->avg_r[i] + sd->avg_g[i] + sd->avg_b[i]) / 3);
sd->avg_r[i] = sd->avg_g[i] = sd->avg_b[i] = n;
}
typedef struct _ImageSimilarityData ImageSimilarityData;
struct _ImageSimilarityData
{
- guint8 avg_r[1024];
- guint8 avg_g[1024];
- guint8 avg_b[1024];
+ guint8 avg_r[1024];
+ guint8 avg_g[1024];
+ guint8 avg_b[1024];
- gint filled;
+ gint filled;
};
gchar *cache_dir;
gint success = FALSE;
mode_t mode = 0755;
-
+
if (!tl) return FALSE;
cache_dir = cache_get_location(CACHE_TYPE_THUMB, tl->path, FALSE, &mode);
void thumb_loader_set_cache(ThumbLoader *tl, gint enable_cache, gint local, gint retry_failed)
{
- if (!tl) return;
+ if (!tl) return;
if (tl->standard_loader)
{
{
thumb_loader_mark_failure(tl);
}
-
+
image_loader_free(tl->il);
tl->il = NULL;
return FALSE;
pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_NEAREST);
gdk_pixbuf_unref(tmp);
}
-
+
return pixbuf;
}
}
folder = (tm->pass == 1) ? THUMB_FOLDER_NORMAL : THUMB_FOLDER_LARGE;
-
+
g_free(tm->thumb_path);
tm->thumb_path = thumb_std_cache_path(tm->source, tm->source_uri, FALSE, folder);
tm->tl = thumb_loader_std_thumb_file_validate(tm->thumb_path, 0,
ImageWindow *image;
ImageWindow *split_images[MAX_SPLIT_IMAGES];
- ImageSplitMode split_mode;
+ ImageSplitMode split_mode;
gint active_split_image;
- GtkWidget *split_image_widget;
-
+ GtkWidget *split_image_widget;
+
gint connect_zoom, connect_scroll;
-
+
/* tools window (float) */
GtkWidget *tools;
GtkWidget *thumb_button;
gint thumbs_enabled;
gint marks_enabled;
-
+
/* dir view */
LayoutLocation dir_location;
void (*dnd_drop_update_func)(ViewDir *vd);
void (*dnd_drop_leave_func)(ViewDir *vd);
-
+
LayoutWindow *layout;
GtkWidget *popup;
gint thumbs_enabled;
gint marks_enabled;
gint active_mark;
-
+
/* thumb updates */
gint thumbs_running;
gint thumbs_count;
gint sync_idle_id;
/* thumbs */
-
+
gint thumbs_running;
GList *thumbs_list;
gint thumbs_count;
/* file ops */
struct {
gint enable_in_place_rename;
-
+
gint confirm_delete;
gint enable_delete_key;
gint safe_delete_enable;
gint view_as_icons;
DirViewType dir_view_type;
-
+
gint show_thumbnails;
gint show_marks;
{
return g_strdup_printf("%s"MARKER_PATH"%s"MARKER_ICON"%s", name, path, icon);
}
-
+
return g_strdup_printf("%s"MARKER_PATH"%s", name, path);
}
GtkWidget *table;
GtkWidget *label;
const gchar *icon;
-
+
if (!key) key = "bookmarks";
p = g_new0(BookPropData, 1);
icon = p->bb->icon;
if (!icon) icon = "";
label = tab_completion_new_with_history(&p->icon_entry, icon,
- "bookmark_icons", -1, NULL, NULL);
+ "bookmark_icons", -1, NULL, NULL);
tab_completion_add_select_button(p->icon_entry, _("Select icon"), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3);
generic_dialog_attach_default(gd, p->icon_entry);
static void bookmark_menu_remove_cb(GtkWidget *widget, gpointer data)
{
BookMarkData *bm = data;
-
+
if (!bm->active_button) return;
history_list_item_remove(bm->key, bm->active_button->key);
if (event->button != 3) return FALSE;
bookmark_menu_popup(bm, button, event->button, event->time, FALSE);
-
+
return TRUE;
}
b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
if (!b) return;
-
+
list = g_list_append(list, b->path);
switch (info)
gint x, y;
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
- button->allocation.width, button->allocation.height);
+ button->allocation.width, button->allocation.height);
gdk_pixbuf_get_from_drawable(pixbuf, button->window, NULL,
button->allocation.x, button->allocation.y,
0, 0, button->allocation.width, button->allocation.height);
gdk_window_get_pointer(button->window, &x, &y, &mask);
gtk_drag_set_icon_pixbuf(context, pixbuf,
- x - button->allocation.x, y - button->allocation.y);
+ x - button->allocation.x, y - button->allocation.y);
g_object_unref(pixbuf);
}
GtkBox *box;
GList *work;
GList *children;
-
+
box = GTK_BOX(bm->box);
children = gtk_container_get_children(GTK_CONTAINER(box));
work = children;
while (work && work->next)
{
gchar *name;
-
+
name = work->data;
work = work->next;
path = work->data;
else
{
b->image = gtk_image_new_from_stock(GTK_STOCK_MISSING_IMAGE,
- GTK_ICON_SIZE_BUTTON);
+ GTK_ICON_SIZE_BUTTON);
}
}
else
static void bookmark_populate_all(const gchar *key)
{
GList *work;
-
+
if (!key) return;
-
+
work = bookmark_widget_list;
while (work)
{
{
GtkWidget *scrolled;
BookMarkData *bm;
-
+
if (!key) key = "bookmarks";
bm = g_new0(BookMarkData, 1);
*/
static gint escape_char_list[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0 */
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 */
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 10 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 */
/* spc ! " # $ % & ' */
1, 1, 0, 0, 1, 1, 0, 1, 0, 0, /* 30 */
const gchar *p;
if (!text) return NULL;
-
+
string = g_string_new("");
p = text;
*-----------------------------------------------------------------------------
* generic file information and manipulation routines (public)
*-----------------------------------------------------------------------------
- */
+ */
gint isdir(const gchar *s)
{
struct stat st;
-
+
return (stat_utf8(s ,&st) && S_ISDIR(st.st_mode));
}
gint islink(const gchar *s)
{
struct stat st;
-
+
return (lstat_utf8(s ,&st) && S_ISLNK(st.st_mode));
}
gint64 filesize(const gchar *s)
{
struct stat st;
-
+
if (!stat_utf8(s, &st)) return 0;
return (gint)st.st_size;
}
time_t filetime(const gchar *s)
{
- struct stat st;
+ struct stat st;
if (!stat_utf8(s, &st)) return 0;
return st.st_mtime;
while (work)
{
gchar *path;
-
+
path = work->data;
work = work->next;
-
+
new_list = g_list_prepend(new_list, g_strdup(path));
}
-
+
return g_list_reverse(new_list);
}
gchar *msg = g_strdup_printf(__VA_ARGS__); \
print_term(msg); \
g_free(msg); \
- } while (0)
+ } while (0)
gchar *path_to_utf8(const gchar *path);
gchar *path_from_utf8(const gchar *path);
*-----------------------------------------------------------------------------
* menu items
*-----------------------------------------------------------------------------
- */
+ */
static void menu_item_finish(GtkWidget *menu, GtkWidget *item, GCallback func, gpointer data)
{
item = menu_item_add_stock(menu, label, stock_id, func, data);
gtk_widget_set_sensitive(item, sensitive);
-
+
return item;
}
{
GtkWidget *item = gtk_menu_item_new();
gtk_widget_set_sensitive(item, FALSE);
- gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
- gtk_widget_show(item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu),item);
+ gtk_widget_show(item);
}
GtkWidget *menu_item_add_simple(GtkWidget *menu, const gchar *label,
*-----------------------------------------------------------------------------
* popup menus
*-----------------------------------------------------------------------------
- */
+ */
static void popup_menu_short_lived_cb(GtkWidget *widget, gpointer data)
{
gint adjusted = FALSE;
gint w, h;
gint xw, xh;
-
+
w = GTK_WIDGET(menu)->requisition.width;
h = GTK_WIDGET(menu)->requisition.height;
xw = gdk_screen_width();
/* use to avoid mnemonics, for example filenames */
GtkWidget *menu_item_add_simple(GtkWidget *menu, const gchar *label,
- GCallback func, gpointer data);
+ GCallback func, gpointer data);
GtkWidget *popup_menu_short_lived(void);
return ds->box;
}
-
+
void date_selection_set(GtkWidget *widget, gint day, gint month, gint year)
{
DateSelection *ds;
if (month) *month = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_m));
if (year) *year = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_y));
}
-
+
void date_selection_time_set(GtkWidget *widget, time_t t)
{
struct tm *lt;
g_free(token);
- return ret;
+ return ret;
}
static void pref_list_set(const gchar *group, const gchar *key, const gchar *marker, const gchar *text)
GCallback func, gpointer data)
{
GtkWidget *button;
-
+
if (color)
{
button = gtk_color_button_new_with_color(color);
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(parent_box), hbox, TRUE, TRUE, 0);
-
+
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
{
gtk_widget_show(button);
}
-
+
return button;
}
SizerPositionType position);
void sizer_set_limits(GtkWidget *sizer,
- gint hsize_min, gint hsize_max,
- gint vsize_min, gint vsize_max);
+ gint hsize_min, gint hsize_max,
+ gint vsize_min, gint vsize_max);
void pref_list_int_set(const gchar *group, const gchar *key, gint value);
void pref_color_button_set_cb(GtkWidget *widget, gpointer data);
GtkWidget *pref_color_button_new(GtkWidget *parent_box,
- const gchar *title, const GdkColor *color,
- GCallback func, gpointer data);
+ const gchar *title, const GdkColor *color,
+ GCallback func, gpointer data);
#endif
*-----------------------------------------------------------------------------
* (private)
*-----------------------------------------------------------------------------
- */
+ */
static void dest_free_data(GtkWidget *widget, gpointer data)
{
{
if (!options->file_filter.show_dot_directory
&& dir->d_name[0] == '.' && dir->d_name[1] == '\0')
- continue;
+ continue;
if (dir->d_name[0] == '.' && dir->d_name[1] == '.' && dir->d_name[2] == '\0'
&& pathl[0] == '/' && pathl[1] == '\0')
- continue; /* no .. for root directory */
+ continue; /* no .. for root directory */
if (dd->show_hidden || !is_hidden(dir->d_name))
{
gchar *name = dir->d_name;
{
filepath = concat_dir_and_file(path, list->data);
}
-
+
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, list->data, 1, filepath, -1);
list = file_list;
while (list)
- {
+ {
GtkTreeIter iter;
gchar *filepath;
const gchar *name = list->data;
filepath = concat_dir_and_file(path, name);
-
+
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, name, 1, filepath, -1);
model = gtk_tree_view_get_model(view);
gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
gtk_tree_model_get(model, &iter, 1, &path, -1);
-
+
if (!path) return;
dl = g_new(DestDel_Data, 1);
gtk_tree_model_get(model, &iter, 0, &text, -1);
if (!text) return FALSE;
-
+
normal_dir = (strcmp(text, ".") == 0 || strcmp(text, "..") == 0);
menu = popup_menu_short_lived();
return FALSE;
}
-
+
static void dest_new_dir_cb(GtkWidget *widget, gpointer data)
{
Dest_Data *dd = data;
*-----------------------------------------------------------------------------
* destination widget file selection, traversal, view options
*-----------------------------------------------------------------------------
- */
+ */
static void dest_select_cb(GtkTreeSelection *selection, gpointer data)
{
else if (isfile(path) && dd->f_view)
{
gtk_entry_set_text(GTK_ENTRY(dd->entry), path);
- }
+ }
}
/*
*-----------------------------------------------------------------------------
* destination widget setup routines (public)
*-----------------------------------------------------------------------------
- */
+ */
GtkWidget *path_selection_new_with_files(GtkWidget *entry, const gchar *path,
const gchar *filter, const gchar *filter_desc)
G_CALLBACK(dest_activate_cb), dd);
g_signal_connect(G_OBJECT(dd->d_view), "destroy",
G_CALLBACK(dest_free_data), dd);
-
+
if (filter)
{
GtkListStore *store;
if (!dd) return;
path = gtk_entry_get_text(GTK_ENTRY(entry));
-
+
if (isdir(path) && (!dd->path || strcmp(path, dd->path) != 0))
{
dest_populate(dd, path);
# include "config.h"
#endif
#include "intl.h"
-
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-
+
#include <gtk/gtk.h>
#include "ui_spinner.h"
static void tab_completion_read_dir(TabCompData *td, const gchar *path)
{
- DIR *dp;
- struct dirent *dir;
- GList *list = NULL;
+ DIR *dp;
+ struct dirent *dir;
+ GList *list = NULL;
gchar *pathl;
tab_completion_free_list(td);
pathl = path_from_utf8(path);
- dp = opendir(pathl);
+ dp = opendir(pathl);
g_free(pathl);
if (!dp)
- {
- /* dir not found */
- return;
- }
- while ((dir = readdir(dp)) != NULL)
- {
+ {
+ /* dir not found */
+ return;
+ }
+ while ((dir = readdir(dp)) != NULL)
+ {
gchar *name = dir->d_name;
if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0)
{
list = g_list_prepend(list, path_to_utf8(name));
}
}
- closedir(dp);
+ closedir(dp);
td->dir_path = g_strdup(path);
td->file_list = list;
gtk_menu_popdown(GTK_MENU(widget));
/* doing this does not emit the "selection done" signal, unref it ourselves */
gtk_widget_unref(widget);
-
+
return TRUE;
}
static gint simple_sort(gconstpointer a, gconstpointer b)
{
- return CASE_SORT((gchar *)a, (gchar *)b);
+ return CASE_SORT((gchar *)a, (gchar *)b);
}
#endif
switch (event->keyval)
{
- case GDK_Tab:
+ case GDK_Tab:
if (!(event->state & GDK_CONTROL_MASK))
{
if (tab_completion_do(td))
g_list_free(renderers);
if (!cell) return FALSE;
-
+
if (!gtk_tree_view_column_cell_get_position(tv_column, cell, &cell_x, &cell_width))
{
cell_x = 0;
gint tree_view_row_get_visibility(GtkTreeView *widget, GtkTreeIter *iter, gint fully_visible)
{
GtkTreeModel *store;
- GtkTreePath *tpath;
+ GtkTreePath *tpath;
gint cx, cy;
-
+
GdkRectangle vrect;
GdkRectangle crect;
gint tree_path_to_row(GtkTreePath *tpath)
{
gint *indices;
-
+
indices = gtk_tree_path_get_indices(tpath);
if (indices) return indices[0];
-
+
return -1;
}
*-----------------------------------------------------------------------------
* generic dialog
*-----------------------------------------------------------------------------
- */
+ */
void generic_dialog_close(GenericDialog *gd)
{
{
GenericDialog *gd = data;
if (gd->cancel_button)
- {
+ {
gtk_box_reorder_child(GTK_BOX(gd->hbox), gd->cancel_button, -1);
}
gtk_widget_show(gd->hbox);
if (gd->cancel_cb)
- {
+ {
gd->cancel_button = generic_dialog_add_button(gd, GTK_STOCK_CANCEL, NULL, gd->cancel_cb, TRUE);
}
else
*-----------------------------------------------------------------------------
* simple warning dialog
*-----------------------------------------------------------------------------
- */
+ */
static void warning_dialog_ok_cb(GenericDialog *gd, gpointer data)
{
*-----------------------------------------------------------------------------
* generic file ops dialog routines
*-----------------------------------------------------------------------------
- */
+ */
void file_dialog_close(FileDialog *fdlg)
{
/* only the first image is stored (for use in gd_image_set) */
g_object_set_data(G_OBJECT(gd->dialog), "img_image", imd);
g_object_set_data(G_OBJECT(gd->dialog), "img_label", label);
-
+
/* image 2 */
{
ImageWindow *imd;
GtkWidget *label;
-
+
imd = g_object_get_data(G_OBJECT(gd->dialog), "img_image");
label = g_object_get_data(G_OBJECT(gd->dialog), "img_label");
{
FileData *fd = list->data;
gchar *title = _("Error copying file");
- gchar *text = g_strdup_printf(_("%s\nUnable to copy file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
+ gchar *text = g_strdup_printf(_("%s\nUnable to copy file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
}
}
file_data_change_info_free(NULL, fd);
-
+
return ok;
}
{
FileData *fd = list->data;
gchar *title = _("Error moving file");
- gchar *text = g_strdup_printf(_("%s\nUnable to move file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
+ gchar *text = g_strdup_printf(_("%s\nUnable to move file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
}
g_assert(fd->change);
if (options->editor_command[CMD_MOVE])
{
- ok = !start_editor_from_file_full(CMD_MOVE, fd, move_file_ext_cb, NULL);
- if (ok) return ok; /* that's all for now, let's continue in callback */
+ ok = !start_editor_from_file_full(CMD_MOVE, fd, move_file_ext_cb, NULL);
+ if (ok) return ok; /* that's all for now, let's continue in callback */
}
else
ok = move_file(fd->change->source, fd->change->dest);
}
file_data_change_info_free(NULL, fd);
-
+
return ok;
}
{
FileData *fd = list->data;
gchar *title = _("Error renaming file");
- gchar *text = g_strdup_printf(_("%s\nUnable to rename file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
+ gchar *text = g_strdup_printf(_("%s\nUnable to rename file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
}
}
else
ok = rename_file(fd->change->source, fd->change->dest);
-
+
if (ok)
{
file_data_do_change(fd);
file_maint_renamed(fd);
}
-
+
file_data_change_info_free(NULL, fd);
-
+
return ok;
}
{
FileData *fd;
gint v;
-
+
fd = work->data;
work = work->next;
if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
{
GString *msg = g_string_new(editor_get_error_str(flags));
- g_string_append(msg,_("\nUnable to delete file by external command:\n"));
+ g_string_append(msg,_("\nUnable to delete file by external command:\n"));
GenericDialog *d;
while (list)
{
FileData *fd = list->data;
-
+
g_string_append(msg, fd->path);
g_string_append(msg, "\n");
list = list->next;
}
g_string_free(msg, TRUE);
}
-
-
+
+
{
while (list)
{
FileData *fd = list->data;
if (flags & EDITOR_ERROR_MASK)
/* an error occured -> no change -> delete change info */
- file_data_change_info_free(NULL, fd);
+ file_data_change_info_free(NULL, fd);
else
/* files were successfully deleted, call the maint functions and keep the change info forever */
file_maint_removed(fd, list);
file_data_add_change_info(fd, FILEDATA_CHANGE_DELETE, NULL, NULL);
work = work->next;
}
-
+
if ((flags = start_editor_from_filelist_full(CMD_DELETE, source_list, file_util_delete_ext_cb, NULL)))
{
- gchar *text = g_strdup_printf(_("%s\nUnable to delete files by external command.\n"), editor_get_error_str(flags));
+ gchar *text = g_strdup_printf(_("%s\nUnable to delete files by external command.\n"), editor_get_error_str(flags));
file_util_warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
}
-
+
filelist_free(source_list);
return;
}
else
{
gchar *text;
-
+
text = g_strdup_printf(_("Unable to delete file:\n%s"), fd->path);
file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
g_free(text);
gd = file_util_gen_dlg(title, GQ_WMCLASS, "dlg_confirm", parent, TRUE,
file_util_delete_multiple_cancel_cb, source_list);
g_free(title);
-
+
generic_dialog_add_message(gd, NULL, _("Delete multiple files"), NULL);
generic_dialog_add_image(gd, NULL, NULL, NULL, NULL, NULL, TRUE);
{
dest = g_strdup_printf("%s/%s%0*d%s", base, front, padding, n, end);
}
-
+
if (!file_data_add_change_info(fd, FILEDATA_CHANGE_RENAME, fd->path, dest) ||
!rename_file_ext(fd))
{
if (rd->rename_type == RENAME_TYPE_FORMATTED)
{
FileData *fd;
-
+
gtk_tree_model_get(store, &iter, RENAME_COLUMN_FD, &fd, -1);
dest = file_util_rename_multiple_auto_format_name(format, fd->name, n);
// file_data_unref(fd);
GtkCellRenderer *renderer;
column = gtk_tree_view_column_new();
- gtk_tree_view_column_set_title(column, text);
- gtk_tree_view_column_set_min_width(column, 4);
- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
- renderer = gtk_cell_renderer_text_new();
- gtk_tree_view_column_pack_start(column, renderer, TRUE);
- gtk_tree_view_column_add_attribute(column, renderer, "text", n);
- gtk_tree_view_append_column(GTK_TREE_VIEW(rd->listview), column);
+ gtk_tree_view_column_set_title(column, text);
+ gtk_tree_view_column_set_min_width(column, 4);
+ gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start(column, renderer, TRUE);
+ gtk_tree_view_column_add_attribute(column, renderer, "text", n);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(rd->listview), column);
return column;
}
gchar *title;
rd = g_new0(RenameDataMult, 1);
-
+
title = g_strdup_printf("%s -%s", _("Rename"), GQ_APPNAME);
rd->fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_rename", parent,
file_util_rename_multiple_close_cb, rd);
pane = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(vbox), pane, TRUE, TRUE, 0);
gtk_widget_show(pane);
-
+
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled),
file_util_rename_multiple_add_column(rd, _("Original Name"), RENAME_COLUMN_NAME);
column = file_util_rename_multiple_add_column(rd, _("Preview"), RENAME_COLUMN_PREVIEW);
gtk_tree_view_column_set_visible(column, FALSE);
-
+
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(rd->listview), TRUE);
g_signal_connect(G_OBJECT(store), "row_changed",
G_CALLBACK(file_util_rename_multiple_preview_order_cb), rd);
G_CALLBACK(file_util_rename_multiple_preview_entry_cb), rd);
gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
gtk_widget_show(combo);
-
+
box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
rd->auto_spin_start = pref_spin_new(box2, NULL, NULL,
G_CALLBACK(file_util_rename_multiple_preview_entry_cb), rd);
gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
gtk_widget_show(combo);
-
+
box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
rd->format_spin = pref_spin_new(box2, NULL, NULL,
title = g_strdup_printf("%s -%s", _("Rename"), GQ_APPNAME);
fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_rename", parent,
- file_util_rename_single_close_cb, NULL);
+ file_util_rename_single_close_cb, NULL);
g_free(title);
generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, _("Rename file"), NULL);
title = g_strdup_printf("%s -%s", _("New folder"), GQ_APPNAME);
fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_newdir", parent,
- file_util_create_dir_close_cb, NULL);
+ file_util_create_dir_close_cb, NULL);
g_free(title);
text = g_strdup_printf(_("Create folder in:\n%s\nnamed:"), path);
case DIRVIEW_LIST: vdlist_destroy_cb(widget, data); break;
case DIRVIEW_TREE: vdtree_destroy_cb(widget, data); break;
}
-
+
if (vd->pf) folder_icons_free(vd->pf);
if (vd->drop_list) filelist_free(vd->drop_list);
}
gtk_container_add(GTK_CONTAINER(vd->widget), vd->view);
-
+
vd_dnd_init(vd);
g_signal_connect(G_OBJECT(vd->view), "row_activated",
return vd;
}
-
+
void vd_set_select_func(ViewDir *vd,
- void (*func)(ViewDir *vd, const gchar *path, gpointer data), gpointer data)
+ void (*func)(ViewDir *vd, const gchar *path, gpointer data), gpointer data)
{
- vd->select_func = func;
- vd->select_data = data;
+ vd->select_func = func;
+ vd->select_data = data;
}
void vd_set_layout(ViewDir *vd, LayoutWindow *layout)
*-----------------------------------------------------------------------------
* pop-up menu
*-----------------------------------------------------------------------------
- */
+ */
static void vd_pop_menu_up_cb(GtkWidget *widget, gpointer data)
{
static void vd_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
{
ViewDir *vd = data;
-
+
vd_rename_by_data(vd, vd->click_fd);
}
/* ignore .. and . */
rename_delete_active = (new_folder_active && fd &&
strcmp(fd->name, ".") != 0 &&
- strcmp(fd->name, "..") != 0 &&
- access_file(fd->path, W_OK | X_OK));
+ strcmp(fd->name, "..") != 0 &&
+ access_file(fd->path, W_OK | X_OK));
};
break;
case DIRVIEW_TREE:
G_CALLBACK(vd_pop_menu_delete_cb), vd);
menu_item_add_divider(menu);
-
+
item = menu_item_add(menu, _("_View as"), NULL, NULL);
submenu = gtk_menu_new();
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
for (i = 0; i < G_N_ELEMENTS(menu_view_dir_radio_entries); i++)
{
static gint vd_dnd_drop_motion(GtkWidget *widget, GdkDragContext *context,
gint x, gint y, guint time, gpointer data)
{
- ViewDir *vd = data;
+ ViewDir *vd = data;
vd->click_fd = NULL;
*-----------------------------------------------------------------------------
* main
*-----------------------------------------------------------------------------
- */
+ */
void vdlist_select_row(ViewDir *vd, FileData *fd)
{
if (strcmp(vd->path, "/") != 0)
{
- filepath = g_strconcat(vd->path, "/", "..", NULL);
+ filepath = g_strconcat(vd->path, "/", "..", NULL);
fd = file_data_new_simple(filepath);
VDLIST_INFO(vd, list) = g_list_prepend(VDLIST_INFO(vd, list), fd);
g_free(filepath);
}
-
+
if (options->file_filter.show_dot_directory)
{
- filepath = g_strconcat(vd->path, "/", ".", NULL);
+ filepath = g_strconcat(vd->path, "/", ".", NULL);
fd = file_data_new_simple(filepath);
VDLIST_INFO(vd, list) = g_list_prepend(VDLIST_INFO(vd, list), fd);
g_free(filepath);
{
ViewDir *vd = data;
GtkTreePath *tpath;
-
+
if (event->keyval != GDK_Menu) return FALSE;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, NULL);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &vd->click_fd, -1);
-
+
gtk_tree_path_free(tpath);
}
else
if (!nd) return FALSE;
current_time = time(NULL);
-
+
if (nd->expanded)
{
if (!force && current_time - nd->last_update < 10) return TRUE;
static gint selection_is_ok = FALSE;
static gboolean vdtree_select_cb(GtkTreeSelection *selection, GtkTreeModel *store, GtkTreePath *tpath,
- gboolean path_currently_selected, gpointer data)
+ gboolean path_currently_selected, gpointer data)
{
return selection_is_ok;
}
{
GtkTreeSelection *selection;
GtkTreeIter iter;
-
+
if (!vd_find_row(vd, fd, &iter)) return;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
vdtree_expand_by_iter(vd, &iter, TRUE);
- if (fd && vd->select_func)
- {
- vd->select_func(vd, fd->path, vd->select_data);
- }
+ if (fd && vd->select_func)
+ {
+ vd->select_func(vd, fd->path, vd->select_data);
+ }
}
gint vdtree_set_path(ViewDir *vd, const gchar *path)
VDTREE_INFO(vd, drop_expand_id) = -1;
VDTREE_INFO(vd, busy_ref) = 0;
-
+
vd->dnd_drop_leave_func = vdtree_dnd_drop_expand_cancel;
vd->dnd_drop_update_func = vdtree_dnd_drop_expand;
IconData *id;
fd = work->data;
- g_assert(fd->magick == 0x12345678);
+ g_assert(fd->magick == 0x12345678);
id = g_new0(IconData, 1);
id->selected = SELECTION_NONE;
IconData *id = work->data;
file_data_unref(id->fd);
g_free(id);
- work = work->next;
- }
-
- g_list_free(list);
+ work = work->next;
+ }
+
+ g_list_free(list);
}
if (vfi->click_id->selected & SELECTION_SELECTED)
{
GList *list;
-
+
list = vficon_selection_get_list(vfi);
view_window_new_from_list(list);
filelist_free(list);
SortType type;
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
-
+
vfi = submenu_item_get_data(widget);
if (!vfi) return;
static void vficon_popup_destroy_cb(GtkWidget *widget, gpointer data)
{
- ViewFileIcon *vfi = data;
+ ViewFileIcon *vfi = data;
vficon_selection_remove(vfi, vfi->click_id, SELECTION_PRELIGHT, NULL);
vfi->click_id = NULL;
vfi->popup = NULL;
if (!vfi->layout || !id || !id->fd) return;
sel_fd = id->fd;
-
+
cur_fd = layout_image_get_fd(vfi->layout);
if (sel_fd == cur_fd) return; /* no change */
-
+
if (options->image.enable_read_ahead)
{
gint row;
{
id = work->data;
vficon_select_util(vfi, id, select);
-
+
if (work->data != end)
work = work->next;
else
{
IconData *id = work->data;
FileData *fd = id->fd;
- g_assert(fd->magick == 0x12345678);
+ g_assert(fd->magick == 0x12345678);
b += fd->size;
work = work->next;
{
IconData *id = work->data;
FileData *fd = id->fd;
- g_assert(fd->magick == 0x12345678);
+ g_assert(fd->magick == 0x12345678);
list = g_list_prepend(list, file_data_ref(fd));
GList *list = NULL;
GList *work;
- work = vfi->selection;
+ work = vfi->selection;
while (work)
{
list = g_list_prepend(list, GINT_TO_POINTER(g_list_index(vfi->list, work->data)));
FileData *fd = id->fd;
gboolean mark_val, selected;
- g_assert(fd->magick == 0x12345678);
+ g_assert(fd->magick == 0x12345678);
mark_val = fd->marks[mark];
selected = (id->selected & SELECTION_SELECTED);
-
- switch (mode)
+
+ switch (mode)
{
case MTS_MODE_SET: selected = mark_val;
break;
case MTS_MODE_MINUS: selected = !mark_val & selected;
break;
}
-
+
vficon_select_util(vfi, id, selected);
work = work->next;
while (work)
{
FileData *fd = work->data;
-
+
switch (mode)
{
case STM_MODE_SET: fd->marks[mark] = 1;
case STM_MODE_TOGGLE: fd->marks[mark] = !fd->marks[mark];
break;
}
-
+
work = work->next;
}
filelist_free(slist);
IconData *id;
tip_unschedule(vfi);
-
+
id = vficon_find_data_by_coord(vfi, (gint)bevent->x, (gint)bevent->y, &iter);
vfi->click_id = id;
id && vfi->click_id == id)
{
vficon_set_focus(vfi, id);
-
+
if (bevent->state & GDK_CONTROL_MASK)
{
gint select;
{
list = vficon_add_row(vfi, &iter);
}
-
+
while (list)
{
IconData *id;
FileData *vficon_index_get_data(ViewFileIcon *vfi, gint row)
{
IconData *id;
-
+
id = g_list_nth_data(vfi->list, row);
return id ? id->fd : NULL;
}
{
FileData *fd;
IconData *id;
-
+
id = g_list_nth_data(vfi->list, row);
fd = id ? id->fd : NULL;
work = vfi->list;
while (work)
{
-
+
IconData *id = work->data;
FileData *fd = id->fd;
work = work->next;
{
IconData *id;
FileData *fd;
-
+
GList *needle;
id = work->data;
fd = id->fd;
-
+
needle = vfi->list;
while (needle)
{
vfi = cd->vfi;
gtk_tree_model_get(tree_model, iter, FILE_COLUMN_POINTER, &list, -1);
-
+
id = g_list_nth_data(list, cd->number);
-
+
if (id) g_assert(id->fd->magick == 0x12345678);
-
+
style = gtk_widget_get_style(vfi->listview);
if (id && id->selected & SELECTION_SELECTED)
{
}
if (GQV_IS_CELL_RENDERER_ICON(cell))
- {
+ {
if (id)
{
g_object_set(cell, "pixbuf", id->fd->pixbuf,
"cell-background-set", FALSE,
"foreground-set", FALSE,
"has-focus", FALSE, NULL);
- }
+ }
}
}
ignore_id = work->data;
ignore_fd = ignore_id->fd;
- g_assert(ignore_fd->magick == 0x12345678);
+ g_assert(ignore_fd->magick == 0x12345678);
work = work->next;
tmp = ignore_list;
while (tmp && !match)
{
FileData *ignore_list_fd = tmp->data;
- g_assert(ignore_list_fd->magick == 0x12345678);
+ g_assert(ignore_list_fd->magick == 0x12345678);
tmp = tmp->next;
if (ignore_list_fd == ignore_fd)
{
GtkTreeModel *store;
ViewFileListFindRowData data = {fd, iter, 0, 0};
-
+
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vfl->listview));
gtk_tree_model_foreach(store, vflist_find_row_cb, &data);
{
FileData *fd_p = work->data;
if (fd == fd_p) return i;
-
+
i++;
GList *work2 = fd_p->sidecar_files;
while (work2)
{
- fd_p = work2->data;
+ fd_p = work2->data;
if (fd == fd_p) return i;
-
+
i++;
work2 = work2->next;
}
work = work->next;
i++;
}
-
+
g_list_free(columns);
return i;
}
SortType type;
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
-
+
vfl = submenu_item_get_data(widget);
if (!vfl) return;
gchar *str_sel_mark_or = g_strdup_printf(_("_Add mark %d"), mark + 1);
gchar *str_sel_mark_and = g_strdup_printf(_("_Intersection with mark %d"), mark + 1);
gchar *str_sel_mark_minus = g_strdup_printf(_("_Unselect mark %d"), mark + 1);
-
-
+
+
vfl->active_mark = mark;
menu_item_add_sensitive(menu, str_set_mark, active,
- G_CALLBACK(vflist_pop_menu_set_mark_sel_cb), vfl);
-
+ G_CALLBACK(vflist_pop_menu_set_mark_sel_cb), vfl);
+
menu_item_add_sensitive(menu, str_res_mark, active,
- G_CALLBACK(vflist_pop_menu_res_mark_sel_cb), vfl);
-
+ G_CALLBACK(vflist_pop_menu_res_mark_sel_cb), vfl);
+
menu_item_add_sensitive(menu, str_toggle_mark, active,
- G_CALLBACK(vflist_pop_menu_toggle_mark_sel_cb), vfl);
+ G_CALLBACK(vflist_pop_menu_toggle_mark_sel_cb), vfl);
menu_item_add_divider(menu);
-
+
menu_item_add_sensitive(menu, str_sel_mark, active,
- G_CALLBACK(vflist_pop_menu_sel_mark_cb), vfl);
+ G_CALLBACK(vflist_pop_menu_sel_mark_cb), vfl);
menu_item_add_sensitive(menu, str_sel_mark_or, active,
- G_CALLBACK(vflist_pop_menu_sel_mark_or_cb), vfl);
+ G_CALLBACK(vflist_pop_menu_sel_mark_or_cb), vfl);
menu_item_add_sensitive(menu, str_sel_mark_and, active,
- G_CALLBACK(vflist_pop_menu_sel_mark_and_cb), vfl);
+ G_CALLBACK(vflist_pop_menu_sel_mark_and_cb), vfl);
menu_item_add_sensitive(menu, str_sel_mark_minus, active,
- G_CALLBACK(vflist_pop_menu_sel_mark_minus_cb), vfl);
-
+ G_CALLBACK(vflist_pop_menu_sel_mark_minus_cb), vfl);
+
menu_item_add_divider(menu);
-
+
g_free(str_set_mark);
g_free(str_res_mark);
g_free(str_toggle_mark);
file_util_warning_dialog(_("Error renaming file"), text, GTK_STOCK_DIALOG_ERROR, vfl->listview);
g_free(text);
}
- else
+ else
{
gint row = vflist_index_by_path(vfl, old_path);
- if (row >= 0)
+ if (row >= 0)
{
GList *work = g_list_nth(vfl->list, row);
FileData *fd = work->data;
-
+
if (!file_data_add_change_info(fd, FILEDATA_CHANGE_RENAME, old_path, new_path) || !rename_file_ext(fd))
{
gchar *text = g_strdup_printf(_("Unable to rename file:\n%s\nto:\n%s"), old, new);
FileData *fd = NULL;
GtkTreeViewColumn *column;
gint col_idx = 0;
-
+
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
&tpath, &column, NULL, NULL))
{
GtkTreeModel *store;
col_idx = GPOINTER_TO_INT(g_object_get_data (G_OBJECT(column), "column_store_idx"));
-
+
if (bevent->button == 1 &&
col_idx >= FILE_COLUMN_MARKS && col_idx <= FILE_COLUMN_MARKS_LAST)
return FALSE;
-
+
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
gint row;
FileData *cur_fd;
if (!sel_fd) return;
-
+
cur_fd = layout_image_get_fd(vfl->layout);
if (sel_fd == cur_fd) return; /* no change */
-
+
row = g_list_index(vfl->list, sel_fd);
// FIXME sidecar data
/*
static gboolean vflist_dummy_select_cb(GtkTreeSelection *selection, GtkTreeModel *store, GtkTreePath *tpath,
- gboolean path_currently_selected, gpointer data)
+ gboolean path_currently_selected, gpointer data)
{
return TRUE;
}
if (fd->sidecar_files)
sidecars = sidecar_file_data_list_to_string(fd);
size = text_from_size(fd->size);
-
+
gtk_tree_store_set(store, iter, FILE_COLUMN_POINTER, fd,
FILE_COLUMN_THUMB, (vfl->thumbs_enabled) ? fd->pixbuf : NULL,
FILE_COLUMN_NAME, fd->name,
vflist_setup_iter(vfl, store, iter, fd);
- /* this is almost the same code as in vflist_populate_view
+ /* this is almost the same code as in vflist_populate_view
maybe it should be made more generic and used in both places */
-
-
+
+
valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &s_iter, iter);
work = fd->sidecar_files;
while (!done)
{
FileData *old_sfd = NULL;
-
+
if (valid)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &s_iter, FILE_COLUMN_POINTER, &old_sfd, -1);
-
+
if (sfd == old_sfd)
{
match = 0;
match = filelist_sort_compare_filedata_full(sfd, old_sfd, SORT_NAME, TRUE);
}
}
-
+
else
{
match = -1;
if (match < 0)
{
GtkTreeIter new;
-
+
if (valid)
{
gtk_tree_store_insert_before(store, &new, iter, &s_iter);
{
gtk_tree_store_append(store, &new, iter);
}
-
+
vflist_setup_iter(vfl, store, &new, sfd);
done = TRUE;
vfl->sort_ascend = ascend;
vfl->list = filelist_sort(vfl->list, vfl->sort_method, vfl->sort_ascend);
-
+
new_order = g_malloc(i * sizeof(gint));
-
+
work = vfl->list;
i = 0;
while (work)
i++;
work = work->next;
}
-
+
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vfl->listview)));
gtk_tree_store_reorder(store, NULL, new_order);
-
+
g_free(new_order);
g_hash_table_destroy(fd_idx_hash);
}
static void vflist_thumb_stop(ViewFileList *vfl)
{
- if (vfl->thumbs_running) vflist_thumb_cleanup(vfl);
+ if (vfl->thumbs_running) vflist_thumb_cleanup(vfl);
}
static void vflist_thumb_do(ViewFileList *vfl, ThumbLoader *tl, FileData *fd)
while (work && !fd)
{
FileData *fd_p = work->data;
- if (!fd_p->pixbuf)
+ if (!fd_p->pixbuf)
fd = fd_p;
else
{
GList *work2 = fd_p->sidecar_files;
-
+
while (work2 && !fd)
{
- fd_p = work2->data;
+ fd_p = work2->data;
if (!fd_p->pixbuf) fd = fd_p;
work2 = work2->next;
}
GtkTreeIter iter;
GtkTreeSelection *selection;
gint valid;
-
+
g_assert(mark >= 0 && mark < FILEDATA_MARKS_SIZE);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vfl->listview));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vfl->listview));
-
+
valid = gtk_tree_model_get_iter_first(store, &iter);
while (valid)
{
FileData *fd;
gboolean mark_val, selected;
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FILE_COLUMN_POINTER, &fd, -1);
-
+
mark_val = fd->marks[mark];
selected = gtk_tree_selection_iter_is_selected(selection, &iter);
-
- switch (mode)
+
+ switch (mode)
{
case MTS_MODE_SET: selected = mark_val;
break;
case MTS_MODE_MINUS: selected = !mark_val & selected;
break;
}
-
+
if (selected)
gtk_tree_selection_select_iter(selection, &iter);
else
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &fd, -1);
-
+
switch (mode)
{
case STM_MODE_SET: fd->marks[mark] = 1;
case STM_MODE_TOGGLE: fd->marks[mark] = !fd->marks[mark];
break;
}
-
- gtk_tree_store_set(GTK_TREE_STORE(store), &iter, FILE_COLUMN_MARKS + mark, fd->marks[mark], -1);
+
+ gtk_tree_store_set(GTK_TREE_STORE(store), &iter, FILE_COLUMN_MARKS + mark, fd->marks[mark], -1);
work = work->next;
}
while (!done)
{
FileData *old_fd = NULL;
-
+
if (valid)
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FILE_COLUMN_POINTER, &old_fd, -1);
-
+
if (fd == old_fd)
{
match = 0;
match = -1; /* probably should not happen*/
}
}
-
+
else
{
match = -1;
if (match < 0)
{
GtkTreeIter new;
-
+
if (valid)
{
gtk_tree_store_insert_before(store, &new, NULL, &iter);
FileData *fd;
gboolean mark;
guint col_idx;
-
+
if (!path || !gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path))
return;
col_idx = GPOINTER_TO_INT(g_object_get_data (G_OBJECT(cell), "column_store_idx"));
-
+
g_assert(col_idx >= FILE_COLUMN_MARKS && col_idx <= FILE_COLUMN_MARKS_LAST);
-
+
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FILE_COLUMN_POINTER, &fd, col_idx, &mark, -1);
mark = !mark;
fd->marks[col_idx - FILE_COLUMN_MARKS] = mark;
-
+
gtk_tree_store_set(store, &iter, col_idx, mark, -1);
gtk_tree_path_free(path);
}
GtkCellRenderer *renderer;
GtkTreeStore *store;
gint index;
-
+
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vfl->listview)));
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
g_object_set_data (G_OBJECT (column), "column_store_idx", GUINT_TO_POINTER(n));
g_object_set_data (G_OBJECT (renderer), "column_store_idx", GUINT_TO_POINTER(n));
-
+
index = gtk_tree_view_append_column(GTK_TREE_VIEW(vfl->listview), column);
gtk_tree_view_column_set_fixed_width(column, 16);
gtk_tree_view_column_set_visible(column, vfl->marks_enabled);
-
+
g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(vflist_listview_mark_toggled), store);
}
GType flist_types[FILE_COLUMN_COUNT];
int i;
-
+
vfl = g_new0(ViewFileList, 1);
vfl->path = NULL;
flist_types[i] = G_TYPE_BOOLEAN;
store = gtk_tree_store_newv(FILE_COLUMN_COUNT, flist_types);
-
+
vfl->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
vflist_listview_add_column(vfl, FILE_COLUMN_SIZE, _("Size"), FALSE, TRUE, FALSE);
vflist_listview_add_column(vfl, FILE_COLUMN_DATE, _("Date"), FALSE, TRUE, FALSE);
-
+
g_signal_connect(G_OBJECT(vfl->listview), "key_press_event",
G_CALLBACK(vflist_press_key_cb), vfl);
gtk_widget_show(vfl->listview);
vflist_dnd_init(vfl);
-
+
g_signal_connect(G_OBJECT(vfl->listview), "button_press_event",
G_CALLBACK(vflist_press_cb), vfl);
g_signal_connect(G_OBJECT(vfl->listview), "button_release_event",
G_CALLBACK(vflist_release_cb), vfl);
-
-
+
+
if (path) vflist_set_path(vfl, path);
return vfl;
void vflist_marks_set(ViewFileList *vfl, gint enable)
{
GList *columns, *work;
-
+
if (vfl->marks_enabled == enable) return;
vfl->marks_enabled = enable;
-
+
columns = gtk_tree_view_get_columns(GTK_TREE_VIEW(vfl->listview));
-
+
work = columns;
while (work)
{
GtkTreeViewColumn *column = work->data;
gint col_idx = GPOINTER_TO_INT(g_object_get_data (G_OBJECT(column), "column_store_idx"));
work = work->next;
-
- if (col_idx <= FILE_COLUMN_MARKS_LAST && col_idx >= FILE_COLUMN_MARKS)
+
+ if (col_idx <= FILE_COLUMN_MARKS_LAST && col_idx >= FILE_COLUMN_MARKS)
gtk_tree_view_column_set_visible(column, enable);
}
-
+
g_list_free(columns);
//vflist_refresh(vfl);
}
projects / geeqie.git / commitdiff