{
ExifWin *ew;
- ew = g_object_get_data(G_OBJECT(window), "advanced_exif_data");
+ ew = static_cast<ExifWin *>(g_object_get_data(G_OBJECT(window), "advanced_exif_data"));
if (!ew) return;
/* store this, advanced view toggle needs to reload data */
{
PaneCommentData *pcd;
- pcd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pcd = static_cast<PaneCommentData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pcd) return;
file_data_unref(pcd->fd);
{
PaneCommentData *pcd;
- pcd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pcd = static_cast<PaneCommentData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pcd) return FALSE;
if (gtk_widget_has_focus(pcd->comment_view)) return gtk_widget_event(pcd->comment_view, event);
PaneCommentData *pcd;
gint w, h;
- pcd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pcd = static_cast<PaneCommentData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pcd) return;
gtk_widget_get_size_request(GTK_WIDGET(pane), &w, &h);
{
PaneCommentData *pcd;
- pcd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pcd = static_cast<PaneCommentData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pcd) return;
gchar *title = NULL;
static void bar_pane_exif_reparent_entry(GtkWidget *entry, GtkWidget *pane)
{
- PaneExifData *ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ PaneExifData *ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
PaneExifData *old_ped;
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
if (!ped || !ee) return;
static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
{
gchar *text;
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
gshort rating;
if (!ee) return;
{
PaneExifData *ped;
- ped = g_object_get_data(G_OBJECT(widget), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!ped) return;
file_data_unref(ped->fd);
gboolean ret = FALSE;
GList *list, *work;
- ped = g_object_get_data(G_OBJECT(bar), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!ped) return FALSE;
list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
while (!ret && work)
{
GtkWidget *entry = static_cast<GtkWidget *>(work->data);
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
work = work->next;
if (ee->editable && gtk_widget_has_focus(ee->value_widget)) ret = gtk_widget_event(ee->value_widget, event);
GtkSelectionData *selection_data, guint info,
guint UNUSED(time), gpointer UNUSED(data))
{
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
switch (info)
{
gint pos;
GtkWidget *new_entry = NULL;
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
switch (info)
static void bar_pane_exif_entry_dnd_begin(GtkWidget *entry, GdkDragContext *context, gpointer UNUSED(data))
{
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
if (!ee) return;
dnd_set_drag_label(entry, context, ee->key);
static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
{
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
bar_pane_exif_drag_types, n_exif_entry_drag_types,
ConfDialogData *cdd = static_cast<ConfDialogData *>(data);
/* either one or the other */
- PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
- ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
+ PaneExifData *ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(cdd->widget), "pane_data"));
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(cdd->widget), "entry_data"));
if (ped)
{
while (pane)
{
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (ped) break;
pane = gtk_widget_get_parent(pane);
}
/* the widget can be either ExifEntry (for editing) or Pane (for new entry)
we can decide it by the attached data */
- ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(widget), "entry_data"));
cdd = g_new0(ConfDialogData, 1);
const gchar *value;
ExifEntry *ee;
- ee = g_object_get_data(G_OBJECT(widget), "entry_data");
+ ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(widget), "entry_data"));
value = gtk_label_get_text(GTK_LABEL(ee->value_widget));
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clipboard, value, -1);
GtkWidget *menu;
/* the widget can be either ExifEntry (for editing) or Pane (for new entry)
we can decide it by the attached data */
- ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(widget), "entry_data"));
menu = popup_menu_short_lived();
if (bevent->button == MOUSE_BUTTON_LEFT)
{
- ee = g_object_get_data(G_OBJECT(widget), "entry_data");
+ ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(widget), "entry_data"));
value = gtk_label_get_text(GTK_LABEL(ee->value_widget));
clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
gtk_clipboard_set_text(clipboard, value, -1);
static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
{
- ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ExifEntry *ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
if (!ee) return;
WRITE_NL(); WRITE_STRING("<entry ");
PaneExifData *ped;
GList *work, *list;
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
WRITE_NL(); WRITE_STRING("<pane_exif ");
ExifEntry *ee;
work_windows = layout_window_list;
- lw = work_windows->data;
+ lw = static_cast<LayoutWindow *>(work_windows->data);
bar = lw->bar;
pane = bar_find_pane_by_id(bar, PANE_EXIF, "exif");
if (pane)
{
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
while (list)
{
- entry = list->data;
+ entry = static_cast<GtkWidget *>(list->data);
list = list->next;
- ee = g_object_get_data(G_OBJECT(entry), "entry_data");
+ ee = static_cast<ExifEntry *>(g_object_get_data(G_OBJECT(entry), "entry_data"));
exif_list = g_list_append(exif_list, g_strdup(ee->title));
exif_list = g_list_append(exif_list, g_strdup(ee->key));
}
PaneExifData *ped;
gchar *title = NULL;
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
while (*attribute_names)
gboolean if_set = TRUE;
gboolean editable = FALSE;
- ped = g_object_get_data(G_OBJECT(pane), "pane_data");
+ ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
while (*attribute_names)
work = g_list_first(pgd->geocode_list);
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
if (fd->name && !fd->parent)
{
work = work->next;
gchar *location;
gchar **latlong;
- pgd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pgd) return;
if (info == TARGET_URI_LIST)
work = list;
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (fd->name && !fd->parent)
{
message = g_string_new("");
if (count == 1)
{
- fd_found = g_list_first(pgd->geocode_list)->data;
+ fd_found = static_cast<FileData *>(g_list_first(pgd->geocode_list)->data);
g_string_append_printf(message,
_("\nDo you want to geocode image %s?"), fd_found->name);
}
ClutterActor *actor;
marker = CLUTTER_ACTOR(data);
- fd = g_object_get_data(G_OBJECT(marker), "file_fd");
+ fd = static_cast<FileData *>(g_object_get_data(G_OBJECT(marker), "file_fd"));
if (fd->thumb_pixbuf != NULL)
{
actor = gtk_clutter_texture_new();
if (bevent->button == MOUSE_BUTTON_LEFT)
{
label_marker = CLUTTER_ACTOR(widget);
- fd = g_object_get_data(G_OBJECT(label_marker), "file_fd");
+ fd = static_cast<FileData *>(g_object_get_data(G_OBJECT(label_marker), "file_fd"));
/* If the marker is showing a thumbnail, delete it
*/
if(pgd->not_added)
{
- fd = pgd->not_added->data;
+ fd = static_cast<FileData *>(pgd->not_added->data);
pgd->not_added = pgd->not_added->next;
latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 0);
if (!pgd) return;
- mapsource = g_object_get_data(G_OBJECT(widget), "menu_item_radio_data");
+ mapsource = static_cast<gchar *>(g_object_get_data(G_OBJECT(widget), "menu_item_radio_data"));
bar_pane_gps_set_map_source(pgd, mapsource);
}
if (count == 0) return;
- pgd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pgd) return;
bar_pane_gps_update(pgd);
{
PaneGPSData *pgd;
- pgd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pgd) return;
file_data_unref(pgd->fd);
{
PaneGPSData *pgd;
- pgd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pgd) return FALSE;
if (gtk_widget_has_focus(pgd->widget)) return gtk_widget_event(GTK_WIDGET(pgd->widget), event);
gint int_position;
gint w, h;
- pgd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pgd) return;
WRITE_NL();
gint int_longitude, int_latitude;
gdouble longitude, latitude;
- pgd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pgd = static_cast<PaneGPSData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pgd)
return;
{
PaneHistogramData *phd;
- phd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ phd = static_cast<PaneHistogramData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!phd) return;
file_data_unref(phd->fd);
{
PaneHistogramData *phd;
- phd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ phd = static_cast<PaneHistogramData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!phd) return;
WRITE_NL(); WRITE_STRING("<pane_histogram ");
{
PaneHistogramData *phd;
- phd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ phd = static_cast<PaneHistogramData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!phd) return;
gint histogram_channel = phd->histogram->histogram_channel;
while (list)
{
- const gchar *word = list->data;
+ const gchar *word = static_cast<const gchar *>(list->data);
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
{
PaneKeywordsData *pkd;
- pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pkd) return;
file_data_unref(pkd->fd);
GList *path_expanded = NULL;
gint w, h;
- pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pkd) return;
gtk_widget_get_size_request(GTK_WIDGET(pane), &w, &h);
{
PaneKeywordsData *pkd;
- pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
+ pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
if (!pkd) return FALSE;
if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
GList *work = *keywords;
while (work)
{
- gchar *keyword = work->data;
+ gchar *keyword = static_cast<gchar *>(work->data);
if (keyword_exists(keyword_tree, NULL, dest_kw_iter, keyword, FALSE, NULL))
{
GList *next = work->next;
work = new_keywords;
while (work)
{
- gchar *keyword = work->data;
+ gchar *keyword = static_cast<gchar *>(work->data);
keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
work = work->next;
work = pkd->expanded_rows;
while (work)
{
- path = work->data;
+ path = static_cast<gchar *>(work->data);
tree_path = gtk_tree_path_new_from_string(path);
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
work = work->next;
{
PaneKeywordsData *pkd;
- pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pkd) return;
gchar *title = NULL;
gchar *path = NULL;
GtkTreePath *tree_path;
- pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pkd) return;
while (*attribute_names)
{
PaneRatingData *prd;
- prd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ prd = static_cast<PaneRatingData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!prd) return;
file_data_unref(prd->fd);
{
PaneRatingData *prd;
- prd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ prd = static_cast<PaneRatingData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!prd) return;
WRITE_NL();
PaneRatingData *prd;
gchar *title = NULL;
- prd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ prd = static_cast<PaneRatingData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!prd) return;
while (*attribute_names)
FileData *fd;
gchar *name;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (file_extension_match(fd->path, GQ_COLLECTION_EXT))
GList *work = sd->undo_src_list;
while(work)
{
- gchar *filename = g_strdup(filename_from_path(work->data));
+ gchar *filename = g_strdup(filename_from_path(work->data));
gchar *dest_path = g_build_filename(g_strdup(dest), filename, NULL);
sd->undo_dest_list = g_list_prepend(sd->undo_dest_list, g_strdup(dest_path));
work = work->next;
{
GList *work = NULL;
- src_path = g_strdup(sd->undo_src_list->data);
+ src_path = g_strdup(static_cast<const gchar *>(sd->undo_src_list->data));
src_dir = remove_level_from_path(src_path);
list = sd->undo_dest_list;
while (list)
{
- work = g_list_prepend(work, file_data_new_group(list->data));
+ work = g_list_prepend(work, file_data_new_group(static_cast<const gchar *>(list->data)));
list=list->next;
}
file_util_move_simple(work, src_dir, sd->lw->window);
delete_list = sd->undo_dest_list;
while (delete_list)
{
- work = g_list_append(work, file_data_new_group(delete_list->data));
+ work = g_list_append(work, file_data_new_group(static_cast<const gchar *>(delete_list->data)));
delete_list = delete_list->next;
}
options->file_ops.safe_delete_enable = TRUE;
}
layout_refresh(sd->lw);
- origin = (sd->undo_src_list)->data;
+ origin = static_cast<gchar *>((sd->undo_src_list)->data);
if (isfile(origin))
{
while (work)
{
gchar *source;
- source = work->data;
+ source = static_cast<gchar *>(work->data);
work = work->next;
collect_manager_remove(file_data_new_group(source), sd->undo_collection);
}
{
FileData *image_fd;
- image_fd = list->data;
+ image_fd = static_cast<FileData *>(list->data);
list = list->next;
collect_manager_add(image_fd, path);
}
const gchar *key;
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
- key = g_object_get_data(G_OBJECT(button), "filter_key");
+ key = static_cast<const gchar *>(g_object_get_data(G_OBJECT(button), "filter_key"));
bar_sort_set_action(sd, BAR_SORT_FILTER, key);
}
{
SortData *sd;
- sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
+ sd = static_cast<SortData *>(g_object_get_data(G_OBJECT(bar), "bar_sort_data"));
if (!sd) return;
gtk_widget_destroy(sd->vbox);
SortData *sd;
if (!bar) return;
- sd = g_object_get_data(G_OBJECT(bar), "bar_sort_data");
+ sd = static_cast<SortData *>(g_object_get_data(G_OBJECT(bar), "bar_sort_data"));
if (!sd) return;
WRITE_NL(); WRITE_STRING("<bar_sort ");
gdk_device_get_position(device, NULL, &x, &y);
list = gtk_container_get_children(GTK_CONTAINER(expander));
- data_box = list->data;
+ data_box = static_cast<GtkWidget *>(list->data);
window = gtk_window_new(GTK_WINDOW_POPUP);
{
//GtkWidget *bar = static_cast<//GtkWidget *>(data);
const KnownPanes *pane = known_panes;
- const gchar *id = g_object_get_data(G_OBJECT(widget), "pane_add_id");
+ const gchar *id = static_cast<const gchar *>(g_object_get_data(G_OBJECT(widget), "pane_add_id"));
const gchar *config;
if (!id) return;
(g_strcmp0(label, "Keywords") == 0) ||
(g_strcmp0(label, "GPS Map") == 0);
- bd = g_object_get_data(G_OBJECT(widget), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(widget), "bar_data"));
if (bd)
{
expander = NULL;
static void bar_pane_set_fd_cb(GtkWidget *expander, gpointer data)
{
GtkWidget *widget = gtk_bin_get_child(GTK_BIN(expander));
- PaneData *pd = g_object_get_data(G_OBJECT(widget), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!pd) return;
if (pd->pane_set_fd) pd->pane_set_fd(widget, data);
}
void bar_set_fd(GtkWidget *bar, FileData *fd)
{
BarData *bd;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return;
file_data_unref(bd->fd);
static void bar_pane_notify_selection_cb(GtkWidget *expander, gpointer data)
{
GtkWidget *widget = gtk_bin_get_child(GTK_BIN(expander));
- PaneData *pd = g_object_get_data(G_OBJECT(widget), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!pd) return;
if (pd->pane_notify_selection) pd->pane_notify_selection(widget, GPOINTER_TO_INT(data));
}
void bar_notify_selection(GtkWidget *bar, gint count)
{
BarData *bd;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return;
gtk_container_foreach(GTK_CONTAINER(bd->vbox), bar_pane_notify_selection_cb, GINT_TO_POINTER(count));
GList *list, *work;
gboolean ret = FALSE;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return FALSE;
list = gtk_container_get_children(GTK_CONTAINER(bd->vbox));
while (work)
{
GtkWidget *widget = gtk_bin_get_child(GTK_BIN(work->data));
- PaneData *pd = g_object_get_data(G_OBJECT(widget), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!pd) continue;
if (pd->pane_event && pd->pane_event(widget, event))
if (!id || !id[0]) return NULL;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return NULL;
list = gtk_container_get_children(GTK_CONTAINER(bd->vbox));
while (work)
{
GtkWidget *widget = gtk_bin_get_child(GTK_BIN(work->data));
- PaneData *pd = g_object_get_data(G_OBJECT(widget), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!pd) continue;
if (type == pd->type && strcmp(id, pd->id) == 0)
BarData *bd;
GList *list, *work;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return;
list = gtk_container_get_children(GTK_CONTAINER(bd->vbox));
if (!bar) return;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return;
WRITE_NL(); WRITE_STRING("<bar ");
{
GtkWidget *expander = static_cast<GtkWidget *>(work->data);
GtkWidget *widget = gtk_bin_get_child(GTK_BIN(expander));
- PaneData *pd = g_object_get_data(G_OBJECT(widget), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(widget), "pane_data"));
if (!pd) continue;
pd->expanded = gtk_expander_get_expanded(GTK_EXPANDER(expander));
void bar_update_expander(GtkWidget *pane)
{
- PaneData *pd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
GtkWidget *expander;
if (!pd) return;
void bar_add(GtkWidget *bar, GtkWidget *pane)
{
GtkWidget *expander;
- BarData *bd = g_object_get_data(G_OBJECT(bar), "bar_data");
- PaneData *pd = g_object_get_data(G_OBJECT(pane), "pane_data");
+ BarData *bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
+ PaneData *pd = static_cast<PaneData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!bd) return;
{
BarData *bd;
- bd = g_object_get_data(G_OBJECT(bar), "bar_data");
+ bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
if (!bd) return;
gtk_widget_destroy(bd->widget);
return FALSE;
}
- fd = cm->list->data;
+ fd = static_cast<FileData *>(cm->list->data);
DEBUG_1("purge chk (%d) \"%s\"", (cm->clear && !cm->metadata), fd->path);
}
}
- fd = cm->list->data;
+ fd = static_cast<FileData *>(cm->list->data);
cm->done_list = g_list_remove(cm->done_list, fd);
cm->list = g_list_remove(cm->list, fd);
file_data_unref(fd);
{
const gchar *buf;
- fd = cm->list->data;
+ fd = static_cast<FileData *>(cm->list->data);
if (strlen(fd->path) > base_length)
{
buf = fd->path + base_length;
FileData *fd;
gint success;
- fd = cd->list->data;
+ 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);
{
FileData *fd;
- fd = cd->list_dir->data;
+ fd = static_cast<FileData *>(cd->list_dir->data);
cd->list_dir = g_list_remove(cd->list_dir, fd);
cache_manager_render_folder(cd, fd);
{
FileData *next_fd;
- next_fd = cd->list->data;
+ next_fd = static_cast<FileData *>(cd->list->data);
cd->list = g_list_remove(cd->list, next_fd);
DEBUG_1("thumb removed: %s", next_fd->path);
{
FileData *next_fd;
- next_fd = cd->list->data;
+ next_fd = static_cast<FileData *>(cd->list->data);
cd->list = g_list_remove(cd->list, next_fd);
cd->tl = thumb_loader_std_thumb_file_validate(next_fd->path, cd->days,
if (cd->list)
{
FileData *fd;
- fd = cd->list->data;
+ fd = static_cast<FileData *>(cd->list->data);
cd->list = g_list_remove(cd->list, fd);
load_mask = CACHE_LOADER_DIMENSIONS | CACHE_LOADER_DATE | CACHE_LOADER_MD5SUM | CACHE_LOADER_SIMILARITY;
{
FileData *fd;
- fd = cd->list_dir->data;
+ 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);
static void collection_confirm_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
{
FileDialog *fd = static_cast<FileDialog *>(data);
- CollectionData *cd = GENERIC_DIALOG(fd)->data;
+ CollectionData *cd = static_cast<CollectionData *>(GENERIC_DIALOG(fd)->data);
if (!collection_save_confirmed(fd, TRUE, cd))
{
}
work = cd->list;
- ci = work->data;
+ ci = static_cast<CollectInfo *>(work->data);
work = work->next;
/* find first unloaded thumb */
while (work && ci->pixbuf)
{
- ci = work->data;
+ ci = static_cast<CollectInfo *>(work->data);
work = work->next;
}
{
CollectManagerAction *action;
- action = work->data;
+ action = static_cast<CollectManagerAction *>(work->data);
work = work->next;
collect_manager_action_unref(action);
{
CollectManagerEntry *entry;
- entry = work->data;
+ entry = static_cast<CollectManagerEntry *>(work->data);
work = work->next;
if (strcmp(entry->path, path) == 0)
{
return;
}
- orig_action = g_hash_table_lookup(entry->newpath_hash, action->newpath);
+ orig_action = static_cast<CollectManagerAction *>(g_hash_table_lookup(entry->newpath_hash, action->newpath));
if (orig_action)
{
/* target already exists */
return;
}
- orig_action = g_hash_table_lookup(entry->newpath_hash, action->oldpath);
+ orig_action = static_cast<CollectManagerAction *>(g_hash_table_lookup(entry->newpath_hash, action->oldpath));
if (orig_action)
{
/* new action with the same file */
}
- orig_action = g_hash_table_lookup(entry->oldpath_hash, action->oldpath);
+ orig_action = static_cast<CollectManagerAction *>(g_hash_table_lookup(entry->oldpath_hash, action->oldpath));
if (orig_action)
{
/* another action for the same source, ignore */
/* get new files */
if (entry->add_list)
{
- action = entry->add_list->data;
+ action = static_cast<CollectManagerAction *>(entry->add_list->data);
g_assert(action->oldpath == NULL);
entry->add_list = g_list_remove(entry->add_list, action);
path = g_strdup(action->newpath);
return (path != NULL);
}
- action = g_hash_table_lookup(entry->oldpath_hash, path);
+ action = static_cast<CollectManagerAction *>(g_hash_table_lookup(entry->oldpath_hash, path));
if (action)
{
CollectManagerEntry *entry;
GList *list_step;
- entry = work->data;
+ entry = static_cast<CollectManagerEntry *>(work->data);
work = work->next;
list_step = list;
{
FileData *fd;
- fd = list_step->data;
+ fd = static_cast<FileData *>(list_step->data);
list_step = list_step->next;
if (strcmp(fd->path, entry->path) == 0)
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
collect_manager_entry_new(fd->path);
CollectManagerAction *action;
GList *work;
- action = collection_manager_action_list->data;
+ action = static_cast<CollectManagerAction *>(collection_manager_action_list->data);
work = collection_manager_entry_list;
while (work)
{
CollectManagerEntry *entry;
- entry = work->data;
+ entry = static_cast<CollectManagerEntry *>(work->data);
work = work->next;
if (action->type == COLLECTION_MANAGER_UPDATE)
{
CollectManagerEntry *entry;
- entry = work->data;
+ entry = static_cast<CollectManagerEntry *>(work->data);
work = work->next;
if (collect_manager_process_entry(entry)) return TRUE;
}
while (list)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
filename = g_strdup(filename_from_path((gchar *)fd->path));
if (file_extension_match(filename, GQ_COLLECTION_EXT))
work = g_list_find(ct->cd->list, start);
while (work)
{
- info = work->data;
+ info = static_cast<CollectInfo *>(work->data);
collection_table_select_util(ct, info, select);
if (work->data != end)
return;
}
- label = g_object_get_data(G_OBJECT(ct->tip_window), "tip_label");
+ label = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(ct->tip_window), "tip_label"));
gtk_label_set_text(GTK_LABEL(label), ct->show_text ? ct->tip_info->fd->path : ct->tip_info->fd->name);
}
}
static void collection_table_popup_edit_cb(GtkWidget *widget, gpointer data)
{
CollectTable *ct;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- ct = submenu_item_get_data(widget);
+ ct = static_cast<CollectTable *>(submenu_item_get_data(widget));
if (!ct) return;
CollectTable *ct;
SortType type;
- ct = submenu_item_get_data(widget);
+ ct = static_cast<CollectTable *>(submenu_item_get_data(widget));
if (!ct) return;
{
CollectTable *ct;
- ct = submenu_item_get_data(widget);
+ ct = static_cast<CollectTable *>(submenu_item_get_data(widget));
if (!ct) return;
list = collection_table_selection_get_list(ct);
if (list)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
if (fd)
{
layout_set_fd(lw, fd);
gtk_tree_model_get(store, &iter, CTABLE_COLUMN_POINTER, &list, -1);
n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_number"));
- info = g_list_nth_data(list, n);
+ info = static_cast<CollectInfo *>(g_list_nth_data(list, n));
if (info)
{
{
gint col;
- info = work->data;
+ info = static_cast<CollectInfo *>(work->data);
*after = TRUE;
if (collection_table_find_iter(ct, info, &iter, &col))
work = g_list_find(ct->cd->list, info);
if (work && work->next)
{
- info = work->next->data;
+ info = static_cast<CollectInfo *>(work->next->data);
}
else
{
gtk_tree_view_column_set_fixed_width(column, thumb_width + (THUMB_BORDER_PADDING * 6));
list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
- cell = (list) ? list->data : NULL;
+ cell = static_cast<GtkCellRenderer *>((list) ? list->data : NULL);
g_list_free(list);
if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
CollectInfo *info;
if (work)
{
- info = work->data;
+ info = static_cast<CollectInfo *>(work->data);
work = work->next;
c++;
}
*/
if (cd->number == COLLECT_TABLE_MAX_COLUMNS) return;
- info = g_list_nth_data(list, cd->number);
+ info = static_cast<CollectInfo *>(g_list_nth_data(list, cd->number));
style = gtk_widget_get_style(ct->listview);
if (info && (info->flag_mask & SELECTION_SELECTED) )
work = cd->list;
while (work)
{
- ci = work->data;
+ ci = static_cast<CollectInfo *>(work->data);
fd = ci->fd;
*contents = g_string_append(*contents, g_strdup(fd->path));
*contents = g_string_append(*contents, "\n");
work = cd->list;
while (work)
{
- ci = work->data;
+ ci = static_cast<CollectInfo *>(work->data);
list = g_list_append(list, ci->fd);
work = work->next;
else
while (*ptr == '\n') ptr++;
- info = g_list_nth_data(cd->list, item_number);
+ info = static_cast<CollectInfo *>(g_list_nth_data(cd->list, item_number));
if (!info) continue;
if (list) *list = g_list_append(*list, file_data_ref(info->fd));
while (work)
{
gint len;
- gchar *text = work->data;
+ gchar *text = static_cast<gchar *>(work->data);
work = work->prev;
work = list;
while (work)
{
- cd->list = collection_list_remove(cd->list, work->data);
+ cd->list = collection_list_remove(cd->list, static_cast<CollectInfo *>(work->data));
work = work->next;
}
cd->changed = (cd->list != NULL);
{
ColorManCache *cc;
- cc = cm_cache_list->data;
+ cc = static_cast<ColorManCache *>(cm_cache_list->data);
color_man_cache_free(cc);
}
}
ColorManCache *cc;
gboolean match = FALSE;
- cc = work->data;
+ cc = static_cast<ColorManCache *>(work->data);
work = work->next;
if (cc->profile_in_type == in_type &&
pixbuf_width = gdk_pixbuf_get_width(pixbuf);
pixbuf_height = gdk_pixbuf_get_height(pixbuf);
- cc = cm->profile;
+ cc = static_cast<ColorManCache *>(cm->profile);
pix = gdk_pixbuf_get_pixels(pixbuf);
rs = gdk_pixbuf_get_rowstride(pixbuf);
ColorManCache *cc;
if (!cm) return FALSE;
- cc = cm->profile;
+ cc = static_cast<ColorManCache *>(cm->profile);
if (image_profile) *image_profile = color_man_get_profile_name(cc->profile_in_type, cc->profile_in);
if (screen_profile) *screen_profile = color_man_get_profile_name(cc->profile_out_type, cc->profile_out);
static gboolean log_msg_cb(gpointer data)
{
- gchar *buf = data;
+ gchar *buf = static_cast<gchar *>(data);
log_window_append(buf, LOG_MSG);
g_free(buf);
return FALSE;
*/
static gboolean log_normal_cb(gpointer data)
{
- gchar *buf = data;
+ gchar *buf = static_cast<gchar *>(data);
gchar *buf_casefold = g_utf8_casefold(buf, -1);
gchar *error_casefold = g_utf8_casefold(_("error"), -1);
gchar *warning_casefold = g_utf8_casefold(_("warning"), -1);
list = options->disabled_plugins;
while (list)
{
- haystack = list->data;
+ haystack = static_cast<gchar *>(list->data);
if (haystack && strcmp(haystack, path) == 0)
{
*/
static void dupe_comparison_func(gpointer d1, gpointer d2)
{
- DupeQueueItem *dqi = d1;
- DupeWindow *dw = d2;
+ DupeQueueItem *dqi = static_cast<DupeQueueItem *>(d1);
+ DupeWindow *dw = static_cast<DupeWindow *>(d2);
DupeSearchMatch *dsm;
DupeItem *di;
GList *matches = NULL;
GList *work = dqi->work;
while (work)
{
- di = work->data;
+ di = static_cast<DupeItem *>(work->data);
/* forward for second set, back for simple compare */
if (dw->second_set)
if (child->group)
{
- dm = child->group->data;
+ dm = static_cast<DupeMatch *>(child->group->data);
rank = (gint)floor(dm->rank);
}
else
temp = g_list_last(parent->group);
while (temp)
{
- DupeMatch *dm = temp->data;
+ DupeMatch *dm = static_cast<DupeMatch *>(temp->data);
DupeItem *child;
child = dm->di;
if (dw->setup_point)
{
- DupeItem *di = dw->setup_point->data;
+ DupeItem *di = static_cast<DupeItem *>(dw->setup_point->data);
if (!di->simd)
{
while (dw->setup_point)
{
- DupeItem *di = dw->setup_point->data;
+ DupeItem *di = static_cast<DupeItem *>(dw->setup_point->data);
dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
dw->setup_n++;
while (dw->setup_point)
{
- DupeItem *di = dw->setup_point->data;
+ DupeItem *di = static_cast<DupeItem *>(dw->setup_point->data);
dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
dw->setup_n++;
while (dw->setup_point)
{
- DupeItem *di = dw->setup_point->data;
+ DupeItem *di = static_cast<DupeItem *>(dw->setup_point->data);
if (!di->simd)
{
{
dw->setup_n++;
dupe_window_update_progress(dw, _("Sorting..."), 0.0, FALSE);
- search_match_list_item = dw->search_matches_sorted->data;
+ search_match_list_item = static_cast<DupeSearchMatch *>(dw->search_matches_sorted->data);
if (!dupe_match_link_exists(search_match_list_item->a, search_match_list_item->b))
{
DupeItem *new_parent;
DupeMatch *dm;
- dm = parent->group->data;
+ dm = static_cast<DupeMatch *>(parent->group->data);
new_parent = dm->di;
dupe_match_reparent(dw, parent, new_parent);
dupe_listview_remove(dw, parent);
return FALSE;
}
- fd = queue->data;
+ fd = static_cast<FileData *>(queue->data);
if (fd)
{
if (isfile(fd->path))
work = g_list_first(dw->list);
while (work)
{
- di_list = work->data;
+ di_list = static_cast<DupeItem *>(work->data);
if (di_list->fd == di->fd)
{
return;
work = g_list_first(dw->second_list);
while (work)
{
- di_list = work->data;
+ di_list = static_cast<DupeItem *>(work->data);
if (di_list->fd == di->fd)
{
return;
for (GList *i = dw->list; i != NULL; i = i->next)
{
- DupeItem *di = i->data;
+ DupeItem *di = static_cast<DupeItem *>(i->data);
g_hash_table_add(dw->list_cache, di->fd);
}
for (GList *i = dw->second_list; i != NULL; i = i->next)
{
- DupeItem *di = i->data;
+ DupeItem *di = static_cast<DupeItem *>(i->data);
g_hash_table_add(dw->second_list_cache, di->fd);
}
{
DupeItem *di;
- di = work->data;
+ di = static_cast<DupeItem *>(work->data);
work = work->next;
dupe_item_remove(dw, di);
}
static void dupe_menu_edit_cb(GtkWidget *widget, gpointer data)
{
DupeWindow *dw;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- dw = submenu_item_get_data(widget);
+ dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
if (!dw) return;
dupe_window_edit_selected(dw, key);
DupeWindow *dw;
GList *selection_list;
- dw = submenu_item_get_data(widget);
+ dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
selection_list = dupe_listview_get_selection(dw, dw->listview);
pop_menu_collections(selection_list, data);
list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
if (!list) return;
- cell = list->data;
+ cell = static_cast<GtkCellRenderer *>(list->data);
g_list_free(list);
g_object_set(G_OBJECT(cell), "height", (thumb) ? options->thumbnails.max_height : -1, NULL);
GList *last;
last = g_list_last(slist);
- tpath = last->data;
+ tpath = static_cast<GtkTreePath *>(last->data);
/* last is newest selected file */
gtk_tree_model_get_iter(store, &iter, tpath);
slist = gtk_tree_selection_get_selected_rows(selection, &store);
work = slist;
- tpath = work->data;
+ tpath = static_cast<GtkTreePath *>(work->data);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_new, -1);
color_old = !color_new;
while (work)
{
- tpath = work->data;
+ tpath = static_cast<GtkTreePath *>(work->data);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_POINTER, &di, -1);
static void pop_menu_export(GList *UNUSED(selection_list), gpointer dupe_window, gpointer data)
{
const gint index = GPOINTER_TO_INT(data);
- DupeWindow *dw = dupe_window;
+ DupeWindow *dw = static_cast<DupeWindow *>(dupe_window);
gchar *title = "Export duplicates data";
gchar *default_path = "/tmp/";
gchar *file_extension;
DupeWindow *dw;
GList *selection_list;
- dw = submenu_item_get_data(widget);
+ dw = static_cast<DupeWindow *>(submenu_item_get_data(widget));
selection_list = dupe_listview_get_selection(dw, dw->listview);
pop_menu_export(selection_list, dw, data);
static gboolean editor_remove_desktop_file_cb(gpointer UNUSED(key), gpointer value, gpointer UNUSED(user_data))
{
- EditorDescription *editor = value;
+ EditorDescription *editor = static_cast<EditorDescription *>(value);
return editor->hidden || editor->ignored;
}
static void editor_list_add_cb(gpointer UNUSED(key), gpointer value, gpointer data)
{
GList **listp = static_cast<GList **>(data);
- EditorDescription *editor = value;
+ EditorDescription *editor = static_cast<EditorDescription *>(value);
/* do not show the special commands in any list, they are called explicitly */
if (strcmp(editor->key, CMD_COPY) == 0 ||
while (work)
{
GList *work2;
- gchar *ext = work->data;
+ gchar *ext = static_cast<gchar *>(work->data);
work = work->next;
if (strcmp(ext, "*") == 0 ||
work2 = consider_sidecars ? fd->sidecar_files : NULL;
while (work2)
{
- FileData *sfd = work2->data;
+ FileData *sfd = static_cast<FileData *>(work2->data);
work2 = work2->next;
if (g_ascii_strcasecmp(ext, sfd->extension) == 0)
static EditorFlags editor_command_one(const EditorDescription *editor, GList *list, EditorData *ed)
{
gchar *command;
- FileData *fd = (ed->flags & EDITOR_NO_PARAM) ? NULL : list->data;;
+ FileData *fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? NULL : list->data);;
GPid pid;
gint standard_output;
gint standard_error;
FileData *fd;
EditorFlags error;
- fd = (ed->flags & EDITOR_NO_PARAM) ? NULL : ed->list->data;
+ fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? NULL : ed->list->data);
if (ed->vd)
{
EditorDescription *editor;
if (!key) return EDITOR_ERROR_EMPTY;
- editor = g_hash_table_lookup(editors, key);
+ editor = static_cast<EditorDescription *>(g_hash_table_lookup(editors, key));
if (!editor) return EDITOR_ERROR_EMPTY;
if (!list && !(editor->flags & EDITOR_NO_PARAM)) return EDITOR_ERROR_NO_FILE;
EditorDescription *editor;
if (!key) return TRUE;
- editor = g_hash_table_lookup(editors, key);
+ editor = static_cast<EditorDescription *>(g_hash_table_lookup(editors, key));
if (!editor) return TRUE;
return !!(editor->flags & EDITOR_KEEP_FS);
EditorDescription *editor;
if (!key) return TRUE;
- editor = g_hash_table_lookup(editors, key);
+ editor = static_cast<EditorDescription *>(g_hash_table_lookup(editors, key));
if (!editor) return TRUE;
return !!(editor->flags & EDITOR_DEST);
EditorDescription *editor;
if (!key) return FALSE;
- editor = g_hash_table_lookup(editors, key);
+ editor = static_cast<EditorDescription *>(g_hash_table_lookup(editors, key));
if (!editor) return FALSE;
return !!(editor->flags & EDITOR_NO_PARAM);
EditorDescription *editor;
if (!key) return FALSE;
- editor = g_hash_table_lookup(editors, key);
+ editor = static_cast<EditorDescription *>(g_hash_table_lookup(editors, key));
if (!editor) return FALSE;
/* Decide if the image file should be blocked during editor execution
guint i;
for (i = 0; i < chunk_count; i++) cp_length += chunk_length[i];
- cp_data = g_malloc(cp_length);
+ cp_data = static_cast<guchar *>(g_malloc(cp_length));
for (i = 0; i < chunk_count; i++)
{
while (fc->size > size && work)
{
GList *prev;
- last_fe = work->data;
+ last_fe = static_cast<FileCacheEntry *>(work->data);
prev = work->prev;
fc->list = g_list_delete_link(fc->list, work);
work = prev;
while (work)
{
GList *current = work;
- fe = work->data;
+ fe = static_cast<FileCacheEntry *>(work->data);
work = work->next;
if (fe->fd == fd)
work = sidecars;
while (work)
{
- sfd = work->data;
+ sfd = static_cast<FileData *>(work->data);
work = work->next;
file_data_disconnect_sidecar_file(fd, sfd);
if (!file_data_pool)
file_data_pool = g_hash_table_new(g_str_hash, g_str_equal);
- fd = g_hash_table_lookup(file_data_pool, path_utf8);
+ fd = static_cast<FileData *>(g_hash_table_lookup(file_data_pool, path_utf8));
if (fd)
{
file_data_ref(fd);
if (!fd && file_data_planned_change_hash)
{
- fd = g_hash_table_lookup(file_data_planned_change_hash, path_utf8);
+ fd = static_cast<FileData *>(g_hash_table_lookup(file_data_planned_change_hash, path_utf8));
if (fd)
{
DEBUG_1("planned change: using %s -> %s", path_utf8, fd->path);
st.st_mtime = 0;
}
- fd = g_hash_table_lookup(file_data_pool, path_utf8);
+ fd = static_cast<FileData *>(g_hash_table_lookup(file_data_pool, path_utf8));
if (!fd) fd = file_data_new(path_utf8, &st, TRUE);
if (fd)
{
while (list)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
log_printf("%-4d %s", fd->ref, fd->path);
list = list->next;
}
work = sidecar_ext_get_list();
while (work) {
- gchar *ext = work->data;
+ gchar *ext = static_cast<gchar *>(work->data);
work = work->next;
if (g_ascii_strcasecmp(extension, ext) == 0) return i;
s_work = fd->sidecar_files;
while (s_work)
{
- FileData *sfd = s_work->data;
+ FileData *sfd = static_cast<FileData *>(s_work->data);
s_work = s_work->next;
g_assert(sfd->magick == FD_MAGICK);
DEBUG_2(" sidecar: %p %s", (void *)sfd, sfd->name);
g_assert(fd->parent == NULL || fd->sidecar_files == NULL);
}
- parent_fd = basename_list->data;
+ parent_fd = static_cast<FileData *>(basename_list->data);
/* check if the second and next entries of basename_list are already connected
as sidecars of the first entry (parent_fd) */
while (fd->sidecar_files)
{
- FileData *sfd = fd->sidecar_files->data;
+ FileData *sfd = static_cast<FileData *>(fd->sidecar_files->data);
g_assert(sfd->parent == NULL || sfd->sidecar_files == NULL);
file_data_ref(sfd);
file_data_disconnect_sidecar_file(fd, sfd);
GList *list;
gchar *basename = g_strndup(fd->path, fd->extension - fd->path);
- list = g_hash_table_lookup(basename_hash, basename);
+ list = static_cast<GList *>(g_hash_table_lookup(basename_hash, basename));
if (!list)
{
DEBUG_1("TG: parent extension %s",parent_extension);
gchar *parent_basename = g_strndup(basename, parent_extension - basename);
DEBUG_1("TG: parent basename %s",parent_basename);
- FileData *parent_fd = g_hash_table_lookup(file_data_pool, basename);
+ FileData *parent_fd = static_cast<FileData *>(g_hash_table_lookup(file_data_pool, basename));
if (parent_fd)
{
DEBUG_1("TG: parent fd found");
- list = g_hash_table_lookup(basename_hash, parent_basename);
+ list = static_cast<GList *>(g_hash_table_lookup(basename_hash, parent_basename));
if (!g_list_find(list, parent_fd))
{
DEBUG_1("TG: parent fd doesn't fit");
filelist_read_real(dir, &files, NULL, TRUE);
- fd = g_hash_table_lookup(file_data_pool, path_utf8);
+ fd = static_cast<FileData *>(g_hash_table_lookup(file_data_pool, path_utf8));
if (!fd) fd = file_data_new(path_utf8, &st, TRUE);
if (fd)
{
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
new_list = g_list_prepend(new_list, file_data_ref(fd));
{
gchar *path;
- path = work->data;
+ path = static_cast<gchar *>(work->data);
work = work->next;
new_list = g_list_prepend(new_list, file_data_new_group(path));
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
new_list = g_list_prepend(new_list, g_strdup(fd->path));
static void file_data_notify_mark_func(gpointer UNUSED(key), gpointer value, gpointer UNUSED(user_data))
{
- FileData *fd = value;
+ FileData *fd = static_cast<FileData *>(value);
file_data_increment_version(fd);
file_data_send_notification(fd, NOTIFY_MARKS);
}
file_data_unref(fd);
}
- ofd = g_hash_table_lookup(file_data_planned_change_hash, new_path);
+ ofd = static_cast<FileData *>(g_hash_table_lookup(file_data_planned_change_hash, new_path));
if (ofd != fd)
{
if (ofd)
work = list;
while (work)
{
- fd1 = work->data;
+ fd1 = static_cast<FileData *>(work->data);
work = work->next;
if (fd1 != NULL && fd != fd1 )
{
FileData *fd;
gint error;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
error = with_sidecars ? file_data_sc_verify_ci(fd, list) : file_data_verify_ci(fd, list);
FileData *fd;
gint error;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
error = errors[i] & ~common_errors;
static void realtime_monitor_check_cb(gpointer key, gpointer UNUSED(value), gpointer UNUSED(data))
{
- FileData *fd = key;
+ FileData *fd = static_cast<FileData *>(key);
file_data_check_changed_files(fd);
static void marks_get_files(gpointer key, gpointer value, gpointer userdata)
{
- gchar *file_name = key;
- GString *result = userdata;
+ gchar *file_name = static_cast<gchar *>(key);
+ GString *result = static_cast<GString *>(userdata);
FileData *fd;
if (isfile(file_name))
{
- fd = value;
+ fd = static_cast<FileData *>(value);
if (fd && fd->marks > 0)
{
g_string_append_printf(result, "%s,%i\n", fd->path, fd->marks);
static void marks_clear(gpointer key, gpointer value, gpointer UNUSED(userdata))
{
- gchar *file_name = key;
+ gchar *file_name = static_cast<gchar *>(key);
gint mark_no;
gint n;
FileData *fd;
if (isfile(file_name))
{
- fd = value;
+ fd = static_cast<FileData *>(value);
if (fd && fd->marks > 0)
{
n = 0;
GString *filter = NULL;
guint i;
- format = work->data;
+ format = static_cast<GdkPixbufFormat *>(work->data);
work = work->next;
name = gdk_pixbuf_format_get_name(format);
{
FilterEntry *fe;
- fe = work->data;
+ fe = static_cast<FilterEntry *>(work->data);
work = work->next;
if (fe->enabled)
work = filter;
while (work)
{
- gchar *filter = work->data;
+ gchar *filter = static_cast<gchar *>(work->data);
guint lf = strlen(filter);
if (ln >= lf)
work = sidecar_ext_list;
while (work)
{
- gchar *ext = work->data;
+ gchar *ext = static_cast<gchar *>(work->data);
work = work->next;
g_free(ext);
}
static void fullscreen_prefs_selection_cb(GtkWidget *combo, gpointer data)
{
- gint *value = data;
+ gint *value = static_cast<gint *>(data);
GtkTreeModel *store;
GtkTreeIter iter;
GtkWidget *button;
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter)) return;
gtk_tree_model_get(store, &iter, FS_MENU_COLUMN_VALUE, value, -1);
- button = g_object_get_data(G_OBJECT(combo), BUTTON_ABOVE_KEY);
+ button = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(combo), BUTTON_ABOVE_KEY));
if (button)
{
gtk_widget_set_sensitive(button, *value != -1);
else
{
work = g_list_last(history_chain);
- if (g_strcmp0(work->data , path) != 0)
+ if (g_strcmp0(work->data , path) != static_cast<const char *>(0))
{
history_chain = g_list_append (history_chain, g_strdup(path));
chain_index = g_list_length(history_chain) - 1;
else
{
work = g_list_last(image_chain);
- if (g_strcmp0(work->data , path) != 0)
+ if (g_strcmp0(work->data , path) != static_cast<const char *>(0))
{
image_chain = g_list_append(image_chain, g_strdup(path));
image_chain_index = g_list_length(image_chain) - 1;
HistoryData *hd;
GList *work;
- hd = list->data;
+ hd = static_cast<HistoryData *>(list->data);
list = list->prev;
secure_fprintf(ssi, "[%s]\n", hd->key);
work = hd->list;
while (work)
{
- gchar *buf = work->data;
+ gchar *buf = static_cast<gchar *>(work->data);
if (strcmp(buf, path) == 0)
{
work = hd->list;
while (work)
{
- gchar *buf = work->data;
+ gchar *buf = static_cast<gchar *>(work->data);
if (strcmp(buf, oldpath) == 0)
{
if (newpath)
work = hd->list;
while (work)
{
- gchar *buf = work->data;
+ gchar *buf = static_cast<gchar *>(work->data);
if (strcmp(buf, path) == 0)
{
p += direction;
while (work)
{
- dirname = g_path_get_dirname(work->data);
+ dirname = static_cast<const gchar *>(g_path_get_dirname(work->data));
if (g_strcmp0(dirname, path) == 0)
{
if (isfile(work->data))
{
- ret = g_strdup(work->data);
+ ret = static_cast<const gchar *>(g_strdup(work->data));
}
g_free(dirname);
break;
while (work)
{
- list_dir = g_path_get_dirname(work->data);
+ list_dir = static_cast<const gchar *>(g_path_get_dirname(work->data));
/* If folder already in list, update and move to start of list */
if (g_strcmp0(list_dir, image_dir) == 0)
static gboolean image_loader_collection_load(gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
ImageLoaderCOLLECTION *ld = (ImageLoaderCOLLECTION *) loader;
- ImageLoader *il = ld->data;
+ ImageLoader *il = static_cast<ImageLoader *>(ld->data);
#define LINE_LENGTH 1000
static gboolean image_loader_external_load(gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
ImageLoaderExternal *ld = (ImageLoaderExternal *) loader;
- ImageLoader *il = ld->data;
+ ImageLoader *il = static_cast<ImageLoader *>(ld->data);
gchar *cmd_line;
gchar *randname;
gchar *tilde_filename;
static gboolean image_loader_ft_load (gpointer loader, const guchar *UNUSED(buf), gsize UNUSED(count), GError **UNUSED(error))
{
ImageLoaderFT *lft = (ImageLoaderFT *) loader;
- ImageLoader *il = lft->data;
+ ImageLoader *il = static_cast<ImageLoader *>(lft->data);
image_data *image = video_thumbnailer_create_image_data();
ctx->state = PSD_STATE_HEADER;
/* we'll allocate larger buffer once we know image size */
- ctx->buffer = g_malloc(PSD_HEADER_SIZE);
+ ctx->buffer = static_cast<guchar *>(g_malloc(PSD_HEADER_SIZE));
reset_context_buffer(ctx);
ctx->ch_bufs = NULL;
lt->requested_height = height;
lt->size_cb(loader, lt->requested_width, lt->requested_height, lt->data);
- pixels = g_try_malloc (bytes);
+ pixels = static_cast<guchar *>(g_try_malloc (bytes));
if (!pixels)
{
else
image_loader_backend_set_default(&il->backend);
- il->loader = il->backend.loader_new(image_loader_area_updated_cb, image_loader_size_cb, image_loader_area_prepared_cb, il);
+ il->loader = static_cast<void *>(il->backend.loader_new(image_loader_area_updated_cb, image_loader_size_cb, image_loader_area_prepared_cb, il));
#ifdef HAVE_TIFF
format = il->backend.get_format_name(il->loader);
g_assert(imd->pr);
- osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
+ osd = static_cast<OverlayStateData *>(g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA"));
return osd;
}
ColorMan *cm;
if (!imd) return FALSE;
- cm = imd->cm;
+ cm = static_cast<ColorMan *>(imd->cm);
if (!cm) return FALSE;
return color_man_get_status(cm, image_profile, screen_profile);
{
ImageWindow *imd;
- imd = work->data;
+ imd = static_cast<ImageWindow *>(work->data);
work = work->next;
image_options_set(imd);
{
FileData *temp;
- temp = work->data;
+ temp = static_cast<FileData *>(work->data);
if (fd == temp)
{
if (!work) return;
vw->list_pointer = work;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
image_change_fd(imd, fd, image_zoom_get_default(imd));
if (options->image.enable_read_ahead && work_ahead)
{
- FileData *next_fd = work_ahead->data;
+ FileData *next_fd = static_cast<FileData *>(work_ahead->data);
image_prebuffer_set(imd, next_fd);
}
}
}
vw->list_pointer = work;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
image_change_fd(imd, fd, image_zoom_get_default(imd));
if (options->image.enable_read_ahead && work_ahead)
{
- FileData *next_fd = work_ahead->data;
+ FileData *next_fd = static_cast<FileData *>(work_ahead->data);
image_prebuffer_set(imd, next_fd);
}
}
{
FileData *temp;
- temp = work->data;
+ temp = static_cast<FileData *>(work->data);
if (fd == temp)
{
vw->list_pointer = work;
vw->list_pointer = vw->list;
image_change_fd(vw->imd, (FileData *)vw->list->data, image_zoom_get_default(NULL));
/* Set fd to first in list */
- fd = vw->list->data;
+ fd = static_cast<FileData *>(vw->list->data);
if (options->image.enable_read_ahead)
{
{
ViewWindow *vw;
ImageWindow *imd;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- vw = submenu_item_get_data(widget);
+ vw = static_cast<ViewWindow *>(submenu_item_get_data(widget));
if (!vw) return;
if (!editor_window_flag_set(key))
ViewWindow *vw;
AlterType type;
- vw = submenu_item_get_data(widget);
+ vw = static_cast<ViewWindow *>(submenu_item_get_data(widget));
type = GPOINTER_TO_INT(data);
if (!vw) return;
FileData *fd;
GList *selection_list = NULL;
- vw = submenu_item_get_data(widget);
+ vw = static_cast<ViewWindow *>(submenu_item_get_data(widget));
imd = view_window_active_image(vw);
fd = image_get_fd(imd);
selection_list = g_list_append(selection_list, fd);
FileData *fd;
vw->list_pointer = vw->list;
- fd = vw->list->data;
+ fd = static_cast<FileData *>(vw->list->data);
image_change_fd(vw->imd, fd, image_zoom_get_default(vw->imd));
work = vw->list->next;
if (options->image.enable_read_ahead && work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
image_prebuffer_set(vw->imd, fd);
}
}
{
FileData *fd;
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
if (isfile(fd->path))
{
view_slideshow_stop(vw);
FileData *chk_fd;
GList *chk_link;
- chk_fd = work->data;
+ chk_fd = static_cast<FileData *>(work->data);
chk_link = work;
work = work->next;
if (vw->list_pointer)
{
- fd = vw->list_pointer->data;
+ fd = static_cast<FileData *>(vw->list_pointer->data);
}
else
{
GtkWidget *button;
gint a, b, c;
- lc = g_object_get_data(G_OBJECT(widget), "layout_config");
+ lc = static_cast<LayoutConfig *>(g_object_get_data(G_OBJECT(widget), "layout_config"));
if (!lc) return;
style = CLAMP(style, 0, layout_config_style_count);
- button = g_list_nth_data(lc->style_widgets, style);
+ button = static_cast<GtkWidget *>(g_list_nth_data(lc->style_widgets, style));
if (!button) return;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
{
LayoutConfig *lc;
- lc = g_object_get_data(G_OBJECT(widget), "layout_config");
+ lc = static_cast<LayoutConfig *>(g_object_get_data(G_OBJECT(widget), "layout_config"));
/* this should not happen */
if (!lc) return NULL;
{
LayoutConfig *lc;
- lc = g_object_get_data(G_OBJECT(widget), "layout_config");
+ lc = static_cast<LayoutConfig *>(g_object_get_data(G_OBJECT(widget), "layout_config"));
if (lc) lc->style = GPOINTER_TO_INT(data);
}
static void li_pop_menu_edit_cb(GtkWidget *widget, gpointer data)
{
LayoutWindow *lw;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- lw = submenu_item_get_data(widget);
+ lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
if (!editor_window_flag_set(key))
{
LayoutWindow *lw = static_cast<LayoutWindow *>(data);
AlterType type;
- lw = submenu_item_get_data(widget);
+ lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
type = (AlterType)GPOINTER_TO_INT(data);
image_alter_orientation(lw->image, lw->image->image_fd, type);
menu = gtk_widget_get_toplevel(widget);
if (!menu) return NULL;
- parent = g_object_get_data(G_OBJECT(menu), "click_parent");
+ parent = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(menu), "click_parent"));
if (!parent && lw->full_screen)
{
LayoutWindow *lw;
GList *selection_list = NULL;
- lw = submenu_item_get_data(widget);
+ lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
selection_list = g_list_append(selection_list, layout_image_get_fd(lw));
pop_menu_collections(selection_list, data);
if (list)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
if (isfile(fd->path))
{
{
if (lw->vf->type == FILEVIEW_ICON)
{
- fd_n = work->data;
+ fd_n = static_cast<FileData *>(work->data);
work = work->next;
}
else
{
- tpath = work->data;
+ tpath = static_cast<GtkTreePath *>(work->data);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &fd_n, -1);
work = work->next;
{
if (lw->vf->type == FILEVIEW_ICON)
{
- fd_n = work->data;
+ fd_n = static_cast<FileData *>(work->data);
work = work->next;
}
else
{
- tpath = work->data;
+ tpath = static_cast<GtkTreePath *>(work->data);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &fd_n, -1);
work = work->next;
{
if (lw->vf->type == FILEVIEW_ICON)
{
- fd_n = work->data;
+ fd_n = static_cast<FileData *>(work->data);
work = work->next;
}
else
{
- tpath = work->data;
+ tpath = static_cast<GtkTreePath *>(work->data);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &fd_n, -1);
work = work->next;
n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "recent_index"));
- path = g_list_nth_data(history_list_get_by_key("recent"), n);
+ path = static_cast<gchar *>(g_list_nth_data(history_list_get_by_key("recent"), n));
if (!path) return;
dupe = FALSE;
while (list)
{
- lw_tmp = list->data;
+ lw_tmp = static_cast<LayoutWindow *>(list->data);
if (g_strcmp0(lw_tmp->options.id, name_base) == 0)
{
dupe = TRUE;
GList *menulist = NULL;
menulist = layout_window_menu_list(menulist);
- WindowNames *wn = g_list_nth(menulist, n )->data;
+ WindowNames *wn = static_cast<WindowNames *>(g_list_nth(menulist, n )->data);
if (wn->path)
{
n = 0;
while (list)
{
- wn = list->data;
+ wn = static_cast<WindowNames *>(list->data);
item = menu_item_add_simple(sub_menu, wn->name, G_CALLBACK(layout_menu_new_window_cb), GINT_TO_POINTER(n));
if (wn->displayed)
{
list = layout_window_menu_list(list);
while (list)
{
- WindowNames *ln = list->data;
+ WindowNames *ln = static_cast<WindowNames *>(list->data);
if (g_strcmp0(ln->name, new_id) == 0)
{
gchar *buf;
for (i = 0; i < to_close; i++)
{
- gchar *name = old_path->data;
+ gchar *name = static_cast<gchar *>(old_path->data);
if (g_str_has_suffix(name, "Section"))
{
g_string_append(desc, " </placeholder>");
for (i = 0; i < to_open; i++)
{
- gchar *name = path->data;
+ gchar *name = static_cast<gchar *>(path->data);
if (g_str_has_suffix(name, "Section"))
{
g_string_append_printf(desc, " <placeholder name='%s'>", name);
case TOOLBAR_MAIN:
if (layout_window_list)
{
- lw_first = layout_window_list->data;
+ lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
if (lw_first->toolbar_actions[TOOLBAR_MAIN])
{
work_action = lw_first->toolbar_actions[type];
while (work_action)
{
- gchar *action = work_action->data;
+ gchar *action = static_cast<gchar *>(work_action->data);
work_action = work_action->next;
layout_toolbar_add(lw, type, action);
}
case TOOLBAR_STATUS:
if (layout_window_list)
{
- lw_first = layout_window_list->data;
+ lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
if (lw_first->toolbar_actions[TOOLBAR_MAIN])
{
work_action = lw_first->toolbar_actions[type];
while (work_action)
{
- gchar *action = work_action->data;
+ gchar *action = static_cast<gchar *>(work_action->data);
work_action = work_action->next;
layout_toolbar_add(lw, type, action);
}
WRITE_NL(); WRITE_STRING("<clear/>");
while (work)
{
- gchar *action = work->data;
+ gchar *action = static_cast<gchar *>(work->data);
work = work->next;
WRITE_NL(); WRITE_STRING("<toolitem ");
write_char_option(outstr, indent + 1, "action", action);
if (*lw == NULL)
{
if (current_lw) *lw = current_lw;
- else if (layout_window_list) *lw = layout_window_list->data;
+ else if (layout_window_list) *lw = static_cast<LayoutWindow *>(layout_window_list->data);
return (*lw != NULL);
}
return (g_list_find(layout_window_list, *lw) != NULL);
work = layout_window_list;
while (work)
{
- lw = work->data;
+ lw = static_cast<LayoutWindow *>(work->data);
lw->options.folder_window.vdivider_pos = gtk_paned_get_position(GTK_PANED(widget));
work = work->next;
}
gchar *current_path;
box_child_list = gtk_container_get_children(GTK_CONTAINER(widget));
- path_entry = box_child_list->data;
+ path_entry = static_cast<GtkComboBox *>(box_child_list->data);
current_path = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(path_entry));
gtk_widget_set_tooltip_text(GTK_WIDGET(widget), current_path);
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
- lw = submenu_item_get_data(widget);
+ lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
if (!lw) return;
type = (SortType)GPOINTER_TO_INT(data);
if (success)
{
work = g_list_last(layout_window_list);
- lw = work->data;
+ lw = static_cast<LayoutWindow *>(work->data);
g_free(lw->options.id);
lw->options.id = g_strdup(layout_get_unique_id());
}
static void search_entry_icon_cb(GtkEntry *UNUSED(entry), GtkEntryIconPosition pos, GdkEvent *UNUSED(event), gpointer userdata)
{
- LogWindow *logwin = userdata;
+ LogWindow *logwin = static_cast<LogWindow *>(userdata);
GtkTextIter start_find;
GtkTextIter end_find;
GtkTextBuffer *buffer;
while (work)
{
- gchar *opt = work->data;
+ gchar *opt = static_cast<gchar *>(work->data);
command_line_errors = g_string_append(command_line_errors, opt);
command_line_errors = g_string_append(command_line_errors, "\n");
list = layout_window_list;
while (list)
{
- tmp_lw = list->data;
+ tmp_lw = static_cast<LayoutWindow *>(list->data);
if (!g_str_has_prefix(tmp_lw->options.id, "lw"))
{
save_layout(list->data);
if (!options->image.use_custom_border_color)
{
work = layout_window_list;
- lw = work->data;
+ lw = static_cast<LayoutWindow *>(work->data);
style_context = gtk_widget_get_style_context(lw->window);
gtk_style_context_get_background_color(style_context, GTK_STATE_FLAG_NORMAL, &bg_color);
while (work)
{
- lw = work->data;
+ lw = static_cast<LayoutWindow *>(work->data);
image_background_set_color(lw->image, &theme_color);
work = work->next;
}
CollectWindow *cw;
const gchar *path;
- path = work->data;
+ path = static_cast<const gchar *>(work->data);
work = work->next;
cw = collection_window_new(path);
{
gchar *dirname;
- dirname = g_path_get_dirname(work->data);
+ dirname = static_cast<const gchar *>(g_path_get_dirname(work->data));
if (!path)
{
path = g_strdup(dirname);
{
FileData *fd;
- fd = file_data_new_simple(work->data);
+ fd = file_data_new_simple(static_cast<const gchar *>(work->data));
collection_add(cd, fd, FALSE);
file_data_unref(fd);
work = work->next;
gchar *result;
gint i;
- result = g_malloc(33);
+ result = static_cast<gchar *>(g_malloc(33));
for (i = 0; i < 16; i++)
{
result[2*i] = hex_digits[digest[i] >> 4];
work = collection_list;
while (work)
{
- const gchar *collection_name = work->data;
+ const gchar *collection_name = static_cast<const gchar *>(work->data);
menu_item_add(menu, collection_name, func,
GINT_TO_POINTER(index));
if (index >= 0)
{
collect_manager_list(&collection_list, NULL, NULL);
- collection_name = g_list_nth_data(collection_list, index);
+ collection_name = static_cast<gchar *>(g_list_nth_data(collection_list, index));
name = collection_path(collection_name);
cw = collection_window_new(name);
g_free(name);
while (work)
{
GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = entry->data;
+ gchar *entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
while (work)
{
GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = entry->data;
+ gchar *entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
while (work)
{
GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = entry->data;
+ gchar *entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
secure_fprintf(ssi, "[keywords]\n");
while (keywords && secsave_errno == SS_ERR_NONE)
{
- const gchar *word = keywords->data;
+ const gchar *word = static_cast<const gchar *>(keywords->data);
keywords = keywords->next;
secure_fprintf(ssi, "%s\n", word);
while (work)
{
- gchar *key = work->data;
+ gchar *key = static_cast<gchar *>(work->data);
if (g_hash_table_lookup(hashtable, key) == NULL)
{
/* unwritten data override everything */
if (fd->modified_xmp && format == METADATA_PLAIN)
{
- list = g_hash_table_lookup(fd->modified_xmp, key);
+ list = static_cast<GList *>(g_hash_table_lookup(fd->modified_xmp, key));
if (list) return string_list_copy(list);
}
GList *string_list = metadata_read_list(fd, key, format);
if (string_list)
{
- gchar *str = string_list->data;
+ gchar *str = static_cast<gchar *>(string_list->data);
string_list->data = NULL;
string_list_free(string_list);
return str;
while (list)
{
- gchar *haystack = list->data;
+ gchar *haystack = static_cast<gchar *>(list->data);
if (haystack)
{
{
while (list)
{
- gchar *haystack = list->data;
+ gchar *haystack = static_cast<gchar *>(list->data);
if (haystack && strcmp(haystack, string) == 0)
return haystack;
if (get_mark_func == meta_data_get_keyword_mark)
{
GtkTreeIter old_kw_iter;
- GList *old_path = mark_func_data;
+ GList *old_path = static_cast<GList *>(mark_func_data);
if (keyword_tree_get_iter(keyword_tree, &old_kw_iter, old_path) &&
(i == mark || /* release any previous connection of given mark */
gchar *iter_casefold = keyword_get_casefold(keyword_tree, &iter);
while (work)
{
- const gchar *casefold = work->data;
+ const gchar *casefold = static_cast<const gchar *>(work->data);
work = work->next;
if (strcmp(iter_casefold, casefold) == 0)
gchar *iter_name = keyword_get_name(keyword_tree, &iter);
while (work)
{
- const gchar *name = work->data;
+ const gchar *name = static_cast<const gchar *>(work->data);
work = work->next;
if (strcmp(iter_name, name) == 0)
work = kw_list;
while (work)
{
- const gchar *kw = work->data;
+ const gchar *kw = static_cast<const gchar *>(work->data);
work = work->next;
casefold_list = g_list_prepend(casefold_list, g_utf8_casefold(kw, -1));
gchar *buf;
gint l;
- buf = g_malloc(st.st_size + 1);
+ buf = static_cast<gchar *>(g_malloc(st.st_size + 1));
l = readlink(sl, buf, st.st_size);
if (l == st.st_size)
TagData *td;
buffer = gtk_text_view_get_buffer(image_overlay_template_view);
- td = g_object_get_data(G_OBJECT(widget), "tag_data");
+ td = static_cast<TagData *>(g_object_get_data(G_OBJECT(widget), "tag_data"));
gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer), td->key, -1);
gtk_widget_grab_focus(GTK_WIDGET(image_overlay_template_view));
TagData *td;
GtkTextView *image_overlay_template_view = static_cast<GtkTextView *>(data);
- td = g_object_get_data(G_OBJECT(btn), "tag_data");
+ td = static_cast<TagData *>(g_object_get_data(G_OBJECT(btn), "tag_data"));
gtk_selection_data_set_text(selection_data, td->key, -1);
gtk_widget_grab_focus(GTK_WIDGET(image_overlay_template_view));
{
TagData *td;
- td = g_object_get_data(G_OBJECT(btn), "tag_data");
+ td = static_cast<TagData *>(g_object_get_data(G_OBJECT(btn), "tag_data"));
g_free(td->key);
g_free(td->title);
}
while (work)
{
- gchar *kw = work->data;
+ gchar *kw = static_cast<gchar *>(work->data);
work = work->next;
if (!kw) continue;
#endif
else
{
- data = g_strdup(g_hash_table_lookup(vars, name));
+ data = static_cast<const gchar *>(g_strdup(g_hash_table_lookup(vars, name)));
if (!data)
data = metadata_read_string(fd, name, METADATA_FORMATTED);
}
PanItem *dot;
GList *node;
- dot = work->data;
+ dot = static_cast<PanItem *>(work->data);
node = work;
work = work->next;
{
PanItem *dot;
- dot = work->data;
+ dot = static_cast<PanItem *>(work->data);
work = work->next;
if (dot->fd)
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!pan_date_compare(fd->date, tc, PAN_DATE_LENGTH_DAY))
if (list)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
year = pan_date_value(fd->date, PAN_DATE_LENGTH_YEAR);
month = pan_date_value(fd->date, PAN_DATE_LENGTH_MONTH);
dx = x + PAN_CAL_DOT_GAP * 2;
dy = y + PAN_CAL_DOT_GAP * 2;
- fd = (work) ? work->data : NULL;
+ fd = static_cast<FileData *>((work) ? work->data : NULL);
while (fd && pan_date_compare(fd->date, dt, PAN_DATE_LENGTH_DAY))
{
PanItem *pi;
n++;
work = work->next;
- fd = (work) ? work->data : NULL;
+ fd = static_cast<FileData *>((work) ? work->data : NULL);
}
if (n > 0)
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (x1 > pi->x) x1 = pi->x;
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
pi->x -= x1;
{
gint *coord;
- coord = pi->data;
+ coord = static_cast<gint *>(pi->data);
coord[0] -= x1;
coord[1] -= y1;
coord[2] -= x1;
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
pi->x += x;
{
FlowerGroup *child;
- child = work->data;
+ child = static_cast<FlowerGroup *>(work->data);
work = work->next;
group->circumference += child->diameter;
{
FlowerGroup *child;
- child = work->data;
+ child = static_cast<FlowerGroup *>(work->data);
work = work->prev;
pan_flower_build(pw, child, group);
FileData *fd;
PanItem *pi;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE)
FileData *fd;
FlowerGroup *child;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!pan_is_ignored(fd->path, pw->ignore_symlinks))
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
pan_item_free(pi);
list = pan_item_find_by_fd(pw, PAN_ITEM_BOX, dir_fd, FALSE, FALSE);
if (list)
{
- PanItem *pi = list->data;
+ PanItem *pi = static_cast<PanItem *>(list->data);
*scroll_x = pi->x + pi->width / 2;
*scroll_y = pi->y + pi->height / 2;
}
FileData *fd;
PanItem *pi;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE)
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!pan_is_ignored(fd->path, pw->ignore_symlinks))
FileData *fd;
PanItem *pi;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE)
if (!pi || pi->type != PAN_ITEM_BOX) return;
- shadow = pi->data;
+ shadow = static_cast<gint *>(pi->data);
if (shadow)
{
pi->width -= shadow[0];
bw = pi->width;
bh = pi->height;
- shadow = pi->data;
+ shadow = static_cast<gint *>(pi->data);
if (shadow)
{
bw -= shadow[0];
pi->x, pi->y, pi->width, pi->height,
&rx, &ry, &rw, &rh) && pi->data)
{
- gint *coord = pi->data;
+ gint *coord = static_cast<gint *>(pi->data);
pixbuf_draw_triangle(pixbuf,
rx - x, ry - y, rw, rh,
coord[0] - x, coord[1] - y,
{
PanCacheData *pc;
- pc = work->data;
+ pc = static_cast<PanCacheData *>(work->data);
work = work->next;
if (pc->cd && pc->cd->dimensions &&
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
if ((pi->type == type || type == PAN_ITEM_NONE) &&
pi->key && strcmp(pi->key, key) == 0)
{
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
if ((pi->type == type || type == PAN_ITEM_NONE) &&
pi->key && strcmp(pi->key, key) == 0)
{
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
if ((pi->type == type || type == PAN_ITEM_NONE) && pi->fd)
{
gboolean match = FALSE;
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
if ((pi->type == type || type == PAN_ITEM_NONE) &&
x >= pi->x && x < pi->x + pi->width &&
y >= pi->y && y < pi->y + pi->height &&
{
PanItem *p;
- p = work1->data;
+ p = static_cast<PanItem *>(work1->data);
work1 = work1->next;
if (p && p->width > cw1) cw1 = p->width;
{
PanItem *p;
- p = work2->data;
+ p = static_cast<PanItem *>(work2->data);
work2 = work2->next;
if (p && p->width > cw2) cw2 = p->width;
PanItem *p2;
gint height = 0;
- p1 = work1->data;
- p2 = work2->data;
+ p1 = static_cast<PanItem *>(work1->data);
+ p2 = static_cast<PanItem *>(work2->data);
work1 = work1->next;
work2 = work2->next;
FileData *fd;
PanItem *pi;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!pan_date_compare(fd->date, group_start_date, PAN_DATE_LENGTH_DAY))
{
FileData *nfd;
- nfd = needle->data;
+ nfd = static_cast<FileData *>(needle->data);
if (pan_date_compare(nfd->date, group_start_date, PAN_DATE_LENGTH_DAY))
{
needle = needle->next;
gchar *buf;
gint l;
- buf = g_malloc(st.st_size + 1);
+ buf = static_cast<gchar *>(g_malloc(st.st_size + 1));
l = readlink(sl, buf, st.st_size);
if (l == st.st_size)
{
{
FileData *fd;
- fd = folders->data;
+ fd = static_cast<FileData *>(folders->data);
folders = g_list_remove(folders, fd);
if (!pan_is_ignored(fd->path, ignore_symlinks) &&
GList *work = g_list_first(haystack);
while (work)
{
- gchar *keyword = work->data;
+ gchar *keyword = static_cast<gchar *>(work->data);
work = work->next;
if (g_regex_match(filter->kw_regex, keyword, 0x0, NULL))
{
{
// regex compile failed; fall back to exact string match.
GList *found_elem = g_list_find_custom(haystack, filter->keyword, (GCompareFunc)g_strcmp0);
- if (found_elem && found_kw) *found_kw = found_elem->data;
+ if (found_elem && found_kw) *found_kw = static_cast<gchar *>(found_elem->data);
return !!found_elem;
}
}
while (filter_element)
{
- PanViewFilterElement *filter = filter_element->data;
+ PanViewFilterElement *filter = static_cast<PanViewFilterElement *>(filter_element->data);
filter_element = filter_element->next;
gchar *found_kw = NULL;
gboolean has_kw = pan_view_list_contains_kw_pattern(img_keywords, filter, &found_kw);
if (found && found->next)
{
found = found->next;
- pi = found->data;
+ pi = static_cast<PanItem *>(found->data);
}
else
{
- pi = list->data;
+ pi = static_cast<PanItem *>(list->data);
}
pan_info_update(pw, pi);
if (found && found->next)
{
found = found->next;
- pi = found->data;
+ pi = static_cast<PanItem *>(found->data);
}
else
{
- pi = list->data;
+ pi = static_cast<PanItem *>(list->data);
}
pan_info_update(pw, pi);
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->prev;
if (pi->fd && (pi->type == type || type == PAN_ITEM_NONE) &&
if (found && found->next)
{
found = found->next;
- pi = found->data;
+ pi = static_cast<PanItem *>(found->data);
}
else
{
- pi = list->data;
+ pi = static_cast<PanItem *>(list->data);
}
}
if (!pw->queue) return FALSE;
- pi = pw->queue->data;
+ pi = static_cast<PanItem *>(pw->queue->data);
pw->queue = g_list_remove(pw->queue, pi);
pw->queue_pi = pi;
PanItem *pi;
gboolean queue = FALSE;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
pi->refcount++;
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (pi->refcount > 0)
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (pi->fd &&
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (pi->fd &&
static gint pan_cache_sort_file_cb(gpointer a, gpointer b)
{
- PanCacheData *pca = a;
- PanCacheData *pcb = b;
+ PanCacheData *pca = static_cast<PanCacheData *>(a);
+ PanCacheData *pcb = static_cast<PanCacheData *>(b);
return filelist_sort_compare_filedata(pca->fd, pcb->fd);
}
GList *pan_cache_sort(GList *list, SortType method, gboolean ascend)
{
PanCacheData *pc;
- pc = work->data;
+ pc = static_cast<PanCacheData *>(work->data);
work = work->next;
cache_sim_data_free(pc->cd);
if (pw->cache_list)
{
PanCacheData *pc;
- pc = pw->cache_list->data;
+ pc = static_cast<PanCacheData *>(pw->cache_list->data);
if (!pc->cd)
{
if (!pw->cache_todo) return TRUE;
- fd = pw->cache_todo->data;
+ fd = static_cast<FileData *>(pw->cache_todo->data);
pw->cache_todo = g_list_remove(pw->cache_todo, fd);
pc = g_new0(PanCacheData, 1);
FileData *fd;
GList *needle;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
needle = haystack;
{
PanCacheData *pc;
- pc = needle->data;
+ pc = static_cast<PanCacheData *>(needle->data);
if (pc->fd == fd)
{
if (pc->cd && pc->cd->have_date && pc->cd->date >= 0)
{
PanGrid *pg;
- pg = work->data;
+ pg = static_cast<PanGrid *>(work->data);
work = work->next;
g_list_free(pg->list);
PanItem *pi;
GList *grid;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
grid = pw->list_grid;
PanGrid *pg;
gint rx, ry, rw, rh;
- pg = grid->data;
+ pg = static_cast<PanGrid *>(grid->data);
grid = grid->next;
if (util_clip_region(pi->x, pi->y, pi->width, pi->height,
{
PanGrid *pg;
- pg = work->data;
+ pg = static_cast<PanGrid *>(work->data);
work = work->next;
pg->list = g_list_reverse(pg->list);
PanItem *pi;
gint rx, ry, rw, rh;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (util_clip_region(x, y, width, height,
grid = pw->list_grid;
while (grid && !pg)
{
- pg = grid->data;
+ pg = static_cast<PanGrid *>(grid->data);
grid = grid->next;
if (x < pg->x || x + width > pg->x + pg->w ||
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (width < pi->x + pi->width) width = pi->x + pi->width;
{
PanItem *pi;
- pi = work->data;
+ pi = static_cast<PanItem *>(work->data);
work = work->next;
if (width < pi->x + pi->width) width = pi->x + pi->width;
exif_list = bar_pane_exif_list();
while (exif_list)
{
- title = exif_list->data;
+ title = static_cast<gchar *>(exif_list->data);
exif_list = exif_list->next;
- key = exif_list->data;
+ key = static_cast<gchar *>(exif_list->data);
exif_list = exif_list->next;
text = metadata_read_string(fd, key, METADATA_FORMATTED);
{
PanWindow *pw;
FileData *fd;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- pw = submenu_item_get_data(widget);
+ pw = static_cast<PanWindow *>(submenu_item_get_data(widget));
if (!pw) return;
fd = pan_menu_click_fd(pw);
PanWindow *pw;
GList *selection_list = NULL;
- pw = submenu_item_get_data(widget);
+ pw = static_cast<PanWindow *>(submenu_item_get_data(widget));
selection_list = g_list_append(selection_list, pan_menu_click_fd(pw));
pop_menu_collections(selection_list, data);
list = uri_filelist_from_gtk_selection_data(selection_data);
if (list && isdir(((FileData *)list->data)->path))
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
pan_layout_set_fd(pw, fd);
}
{
GObjectClass *gobject_class = G_OBJECT_CLASS(renderer_class);
- parent_class = g_type_class_peek_parent(renderer_class);
+ parent_class = static_cast<GtkEventBoxClass *>(g_type_class_peek_parent(renderer_class));
gobject_class->set_property = pixbuf_renderer_set_property;
gobject_class->get_property = pixbuf_renderer_get_property;
{
SourceTile *st;
- st = work->data;
+ st = static_cast<SourceTile *>(work->data);
work = work->next;
pr_source_tile_free(st);
{
SourceTile *needle;
- needle = work->data;
+ needle = static_cast<SourceTile *>(work->data);
work = work->prev;
if (!pr_source_tile_visible(pr, needle))
SourceTile *st;
gint rx, ry, rw, rh;
- st = work->data;
+ st = static_cast<SourceTile *>(work->data);
work = work->next;
if (pr_clip_region(st->x, st->y, pr->source_tile_width, pr->source_tile_height,
gint h;
gint page_number;
- lw = layout_window_list->data;
+ lw = static_cast<LayoutWindow *>(layout_window_list->data);
window = gtk_widget_get_window(widget);
gdk_window_get_root_origin(window, &x, &y);
static void quality_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
static void dnd_default_action_selection_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
}
static void clipboard_selection_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
static void zoom_style_selection_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
static void mouse_buttons_selection_menu_cb(GtkWidget *combo, gpointer data)
{
- gchar **option = data;
+ gchar **option = static_cast<gchar **>(data);
gchar *label;
label = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
static void stereo_mode_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
static void video_menu_cb(GtkWidget *combo, gpointer data)
{
- gchar **option = data;
+ gchar **option = static_cast<gchar **>(data);
- EditorDescription *ed = g_list_nth_data(editor_list_get(), gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
+ EditorDescription *ed = static_cast<EditorDescription *>(g_list_nth_data(editor_list_get(), gtk_combo_box_get_active(GTK_COMBO_BOX(combo))));
*option = ed->key;
}
static void video_menu_populate(gpointer data, gpointer user_data)
{
- GtkWidget *combo = user_data;
+ GtkWidget *combo = static_cast<GtkWidget *>(user_data);
EditorDescription *ed = static_cast<EditorDescription *>(data);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ed->name);
FilterEntry *fe;
GtkTreeIter iter;
- fe = work->data;
+ fe = static_cast<FilterEntry *>(work->data);
work = work->next;
gtk_list_store_append(filter_store, &iter);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(data), 0);
list_cells = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
- cell = g_list_last(list_cells)->data;
+ cell = static_cast<GtkCellRenderer *>(g_list_last(list_cells)->data);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(data));
valid = gtk_tree_model_get_iter_first(store, &iter);
if (!accel_store || !layout_window_list || !layout_window_list->data) return;
gtk_tree_store_clear(accel_store);
- lw = layout_window_list->data; /* get the actions from the first window, it should not matter, they should be the same in all windows */
+ lw = static_cast<LayoutWindow *>(layout_window_list->data); /* get the actions from the first window, it should not matter, they should be the same in all windows */
g_assert(lw && lw->ui_manager);
groups = gtk_ui_manager_get_action_groups(lw->ui_manager);
static gboolean accel_remove_key_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer data)
{
- gchar *accel1 = data;
+ gchar *accel1 = static_cast<gchar *>(data);
gchar *accel2;
GtkAccelKey key1;
GtkAccelKey key2;
list = gtk_container_get_children(hbox);
- hex_code_entry = g_list_nth_data(list, 2);
+ hex_code_entry = static_cast<GtkEntry *>(g_list_nth_data(list, 2));
hex_code_full = g_strdup(gtk_entry_get_text(hex_code_entry));
hex_code = g_strsplit(hex_code_full, "+", 2);
{
FileData *fd;
- fd = kfd->list->data;
+ fd = static_cast<FileData *>(kfd->list->data);
kfd->list = g_list_remove(kfd->list, fd);
keywords = metadata_read_list(fd, KEYWORD_KEY, METADATA_PLAIN);
{
FileData *fd;
- fd = kfd->list_dir->data;
+ fd = static_cast<FileData *>(kfd->list_dir->data);
kfd->list_dir = g_list_remove(kfd->list_dir, fd);
keywords_find_folder(kfd, fd);
#ifdef HAVE_LCMS
static void intent_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = data;
+ gint *option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
GtkWidget *toolbardata;
LayoutWindow *lw;
- lw = layout_window_list->data;
+ lw = static_cast<LayoutWindow *>(layout_window_list->data);
vbox = scrolled_notebook_page(notebook, _("Toolbar Main"));
GtkWidget *toolbardata;
LayoutWindow *lw;
- lw = layout_window_list->data;
+ lw = static_cast<LayoutWindow *>(layout_window_list->data);
vbox = scrolled_notebook_page(notebook, _("Toolbar Status"));
while (formats_list)
{
- fm = formats_list->data;
+ fm = static_cast<GdkPixbufFormat *>(formats_list->data);
extensions = gdk_pixbuf_format_get_extensions(fm);
i = 0;
{
if (types_string->len == 0)
{
- types_string = g_string_append(types_string, extensions_list->data);
+ types_string = g_string_append(types_string, static_cast<const gchar *>(extensions_list->data));
}
else
{
types_string = g_string_append(types_string, ", ");
- types_string = g_string_append(types_string, extensions_list->data);
+ types_string = g_string_append(types_string, static_cast<const gchar *>(extensions_list->data));
}
extensions_list = extensions_list->next;
{
FileData *fd = NULL;
- fd = g_list_nth_data(pw->source_selection, pw->job_page);
+ fd = static_cast<FileData *>(g_list_nth_data(pw->source_selection, pw->job_page));
if (!fd) return FALSE;
image_loader_free(pw->job_loader);
char *font;
PangoFontDescription *font_desc;
- dialog = gtk_font_chooser_dialog_new(data, GTK_WINDOW(gtk_widget_get_toplevel(widget)));
+ dialog = gtk_font_chooser_dialog_new(static_cast<const gchar *>(data), GTK_WINDOW(gtk_widget_get_toplevel(widget)));
gtk_font_chooser_set_font(GTK_FONT_CHOOSER(dialog), option);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
GtkToggleButton *new_sel;
gint new_pos = - 1;
- current_sel = g_slist_nth(list, pos)->data;
+ current_sel = static_cast<GtkToggleButton *>(g_slist_nth(list, pos)->data);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(current_sel)))
{
new_pos = (pos - 1);
{
new_pos = HEADER_1;
}
- new_sel = g_slist_nth(list, new_pos)->data;
+ new_sel = static_cast<GtkToggleButton *>(g_slist_nth(list, new_pos)->data);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(new_sel), TRUE);
}
return new_pos;
gchar *tmp;
gint total;
- fd = g_list_nth_data(pw->source_selection, page_nr);
+ fd = static_cast<FileData *>(g_list_nth_data(pw->source_selection, page_nr));
total = g_list_length(pw->source_selection);
- pixbuf = g_list_nth_data(pw->print_pixbuf_queue, page_nr);
+ pixbuf = static_cast<GdkPixbuf *>(g_list_nth_data(pw->print_pixbuf_queue, page_nr));
if (fd->exif_orientation != EXIF_ORIENTATION_TOP_LEFT)
{
rotated = pixbuf_apply_orientation(pixbuf, fd->exif_orientation);
GtkPrintContext *UNUSED(context),
gpointer user_data)
{
- PrintWindow *pw = user_data;
+ PrintWindow *pw = static_cast<PrintWindow *>(user_data);
gint page_count;
page_count = print_layout_page_count(pw);
GObject *option_tab_cb(GtkPrintOperation *UNUSED(operation), gpointer user_data)
{
- PrintWindow *pw = user_data;
+ PrintWindow *pw = static_cast<PrintWindow *>(user_data);
return G_OBJECT(pw->vbox);
}
work = pw->print_pixbuf_queue;
while (work)
{
- pixbuf = work->data;
+ pixbuf = static_cast<GdkPixbuf *>(work->data);
if (pixbuf)
{
g_object_unref(pixbuf);
void options_parse_func_set_data(GQParserData *parser_data, gpointer data)
{
- GQParserFuncData *func = parser_data->parse_func_stack->data;
+ GQParserFuncData *func = static_cast<GQParserFuncData *>(parser_data->parse_func_stack->data);
func->data = data;
}
gpointer user_data,
GError **error)
{
- GQParserData *parser_data = user_data;
- GQParserFuncData *func = parser_data->parse_func_stack->data;
+ GQParserData *parser_data = static_cast<GQParserData *>(user_data);
+ GQParserFuncData *func = static_cast<GQParserFuncData *>(parser_data->parse_func_stack->data);
DEBUG_2("start %s", element_name);
if (func->start_func)
gpointer user_data,
GError **error)
{
- GQParserData *parser_data = user_data;
- GQParserFuncData *func = parser_data->parse_func_stack->data;
+ GQParserData *parser_data = static_cast<GQParserData *>(user_data);
+ GQParserFuncData *func = static_cast<GQParserFuncData *>(parser_data->parse_func_stack->data);
DEBUG_2("end %s", element_name);
if (func->end_func)
{
while (rc->clients)
{
- RemoteClient *client = rc->clients->data;
+ RemoteClient *client = static_cast<RemoteClient *>(rc->clients->data);
rc->clients = g_list_remove(rc->clients, client);
work = list;
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
g_string_append_printf(out_string, "%s", fd->path);
format_class = filter_file_get_class(fd->path);
for (GList *sidecar = fd->sidecar_files; sidecar && !fd_to_select; sidecar = sidecar->next)
{
- FileData *side_fd = sidecar->data;
+ FileData *side_fd = static_cast<FileData *>(sidecar->data);
if (!strcmp(path, side_fd->path)
|| g_str_has_suffix(side_fd->path, slash_plus_filename))
{
work = collection_list;
while (work)
{
- const gchar *collection_name = work->data;
+ const gchar *collection_name = static_cast<const gchar *>(work->data);
out_string = g_string_append(out_string, g_strdup(collection_name));
out_string = g_string_append(out_string, "\n");
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
g_io_channel_write_chars(channel, fd->path, -1, NULL, NULL);
g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
gchar *text;
RemoteCommandEntry *entry;
- text = work->data;
+ text = static_cast<gchar *>(work->data);
work = work->next;
entry = remote_command_find(text, NULL);
gchar *text;
RemoteCommandEntry *entry;
- text = work->data;
+ text = static_cast<gchar *>(work->data);
work = work->next;
entry = remote_command_find(text, NULL);
const gchar *name;
gchar *text;
- name = work->data;
+ name = static_cast<const gchar *>(work->data);
work = work->next;
text = g_strdup_printf("file:%s", name);
{
ImageTile *it;
- it = work->data;
+ it = static_cast<ImageTile *>(work->data);
work = work->next;
rt_tile_free(it);
{
ImageTile *needle;
- needle = work->data;
+ needle = static_cast<ImageTile *>(work->data);
work = work->prev;
if (needle != it &&
((!needle->qd && !needle->qd2) || !rt_tile_is_visible(rt, needle))) rt_tile_remove(rt, needle);
{
ImageTile *it;
- it = work->data;
+ it = static_cast<ImageTile *>(work->data);
work = work->next;
it->render_done = TILE_RENDER_NONE;
{
ImageTile *it;
- it = work->data;
+ it = static_cast<ImageTile *>(work->data);
work = work->next;
if (it->x < x2 && it->x + it->w > x1 &&
{
ImageTile *it;
- it = work->data;
+ it = static_cast<ImageTile *>(work->data);
if (it->x == x && it->y == y)
{
rt->tiles = g_list_delete_link(rt->tiles, work);
gint px, py, pw, ph;
gint rx, ry, rw, rh;
- od = work->data;
+ od = static_cast<OverlayData *>(work->data);
work = work->next;
if (!od->window) rt_overlay_init_window(rt, od);
{
OverlayData *od;
- od = rt->overlay_list->data;
+ od = static_cast<OverlayData *>(rt->overlay_list->data);
rt_overlay_free(rt, od);
}
}
SourceTile *st;
gint rx, ry, rw, rh;
- st = work->data;
+ st = static_cast<SourceTile *>(work->data);
work = work->next;
if (pr_clip_region(st->x, st->y, pr->source_tile_width, pr->source_tile_height,
gint rx, ry, rw, rh;
gint stx, sty, stw, sth;
- st = work->data;
+ st = static_cast<SourceTile *>(work->data);
work = work->next;
stx = floor((gdouble)st->x * scale_x);
if (rt->draw_queue)
{
- qd = rt->draw_queue->data;
+ qd = static_cast<QueueData *>(rt->draw_queue->data);
fast = (pr->zoom_2pass && ((pr->zoom_quality != GDK_INTERP_NEAREST && pr->scale != 1.0) || pr->post_process_slow));
}
else
return rt_queue_schedule_next_draw(rt, FALSE);
}
- qd = rt->draw_queue_2pass->data;
+ qd = static_cast<QueueData *>(rt->draw_queue_2pass->data);
fast = FALSE;
}
{
QueueData *qd;
- qd = work->data;
+ qd = static_cast<QueueData *>(work->data);
work = work->next;
qd->it->qd = NULL;
work = rt->overlay_list;
while (work)
{
- od = work->data;
+ od = static_cast<OverlayData *>(work->data);
gint px, py, pw, ph;
pw = gdk_pixbuf_get_width(od->pixbuf);
ph = gdk_pixbuf_get_height(od->pixbuf);
list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
if (!list) return;
- cell = list->data;
+ cell = static_cast<GtkCellRenderer *>(list->data);
g_list_free(list);
g_object_set(G_OBJECT(cell), "height", (sd->thumb_enable) ? options->thumbnails.max_height : -1, NULL);
static void sr_menu_edit_cb(GtkWidget *widget, gpointer data)
{
SearchData *sd;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- sd = submenu_item_get_data(widget);
+ sd = static_cast<SearchData *>(submenu_item_get_data(widget));
if (!sd) return;
search_result_edit_selected(sd, key);
SearchData *sd;
GList *selection_list;
- sd = submenu_item_get_data(widget);
+ sd = static_cast<SearchData *>(submenu_item_get_data(widget));
selection_list = search_result_selection_list(sd);
pop_menu_collections(selection_list, data);
GList *last;
last = g_list_last(slist);
- tpath = last->data;
+ tpath = static_cast<GtkTreePath *>(last->data);
/* last is newest selected file */
gtk_tree_model_get_iter(store, &iter, tpath);
*/
if (list != NULL)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);
longitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLongitude", 1000);
if (latitude != 1000 && longitude != 1000)
*/
if (list != NULL)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
gtk_entry_set_text(GTK_ENTRY(sd->path_entry),
g_strdup_printf("%s", fd->path));
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->path_entry),g_strdup_printf("%s", fd->path));
*/
if (list != NULL)
{
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
gtk_entry_set_text(GTK_ENTRY(sd->entry_similarity),
g_strdup_printf("%s", fd->path));
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->entry_similarity),g_strdup_printf("%s", fd->path));
sd->search_total++;
}
- fd = sd->search_file_list->data;
+ fd = static_cast<FileData *>(sd->search_file_list->data);
if (match && sd->match_name_enable && sd->search_name)
{
return FALSE;
}
- fd = sd->search_folder_list->data;
+ fd = static_cast<FileData *>(sd->search_folder_list->data);
if (g_list_find(sd->search_done_list, fd) == NULL)
{
GList *link;
gchar *meta_path;
- fdp = work->data;
+ fdp = static_cast<FileData *>(work->data);
link = work;
work = work->next;
static void menu_choice_spin_cb(GtkAdjustment *adjustment, gpointer data)
{
- gint *value = data;
+ gint *value = static_cast<gint *>(data);
*value = (gint)gtk_adjustment_get_value(adjustment);
}
active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
gtk_widget_set_sensitive(widget, active);
- value = g_object_get_data(G_OBJECT(button), "check_var");
+ value = static_cast<gboolean *>(g_object_get_data(G_OBJECT(button), "check_var"));
if (value) *value = active;
}
static gint image_sim_channel_eq_sort_cb(gconstpointer a, gconstpointer b)
{
- gint *pa = (gpointer)a;
- gint *pb = (gpointer)b;
+ gint *pa = static_cast<gint *>((gpointer)a);
+ gint *pb = static_cast<gint *>((gpointer)b);
if (pa[1] < pb[1]) return -1;
if (pa[1] > pb[1]) return 1;
return 0;
{
CollectInfo *info;
- info = g_list_nth_data(ss->cd->list, row);
+ info = static_cast<CollectInfo *>(g_list_nth_data(ss->cd->list, row));
ss->slide_fd = file_data_ref(info->fd);
if (ss->lw)
else if (ss->cd)
{
CollectInfo *info;
- info = g_list_nth_data(ss->cd->list, r);
+ info = static_cast<CollectInfo *>(g_list_nth_data(ss->cd->list, r));
if (info) image_prebuffer_set(ss->imd, info->fd);
}
else if (ss->from_selection)
if (!tl) return;
- tv = tl->data;
+ tv = static_cast<ThumbValidate *>(tl->data);
if (tv->idle_id)
{
if (!thumb_std_maint_move_list) return FALSE;
- tm = thumb_std_maint_move_list->data;
+ tm = static_cast<TMaintMove *>(thumb_std_maint_move_list->data);
thumb_std_maint_move_list = g_list_remove(thumb_std_maint_move_list, tm);
if (!thumb_std_maint_move_list) thumb_std_maint_move_tail = NULL;
static void toolbarlist_add_cb(GtkWidget *widget, gpointer data)
{
- const gchar *name = g_object_get_data(G_OBJECT(widget), "toolbar_add_name");
- const gchar *label = g_object_get_data(G_OBJECT(widget), "toolbar_add_label");
- const gchar *stock_id = g_object_get_data(G_OBJECT(widget), "toolbar_add_stock_id");
+ const gchar *name = static_cast<const gchar *>(g_object_get_data(G_OBJECT(widget), "toolbar_add_name"));
+ const gchar *label = static_cast<const gchar *>(g_object_get_data(G_OBJECT(widget), "toolbar_add_label"));
+ const gchar *stock_id = static_cast<const gchar *>(g_object_get_data(G_OBJECT(widget), "toolbar_add_stock_id"));
ToolbarData *tbbd = static_cast<ToolbarData *>(data);
toolbarlist_add_button(name, label, stock_id, GTK_BOX(tbbd->vbox));
work_windows = layout_window_list;
while (work_windows)
{
- lw = work_windows->data;
+ lw = static_cast<LayoutWindow *>(work_windows->data);
layout_toolbar_clear(lw, bar);
work_toolbar = gtk_container_get_children(GTK_CONTAINER(toolbarlist[bar]->vbox));
while (work_toolbar)
{
- GtkButton *button = work_toolbar->data;
+ GtkButton *button = static_cast<GtkButton *>(work_toolbar->data);
ToolbarButtonData *tbbd;
- tbbd = g_object_get_data(G_OBJECT(button),"toolbarbuttondata");
+ tbbd = static_cast<ToolbarButtonData *>(g_object_get_data(G_OBJECT(button),"toolbarbuttondata"));
layout_toolbar_add(lw, bar, tbbd->name);
work_toolbar = work_toolbar->next;
while (work)
{
- gchar *name = work->data;
+ gchar *name = static_cast<gchar *>(work->data);
gchar *label;
gchar *icon;
work = work->next;
FileData *fd;
gint v;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
v = (gint)strtol(fd->name, NULL, 10);
sorted = TRUE;
}
- fd = list->data;
+ fd = static_cast<FileData *>(list->data);
list = g_list_remove(list, fd);
DEBUG_1("expunging from trash for space: %s", fd->name);
BookMarkData *bm = static_cast<BookMarkData *>(data);
BookButtonData *b;
- b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
+ b = static_cast<BookButtonData *>(g_object_get_data(G_OBJECT(button), "bookbuttondata"));
if (!b) return;
if (bm->select_func) bm->select_func(b->path, bm->select_data);
if (!bm->editable) return;
- b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
+ b = static_cast<BookButtonData *>(g_object_get_data(G_OBJECT(button), "bookbuttondata"));
if (!b) return;
list = gtk_container_get_children(GTK_CONTAINER(bm->box));
GtkWidget *menu;
BookButtonData *b;
- b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
+ b = static_cast<BookButtonData *>(g_object_get_data(G_OBJECT(button), "bookbuttondata"));
if (!b) return;
bm->active_button = b;
return;
if (gdk_drag_context_get_dest_window(context) == gtk_widget_get_window(bm->widget)) return;
- b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
+ b = static_cast<BookButtonData *>(g_object_get_data(G_OBJECT(button), "bookbuttondata"));
if (!b) return;
list = g_list_append(list, b->path);
{
BookButtonData *b;
- b = g_object_get_data(G_OBJECT(button), "bookbuttondata");
+ b = static_cast<BookButtonData *>(g_object_get_data(G_OBJECT(button), "bookbuttondata"));
gtk_widget_set_tooltip_text(GTK_WIDGET(button), b->path);
return FALSE;
{
gchar *name;
- name = work->data;
+ name = static_cast<gchar *>(work->data);
work = work->next;
- path = work->data;
+ path = static_cast<gchar *>(work->data);
work = work->next;
if (strcmp(name, ".") == 0)
{
BookButtonData *b;
- b = bookmark_from_string(work->data);
+ b = bookmark_from_string(static_cast<const gchar *>(work->data));
if (b)
{
if (strcmp(b->name, ".") == 0)
{
BookMarkData *bm;
- bm = work->data;
+ bm = static_cast<BookMarkData *>(work->data);
work = work->next;
if (strcmp(bm->key, key) == 0)
work = list;
while (work)
{
- gchar *path = work->data;
+ gchar *path = static_cast<gchar *>(work->data);
gchar *buf;
work = work->next;
if (!list || !key) return;
- bm = g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY);
+ bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
if (bm->key && strcmp(bm->key, key) == 0) return;
{
BookMarkData *bm;
- bm = g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY);
+ bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
bm->no_defaults = no_defaults;
{
BookMarkData *bm;
- bm = g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY);
+ bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
bm->editable = editable;
{
BookMarkData *bm;
- bm = g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY);
+ bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
bm->only_directories = only_directories;
BookMarkData *bm;
gchar *buf;
- bm = g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY);
+ bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
buf = bookmark_string(name, path, NULL);
HistoryComboData *hc;
gchar *new_text;
- hc = g_object_get_data(G_OBJECT(widget), "history_combo_data");
+ hc = static_cast<HistoryComboData *>(g_object_get_data(G_OBJECT(widget), "history_combo_data"));
if (!hc)
{
log_printf("widget is not a history combo\n");
gchar *link_target;
ssize_t i;
- link_target = g_malloc(st.st_size + 1);
+ link_target = static_cast<gchar *>(g_malloc(st.st_size + 1));
i = readlink(sl, link_target, st.st_size);
if (i<0)
{
gchar *lastslash = strrchr(sl, G_DIR_SEPARATOR);
gint len = lastslash - sl + 1;
- absolute = g_malloc(len + st.st_size + 1);
+ absolute = static_cast<gchar *>(g_malloc(len + st.st_size + 1));
strncpy(absolute, sl, len);
strcpy(absolute + len, link_target);
g_free(link_target);
{
gchar *path;
- path = work->data;
+ path = static_cast<gchar *>(work->data);
work = work->next;
new_list = g_list_prepend(new_list, g_strdup(path));
if (!window) return;
- text = g_object_get_data(G_OBJECT(window), "text_widget");
+ text = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(window), "text_widget"));
if (!text) return;
gdk_window_raise(gtk_widget_get_window(window));
pango_parse_markup(menu_label, -1, '_', NULL, &menu_label_text, NULL, NULL);
- lw = layout_window_list->data; /* get the actions from the first window, it should not matter, they should be the same in all windows */
+ lw = static_cast<LayoutWindow *>(layout_window_list->data); /* get the actions from the first window, it should not matter, they should be the same in all windows */
g_assert(lw && lw->ui_manager);
groups = gtk_ui_manager_get_action_groups(lw->ui_manager);
hard_coded_window_keys *window_keys;
item = gtk_menu_item_new_with_mnemonic(label);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
if (accel_group && window_keys)
{
hard_coded_window_keys *window_keys;
item = gtk_image_menu_item_new_with_mnemonic(label);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
item = menu_item_add(menu, label, func, data);
gtk_widget_set_sensitive(item, sensitive);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
if (accel_group && window_keys)
{
menu_item_add_accelerator(item, accel_group, window_keys);
item = menu_item_add_stock(menu, label, stock_id, func, data);
gtk_widget_set_sensitive(item, sensitive);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
if (accel_group && window_keys)
{
menu_item_add_accelerator(item, accel_group, window_keys);
hard_coded_window_keys *window_keys;
item = gtk_check_menu_item_new_with_mnemonic(label);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
if (accel_group && window_keys)
{
g_object_set_data(G_OBJECT(item), "menu_item_radio_data", item_data);
g_object_set(G_OBJECT(item), "draw-as-radio", TRUE, NULL);
- window_keys = g_object_get_data(G_OBJECT(menu), "window_keys");
- accel_group = g_object_get_data(G_OBJECT(menu), "accel_group");
+ window_keys = static_cast<hard_coded_window_keys *>(g_object_get_data(G_OBJECT(menu), "window_keys"));
+ accel_group = static_cast<GtkAccelGroup *>(g_object_get_data(G_OBJECT(menu), "accel_group"));
if (accel_group && window_keys)
{
menu_item_add_accelerator(item, accel_group, window_keys);
{
GtkWidget *group;
- group = g_object_get_data(G_OBJECT(parent), "pref_group");
+ group = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(parent), "pref_group"));
if (group && GTK_IS_WIDGET(group)) return group;
parent = gtk_widget_get_parent(parent);
static void pref_checkbox_int_cb(GtkWidget *widget, gpointer data)
{
- gboolean *result = data;
+ gboolean *result = static_cast<gboolean *>(data);
*result = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}
static void pref_radiobutton_int_cb(GtkWidget *widget, gpointer data)
{
- gboolean *result = data;
+ gboolean *result = static_cast<gboolean *>(data);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
static void pref_spin_int_cb(GtkWidget *widget, gpointer data)
{
- gint *var = data;
+ gint *var = static_cast<gint *>(data);
*var = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
}
{
DateSelection *ds;
- ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
+ 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);
{
DateSelection *ds;
- ds = g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY);
+ ds = static_cast<DateSelection *>(g_object_get_data(G_OBJECT(widget), DATE_SELECION_KEY));
if (!ds) return;
if (day) *day = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ds->spin_d));
work = history_list_get_by_key(group);
while (work)
{
- const gchar *text = work->data;
+ const gchar *text = static_cast<const gchar *>(work->data);
if (strncmp(text, token, l) == 0) return work;
work = pref_list_find(group, token);
if (work)
{
- gchar *old_path = work->data;
+ gchar *old_path = static_cast<gchar *>(work->data);
if (text)
{
{
GtkTreeIter iter;
gchar *filepath;
- const gchar *name = list->data;
+ const gchar *name = static_cast<const gchar *>(list->data);
filepath = g_build_filename(path, name, NULL);
gchar *name;
gchar *filter;
- name = twork->data;
- filter = fwork->data;
+ name = static_cast<gchar *>(twork->data);
+ filter = static_cast<gchar *>(fwork->data);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, FILTER_COLUMN_NAME, name,
work = dd->filter_list;
while (work)
{
- gchar *f = work->data;
+ gchar *f = static_cast<gchar *>(work->data);
if (strcmp(f, filter) == 0)
{
void path_selection_add_select_func(GtkWidget *entry,
void (*func)(const gchar *, gpointer), gpointer data)
{
- Dest_Data *dd = g_object_get_data(G_OBJECT(entry), "destination_data");
+ Dest_Data *dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
if (!dd) return;
void path_selection_add_filter(GtkWidget *entry, const gchar *filter, const gchar *description, gboolean set)
{
- Dest_Data *dd = g_object_get_data(G_OBJECT(entry), "destination_data");
+ Dest_Data *dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
if (!dd) return;
if (!filter) return;
void path_selection_clear_filter(GtkWidget *entry)
{
- Dest_Data *dd = g_object_get_data(G_OBJECT(entry), "destination_data");
+ Dest_Data *dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
if (!dd) return;
{
GdkPixbuf *pb;
- pb = g_list_nth_data(sp->list, frame);
+ pb = static_cast<GdkPixbuf *>(g_list_nth_data(sp->list, frame));
if (pb) gtk_image_set_from_pixbuf(GTK_IMAGE(sp->image), pb);
sp->frame = frame;
{
GdkPixbuf *pb;
- pb = sp->list->data;
+ pb = static_cast<GdkPixbuf *>(sp->list->data);
sp->image = gtk_image_new_from_pixbuf(pb);
}
else
{
SpinnerData *sp;
- sp = g_object_get_data(G_OBJECT(spinner), "spinner");
+ sp = static_cast<SpinnerData *>(g_object_get_data(G_OBJECT(spinner), "spinner"));
spinner_set_timeout(sp, interval);
}
static void tab_completion_popup_cb(GtkWidget *widget, gpointer data)
{
- gchar *name = data;
+ gchar *name = static_cast<gchar *>(data);
TabCompData *td;
gchar *buf;
- td = g_object_get_data(G_OBJECT(widget), "tab_completion_data");
+ td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(widget), "tab_completion_data"));
if (!td) return;
buf = g_build_filename(td->dir_path, name, NULL);
work = list;
while (work && count < TAB_COMP_POPUP_MAX)
{
- gchar *name = work->data;
+ gchar *name = static_cast<gchar *>(work->data);
GtkWidget *item;
item = menu_item_add_simple(menu, name, G_CALLBACK(tab_completion_popup_cb), name);
gchar *buf;
const gchar *file;
- file = td->file_list->data;
+ file = static_cast<const gchar *>(td->file_list->data);
buf = g_build_filename(entry_dir, file, NULL);
if (isdir(buf))
{
list = td->file_list;
while (list)
{
- gchar *file = list->data;
+ gchar *file = static_cast<gchar *>(list->data);
if (strncmp(entry_file, file, l) == 0)
{
poss = g_list_prepend(poss, file);
{
if (!poss->next)
{
- gchar *file = poss->data;
+ gchar *file = static_cast<gchar *>(poss->data);
gchar *buf;
buf = g_build_filename(entry_dir, file, NULL);
{
gsize c = strlen(entry_file);
gboolean done = FALSE;
- gchar *test_file = poss->data;
+ gchar *test_file = static_cast<gchar *>(poss->data);
while (!done)
{
if (!list) done = TRUE;
while (list && !done)
{
- gchar *file = list->data;
+ gchar *file = static_cast<gchar *>(list->data);
if (strlen(file) < c || strncmp(test_file, file, c) != 0)
{
done = TRUE;
TabCompData *td;
GtkWidget *entry = static_cast<GtkWidget *>(data);
- td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
if (!td) return;
tab_completion_add_to_entry(combo_entry, enter_func, NULL, NULL, data);
- td = g_object_get_data(G_OBJECT(combo_entry), "tab_completion_data");
+ td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(combo_entry), "tab_completion_data"));
if (!td) return NULL; /* this should never happen! */
td->combo = combo;
const gchar *tab_completion_set_to_last_history(GtkWidget *entry)
{
- TabCompData *td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ TabCompData *td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
const gchar *buf;
if (!td || !td->has_history) return NULL;
GList *work;
gint n = 0;
- td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
if (!path) return;
void tab_completion_add_tab_func(GtkWidget *entry, void (*tab_func)(const gchar *, gpointer), gpointer data)
{
- TabCompData *td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ TabCompData *td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
if (!td) return;
/* Add a callback function called when a new entry is appended to the list */
void tab_completion_add_append_func(GtkWidget *entry, void (*tab_append_func)(const gchar *, gpointer, gint), gpointer data)
{
- TabCompData *td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ TabCompData *td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
if (!td) return;
GtkWidget *parent;
GtkWidget *hbox;
- td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
+ td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
if (!td) return;
work = list;
while (work && !cell)
{
- cell = work->data;
+ cell = static_cast<GtkCellRenderer *>(work->data);
if (!GTK_IS_CELL_RENDERER_TEXT(cell))
{
cell = NULL;
work = renderers;
while (work && !cell)
{
- cell = work->data;
+ cell = static_cast<GtkCellRenderer *>(work->data);
work = work->next;
if (!GTK_IS_CELL_RENDERER_TEXT(cell)) cell = NULL;
}
{
AutoScrollData *sd;
- sd = g_object_get_data(G_OBJECT(widget), "autoscroll");
+ sd = static_cast<AutoScrollData *>(g_object_get_data(G_OBJECT(widget), "autoscroll"));
if (!sd) return;
g_object_set_data(G_OBJECT(widget), "autoscroll", NULL);
work = list;
while (work)
{
- const gchar *path = work->data;
+ const gchar *path = static_cast<const gchar *>(work->data);
gchar *local_path = path_from_utf8(path);
uris[i] = g_filename_to_uri(local_path, NULL, NULL);
g_free(local_path);
FileData *fd2 = NULL;
gchar *buf;
- imd = g_object_get_data(G_OBJECT(ud->gd->dialog), "img_image");
- label = g_object_get_data(G_OBJECT(ud->gd->dialog), "img_label");
+ imd = static_cast<ImageWindow *>(g_object_get_data(G_OBJECT(ud->gd->dialog), "img_image"));
+ label = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(ud->gd->dialog), "img_label"));
if (!imd) return;
if (ud->type == UTILITY_TYPE_RENAME || ud->type == UTILITY_TYPE_COPY || ud->type == UTILITY_TYPE_MOVE)
{
- imd = g_object_get_data(G_OBJECT(ud->gd->dialog), "img_image2");
- label = g_object_get_data(G_OBJECT(ud->gd->dialog), "img_label2");
+ imd = static_cast<ImageWindow *>(g_object_get_data(G_OBJECT(ud->gd->dialog), "img_image2"));
+ label = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(ud->gd->dialog), "img_label2"));
if (imd)
{
while (list)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
GtkTreeIter iter;
gchar *sidecars;
g_string_append(msg, "\n");
while (list)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
g_string_append(msg, fd->path);
g_string_append(msg, "\n");
while (list) /* be careful, file_util_perform_ci_internal can pass ud->flist as list */
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
list = list->next;
if (!EDITOR_ERRORS(flags)) /* files were successfully deleted, call the maint functions */
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!fail)
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (!fail)
static void file_util_details_dialog_exclude(GenericDialog *gd, gpointer data, gboolean discard)
{
UtilityData *ud = static_cast<UtilityData *>(data);
- FileData *fd = g_object_get_data(G_OBJECT(gd->dialog), "file_data");
+ FileData *fd = static_cast<FileData *>(g_object_get_data(G_OBJECT(gd->dialog), "file_data"));
if (!fd) return;
file_util_exclude_fd(ud, fd);
i = 0;
while (work)
{
- const gchar *key = work->data;
+ const gchar *key = static_cast<const gchar *>(work->data);
gchar *title = exif_get_description_by_key(key);
gchar *title_f = g_strdup_printf("%s:", title);
gchar *value = metadata_read_string(fd, key, METADATA_FORMATTED);
{
FileData *fd;
- fd = dlist->data;
+ fd = static_cast<FileData *>(dlist->data);
dlist = dlist->next;
if (!fd->name ||
{
FileData *lfd;
- lfd = work->data;
+ lfd = static_cast<FileData *>(work->data);
work = work->next;
ok = file_util_delete_dir_empty_path(ud, lfd, level);
{
FileData *lfd;
- lfd = work->data;
+ lfd = static_cast<FileData *>(work->data);
work = work->next;
DEBUG_1("deltree child: %s", lfd->path);
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
ok = file_util_delete_dir_empty_path(ud, fd, 0);
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
file_data_sc_free_ci(fd);
}
{
FileData *lfd;
- lfd = work->data;
+ lfd = static_cast<FileData *>(work->data);
work = work->next;
ud->content_list = g_list_prepend(ud->content_list, file_data_ref(lfd));
gchar *np;
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
g_assert(strncmp(fd->path, ud->dir_fd->path, orig_len) == 0);
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
file_data_sc_free_ci(fd);
}
{
FileData *fd;
- fd = g_list_nth_data(VDLIST(vd)->list, row);
+ fd = static_cast<FileData *>(g_list_nth_data(VDLIST(vd)->list, row));
if (fd) return fd->path;
const gchar *date = "";
gboolean done = FALSE;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
if (access_file(fd->path, R_OK | X_OK) && fd->name)
{
FileData *fd = NULL;
pd = g_new0(PathData, 1);
- pd->name = work->data;
+ pd->name = static_cast<gchar *>(work->data);
while (valid && !fd)
{
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
if (strcmp(fd->name, ".") == 0 || strcmp(fd->name, "..") == 0)
return NULL;
}
- parent_pd = work->prev->data;
+ parent_pd = static_cast<PathData *>(work->prev->data);
if (!vd_find_row(vd, parent_pd->node, &parent_iter) ||
!vdtree_populate_path_by_iter(vd, &parent_iter, force, target_fd) ||
if (!vd->drop_fd) return;
- key = g_object_get_data(G_OBJECT(widget), "filter_key");
+ key = static_cast<const gchar *>(g_object_get_data(G_OBJECT(widget), "filter_key"));
path = vd->drop_fd->path;
list = vd->drop_list;
ViewDir *vd;
SortType type;
- vd = submenu_item_get_data(widget);
+ vd = static_cast<ViewDir *>(submenu_item_get_data(widget));
if (!vd) return;
if (!vd->layout) return;
column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), "column_number"));
g_object_get(G_OBJECT(cell), "toggled_mark", &toggled_mark, NULL);
- fd = g_list_nth_data(list, column);
+ fd = static_cast<FileData *>(g_list_nth_data(list, column));
if (fd)
{
file_data_set_mark(fd, toggled_mark, !file_data_get_mark(fd, toggled_mark));
return;
}
- label = g_object_get_data(G_OBJECT(VFICON(vf)->tip_window), "tip_label");
+ label = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(VFICON(vf)->tip_window), "tip_label"));
gtk_label_set_text(GTK_LABEL(label), VFICON(vf)->tip_fd->name);
}
}
work2 = fd->sidecar_files;
while (work2)
{
- fd = work2->data;
+ fd = static_cast<FileData *>(work2->data);
list = g_list_prepend(list, file_data_ref(fd));
work2 = work2->next;
}
work = list;
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
if (g_list_find(vf->list, fd))
{
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
{
gint match;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
match = filelist_sort_compare_filedata_full(fd, sel_fd, vf->sort_method, vf->sort_ascend);
gtk_tree_path_free(tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
- if (list) visible_fd = list->data;
+ if (list) visible_fd = static_cast<FileData *>(list->data);
}
gtk_tree_view_column_set_fixed_width(column, thumb_width + (THUMB_BORDER_PADDING * 6));
list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
- cell = (list) ? list->data : NULL;
+ cell = static_cast<GtkCellRenderer *>((list) ? list->data : NULL);
g_list_free(list);
if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
if (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
c++;
}
/** @todo (xsdg): for loop here. */
for (; list; list = list->next)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
if (fd && !fd->thumb_pixbuf) return fd;
}
for (; list; list = list->next)
{
- FileData *fd = list->data;
+ FileData *fd = static_cast<FileData *>(list->data);
if (fd && fd->rating == STAR_RATING_NOT_READ)
{
vf->stars_filedata = fd;
if (VFICON(vf)->selection)
{
old_selected = g_list_copy(VFICON(vf)->selection);
- first_selected = VFICON(vf)->selection->data;
+ first_selected = static_cast<FileData *>(VFICON(vf)->selection->data);
file_data_ref(first_selected);
g_list_free(VFICON(vf)->selection);
VFICON(vf)->selection = NULL;
if (work && new_work)
{
- fd = work->data;
- new_fd = new_work->data;
+ fd = static_cast<FileData *>(work->data);
+ new_fd = static_cast<FileData *>(new_work->data);
if (fd == new_fd)
{
else if (work)
{
/* old item was deleted */
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
match = -1;
}
else
{
/* new item was added */
- new_fd = new_work->data;
+ new_fd = static_cast<FileData *>(new_work->data);
match = 1;
}
gtk_tree_model_get(tree_model, iter, FILE_COLUMN_POINTER, &list, -1);
- fd = g_list_nth_data(list, cd->number);
+ fd = static_cast<FileData *>(g_list_nth_data(list, cd->number));
if (fd)
{
filelist_read(vf->dir_fd, &files, NULL);
while (files)
{
- FileData *fd = files->data;
+ FileData *fd = static_cast<FileData *>(files->data);
files = files->next;
file_data_unlock(fd);
file_data_unref(fd); // undo the ref that got added in filelist_read
while (work2 && !fd)
{
- fd_p = work2->data;
+ fd_p = static_cast<FileData *>(work2->data);
if (!fd_p->thumb_pixbuf) fd = fd_p;
work2 = work2->next;
}
it is sufficient for next/prev navigation but it should be rewritten
without using indexes at all
*/
- FileData *sidecar_fd = work2->data;
+ FileData *sidecar_fd = static_cast<FileData *>(work2->data);
if (sidecar_fd == fd) return p;
work2 = work2->next;
}
GList *work2 = fd->sidecar_files;
while (work2)
{
- FileData *sfd = work2->data;
+ FileData *sfd = static_cast<FileData *>(work2->data);
list = g_list_prepend(list, file_data_ref(sfd));
work2 = work2->next;
}
{
FileData *fd;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
if (vflist_find_row(vf, fd, &iter) < 0) return;
if (!vflist_row_is_selected(vf, fd))
while (work)
{
gint match;
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
work = work->next;
match = filelist_sort_compare_filedata_full(fd, sel_fd, vf->sort_method, vf->sort_ascend);
list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
if (!list) return;
- cell = list->data;
+ cell = static_cast<GtkCellRenderer *>(list->data);
g_list_free(list);
g_object_set(G_OBJECT(cell), "height", options->thumbnails.max_height, NULL);
static void vf_pop_menu_edit_cb(GtkWidget *widget, gpointer data)
{
ViewFile *vf;
- const gchar *key = data;
+ const gchar *key = static_cast<const gchar *>(data);
- vf = submenu_item_get_data(widget);
+ vf = static_cast<ViewFile *>(submenu_item_get_data(widget));
if (!vf) return;
if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
- vf = submenu_item_get_data(widget);
+ vf = static_cast<ViewFile *>(submenu_item_get_data(widget));
if (!vf) return;
type = (SortType)GPOINTER_TO_INT(data);
ViewFile *vf;
GList *selection_list;
- vf = submenu_item_get_data(widget);
+ vf = static_cast<ViewFile *>(submenu_item_get_data(widget));
selection_list = vf_selection_get_list(vf);
pop_menu_collections(selection_list, data);
void vf_marks_filter_on_icon_press(GtkEntry *UNUSED(entry), GtkEntryIconPosition UNUSED(pos),
GdkEvent *UNUSED(event), gpointer userdata)
{
- MarksTextEntry *mte = userdata;
+ MarksTextEntry *mte = static_cast<MarksTextEntry *>(userdata);
g_free(mte->text_entry);
mte->text_entry = g_strdup("");
children = gtk_container_get_children(GTK_CONTAINER(parent));
while (children)
{
- child = children->data;
+ child = static_cast<GtkWidget *>(children->data);
if (i < FILE_FORMAT_CLASSES)
{
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(child), state);
while (work)
{
- fd = work->data;
+ fd = static_cast<FileData *>(work->data);
if (fd && !fd->metadata_in_idle_loaded)
{
static void help_search_window_show_icon_press(GtkEntry *UNUSED(entry), GtkEntryIconPosition UNUSED(pos),
GdkEvent *UNUSED(event), gpointer userdata)
{
- HelpSearchData *hsd = userdata;
+ HelpSearchData *hsd = static_cast<HelpSearchData *>(userdata);
g_free(hsd->text_entry);
hsd->text_entry = g_strdup("");
projects / geeqie.git / commitdiff