list = history_list_get_by_key("exif_extras");
while (list)
{
- if (strcmp(name, (gchar *)(list->data)) == 0) return TRUE;
+ if (strcmp(name, static_cast<gchar *>(list->data)) == 0) return TRUE;
list = list->next;
}
{
case TARGET_APP_KEYWORD_PATH:
{
- auto path = static_cast<GList *>(*(gpointer *)(gtk_selection_data_get_data(selection_data)));
+ auto path = static_cast<GList *>(*reinterpret_cast<const gpointer *>(gtk_selection_data_get_data(selection_data)));
src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
string_list_free(path);
break;
{
gchar *path;
gboolean has_extension;
- auto filename = (gchar *) name;
+ auto filename = const_cast<gchar *>(name);
if (empty_name) return;
static void cache_maintenance_render_stop_cb(gpointer UNUSED(data))
{
gtk_status_icon_set_tooltip_text(status_icon, _("Geeqie: Creating sim data..."));
- cache_manager_sim_remote(cache_maintenance_path, TRUE, (GDestroyNotify *)cache_maintenance_sim_stop_cb);
+ cache_manager_sim_remote(cache_maintenance_path, TRUE, reinterpret_cast<GDestroyNotify *>(cache_maintenance_sim_stop_cb));
}
static void cache_maintenance_clean_stop_cb(gpointer UNUSED(data))
{
gtk_status_icon_set_tooltip_text(status_icon, _("Geeqie: Creating thumbs..."));
- cache_manager_render_remote(cache_maintenance_path, TRUE, options->thumbnails.cache_into_dirs, (GDestroyNotify *)cache_maintenance_render_stop_cb);
+ cache_manager_render_remote(cache_maintenance_path, TRUE, options->thumbnails.cache_into_dirs, reinterpret_cast<GDestroyNotify *>(cache_maintenance_render_stop_cb));
}
static void cache_maintenance_user_cancel_cb()
gtk_status_icon_set_visible(status_icon, TRUE);
g_signal_connect(G_OBJECT(status_icon), "activate", G_CALLBACK(cache_maintenance_status_icon_activate_cb), NULL);
- cache_maintain_home_remote(FALSE, FALSE, (GDestroyNotify *)cache_maintenance_clean_stop_cb);
+ cache_maintain_home_remote(FALSE, FALSE, reinterpret_cast<GDestroyNotify *>(cache_maintenance_clean_stop_cb));
}
/*
cm->metadata = metadata;
cm->remote = TRUE;
- cm->idle_id = g_idle_add_full(G_PRIORITY_LOW, cache_maintain_home_cb, cm, (GDestroyNotify)func);
+ cm->idle_id = g_idle_add_full(G_PRIORITY_LOW, cache_maintain_home_cb, cm, reinterpret_cast<GDestroyNotify>(func));
}
static void cache_file_move(const gchar *src, const gchar *dest)
filelist_free(cd->list_dir);
cd->list_dir = NULL;
- thumb_loader_free((ThumbLoader *)cd->tl);
+ thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
cd->tl = NULL;
}
{
auto cd = static_cast<CacheOpsData *>(data);
- thumb_loader_free((ThumbLoader *)cd->tl);
+ thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
cd->tl = NULL;
while (cache_manager_render_file(cd));
fd = static_cast<FileData *>(cd->list->data);
cd->list = g_list_remove(cd->list, fd);
- cd->tl = (ThumbLoaderStd *)thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
- thumb_loader_set_callbacks((ThumbLoader *)cd->tl,
+ cd->tl = reinterpret_cast<ThumbLoaderStd *>(thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height));
+ thumb_loader_set_callbacks(reinterpret_cast<ThumbLoader *>(cd->tl),
cache_manager_render_thumb_done_cb,
cache_manager_render_thumb_done_cb,
NULL, cd);
- thumb_loader_set_cache((ThumbLoader *)cd->tl, TRUE, cd->local, TRUE);
- success = thumb_loader_start((ThumbLoader *)cd->tl, fd);
+ thumb_loader_set_cache(reinterpret_cast<ThumbLoader *>(cd->tl), TRUE, cd->local, TRUE);
+ success = thumb_loader_start(reinterpret_cast<ThumbLoader *>(cd->tl), fd);
if (success)
{
if (!cd->remote)
{
gtk_entry_set_text(GTK_ENTRY(cd->progress), fd->path);
cd->count_done = cd->count_done + 1;
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), (gdouble)cd->count_done / cd->count_total);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), static_cast<gdouble>(cd->count_done) / cd->count_total);
}
}
else
{
- thumb_loader_free((ThumbLoader *)cd->tl);
+ thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
cd->tl = NULL;
}
if (cd->destroy_func)
{
- g_idle_add((GSourceFunc)cd->destroy_func, NULL);
+ g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), NULL);
}
return FALSE;
if (cd->count_total != 0)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
- (gdouble)cd->count_done / cd->count_total);
+ static_cast<gdouble>(cd->count_done) / cd->count_total);
}
}
if (cd->count_total != 0)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress),
- (gdouble)cd->count_done / cd->count_total);
+ static_cast<gdouble>(cd->count_done) / cd->count_total);
}
}
}
filelist_free(cd->list_dir);
cd->list_dir = NULL;
- cache_loader_free((CacheLoader *)cd->cl);
+ cache_loader_free(cd->cl);
cd->cl = NULL;
}
{
auto cd = static_cast<CacheOpsData *>(data);
- cache_loader_free((CacheLoader *)cd->cl);
+ cache_loader_free(cd->cl);
cd->cl = NULL;
while (cache_manager_sim_file(cd));
cd->list = g_list_remove(cd->list, fd);
load_mask = static_cast<CacheDataType>(CACHE_LOADER_DIMENSIONS | CACHE_LOADER_DATE | CACHE_LOADER_MD5SUM | CACHE_LOADER_SIMILARITY);
- cd->cl = (CacheLoader *)cache_loader_new(fd, load_mask, (cache_manager_sim_file_done_cb), cd);
+ cd->cl = cache_loader_new(fd, load_mask, (cache_manager_sim_file_done_cb), cd);
if (!cd->remote)
{
cd->count_done = cd->count_done + 1;
if (!cd->remote)
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), (gdouble)cd->count_done / cd->count_total);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress_bar), static_cast<gdouble>(cd->count_done) / cd->count_total);
}
return FALSE;
fd = static_cast<FileData *>(cd->list_dir->data);
cd->list_dir = g_list_remove(cd->list_dir, fd);
- cache_manager_sim_folder((CacheOpsData *)cd, fd);
+ cache_manager_sim_folder(cd, fd);
file_data_unref(fd);
return TRUE;
gtk_entry_set_text(GTK_ENTRY(cd->progress), _("done"));
}
- cache_manager_sim_finish((CacheOpsData *)cd);
+ cache_manager_sim_finish(cd);
if (cd->destroy_func)
{
- g_idle_add((GSourceFunc)cd->destroy_func, NULL);
+ g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), NULL);
}
return FALSE;
g_list_free(list_total);
cd->count_done = 0;
- while (cache_manager_sim_file((CacheOpsData *)cd));
+ while (cache_manager_sim_file(static_cast<CacheOpsData *>(cd)));
}
g_free(path);
sizeof(GQvCellRendererIconClass), /* class_size */
NULL, /* base_init */
NULL, /* base_finalize */
- (GClassInitFunc) gqv_cell_renderer_icon_class_init_wrapper, /* class_init */
+ static_cast<GClassInitFunc>(gqv_cell_renderer_icon_class_init_wrapper), /* class_init */
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(GQvCellRendererIcon), /* instance_size */
0, /* n_preallocs */
- (GInstanceInitFunc) gqv_cell_renderer_icon_init_wrapper, /* instance_init */
+ reinterpret_cast<GInstanceInitFunc>(gqv_cell_renderer_icon_init_wrapper), /* instance_init */
NULL, /* value_table */
};
{
GdkPixbuf *pixbuf;
- pixbuf = (GdkPixbuf *) g_value_get_object(value);
+ pixbuf = static_cast<GdkPixbuf *>(g_value_get_object(value));
if (pixbuf) g_object_ref(pixbuf);
if (cellicon->pixbuf) g_object_unref(cellicon->pixbuf);
cellicon->pixbuf = pixbuf;
gint *width,
gint *height)
{
- auto cellicon = (GQvCellRendererIcon *) cell;
+ auto cellicon = reinterpret_cast<GQvCellRendererIcon *>(cell);
gint calc_width;
gint calc_height;
gint xpad, ypad;
{
GtkStyleContext *context = gtk_widget_get_style_context(widget);
- auto cellicon = (GQvCellRendererIcon *) cell;
+ auto cellicon = reinterpret_cast<GQvCellRendererIcon *>(cell);
GdkPixbuf *pixbuf;
const gchar *text;
GdkRectangle cell_rect;
gtk_style_context_add_class(context, "marks");
GtkStyleProvider *provider;
- provider = (GtkStyleProvider *)gtk_css_provider_new();
+ provider = reinterpret_cast<GtkStyleProvider *>(gtk_css_provider_new());
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),
".marks {\n"
"border-color: #808080;\n"
const GdkRectangle *cell_area,
GtkCellRendererState UNUSED(flags))
{
- auto cellicon = (GQvCellRendererIcon *) cell;
+ auto cellicon = reinterpret_cast<GQvCellRendererIcon *>(cell);
GdkEventButton *bevent = &event->button;
if (cellicon->show_marks &&
if (!cd) return;
title = _("Save collection");
btntext = NULL;
- btnfunc = (gpointer)collection_save_cb;
+ btnfunc = reinterpret_cast<gpointer>(collection_save_cb);
stock_id = GTK_STOCK_SAVE;
}
else if (type == DIALOG_LOAD)
{
title = _("Open collection");
btntext = NULL;
- btnfunc = (gpointer)collection_load_cb;
+ btnfunc = reinterpret_cast<gpointer>(collection_load_cb);
stock_id = GTK_STOCK_OPEN;
}
else
if (!cd) return;
title = _("Append collection");
btntext = _("_Append");
- btnfunc = (gpointer)collection_append_cb;
+ btnfunc = reinterpret_cast<gpointer>(collection_append_cb);
stock_id = GTK_STOCK_ADD;
}
collection_save_or_load_dialog_close_cb, cd);
generic_dialog_add_message(GENERIC_DIALOG(fd), NULL, title, NULL, FALSE);
- file_dialog_add_button(fd, stock_id, btntext, (void (*)(FileDialog *, gpointer))btnfunc, TRUE);
+ file_dialog_add_button(fd, stock_id, btntext, reinterpret_cast<void (*)(FileDialog *, gpointer)>(btnfunc), TRUE);
file_dialog_add_path_widgets(fd, get_collections_dir(), path,
"collection_load_save", GQ_COLLECTION_EXT, _("Collection Files"));
static void collect_manager_entry_init_data(CollectManagerEntry *entry)
{
entry->add_list = NULL;
- entry->oldpath_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify) collect_manager_action_unref);
+ entry->oldpath_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, reinterpret_cast<GDestroyNotify>(collect_manager_action_unref));
entry->newpath_hash = g_hash_table_new(g_str_hash, g_str_equal);
entry->empty = TRUE;
while (list)
{
fd = static_cast<FileData *>(list->data);
- filename = g_strdup(filename_from_path((gchar *)fd->path));
+ filename = g_strdup(filename_from_path(fd->path));
if (file_extension_match(filename, GQ_COLLECTION_EXT))
{
if (!ct) return;
- type = (SortType)GPOINTER_TO_INT(data);
+ type = static_cast<SortType>GPOINTER_TO_INT(data);
collection_set_sort_method(ct->cd, type);
}
gint ret;
adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(ct->listview));
- page_size = (gint)gtk_adjustment_get_page_increment(adj);
+ page_size = static_cast<gint>(gtk_adjustment_get_page_increment(adj));
row_height = options->thumbnails.max_height + THUMB_BORDER_PADDING * 2;
if (ct->show_text) row_height += options->thumbnails.max_height / 3;
{
auto ct = static_cast<CollectTable *>(data);
- collection_table_motion_update(ct, (gint)event->x, (gint)event->y, FALSE);
+ collection_table_motion_update(ct, static_cast<gint>(event->x), static_cast<gint>(event->y), FALSE);
return FALSE;
}
tip_unschedule(ct);
- info = collection_table_find_data_by_coord(ct, (gint)bevent->x, (gint)bevent->y, &iter);
+ info = collection_table_find_data_by_coord(ct, static_cast<gint>(bevent->x), static_cast<gint>(bevent->y), &iter);
ct->click_info = info;
collection_table_selection_add(ct, ct->click_info, SELECTION_PRELIGHT, &iter);
tip_schedule(ct);
- if ((gint)bevent->x != 0 || (gint)bevent->y != 0)
+ if (static_cast<gint>(bevent->x) != 0 || static_cast<gint>(bevent->y) != 0)
{
- info = collection_table_find_data_by_coord(ct, (gint)bevent->x, (gint)bevent->y, &iter);
+ info = collection_table_find_data_by_coord(ct, static_cast<gint>(bevent->x), static_cast<gint>(bevent->y), &iter);
}
if (ct->click_info)
work = list;
while (work)
{
- collection_add(ct->cd, (FileData *)work->data, FALSE);
+ collection_add(ct->cd, static_cast<FileData *>(work->data), FALSE);
work = work->next;
}
}
work = list;
while (work)
{
- collection_insert(ct->cd, (FileData *)work->data, insert_info, FALSE);
+ collection_insert(ct->cd, static_cast<FileData *>(work->data), insert_info, FALSE);
work = work->next;
}
if (ct->columns != 0 && ct->rows != 0)
{
- value = (gdouble)(row * ct->columns + col) / (ct->columns * ct->rows);
+ value = static_cast<gdouble>(row * ct->columns + col) / (ct->columns * ct->rows);
}
else
{
work = g_list_last(d);
while (work)
{
- collection_table_add_dir_recursive(ct, (FileData *)work->data, TRUE);
+ collection_table_add_dir_recursive(ct, static_cast<FileData *>(work->data), TRUE);
work = work->prev;
}
g_list_free(list);
}
gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
- 8, (guchar *)uri_text, total);
+ 8, reinterpret_cast<guchar *>(uri_text), total);
g_free(uri_text);
break;
case TARGET_URI_LIST:
work = list;
while (work)
{
- collection_info_free((CollectInfo *)work->data);
+ collection_info_free(static_cast<CollectInfo *>(work->data));
work = work->next;
}
g_list_free(list);
length = g_list_length(list);
if (!length) return NULL;
- srand((unsigned int)time(NULL)); // Initialize random generator (hasn't to be that much strong)
+ srand(static_cast<unsigned int>(time(NULL))); // Initialize random generator (hasn't to be that much strong)
for (i = 0; i < length; i++)
{
- random = (guint) (1.0 * length * rand()/(RAND_MAX + 1.0));
+ random = static_cast<guint>(1.0 * length * rand()/(RAND_MAX + 1.0));
olist = g_list_nth(list, i);
nlist = g_list_nth(list, random);
tmp = olist->data;
guint item_number;
CollectInfo *info;
- item_number = (guint) atoi(ptr);
+ item_number = static_cast<guint>(atoi(ptr));
while (*ptr != '\n' && *ptr != '\0') ptr++;
if (*ptr == '\0')
break;
if (!list->next)
{
/* more efficient (in collect-table) to remove a single item this way */
- collection_remove_by_info(cd, (CollectInfo *)list->data);
+ collection_remove_by_info(cd, static_cast<CollectInfo *>(list->data));
return;
}
previous = tv;
started = 1;
- g_snprintf(timestr, sizeof(timestr), "%5d.%06d (+%05d.%06d)", (gint)tv.tv_sec, (gint)tv.tv_usec, (gint)delta.tv_sec, (gint)delta.tv_usec);
+ g_snprintf(timestr, sizeof(timestr), "%5d.%06d (+%05d.%06d)", static_cast<gint>(tv.tv_sec), static_cast<gint>(tv.tv_usec), static_cast<gint>(delta.tv_sec), static_cast<gint>(delta.tv_usec));
return timestr;
}
if (gettimeofday(&tv, NULL) == -1) return 0;
- return (guint64)tv.tv_sec * 1000000 + (guint64)tv.tv_usec;
+ return static_cast<guint64>(tv.tv_sec) * 1000000 + static_cast<guint64>(tv.tv_usec);
}
static gint dupe_iterations(gint n)
d = dw->setup_count - dw->setup_n;
}
- rem = (t - d) ? ((gdouble)(dw->setup_time_count / 1000000) / (t - d)) * d : 0;
+ rem = (t - d) ? (static_cast<gdouble>(dw->setup_time_count / 1000000) / (t - d)) * d : 0;
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), value);
if (child->group)
{
dm = static_cast<DupeMatch *>(child->group->data);
- rank = (gint)floor(dm->rank);
+ rank = static_cast<gint>(floor(dm->rank));
}
else
{
}
text[DUPE_COLUMN_THUMB] = ("");
- text[DUPE_COLUMN_NAME] = (gchar *)di->fd->name;
+ text[DUPE_COLUMN_NAME] = const_cast<gchar *>(di->fd->name);
text[DUPE_COLUMN_SIZE] = text_from_size(di->fd->size);
- text[DUPE_COLUMN_DATE] = (gchar *)text_from_time(di->fd->date);
+ text[DUPE_COLUMN_DATE] = const_cast<gchar *>(text_from_time(di->fd->date));
if (di->width > 0 && di->height > 0)
{
text[DUPE_COLUMN_DIMENSIONS] = g_strdup_printf("%d x %d", di->width, di->height);
}
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return g_list_reverse(list);
if (di_n == di) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return found;
if (mask & DUPE_MATCH_SIM_HIGH) m = 0.95;
else if (mask & DUPE_MATCH_SIM_MED) m = 0.90;
- else if (mask & DUPE_MATCH_SIM_CUSTOM) m = (gdouble)options->duplicates_similarity_threshold / 100.0;
+ else if (mask & DUPE_MATCH_SIM_CUSTOM) m = static_cast<gdouble>(options->duplicates_similarity_threshold) / 100.0;
else m = 0.85;
if (fast)
*/
static gint dupe_match_binary_search_cb(gconstpointer a, gconstpointer b)
{
- const DupeItem *di1 = *((DupeItem **) a);
+ auto di1 = *(static_cast<const DupeItem *const *>(a));
auto di2 = static_cast<const DupeItem *>(b);
DupeMatchType mask = param_match_mask;
*/
static gint dupe_match_sort_cb(gconstpointer a, gconstpointer b, gpointer data)
{
- const DupeItem *di1 = *((DupeItem **) a);
- const DupeItem *di2 = *((DupeItem **) b);
+ auto di1 = *(static_cast<const DupeItem *const *>(a));
+ auto di2 = *(static_cast<const DupeItem *const *>(b));
auto dw = static_cast<DupeWindow *>(data);
DupeMatchType mask = dw->match_mask;
}
g_array_sort_with_data(array_set2, dupe_match_sort_cb, dw);
- for (i_set1 = 0; i_set1 <= (gint)(array_set1->len) - 1; i_set1++)
+ for (i_set1 = 0; i_set1 <= static_cast<gint>(array_set1->len) - 1; i_set1++)
{
auto di1 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1));
DupeItem *di2 = NULL;
/* If multiple identical entries in set 1, use the last one */
- if (i_set1 < (gint)(array_set1->len) - 2)
+ if (i_set1 < static_cast<gint>(array_set1->len) - 2)
{
di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
check_result = dupe_match_check(di1, di2, dw);
}
i_set2 = out_match_index + 1;
- if (i_set2 > (gint)(array_set2->len) - 1)
+ if (i_set2 > static_cast<gint>(array_set2->len) - 1)
{
break;
}
dupe_match_link(di2, di1, 0.0);
}
i_set2++;
- if (i_set2 > (gint)(array_set2->len) - 1)
+ if (i_set2 > static_cast<gint>(array_set2->len) - 1)
{
break;
}
g_list_free(dw->dupes);
dw->dupes = NULL;
- if ((gint)(array_set1->len) > 1)
+ if (static_cast<gint>(array_set1->len) > 1)
{
- for (i_set1 = 0; i_set1 <= (gint)(array_set1->len) - 2; i_set1++)
+ for (i_set1 = 0; i_set1 <= static_cast<gint>(array_set1->len) - 2; i_set1++)
{
auto di1 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1));
auto di2 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1 + 1));
}
i_set1++;
- if ( i_set1 + 1 > (gint)(array_set1->len) - 1)
+ if ( i_set1 + 1 > static_cast<gint>(array_set1->len) - 1)
{
break;
}
}
i_set1++;
- if (i_set1 + 1 > (gint)(array_set1->len) - 1)
+ if (i_set1 + 1 > static_cast<gint>(array_set1->len) - 1)
{
break;
}
}
dupe_window_update_progress(dw, _("Loading thumbs..."),
- length == 0 ? 0.0 : (gdouble)(row) / length, FALSE);
+ length == 0 ? 0.0 : static_cast<gdouble>(row) / length, FALSE);
dw->thumb_item = di;
thumb_loader_free(dw->thumb_loader);
if (!di->md5sum)
{
dupe_window_update_progress(dw, _("Reading checksums..."),
- dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
+ dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n - 1) / dw->setup_count, FALSE);
if (options->thumbnails.enable_caching)
{
if (di->width == 0 && di->height == 0)
{
dupe_window_update_progress(dw, _("Reading dimensions..."),
- dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
+ dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n - 1) / dw->setup_count, FALSE);
if (options->thumbnails.enable_caching)
{
if (!di->simd)
{
dupe_window_update_progress(dw, _("Reading similarity data..."),
- dw->setup_count == 0 ? 0.0 : (gdouble)dw->setup_n / dw->setup_count, FALSE);
+ dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n) / dw->setup_count, FALSE);
if (options->thumbnails.enable_caching)
{
dw->match_mask == DUPE_MATCH_SIM_CUSTOM)
{
/* This is the similarity comparison */
- dupe_list_check_match(dw, (DupeItem *)dw->working->data, dw->working);
- dupe_window_update_progress(dw, _("Queuing..."), dw->setup_count == 0 ? 0.0 : (gdouble) dw->setup_n / dw->setup_count, FALSE);
+ dupe_list_check_match(dw, static_cast<DupeItem *>(dw->working->data), dw->working);
+ dupe_window_update_progress(dw, _("Queuing..."), dw->setup_count == 0 ? 0.0 : static_cast<gdouble>(dw->setup_n) / dw->setup_count, FALSE);
dw->setup_n++;
dw->queue_count++;
work = f;
while (work)
{
- dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
+ dupe_files_add(dw, NULL, NULL, static_cast<FileData *>(work->data), TRUE);
work = work->next;
}
filelist_free(f);
work = d;
while (work)
{
- dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
+ dupe_files_add(dw, NULL, NULL, static_cast<FileData *>(work->data), TRUE);
work = work->next;
}
filelist_free(d);
if (di) list = g_list_prepend(list, di);
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
dw->color_frozen = TRUE;
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
if (event->state & GDK_CONTROL_MASK)
{
g_hash_table_destroy(editors);
}
- editors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify)editor_description_free);
+ editors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, reinterpret_cast<GDestroyNotify>(editor_description_free));
editors_finished = FALSE;
}
if (ed->total)
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ed->vd->progress), (gdouble)ed->count / ed->total);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ed->vd->progress), static_cast<gdouble>(ed->count) / ed->total);
}
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ed->vd->progress), (text) ? text : "");
flags = static_cast<EditorFlags>(flags | EDITOR_ERROR_NO_FILE);
goto err;
}
- pathl = editor_command_path_parse((FileData *)list->data,
+ pathl = editor_command_path_parse(static_cast<FileData *>(list->data),
consider_sidecars,
(*p == 'f') ? PATH_FILE : PATH_FILE_URL,
editor);
{
if (!r || r->den == 0.0) return 0.0;
- if (sign) return (gdouble)((gint)r->num) / (gdouble)((gint)r->den);
- return (gdouble)r->num / r->den;
+ if (sign) return static_cast<gdouble>(static_cast<gint>(r->num)) / static_cast<gdouble>(static_cast<gint>(r->den));
+ return static_cast<gdouble>(r->num) / r->den;
}
static gdouble exif_get_rational_as_double(ExifData *exif, const gchar *key)
r = exif_get_rational(exif, "Exif.Photo.ExposureTime", NULL);
if (r && r->num && r->den)
{
- gdouble n = (gdouble)r->den / (gdouble)r->num;
+ gdouble n = static_cast<gdouble>(r->den) / static_cast<gdouble>(r->num);
return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
n > 1.0 ? n : 1.0 / n);
}
gdouble n = pow(2.0, exif_rational_to_double(r, TRUE));
/* Correct exposure time to avoid values like 1/91s (seen on Minolta DImage 7) */
- if (n > 1.0 && (gint)n - ((gint)(n/10))*10 == 1) n--;
+ if (n > 1.0 && static_cast<gint>(n) - (static_cast<gint>(n/10))*10 == 1) n--;
return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
n > 1.0 ? floor(n) : 1.0 / n);
r = exif_get_rational(exif, "Exif.Photo.SubjectDistance", &sign);
if (!r) return NULL;
- if ((glong)r->num == (glong)0xffffffff) return g_strdup(_("infinity"));
- if ((glong)r->num == 0) return g_strdup(_("unknown"));
+ if (static_cast<glong>(r->num) == static_cast<glong>(0xffffffff)) return g_strdup(_("infinity"));
+ if (static_cast<glong>(r->num) == 0) return g_strdup(_("unknown"));
n = exif_rational_to_double(r, sign);
if (n == 0.0) return _("unknown");
if (!rx || !ry) return NULL;
units = exif_get_data_as_text(exif, "Exif.Image.ResolutionUnit");
- text = g_strdup_printf("%0.f x %0.f (%s/%s)", rx->den ? (gdouble)rx->num / rx->den : 1.0,
- ry->den ? (gdouble)ry->num / ry->den : 1.0,
+ text = g_strdup_printf("%0.f x %0.f (%s/%s)", rx->den ? static_cast<gdouble>(rx->num) / rx->den : 1.0,
+ ry->den ? static_cast<gdouble>(ry->num) / ry->den : 1.0,
_("dot"), (units) ? units : _("unknown"));
g_free(units);
{
value = exif_item_get_rational(item, NULL, i);
if (value && value->num && value->den)
- p += (gdouble)value->num / (gdouble)value->den / pow(60.0, (gdouble)i);
+ p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
}
- p1 = (gint)p;
- p2 = (gint)((p - p1)*60);
+ p1 = static_cast<gint>(p);
+ p2 = static_cast<gint>((p - p1)*60);
p3 = ((p - p1)*60 - p2)*60;
g_string_append_printf(string, "%0lu° %0lu' %0.2f\" %.1s", p1, p2, p3, ref);
{
value = exif_item_get_rational(item, NULL, i);
if (value && value->num && value->den)
- p += (gdouble)value->num / (gdouble)value->den / pow(60.0, (gdouble)i);
+ p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
}
- p1 = (gint)p;
- p2 = (gint)((p - p1)*60);
+ p1 = static_cast<gint>(p);
+ p2 = static_cast<gint>((p - p1)*60);
p3 = ((p - p1)*60 - p2)*60;
g_string_append_printf(string, ", %0lu° %0lu' %0.2f\" %.1s", p1, p2, p3, ref);
{
guint i;
- chunk_count = (guint)chunk_tot;
+ chunk_count = static_cast<guint>(chunk_tot);
for (i = 0; i < chunk_count; i++) chunk_offset[i] = 0;
for (i = 0; i < chunk_count; i++) chunk_length[i] = 0;
}
if (strcmp(key, "file.size") == 0)
{
- return g_strdup_printf("%ld", (long)fd->size);
+ return g_strdup_printf("%ld", static_cast<long>(fd->size));
}
if (strcmp(key, "file.date") == 0)
{
if (!open) io.open();
if (io.isopen())
{
- auto mapped = (unsigned char*)io.mmap();
+ auto mapped = static_cast<unsigned char*>(io.mmap());
if (mapped) exif_jpeg_parse_color(this, mapped, io.size());
io.munmap();
}
#if GLIB_CHECK_VERSION(2,68,0)
return (unsigned char *) g_memdup2(cp_data_, cp_length_);
#else
- return (unsigned char *) g_memdup(cp_data_, cp_length_);
+ return static_cast<unsigned char *>(g_memdup(cp_data_, cp_length_));
#endif
}
return NULL;
static void _ExifDataProcessed_update_xmp(gpointer key, gpointer value, gpointer data)
{
- exif_update_metadata((ExifData *)data, (gchar *)key, (GList *)value);
+ exif_update_metadata(static_cast<ExifData *>(data), static_cast<gchar *>(key), static_cast<GList *>(value));
}
ExifData *exif_read(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp)
#endif
}
}
- return (ExifItem *)item;
+ return reinterpret_cast<ExifItem *>(item);
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
#endif
}
}
- return (ExifItem *)item;
+ return reinterpret_cast<ExifItem *>(item);
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
{
try {
if (!item) return NULL;
- return g_strdup(((Exiv2::Metadatum *)item)->key().c_str());
+ return g_strdup((reinterpret_cast<Exiv2::Metadatum *>(item))->key().c_str());
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
{
try {
if (!item) return 0;
- return ((Exiv2::Metadatum *)item)->tag();
+ return (reinterpret_cast<Exiv2::Metadatum *>(item))->tag();
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
{
try {
if (!item) return 0;
- return ((Exiv2::Metadatum *)item)->count();
+ return (reinterpret_cast<Exiv2::Metadatum *>(item))->count();
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
{
try {
if (!item) return 0;
- auto md = (Exiv2::Metadatum *)item;
+ auto md = reinterpret_cast<Exiv2::Metadatum *>(item);
if (data_len) *data_len = md->size();
- auto data = (char *)g_malloc(md->size());
- long res = md->copy((Exiv2::byte *)data, Exiv2::littleEndian /* should not matter */);
+ auto data = static_cast<char *>(g_malloc(md->size()));
+ long res = md->copy(reinterpret_cast<Exiv2::byte *>(data), Exiv2::littleEndian /* should not matter */);
g_assert(res == md->size());
return data;
}
{
try {
if (!item) return NULL;
- return utf8_validate_or_convert(((Exiv2::Metadatum *)item)->tagLabel().c_str());
+ return utf8_validate_or_convert((reinterpret_cast<Exiv2::Metadatum *>(item))->tagLabel().c_str());
}
catch (std::exception& e) {
// debug_exception(e);
{
try {
if (!item) return EXIF_FORMAT_UNKNOWN;
- guint id = ((Exiv2::Metadatum *)item)->typeId();
+ guint id = (reinterpret_cast<Exiv2::Metadatum *>(item))->typeId();
if (id >= (sizeof(format_id_trans_tbl) / sizeof(format_id_trans_tbl[0])) ) return EXIF_FORMAT_UNKNOWN;
return format_id_trans_tbl[id];
}
{
try {
if (!item) return NULL;
- return ((Exiv2::Metadatum *)item)->typeName();
+ return (reinterpret_cast<Exiv2::Metadatum *>(item))->typeName();
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
{
try {
if (!item) return NULL;
- auto metadatum = (Exiv2::Metadatum *)item;
+ auto metadatum = reinterpret_cast<Exiv2::Metadatum *>(item);
#if EXIV2_TEST_VERSION(0,17,0)
return utf8_validate_or_convert(metadatum->print().c_str());
#else
{
try {
if (!item) return NULL;
- auto em = (Exiv2::Metadatum *)item;
+ auto em = reinterpret_cast<Exiv2::Metadatum *>(item);
#if EXIV2_TEST_VERSION(0,16,0)
std::string str = em->toString(idx);
#else
#if EXIV2_TEST_VERSION(0,28,0)
*value = ((Exiv2::Metadatum *)item)->toInt64();
#else
- *value = ((Exiv2::Metadatum *)item)->toLong();
+ *value = (reinterpret_cast<Exiv2::Metadatum *>(item))->toLong();
#endif
return 1;
}
try {
if (!item) return NULL;
if (n >= exif_item_get_elements(item)) return NULL;
- Exiv2::Rational v = ((Exiv2::Metadatum *)item)->toRational(n);
+ Exiv2::Rational v = (reinterpret_cast<Exiv2::Metadatum *>(item))->toRational(n);
static ExifRational ret;
ret.num = v.first;
ret.den = v.second;
- if (sign) *sign = (((Exiv2::Metadatum *)item)->typeId() == Exiv2::signedRational);
+ if (sign) *sign = ((reinterpret_cast<Exiv2::Metadatum *>(item))->typeId() == Exiv2::signedRational);
return &ret;
}
catch (Exiv2::AnyError& e) {
while (work)
{
- exif->exifData()[key] = (gchar *)work->data;
+ exif->exifData()[key] = static_cast<gchar *>(work->data);
work = work->next;
}
}
while (work)
{
- exif->iptcData()[key] = (gchar *)work->data;
+ exif->iptcData()[key] = static_cast<gchar *>(work->data);
work = work->next;
}
}
while (work)
{
- exif->xmpData()[key] = (gchar *)work->data;
+ exif->xmpData()[key] = static_cast<gchar *>(work->data);
work = work->next;
}
}
ExifItem *prof_item = exif_get_item(exif, "Exif.Image.InterColorProfile");
if (prof_item && exif_item_get_format_id(prof_item) == EXIF_FORMAT_UNDEFINED)
- ret = (guchar *)exif_item_get_data(prof_item, data_len);
+ ret = reinterpret_cast<guchar *>(exif_item_get_data(prof_item, data_len));
return ret;
}
pos = list.begin();
while (pos != last)
{
- if (pos->width_ >= (uint32_t)requested_width &&
- pos->height_ >= (uint32_t)requested_height) break;
+ if (pos->width_ >= static_cast<uint32_t>(requested_width) &&
+ pos->height_ >= static_cast<uint32_t>(requested_height)) break;
++pos;
}
// we are not interested in smaller thumbnails in normal image formats - we can use full image instead
if (!is_raw)
{
- if (pos->width_ < (uint32_t)requested_width || pos->height_ < (uint32_t)requested_height) return NULL;
+ if (pos->width_ < static_cast<uint32_t>(requested_width) || pos->height_ < static_cast<uint32_t>(requested_height)) return NULL;
}
}
void exif_free_preview(guchar *buf)
{
- delete[] (Exiv2::byte*)buf;
+ delete[] static_cast<Exiv2::byte*>(buf);
}
#endif
if (size > G_MAXINT)
{
/* the %lld conversion is not valid in all libcs, so use a simple work-around */
- a = g_strdup_printf("%d%09d", (guint)(size / 1000000000), (guint)(size % 1000000000));
+ a = g_strdup_printf("%d%09d", static_cast<guint>(size / 1000000000), static_cast<guint>(size % 1000000000));
}
else
{
- a = g_strdup_printf("%d", (guint)size);
+ a = g_strdup_printf("%d", static_cast<guint>(size));
}
l = strlen(a);
n = (l - 1)/ 3;
gchar *text_from_size_abrev(gint64 size)
{
- if (size < (gint64)1024)
+ if (size < static_cast<gint64>(1024))
{
- return g_strdup_printf(_("%d bytes"), (gint)size);
+ return g_strdup_printf(_("%d bytes"), static_cast<gint>(size));
}
- if (size < (gint64)1048576)
+ if (size < static_cast<gint64>(1048576))
{
- return g_strdup_printf(_("%.1f KiB"), (gdouble)size / 1024.0);
+ return g_strdup_printf(_("%.1f KiB"), static_cast<gdouble>(size) / 1024.0);
}
- if (size < (gint64)1073741824)
+ if (size < static_cast<gint64>(1073741824))
{
- return g_strdup_printf(_("%.1f MiB"), (gdouble)size / 1048576.0);
+ return g_strdup_printf(_("%.1f MiB"), static_cast<gdouble>(size) / 1048576.0);
}
/* to avoid overflowing the gdouble, do division in two steps */
size /= 1048576;
- return g_strdup_printf(_("%.1f GiB"), (gdouble)size / 1024.0);
+ return g_strdup_printf(_("%.1f GiB"), static_cast<gdouble>(size) / 1024.0);
}
/* note: returned string is valid until next call to text_from_time() */
GList *filelist_sort(GList *list, SortType method, gboolean ascend)
{
- return filelist_sort_full(list, method, ascend, (GCompareFunc) filelist_sort_file_cb);
+ return filelist_sort_full(list, method, ascend, reinterpret_cast<GCompareFunc>(filelist_sort_file_cb));
}
//GList *filelist_insert_sort(GList *list, FileData *fd, SortType method, gboolean ascend)
static void file_data_basename_hash_insert_cb(gpointer fd, gpointer basename_hash)
{
- file_data_basename_hash_insert((GHashTable *)basename_hash, (FileData *)fd);
+ file_data_basename_hash_insert(static_cast<GHashTable *>(basename_hash), static_cast<FileData *>(fd));
}
static void file_data_basename_hash_remove_list(gpointer UNUSED(key), gpointer value, gpointer UNUSED(data))
{
- filelist_free((GList *)value);
+ filelist_free(static_cast<GList *>(value));
}
static void file_data_basename_hash_free(GHashTable *basename_hash)
static void file_data_basename_hash_to_sidecars(gpointer UNUSED(key), gpointer value, gpointer UNUSED(data))
{
- auto basename_list = (GList *)value;
+ auto basename_list = static_cast<GList *>(value);
file_data_check_sidecars(basename_list);
}
work = list;
while (work)
{
- auto fd = (FileData *)(work->data);
+ auto fd = static_cast<FileData *>(work->data);
const gchar *name = fd->name;
if ((!options->file_filter.show_hidden_files && is_hidden_file(name)) ||
work = dirs;
while (work)
{
- auto fd = (FileData *)(work->data);
+ auto fd = static_cast<FileData *>(work->data);
GList *f;
GList *d;
work = dirs;
while (work)
{
- auto fd = (FileData *)(work->data);
+ auto fd = static_cast<FileData *>(work->data);
GList *f;
GList *d;
if (filelist_read(fd, &f, &d))
{
f = filelist_filter(f, FALSE);
- f = filelist_sort_full(f, method, ascend, (GCompareFunc) filelist_sort_file_cb);
+ f = filelist_sort_full(f, method, ascend, reinterpret_cast<GCompareFunc>(filelist_sort_file_cb));
*list = g_list_concat(*list, f);
d = filelist_filter(d, TRUE);
if (!filelist_read(dir_fd, &list, &d)) return NULL;
list = filelist_filter(list, FALSE);
- list = filelist_sort_full(list, method, ascend, (GCompareFunc) filelist_sort_file_cb);
+ list = filelist_sort_full(list, method, ascend, reinterpret_cast<GCompareFunc>(filelist_sort_file_cb));
d = filelist_filter(d, TRUE);
d = filelist_sort_path(d);
gboolean file_data_filter_file_filter(FileData *fd, GRegex *filter)
{
- return g_regex_match(filter, fd->name, (GRegexMatchFlags)0, NULL);
+ return g_regex_match(filter, fd->name, static_cast<GRegexMatchFlags>(0), NULL);
}
GList *file_data_filter_file_filter_list(GList *list, GRegex *filter)
{
if (filter & (1 << i))
{
- if ((FileFormatClass)i == filter_file_get_class(fd->path))
+ if (static_cast<FileFormatClass>(i) == filter_file_get_class(fd->path))
{
return TRUE;
}
while (work)
{
- auto nd = (NotifyData *)work->data;
+ auto nd = static_cast<NotifyData *>(work->data);
if (nd->func == func && nd->data == data)
{
while (work)
{
- auto nd = (NotifyData *)work->data;
+ auto nd = static_cast<NotifyData *>(work->data);
if (nd->func == func && nd->data == data)
{
while (work)
{
- auto nd = (NotifyData *)work->data;
+ auto nd = static_cast<NotifyData *>(work->data);
nd->func(fd, type, nd->data);
work = work->next;
if (histogram->vgrid == 0) return;
- add = width / (float)histogram->vgrid;
+ add = width / static_cast<float>(histogram->vgrid);
for (i = 1; i < histogram->vgrid; i++)
{
- gint xpos = x + (int)(i * add + 0.5);
+ gint xpos = x + static_cast<int>(i * add + 0.5);
pixbuf_draw_line(pixbuf, x, y, width, height, xpos, y, xpos, y + height,
histogram->grid_color.R,
if (histogram->hgrid == 0) return;
- add = height / (float)histogram->hgrid;
+ add = height / static_cast<float>(histogram->hgrid);
for (i = 1; i < histogram->hgrid; i++)
{
- gint ypos = y + (int)(i * add + 0.5);
+ gint ypos = y + static_cast<int>(i * add + 0.5);
pixbuf_draw_line(pixbuf, x, y, width, height, x, ypos, x + width, ypos,
histogram->grid_color.R,
if (v[chanmax] == 0)
pt = 0;
else if (histogram->histogram_mode)
- pt = ((gdouble)log(v[chanmax])) / logmax * (height - 1);
+ pt = (static_cast<gdouble>(log(v[chanmax]))) / logmax * (height - 1);
else
- pt = ((gdouble)v[chanmax]) / max * (height - 1);
+ pt = (static_cast<gdouble>(v[chanmax])) / max * (height - 1);
pixbuf_draw_line(pixbuf,
x, y, width, height,
&&
(!(strcmp(hd->key, "image_list") == 0 && list_count > options->recent_folder_image_list_maxsize)))
{
- secure_fprintf(ssi, "\"%s\"\n", (gchar *)work->data);
+ secure_fprintf(ssi, "\"%s\"\n", static_cast<gchar *>(work->data));
}
work = work->prev;
list_count--;
static gboolean image_loader_collection_load(gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
- auto ld = (ImageLoaderCOLLECTION *) loader;
+ auto ld = static_cast<ImageLoaderCOLLECTION *>(loader);
auto il = static_cast<ImageLoader *>(ld->data);
#define LINE_LENGTH 1000
static void image_loader_collection_set_size(gpointer loader, int width, int height)
{
- auto ld = (ImageLoaderCOLLECTION *) loader;
+ auto ld = static_cast<ImageLoaderCOLLECTION *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_collection_get_pixbuf(gpointer loader)
{
- auto ld = (ImageLoaderCOLLECTION *) loader;
+ auto ld = static_cast<ImageLoaderCOLLECTION *>(loader);
return ld->pixbuf;
}
static void image_loader_collection_abort(gpointer loader)
{
- auto ld = (ImageLoaderCOLLECTION *) loader;
+ auto ld = static_cast<ImageLoaderCOLLECTION *>(loader);
ld->abort = TRUE;
}
static void image_loader_collection_free(gpointer loader)
{
- auto ld = (ImageLoaderCOLLECTION *) loader;
+ auto ld = static_cast<ImageLoaderCOLLECTION *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
struct error_handler_data *errmgr;
char buffer[JMSG_LENGTH_MAX];
- errmgr = (struct error_handler_data *) cinfo->err;
+ errmgr = reinterpret_cast<struct error_handler_data *>(cinfo->err);
/* Create the message */
(* cinfo->err->format_message) (cinfo, buffer);
}
static void skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
- auto src = (struct jpeg_source_mgr*) cinfo->src;
+ auto src = static_cast<struct jpeg_source_mgr*>(cinfo->src);
- if ((gulong)num_bytes > src->bytes_in_buffer)
+ if (static_cast<gulong>(num_bytes) > src->bytes_in_buffer)
{
ERREXIT(cinfo, JERR_INPUT_EOF);
}
else if (num_bytes > 0)
{
- src->next_input_byte += (size_t) num_bytes;
- src->bytes_in_buffer -= (size_t) num_bytes;
+ src->next_input_byte += static_cast<size_t>(num_bytes);
+ src->bytes_in_buffer -= static_cast<size_t>(num_bytes);
}
}
static void term_source (j_decompress_ptr UNUSED(cinfo)) {}
if (cinfo->src == NULL)
{ /* first time for this JPEG object? */
- cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small) (
- (j_common_ptr) cinfo, JPOOL_PERMANENT,
- sizeof(struct jpeg_source_mgr));
+ cinfo->src = static_cast<struct jpeg_source_mgr *>((*cinfo->mem->alloc_small) (
+ reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT,
+ sizeof(struct jpeg_source_mgr)));
}
- src = (struct jpeg_source_mgr*) cinfo->src;
+ src = static_cast<struct jpeg_source_mgr*>(cinfo->src);
src->init_source = init_source;
src->fill_input_buffer = fill_input_buffer;
src->skip_input_data = skip_input_data;
src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
src->term_source = term_source;
src->bytes_in_buffer = nbytes;
- src->next_input_byte = (JOCTET*)buffer;
+ src->next_input_byte = static_cast<JOCTET*>(buffer);
}
static gboolean image_loader_cr3_load (gpointer loader, const guchar *buf, gsize count, GError **error)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
struct jpeg_decompress_struct cinfo;
struct jpeg_decompress_struct cinfo2;
guchar *dptr, *dptr2;
}
count = i;
- buf = (unsigned char *)buf + n + 12;
+ buf = const_cast<unsigned char *>(buf) + n + 12;
lj->stereo = FALSE;
if (idx1 >= 0 && idx2 >= 0)
{
lj->stereo = TRUE;
- stereo_buf2 = (unsigned char *)buf + mpo->images[idx2].offset;
+ stereo_buf2 = const_cast<unsigned char *>(buf) + mpo->images[idx2].offset;
stereo_length = mpo->images[idx2].length;
- buf = (unsigned char *)buf + mpo->images[idx1].offset;
+ buf = const_cast<unsigned char *>(buf) + mpo->images[idx1].offset;
count = mpo->images[idx1].length;
}
}
jpeg_create_decompress(&cinfo);
- set_mem_src(&cinfo, (unsigned char *)buf, count);
+ set_mem_src(&cinfo, const_cast<unsigned char *>(buf), count);
jpeg_read_header(&cinfo, TRUE);
static void image_loader_cr3_set_size(gpointer loader, int width, int height)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
lj->requested_width = width;
lj->requested_height = height;
}
static GdkPixbuf* image_loader_cr3_get_pixbuf(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
return lj->pixbuf;
}
static void image_loader_cr3_abort(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
lj->abort = TRUE;
}
static void image_loader_cr3_free(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
if (lj->pixbuf) g_object_unref(lj->pixbuf);
g_free(lj);
}
}
}
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsDecodeDXT3(uint width, uint height, const unsigned char *buffer) {
}
}
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsDecodeDXT2(uint width, uint height, const unsigned char *buffer) {
}
}
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsDecodeDXT4(uint width, uint height, const unsigned char *buffer) {
uint a = 255 * ((rgba & A1R5G5B5_MASKS[3]) >> 15);
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadX1R5G5B5(uint width, uint height, const unsigned char *buffer) {
uint a = 255;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadA4R4G4B4(uint width, uint height, const unsigned char *buffer) {
uint a = 17 * ((rgba & A4R4G4B4_MASKS[3]) >> 12);
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadX4R4G4B4(uint width, uint height, const unsigned char *buffer) {
uint a = 255;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadR5G6B5(uint width, uint height, const unsigned char *buffer) {
uint a = 255;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadR8G8B8(uint width, uint height, const unsigned char *buffer) {
uint a = 255;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadA8B8G8R8(uint width, uint height, const unsigned char *buffer) {
uint a = buffer[index++] & 0xFF;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadX8B8G8R8(uint width, uint height, const unsigned char *buffer) {
uint a = 255; index++;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadA8R8G8B8(uint width, uint height, const unsigned char *buffer) {
uint a = buffer[index++] & 0xFF;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
guchar *ddsReadX8R8G8B8(uint width, uint height, const unsigned char *buffer) {
uint a = 255; index++;
pixels[i] = (a << 24) | (r << 0) | (g << 8) | (b << 16);
}
- return (guchar *) pixels;
+ return reinterpret_cast<guchar *>(pixels);
}
static gboolean image_loader_dds_load (gpointer loader, const guchar *buf, gsize UNUSED(count), GError **UNUSED(error))
{
- auto ld = (ImageLoaderDDS *) loader;
+ auto ld = static_cast<ImageLoaderDDS *>(loader);
uint width = ddsGetWidth(buf);
uint height = ddsGetHeight(buf);
uint type = ddsGetType(buf);
static void image_loader_dds_set_size(gpointer loader, int width, int height)
{
- auto ld = (ImageLoaderDDS *) loader;
+ auto ld = static_cast<ImageLoaderDDS *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_dds_get_pixbuf(gpointer loader)
{
- auto ld = (ImageLoaderDDS *) loader;
+ auto ld = static_cast<ImageLoaderDDS *>(loader);
return ld->pixbuf;
}
static void image_loader_dds_abort(gpointer loader)
{
- auto ld = (ImageLoaderDDS *) loader;
+ auto ld = static_cast<ImageLoaderDDS *>(loader);
ld->abort = TRUE;
}
static void image_loader_dds_free(gpointer loader)
{
- auto ld = (ImageLoaderDDS *) loader;
+ auto ld = static_cast<ImageLoaderDDS *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
static gboolean image_loader_external_load(gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
- auto ld = (ImageLoaderExternal *) loader;
+ auto ld = static_cast<ImageLoaderExternal *>(loader);
auto il = static_cast<ImageLoader *>(ld->data);
gchar *cmd_line;
gchar *randname;
static void image_loader_external_set_size(gpointer loader, int width, int height)
{
- auto ld = (ImageLoaderExternal *) loader;
+ auto ld = static_cast<ImageLoaderExternal *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_external_get_pixbuf(gpointer loader)
{
- auto ld = (ImageLoaderExternal *) loader;
+ auto ld = static_cast<ImageLoaderExternal *>(loader);
return ld->pixbuf;
}
static void image_loader_external_abort(gpointer loader)
{
- auto ld = (ImageLoaderExternal *) loader;
+ auto ld = static_cast<ImageLoaderExternal *>(loader);
ld->abort = TRUE;
}
static void image_loader_external_free(gpointer loader)
{
- auto ld = (ImageLoaderExternal *) loader;
+ auto ld = static_cast<ImageLoaderExternal *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
void image_loader_ft_destroy_image_data(guchar *UNUSED(pixels), gpointer data)
{
- auto image = (image_data *) data;
+ auto image = static_cast<image_data *>(data);
video_thumbnailer_destroy_image_data (image);
}
static void image_loader_ft_set_size(gpointer loader, int width, int height)
{
- auto lft = (ImageLoaderFT *) loader;
+ auto lft = static_cast<ImageLoaderFT *>(loader);
lft->requested_width = width;
lft->requested_height = height;
DEBUG_1("TG: setting size, w=%d, h=%d", width, height);
// static gboolean image_loader_ft_loadfromdisk(gpointer loader, const gchar *path, GError **error)
static gboolean image_loader_ft_load (gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
- auto lft = (ImageLoaderFT *) loader;
+ auto lft = static_cast<ImageLoaderFT *>(loader);
auto il = static_cast<ImageLoader *>(lft->data);
image_data *image = video_thumbnailer_create_image_data();
static GdkPixbuf* image_loader_ft_get_pixbuf(gpointer loader)
{
- auto lft = (ImageLoaderFT *) loader;
+ auto lft = static_cast<ImageLoaderFT *>(loader);
return lft->pixbuf;
}
static void image_loader_ft_free(gpointer loader)
{
- auto lft = (ImageLoaderFT *) loader;
+ auto lft = static_cast<ImageLoaderFT *>(loader);
if (lft->pixbuf) g_object_unref(lft->pixbuf);
video_thumbnailer_destroy (lft->vt);
void image_loader_backend_set_default(ImageLoaderBackend *funcs)
{
funcs->loader_new = image_loader_gdk_new;
- funcs->set_size = (ImageLoaderBackendFuncSetSize) gdk_pixbuf_loader_set_size;
+ funcs->set_size = reinterpret_cast<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
funcs->load = NULL;
- funcs->write = (ImageLoaderBackendFuncWrite) gdk_pixbuf_loader_write;
- funcs->get_pixbuf = (ImageLoaderBackendFuncGetPixbuf) gdk_pixbuf_loader_get_pixbuf;
- funcs->close = (ImageLoaderBackendFuncClose) gdk_pixbuf_loader_close;
+ funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
+ funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
+ funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
funcs->abort = image_loader_gdk_abort;
funcs->free = image_loader_gdk_free;
struct error_handler_data *errmgr;
char buffer[JMSG_LENGTH_MAX];
- errmgr = (struct error_handler_data *) cinfo->err;
+ errmgr = reinterpret_cast<struct error_handler_data *>(cinfo->err);
/* Create the message */
(* cinfo->err->format_message) (cinfo, buffer);
}
static void skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
- auto src = (struct jpeg_source_mgr*) cinfo->src;
+ auto src = static_cast<struct jpeg_source_mgr*>(cinfo->src);
- if ((gulong)num_bytes > src->bytes_in_buffer)
+ if (static_cast<gulong>(num_bytes) > src->bytes_in_buffer)
{
ERREXIT(cinfo, JERR_INPUT_EOF);
}
else if (num_bytes > 0)
{
- src->next_input_byte += (size_t) num_bytes;
- src->bytes_in_buffer -= (size_t) num_bytes;
+ src->next_input_byte += static_cast<size_t>(num_bytes);
+ src->bytes_in_buffer -= static_cast<size_t>(num_bytes);
}
}
static void term_source (j_decompress_ptr UNUSED(cinfo)) {}
if (cinfo->src == NULL)
{ /* first time for this JPEG object? */
- cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small) (
- (j_common_ptr) cinfo, JPOOL_PERMANENT,
- sizeof(struct jpeg_source_mgr));
+ cinfo->src = static_cast<struct jpeg_source_mgr *>((*cinfo->mem->alloc_small) (
+ reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT,
+ sizeof(struct jpeg_source_mgr)));
}
- src = (struct jpeg_source_mgr*) cinfo->src;
+ src = static_cast<struct jpeg_source_mgr*>(cinfo->src);
src->init_source = init_source;
src->fill_input_buffer = fill_input_buffer;
src->skip_input_data = skip_input_data;
src->resync_to_restart = jpeg_resync_to_restart; /* use default method */
src->term_source = term_source;
src->bytes_in_buffer = nbytes;
- src->next_input_byte = (JOCTET*)buffer;
+ src->next_input_byte = static_cast<JOCTET*>(buffer);
}
static gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count, GError **error)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
struct jpeg_decompress_struct cinfo;
struct jpeg_decompress_struct cinfo2;
guchar *dptr, *dptr2;
if (idx1 >= 0 && idx2 >= 0)
{
lj->stereo = TRUE;
- stereo_buf2 = (unsigned char *)buf + mpo->images[idx2].offset;
+ stereo_buf2 = const_cast<unsigned char *>(buf) + mpo->images[idx2].offset;
stereo_length = mpo->images[idx2].length;
- buf = (unsigned char *)buf + mpo->images[idx1].offset;
+ buf = const_cast<unsigned char *>(buf) + mpo->images[idx1].offset;
count = mpo->images[idx1].length;
}
}
jpeg_create_decompress(&cinfo);
- set_mem_src(&cinfo, (unsigned char *)buf, count);
+ set_mem_src(&cinfo, const_cast<unsigned char *>(buf), count);
jpeg_read_header(&cinfo, TRUE);
static void image_loader_jpeg_set_size(gpointer loader, int width, int height)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
lj->requested_width = width;
lj->requested_height = height;
}
static GdkPixbuf* image_loader_jpeg_get_pixbuf(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
return lj->pixbuf;
}
static void image_loader_jpeg_abort(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
lj->abort = TRUE;
}
static void image_loader_jpeg_free(gpointer loader)
{
- auto lj = (ImageLoaderJpeg *) loader;
+ auto lj = static_cast<ImageLoaderJpeg *>(loader);
if (lj->pixbuf) g_object_unref(lj->pixbuf);
g_free(lj);
}
static gboolean image_loader_psd_load(gpointer loader, const guchar *buf, gsize count, GError **UNUSED(error))
{
- auto ld = (ImageLoaderPSD *) loader;
+ auto ld = static_cast<ImageLoaderPSD *>(loader);
auto ctx = g_new0(PsdContext, 1);
guint i;
guint32 j;
break;
case PSD_STATE_LINES_LENGTHS:
if (feed_buffer(
- (guchar*) ctx->lines_lengths, &ctx->bytes_read, &buf,
+ reinterpret_cast<guchar*>(ctx->lines_lengths), &ctx->bytes_read, &buf,
&size, 2 * ctx->height * ctx->channels))
{
/* convert from different endianness */
for (i = 0; i < ctx->height * ctx->channels; i++) {
ctx->lines_lengths[i] = read_uint16(
- (guchar*) &ctx->lines_lengths[i]);
+ reinterpret_cast<guchar*>(&ctx->lines_lengths[i]));
}
ctx->state = PSD_STATE_CHANNEL_DATA;
reset_context_buffer(ctx);
for (i = 0; i < ctx->height; i++) {
for (j = 0; j < ctx->width; j++) {
double c = 1.0 -
- (double) ctx->ch_bufs[0][ctx->width*i + j] / 255.0;
+ static_cast<double>(ctx->ch_bufs[0][ctx->width*i + j]) / 255.0;
double m = 1.0 -
- (double) ctx->ch_bufs[1][ctx->width*i + j] / 255.0;
+ static_cast<double>(ctx->ch_bufs[1][ctx->width*i + j]) / 255.0;
double y = 1.0 -
- (double) ctx->ch_bufs[2][ctx->width*i + j] / 255.0;
+ static_cast<double>(ctx->ch_bufs[2][ctx->width*i + j]) / 255.0;
double k = 1.0 -
- (double) ctx->ch_bufs[3][ctx->width*i + j] / 255.0;
+ static_cast<double>(ctx->ch_bufs[3][ctx->width*i + j]) / 255.0;
pixels[3*j+0] = (1.0 - (c * (1.0 - k) + k)) * 255.0;
pixels[3*j+1] = (1.0 - (m * (1.0 - k) + k)) * 255.0;
static void image_loader_psd_set_size(gpointer loader, int width, int height)
{
- auto ld = (ImageLoaderPSD *) loader;
+ auto ld = static_cast<ImageLoaderPSD *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_psd_get_pixbuf(gpointer loader)
{
- auto ld = (ImageLoaderPSD *) loader;
+ auto ld = static_cast<ImageLoaderPSD *>(loader);
return ld->pixbuf;
}
static void image_loader_psd_abort(gpointer loader)
{
- auto ld = (ImageLoaderPSD *) loader;
+ auto ld = static_cast<ImageLoaderPSD *>(loader);
ld->abort = TRUE;
}
static void image_loader_psd_free(gpointer loader)
{
- auto ld = (ImageLoaderPSD *) loader;
+ auto ld = static_cast<ImageLoaderPSD *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
void image_loader_backend_set_svgz(ImageLoaderBackend *funcs)
{
funcs->loader_new = image_loader_svgz_new;
- funcs->set_size = (ImageLoaderBackendFuncSetSize) gdk_pixbuf_loader_set_size;
+ funcs->set_size = reinterpret_cast<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
funcs->load = NULL;
- funcs->write = (ImageLoaderBackendFuncWrite) gdk_pixbuf_loader_write;
- funcs->get_pixbuf = (ImageLoaderBackendFuncGetPixbuf) gdk_pixbuf_loader_get_pixbuf;
- funcs->close = (ImageLoaderBackendFuncClose) gdk_pixbuf_loader_close;
+ funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
+ funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
+ funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
funcs->abort = image_loader_svgz_abort;
funcs->free = image_loader_svgz_free;
static gboolean image_loader_zxscr_load(gpointer loader, const guchar *buf, gsize count, GError **UNUSED(error))
{
- auto ld = (ImageLoaderZXSCR *) loader;
+ auto ld = static_cast<ImageLoaderZXSCR *>(loader);
guint8 *pixels;
gint width, height;
gint row, col, mrow, pxs, i;
static void image_loader_zxscr_set_size(gpointer loader, int width, int height)
{
- auto ld = (ImageLoaderZXSCR *) loader;
+ auto ld = static_cast<ImageLoaderZXSCR *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf *image_loader_zxscr_get_pixbuf(gpointer loader)
{
- auto ld = (ImageLoaderZXSCR *) loader;
+ auto ld = static_cast<ImageLoaderZXSCR *>(loader);
return ld->pixbuf;
}
static void image_loader_zxscr_abort(gpointer loader)
{
- auto ld = (ImageLoaderZXSCR *) loader;
+ auto ld = static_cast<ImageLoaderZXSCR *>(loader);
ld->abort = TRUE;
}
static void image_loader_zxscr_free(gpointer loader)
{
- auto ld = (ImageLoaderZXSCR *) loader;
+ auto ld = static_cast<ImageLoaderZXSCR *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
sizeof(ImageLoaderClass),
NULL, /* base_init */
NULL, /* base_finalize */
- (GClassInitFunc)image_loader_class_init_wrapper, /* class_init */
+ static_cast<GClassInitFunc>(image_loader_class_init_wrapper), /* class_init */
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(ImageLoader),
0, /* n_preallocs */
- (GInstanceInitFunc)image_loader_init, /* instance_init */
+ static_cast<GInstanceInitFunc>(image_loader_init), /* instance_init */
NULL /* value_table */
};
type = g_type_register_static(G_TYPE_OBJECT, "ImageLoaderType", &info, GTypeFlags(0));
static void image_loader_init(GTypeInstance *instance, gpointer UNUSED(g_class))
{
- auto il = (ImageLoader *)instance;
+ auto il = reinterpret_cast<ImageLoader *>(instance);
il->pixbuf = NULL;
il->idle_id = 0;
static void image_loader_finalize(GObject *object)
{
- auto il = (ImageLoader *)object;
+ auto il = reinterpret_cast<ImageLoader *>(object);
image_loader_stop(il);
if (!fd) return NULL;
- il = (ImageLoader *) g_object_new(TYPE_IMAGE_LOADER, NULL);
+ il = static_cast<ImageLoader *>(g_object_new(TYPE_IMAGE_LOADER, NULL));
il->fd = file_data_ref(fd);
if (width > il->requested_width || height > il->requested_height)
{
- if (((gdouble)il->requested_width / width) < ((gdouble)il->requested_height / height))
+ if ((static_cast<gdouble>(il->requested_width) / width) < (static_cast<gdouble>(il->requested_height) / height))
{
nw = il->requested_width;
- nh = (gdouble)nw / width * height;
+ nh = static_cast<gdouble>(nw) / width * height;
if (nh < 1) nh = 1;
}
else
{
nh = il->requested_height;
- nw = (gdouble)nh / height * width;
+ nw = static_cast<gdouble>(nh) / height * width;
if (nw < 1) nw = 1;
}
if (options->thumbnails.use_exif)
{
- il->mapped_file = exif_get_preview(exif, (guint *)&il->bytes_total, il->requested_width, il->requested_height);
+ il->mapped_file = exif_get_preview(exif, static_cast<guint *>(&il->bytes_total), il->requested_width, il->requested_height);
if (il->mapped_file)
{
}
else
{
- il->mapped_file = libraw_get_preview(il, (guint *)&il->bytes_total);
+ il->mapped_file = libraw_get_preview(il, static_cast<guint *>(&il->bytes_total));
if (il->mapped_file)
{
/* If libraw does not find a thumbnail, try exiv2 */
if (!il->mapped_file)
{
- il->mapped_file = exif_get_preview(exif, (guint *)&il->bytes_total, 0, 0); /* get the largest available preview image or NULL for normal images*/
+ il->mapped_file = exif_get_preview(exif, static_cast<guint *>(&il->bytes_total), 0, 0); /* get the largest available preview image or NULL for normal images*/
if (il->mapped_file)
{
}
else
{
- ret = (gdouble)il->bytes_read / il->bytes_total;
+ ret = static_cast<gdouble>(il->bytes_read) / il->bytes_total;
}
g_mutex_unlock(il->data_mutex);
return ret;
osd_template_insert(vars, "number", g_strdup_printf("%d", n), OSDT_NO_DUP);
osd_template_insert(vars, "total", g_strdup_printf("%d", t), OSDT_NO_DUP);
- osd_template_insert(vars, "name", (gchar *) name, OSDT_NONE);
- osd_template_insert(vars, "path", (gchar *) image_get_path(imd), OSDT_NONE);
- osd_template_insert(vars, "date", imd->image_fd ? ((gchar *) text_from_time(imd->image_fd->date)) : "", OSDT_NONE);
+ osd_template_insert(vars, "name", const_cast<gchar *>(name), OSDT_NONE);
+ osd_template_insert(vars, "path", const_cast<gchar *>(image_get_path(imd)), OSDT_NONE);
+ osd_template_insert(vars, "date", imd->image_fd ? (const_cast<gchar *>(text_from_time(imd->image_fd->date))) : "", OSDT_NONE);
osd_template_insert(vars, "size", imd->image_fd ? (text_from_size_abrev(imd->image_fd->size)) : g_strdup(""), OSDT_FREE);
osd_template_insert(vars, "zoom", image_zoom_get_as_text(imd), OSDT_FREE);
static gint image_overlay_add(ImageWindow *imd, GdkPixbuf *pixbuf, gint x, gint y,
OverlayRendererFlags flags)
{
- return pixbuf_renderer_overlay_add((PixbufRenderer *)imd->pr, pixbuf, x, y, flags);
+ return pixbuf_renderer_overlay_add(reinterpret_cast<PixbufRenderer *>(imd->pr), pixbuf, x, y, flags);
}
static void image_overlay_set(ImageWindow *imd, gint id, GdkPixbuf *pixbuf, gint x, gint y)
{
- pixbuf_renderer_overlay_set((PixbufRenderer *)imd->pr, id, pixbuf, x, y);
+ pixbuf_renderer_overlay_set(reinterpret_cast<PixbufRenderer *>(imd->pr), id, pixbuf, x, y);
}
static void image_overlay_remove(ImageWindow *imd, gint id)
{
- pixbuf_renderer_overlay_remove((PixbufRenderer *)imd->pr, id);
+ pixbuf_renderer_overlay_remove(reinterpret_cast<PixbufRenderer *>(imd->pr), id);
}
static void image_osd_icon_show(OverlayStateData *osd, ImageOSDFlag flag)
if (rect_id)
{
- pixbuf_renderer_overlay_remove((PixbufRenderer *)imd->pr, rect_id);
+ pixbuf_renderer_overlay_remove(reinterpret_cast<PixbufRenderer *>(imd->pr), rect_id);
}
lw = layout_find_by_image(imd);
switch_coords_orientation(imd, image_x_pixel, image_y_pixel, width, height);
if (rect_id)
{
- pixbuf_renderer_overlay_remove((PixbufRenderer *)imd->pr, rect_id);
+ pixbuf_renderer_overlay_remove(reinterpret_cast<PixbufRenderer *>(imd->pr), rect_id);
}
rect_width = pr->drag_last_x - pixbuf_start_x;
pixbuf_set_rect(rect_pixbuf, 1, 1, rect_width-2, rect_height - 2, 0, 0, 0, 255, 1, 1, 1, 1);
pixbuf_set_rect(rect_pixbuf, 2, 2, rect_width-4, rect_height - 4, 255, 255, 255, 255, 1, 1, 1, 1);
- rect_id = pixbuf_renderer_overlay_add((PixbufRenderer *)imd->pr, rect_pixbuf, pixbuf_start_x, pixbuf_start_y, OVL_NORMAL);
+ rect_id = pixbuf_renderer_overlay_add(reinterpret_cast<PixbufRenderer *>(imd->pr), rect_pixbuf, pixbuf_start_x, pixbuf_start_y, OVL_NORMAL);
}
pixbuf_renderer_get_scaled_size(pr, &width, &height);
if (imd->func_drag)
{
imd->func_drag(imd, event,
- (gfloat)(pr->drag_last_x - event->x) / width,
- (gfloat)(pr->drag_last_y - event->y) / height,
+ static_cast<gfloat>(pr->drag_last_x - event->x) / width,
+ static_cast<gfloat>(pr->drag_last_y - event->y) / height,
imd->data_button);
}
}
if (imd->func_scroll_notify && pr->scale)
{
imd->func_scroll_notify(imd,
- (gint)((gdouble)pr->x_scroll / pr->scale),
- (gint)((gdouble)pr->y_scroll / pr->scale),
- (gint)((gdouble)pr->image_width - pr->vis_width / pr->scale),
- (gint)((gdouble)pr->image_height - pr->vis_height / pr->scale),
+ static_cast<gint>(static_cast<gdouble>(pr->x_scroll) / pr->scale),
+ static_cast<gint>(static_cast<gdouble>(pr->y_scroll) / pr->scale),
+ static_cast<gint>(static_cast<gdouble>(pr->image_width) - pr->vis_width / pr->scale),
+ static_cast<gint>(static_cast<gdouble>(pr->image_height) - pr->vis_height / pr->scale),
imd->data_scroll_notify);
}
}
static void image_post_process_tile_color_cb(PixbufRenderer *UNUSED(pr), GdkPixbuf **pixbuf, gint x, gint y, gint w, gint h, gpointer data)
{
- auto imd = (ImageWindow *)data;
+ auto imd = static_cast<ImageWindow *>(data);
if (imd->cm) color_man_correct_region(static_cast<ColorMan *>(imd->cm), *pixbuf, x, y, w, h);
if (imd->desaturate) pixbuf_desaturate_rect(*pixbuf, x, y, w, h);
if (imd->overunderexposed) pixbuf_highlight_overunderexposed(*pixbuf, x, y, w, h);
if (imd->image_fd == fd_n && !(options->metadata.write_orientation && !options->image.exif_rotate_enable))
{
imd->orientation = orientation;
- pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, orientation);
+ pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), orientation);
}
}
{
imd->desaturate = desaturate;
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<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);
- pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, imd->orientation);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
}
gboolean image_get_desaturate(ImageWindow *imd)
{
imd->overunderexposed = overunderexposed;
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<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);
- pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, imd->orientation);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
}
gboolean image_get_overunderexposed(ImageWindow *imd)
void image_set_ignore_alpha(ImageWindow *imd, gboolean ignore_alpha)
{
- pixbuf_renderer_set_ignore_alpha((PixbufRenderer *)imd->pr, ignore_alpha);
+ pixbuf_renderer_set_ignore_alpha(reinterpret_cast<PixbufRenderer *>(imd->pr), ignore_alpha);
}
/*
{
static FileCacheData *cache = NULL;
if (!cache) cache = file_cache_new(image_cache_release_cb, 1);
- file_cache_set_max_size(cache, (gulong)options->image.image_cache_max * 1048576); /* update from options */
+ file_cache_set_max_size(cache, static_cast<gulong>(options->image.image_cache_max) * 1048576); /* update from options */
return cache;
}
{
g_assert(fd->pixbuf);
- file_cache_put(image_get_cache(), fd, (gulong)gdk_pixbuf_get_rowstride(fd->pixbuf) * (gulong)gdk_pixbuf_get_height(fd->pixbuf));
+ file_cache_put(image_get_cache(), fd, static_cast<gulong>(gdk_pixbuf_get_rowstride(fd->pixbuf)) * static_cast<gulong>(gdk_pixbuf_get_height(fd->pixbuf)));
file_data_send_notification(fd, NOTIFY_PIXBUF); /* to update histogram */
}
auto imd = static_cast<ImageWindow *>(data);
PixbufRenderer *pr;
- pr = (PixbufRenderer *)imd->pr;
+ pr = reinterpret_cast<PixbufRenderer *>(imd->pr);
if (imd->delay_flip &&
pr->pixbuf != image_loader_get_pixbuf(il))
if (options->image.enable_read_ahead && imd->image_fd && !imd->image_fd->pixbuf && image_loader_get_pixbuf(imd->il))
{
- imd->image_fd->pixbuf = (GdkPixbuf*)g_object_ref(image_loader_get_pixbuf(imd->il));
+ imd->image_fd->pixbuf = static_cast<GdkPixbuf*>(g_object_ref(image_loader_get_pixbuf(imd->il)));
image_cache_set(imd, imd->image_fd);
}
/* call the callback triggered by image_state after fd->pixbuf is set */
auto imd = static_cast<ImageWindow *>(data);
DEBUG_1("image_load_size_cb: %dx%d", width, height);
- pixbuf_renderer_set_size_early((PixbufRenderer *)imd->pr, width, height);
+ pixbuf_renderer_set_size_early(reinterpret_cast<PixbufRenderer *>(imd->pr), width, height);
}
static void image_load_error_cb(ImageLoader *il, gpointer data)
image_loader_free(imd->il);
imd->il = NULL;
- color_man_free((ColorMan *)imd->cm);
+ color_man_free(static_cast<ColorMan *>(imd->cm));
imd->cm = NULL;
imd->delay_alter_type = ALTER_NONE;
if (!(options->image.fit_window_to_image && lw && (lw->options.tools_float || lw->options.tools_hidden))) window = NULL;
- pixbuf_renderer_set_parent((PixbufRenderer *)imd->pr, (GtkWindow *)window);
+ pixbuf_renderer_set_parent(reinterpret_cast<PixbufRenderer *>(imd->pr), reinterpret_cast<GtkWindow *>(window));
image_update_title(imd);
}
GdkPixbuf *image_get_pixbuf(ImageWindow *imd)
{
- return pixbuf_renderer_get_pixbuf((PixbufRenderer *)imd->pr);
+ return pixbuf_renderer_get_pixbuf(reinterpret_cast<PixbufRenderer *>(imd->pr));
}
void image_change_pixbuf(ImageWindow *imd, GdkPixbuf *pixbuf, gdouble zoom, gboolean lazy)
}
}
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, NULL, NULL, FALSE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, FALSE);
if (imd->cm)
{
color_man_free(static_cast<ColorMan *>(imd->cm));
if (lazy)
{
- pixbuf_renderer_set_pixbuf_lazy((PixbufRenderer *)imd->pr, pixbuf, zoom, imd->orientation, stereo_data);
+ pixbuf_renderer_set_pixbuf_lazy(reinterpret_cast<PixbufRenderer *>(imd->pr), pixbuf, zoom, imd->orientation, stereo_data);
}
else
{
- pixbuf_renderer_set_pixbuf((PixbufRenderer *)imd->pr, pixbuf, zoom);
- pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, imd->orientation);
- pixbuf_renderer_set_stereo_data((PixbufRenderer *)imd->pr, stereo_data);
+ pixbuf_renderer_set_pixbuf(reinterpret_cast<PixbufRenderer *>(imd->pr), pixbuf, zoom);
+ pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
+ pixbuf_renderer_set_stereo_data(reinterpret_cast<PixbufRenderer *>(imd->pr), stereo_data);
}
if (pixbuf) g_object_unref(pixbuf);
}
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
image_state_set(imd, IMAGE_STATE_IMAGE);
}
imd->color_profile_enable = source->color_profile_enable;
imd->color_profile_input = source->color_profile_input;
imd->color_profile_use_image = source->color_profile_use_image;
- color_man_free((ColorMan *)imd->cm);
+ color_man_free(static_cast<ColorMan *>(imd->cm));
imd->cm = NULL;
if (source->cm)
{
imd->cm = source->cm;
source->cm = NULL;
- cm = (ColorMan *)imd->cm;
+ cm = static_cast<ColorMan *>(imd->cm);
cm->imd = imd;
cm->func_done_data = imd;
}
pixbuf_renderer_move(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<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);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
}
imd->color_profile_enable = source->color_profile_enable;
imd->color_profile_input = source->color_profile_input;
imd->color_profile_use_image = source->color_profile_use_image;
- color_man_free((ColorMan *)imd->cm);
+ color_man_free(static_cast<ColorMan *>(imd->cm));
imd->cm = NULL;
if (source->cm)
{
imd->cm = source->cm;
source->cm = NULL;
- cm = (ColorMan *)imd->cm;
+ cm = static_cast<ColorMan *>(imd->cm);
cm->imd = imd;
cm->func_done_data = imd;
}
pixbuf_renderer_copy(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<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);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
}
void image_area_changed(ImageWindow *imd, gint x, gint y, gint width, gint height)
{
- pixbuf_renderer_area_changed((PixbufRenderer *)imd->pr, x, y, width, height);
+ pixbuf_renderer_area_changed(reinterpret_cast<PixbufRenderer *>(imd->pr), x, y, width, height);
}
void image_reload(ImageWindow *imd)
{
- if (pixbuf_renderer_get_tiles((PixbufRenderer *)imd->pr)) return;
+ if (pixbuf_renderer_get_tiles(reinterpret_cast<PixbufRenderer *>(imd->pr))) return;
image_change_complete(imd, image_zoom_get(imd));
}
void image_scroll(ImageWindow *imd, gint x, gint y)
{
- pixbuf_renderer_scroll((PixbufRenderer *)imd->pr, x, y);
+ pixbuf_renderer_scroll(reinterpret_cast<PixbufRenderer *>(imd->pr), x, y);
}
void image_scroll_to_point(ImageWindow *imd, gint x, gint y,
gdouble x_align, gdouble y_align)
{
- pixbuf_renderer_scroll_to_point((PixbufRenderer *)imd->pr, x, y, x_align, y_align);
+ pixbuf_renderer_scroll_to_point(reinterpret_cast<PixbufRenderer *>(imd->pr), x, y, x_align, y_align);
}
void image_get_scroll_center(ImageWindow *imd, gdouble *x, gdouble *y)
void image_zoom_adjust(ImageWindow *imd, gdouble increment)
{
- pixbuf_renderer_zoom_adjust((PixbufRenderer *)imd->pr, increment);
+ pixbuf_renderer_zoom_adjust(reinterpret_cast<PixbufRenderer *>(imd->pr), increment);
}
void image_zoom_adjust_at_point(ImageWindow *imd, gdouble increment, gint x, gint y)
{
- pixbuf_renderer_zoom_adjust_at_point((PixbufRenderer *)imd->pr, increment, x, y);
+ pixbuf_renderer_zoom_adjust_at_point(reinterpret_cast<PixbufRenderer *>(imd->pr), increment, x, y);
}
void image_zoom_set_limits(ImageWindow *imd, gdouble min, gdouble max)
{
- pixbuf_renderer_zoom_set_limits((PixbufRenderer *)imd->pr, min, max);
+ pixbuf_renderer_zoom_set_limits(reinterpret_cast<PixbufRenderer *>(imd->pr), min, max);
}
void image_zoom_set(ImageWindow *imd, gdouble zoom)
{
- pixbuf_renderer_zoom_set((PixbufRenderer *)imd->pr, zoom);
+ pixbuf_renderer_zoom_set(reinterpret_cast<PixbufRenderer *>(imd->pr), zoom);
}
void image_zoom_set_fill_geometry(ImageWindow *imd, gboolean vertical)
gdouble zoom;
gint width, height;
- pr = (PixbufRenderer *)imd->pr;
+ pr = reinterpret_cast<PixbufRenderer *>(imd->pr);
if (!pixbuf_renderer_get_pixbuf(pr) ||
!pixbuf_renderer_get_image_size(pr, &width, &height)) return;
if (vertical)
{
- zoom = (gdouble)pr->viewport_height / height;
+ zoom = static_cast<gdouble>(pr->viewport_height) / height;
}
else
{
- zoom = (gdouble)pr->viewport_width / width;
+ zoom = static_cast<gdouble>(pr->viewport_width) / width;
}
if (zoom < 1.0)
gdouble image_zoom_get(ImageWindow *imd)
{
- return pixbuf_renderer_zoom_get((PixbufRenderer *)imd->pr);
+ return pixbuf_renderer_zoom_get(reinterpret_cast<PixbufRenderer *>(imd->pr));
}
gdouble image_zoom_get_real(ImageWindow *imd)
{
- return pixbuf_renderer_zoom_get_scale((PixbufRenderer *)imd->pr);
+ return pixbuf_renderer_zoom_get_scale(reinterpret_cast<PixbufRenderer *>(imd->pr));
}
gchar *image_zoom_get_as_text(ImageWindow *imd)
void image_stereo_set(ImageWindow *imd, gint stereo_mode)
{
DEBUG_1("Setting stereo mode %04x for imd %p", stereo_mode, (void *)imd);
- pixbuf_renderer_stereo_set((PixbufRenderer *)imd->pr, stereo_mode);
+ pixbuf_renderer_stereo_set(reinterpret_cast<PixbufRenderer *>(imd->pr), stereo_mode);
}
//void image_stereo_swap(ImageWindow *imd)
void image_prebuffer_set(ImageWindow *imd, FileData *fd)
{
- if (pixbuf_renderer_get_tiles((PixbufRenderer *)imd->pr)) return;
+ if (pixbuf_renderer_get_tiles(reinterpret_cast<PixbufRenderer *>(imd->pr))) return;
if (fd)
{
void image_background_set_color(ImageWindow *imd, GdkColor *color)
{
- pixbuf_renderer_set_color((PixbufRenderer *)imd->pr, color);
+ pixbuf_renderer_set_color(reinterpret_cast<PixbufRenderer *>(imd->pr), color);
}
void image_background_set_color_from_options(ImageWindow *imd, gboolean fullscreen)
NULL);
- pixbuf_renderer_set_parent((PixbufRenderer *)imd->pr, (GtkWindow *)imd->top_window);
+ pixbuf_renderer_set_parent(reinterpret_cast<PixbufRenderer *>(imd->pr), reinterpret_cast<GtkWindow *>(imd->top_window));
image_stereo_set(imd, options->stereo.mode);
- pixbuf_renderer_stereo_fixed_set((PixbufRenderer *)imd->pr,
+ pixbuf_renderer_stereo_fixed_set(reinterpret_cast<PixbufRenderer *>(imd->pr),
options->stereo.fixed_w, options->stereo.fixed_h,
options->stereo.fixed_x1, options->stereo.fixed_y1,
options->stereo.fixed_x2, options->stereo.fixed_y2);
break;
}
}
- else if ( (event->state & GDK_SHIFT_MASK) != (guint) (options->mousewheel_scrolls))
+ else if ( (event->state & GDK_SHIFT_MASK) != static_cast<guint>(options->mousewheel_scrolls))
{
switch (event->direction)
{
{
view_window_set_list(vw, list);
vw->list_pointer = vw->list;
- image_change_fd(vw->imd, (FileData *)vw->list->data, image_zoom_get_default(NULL));
+ image_change_fd(vw->imd, static_cast<FileData *>(vw->list->data), image_zoom_get_default(NULL));
/* Set fd to first in list */
fd = static_cast<FileData *>(vw->list->data);
if (options->image.enable_read_ahead)
{
GList *work = vw->list->next;
- if (work) image_prebuffer_set(vw->imd, (FileData *)work->data);
+ if (work) image_prebuffer_set(vw->imd, static_cast<FileData *>(work->data));
}
}
else
marker != JPEG_MARKER_EOI)
{
if (offset + 4 >= size) return FALSE;
- length += ((guint)data[offset + 2] << 8) + data[offset + 3];
+ length += (static_cast<guint>(data[offset + 2]) << 8) + data[offset + 3];
if (marker == app_marker &&
offset + length < size &&
static gboolean show_next_frame(gpointer data)
{
- auto fd = (AnimationData*)data;
+ auto fd = static_cast<AnimationData*>(data);
int delay;
PixbufRenderer *pr;
return FALSE;
}
- pr = (PixbufRenderer*)fd->iw->pr;
+ pr = reinterpret_cast<PixbufRenderer*>(fd->iw->pr);
if (gdk_pixbuf_animation_iter_advance(fd->iter,NULL)==FALSE)
{
if (gfstream)
{
animation->gfstream = gfstream;
- gdk_pixbuf_animation_new_from_stream_async((GInputStream*)gfstream, animation->cancellable, animation_async_ready_cb, animation);
+ gdk_pixbuf_animation_new_from_stream_async(reinterpret_cast<GInputStream*>(gfstream), animation->cancellable, animation_async_ready_cb, animation);
}
else
{
AlterType type;
lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
- type = (AlterType)GPOINTER_TO_INT(data);
+ type = static_cast<AlterType>GPOINTER_TO_INT(data);
image_alter_orientation(lw->image, lw->image->image_fd, type);
}
if (!isfile(fd->path))
{
- if ((guint) row < layout_list_count(lw, NULL) - 1)
+ if (static_cast<guint>(row) < layout_list_count(lw, NULL) - 1)
{
layout_image_next(lw);
}
if (!connect_scroll) return;
image_get_image_size(lw->image, &width, &height);
- dx = (gdouble) x / width;
- dy = (gdouble) y / height;
+ dx = static_cast<gdouble>(x) / width;
+ dy = static_cast<gdouble>(y) / height;
for (i = 0; i < MAX_SPLIT_IMAGES; i++)
{
imd->orientation = imd->image_fd->user_orientation;
}
- pixbuf_renderer_set_orientation((PixbufRenderer *)imd->pr, imd->orientation);
+ pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
}
void layout_image_set_desaturate(LayoutWindow *lw, gboolean desaturate)
if (current >= 0)
{
- if ((guint) current < layout_list_count(lw, NULL) - 1)
+ if (static_cast<guint>(current) < layout_list_count(lw, NULL) - 1)
{
layout_image_set_index(lw, current + 1);
}
/* the gtkaccelgroup of the window is stealing presses before they get to the entry (and more),
* so when the some widgets have focus, give them priority (HACK)
*/
- if (gtk_widget_event(lw->path_entry, (GdkEvent *)event))
+ if (gtk_widget_event(lw->path_entry, reinterpret_cast<GdkEvent *>(event)))
{
return TRUE;
}
if (lw->vf->file_filter.combo && gtk_widget_has_focus(gtk_bin_get_child(GTK_BIN(lw->vf->file_filter.combo))))
{
- if (gtk_widget_event(gtk_bin_get_child(GTK_BIN(lw->vf->file_filter.combo)), (GdkEvent *)event))
+ if (gtk_widget_event(gtk_bin_get_child(GTK_BIN(lw->vf->file_filter.combo)), reinterpret_cast<GdkEvent *>(event)))
{
return TRUE;
}
if (lw->vd && lw->options.dir_view_type == DIRVIEW_TREE && gtk_widget_has_focus(lw->vd->view) &&
!layout_key_match(event->keyval) &&
- gtk_widget_event(lw->vd->view, (GdkEvent *)event))
+ gtk_widget_event(lw->vd->view, reinterpret_cast<GdkEvent *>(event)))
{
return TRUE;
}
if (lw->bar &&
- bar_event(lw->bar, (GdkEvent *)event))
+ bar_event(lw->bar, reinterpret_cast<GdkEvent *>(event)))
{
return TRUE;
}
auto lw = static_cast<LayoutWindow *>(data);
layout_exit_fullscreen(lw);
- layout_views_set(lw, lw->options.dir_view_type, (FileViewType) gtk_radio_action_get_current_value(action));
+ layout_views_set(lw, lw->options.dir_view_type, static_cast<FileViewType>(gtk_radio_action_get_current_value(action)));
}
static void layout_menu_view_dir_as_cb(GtkToggleAction *action, gpointer data)
while (list)
{
- const gchar *filename = filename_from_path((gchar *)list->data);
+ const gchar *filename = filename_from_path(static_cast<gchar *>(list->data));
gchar *name;
gboolean free_name = FALSE;
}
else
{
- name = (gchar *) filename;
+ name = const_cast<gchar *>(filename);
}
item = menu_item_add_simple(menu, name, G_CALLBACK(layout_menu_recent_cb), lw);
auto wna = static_cast<const WindowNames *>(a);
auto wnb = static_cast<const WindowNames *>(b);
- return g_strcmp0((gchar *)wna->name, (gchar *)wnb->name);
+ return g_strcmp0(wna->name, wnb->name);
}
static GList *layout_window_menu_list(GList *listin)
static gchar *menu_translate(const gchar *path, gpointer UNUSED(data))
{
- return (gchar *)(_(path));
+ return static_cast<gchar *>(_(path));
}
static void layout_actions_setup_mark(LayoutWindow *lw, gint mark, const gchar *name_tmpl,
static void layout_actions_editor_add(GString *desc, GList *path, GList *old_path)
{
gint to_open, to_close, i;
- while (path && old_path && strcmp((gchar *)path->data, (gchar *)old_path->data) == 0)
+ while (path && old_path && strcmp(static_cast<gchar *>(path->data), static_cast<gchar *>(old_path->data)) == 0)
{
path = path->next;
old_path = old_path->next;
}
if (path)
- g_string_append_printf(desc, " <menuitem action='%s'/>", (gchar *)path->data);
+ g_string_append_printf(desc, " <menuitem action='%s'/>", static_cast<gchar *>(path->data));
}
static void layout_actions_setup_editors(LayoutWindow *lw)
if (!action || !lw->ui_manager) return;
- if (g_list_find_custom(lw->toolbar_actions[type], action, (GCompareFunc)strcmp)) return;
+ if (g_list_find_custom(lw->toolbar_actions[type], action, reinterpret_cast<GCompareFunc>(strcmp))) return;
switch (type)
{
lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
if (!lw) return;
- type = (SortType)GPOINTER_TO_INT(data);
+ type = static_cast<SortType>GPOINTER_TO_INT(data);
if (type == SORT_EXIFTIME || type == SORT_EXIFTIMEDIGITIZED || type == SORT_RATING)
{
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
- mode = (ZoomMode)GPOINTER_TO_INT(data);
+ mode = static_cast<ZoomMode>GPOINTER_TO_INT(data);
options->image.zoom_mode = mode;
}
}
hrs = options->slideshow.delay / (36000);
min = (options->slideshow.delay -(36000 * hrs))/600;
- sec = (gdouble)(options->slideshow.delay -(36000 * hrs)-(min * 600)) / 10;
+ sec = static_cast<gdouble>(options->slideshow.delay -(36000 * hrs)-(min * 600)) / 10;
if (hrs > 0)
{
gtk_text_iter_forward_to_line_end(&line_end);
chr_start = cursor_iter;
- gtk_text_iter_backward_find_char(&chr_start, (GtkTextCharPredicate)iter_char_search_cb, GUINT_TO_POINTER(' '), &line_start);
+ gtk_text_iter_backward_find_char(&chr_start, static_cast<GtkTextCharPredicate>(iter_char_search_cb), GUINT_TO_POINTER(' '), &line_start);
chr_end = cursor_iter;
- gtk_text_iter_forward_find_char(&chr_end, (GtkTextCharPredicate)iter_char_search_cb, GUINT_TO_POINTER(' '), &line_end);
+ gtk_text_iter_forward_find_char(&chr_end, static_cast<GtkTextCharPredicate>(iter_char_search_cb), GUINT_TO_POINTER(' '), &line_end);
gtk_text_buffer_select_range(buffer, &chr_start, &chr_end);
}
memory = g_list_prepend(memory, msg);
- while (g_list_length(memory) >= (guint)options->log_window_lines)
+ while (g_list_length(memory) >= static_cast<guint>(options->log_window_lines))
{
GList *work = g_list_last(memory);
auto oldest_msg = static_cast<LogMsg *>(work->data);
gchar *path;
length = wai_getExecutablePath(NULL, 0, NULL);
- path = (gchar *)malloc(length + 1);
+ path = static_cast<gchar *>(malloc(length + 1));
wai_getExecutablePath(path, length, NULL);
path[length] = '\0';
work = command_line->collection_list;
while (work)
{
- collection_load(cd, (gchar *)work->data, COLLECTION_LOAD_APPEND);
+ collection_load(cd, static_cast<gchar *>(work->data), COLLECTION_LOAD_APPEND);
work = work->next;
}
work = command_line->cmd_list;
while (work)
{
- fd = file_data_new_simple((gchar *)work->data);
+ fd = file_data_new_simple(static_cast<gchar *>(work->data));
selected = g_list_append(selected, fd);
file_data_unref(fd);
work = work->next;
static void md5_transform(guint32 buf[4], const guint32 in[16]);
static gint _ie = 0x44332211;
-static union _endian { gint i; gchar b[4]; } *_endian = (union _endian *)&_ie;
+static union _endian { gint i; gchar b[4]; } *_endian = reinterpret_cast<union _endian *>(&_ie);
#define IS_BIG_ENDIAN() (_endian->b[0] == '\x44')
#define IS_LITTLE_ENDIAN() (_endian->b[0] == '\x11')
{
guint32 t;
do {
- t = (guint32) ((guint32) buf[3] << 8 | buf[2]) << 16 |
- ((guint32) buf[1] << 8 | buf[0]);
- *(guint32 *) buf = t;
+ t = static_cast<guint32>(static_cast<guint32>(buf[3]) << 8 | buf[2]) << 16 |
+ (static_cast<guint32>(buf[1]) << 8 | buf[0]);
+ *reinterpret_cast<guint32 *>(buf) = t;
buf += 4;
} while (--longs);
}
/* Update bitcount */
t = ctx->bits[0];
- if ((ctx->bits[0] = t + ((guint32) len << 3)) < t)
+ if ((ctx->bits[0] = t + (len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
memcpy(p, buf, t);
if (ctx->doByteReverse)
_byte_reverse(ctx->in, 16);
- md5_transform(ctx->buf, (guint32 *) ctx->in);
+ md5_transform(ctx->buf, reinterpret_cast<guint32 *>(ctx->in));
buf += t;
len -= t;
}
memcpy(ctx->in, buf, 64);
if (ctx->doByteReverse)
_byte_reverse(ctx->in, 16);
- md5_transform(ctx->buf, (guint32 *) ctx->in);
+ md5_transform(ctx->buf, reinterpret_cast<guint32 *>(ctx->in));
buf += 64;
len -= 64;
}
memset(p, 0, count);
if (ctx->doByteReverse)
_byte_reverse(ctx->in, 16);
- md5_transform(ctx->buf, (guint32 *) ctx->in);
+ md5_transform(ctx->buf, reinterpret_cast<guint32 *>(ctx->in));
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
_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];
+ (reinterpret_cast<guint32 *>(ctx->in))[14] = ctx->bits[0];
+ (reinterpret_cast<guint32 *>(ctx->in))[15] = ctx->bits[1];
- md5_transform(ctx->buf, (guint32 *) ctx->in);
+ md5_transform(ctx->buf, reinterpret_cast<guint32 *>(ctx->in));
if (ctx->doByteReverse)
- _byte_reverse((guchar *) ctx->buf, 4);
+ _byte_reverse(reinterpret_cast<guchar *>(ctx->buf), 4);
memcpy(digest, ctx->buf, 16);
}
{
if (!fd->modified_xmp)
{
- fd->modified_xmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)string_list_free);
+ fd->modified_xmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, reinterpret_cast<GDestroyNotify>(string_list_free));
}
- g_hash_table_insert(fd->modified_xmp, g_strdup(key), string_list_copy((GList *)values));
+ g_hash_table_insert(fd->modified_xmp, g_strdup(key), string_list_copy(const_cast<GList *>(values)));
metadata_cache_remove(fd, key);
{
gchar string[50];
- g_snprintf(string, sizeof(string), "%llu", (unsigned long long) value);
+ g_snprintf(string, sizeof(string), "%llu", static_cast<unsigned long long>(value));
return metadata_write_string(fd, key, string);
}
have_keywords = g_hash_table_lookup_extended(fd->modified_xmp, KEYWORD_KEY, NULL, &keywords);
have_comment = g_hash_table_lookup_extended(fd->modified_xmp, COMMENT_KEY, NULL, &comment_l);
- comment = static_cast<const gchar *>((have_comment && comment_l) ? ((GList *)comment_l)->data : NULL);
+ comment = static_cast<const gchar *>((have_comment && comment_l) ? (static_cast<GList *>(comment_l))->data : NULL);
if (!have_keywords || !have_comment) metadata_file_read(metadata_pathl, &orig_keywords, &orig_comment);
success = metadata_file_write(metadata_pathl,
- have_keywords ? (GList *)keywords : orig_keywords,
+ have_keywords ? static_cast<GList *>(keywords) : orig_keywords,
have_comment ? comment : orig_comment);
g_free(metadata_pathl);
GList *path;
gchar *mark_str;
path = keyword_tree_get_path(keyword_tree, kw_iter);
- file_data_register_mark_func(mark, meta_data_get_keyword_mark, meta_data_set_keyword_mark, path, (GDestroyNotify)string_list_free);
+ file_data_register_mark_func(mark, meta_data_get_keyword_mark, meta_data_set_keyword_mark, path, reinterpret_cast<GDestroyNotify>(string_list_free));
mark_str = g_strdup_printf("%d", (mark < 9 ? mark : -1) + 1);
gtk_tree_store_set(GTK_TREE_STORE(keyword_tree), kw_iter, KEYWORD_COLUMN_MARK, mark_str, -1);
if (mark_str)
{
- gint i = (gint)atoi(mark_str);
+ gint i = static_cast<gint>(atoi(mark_str));
if (i == 0) i = 10;
meta_data_connect_mark_with_keyword(GTK_TREE_MODEL(keyword_tree),
gdouble get_zoom_increment(void)
{
- return ((options->image.zoom_increment != 0) ? (gdouble)options->image.zoom_increment / 100.0 : 1.0);
+ return ((options->image.zoom_increment != 0) ? static_cast<gdouble>(options->image.zoom_increment) / 100.0 : 1.0);
}
gchar *utf8_validate_or_convert(const gchar *text)
}
else
{
- s1_t = (gchar *) s1;
- s2_t = (gchar *) s2;
+ s1_t = const_cast<gchar *>(s1);
+ s2_t = const_cast<gchar *>(s2);
}
s1_key = g_utf8_collate_key(s1_t, -1);
}
if (limpos)
- limit = (guint) atoi(limpos);
+ limit = static_cast<guint>(atoi(limpos));
if (extrapos)
extra = g_strndup(extrapos, end - extrapos);
}
}
- grid = (gint)(sqrt(g_list_length(list)) + 0.5);
+ grid = static_cast<gint>(sqrt(g_list_length(list)) + 0.5);
x = pi_day->x + pi_day->width + 4;
y = pi_day->y;
DEBUG_1("biggest day contains %d images", day_max);
- grid = (gint)(sqrt((gdouble)day_max) + 0.5) * (PAN_THUMB_SIZE + PAN_SHADOW_OFFSET * 2 + PAN_THUMB_GAP);
+ grid = static_cast<gint>(sqrt(static_cast<gdouble>(day_max)) + 0.5) * (PAN_THUMB_SIZE + PAN_SHADOW_OFFSET * 2 + PAN_THUMB_GAP);
if (list)
{
work = g_list_last(list);
if (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
end_year = pan_date_value(fd->date, PAN_DATE_LENGTH_YEAR);
end_month = pan_date_value(fd->date, PAN_DATE_LENGTH_MONTH);
}
dt -= 60 * 60 * 24;
/* anything to show this month? */
- if (!pan_date_compare(((FileData *)(work->data))->date, dt, PAN_DATE_LENGTH_MONTH))
+ if (!pan_date_compare((static_cast<FileData *>(work->data))->date, dt, PAN_DATE_LENGTH_MONTH))
{
month ++;
if (month > 12)
a = 2*PI * group->diameter / parent->circumference;
- x = (gint)((gdouble)radius * cos(parent->angle + a / 2));
- y = (gint)((gdouble)radius * sin(parent->angle + a / 2));
+ x = static_cast<gint>(static_cast<gdouble>(radius) * cos(parent->angle + a / 2));
+ y = static_cast<gint>(static_cast<gdouble>(radius) * sin(parent->angle + a / 2));
parent->angle += a;
x += PAN_BOX_BORDER;
y += PAN_BOX_BORDER;
- grid_size = (gint)(sqrt(g_list_length(f)) + 0.9);
+ grid_size = static_cast<gint>(sqrt(g_list_length(f)) + 0.9);
grid_count = 0;
x_start = x;
y_height = y;
group->width = pi_box->width;
group->height = pi_box->y + pi_box->height;
- group->diameter = (gint)sqrt(group->width * group->width + group->height * group->height);
+ group->diameter = static_cast<gint>(sqrt(group->width * group->width + group->height * group->height));
group->children = NULL;
list = pan_list_tree(dir_fd, SORT_NAME, TRUE, pw->ignore_symlinks);
pan_filter_fd_list(&list, pw->filter_ui->filter_elements, pw->filter_ui->filter_classes);
- grid_size = (gint)sqrt((gdouble)g_list_length(list));
+ grid_size = static_cast<gint>(sqrt(static_cast<gdouble>(g_list_length(list))));
if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE)
{
grid_size = grid_size * (512 + PAN_THUMB_GAP) * pw->image_size / 100;
{
PangoLayout *layout;
- layout = pan_item_text_layout(pi, (GtkWidget *)pr);
- pixbuf_draw_layout(pixbuf, layout, (GtkWidget *)pr,
+ layout = pan_item_text_layout(pi, reinterpret_cast<GtkWidget *>(pr));
+ pixbuf_draw_layout(pixbuf, layout, reinterpret_cast<GtkWidget *>(pr),
pi->x - x + pi->border, pi->y - y + pi->border,
pi->color_r, pi->color_g, pi->color_b, pi->color_a);
g_object_unref(G_OBJECT(layout));
&rx, &ry, &rw, &rh))
{
gdk_pixbuf_composite(pi->pixbuf, pixbuf, rx - x, ry - y, rw, rh,
- (gdouble) tx - x,
- (gdouble) ty - y,
+ static_cast<gdouble>(tx) - x,
+ static_cast<gdouble>(ty) - y,
1.0, 1.0, GDK_INTERP_NEAREST,
255);
}
if (pi->pixbuf)
{
gdk_pixbuf_composite(pi->pixbuf, pixbuf, rx - x, ry - y, rw, rh,
- (gdouble) pi->x - x,
- (gdouble) pi->y - y,
+ static_cast<gdouble>(pi->x) - x,
+ static_cast<gdouble>(pi->y) - y,
1.0, 1.0, GDK_INTERP_NEAREST,
pi->color_a);
}
gtk_widget_show(ui->filter_check_buttons[i]);
}
- gtk_toggle_button_set_active((GtkToggleButton *)ui->filter_check_buttons[FORMAT_CLASS_IMAGE], TRUE);
- gtk_toggle_button_set_active((GtkToggleButton *)ui->filter_check_buttons[FORMAT_CLASS_RAWIMAGE], TRUE);
- gtk_toggle_button_set_active((GtkToggleButton *)ui->filter_check_buttons[FORMAT_CLASS_VIDEO], TRUE);
+ gtk_toggle_button_set_active(reinterpret_cast<GtkToggleButton *>(ui->filter_check_buttons[FORMAT_CLASS_IMAGE]), TRUE);
+ gtk_toggle_button_set_active(reinterpret_cast<GtkToggleButton *>(ui->filter_check_buttons[FORMAT_CLASS_RAWIMAGE]), TRUE);
+ gtk_toggle_button_set_active(reinterpret_cast<GtkToggleButton *>(ui->filter_check_buttons[FORMAT_CLASS_VIDEO]), TRUE);
ui->filter_classes = (1 << FORMAT_CLASS_IMAGE) | (1 << FORMAT_CLASS_RAWIMAGE) | (1 << FORMAT_CLASS_VIDEO);
// Connecting the signal before setting the state causes segfault as pw is not yet prepared
static void pan_filter_kw_button_cb(GtkButton *widget, gpointer data)
{
- auto cb_state = (PanFilterCallbackState *)data;
+ auto cb_state = static_cast<PanFilterCallbackState *>(data);
PanWindow *pw = cb_state->pw;
PanViewFilterUi *ui = pw->filter_ui;
void pan_filter_activate_cb(const gchar *text, gpointer data)
{
GtkWidget *kw_button;
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PanViewFilterUi *ui = pw->filter_ui;
GtkTreeIter iter;
void pan_filter_toggle_cb(GtkWidget *button, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PanViewFilterUi *ui = pw->filter_ui;
gboolean visible;
GtkWidget *parent;
void pan_filter_toggle_button_cb(GtkWidget *UNUSED(button), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PanViewFilterUi *ui = pw->filter_ui;
gint old_classes = ui->filter_classes;
for (gint i = 0; i < FILE_FORMAT_CLASSES; i++)
{
- ui->filter_classes |= gtk_toggle_button_get_active((GtkToggleButton *)ui->filter_check_buttons[i]) ? 1 << i : 0;
+ ui->filter_classes |= gtk_toggle_button_get_active(reinterpret_cast<GtkToggleButton *>(ui->filter_check_buttons[i])) ? 1 << i : 0;
}
if (ui->filter_classes != old_classes)
else
{
// regex compile failed; fall back to exact string match.
- GList *found_elem = g_list_find_custom(haystack, filter->keyword, (GCompareFunc)g_strcmp0);
+ GList *found_elem = g_list_find_custom(haystack, filter->keyword, reinterpret_cast<GCompareFunc>(g_strcmp0));
if (found_elem && found_kw) *found_kw = static_cast<gchar *>(found_elem->data);
return !!found_elem;
}
work = *fd_list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
GList *last_work = work;
work = work->next;
if (!text) return FALSE;
- ptr = (gchar *)text;
+ ptr = const_cast<gchar *>(text);
while (*ptr != '\0')
{
if (!g_unichar_isdigit(*ptr) && !valid_date_separator(*ptr)) return FALSE;
if (valid_date_separator(*text))
{
year = -1;
- mptr = (gchar *)text;
+ mptr = const_cast<gchar *>(text);
}
else
{
- year = (gint)strtol(text, &mptr, 10);
+ year = static_cast<gint>(strtol(text, &mptr, 10));
if (mptr == text) return FALSE;
}
void pan_search_activate_cb(const gchar *text, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
if (!text) return;
void pan_search_toggle_cb(GtkWidget *button, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PanViewSearchUi *ui = pw->search_ui;
gboolean visible;
GtkWidget *parent;
static void pan_queue_thumb_done_cb(ThumbLoader *tl, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
if (pw->queue_pi)
{
static void pan_queue_image_done_cb(ImageLoader *il, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
GdkPixbuf *rotated = NULL;
if (pw->queue_pi)
tmp = pi->pixbuf;
pi->pixbuf = gdk_pixbuf_scale_simple(tmp, pi->width, pi->height,
- (GdkInterpType)options->image.zoom_quality);
+ static_cast<GdkInterpType>(options->image.zoom_quality));
g_object_unref(tmp);
}
static gboolean pan_window_request_tile_cb(PixbufRenderer *pr, gint x, gint y,
gint width, gint height, GdkPixbuf *pixbuf, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
GList *list;
GList *work;
gint i;
static void pan_window_dispose_tile_cb(PixbufRenderer *UNUSED(pr), gint x, gint y,
gint width, gint height, GdkPixbuf *UNUSED(pixbuf), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
GList *list;
GList *work;
}
GList *pan_cache_sort(GList *list, SortType method, gboolean ascend)
{
- return filelist_sort_full(list, method, ascend, (GCompareFunc) pan_cache_sort_file_cb);
+ return filelist_sort_full(list, method, ascend, reinterpret_cast<GCompareFunc>(pan_cache_sort_file_cb));
}
static void pan_cache_step_done_cb(CacheLoader *cl, gint UNUSED(error), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
if (pw->cache_list)
{
if (l < 1) return;
- col = (gint)(sqrt((gdouble)l / grid_size) * width / height + 0.999);
+ col = static_cast<gint>(sqrt(static_cast<gdouble>(l) / grid_size) * width / height + 0.999);
col = CLAMP(col, 1, l / grid_size + 1);
- row = (gint)((gdouble)l / grid_size / col);
+ row = static_cast<gint>(static_cast<gdouble>(l) / grid_size / col);
if (row < 1) row = 1;
/* limit minimum size of grid so that a tile will always fit regardless of position */
work = pw->list;
while (work)
{
- auto pi = (PanItem *)work->data;
+ auto pi = static_cast<PanItem *>(work->data);
work = work->next;
pan_item_free(pi);
static gint pan_layout_update_idle_cb(gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
gint width;
gint height;
gint scroll_x;
static gboolean pan_window_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PixbufRenderer *pr;
FileData *fd;
gboolean stop_signal = FALSE;
static void button_cb(PixbufRenderer *pr, GdkEventButton *event, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PanItem *pi = NULL;
GtkWidget *menu;
gint rx, ry;
rx = ry = 0;
if (pr->scale)
{
- rx = (gdouble)(pr->x_scroll + event->x - pr->x_offset) / pr->scale;
- ry = (gdouble)(pr->y_scroll + event->y - pr->y_offset) / pr->scale;
+ rx = static_cast<gdouble>(pr->x_scroll + event->x - pr->x_offset) / pr->scale;
+ ry = static_cast<gdouble>(pr->y_scroll + event->y - pr->y_offset) / pr->scale;
}
pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "info");
{
case GDK_SCROLL_UP:
pixbuf_renderer_zoom_adjust_at_point(pr, ZOOM_INCREMENT,
- (gint)event->x, (gint)event->y);
+ static_cast<gint>(event->x), static_cast<gint>(event->y));
break;
case GDK_SCROLL_DOWN:
pixbuf_renderer_zoom_adjust_at_point(pr, -ZOOM_INCREMENT,
- (gint)event->x, (gint)event->y);
+ static_cast<gint>(event->x), static_cast<gint>(event->y));
break;
default:
break;
static void pan_fullscreen_stop_func(FullScreenData *UNUSED(fs), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->fs = NULL;
pw->imd = pw->imd_normal;
static void pan_window_image_zoom_cb(PixbufRenderer *UNUSED(pr), gdouble UNUSED(zoom), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
gchar *text;
text = image_zoom_get_as_text(pw->imd);
static void pan_window_image_scroll_notify_cb(PixbufRenderer *pr, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
GtkAdjustment *adj;
GdkRectangle rect;
gint width, height;
gtk_adjustment_set_step_increment(adj, 48.0 / pr->scale);
gtk_adjustment_set_lower(adj, 0.0);
gtk_adjustment_set_upper(adj, MAX((gdouble)width, 1.0));
- gtk_adjustment_set_value(adj, (gdouble)rect.x);
+ gtk_adjustment_set_value(adj, static_cast<gdouble>(rect.x));
pref_signal_block_data(pw->scrollbar_h, pw);
gtk_adjustment_changed(adj);
gtk_adjustment_set_step_increment(adj, 48.0 / pr->scale);
gtk_adjustment_set_lower(adj, 0.0);
gtk_adjustment_set_upper(adj, MAX((gdouble)height, 1.0));
- gtk_adjustment_set_value(adj, (gdouble)rect.y);
+ gtk_adjustment_set_value(adj, static_cast<gdouble>(rect.y));
pref_signal_block_data(pw->scrollbar_v, pw);
gtk_adjustment_changed(adj);
static void pan_window_scrollbar_h_value_cb(GtkRange *range, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PixbufRenderer *pr;
gint x;
if (!pr->scale) return;
- x = (gint)gtk_range_get_value(range);
+ x = static_cast<gint>(gtk_range_get_value(range));
- pixbuf_renderer_scroll_to_point(pr, x, (gint)((gdouble)pr->y_scroll / pr->scale), 0.0, 0.0);
+ pixbuf_renderer_scroll_to_point(pr, x, static_cast<gint>(static_cast<gdouble>(pr->y_scroll) / pr->scale), 0.0, 0.0);
}
static void pan_window_scrollbar_v_value_cb(GtkRange *range, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
PixbufRenderer *pr;
gint y;
if (!pr->scale) return;
- y = (gint)gtk_range_get_value(range);
+ y = static_cast<gint>(gtk_range_get_value(range));
- pixbuf_renderer_scroll_to_point(pr, (gint)((gdouble)pr->x_scroll / pr->scale), y, 0.0, 0.0);
+ pixbuf_renderer_scroll_to_point(pr, static_cast<gint>(static_cast<gdouble>(pr->x_scroll) / pr->scale), y, 0.0, 0.0);
}
static void pan_window_layout_change_cb(GtkWidget *combo, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->layout = static_cast<PanLayoutType>(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
pan_layout_update(pw);
static void pan_window_layout_size_cb(GtkWidget *combo, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->size = static_cast<PanImageSize>(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
pan_layout_update(pw);
static void pan_window_entry_activate_cb(const gchar *new_text, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
gchar *path;
path = remove_trailing_slash(new_text);
static gboolean pan_window_delete_cb(GtkWidget *UNUSED(w), GdkEventAny *UNUSED(event), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pan_window_close(pw);
return TRUE;
static void pan_warning_ok_cb(GenericDialog *gd, gpointer data)
{
- auto dir_fd = (FileData *)data;
+ auto dir_fd = static_cast<FileData *>(data);
generic_dialog_close(gd);
static void pan_new_window_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_go_to_original_cb(GtkWidget *UNUSED(widget), gpointer data)
{
LayoutWindow *lw = NULL;
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
if (!layout_valid(&lw)) return;
static void pan_zoom_in_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
image_zoom_adjust(pw->imd, ZOOM_INCREMENT);
}
static void pan_zoom_out_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
image_zoom_adjust(pw->imd, -ZOOM_INCREMENT);
}
static void pan_zoom_1_1_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
image_zoom_set(pw->imd, 1.0);
}
static void pan_copy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_copy_path_unquoted_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
static void pan_exif_date_toggle_cb(GtkWidget *widget, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->exif_date_enable = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
pan_layout_update(pw);
static void pan_info_toggle_exif_cb(GtkWidget *widget, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->info_includes_exif = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
/** @FIXME sync info now */
static void pan_info_toggle_image_cb(GtkWidget *widget, gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pw->info_image_size = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), INFO_IMAGE_SIZE_KEY));
/** @FIXME sync info now */
static void pan_fullscreen_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pan_fullscreen_toggle(pw, FALSE);
}
static void pan_close_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
pan_window_close(pw);
}
static void pan_popup_menu_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto editmenu_fd_list = (GList *)data;
+ auto editmenu_fd_list = static_cast<GList *>(data);
filelist_free(editmenu_fd_list);
}
static void pan_play_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
start_editor_from_file(options->image_l_click_video_editor, pw->click_pi->fd);
}
GtkSelectionData *selection_data, guint info,
guint UNUSED(time), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
if (gtk_drag_get_source_widget(context) == pw->imd->pr) return;
GList *list;
list = uri_filelist_from_gtk_selection_data(selection_data);
- if (list && isdir(((FileData *)list->data)->path))
+ if (list && isdir((static_cast<FileData *>(list->data))->path))
{
auto fd = static_cast<FileData *>(list->data);
GtkSelectionData *selection_data, guint UNUSED(info),
guint UNUSED(time), gpointer data)
{
- auto pw = (PanWindow *)data;
+ auto pw = static_cast<PanWindow *>(data);
FileData *fd;
fd = pan_menu_click_fd(pw);
sizeof(PixbufRendererClass), /* class_size */
NULL, /* base_init */
NULL, /* base_finalize */
- (GClassInitFunc)pixbuf_renderer_class_init_wrapper,
+ static_cast<GClassInitFunc>(pixbuf_renderer_class_init_wrapper),
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(PixbufRenderer), /* instance_size */
0, /* n_preallocs */
- (GInstanceInitFunc)pixbuf_renderer_init_wrapper, /* instance_init */
+ reinterpret_cast<GInstanceInitFunc>(pixbuf_renderer_init_wrapper), /* instance_init */
NULL, /* value_table */
};
x2 = pr->x_scroll + pr->vis_width;
y2 = pr->y_scroll + pr->vis_height;
- return !((gdouble)st->x * pr->scale > (gdouble)x2 ||
- (gdouble)(st->x + pr->source_tile_width) * pr->scale < (gdouble)x1 ||
- (gdouble)st->y * pr->scale > (gdouble)y2 ||
- (gdouble)(st->y + pr->source_tile_height) * pr->scale < (gdouble)y1);
+ return !(static_cast<gdouble>(st->x) * pr->scale > static_cast<gdouble>(x2) ||
+ static_cast<gdouble>(st->x + pr->source_tile_width) * pr->scale < static_cast<gdouble>(x1) ||
+ static_cast<gdouble>(st->y) * pr->scale > static_cast<gdouble>(y2) ||
+ static_cast<gdouble>(st->y + pr->source_tile_height) * pr->scale < static_cast<gdouble>(y1));
}
static SourceTile *pr_source_tile_new(PixbufRenderer *pr, gint x, gint y)
if (pr->width > pr->viewport_width)
{
src_x = pr->x_scroll + pr->vis_width / 2;
- pr->norm_center_x = (gdouble)src_x / pr->width;
+ pr->norm_center_x = static_cast<gdouble>(src_x) / pr->width;
}
if (pr->height > pr->viewport_height)
{
src_y = pr->y_scroll + pr->vis_height / 2;
- pr->norm_center_y = (gdouble)src_y / pr->height;
+ pr->norm_center_y = static_cast<gdouble>(src_y) / pr->height;
}
}
if ((pr->zoom_expand && !sizeable) || w > max_w || h > max_h)
{
- if ((gdouble)max_w / w > (gdouble)max_h / h / pr->aspect_ratio)
+ if (static_cast<gdouble>(max_w) / w > static_cast<gdouble>(max_h) / h / pr->aspect_ratio)
{
- scale = (gdouble)max_h / h / pr->aspect_ratio;
+ scale = static_cast<gdouble>(max_h) / h / pr->aspect_ratio;
h = max_h;
w = w * scale + 0.5;
if (w > max_w) w = max_w;
}
else
{
- scale = (gdouble)max_w / w;
+ scale = static_cast<gdouble>(max_w) / w;
w = max_w;
h = h * scale * pr->aspect_ratio + 0.5;
if (h > max_h) h = max_h;
if (pr->autofit_limit)
{
- gdouble factor = (gdouble)pr->autofit_limit_size / 100;
+ gdouble factor = static_cast<gdouble>(pr->autofit_limit_size) / 100;
w = w * factor + 0.5;
h = h * factor + 0.5;
scale = scale * factor;
if (pr->zoom_expand)
{
- gdouble factor = (gdouble)pr->enlargement_limit_size / 100;
+ gdouble factor = static_cast<gdouble>(pr->enlargement_limit_size) / 100;
if (scale > factor)
{
w = w * factor / scale;
{
case PR_SCROLL_RESET_NOCHANGE:
/* maintain old scroll position */
- pr->x_scroll = ((gdouble)pr->image_width * old_center_x * pr->scale) - pr->vis_width / 2;
- pr->y_scroll = ((gdouble)pr->image_height * old_center_y * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
+ pr->x_scroll = (static_cast<gdouble>(pr->image_width) * old_center_x * pr->scale) - pr->vis_width / 2;
+ pr->y_scroll = (static_cast<gdouble>(pr->image_height) * old_center_y * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
break;
case PR_SCROLL_RESET_CENTER:
/* center new image */
- pr->x_scroll = ((gdouble)pr->image_width / 2.0 * pr->scale) - pr->vis_width / 2;
- pr->y_scroll = ((gdouble)pr->image_height / 2.0 * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
+ pr->x_scroll = (static_cast<gdouble>(pr->image_width) / 2.0 * pr->scale) - pr->vis_width / 2;
+ pr->y_scroll = (static_cast<gdouble>(pr->image_height) / 2.0 * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
break;
case PR_SCROLL_RESET_TOPLEFT:
default:
x_align = CLAMP(x_align, 0.0, 1.0);
y_align = CLAMP(y_align, 0.0, 1.0);
- ax = (gdouble)pr->vis_width * x_align;
- ay = (gdouble)pr->vis_height * y_align;
+ ax = static_cast<gdouble>(pr->vis_width) * x_align;
+ ay = static_cast<gdouble>(pr->vis_height) * y_align;
- px = (gdouble)x * pr->scale - (pr->x_scroll + ax);
- py = (gdouble)y * pr->scale * pr->aspect_ratio - (pr->y_scroll + ay);
+ px = static_cast<gdouble>(x) * pr->scale - (pr->x_scroll + ax);
+ py = static_cast<gdouble>(y) * pr->scale * pr->aspect_ratio - (pr->y_scroll + ay);
pixbuf_renderer_scroll(pr, px, py);
}
dst_x = x * pr->width - pr->vis_width / 2 - pr->x_scroll + CLAMP(pr->subpixel_x_scroll, -1.0, 1.0);
dst_y = y * pr->height - pr->vis_height / 2 - pr->y_scroll + CLAMP(pr->subpixel_y_scroll, -1.0, 1.0);
- pr->subpixel_x_scroll = dst_x - (gint)dst_x;
- pr->subpixel_y_scroll = dst_y - (gint)dst_y;
+ pr->subpixel_x_scroll = dst_x - static_cast<gint>(dst_x);
+ pr->subpixel_y_scroll = dst_y - static_cast<gint>(dst_y);
- pixbuf_renderer_scroll(pr, (gint)dst_x, (gint)dst_y);
+ pixbuf_renderer_scroll(pr, static_cast<gint>(dst_x), static_cast<gint>(dst_y));
}
/*
prs = gdk_pixbuf_get_rowstride(pb);
p_pix = gdk_pixbuf_get_pixels(pb);
- xoff = (size_t)map_x * (p_alpha ? 4 : 3);
- yoff = (size_t)map_y * prs;
+ xoff = static_cast<size_t>(map_x) * (p_alpha ? 4 : 3);
+ yoff = static_cast<size_t>(map_y) * prs;
pp = p_pix + yoff + xoff;
*r_mouse = *pp;
pp++;
return FALSE;
}
- x_pixel = floor((gdouble)(pr->x_mouse - pr->x_offset + pr->x_scroll) / pr->scale);
- y_pixel = floor((gdouble)(pr->y_mouse - pr->y_offset + pr->y_scroll) / pr->scale / pr->aspect_ratio);
+ x_pixel = floor(static_cast<gdouble>(pr->x_mouse - pr->x_offset + pr->x_scroll) / pr->scale);
+ y_pixel = floor(static_cast<gdouble>(pr->y_mouse - pr->y_offset + pr->y_scroll) / pr->scale / pr->aspect_ratio);
x_pixel_clamped = CLAMP(x_pixel, 0, pr->image_width - 1);
y_pixel_clamped = CLAMP(y_pixel, 0, pr->image_height - 1);
return FALSE;
}
- rect->x = (gint)((gdouble)pr->x_scroll / pr->scale);
- rect->y = (gint)((gdouble)pr->y_scroll / pr->scale / pr->aspect_ratio);
- rect->width = (gint)((gdouble)pr->vis_width / pr->scale);
- rect->height = (gint)((gdouble)pr->vis_height / pr->scale / pr->aspect_ratio);
+ rect->x = static_cast<gint>(static_cast<gdouble>(pr->x_scroll) / pr->scale);
+ rect->y = static_cast<gint>(static_cast<gdouble>(pr->y_scroll) / pr->scale / pr->aspect_ratio);
+ rect->width = static_cast<gint>(static_cast<gdouble>(pr->vis_width) / pr->scale);
+ rect->height = static_cast<gint>(static_cast<gdouble>(pr->vis_height) / pr->scale / pr->aspect_ratio);
return TRUE;
}
gint old_w, gint old_h,
gint *new_w, gint *new_h)
{
- if (((gdouble)req_w / old_w) < ((gdouble)req_h / old_h))
+ if ((static_cast<gdouble>(req_w) / old_w) < (static_cast<gdouble>(req_h) / old_h))
{
*new_w = req_w;
- *new_h = (gdouble)*new_w / old_w * old_h;
+ *new_h = static_cast<gdouble>(*new_w) / old_w * old_h;
if (*new_h < 1) *new_h = 1;
}
else
{
*new_h = req_h;
- *new_w = (gdouble)*new_h / old_h * old_w;
+ *new_w = static_cast<gdouble>(*new_h) / old_h * old_w;
if (*new_w < 1) *new_w = 1;
}
t = y1; y1 = y2; y2 = t;
}
- slope1 = (gdouble)(y2 - y1);
- if (slope1) slope1 = (gdouble)(x2 - x1) / slope1;
+ slope1 = static_cast<gdouble>(y2 - y1);
+ if (slope1) slope1 = static_cast<gdouble>(x2 - x1) / slope1;
slope1_x = x1;
slope1_y = y1;
- slope2 = (gdouble)(y3 - y1);
- if (slope2) slope2 = (gdouble)(x3 - x1) / slope2;
+ slope2 = static_cast<gdouble>(y3 - y1);
+ if (slope2) slope2 = static_cast<gdouble>(x3 - x1) / slope2;
for (y = fy1; y < fy2; y++)
{
if (!middle && y > y2)
{
- slope1 = (gdouble)(y3 - y2);
- if (slope1) slope1 = (gdouble)(x3 - x2) / slope1;
+ slope1 = static_cast<gdouble>(y3 - y2);
+ if (slope1) slope1 = static_cast<gdouble>(x3 - x2) / slope1;
slope1_x = x2;
slope1_y = y2;
middle = TRUE;
}
- xa = slope1_x + ((gdouble)slope1 * (y - slope1_y) + 0.5);
- xb = x1 + ((gdouble)slope2 * (y - y1) + 0.5);
+ xa = slope1_x + (slope1 * (y - slope1_y) + 0.5);
+ xb = x1 + (slope2 * (y - y1) + 0.5);
if (xa > xb)
{
if (!util_clip_region(0, 0, pw, ph,
clip_x, clip_y, clip_w, clip_h,
&rx, &ry, &rw, &rh)) return;
- if (!util_clip_line((gdouble)rx, (gdouble)ry, (gdouble)rw, (gdouble)rh,
- (gdouble)x1, (gdouble)y1, (gdouble)x2, (gdouble)y2,
+ if (!util_clip_line(static_cast<gdouble>(rx), static_cast<gdouble>(ry), static_cast<gdouble>(rw), static_cast<gdouble>(rh),
+ static_cast<gdouble>(x1), static_cast<gdouble>(y1), static_cast<gdouble>(x2), static_cast<gdouble>(y2),
&rx1, &ry1, &rx2, &ry2)) return;
cx1 = rx;
if (slope != 0.0) slope = (ry2 - ry1) / slope;
for (x = rx1; x < rx2; x += 1.0)
{
- px = (gint)(x + 0.5);
- py = (gint)(ry1 + (x - rx1) * slope + 0.5);
+ px = static_cast<gint>(x + 0.5);
+ py = static_cast<gint>(ry1 + (x - rx1) * slope + 0.5);
if (px >= cx1 && px < cx2 && py >= cy1 && py < cy2)
{
if (slope != 0.0) slope = (rx2 - rx1) / slope;
for (y = ry1; y < ry2; y += 1.0)
{
- px = (gint)(rx1 + (y - ry1) * slope + 0.5);
- py = (gint)(y + 0.5);
+ px = static_cast<gint>(rx1 + (y - ry1) * slope + 0.5);
+ py = static_cast<gint>(y + 0.5);
if (px >= cx1 && px < cx2 && py >= cy1 && py < cy2)
{
static void zoom_increment_cb(GtkWidget *spin, gpointer UNUSED(data))
{
- c_options->image.zoom_increment = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) * 100.0 + 0.01);
+ c_options->image.zoom_increment = static_cast<gint>(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) * 100.0 + 0.01);
}
static void slideshow_delay_hours_cb(GtkWidget *spin, gpointer UNUSED(data))
hours_mins = c_options->slideshow.delay / (60 * SLIDESHOW_SUBSECOND_PRECISION);
delay = (hours_mins * (60 * SLIDESHOW_SUBSECOND_PRECISION)) +
- (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) *
- (gdouble)(SLIDESHOW_SUBSECOND_PRECISION) + 0.01);
+ static_cast<gint>(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) *
+ static_cast<gdouble>(SLIDESHOW_SUBSECOND_PRECISION) + 0.01);
c_options->slideshow.delay = delay > 0 ? delay : SLIDESHOW_MIN_SECONDS *
SLIDESHOW_SUBSECOND_PRECISION;
n = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
if (n < 0) return;
- if ((guint) n < sizeof(thumb_size_list) / sizeof(ThumbSize))
+ if (static_cast<guint>(n) < sizeof(thumb_size_list) / sizeof(ThumbSize))
{
c_options->thumbnails.max_width = thumb_size_list[n].w;
c_options->thumbnails.max_height = thumb_size_list[n].h;
combo = gtk_combo_box_text_new();
current = -1;
- for (i = 0; (guint) i < sizeof(thumb_size_list) / sizeof(ThumbSize); i++)
+ for (i = 0; static_cast<guint>(i) < sizeof(thumb_size_list) / sizeof(ThumbSize); i++)
{
gint w, h;
gchar *buf;
filter_add_unique("description", ".new", FORMAT_CLASS_IMAGE, TRUE, FALSE, TRUE);
filter_store_populate();
- g_idle_add((GSourceFunc)filter_add_scroll, data);
+ g_idle_add(static_cast<GSourceFunc>(filter_add_scroll), data);
}
static void filter_remove_cb(GtkWidget *UNUSED(widget), gpointer data)
filter_rebuild();
filter_store_populate();
- g_idle_add((GSourceFunc)filter_default_ok_scroll, gd->data);
+ g_idle_add(reinterpret_cast<GSourceFunc>(filter_default_ok_scroll), gd->data);
}
static void dummy_cancel_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
static void accel_store_edited_cb(GtkCellRendererAccel *UNUSED(accel), gchar *path_string, guint accel_key, GdkModifierType accel_mods, guint UNUSED(hardware_keycode), gpointer UNUSED(user_data))
{
- auto model = (GtkTreeModel *)accel_store;
+ auto model = reinterpret_cast<GtkTreeModel *>(accel_store);
GtkTreeIter iter;
gchar *acc;
gchar *accel_path;
{
accel_store_populate();
- g_idle_add((GSourceFunc)accel_default_scroll, data);
+ g_idle_add(reinterpret_cast<GSourceFunc>(accel_default_scroll), data);
}
void accel_clear_selection(GtkTreeModel *UNUSED(model), GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer UNUSED(data))
{
hex_value = 0x003F; // Unicode 'Question Mark'
}
- str = g_string_append_unichar(str, (gunichar)hex_value);
+ str = g_string_append_unichar(str, static_cast<gunichar>(hex_value));
gtk_label_set_text(static_cast<GtkLabel *>(g_list_nth_data(list, 1)), str->str);
g_strfreev(hex_code);
hours = options->slideshow.delay / (3600 * SLIDESHOW_SUBSECOND_PRECISION);
remainder = options->slideshow.delay % (3600 * SLIDESHOW_SUBSECOND_PRECISION);
minutes = remainder / (60 * SLIDESHOW_SUBSECOND_PRECISION);
- seconds = (gdouble)(remainder % (60 * SLIDESHOW_SUBSECOND_PRECISION)) /
+ seconds = static_cast<gdouble>(remainder % (60 * SLIDESHOW_SUBSECOND_PRECISION)) /
SLIDESHOW_SUBSECOND_PRECISION;
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
c_options->image.zoom_increment = options->image.zoom_increment;
spin = pref_spin_new(group, _("Zoom increment:"), NULL,
- 0.01, 4.0, 0.01, 2, (gdouble)options->image.zoom_increment / 100.0,
+ 0.01, 4.0, 0.01, 2, static_cast<gdouble>(options->image.zoom_increment) / 100.0,
G_CALLBACK(zoom_increment_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_ext_edit_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
- g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
+ g_object_set(G_OBJECT(renderer), "editable", static_cast<gboolean>TRUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_EXTENSION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_desc_edit_cb), filter_store);
- g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
+ g_object_set(G_OBJECT(renderer), "editable", static_cast<gboolean>TRUE, NULL);
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_DESCRIPTION), NULL);
gtk_tree_view_column_set_title(column, _("Class"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_combo_new();
- g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE,
+ g_object_set(G_OBJECT(renderer), "editable", static_cast<gboolean>TRUE,
"model", create_class_model(),
"text-column", 0,
"has-entry", FALSE,
pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
options->progressive_key_scrolling, &c_options->progressive_key_scrolling);
pref_spin_new_int(group, _("Keyboard scrolling step multiplier:"), NULL,
- 1, 32, 1, options->keyboard_scroll_step, (int *)&c_options->keyboard_scroll_step);
+ 1, 32, 1, options->keyboard_scroll_step, reinterpret_cast<int *>(&c_options->keyboard_scroll_step));
pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
options->mousewheel_scrolls, &c_options->mousewheel_scrolls);
pref_checkbox_new_int(group, _("Navigation by left or middle click on image"),
if (!g_cancellable_is_cancelled(tz->cancellable))
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(tz->progress), (gdouble)current_num_bytes / total_num_bytes);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(tz->progress), static_cast<gdouble>(current_num_bytes) / total_num_bytes);
}
}
osd_template_insert(vars, "number", g_strdup_printf("%d", page_nr + 1), OSDT_NO_DUP);
osd_template_insert(vars, "total", g_strdup_printf("%d", total), OSDT_NO_DUP);
- osd_template_insert(vars, "name", (gchar *) name, OSDT_NONE);
- osd_template_insert(vars, "date", fd ? ((gchar *) text_from_time(fd->date)) : "", OSDT_NONE);
+ osd_template_insert(vars, "name", const_cast<gchar *>(name), OSDT_NONE);
+ osd_template_insert(vars, "date", fd ? (const_cast<gchar *>(text_from_time(fd->date))) : "", OSDT_NONE);
osd_template_insert(vars, "size", fd ? (text_from_size_abrev(fd->size)) : g_strdup(""), OSDT_FREE);
if (fd->pixbuf)
pango_layout_set_font_description(layout_image, desc);
pango_layout_get_extents(layout_image, &ink_rect, &logical_rect);
- image_text_width = ((gdouble)logical_rect.width / PANGO_SCALE) ;
- image_text_height = ((gdouble)logical_rect.height / PANGO_SCALE);
+ image_text_width = (static_cast<gdouble>(logical_rect.width) / PANGO_SCALE) ;
+ image_text_height = (static_cast<gdouble>(logical_rect.height) / PANGO_SCALE);
pango_layout_set_alignment(layout_image, PANGO_ALIGN_CENTER);
pango_layout_set_text(layout_image, image_text->str, -1);
pango_layout_set_font_description(layout_page, desc);
pango_layout_get_extents(layout_page, &ink_rect, &logical_rect);
- page_text_width = ((gdouble)logical_rect.width / PANGO_SCALE) ;
- page_text_height = ((gdouble)logical_rect.height / PANGO_SCALE);
+ page_text_width = (static_cast<gdouble>(logical_rect.width) / PANGO_SCALE) ;
+ page_text_height = (static_cast<gdouble>(logical_rect.height) / PANGO_SCALE);
pango_layout_set_alignment(layout_page, PANGO_ALIGN_CENTER);
pango_layout_set_text(layout_page, page_text->str, -1);
'"', 0 /* '"' is handled in g_markup_escape_text */
};
- gchar *escval1 = g_strescape(text ? text : "", (gchar *) no_quote_utf);
+ gchar *escval1 = g_strescape(text ? text : "", reinterpret_cast<const gchar *>(no_quote_utf));
gchar *escval2 = g_markup_escape_text(escval1, -1);
g_string_append_printf(str, "%s = \"%s\" ", label, escval2);
g_free(escval2);
addr.sun_family = AF_UNIX;
sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX);
strncpy(addr.sun_path, path, sun_path_len);
- if (bind(fd, (const struct sockaddr*)&addr, sizeof(addr)) == -1 ||
+ if (bind(fd, reinterpret_cast<const struct sockaddr*>(&addr), sizeof(addr)) == -1 ||
listen(fd, REMOTE_SERVER_BACKLOG) == -1)
{
log_printf("error subscribing to socket: %s\n", strerror(errno));
addr.sun_family = AF_UNIX;
sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX);
strncpy(addr.sun_path, path, sun_path_len);
- if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1)
+ if (connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == -1)
{
DEBUG_1("error connecting to socket: %s", strerror(errno));
close(fd);
n = 0;
}
- options->slideshow.delay = (gint)(n * 10.0 + 0.01);
+ options->slideshow.delay = static_cast<gint>(n * 10.0 + 0.01);
}
static void gr_tools_show(const gchar *UNUSED(text), GIOChannel *UNUSED(channel), gpointer UNUSED(data))
if (!layout_valid(&lw_id)) return;
- pr = (PixbufRenderer*)lw_id->image->pr;
+ pr = reinterpret_cast<PixbufRenderer*>(lw_id->image->pr);
if (pr)
{
if (!options->draw_rectangle) return;
if (!layout_valid(&lw_id)) return;
- pr = (PixbufRenderer*)lw_id->image->pr;
+ pr = reinterpret_cast<PixbufRenderer*>(lw_id->image->pr);
if (pr)
{
while (work && remote_data->single_dir)
{
gchar *dirname;
- dirname = g_path_get_dirname(((FileData *)work->data)->path);
+ dirname = g_path_get_dirname((static_cast<FileData *>(work->data))->path);
if (!path)
{
path = g_strdup(dirname);
layout_select_list(lw_id, remote_data->file_list);
layout_refresh(lw_id);
- first = (FileData *)(g_list_first(vf_selection_get_list(lw_id->vf))->data);
+ first = static_cast<FileData *>(g_list_first(vf_selection_get_list(lw_id->vf))->data);
layout_set_fd(lw_id, first);
CollectionData *cd;
pr->viewport_width, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
pr->x_offset, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
pr->viewport_width - pr->vis_width - pr->x_offset, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
pr->vis_width, pr->y_offset,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
pr->vis_width, pr->viewport_height - pr->vis_height - pr->y_offset,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
cairo_surface_t *surface;
guint size;
- surface = gdk_window_create_similar_surface(gtk_widget_get_window((GtkWidget *)pr),
+ surface = gdk_window_create_similar_surface(gtk_widget_get_window(reinterpret_cast<GtkWidget *>(pr)),
CAIRO_CONTENT_COLOR,
rt->tile_width, rt->tile_height);
{
if (!rt->overlay_buffer)
{
- rt->overlay_buffer = gdk_window_create_similar_surface(gtk_widget_get_window((GtkWidget *)pr),
+ rt->overlay_buffer = gdk_window_create_similar_surface(gtk_widget_get_window(reinterpret_cast<GtkWidget *>(pr)),
CAIRO_CONTENT_COLOR,
rt->tile_width, rt->tile_height);
}
gint renderer_tiles_overlay_add(void *renderer, GdkPixbuf *pixbuf, gint x, gint y,
OverlayRendererFlags flags)
{
- auto rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
OverlayData *od;
gint id;
void renderer_tiles_overlay_set(void *renderer, gint id, GdkPixbuf *pixbuf, gint UNUSED(x), gint UNUSED(y))
{
- auto rc = (RendererTiles *)renderer;
+ auto rc = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rc->pr;
OverlayData *od;
gboolean renderer_tiles_overlay_get(void *renderer, gint id, GdkPixbuf **pixbuf, gint *x, gint *y)
{
- auto rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
OverlayData *od;
gint sx, sy, sw, sh;
if (pr->image_width == 0 || pr->image_height == 0) return FALSE;
- scale_x = (gdouble)pr->width / pr->image_width;
- scale_y = (gdouble)pr->height / pr->image_height;
+ scale_x = static_cast<gdouble>(pr->width) / pr->image_width;
+ scale_y = static_cast<gdouble>(pr->height) / pr->image_height;
- sx = (gdouble)(it->x + x) / scale_x;
- sy = (gdouble)(it->y + y) / scale_y;
- sw = (gdouble)w / scale_x;
- sh = (gdouble)h / scale_y;
+ sx = static_cast<gdouble>(it->x + x) / scale_x;
+ sy = static_cast<gdouble>(it->y + y) / scale_y;
+ sw = static_cast<gdouble>(w) / scale_x;
+ sh = static_cast<gdouble>(h) / scale_y;
if (pr->width < PR_MIN_SCALE_SIZE || pr->height < PR_MIN_SCALE_SIZE) fast = TRUE;
st = static_cast<SourceTile *>(work->data);
work = work->next;
- stx = floor((gdouble)st->x * scale_x);
- sty = floor((gdouble)st->y * scale_y);
- stw = ceil((gdouble)(st->x + pr->source_tile_width) * scale_x) - stx;
- sth = ceil((gdouble)(st->y + pr->source_tile_height) * scale_y) - sty;
+ stx = floor(static_cast<gdouble>(st->x) * scale_x);
+ sty = floor(static_cast<gdouble>(st->y) * scale_y);
+ stw = ceil(static_cast<gdouble>(st->x + pr->source_tile_width) * scale_x) - stx;
+ sth = ceil(static_cast<gdouble>(st->y + pr->source_tile_height) * scale_y) - sty;
if (pr_clip_region(stx, sty, stw, sth,
it->x + x, it->y + y, w, h,
gdouble offset_y;
/* may need to use unfloored stx,sty values here */
- offset_x = (gdouble)(stx - it->x);
- offset_y = (gdouble)(sty - it->y);
+ offset_x = static_cast<gdouble>(stx - it->x);
+ offset_y = static_cast<gdouble>(sty - it->y);
gdk_pixbuf_scale(st->pixbuf, it->pixbuf, rx - it->x, ry - it->y, rw, rh,
- (gdouble) 0.0 + offset_x,
- (gdouble) 0.0 + offset_y,
+ static_cast<gdouble>(0.0) + offset_x,
+ static_cast<gdouble>(0.0) + offset_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality);
draw = TRUE;
{
for (c = 0; c < 3; c++)
{
- pdst[(y * drs) + x*3 + c] = psrc[(-(int)offset_y + pb_y + y) * srs + (-(int)offset_x + pb_x+x)*3 + c];
+ pdst[(y * drs) + x*3 + c] = psrc[(-static_cast<int>(offset_y) + pb_y + y) * srs + (-static_cast<int>(offset_x) + pb_x+x)*3 + c];
}
}
}
if (pr->image_width == 0 || pr->image_height == 0) return;
- scale_x = rt->hidpi_scale * (gdouble)pr->width / pr->image_width;
- scale_y = rt->hidpi_scale * (gdouble)pr->height / pr->image_height;
+ scale_x = rt->hidpi_scale * static_cast<gdouble>(pr->width) / pr->image_width;
+ scale_y = rt->hidpi_scale * static_cast<gdouble>(pr->height) / pr->image_height;
pr_tile_coords_map_orientation(orientation, it->x, it->y,
pr->width, pr->height,
rt_tile_get_region(has_alpha, pr->ignore_alpha,
pr->pixbuf, it->pixbuf, pb_x, pb_y, pb_w, pb_h,
- (gdouble) 0.0 - src_x - GET_RIGHT_PIXBUF_OFFSET(rt) * scale_x,
- (gdouble) 0.0 - src_y,
+ static_cast<gdouble>(0.0) - src_x - GET_RIGHT_PIXBUF_OFFSET(rt) * scale_x,
+ static_cast<gdouble>(0.0) - src_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality,
it->x + pb_x, it->y + pb_y, wide_image);
GdkPixbuf *right_pb = rt_get_spare_tile(rt);
rt_tile_get_region(has_alpha, pr->ignore_alpha,
pr->pixbuf, right_pb, pb_x, pb_y, pb_w, pb_h,
- (gdouble) 0.0 - src_x - GET_LEFT_PIXBUF_OFFSET(rt) * scale_x,
- (gdouble) 0.0 - src_y,
+ static_cast<gdouble>(0.0) - src_x - GET_LEFT_PIXBUF_OFFSET(rt) * scale_x,
+ static_cast<gdouble>(0.0) - src_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality,
it->x + pb_x, it->y + pb_y, wide_image);
static void rt_scroll(void *renderer, gint x_off, gint y_off)
{
- auto rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
rt_sync_scroll(rt);
static void renderer_area_changed(void *renderer, gint src_x, gint src_y, gint src_w, gint src_h)
{
- auto rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
gint x, y, width, height, x1, y1, x2, y2;
height += 2;
}
- x1 = (gint)floor((gdouble)x * pr->scale);
- y1 = (gint)floor((gdouble)y * pr->scale * pr->aspect_ratio);
- x2 = (gint)ceil((gdouble)(x + width) * pr->scale);
- y2 = (gint)ceil((gdouble)(y + height) * pr->scale * pr->aspect_ratio);
+ x1 = static_cast<gint>(floor(static_cast<gdouble>(x) * pr->scale));
+ y1 = static_cast<gint>(floor(static_cast<gdouble>(y) * pr->scale * pr->aspect_ratio));
+ x2 = static_cast<gint>(ceil(static_cast<gdouble>(x + width) * pr->scale));
+ y2 = static_cast<gint>(ceil(static_cast<gdouble>(y + height) * pr->scale * pr->aspect_ratio));
rt_queue(rt, x1, y1, x2 - x1, y2 - y1, FALSE, TILE_RENDER_AREA, TRUE, TRUE);
}
static void renderer_update_pixbuf(void *renderer, gboolean UNUSED(lazy))
{
- rt_queue_clear((RendererTiles *)renderer);
+ rt_queue_clear(static_cast<RendererTiles *>(renderer));
}
static void renderer_update_zoom(void *renderer, gboolean lazy)
{
- auto rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
- rt_tile_invalidate_all((RendererTiles *)renderer);
+ rt_tile_invalidate_all(static_cast<RendererTiles *>(renderer));
if (!lazy)
{
renderer_redraw(static_cast<_RendererTiles *>(renderer), 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, TRUE, FALSE);
static void renderer_invalidate_region(void *renderer, gint x, gint y, gint w, gint h)
{
- rt_tile_invalidate_region((RendererTiles *)renderer, x, y, w, h);
+ rt_tile_invalidate_region(static_cast<RendererTiles *>(renderer), x, y, w, h);
}
static void renderer_update_viewport(void *renderer)
{
- auto rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt->stereo_off_x = 0;
rt->stereo_off_y = 0;
static void renderer_stereo_set(void *renderer, gint stereo_mode)
{
- auto rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt->stereo_mode = stereo_mode;
}
static void renderer_free(void *renderer)
{
- auto rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt_queue_clear(rt);
rt_tile_free_all(rt);
if (rt->spare_tile) g_object_unref(rt->spare_tile);
static gboolean rt_realize_cb(GtkWidget *widget, gpointer data)
{
- auto rt = (RendererTiles *)data;
+ auto rt = static_cast<RendererTiles *>(data);
cairo_t *cr;
if (!rt->surface)
rt->surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget));
cr = cairo_create(rt->surface);
- cairo_set_source_rgb(cr, (gdouble)rt->pr->color.red / 65535, (gdouble)rt->pr->color.green / 65535, (gdouble)rt->pr->color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<gdouble>(rt->pr->color.red) / 65535, static_cast<gdouble>(rt->pr->color.green) / 65535, static_cast<gdouble>(rt->pr->color.blue) / 65535);
cairo_paint(cr);
cairo_destroy(cr);
}
cr = cairo_create(rt->surface);
- cairo_set_source_rgb(cr, (gdouble)options->image.border_color.red / 65535, (gdouble)options->image.border_color.green / 65535, (gdouble)options->image.border_color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<gdouble>(options->image.border_color.red) / 65535, static_cast<gdouble>(options->image.border_color.green) / 65535, static_cast<gdouble>(options->image.border_color.blue) / 65535);
cairo_paint(cr);
cairo_set_source_surface(cr, old_surface, 0, 0);
cairo_paint(cr);
static gboolean rt_draw_cb(GtkWidget *UNUSED(widget), cairo_t *cr, gpointer data)
{
- auto rt = (RendererTiles *)data;
+ auto rt = static_cast<RendererTiles *>(data);
GList *work;
OverlayData *od;
if (rt->stereo_mode & (PR_STEREO_HORIZ | PR_STEREO_VERT))
{
cairo_push_group(cr);
- cairo_set_source_rgb(cr, (double)rt->pr->color.red / 65535, (double)rt->pr->color.green / 65535, (double)rt->pr->color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<double>(rt->pr->color.red) / 65535, static_cast<double>(rt->pr->color.green) / 65535, static_cast<double>(rt->pr->color.blue) / 65535);
if (rt->stereo_mode & PR_STEREO_HORIZ)
{
g_signal_connect(G_OBJECT(pr), "realize", G_CALLBACK(rt_realize_cb), rt);
g_signal_connect(G_OBJECT(pr), "size-allocate", G_CALLBACK(rt_size_allocate_cb), rt);
- return (RendererFuncs *) rt;
+ return reinterpret_cast<RendererFuncs *>(rt);
}
gtk_action_activate(sar->action);
}
- g_idle_add((GSourceFunc)search_and_run_destroy, sar);
+ g_idle_add(static_cast<GSourceFunc>(search_and_run_destroy), sar);
return TRUE;
}
if (mfd_n->fd == fd) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return found;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
if (bytes) *bytes = total;
flist = g_list_prepend(flist, mfd->fd);
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
work = flist;
return;
}
- search_progress_update(sd, FALSE, (gdouble)row/length);
+ search_progress_update(sd, FALSE, static_cast<gdouble>(row)/length);
sd->thumb_fd = mfd->fd;
thumb_loader_free(sd->thumb_loader);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
if (event->state & GDK_CONTROL_MASK)
gdouble result;
result = image_sim_compare_fast(sd->search_similarity_cd->sim, sd->img_cd->sim,
- (gdouble)sd->search_similarity / 100.0);
+ static_cast<gdouble>(sd->search_similarity) / 100.0);
result *= 100.0;
- if (result >= (gdouble)sd->search_similarity)
+ if (result >= static_cast<gdouble>(sd->search_similarity))
{
tmatch = TRUE;
- value = (gint)result;
+ value = static_cast<gint>(result);
}
}
haystack = list;
while (haystack && !found)
{
- found = (g_ascii_strcasecmp((gchar *)needle->data,
- (gchar *)haystack->data) == 0);
+ found = (g_ascii_strcasecmp(static_cast<gchar *>(needle->data),
+ static_cast<gchar *>(haystack->data)) == 0);
haystack = haystack->next;
}
needle = needle->next;
haystack = list;
while (haystack && !found)
{
- found = (g_ascii_strcasecmp((gchar *)needle->data,
- (gchar *)haystack->data) == 0);
+ found = (g_ascii_strcasecmp(static_cast<gchar *>(needle->data),
+ static_cast<gchar *>(haystack->data)) == 0);
haystack = haystack->next;
}
needle = needle->next;
haystack = list;
while (haystack && !found)
{
- found = (g_ascii_strcasecmp((gchar *)needle->data,
- (gchar *)haystack->data) == 0);
+ found = (g_ascii_strcasecmp(static_cast<gchar *>(needle->data),
+ static_cast<gchar *>(haystack->data)) == 0);
haystack = haystack->next;
}
needle = needle->next;
switch (n)
{
case SEARCH_COLUMN_RANK:
- if (((MatchFileData *)fda)->rank > (fdb)->rank) return 1;
- if (((MatchFileData *)fda)->rank < (fdb)->rank) return -1;
+ if ((fda)->rank > (fdb)->rank) return 1;
+ if ((fda)->rank < (fdb)->rank) return -1;
return 0;
break;
case SEARCH_COLUMN_NAME:
{
auto value = static_cast<gint *>(data);
- *value = (gint)gtk_adjustment_get_value(adjustment);
+ *value = static_cast<gint>(gtk_adjustment_get_value(adjustment));
}
static void menu_choice_gps_cb(GtkWidget *combo, gpointer data)
GtkAdjustment *adj;
spin = gtk_spin_button_new_with_range(min, max, 1);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), (gdouble)value);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), static_cast<gdouble>(value));
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(spin));
if (func) g_signal_connect(G_OBJECT(adj), "value_changed",
G_CALLBACK(func), data);
title = _("Select collection");
btntext = NULL;
- btnfunc = (void *)select_collection_dialog_ok_cb;
+ btnfunc = reinterpret_cast<void *>(select_collection_dialog_ok_cb);
stock_id = GTK_STOCK_OK;
fdlg = file_util_file_dlg(title, "dlg_collection", sd->window, select_collection_dialog_close_cb, sd);
generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, title, NULL, FALSE);
- file_dialog_add_button(fdlg, stock_id, btntext, (void(*)(FileDialog *, gpointer))btnfunc, TRUE);
+ file_dialog_add_button(fdlg, stock_id, btntext, reinterpret_cast<void(*)(FileDialog *, gpointer)>(btnfunc), TRUE);
file_dialog_add_path_widgets(fdlg, get_collections_dir(), NULL, "search_collection", GQ_COLLECTION_EXT, _("Collection Files"));
static gint image_sim_channel_eq_sort_cb(gconstpointer a, gconstpointer b)
{
- auto pa = static_cast<gint *>((gpointer)a);
- auto pb = static_cast<gint *>((gpointer)b);
+ auto pa = static_cast<gint *>(const_cast<gpointer>(a));
+ auto pb = static_cast<gint *>(const_cast<gpointer>(b));
if (pa[1] < pb[1]) return -1;
if (pa[1] > pb[1]) return 1;
return 0;
{
buf[p] = i;
p++;
- buf[p] = (gint)pix[i];
+ buf[p] = static_cast<gint>(pix[i]);
p++;
}
n = buf[p];
p += 2;
- pix[n] = (guint8)(255 * i / len);
+ pix[n] = static_cast<guint8>(255 * i / len);
}
g_free(buf);
}
delta = h - l;
- scale = (delta != 0) ? 255.0 / (gdouble)(delta) : 1.0;
+ scale = (delta != 0) ? 255.0 / static_cast<gdouble>(delta) : 1.0;
for (i = 0; i < len; i++)
{
- pix[i] = (guint8)((gdouble)(pix[i] - l) * scale);
+ pix[i] = static_cast<guint8>(static_cast<gdouble>(pix[i] - l) * scale);
}
}
h_left = h;
for (ys = 0; ys < 32; ys++)
{
- if (y_small) j = (gdouble)h / 32 * ys;
- else y_inc = mround((gdouble)h_left/(32-ys));
+ if (y_small) j = static_cast<gdouble>(h) / 32 * ys;
+ else y_inc = mround(static_cast<gdouble>(h_left)/(32-ys));
i = 0;
w_left = w;
gint t;
guchar *xpos;
- if (x_small) i = (gdouble)w / 32 * xs;
- else x_inc = mround((gdouble)w_left/(32-xs));
+ if (x_small) i = static_cast<gdouble>(w) / 32 * xs;
+ else x_inc = mround(static_cast<gdouble>(w_left)/(32-xs));
xy_inc = x_inc * y_inc;
r = g = b = 0;
xpos = pix + (i * p_step);
}
}
- return 1.0 - ((gdouble)sim / (255.0 * 1024.0 * 3.0));
+ return 1.0 - (static_cast<gdouble>(sim) / (255.0 * 1024.0 * 3.0));
}
gdouble image_sim_compare(ImageSimilarityData *a, ImageSimilarityData *b)
sim += abs(a->avg_b[i1*32+j1] - b->avg_b[i2*32+j2]);
}
/* check for abort, if so return 0.0 */
- if ((gdouble)sim / (255.0 * 1024.0 * 3.0) > min) return 0.0;
+ if (static_cast<gdouble>(sim) / (255.0 * 1024.0 * 3.0) > min) return 0.0;
}
- return (1.0 - ((gdouble)sim / (255.0 * 1024.0 * 3.0)) );
+ return (1.0 - (static_cast<gdouble>(sim) / (255.0 * 1024.0 * 3.0)) );
}
/* this uses a cutoff point so that it can abort early when it gets to
{
GPtrArray *arr = g_ptr_array_sized_new(g_list_length(src_list));
- g_list_foreach(src_list, (GFunc) ptr_array_add, arr);
+ g_list_foreach(src_list, reinterpret_cast<GFunc>(ptr_array_add), arr);
return arr;
}
guint i;
for (i = 0; i < array->len; ++i)
{
- guint p = (double)rand() / ((double)RAND_MAX + 1.0) * array->len;
+ guint p = static_cast<double>(rand()) / (static_cast<double>(RAND_MAX) + 1.0) * array->len;
swap(array, i, p);
}
}
g_list_free(src_list);
ptr_array_random_shuffle(src_array);
- g_ptr_array_foreach(src_array, (GFunc) list_prepend, &list);
+ g_ptr_array_foreach(src_array, reinterpret_cast<GFunc>(list_prepend), &list);
g_ptr_array_free(src_array, TRUE);
return list;
if (ss->slide_count < 2)
{
ss->slide_count = layout_list_count(ss->lw, NULL);
- if (!options->slideshow.random && start_point >= 0 && (guint) start_point < ss->slide_count)
+ if (!options->slideshow.random && start_point >= 0 && static_cast<guint>(start_point) < ss->slide_count)
{
start_index = start_point;
}
mark_uri = (tl->cache_local) ? tl->local_uri :tl->thumb_uri;
mark_app = g_strdup_printf("%s %s", GQ_APPNAME, VERSION);
- mark_mtime = g_strdup_printf("%llu", (unsigned long long)tl->source_mtime);
+ mark_mtime = g_strdup_printf("%llu", static_cast<unsigned long long>(tl->source_mtime));
pathl = path_from_utf8(tmp_path);
success = gdk_pixbuf_save(pixbuf, pathl, "png", NULL,
THUMB_MARKER_URI, mark_uri,
&thumb_w, &thumb_h))
{
pixbuf_thumb = gdk_pixbuf_scale_simple(pixbuf, thumb_w, thumb_h,
- (GdkInterpType)options->thumbnails.quality);
+ static_cast<GdkInterpType>(options->thumbnails.quality));
}
else
{
&thumb_w, &thumb_h))
{
result = gdk_pixbuf_scale_simple(pixbuf, thumb_w, thumb_h,
- (GdkInterpType)options->thumbnails.quality);
+ static_cast<GdkInterpType>(options->thumbnails.quality));
}
else
{
{
auto tl = static_cast<ThumbLoaderStd *>(data);
- tl->progress = (gdouble)percent;
+ tl->progress = percent;
if (tl->func_progress) tl->func_progress(tl, tl->data);
}
time_t now;
now = time(NULL);
- if (st.st_atime >= now - (time_t)tv->days * 24 * 60 * 60)
+ if (st.st_atime >= now - static_cast<time_t>(tv->days) * 24 * 60 * 60)
{
valid = TRUE;
}
{
gint w, h;
- if (((gdouble)tl->max_w / pw) < ((gdouble)tl->max_h / ph))
+ if ((static_cast<gdouble>(tl->max_w) / pw) < (static_cast<gdouble>(tl->max_h) / ph))
{
w = tl->max_w;
- h = (gdouble)w / pw * ph;
+ h = static_cast<gdouble>(w) / pw * ph;
if (h < 1) h = 1;
}
else
{
h = tl->max_h;
- w = (gdouble)h / ph * pw;
+ w = static_cast<gdouble>(h) / ph * pw;
if (w < 1) w = 1;
}
if (tl->fd)
{
if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
- tl->fd->thumb_pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, (GdkInterpType)options->thumbnails.quality);
+ tl->fd->thumb_pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, static_cast<GdkInterpType>(options->thumbnails.quality));
}
save = TRUE;
}
if (tl->standard_loader)
{
- thumb_loader_std_set_callbacks((ThumbLoaderStd *)tl,
- (ThumbLoaderStdFunc) func_done,
- (ThumbLoaderStdFunc) func_error,
- (ThumbLoaderStdFunc) func_progress,
+ thumb_loader_std_set_callbacks(reinterpret_cast<ThumbLoaderStd *>(tl),
+ reinterpret_cast<ThumbLoaderStdFunc>(func_done),
+ reinterpret_cast<ThumbLoaderStdFunc>(func_error),
+ reinterpret_cast<ThumbLoaderStdFunc>(func_progress),
data);
return;
}
if (tl->standard_loader)
{
- thumb_loader_std_set_cache((ThumbLoaderStd *)tl, enable_cache, local, retry_failed);
+ thumb_loader_std_set_cache(reinterpret_cast<ThumbLoaderStd *>(tl), enable_cache, local, retry_failed);
return;
}
if (tl->standard_loader)
{
- return thumb_loader_std_start((ThumbLoaderStd *)tl, fd);
+ return thumb_loader_std_start(reinterpret_cast<ThumbLoaderStd *>(tl), fd);
}
if (!tl->fd && !fd) return FALSE;
if (tl && tl->standard_loader)
{
- return thumb_loader_std_get_pixbuf((ThumbLoaderStd *)tl);
+ return thumb_loader_std_get_pixbuf(reinterpret_cast<ThumbLoaderStd *>(tl));
}
if (tl && tl->fd && tl->fd->thumb_pixbuf)
and then performs one additional scaling */
if (options->thumbnails.spec_standard && options->thumbnails.enable_caching)
{
- return (ThumbLoader *)thumb_loader_std_new(width, height);
+ return reinterpret_cast<ThumbLoader *>(thumb_loader_std_new(width, height));
}
tl = g_new0(ThumbLoader, 1);
if (tl->standard_loader)
{
- thumb_loader_std_free((ThumbLoaderStd *)tl);
+ thumb_loader_std_free(reinterpret_cast<ThumbLoaderStd *>(tl));
return;
}
gtk_widget_show(toolbar_entry->button);
g_object_set_data_full(G_OBJECT(toolbar_entry->button), "toolbarbuttondata",
- toolbar_entry, (GDestroyNotify)toolbar_item_free);
+ toolbar_entry, reinterpret_cast<GDestroyNotify>(toolbar_item_free));
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
gtk_container_add(GTK_CONTAINER(toolbar_entry->button), hbox);
fd = static_cast<FileData *>(work->data);
work = work->next;
- v = (gint)strtol(fd->name, NULL, 10);
+ v = static_cast<gint>(strtol(fd->name, NULL, 10));
if (v >= n) n = v + 1;
total += fd->size;
}
while (options->file_ops.safe_delete_folder_maxsize > 0 && list &&
- (free_space < 0 || total + free_space > (gint64)options->file_ops.safe_delete_folder_maxsize * 1048576) )
+ (free_space < 0 || total + free_space > static_cast<gint64>(options->file_ops.safe_delete_folder_maxsize) * 1048576) )
{
FileData *fd;
gtk_widget_show(b->button);
g_object_set_data_full(G_OBJECT(b->button), "bookbuttondata",
- b, (GDestroyNotify)bookmark_free);
+ b, reinterpret_cast<GDestroyNotify>(bookmark_free));
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
gtk_container_add(GTK_CONTAINER(b->button), box);
work = history_list_get_by_key(hc->history_key);
while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(hc->combo), (gchar *)work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(hc->combo), static_cast<gchar *>(work->data));
work = work->next;
n++;
}
work = history_list_get_by_key(hc->history_key);
while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(hc->combo), (gchar *)work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(hc->combo), static_cast<gchar *>(work->data));
work = work->next;
}
}
void string_list_free(GList *list)
{
- g_list_foreach(list, (GFunc)list_free_wrapper, NULL);
+ g_list_foreach(list, static_cast<GFunc>(list_free_wrapper), NULL);
g_list_free(list);
}
GList *string_list_copy(const GList *list)
{
GList *new_list = NULL;
- auto work = (GList *) list;
+ auto work = const_cast<GList *>(list);
while (work)
{
if (!g_cancellable_is_cancelled(web->cancellable))
{
- gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(web->progress), (gdouble)current_num_bytes / total_num_bytes);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(web->progress), static_cast<gdouble>(current_num_bytes) / total_num_bytes);
}
}
{
if (g_strcmp0(window_keys[i].text, label_stripped[0]) == 0)
{
- gtk_widget_add_accelerator(menu, "activate", accel_group, window_keys[i].key_value, (GdkModifierType)window_keys[i].mask, GTK_ACCEL_VISIBLE);
+ gtk_widget_add_accelerator(menu, "activate", accel_group, window_keys[i].key_value, window_keys[i].mask, GTK_ACCEL_VISIBLE);
break;
}
{
*value_var = value;
return pref_spin_new(parent_box, text, suffix,
- (gdouble)min, (gdouble)max, (gdouble)step, 0,
+ static_cast<gdouble>(min), static_cast<gdouble>(max), static_cast<gdouble>(step), 0,
value,
G_CALLBACK(pref_spin_int_cb), value_var);
}
*value_var = value;
return pref_table_spin(table, column, row,
text, suffix,
- (gdouble)min, (gdouble)max, (gdouble)step, 0,
+ static_cast<gdouble>(min), static_cast<gdouble>(max), static_cast<gdouble>(step), 0,
value,
G_CALLBACK(pref_spin_int_cb), value_var);
}
gint xr, yr;
GdkWindow *window;
- xr = (gint)event->x_root;
- yr = (gint)event->y_root;
+ xr = static_cast<gint>(event->x_root);
+ yr = static_cast<gint>(event->y_root);
window = gtk_widget_get_window(ds->window);
gdk_window_get_origin(window, &x, &y);
ds = static_cast<DateSelection *>(g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY));
if (!ds) return;
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), (gdouble)day);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), (gdouble)month);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), (gdouble)year);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_d), static_cast<gdouble>(day));
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_m), static_cast<gdouble>(month));
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(ds->spin_y), static_cast<gdouble>(year));
}
work = pref_list_find(group, token);
if (work)
{
- *result = (const gchar *)work->data + strlen(token);
+ *result = static_cast<const gchar *>(work->data) + strlen(token);
if (strlen(*result) == 0) *result = NULL;
ret = TRUE;
}
if (pref_list_get(group, key, PREF_LIST_MARKER_INT, &text) && text)
{
- *result = (gint)strtol(text, NULL, 10);
+ *result = static_cast<gint>(strtol(text, NULL, 10));
return TRUE;
}
closedir(dp);
g_free(pathl);
- path_list = g_list_sort(path_list, (GCompareFunc) dest_sort_cb);
- file_list = g_list_sort(file_list, (GCompareFunc) dest_sort_cb);
+ path_list = g_list_sort(path_list, reinterpret_cast<GCompareFunc>(dest_sort_cb));
+ file_list = g_list_sort(file_list, reinterpret_cast<GCompareFunc>(dest_sort_cb));
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dd->d_view)));
gtk_list_store_clear(store);
{
gchar *p;
filepath = g_strdup(path);
- p = (gchar *)filename_from_path(filepath);
+ p = const_cast<gchar *>(filename_from_path(filepath));
if (p - 1 != filepath) p--;
p[0] = '\0';
}
{
gint pos = -1;
- dest_populate(dd, (gchar *)homedir());
+ dest_populate(dd, const_cast<gchar *>(homedir()));
if (path) gtk_editable_insert_text(GTK_EDITABLE(dd->entry), G_DIR_SEPARATOR_S, -1, &pos);
if (path) gtk_editable_insert_text(GTK_EDITABLE(dd->entry), path, -1, &pos);
}
}
}
- ptr = (gchar *)filename_from_path(entry_dir);
+ ptr = const_cast<gchar *>(filename_from_path(entry_dir));
if (ptr > entry_dir) ptr--;
ptr[0] = '\0';
work = history_list_get_by_key(history_key);
while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), (gchar *)work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), static_cast<gchar *>(work->data));
work = work->next;
n++;
}
work = history_list_get_by_key(td->history_key);
while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(td->combo), (gchar *)work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(td->combo), static_cast<gchar *>(work->data));
work = work->next;
n++;
}
gint xr, yr;
- xr = (gint)event->x_root;
- yr = (gint)event->y_root;
+ xr = static_cast<gint>(event->x_root);
+ yr = static_cast<gint>(event->y_root);
gdk_window_get_origin(window, &x, &y);
w = gdk_window_get_width(window);
/* up or down ? */
if (direction < 0 ||
- (direction == 0 &&((gint)src->red + (gint)src->green + (gint)src->blue) / 3 > 0xffff / 2))
+ (direction == 0 &&(static_cast<gint>(src->red) + static_cast<gint>(src->green) + static_cast<gint>(src->blue)) / 3 > 0xffff / 2))
{
src->red = MAX(0 , src->red - cs);
src->green = MAX(0 , src->green - cs);
void (*func)(GenericDialog *, gpointer);
gboolean auto_close;
- func = (void(*)(GenericDialog *, gpointer))(g_object_get_data(G_OBJECT(widget), "dialog_function"));
+ func = reinterpret_cast<void(*)(GenericDialog *, gpointer)>(g_object_get_data(G_OBJECT(widget), "dialog_function"));
auto_close = gd->auto_close;
if (func) func(gd, gd->data);
G_CALLBACK(generic_dialog_click_cb), gd);
gtk_widget_set_can_default(button, TRUE);
- g_object_set_data(G_OBJECT(button), "dialog_function", (void *)func_cb);
+ g_object_set_data(G_OBJECT(button), "dialog_function", reinterpret_cast<void *>(func_cb));
gtk_container_add(GTK_CONTAINER(gd->hbox), button);
}
/**
- * @brief
- * @param gd
- * @param icon_stock_id
- * @param heading
- * @param text
- * @param expand Used as the "expand" and "fill" parameters in the eventual call to gtk_box_pack_start()
- * @returns
- *
- *
+ * @brief
+ * @param gd
+ * @param icon_stock_id
+ * @param heading
+ * @param text
+ * @param expand Used as the "expand" and "fill" parameters in the eventual call to gtk_box_pack_start()
+ * @returns
+ *
+ *
*/
GtkWidget *generic_dialog_add_message(GenericDialog *gd, const gchar *icon_stock_id,
const gchar *heading, const gchar *text, gboolean expand)
*-----------------------------------------------------------------------------
* AppImage version update notification message with fade-out
*-----------------------------------------------------------------------------
- *
+ *
* It is expected that the version file on the server has the following format
* for the first two lines in these formats:
- *
+ *
* 1. x86_64 AppImage - e.g. Geeqie-v2.0+20221113-x86_64.AppImage
* 2. arm AppImage - e.g. Geeqie-v2.0+20221025-aarch64.AppImage
*/
generic_dialog_setup(GENERIC_DIALOG(fdlg), title,
role, parent, FALSE,
- (void(*)(GenericDialog *, gpointer))cancel_cb, data);
+ reinterpret_cast<void(*)(GenericDialog *, gpointer)>(cancel_cb), data);
return fdlg;
}
void (*func_cb)(FileDialog *, gpointer), gboolean is_default)
{
return generic_dialog_add_button(GENERIC_DIALOG(fdlg), stock_id, text,
- (void(*)(GenericDialog *, gpointer))func_cb, is_default);
+ reinterpret_cast<void(*)(GenericDialog *, gpointer)>(func_cb), is_default);
}
static void file_dialog_entry_cb(GtkWidget *UNUSED(widget), gpointer data)
while (work)
{
gchar *prev = msg;
- msg = g_strdup_printf("%s\n%s", prev, (gchar *)work->data);
+ msg = g_strdup_printf("%s\n%s", prev, static_cast<gchar *>(work->data));
work = work->next;
g_free(prev);
}
static GtkTargetEntry target_types[] =
{
- {(gchar *)const_cast<gchar *>("text/plain"), 0, CLIPBOARD_TEXT_PLAIN},
- {(gchar *)const_cast<gchar *>("text/uri-list"), 0, CLIPBOARD_TEXT_URI_LIST},
+ {const_cast<gchar *>("text/plain"), 0, CLIPBOARD_TEXT_PLAIN},
+ {const_cast<gchar *>("text/uri-list"), 0, CLIPBOARD_TEXT_URI_LIST},
{(gchar *)"x-special/gnome-copied-files", 0, CLIPBOARD_X_SPECIAL_GNOME_COPIED_FILES},
{(gchar *)"UTF8_STRING", 0, CLIPBOARD_UTF8_STRING}
};
file_directory = remove_level_from_path(source_fd->path);
if (!file_directory && flist)
- file_directory = remove_level_from_path(((FileData *)flist->data)->path);
+ file_directory = remove_level_from_path((static_cast<FileData *>(flist->data))->path);
working_directory = file_directory;
}
if (!vd) return;
if (!vd->layout) return;
- type = (SortType)GPOINTER_TO_INT(data);
+ type = static_cast<SortType>GPOINTER_TO_INT(data);
if (type == SORT_NAME || type == SORT_TIME)
{
void vficon_pop_menu_view_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (!VFICON(vf)->click_fd) return;
void vficon_pop_menu_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_util_rename(NULL, vf_pop_menu_file_list(vf), vf->listview);
}
void vficon_pop_menu_show_names_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vficon_toggle_filenames(vf);
}
void vficon_pop_menu_show_star_rating_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vficon_toggle_star_rating(vf);
}
void vficon_pop_menu_refresh_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_refresh(vf);
}
void vficon_popup_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
VFICON(vf)->click_fd = NULL;
vf->popup = NULL;
row = g_list_index(vf->list, fd);
if (row > vficon_index_by_fd(vf, cur_fd) &&
- (guint) (row + 1) < vf_count(vf, NULL))
+ static_cast<guint>(row + 1) < vf_count(vf, NULL))
{
read_ahead_fd = vf_index_get_data(vf, row + 1);
}
static void vficon_mark_toggled_cb(GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreeModel *store;
GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
GtkTreeIter row;
static gboolean tip_schedule_cb(gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkWidget *window;
if (!VFICON(vf)->tip_delay_id) return FALSE;
GtkSelectionData *selection_data, guint UNUSED(info),
guint UNUSED(time), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GList *list = NULL;
if (!VFICON(vf)->click_fd) return;
int x, int y, GtkSelectionData *selection,
guint info, guint UNUSED(time), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (info == TARGET_TEXT_PLAIN) {
FileData *fd = vficon_find_data_by_coord(vf, x, y, NULL);
if (fd) {
/* Add keywords to file */
- auto str = (gchar *) gtk_selection_data_get_text(selection);
+ auto str = reinterpret_cast<gchar *>(gtk_selection_data_get_text(selection));
GList *kw_list = string_to_keywords_list(str);
metadata_append_list(fd, KEYWORD_KEY, kw_list);
static void vficon_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
tip_unschedule(vf);
static void vficon_dnd_end(GtkWidget *UNUSED(widget), GdkDragContext *context, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
work = VFICON(vf)->selection;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (vficon_index_by_fd(vf, fd) >= 0) continue;
work = vf->list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
work = VFICON(vf)->selection;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
vficon_selection_remove(vf, fd, SELECTION_SELECTED, NULL);
work = vf->list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->selected & SELECTION_SELECTED)
work = g_list_find(vf->list, start);
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
vficon_select_util(vf, fd, select);
if (work->data != end)
work = VFICON(vf)->selection;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
g_assert(fd->magick == FD_MAGICK);
b += fd->size;
work = VFICON(vf)->selection;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
g_assert(fd->magick == FD_MAGICK);
list = g_list_prepend(list, file_data_ref(fd));
work = vf->list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
gboolean mark_val, selected;
g_assert(fd->magick == FD_MAGICK);
work = slist;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
switch (mode)
{
gint ret;
adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(vf->listview));
- page_size = (gint)gtk_adjustment_get_page_increment(adj);
+ page_size = static_cast<gint>(gtk_adjustment_get_page_increment(adj));
row_height = options->thumbnails.max_height + THUMB_BORDER_PADDING * 2;
if (VFICON(vf)->show_text) row_height += options->thumbnails.max_height / 3;
gboolean vficon_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gint focus_row = 0;
gint focus_col = 0;
FileData *fd;
static gboolean vficon_motion_cb(GtkWidget *UNUSED(widget), GdkEventMotion *event, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
FileData *fd;
- fd = vficon_find_data_by_coord(vf, (gint)event->x, (gint)event->y, NULL);
+ fd = vficon_find_data_by_coord(vf, static_cast<gint>(event->x), static_cast<gint>(event->y), NULL);
tip_update(vf, fd);
return FALSE;
gboolean vficon_press_cb(GtkWidget *UNUSED(widget), GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreeIter iter;
FileData *fd;
tip_unschedule(vf);
- fd = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
+ fd = vficon_find_data_by_coord(vf, static_cast<gint>(bevent->x), static_cast<gint>(bevent->y), &iter);
VFICON(vf)->click_fd = fd;
vficon_selection_add(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, &iter);
gboolean vficon_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreeIter iter;
FileData *fd = NULL;
gboolean was_selected;
return TRUE;
}
- if ((gint)bevent->x != 0 || (gint)bevent->y != 0)
+ if (static_cast<gint>(bevent->x) != 0 || static_cast<gint>(bevent->y) != 0)
{
- fd = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
+ fd = vficon_find_data_by_coord(vf, static_cast<gint>(bevent->x), static_cast<gint>(bevent->y), &iter);
}
if (VFICON(vf)->click_fd)
static gboolean vficon_leave_cb(GtkWidget *UNUSED(widget), GdkEventCrossing *UNUSED(event), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
tip_unschedule(vf);
return FALSE;
static void vficon_sized_cb(GtkWidget *UNUSED(widget), GtkAllocation *allocation, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vficon_populate_at_new_size(vf, allocation->width, allocation->height, FALSE);
}
GList *work = list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->thumb_pixbuf) (*done)++;
GList *work = list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->metadata_in_idle_loaded) (*done)++;
GList *work;
for (work = vf->list; work; work = work->next)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
// Note: This implementation differs from view-file-list.cc because sidecar files are not
// distinct list elements here, as they are in the list view.
GList *work;
for (work = vf->list; work; work = work->next)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
if (fd && fd->rating == STAR_RATING_NOT_READ)
{
work = vf->list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
if (fd == in_fd) return p;
work = work->next;
p++;
{
GList *list;
FileData *fd;
- auto cd = (ColumnData *)data;
+ auto cd = static_cast<ColumnData *>(data);
ViewFile *vf = cd->vf;
gchar *star_rating;
void vficon_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_refresh_idle_cancel(vf);
static gboolean vflist_find_row_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer data)
{
- auto find = (ViewFileFindRowData *)data;
+ auto find = static_cast<ViewFileFindRowData *>(data);
FileData *fd;
gtk_tree_model_get(model, iter, FILE_COLUMN_POINTER, &fd, -1);
if (fd == find->fd)
GtkSelectionData *selection_data, guint UNUSED(info),
guint UNUSED(time), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GList *list = NULL;
if (!VFLIST(vf)->click_fd) return;
static void vflist_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, TRUE);
static void vflist_dnd_end(GtkWidget *UNUSED(widget), GdkDragContext *context, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, FALSE);
int x, int y, GtkSelectionData *selection,
guint info, guint UNUSED(time), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (info == TARGET_TEXT_PLAIN) {
FileData *fd = vflist_find_data_by_coord(vf, x, y, NULL);
if (fd) {
/* Add keywords to file */
- auto str = (gchar *) gtk_selection_data_get_text(selection);
+ auto str = reinterpret_cast<gchar *>(gtk_selection_data_get_text(selection));
GList *kw_list = string_to_keywords_list(str);
metadata_append_list(fd, KEYWORD_KEY, kw_list);
GList *work = fd->sidecar_files;
while (work)
{
- auto sfd = (FileData *)work->data;
+ auto sfd = static_cast<FileData *>(work->data);
list = g_list_prepend(list, file_data_ref(sfd));
work = work->next;
}
void vflist_pop_menu_view_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (vflist_row_is_selected(vf, VFLIST(vf)->click_fd))
{
void vflist_pop_menu_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GList *list;
list = vf_pop_menu_file_list(vf);
void vflist_pop_menu_thumbs_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, FALSE);
if (vf->layout)
work = columns;
while (work)
{
- auto column = (GtkTreeViewColumn *)work->data;
+ auto column = static_cast<GtkTreeViewColumn *>(work->data);
gint col_idx = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_store_idx"));
work = work->next;
void vflist_pop_menu_show_star_rating_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
options->show_star_rating = !options->show_star_rating;
void vflist_pop_menu_refresh_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, FALSE);
vf_refresh(vf);
void vflist_popup_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, FALSE);
VFLIST(vf)->click_fd = NULL;
vf->popup = NULL;
static gboolean vflist_row_rename_cb(TreeEditData *UNUSED(td), const gchar *old_name, const gchar *new_name, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gchar *new_path;
if (!new_name || !new_name[0]) return FALSE;
gboolean vflist_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreePath *tpath;
if (event->keyval != GDK_KEY_Menu) return FALSE;
gboolean vflist_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
FileData *fd = NULL;
gboolean vflist_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
FileData *fd = NULL;
if (sel_fd && options->image.enable_read_ahead && row >= 0)
{
if (row > g_list_index(vf->list, cur_fd) &&
- (guint) (row + 1) < vf_count(vf, NULL))
+ static_cast<guint>(row + 1) < vf_count(vf, NULL))
{
read_ahead_fd = vf_index_get_data(vf, row + 1);
}
static gboolean vflist_select_idle_cb(gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (!vf->layout)
{
static gboolean vflist_select_cb(GtkTreeSelection *UNUSED(selection), GtkTreeModel *store, GtkTreePath *tpath, gboolean path_currently_selected, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreeIter iter;
GtkTreePath *cursor_path;
static void vflist_expand_cb(GtkTreeView *UNUSED(tree_view), GtkTreeIter *iter, GtkTreePath *UNUSED(path), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_set_expanded(vf, iter, TRUE);
}
static void vflist_collapse_cb(GtkTreeView *UNUSED(tree_view), GtkTreeIter *iter, GtkTreePath *UNUSED(path), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vflist_set_expanded(vf, iter, FALSE);
}
while (work)
{
gint match;
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
gboolean done = FALSE;
while (!done)
i = 0;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
g_hash_table_insert(fd_idx_hash, fd, GINT_TO_POINTER(i));
i++;
work = work->next;
i = 0;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
new_order[i] = GPOINTER_TO_INT(g_hash_table_lookup(fd_idx_hash, fd));
i++;
work = work->next;
GList *work = list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->thumb_pixbuf) (*done)++;
GList *work = list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->metadata_in_idle_loaded) (*done)++;
GList *work = vf->list;
while (work && !fd)
{
- auto fd_p = (FileData *)work->data;
+ auto fd_p = static_cast<FileData *>(work->data);
if (!fd_p->thumb_pixbuf)
fd = fd_p;
else
while (work && !fd)
{
- auto fd_p = (FileData *)work->data;
+ auto fd_p = static_cast<FileData *>(work->data);
if (fd_p && fd_p->rating == STAR_RATING_NOT_READ)
{
work = vf->list;
while (work)
{
- auto list_fd = (FileData *)work->data;
+ auto list_fd = static_cast<FileData *>(work->data);
if (list_fd == fd) return p;
work2 = list_fd->sidecar_files;
work = slist;
while (!found && work)
{
- auto tpath = (GtkTreePath *)work->data;
+ auto tpath = static_cast<GtkTreePath *>(work->data);
FileData *fd_n;
GtkTreeIter iter;
if (fd_n == fd) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return found;
work = slist;
while (work)
{
- auto tpath = (GtkTreePath *)work->data;
+ auto tpath = static_cast<GtkTreePath *>(work->data);
GtkTreeIter iter;
FileData *fd;
}
count = g_list_length(slist);
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return count;
work = slist;
while (work)
{
- auto tpath = (GtkTreePath *)work->data;
+ auto tpath = static_cast<GtkTreePath *>(work->data);
FileData *fd;
GtkTreeIter iter;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return g_list_reverse(list);
work = slist;
while (work)
{
- auto tpath = (GtkTreePath *)work->data;
+ auto tpath = static_cast<GtkTreePath *>(work->data);
FileData *fd;
GtkTreeIter iter;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
return g_list_reverse(list);
work = slist;
while (work)
{
- auto tpath = (GtkTreePath *)work->data;
+ auto tpath = static_cast<GtkTreePath *>(work->data);
FileData *fd;
GtkTreeIter iter;
work = work->next;
}
- g_list_foreach(slist, (GFunc)tree_path_free_wrapper, NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
g_list_free(slist);
}
static void vflist_listview_color_cb(GtkTreeViewColumn *UNUSED(tree_column), GtkCellRenderer *cell,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gboolean set;
gtk_tree_model_get(tree_model, iter, FILE_COLUMN_COLOR, &set, -1);
static void vflist_listview_mark_toggled_cb(GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkTreeStore *store;
GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
GtkTreeIter iter;
void vflist_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_data_unregister_notify_func(vf_notify_cb, vf);
work = columns;
while (work)
{
- auto column = (GtkTreeViewColumn *)work->data;
+ auto column = static_cast<GtkTreeViewColumn *>(work->data);
gint col_idx = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_store_idx"));
work = work->next;
work = vf->list;
while (work)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
b += fd->size;
GList *work;
for (work = vf->list; work; work = work->next)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
list = g_list_prepend(list, file_data_ref(fd));
}
static gboolean vf_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gboolean ret;
switch (vf->type)
static gboolean vf_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gboolean ret;
switch (vf->type)
static gboolean vf_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gboolean ret;
switch (vf->type)
static void vf_pop_menu_view_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
switch (vf->type)
{
static void vf_pop_menu_open_archive_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
LayoutWindow *lw_new;
FileData *fd = NULL;
gchar *dest_dir;
static void vf_pop_menu_copy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_util_copy(NULL, vf_pop_menu_file_list(vf), NULL, vf->listview);
}
static void vf_pop_menu_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_util_move(NULL, vf_pop_menu_file_list(vf), NULL, vf->listview);
}
static void vf_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
switch (vf->type)
{
static void vf_pop_menu_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
options->file_ops.safe_delete_enable = FALSE;
file_util_delete(NULL, vf_pop_menu_file_list(vf), vf->listview);
static void vf_pop_menu_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
options->file_ops.safe_delete_enable = TRUE;
file_util_delete(NULL, vf_pop_menu_file_list(vf), vf->listview);
static void vf_pop_menu_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_util_copy_path_list_to_clipboard(vf_pop_menu_file_list(vf), TRUE);
}
static void vf_pop_menu_copy_path_unquoted_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_util_copy_path_list_to_clipboard(vf_pop_menu_file_list(vf), FALSE);
}
static void vf_pop_menu_enable_grouping_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_data_disable_grouping_list(vf_pop_menu_file_list(vf), FALSE);
}
static void vf_pop_menu_duplicates_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
DupeWindow *dw;
dw = dupe_window_new();
static void vf_pop_menu_disable_grouping_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
file_data_disable_grouping_list(vf_pop_menu_file_list(vf), TRUE);
}
vf = static_cast<ViewFile *>(submenu_item_get_data(widget));
if (!vf) return;
- type = (SortType)GPOINTER_TO_INT(data);
+ type = static_cast<SortType>GPOINTER_TO_INT(data);
if (type == SORT_EXIFTIME || type == SORT_EXIFTIMEDIGITIZED || type == SORT_RATING)
{
static void vf_pop_menu_sort_ascend_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (vf->layout)
{
static void vf_pop_menu_sel_mark_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_mark_to_selection(vf, vf->active_mark, MTS_MODE_SET);
}
static void vf_pop_menu_sel_mark_and_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_mark_to_selection(vf, vf->active_mark, MTS_MODE_AND);
}
static void vf_pop_menu_sel_mark_or_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_mark_to_selection(vf, vf->active_mark, MTS_MODE_OR);
}
static void vf_pop_menu_sel_mark_minus_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_mark_to_selection(vf, vf->active_mark, MTS_MODE_MINUS);
}
static void vf_pop_menu_set_mark_sel_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_selection_to_mark(vf, vf->active_mark, STM_MODE_SET);
}
static void vf_pop_menu_res_mark_sel_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_selection_to_mark(vf, vf->active_mark, STM_MODE_RESET);
}
static void vf_pop_menu_toggle_mark_sel_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_selection_to_mark(vf, vf->active_mark, STM_MODE_TOGGLE);
}
static void vf_pop_menu_toggle_view_type_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
auto new_type = static_cast<FileViewType>(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "menu_item_radio_data")));
if (!vf->layout) return;
static void vf_pop_menu_refresh_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
switch (vf->type)
{
static void vf_popup_destroy_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
switch (vf->type)
{
static void vf_destroy_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
switch (vf->type)
{
static void vf_marks_filter_toggle_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_refresh_idle(vf);
}
static void vf_marks_tooltip_cancel_cb(GenericDialog *gd, gpointer data)
{
- auto mte = (MarksTextEntry *)data;
+ auto mte = static_cast<MarksTextEntry *>(data);
g_free(mte->text_entry);
generic_dialog_close(gd);
static void vf_marks_tooltip_ok_cb(GenericDialog *gd, gpointer data)
{
- auto mte = (MarksTextEntry *)data;
+ auto mte = static_cast<MarksTextEntry *>(data);
g_free(options->marks_tooltips[mte->mark_no]);
options->marks_tooltips[mte->mark_no] = g_strdup(gtk_entry_get_text(GTK_ENTRY(mte->edit_widget)));
static void vf_file_filter_save_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gchar *entry_text;
gchar *remove_text = NULL;
gchar *index_text = NULL;
static void vf_file_filter_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_refresh(vf);
}
static gboolean vf_file_filter_press_cb(GtkWidget *widget, GdkEventButton *UNUSED(bevent), gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf->file_filter.last_selected = gtk_combo_box_get_active(GTK_COMBO_BOX(vf->file_filter.combo));
gtk_widget_grab_focus(widget);
static gboolean vf_file_filter_class_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gint i;
gboolean state = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
static gboolean vf_file_filter_class_set_all_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GtkWidget *parent;
GList *children;
GtkWidget *child;
static void case_sensitive_cb(GtkWidget *widget, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf->file_filter.case_sensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
vf_refresh(vf);
work = history_list_get_by_key("file_filter");
while (work)
{
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vf->file_filter.combo), (gchar *)work->data);
+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vf->file_filter.combo), static_cast<gchar *>(work->data));
work = work->next;
n++;
vf->file_filter.count = n;
}
DEBUG_1("thumb progress: %d of %d", done, count);
- return (gdouble)done / count;
+ return static_cast<gdouble>(done) / count;
}
static gdouble vf_read_metadata_in_idle_progress(ViewFile *vf)
case FILEVIEW_ICON: vficon_read_metadata_progress_count(vf->list, &count, &done); break;
}
- return (gdouble)done / count;
+ return static_cast<gdouble>(done) / count;
}
static void vf_set_thumb_fd(ViewFile *vf, FileData *fd)
static void vf_thumb_common_cb(ThumbLoader *tl, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
if (vf->thumbs_filedata && vf->thumbs_loader == tl)
{
for (work = vf->list; work; work = work->next)
{
- auto fd = (FileData *)work->data;
+ auto fd = static_cast<FileData *>(work->data);
if (fd->thumb_pixbuf)
{
g_object_unref(fd->thumb_pixbuf);
gboolean vf_stars_cb(gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
FileData *fd = vf->stars_filedata;
if (fd)
static gboolean vf_refresh_idle_cb(gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_refresh(vf);
vf->refresh_idle_id = 0;
void vf_notify_cb(FileData *fd, NotifyType type, gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
gboolean refresh;
auto interested = static_cast<NotifyType>(NOTIFY_CHANGE | NOTIFY_REREAD | NOTIFY_GROUPING);
static gboolean vf_read_metadata_in_idle_cb(gpointer data)
{
FileData *fd;
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
GList *work;
vf_thumb_status(vf, vf_read_metadata_in_idle_progress(vf), _("Loading meta..."));
static void vf_read_metadata_in_idle_finished_cb(gpointer data)
{
- auto vf = (ViewFile *)data;
+ auto vf = static_cast<ViewFile *>(data);
vf_thumb_status(vf, 0.0, "Loading meta...");
vf->read_metadata_in_idle_id = 0;
static void (*zdErrorHandler)(int, int);
static void zdError(enum ZDInternalError errZD, int errNative)
{
- if (zdErrorHandler) zdErrorHandler((int)errZD, errNative);
+ if (zdErrorHandler) zdErrorHandler(static_cast<int>(errZD), errNative);
}
static int32_t ZDFloatToFixedPoint(float input, float scale, unsigned int precision)
{
const float inputScaled = input / scale;
- return (int32_t)(inputScaled * (float)(1 << (precision - 1)));
+ return static_cast<int32_t>(inputScaled * static_cast<float>(1 << (precision - 1)));
}
static float ZDFixedPointToFloat(int32_t input, float scale, unsigned int precision)
{
- const float value = (float)input / (float)(1 << (precision - 1));
+ const float value = static_cast<float>(input) / static_cast<float>(1 << (precision - 1));
return value * scale;
}
static unsigned int ZDDecodeVariableLengthUnsigned(const ZoneDetect *library, uint32_t *index, uint64_t *result)
{
- if(*index >= (uint32_t)library->length) {
+ if(*index >= static_cast<uint32_t>(library->length)) {
return 0;
}
unsigned int shift = 0;
while(1) {
- value |= ((((uint64_t)buffer[i]) & UINT8_C(0x7F)) << shift);
+ value |= (((static_cast<uint64_t>(buffer[i])) & UINT8_C(0x7F)) << shift);
shift += 7u;
if(!(buffer[i] & UINT8_C(0x80))) {
{
uint32_t i = *index;
- if(*index >= (uint32_t)library->length) {
+ if(*index >= static_cast<uint32_t>(library->length)) {
return 0;
}
static int64_t ZDDecodeUnsignedToSigned(uint64_t value)
{
- return (value & 1) ? -(int64_t)(value / 2) : (int64_t)(value / 2);
+ return (value & 1) ? -static_cast<int64_t>(value / 2) : static_cast<int64_t>(value / 2);
}
static unsigned int ZDDecodeVariableLengthSigned(const ZoneDetect *library, uint32_t *index, int32_t *result)
{
uint64_t value = 0;
const unsigned int retVal = ZDDecodeVariableLengthUnsigned(library, index, &value);
- *result = (int32_t)ZDDecodeUnsignedToSigned(value);
+ *result = static_cast<int32_t>(ZDDecodeUnsignedToSigned(value));
return retVal;
}
uint32_t strOffset = *index;
unsigned int remoteStr = 0;
if(strLength >= 256) {
- strOffset = library->metadataOffset + (uint32_t)strLength - 256;
+ strOffset = library->metadataOffset + static_cast<uint32_t>(strLength) - 256;
remoteStr = 1;
if(!ZDDecodeVariableLengthUnsigned(library, &strOffset, &strLength)) {
}
}
- auto str = static_cast<char *>(malloc((size_t)(strLength + 1)));
+ auto str = static_cast<char *>(malloc(static_cast<size_t>(strLength + 1)));
if(str) {
#if defined(_MSC_VER)
#endif
size_t i;
for(i = 0; i < strLength; i++) {
- str[i] = (char)(library->mapping[strOffset + i] ^ UINT8_C(0x80));
+ str[i] = static_cast<char>(library->mapping[strOffset + i] ^ UINT8_C(0x80));
}
#if defined(_MSC_VER)
} __except(GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR
}
if(!remoteStr) {
- *index += (uint32_t)strLength;
+ *index += static_cast<uint32_t>(strLength);
}
return str;
/* By memset: library->bboxOffset = 0 */
if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp)) return -1;
- library->metadataOffset = (uint32_t)tmp + library->bboxOffset;
+ library->metadataOffset = static_cast<uint32_t>(tmp) + library->bboxOffset;
if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp))return -1;
- library->dataOffset = (uint32_t)tmp + library->metadataOffset;
+ library->dataOffset = static_cast<uint32_t>(tmp) + library->metadataOffset;
if(!ZDDecodeVariableLengthUnsigned(library, &index, &tmp)) return -1;
library->dataOffset += index;
/* Verify file length */
- if(tmp + library->dataOffset != (uint32_t)library->length) {
+ if(tmp + library->dataOffset != static_cast<uint32_t>(library->length)) {
return -2;
}
w = (w | (w >> 4)) & 0x00FF00FF00FF00FFllu;
w = (w | (w >> 8)) & 0x0000FFFF0000FFFFllu;
w = (w | (w >> 16)) & 0x00000000FFFFFFFFllu;
- return (uint32_t)w;
+ return static_cast<uint32_t>(w);
}
static void ZDDecodePoint(uint64_t point, int32_t* lat, int32_t* lon)
{
- *lat = (int32_t)ZDDecodeUnsignedToSigned(ZDUnshuffle(point));
- *lon = (int32_t)ZDDecodeUnsignedToSigned(ZDUnshuffle(point >> 1));
+ *lat = static_cast<int32_t>(ZDDecodeUnsignedToSigned(ZDUnshuffle(point)));
+ *lon = static_cast<int32_t>(ZDDecodeUnsignedToSigned(ZDUnshuffle(point >> 1)));
}
struct Reader {
} else if(value == 1) {
int32_t diff;
int64_t start;
- if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, (uint64_t*)&start)) return -1;
+ if(!ZDDecodeVariableLengthUnsigned(reader->library, &reader->polygonIndex, reinterpret_cast<uint64_t*>(&start))) return -1;
if(!ZDDecodeVariableLengthSigned(reader->library, &reader->polygonIndex, &diff)) return -1;
- reader->referenceStart = reader->library->dataOffset+(uint32_t)start;
- reader->referenceEnd = reader->library->dataOffset+(uint32_t)(start + diff);
+ reader->referenceStart = reader->library->dataOffset+static_cast<uint32_t>(start);
+ reader->referenceEnd = reader->library->dataOffset+static_cast<uint32_t>(start + diff);
reader->referenceDirection = diff;
if(diff < 0) {
reader->referenceStart--;
if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &metadataIndexDelta)) break;
if(!ZDDecodeVariableLengthUnsigned(library, &bboxIndex, &polygonIndexDelta)) break;
- metadataIndex += (uint32_t)metadataIndexDelta;
- polygonIndex += (uint32_t)polygonIndexDelta;
+ metadataIndex += static_cast<uint32_t>(metadataIndexDelta);
+ polygonIndex += static_cast<uint32_t>(polygonIndexDelta);
if(polygonId == wantedId) {
if(metadataIndexPtr) {
/* Calculate the parameters of y=ax+b if needed */
if(!lineIsStraight && (distanceSqrMin || windingNeedCompare)) {
- a = ((float)pointLat - (float)prevLat) / ((float)pointLon - (float)prevLon);
- b = (float)pointLat - a * (float)pointLon;
+ a = (static_cast<float>(pointLat) - static_cast<float>(prevLat)) / (static_cast<float>(pointLon) - static_cast<float>(prevLon));
+ b = static_cast<float>(pointLat) - a * static_cast<float>(pointLon);
}
int onStraight = ZDPointInBox(pointLat, latFixedPoint, prevLat, pointLon, lonFixedPoint, prevLon);
/* Jumped two quadrants. */
if(windingNeedCompare) {
/* Check if the target is on the border */
- const auto intersectLon = (int32_t)(((float)latFixedPoint - b) / a);
+ const auto intersectLon = static_cast<int32_t>((static_cast<float>(latFixedPoint) - b) / a);
if(intersectLon >= lonFixedPoint-1 && intersectLon <= lonFixedPoint+1) {
if(distanceSqrMin) *distanceSqrMin = 0;
return ZD_LOOKUP_ON_BORDER_SEGMENT;
if(distanceSqrMin) {
float closestLon, closestLat;
if(!lineIsStraight) {
- closestLon = ((float)lonFixedPoint + a * (float)latFixedPoint - a * b) / (a * a + 1);
- closestLat = (a * ((float)lonFixedPoint + a * (float)latFixedPoint) + b) / (a * a + 1);
+ closestLon = (static_cast<float>(lonFixedPoint) + a * static_cast<float>(latFixedPoint) - a * b) / (a * a + 1);
+ closestLat = (a * (static_cast<float>(lonFixedPoint) + a * static_cast<float>(latFixedPoint)) + b) / (a * a + 1);
} else {
if(pointLon == prevLon) {
- closestLon = (float)pointLon;
- closestLat = (float)latFixedPoint;
+ closestLon = static_cast<float>(pointLon);
+ closestLat = static_cast<float>(latFixedPoint);
} else {
- closestLon = (float)lonFixedPoint;
- closestLat = (float)pointLat;
+ closestLon = static_cast<float>(lonFixedPoint);
+ closestLat = static_cast<float>(pointLat);
}
}
- const int closestInBox = ZDPointInBox(pointLon, (int32_t)closestLon, prevLon, pointLat, (int32_t)closestLat, prevLat);
+ const int closestInBox = ZDPointInBox(pointLon, static_cast<int32_t>(closestLon), prevLon, pointLat, static_cast<int32_t>(closestLat), prevLat);
int64_t diffLat, diffLon;
if(closestInBox) {
/* Calculate squared distance to segment. */
- diffLat = (int64_t)(closestLat - (float)latFixedPoint);
- diffLon = (int64_t)(closestLon - (float)lonFixedPoint);
+ diffLat = static_cast<int64_t>(closestLat - static_cast<float>(latFixedPoint));
+ diffLon = static_cast<int64_t>(closestLon - static_cast<float>(lonFixedPoint));
} else {
/*
* Calculate squared distance to vertices
* It is enough to check the current point since the polygon is closed.
*/
- diffLat = (int64_t)(pointLat - latFixedPoint);
- diffLon = (int64_t)(pointLon - lonFixedPoint);
+ diffLat = static_cast<int64_t>(pointLat - latFixedPoint);
+ diffLon = static_cast<int64_t>(pointLon - lonFixedPoint);
}
/* Note: lon has half scale */
- uint64_t distanceSqr = (uint64_t)(diffLat * diffLat) + (uint64_t)(diffLon * diffLon) * 4;
+ uint64_t distanceSqr = static_cast<uint64_t>(diffLat * diffLat) + static_cast<uint64_t>(diffLon * diffLon) * 4;
if(distanceSqr < *distanceSqrMin) *distanceSqrMin = distanceSqr;
}
}
if(library) {
if(library->fieldNames) {
size_t i;
- for(i = 0; i < (size_t)library->numFields; i++) {
+ for(i = 0; i < static_cast<size_t>(library->numFields); i++) {
if(library->fieldNames[i]) {
free(library->fieldNames[i]);
}
if(library->fdMap && !CloseHandle(library->fdMap)) zdError(ZD_E_DB_MUNMAP, (int)GetLastError());
if(library->fd && !CloseHandle(library->fd)) zdError(ZD_E_DB_CLOSE, (int)GetLastError());
#elif defined(__APPLE__) || defined(__linux__) || defined(__unix__) || defined(_POSIX_VERSION)
- if(library->mapping && munmap(library->mapping, (size_t)(library->length))) zdError(ZD_E_DB_MUNMAP, 0);
+ if(library->mapping && munmap(library->mapping, static_cast<size_t>(library->length))) zdError(ZD_E_DB_MUNMAP, 0);
if(library->fd >= 0 && close(library->fd)) zdError(ZD_E_DB_CLOSE, 0);
#endif
}
if(library) {
memset(library, 0, sizeof(*library));
library->closeType = 1;
- library->length = (long int)length;
+ library->length = static_cast<long int>(length);
if(library->length <= 0) {
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__APPLE__) || defined(__linux__) || defined(__unix__) || defined(_POSIX_VERSION)
}
lseek(library->fd, 0, SEEK_SET);
- library->mapping = static_cast<uint8_t *>(mmap(NULL, (size_t)library->length, PROT_READ, MAP_PRIVATE | MAP_FILE, library->fd, 0));
+ library->mapping = static_cast<uint8_t *>(mmap(NULL, static_cast<size_t>(library->length), PROT_READ, MAP_PRIVATE | MAP_FILE, library->fd, 0));
if(library->mapping == MAP_FAILED) {
zdError(ZD_E_DB_MMAP, errno);
goto fail;
const int32_t latFixedPoint = ZDFloatToFixedPoint(lat, 90, library->precision);
const int32_t lonFixedPoint = ZDFloatToFixedPoint(lon, 180, library->precision);
size_t numResults = 0;
- auto distanceSqrMin = (uint64_t)-1;
+ auto distanceSqrMin = static_cast<uint64_t>(-1);
/* Iterate over all polygons */
uint32_t bboxIndex = library->bboxOffset;
if(!ZDDecodeVariableLengthSigned(library, &bboxIndex, &metadataIndexDelta)) break;
if(!ZDDecodeVariableLengthUnsigned(library, &bboxIndex, &polygonIndexDelta)) break;
- metadataIndex += (uint32_t)metadataIndexDelta;
- polygonIndex += (uint32_t)polygonIndexDelta;
+ metadataIndex += static_cast<uint32_t>(metadataIndexDelta);
+ polygonIndex += static_cast<uint32_t>(polygonIndexDelta);
if(latFixedPoint >= minLat) {
if(latFixedPoint <= maxLat &&
size_t k;
for(k = 0; k < i; k++) {
size_t l;
- for(l = 0; l < (size_t)results[k].numFields; l++) {
+ for(l = 0; l < static_cast<size_t>(results[k].numFields); l++) {
if(results[k].data[l]) {
free(results[k].data[l]);
}
size_t k;
for(k = 0; k < i; k++) {
size_t l;
- for(l = 0; l < (size_t)results[k].numFields; l++) {
+ for(l = 0; l < static_cast<size_t>(results[k].numFields); l++) {
if(results[k].data[l]) {
free(results[k].data[l]);
}
results[numResults].data = NULL;
if(safezone) {
- *safezone = sqrtf((float)distanceSqrMin) * 90 / (float)(1 << (library->precision - 1));
+ *safezone = sqrtf(static_cast<float>(distanceSqrMin)) * 90 / static_cast<float>(1 << (library->precision - 1));
}
return results;
while(results[index].lookupResult != ZD_LOOKUP_END) {
if(results[index].data) {
size_t i;
- for(i = 0; i < (size_t)results[index].numFields; i++) {
+ for(i = 0; i < static_cast<size_t>(results[index].numFields); i++) {
if(results[index].data[i]) {
free(results[index].data[i]);
}
const char *ZDGetErrorString(int errZD)
{
- switch ((enum ZDInternalError)errZD) {
+ switch (static_cast<enum ZDInternalError>(errZD)) {
default:
assert(0);
case ZD_OK :
length += 1;
- output = (char*)malloc(length);
+ output = static_cast<char*>(malloc(length));
if(output) {
output[0] = 0;
for(const auto& string : strings) {
projects / geeqie.git / commitdiff