GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
GtkTreeIter iter;
- if (gtk_tree_selection_get_selected(sel, NULL, &iter))
+ if (gtk_tree_selection_get_selected(sel, nullptr, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
gchar *key;
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
GtkTreeIter iter;
- if (gtk_tree_selection_get_selected(sel, NULL, &iter))
+ if (gtk_tree_selection_get_selected(sel, nullptr, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
gchar *key;
static void advanced_exif_window_get_geometry(ExifWin *ew)
{
GdkWindow *window;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
ew = g_new0(ExifWin, 1);
- ew->window = window_new(GTK_WINDOW_TOPLEVEL, "view", NULL, NULL, _("Metadata"));
+ ew->window = window_new(GTK_WINDOW_TOPLEVEL, "view", nullptr, nullptr, _("Metadata"));
DEBUG_NAME(ew->window);
geometry.min_width = 900;
geometry.min_height = 600;
- gtk_window_set_geometry_hints(GTK_WINDOW(ew->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
+ gtk_window_set_geometry_hints(GTK_WINDOW(ew->window), nullptr, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(ew->window), TRUE);
sortable = GTK_TREE_SORTABLE(store);
for (n = EXIF_ADVCOL_DESCRIPTION; n <= EXIF_ADVCOL_ELEMENTS; n++)
gtk_tree_sortable_set_sort_func(sortable, n, advanced_exif_sort_cb,
- GINT_TO_POINTER(n), NULL);
+ GINT_TO_POINTER(n), nullptr);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(sortable, EXIF_ADVCOL_NAME, GTK_SORT_ASCENDING);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ew->listview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(ew->listview), EXIF_ADVCOL_DESCRIPTION);
- gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(ew->listview), search_function_cb, ew, NULL);
+ gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(ew->listview), search_function_cb, ew, nullptr);
gtk_drag_source_set(ew->listview,
static_cast<GdkModifierType>(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
g_signal_connect(G_OBJECT(ew->listview), "button_release_event",
G_CALLBACK(advanced_exif_mouseclick), ew);
- ew->scrolled = gtk_scrolled_window_new(NULL, NULL);
+ ew->scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(ew->scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ew->scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
static void bar_pane_comment_update(PaneCommentData *pcd)
{
- gchar *comment = NULL;
- gchar *orig_comment = NULL;
+ gchar *comment = nullptr;
+ gchar *orig_comment = nullptr;
const gchar *comment_not_null;
gshort rating;
GtkTextBuffer *comment_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pcd->comment_view));
g_free(comment);
g_free(orig_comment);
- gtk_widget_set_sensitive(pcd->comment_view, (pcd->fd != NULL));
+ gtk_widget_set_sensitive(pcd->comment_view, (pcd->fd != nullptr));
}
static void bar_pane_comment_set_selection(PaneCommentData *pcd, gboolean append)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
- gchar *comment = NULL;
+ gchar *comment = nullptr;
comment = text_widget_text_pull(pcd->comment_view);
list = layout_selection_list(pcd->pane.lw);
- list = file_data_process_groups_in_selection(list, FALSE, NULL);
+ list = file_data_process_groups_in_selection(list, FALSE, nullptr);
work = list;
while (work)
pcd->key = g_strdup(key);
pcd->height = height;
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
pcd->widget = scrolled;
g_object_set_data(G_OBJECT(pcd->widget), "pane_data", pcd);
GtkWidget *bar_pane_comment_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *title = NULL;
+ gchar *title = nullptr;
gchar *key = g_strdup(COMMENT_KEY);
gboolean expanded = TRUE;
gint height = 50;
pcd = static_cast<PaneCommentData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pcd) return;
- gchar *title = NULL;
+ gchar *title = nullptr;
while (*attribute_names)
{
gtk_container_add(GTK_CONTAINER(ee->ebox), ee->box);
gtk_widget_show(ee->box);
- ee->title_label = gtk_label_new(NULL);
+ ee->title_label = gtk_label_new(nullptr);
gtk_label_set_xalign(GTK_LABEL(ee->title_label), horizontal ? 1.0 : 0.0);
gtk_label_set_yalign(GTK_LABEL(ee->title_label), 0.5);
gtk_size_group_add_widget(ped->size_group, ee->title_label);
}
else
{
- ee->value_widget = gtk_label_new(NULL);
+ ee->value_widget = gtk_label_new(nullptr);
// gtk_label_set_width_chars(GTK_LABEL(ee->value_widget), 20);
gtk_label_set_ellipsize(GTK_LABEL(ee->value_widget), PANGO_ELLIPSIZE_END);
// gtk_widget_set_size_request(ee->value_widget, 100, -1);
if (!ped->show_all && ee->if_set && !ee->editable && (!text || !*text))
{
- gtk_label_set_text(GTK_LABEL(ee->value_widget), NULL);
+ gtk_label_set_text(GTK_LABEL(ee->value_widget), nullptr);
gtk_widget_hide(entry);
}
else
g_signal_handlers_block_by_func(ee->value_widget, (gpointer *)bar_pane_exif_entry_changed, ee);
gtk_entry_set_text(GTK_ENTRY(ee->value_widget), text ? text : "");
g_signal_handlers_unblock_by_func(ee->value_widget, (gpointer)bar_pane_exif_entry_changed, ee);
- gtk_widget_set_tooltip_text(ee->box, NULL);
+ gtk_widget_set_tooltip_text(ee->box, nullptr);
}
else
{
PaneExifData *ped;
GList *work, *list;
gint pos;
- GtkWidget *new_entry = NULL;
+ GtkWidget *new_entry = nullptr;
ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
break;
default:
/** @FIXME this needs a check for valid exif keys */
- new_entry = bar_pane_exif_add_entry(ped, reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)), NULL, TRUE, FALSE);
+ new_entry = bar_pane_exif_add_entry(ped, reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)), nullptr, TRUE, FALSE);
break;
}
g_signal_connect(G_OBJECT(widget), "destroy",
G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
- generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL, FALSE);
+ generic_dialog_add_message(gd, nullptr, ee ? _("Configure entry") : _("Add entry"), nullptr, FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr,
bar_pane_exif_edit_ok_cb, TRUE);
table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
PaneExifData *ped;
GList *list;
GList *work_windows;
- GList *exif_list = NULL;
+ GList *exif_list = nullptr;
LayoutWindow *lw;
GtkWidget *bar;
GtkWidget *pane;
GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *title = NULL;
+ gchar *title = nullptr;
gchar *id = g_strdup("exif");
gboolean expanded = TRUE;
gboolean show_all = FALSE;
void bar_pane_exif_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
{
PaneExifData *ped;
- gchar *title = NULL;
+ gchar *title = nullptr;
ped = static_cast<PaneExifData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!ped) return;
void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
{
PaneExifData *ped;
- gchar *key = NULL;
- gchar *title = NULL;
+ gchar *key = nullptr;
+ gchar *title = nullptr;
gboolean if_set = TRUE;
gboolean editable = FALSE;
static void bar_pane_histogram_update(PaneHistogramData *phd)
{
if (phd->pixbuf) g_object_unref(phd->pixbuf);
- phd->pixbuf = NULL;
+ phd->pixbuf = nullptr;
gtk_label_set_text(GTK_LABEL(phd->pane.title), histogram_label(phd->histogram));
{
if (!phd->idle_id)
{
- phd->idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, bar_pane_histogram_update_cb, phd, NULL);
+ phd->idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, bar_pane_histogram_update_cb, phd, nullptr);
}
}
else
gtk_widget_queue_draw_area(GTK_WIDGET(phd->drawing_area), 0, 0, phd->histogram_width, phd->histogram_height);
- if (phd->fd == NULL) return G_SOURCE_REMOVE;
+ if (phd->fd == nullptr) return G_SOURCE_REMOVE;
histmap = histmap_get(phd->fd);
if (!histmap)
GtkWidget *menu;
menu = bar_pane_histogram_menu(phd);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
return TRUE;
}
GtkWidget *bar_pane_histogram_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *title = NULL;
+ gchar *title = nullptr;
gchar *id = g_strdup("histogram");
gboolean expanded = TRUE;
gint height = 80;
static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
static void autocomplete_keywords_list_load(const gchar *path);
-static GtkListStore *keyword_store = NULL;
+static GtkListStore *keyword_store = nullptr;
static gboolean autocomplete_keywords_list_save(gchar *path);
static gboolean autocomplete_activate_cb(GtkWidget *widget, gpointer data);
static void bar_pane_keywords_update(PaneKeywordsData *pkd)
{
- GList *keywords = NULL;
- GList *orig_keywords = NULL;
+ GList *keywords = nullptr;
+ GList *orig_keywords = nullptr;
GList *work1, *work2;
GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
static void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
{
PaneKeywordsData *pkd;
- GList *path_expanded = NULL;
+ GList *path_expanded = nullptr;
gint w, h;
pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
{
- GList *keywords = NULL;
- GList *list = NULL;
+ GList *keywords = nullptr;
+ GList *list = nullptr;
GList *work;
keywords = keyword_list_pull_selected(pkd->keyword_view);
list = layout_selection_list(pkd->pane.lw);
- list = file_data_process_groups_in_selection(list, FALSE, NULL);
+ list = file_data_process_groups_in_selection(list, FALSE, nullptr);
work = list;
while (work)
if (pkd->idle_id) return;
/* higher prio than redraw */
- pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, NULL);
+ pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, nullptr);
}
}
src_name = keyword_get_name(keyword_tree, src_kw_iter);
- if (keyword_exists(keyword_tree, NULL, dest_kw_iter, src_name, FALSE, NULL))
+ if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, src_name, FALSE, nullptr))
{
g_free(src_name);
return FALSE;
while (work)
{
auto keyword = static_cast<gchar *>(work->data);
- if (keyword_exists(keyword_tree, NULL, dest_kw_iter, keyword, FALSE, NULL))
+ if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, keyword, FALSE, nullptr))
{
GList *next = work->next;
g_free(keyword);
guint UNUSED(time), gpointer data)
{
auto pkd = static_cast<PaneKeywordsData *>(data);
- GtkTreePath *tpath = NULL;
+ GtkTreePath *tpath = nullptr;
GtkTreeViewDropPosition pos;
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
gboolean src_valid = FALSE;
- GList *new_keywords = NULL;
+ GList *new_keywords = nullptr;
GList *work;
/* iterators for keyword_tree */
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
- gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), NULL, pos);
+ gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), nullptr, pos);
switch (info)
{
{
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
case GTK_TREE_VIEW_DROP_BEFORE:
- gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
+ gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
break;
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
case GTK_TREE_VIEW_DROP_AFTER:
- gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
+ gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
break;
}
}
}
else
{
- if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, NULL))
+ if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, nullptr))
{
/* the keyword can't be moved if the same name already exist */
return;
}
- if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, NULL, &new_keywords))
+ if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, nullptr, &new_keywords))
{
/* the keywords can't be added if the same name already exist */
return;
}
- gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL);
+ gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr);
}
if (work)
{
GtkTreeIter add;
- gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &new_kw_iter);
+ gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &new_kw_iter);
new_kw_iter = add;
}
}
static gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context,
gint x, gint y, guint time, gpointer UNUSED(data))
{
- GtkTreePath *tpath = NULL;
+ GtkTreePath *tpath = nullptr;
GtkTreeViewDropPosition pos;
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
if (tpath)
if (cdd->edit_existing)
{
if (keywords && keywords->data && /* there should be one keyword */
- !keyword_exists(keyword_tree, NULL, &kw_iter, static_cast<const gchar *>(keywords->data), TRUE, NULL))
+ !keyword_exists(keyword_tree, nullptr, &kw_iter, static_cast<const gchar *>(keywords->data), TRUE, nullptr))
{
keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, static_cast<const gchar *>(keywords->data), cdd->is_keyword);
}
while (work)
{
GtkTreeIter add;
- if (keyword_exists(keyword_tree, NULL, (have_dest || append_to) ? &kw_iter : NULL, static_cast<const gchar *>(work->data), FALSE, NULL))
+ if (keyword_exists(keyword_tree, nullptr, (have_dest || append_to) ? &kw_iter : nullptr, static_cast<const gchar *>(work->data), FALSE, nullptr))
{
work = work->next;
continue;
}
else if (append_to)
{
- gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &kw_iter);
+ gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &kw_iter);
}
else
{
- gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, NULL);
+ gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, nullptr);
append_to = TRUE;
kw_iter = add;
}
GtkWidget *group;
GtkWidget *button;
- gchar *name = NULL;
+ gchar *name = nullptr;
gboolean is_keyword = TRUE;
cdd = g_new0(ConfDialogData, 1);
cdd->pkd =pkd;
cdd->click_tpath = pkd->click_tpath;
- pkd->click_tpath = NULL;
+ pkd->click_tpath = nullptr;
cdd->edit_existing = edit_existing;
cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("New keyword"), "keyword_edit",
G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd);
- generic_dialog_add_message(gd, NULL, name ? _("Configure keyword") : _("New keyword"), NULL, FALSE);
+ generic_dialog_add_message(gd, nullptr, name ? _("Configure keyword") : _("New keyword"), nullptr, FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr,
bar_pane_keywords_edit_ok_cb, TRUE);
table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE);
group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL);
- button = pref_radiobutton_new(group, NULL, _("Active keyword"),
+ button = pref_radiobutton_new(group, nullptr, _("Active keyword"),
(is_keyword),
G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd);
button = pref_radiobutton_new(group, button, _("Helper"),
"marks_keywords", menu_widget, TRUE, dummy_cancel_cb, pkd);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
"Disconnect all Marks Keywords connections?", message->str, TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, bar_pane_keywords_disconnect_marks_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, bar_pane_keywords_disconnect_marks_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
GtkTreeModel *keyword_tree;
string_list_free(pkd->expanded_rows);
- pkd->expanded_rows = NULL;
+ pkd->expanded_rows = nullptr;
gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
(bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
auto pkd = static_cast<PaneKeywordsData *>(data);
string_list_free(pkd->expanded_rows);
- pkd->expanded_rows = NULL;
+ pkd->expanded_rows = nullptr;
gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
(bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
GList *list, *work;
- GList *keywords = NULL;
+ GList *keywords = nullptr;
GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
GtkTreeViewDropPosition pos;
if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
- pkd->click_tpath = NULL;
+ pkd->click_tpath = nullptr;
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
menu = popup_menu_short_lived();
if (keyword)
{
text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
- item = menu_item_add(menu, text, NULL, NULL);
+ item = menu_item_add(menu, text, nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
g_free(text);
}
menu_item_add_divider(menu);
submenu = gtk_menu_new();
- item = menu_item_add(menu, _("On any change"), NULL, NULL);
+ item = menu_item_add(menu, _("On any change"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
pkd->key = g_strdup(key);
pkd->expand_checked = TRUE;
- pkd->expanded_rows = NULL;
+ pkd->expanded_rows = nullptr;
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
gtk_widget_set_size_request(pkd->widget, -1, height);
gtk_widget_show(hbox);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
if (options->show_predefined_keyword_tree)
{
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
keyword_tree_new_default();
}
- store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL);
+ store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), nullptr);
gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
FILTER_KEYWORD_COLUMN_COUNT,
filter_keyword_column_types,
bar_pane_keywords_filter_modify,
pkd,
- NULL);
+ nullptr);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
bar_pane_keywords_filter_visible,
store,
- NULL);
+ nullptr);
pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
g_object_unref(store);
GtkWidget *bar_pane_keywords_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
{
gchar *id = g_strdup("keywords");
- gchar *title = NULL;
+ gchar *title = nullptr;
gchar *key = g_strdup(COMMENT_KEY);
gboolean expanded = TRUE;
gint height = 200;
pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!pkd) return;
- gchar *title = NULL;
+ gchar *title = nullptr;
while (*attribute_names)
{
void bar_pane_keywords_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
{
PaneKeywordsData *pkd;
- gchar *path = NULL;
+ gchar *path = nullptr;
GtkTreePath *tree_path;
pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
kw_split = strtok(entry_text, ",");
- while (kw_split != NULL)
+ while (kw_split != nullptr)
{
kw_cr = g_strconcat(kw_split, "\n", NULL);
g_strchug(kw_cr);
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, kw_cr, -1);
- kw_split = strtok(NULL, ",");
+ kw_split = strtok(nullptr, ",");
g_free(kw_cr);
}
gtk_tree_model_get(model, a, 0, &name1, -1);
gtk_tree_model_get(model, b, 0, &name2, -1);
- if (name1 == NULL || name2 == NULL)
+ if (name1 == nullptr || name2 == nullptr)
{
- if (name1 == NULL && name2 == NULL)
+ if (name1 == nullptr && name2 == nullptr)
{
ret = 0;
}
else
{
- ret = (name1 == NULL) ? -1 : 1;
+ ret = (name1 == nullptr) ? -1 : 1;
}
}
else
sortable = GTK_TREE_SORTABLE(keyword_store);
gtk_tree_sortable_set_sort_func(sortable, 0, autocomplete_sort_iter_compare_func,
- GINT_TO_POINTER(0), NULL);
+ GINT_TO_POINTER(0), nullptr);
gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);
GList *keyword_list_get()
{
- GList *ret_list = NULL;
+ GList *ret_list = nullptr;
gchar *string;
gchar *string_nl;
GtkTreeIter iter;
row_1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
gtk_box_pack_start(GTK_BOX(prd->widget), row_1, FALSE, FALSE, 0);
- radio_rejected = gtk_radio_button_new_with_label(NULL, _("Rejected"));
+ radio_rejected = gtk_radio_button_new_with_label(nullptr, _("Rejected"));
gtk_box_pack_start(GTK_BOX(row_1), radio_rejected, FALSE, FALSE, 0);
g_signal_connect(radio_rejected, "released", G_CALLBACK(bar_pane_rating_selected_cb), prd);
GtkWidget *bar_pane_rating_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *title = NULL;
+ gchar *title = nullptr;
gchar *id = g_strdup("rating");
gboolean expanded = TRUE;
GtkWidget *ret;
void bar_pane_rating_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
{
PaneRatingData *prd;
- gchar *title = NULL;
+ gchar *title = nullptr;
prd = static_cast<PaneRatingData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
if (!prd) return;
bookmark_list_set_key(bookmarks, SORT_KEY_COLLECTIONS);
dir_fd = file_data_new_dir(get_collections_dir());
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
file_data_unref(dir_fd);
list = filelist_sort_path(list);
bar_sort_add_close(sd);
- bar_sort_undo_set(sd, NULL, NULL);
+ bar_sort_undo_set(sd, nullptr, nullptr);
}
static void bar_sort_mode_cb(GtkWidget *combo, gpointer data)
{
/* we should create the undo_dest_list to use it later... */
string_list_free(sd->undo_dest_list);
- sd->undo_dest_list=NULL;
+ sd->undo_dest_list=nullptr;
GList *work = sd->undo_src_list;
while(work)
if (sd->undo_src_list)
{
- GList *work = NULL;
+ GList *work = nullptr;
src_path = g_strdup(static_cast<const gchar *>(sd->undo_src_list->data));
src_dir = remove_level_from_path(src_path);
if (sd->undo_src_list)
{
GList *delete_list;
- GList *work = NULL;
+ GList *work = nullptr;
delete_list = sd->undo_dest_list;
while (delete_list)
delete_list = delete_list->next;
}
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, work, button);
+ file_util_delete(nullptr, work, button);
}
break;
layout_image_set_fd(sd->lw, file_data_new_group(origin));
}
- bar_sort_undo_set(sd, NULL, NULL);
+ bar_sort_undo_set(sd, nullptr, nullptr);
}
static void bar_sort_undo_collection(SortData *sd)
collect_manager_remove(file_data_new_group(source), sd->undo_collection);
}
- bar_sort_undo_set(sd, NULL, NULL);
+ bar_sort_undo_set(sd, nullptr, nullptr);
}
static void bar_sort_undo_cb(GtkWidget *button, gpointer data)
orig_list = layout_selection_list(sd->lw);
action_list = orig_list;
undo_src_list = orig_list;
- orig_list = NULL;
+ orig_list = nullptr;
bar_sort_undo_set(sd, undo_src_list, path);
{
case BAR_SORT_COPY:
file_util_copy_simple(action_list, path, sd->lw->window);
- action_list = NULL;
+ action_list = nullptr;
layout_image_next(sd->lw);
break;
case BAR_SORT_MOVE:
file_util_move_simple(action_list, path, sd->lw->window);
- action_list = NULL;
+ action_list = nullptr;
break;
case BAR_SORT_FILTER:
static void bar_sort_bookmark_select_collection(SortData *sd, FileData *source, const gchar *path)
{
- GList *list = NULL;
+ GList *list = nullptr;
switch (sd->selection)
{
case BAR_SORT_SELECTION_IMAGE:
- list = g_list_append(NULL, file_data_ref(source));
+ list = g_list_append(nullptr, file_data_ref(source));
break;
case BAR_SORT_SELECTION_SELECTED:
list = layout_selection_list(sd->lw);
if (!list)
{
- bar_sort_undo_set(sd, NULL, NULL);
+ bar_sort_undo_set(sd, nullptr, nullptr);
return;
}
}
else
{
- sd->filter_key = NULL;
+ sd->filter_key = nullptr;
}
}
{
auto sd = static_cast<SortData *>(data);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
- bar_sort_set_action(sd, BAR_SORT_COPY, NULL);
+ bar_sort_set_action(sd, BAR_SORT_COPY, nullptr);
}
static void bar_sort_set_move_cb(GtkWidget *button, gpointer data)
{
auto sd = static_cast<SortData *>(data);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) return;
- bar_sort_set_action(sd, BAR_SORT_MOVE, NULL);
+ bar_sort_set_action(sd, BAR_SORT_MOVE, nullptr);
}
static void bar_sort_set_filter_cb(GtkWidget *button, gpointer data)
GenericDialog *gd;
gd = generic_dialog_new(_("Sort Manager Operations"),
- "sort_manager_operations", NULL, TRUE, NULL, NULL);
+ "sort_manager_operations", nullptr, TRUE, nullptr, nullptr);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_INFO,
"Sort Manager Operations", _("Additional operations utilising plugins\nmay be included by setting:\n\nX-Geeqie-Filter=true\n\nin the plugin file."), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL, bar_filter_help_cb, TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, NULL, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_HELP, nullptr, bar_filter_help_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, nullptr, TRUE);
gtk_widget_show(gd->dialog);
}
static void bar_sort_add_close(SortData *sd)
{
if (sd->dialog) file_dialog_close(sd->dialog);
- sd->dialog_name_entry = NULL;
- sd->dialog = NULL;
+ sd->dialog_name_entry = nullptr;
+ sd->dialog = nullptr;
}
static void bar_sort_add_ok_cb(FileDialog *fd, gpointer data)
if (isfile(path))
{
gchar *text = g_strdup_printf(_("The collection:\n%s\nalready exists."), filename);
- file_util_warning_dialog(_("Collection exists"), text, GTK_STOCK_DIALOG_INFO, NULL);
+ file_util_warning_dialog(_("Collection exists"), text, GTK_STOCK_DIALOG_INFO, nullptr);
g_free(text);
}
else
sd->dialog = file_util_file_dlg(title,
"add_bookmark", button,
bar_sort_add_cancel_cb, sd);
- file_dialog_add_button(sd->dialog, GTK_STOCK_OK, NULL, bar_sort_add_ok_cb, TRUE);
+ file_dialog_add_button(sd->dialog, GTK_STOCK_OK, nullptr, bar_sort_add_ok_cb, TRUE);
- generic_dialog_add_message(GENERIC_DIALOG(sd->dialog), NULL, title, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(sd->dialog), nullptr, title, nullptr, FALSE);
if (sd->mode == BAR_SORT_MODE_FOLDER)
{
- file_dialog_add_path_widgets(sd->dialog, NULL, NULL, "add_bookmark", NULL, NULL);
+ file_dialog_add_path_widgets(sd->dialog, nullptr, nullptr, "add_bookmark", nullptr, nullptr);
}
hbox = pref_box_new(GENERIC_DIALOG(sd->dialog)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
gboolean have_filter;
GtkWidget *button;
- if (!lw) return NULL;
+ if (!lw) return nullptr;
sd = g_new0(SortData, 1);
}
sd->selection = selection;
- sd->undo_src_list = NULL;
- sd->undo_dest_list = NULL;
- sd->undo_collection = NULL;
+ sd->undo_src_list = nullptr;
+ sd->undo_dest_list = nullptr;
+ sd->undo_collection = nullptr;
sd->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
DEBUG_NAME(sd->vbox);
DEBUG_NAME(sd->folder_group);
gtk_widget_set_tooltip_text(sd->folder_group, _("See the Help file for additional functions"));
- buttongrp = pref_radiobutton_new(sd->folder_group, NULL,
+ buttongrp = pref_radiobutton_new(sd->folder_group, nullptr,
_("Copy"), (sd->action == BAR_SORT_COPY),
G_CALLBACK(bar_sort_set_copy_cb), sd);
g_signal_connect(G_OBJECT(buttongrp), "button_press_event", G_CALLBACK(bar_filter_message_cb), NULL);
sd->collection_group = pref_box_new(sd->vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
- buttongrp = pref_radiobutton_new(sd->collection_group, NULL,
+ buttongrp = pref_radiobutton_new(sd->collection_group, nullptr,
_("Add image"), (sd->selection == BAR_SORT_SELECTION_IMAGE),
G_CALLBACK(bar_sort_set_selection_image_cb), sd);
pref_radiobutton_new(sd->collection_group, buttongrp,
tbar = pref_toolbar_new(sd->vbox, GTK_TOOLBAR_ICONS);
DEBUG_NAME(tbar);
- sd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
+ sd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, nullptr, FALSE,
_("Add Bookmark"),
G_CALLBACK(bar_sort_add_cb), sd);
- sd->undo_button = pref_toolbar_button(tbar, GTK_STOCK_UNDO, NULL, FALSE,
+ sd->undo_button = pref_toolbar_button(tbar, GTK_STOCK_UNDO, nullptr, FALSE,
_("Undo last image"),
G_CALLBACK(bar_sort_undo_cb), sd);
- sd->help_button = pref_toolbar_button(tbar, GTK_STOCK_HELP, NULL, FALSE,
+ sd->help_button = pref_toolbar_button(tbar, GTK_STOCK_HELP, nullptr, FALSE,
_("Functions additional to Copy and Move"),
G_CALLBACK(bar_sort_help_cb), sd);
gint action = BAR_SORT_COPY;
gint mode = BAR_SORT_MODE_FOLDER;
gint selection = BAR_SORT_SELECTION_IMAGE;
- gchar *filter_key = NULL;
+ gchar *filter_key = nullptr;
while (attribute_names && *attribute_names)
{
GtkWidget *bar_sort_new_default(LayoutWindow *lw)
{
- return bar_sort_new_from_config(lw, NULL, NULL);
+ return bar_sort_new_from_config(lw, nullptr, nullptr);
}
void bar_sort_write_config(GtkWidget *bar, GString *outstr, gint indent)
{PANE_GPS, "gps", N_("GPS Map"), default_config_gps},
#endif
#endif
- {PANE_UNDEF, NULL, NULL, NULL}
+ {PANE_UNDEF, nullptr, nullptr, nullptr}
};
typedef struct _BarData BarData;
display = gdk_display_get_default();
seat = gdk_display_get_default_seat(display);
device = gdk_seat_get_pointer(seat);
- gdk_device_get_position(device, NULL, &x, &y);
+ gdk_device_get_position(device, nullptr, &x, &y);
list = gtk_container_get_children(GTK_CONTAINER(expander));
data_box = static_cast<GtkWidget *>(list->data);
bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(widget), "bar_data"));
if (bd)
{
- expander = NULL;
+ expander = nullptr;
bar = widget;
}
else
menu_item_add_divider(menu);
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static void bar_menu_add_popup(GtkWidget *widget)
pane++;
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
{
BarData *bd;
GList *list, *work;
- GtkWidget *ret = NULL;
+ GtkWidget *ret = nullptr;
- if (!id || !id[0]) return NULL;
+ if (!id || !id[0]) return nullptr;
bd = static_cast<BarData *>(g_object_get_data(G_OBJECT(bar), "bar_data"));
- if (!bd) return NULL;
+ if (!bd) return nullptr;
list = gtk_container_get_children(GTK_CONTAINER(bd->vbox));
pd->lw = bd->lw;
pd->bar = bar;
- expander = gtk_expander_new(NULL);
+ expander = gtk_expander_new(nullptr);
DEBUG_NAME(expander);
if (pd && pd->title)
{
void bar_populate_default(GtkWidget *UNUSED(bar))
{
- const gchar *populate_id[] = {"histogram", "title", "keywords", "comment", "rating", "exif", NULL};
+ const gchar *populate_id[] = {"histogram", "title", "keywords", "comment", "rating", "exif", nullptr};
const gchar **id = populate_id;
while (*id)
gtk_box_pack_start(GTK_BOX(bd->widget), box, FALSE, FALSE, 0);
gtk_widget_show(box);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
DEBUG_NAME(scrolled);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
DEBUG_NAME(add_box);
gtk_box_pack_end(GTK_BOX(bd->widget), add_box, FALSE, FALSE, 0);
tbar = pref_toolbar_new(add_box, GTK_TOOLBAR_ICONS);
- bd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
+ bd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, nullptr, FALSE,
_("Add Pane"),
G_CALLBACK(bar_menu_add_cb), bd);
gtk_widget_show(add_box);
if (strcmp(pane->id, id) == 0) break;
pane++;
}
- if (!pane->id) return NULL;
+ if (!pane->id) return nullptr;
return pane->config;
}
}
image_loader_free(cl->il);
- cl->il = NULL;
+ cl->il = nullptr;
cl->todo_mask = static_cast<CacheDataType>(cl->todo_mask & ~CACHE_LOADER_SIMILARITY);
}
if (recursive_mkdir_if_not_exists(base, mode))
{
g_free(cl->cd->path);
- cl->cd->path = cache_get_location(CACHE_TYPE_SIM, cl->fd->path, TRUE, NULL);
+ cl->cd->path = cache_get_location(CACHE_TYPE_SIM, cl->fd->path, TRUE, nullptr);
if (cache_sim_data_save(cl->cd))
{
filetime_set(cl->cd->path, filetime(cl->fd->path));
CacheLoader *cl;
gchar *found;
- if (!fd || !isfile(fd->path)) return NULL;
+ if (!fd || !isfile(fd->path)) return nullptr;
cl = g_new0(CacheLoader, 1);
cl->fd = file_data_ref(fd);
cl->todo_mask = load_mask;
cl->done_mask = CACHE_LOADER_NONE;
- cl->il = NULL;
+ cl->il = nullptr;
cl->idle_id = g_idle_add(cache_loader_phase1_idle_cb, cl);
cl->error = FALSE;
*-----------------------------------------------------------------------------
* Command line cache maintenance program functions *-----------------------------------------------------------------------------
*/
-static gchar *cache_maintenance_path = NULL;
+static gchar *cache_maintenance_path = nullptr;
static GtkStatusIcon *status_icon;
static void cache_maintenance_sim_stop_cb(gpointer UNUSED(data))
/* take ownership of menu */
g_object_ref_sink(G_OBJECT(menu));
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
void cache_maintenance(const gchar *path)
static gchar *extension_find_dot(gchar *path)
{
- gchar *dot = NULL;
+ gchar *dot = nullptr;
- if (!path) return NULL;
+ if (!path) return nullptr;
while (*path != '\0')
{
g_free(pathl);
if (!dp) return FALSE;
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
gchar *name = dir->d_name;
static gboolean cache_maintain_home_cb(gpointer data)
{
auto cm = static_cast<CMData *>(data);
- GList *dlist = NULL;
- GList *list = NULL;
+ GList *dlist = nullptr;
+ GList *list = nullptr;
FileData *fd;
gboolean just_done = FALSE;
gboolean still_have_a_file = TRUE;
filter_disable = options->file_filter.disable;
options->file_filter.disable = TRUE;
- if (g_list_find(cm->done_list, fd) == NULL)
+ if (g_list_find(cm->done_list, fd) == nullptr)
{
cm->done_list = g_list_prepend(cm->done_list, fd);
cm->list = g_list_concat(dlist, cm->list);
- if (cm->list && g_list_find(cm->done_list, cm->list->data) != NULL)
+ if (cm->list && g_list_find(cm->done_list, cm->list->data) != nullptr)
{
/* check if the dir is empty */
}
dir_fd = file_data_new_dir(cache_folder);
- if (!filelist_read(dir_fd, NULL, &dlist))
+ if (!filelist_read(dir_fd, nullptr, &dlist))
{
file_data_unref(dir_fd);
return;
cm = g_new0(CMData, 1);
cm->list = dlist;
- cm->done_list = NULL;
+ cm->done_list = nullptr;
cm->clear = clear;
cm->metadata = metadata;
cm->remote = FALSE;
cm->gd = generic_dialog_new(_("Maintenance"),
"main_maintenance",
parent, FALSE,
- NULL, cm);
+ nullptr, cm);
cm->gd->cancel_cb = cache_maintain_home_close_cb;
- cm->button_close = generic_dialog_add_button(cm->gd, GTK_STOCK_CLOSE, NULL,
+ cm->button_close = generic_dialog_add_button(cm->gd, GTK_STOCK_CLOSE, nullptr,
cache_maintain_home_close_cb, FALSE);
gtk_widget_set_sensitive(cm->button_close, FALSE);
- cm->button_stop = generic_dialog_add_button(cm->gd, GTK_STOCK_STOP, NULL,
+ cm->button_stop = generic_dialog_add_button(cm->gd, GTK_STOCK_STOP, nullptr,
cache_maintain_home_stop_cb, FALSE);
- generic_dialog_add_message(cm->gd, NULL, msg, NULL, FALSE);
+ generic_dialog_add_message(cm->gd, nullptr, msg, nullptr, FALSE);
gtk_window_set_default_size(GTK_WINDOW(cm->gd->dialog), PURGE_DIALOG_WIDTH, -1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(hbox), cm->entry, TRUE, TRUE, 0);
gtk_widget_show(cm->entry);
- cm->spinner = spinner_new(NULL, SPINNER_SPEED);
+ cm->spinner = spinner_new(nullptr, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), cm->spinner, FALSE, FALSE, 0);
gtk_widget_show(cm->spinner);
}
dir_fd = file_data_new_dir(cache_folder);
- if (!filelist_read(dir_fd, NULL, &dlist))
+ if (!filelist_read(dir_fd, nullptr, &dlist))
{
file_data_unref(dir_fd);
return;
cm = g_new0(CMData, 1);
cm->list = dlist;
- cm->done_list = NULL;
+ cm->done_list = nullptr;
cm->clear = clear;
cm->metadata = metadata;
cm->remote = TRUE;
gchar *d;
buf = cache_find_location(CACHE_TYPE_THUMB, src);
- d = cache_get_location(CACHE_TYPE_THUMB, dest, TRUE, NULL);
+ d = cache_get_location(CACHE_TYPE_THUMB, dest, TRUE, nullptr);
cache_file_move(buf, d);
g_free(d);
g_free(buf);
buf = cache_find_location(CACHE_TYPE_SIM, src);
- d = cache_get_location(CACHE_TYPE_SIM, dest, TRUE, NULL);
+ d = cache_get_location(CACHE_TYPE_SIM, dest, TRUE, nullptr);
cache_file_move(buf, d);
g_free(d);
g_free(buf);
gchar *d;
buf = cache_find_location(CACHE_TYPE_METADATA, src);
- d = cache_get_location(CACHE_TYPE_METADATA, dest, TRUE, NULL);
+ d = cache_get_location(CACHE_TYPE_METADATA, dest, TRUE, nullptr);
cache_file_move(buf, d);
g_free(d);
g_free(buf);
{
gchar *path;
- path = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, TRUE, NULL);
+ path = cache_get_location(CACHE_TYPE_METADATA, fd->change->dest, TRUE, nullptr);
if (!copy_file(src_cache, path))
{
DEBUG_1("failed to copy metadata %s to %s", src_cache, path);
static void cache_manager_render_reset(CacheOpsData *cd)
{
filelist_free(cd->list);
- cd->list = NULL;
+ cd->list = nullptr;
filelist_free(cd->list_dir);
- cd->list_dir = NULL;
+ cd->list_dir = nullptr;
thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
- cd->tl = NULL;
+ cd->tl = nullptr;
}
static void cache_manager_render_close_cb(GenericDialog *UNUSED(fd), gpointer data)
static void cache_manager_render_folder(CacheOpsData *cd, FileData *dir_fd)
{
- GList *list_d = NULL;
- GList *list_f = NULL;
+ GList *list_d = nullptr;
+ GList *list_f = nullptr;
if (cd->recurse)
{
}
else
{
- filelist_read(dir_fd, &list_f, NULL);
+ filelist_read(dir_fd, &list_f, nullptr);
}
list_f = filelist_filter(list_f, FALSE);
auto cd = static_cast<CacheOpsData *>(data);
thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
- cd->tl = NULL;
+ cd->tl = nullptr;
while (cache_manager_render_file(cd));
}
thumb_loader_set_callbacks(reinterpret_cast<ThumbLoader *>(cd->tl),
cache_manager_render_thumb_done_cb,
cache_manager_render_thumb_done_cb,
- NULL, cd);
+ nullptr, cd);
thumb_loader_set_cache(reinterpret_cast<ThumbLoader *>(cd->tl), TRUE, cd->local, TRUE);
success = thumb_loader_start(reinterpret_cast<ThumbLoader *>(cd->tl), fd);
if (success)
else
{
thumb_loader_free(reinterpret_cast<ThumbLoader *>(cd->tl));
- cd->tl = NULL;
+ cd->tl = nullptr;
}
file_data_unref(fd);
if (cd->destroy_func)
{
- g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), NULL);
+ g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), nullptr);
}
return FALSE;
{
auto cd = static_cast<CacheOpsData *>(data);
gchar *path;
- GList *list_total = NULL;
+ GList *list_total = nullptr;
if(!cd->remote)
{
cd->gd = generic_dialog_new(_("Create thumbnails"),
"create_thumbnails",
widget, FALSE,
- NULL, cd);
+ nullptr, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cd->gd->cancel_cb = cache_manager_render_close_cb;
- cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
+ cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, nullptr,
cache_manager_render_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_render_start_cb, FALSE);
- cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
+ cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, nullptr,
cache_manager_render_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
- generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL, FALSE);
+ generic_dialog_add_message(cd->gd, nullptr, _("Create thumbnails"), nullptr, FALSE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- label = tab_completion_new(&cd->entry, path, NULL, NULL, NULL, NULL);
+ label = tab_completion_new(&cd->entry, path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress_bar, TRUE, TRUE, 0);
gtk_widget_show(cd->progress_bar);
- cd->spinner = spinner_new(NULL, -1);
+ cd->spinner = spinner_new(nullptr, -1);
gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
gtk_widget_show(cd->spinner);
- cd->list = NULL;
+ cd->list = nullptr;
gtk_widget_show(cd->gd->dialog);
}
}
thumb_loader_std_thumb_file_validate_cancel(cd->tl);
- cd->tl = NULL;
+ cd->tl = nullptr;
filelist_free(cd->list);
- cd->list = NULL;
+ cd->list = nullptr;
}
static void cache_manager_standard_clean_stop_cb(GenericDialog *UNUSED(gd), gpointer data)
}
}
- cd->tl = NULL;
+ cd->tl = nullptr;
if (cd->list)
{
FileData *next_fd;
path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_NORMAL, NULL);
dir_fd = file_data_new_dir(path);
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
cd->list = list;
file_data_unref(dir_fd);
g_free(path);
path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_LARGE, NULL);
dir_fd = file_data_new_dir(path);
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
cd->list = g_list_concat(cd->list, list);
file_data_unref(dir_fd);
g_free(path);
path = g_build_filename(get_thumbnails_standard_cache_dir(), THUMB_FOLDER_FAIL, NULL);
dir_fd = file_data_new_dir(path);
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
cd->list = g_list_concat(cd->list, list);
file_data_unref(dir_fd);
g_free(path);
}
else
{
- cache_manager_standard_clean_valid_cb(NULL, TRUE, cd);
+ cache_manager_standard_clean_valid_cb(nullptr, TRUE, cd);
}
}
cd->gd = generic_dialog_new(_("Maintenance"),
"standard_maintenance",
widget, FALSE,
- NULL, cd);
+ nullptr, cd);
cd->gd->cancel_cb = cache_manager_standard_clean_close_cb;
- cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
+ cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, nullptr,
cache_manager_standard_clean_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_standard_clean_start_cb, FALSE);
- cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
+ cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, nullptr,
cache_manager_standard_clean_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
- generic_dialog_add_message(cd->gd, stock_id, msg, NULL, FALSE);
+ generic_dialog_add_message(cd->gd, stock_id, msg, nullptr, FALSE);
cd->progress = gtk_progress_bar_new();
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(cd->progress), _("click start to begin"));
gtk_widget_show(cd->progress);
cd->days = 30;
- cd->tl = NULL;
+ cd->tl = nullptr;
cd->idle_id = 0;
gtk_widget_show(cd->gd->dialog);
cd = g_new0(CacheOpsData, 1);
cd->clear = clear;
cd->days = 30;
- cd->tl = NULL;
+ cd->tl = nullptr;
cd->idle_id = 0;
cd->remote = TRUE;
- cache_manager_standard_clean_start(NULL, cd);
+ cache_manager_standard_clean_start(nullptr, cd);
}
static void cache_manager_standard_clean_cb(GtkWidget *widget, gpointer UNUSED(data))
static void cache_manager_main_clear_ok_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
{
- cache_maintain_home(FALSE, TRUE, NULL);
+ cache_maintain_home(FALSE, TRUE, nullptr);
}
void cache_manager_main_clear_confirm(GtkWidget *parent)
gd = generic_dialog_new(_("Clear cache"),
"clear_cache", parent, TRUE,
- dummy_cancel_cb, NULL);
+ dummy_cancel_cb, nullptr);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear cache"),
_("This will remove all thumbnails and sim. files\nthat have been saved to disk, continue?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, cache_manager_main_clear_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, cache_manager_main_clear_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
static void cache_manager_render_cb(GtkWidget *widget, gpointer UNUSED(data))
{
- const gchar *path = layout_get_path(NULL);
+ const gchar *path = layout_get_path(nullptr);
if (!path || !*path) path = homedir();
cache_manager_render_dialog(widget, path);
}
-static CacheManager *cache_manager = NULL;
+static CacheManager *cache_manager = nullptr;
static void cache_manager_close_cb(GenericDialog *gd, gpointer UNUSED(data))
{
generic_dialog_close(gd);
g_free(cache_manager);
- cache_manager = NULL;
+ cache_manager = nullptr;
}
static void cache_manager_help_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
static void cache_manager_sim_reset(CacheOpsData *cd)
{
filelist_free(cd->list);
- cd->list = NULL;
+ cd->list = nullptr;
filelist_free(cd->list_dir);
- cd->list_dir = NULL;
+ cd->list_dir = nullptr;
cache_loader_free(cd->cl);
- cd->cl = NULL;
+ cd->cl = nullptr;
}
static void cache_manager_sim_close_cb(GenericDialog *UNUSED(fd), gpointer data)
static void cache_manager_sim_folder(CacheOpsData *cd, FileData *dir_fd)
{
- GList *list_d = NULL;
- GList *list_f = NULL;
+ GList *list_d = nullptr;
+ GList *list_f = nullptr;
if (cd->recurse)
{
}
else
{
- filelist_read(dir_fd, &list_f, NULL);
+ filelist_read(dir_fd, &list_f, nullptr);
}
list_f = filelist_filter(list_f, FALSE);
auto cd = static_cast<CacheOpsData *>(data);
cache_loader_free(cd->cl);
- cd->cl = NULL;
+ cd->cl = nullptr;
while (cache_manager_sim_file(cd));
}
if (cd->destroy_func)
{
- g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), NULL);
+ g_idle_add(reinterpret_cast<GSourceFunc>(cd->destroy_func), nullptr);
}
return FALSE;
{
auto cd = static_cast<CacheOpsData *>(data);
gchar *path;
- GList *list_total = NULL;
+ GList *list_total = nullptr;
if (!cd->remote)
{
cd->remote = FALSE;
cd->recurse = TRUE;
- cd->gd = generic_dialog_new(_("Create sim. files"), "create_sim_files", widget, FALSE, NULL, cd);
+ cd->gd = generic_dialog_new(_("Create sim. files"), "create_sim_files", widget, FALSE, nullptr, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cd->gd->cancel_cb = cache_manager_sim_close_cb;
- cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
+ cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, nullptr,
cache_manager_sim_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_sim_start_cb, FALSE);
- cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
+ cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, nullptr,
cache_manager_sim_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
- generic_dialog_add_message(cd->gd, NULL, _("Create sim. files recursively"), NULL, FALSE);
+ generic_dialog_add_message(cd->gd, nullptr, _("Create sim. files recursively"), nullptr, FALSE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- label = tab_completion_new(&cd->entry, path, NULL, NULL, NULL, NULL);
+ label = tab_completion_new(&cd->entry, path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(cd->gd->vbox), cd->progress_bar, TRUE, TRUE, 0);
gtk_widget_show(cd->progress_bar);
- cd->spinner = spinner_new(NULL, -1);
+ cd->spinner = spinner_new(nullptr, -1);
gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
gtk_widget_show(cd->spinner);
- cd->list = NULL;
+ cd->list = nullptr;
gtk_widget_show(cd->gd->dialog);
}
static void cache_manager_sim_load_cb(GtkWidget *widget, gpointer UNUSED(data))
{
- const gchar *path = layout_get_path(NULL);
+ const gchar *path = layout_get_path(nullptr);
if (!path || !*path) path = homedir();
cache_manager_sim_load_dialog(widget, path);
{
cmd_line = g_strdup_printf("%s --cache-maintenance \"%s\"", gq_executable_path, path);
- g_spawn_command_line_async(cmd_line, NULL);
+ g_spawn_command_line_async(cmd_line, nullptr);
g_free(cmd_line);
generic_dialog_close(cd->gd);
cd->remote = FALSE;
cd->recurse = TRUE;
- cd->gd = generic_dialog_new(_("Background cache maintenance"), "background_cache_maintenance", widget, FALSE, NULL, cd);
+ cd->gd = generic_dialog_new(_("Background cache maintenance"), "background_cache_maintenance", widget, FALSE, nullptr, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cd->gd->cancel_cb = cache_manager_cache_maintenance_close_cb;
- cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
+ cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, nullptr,
cache_manager_cache_maintenance_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_cache_maintenance_start_cb, FALSE);
- generic_dialog_add_message(cd->gd, NULL, _("Recursively delete orphaned thumbnails\nand .sim files, and create new\nthumbnails and .sim files"), NULL, FALSE);
+ generic_dialog_add_message(cd->gd, nullptr, _("Recursively delete orphaned thumbnails\nand .sim files, and create new\nthumbnails and .sim files"), nullptr, FALSE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- label = tab_completion_new(&cd->entry, path, NULL, NULL, NULL, NULL);
+ label = tab_completion_new(&cd->entry, path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
- cd->list = NULL;
+ cd->list = nullptr;
gtk_widget_show(cd->gd->dialog);
}
static void cache_manager_cache_maintenance_load_cb(GtkWidget *widget, gpointer UNUSED(data))
{
- const gchar *path = layout_get_path(NULL);
+ const gchar *path = layout_get_path(nullptr);
if (!path || !*path) path = homedir();
cache_manager_cache_maintenance_load_dialog(widget, path);
cache_manager->dialog = generic_dialog_new(_("Cache Maintenance"),
"cache_manager",
- NULL, FALSE,
- NULL, cache_manager);
+ nullptr, FALSE,
+ nullptr, cache_manager);
gd = cache_manager->dialog;
gd->cancel_cb = cache_manager_close_cb;
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr,
cache_manager_close_cb, FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_HELP, nullptr,
cache_manager_help_cb, FALSE);
- generic_dialog_add_message(gd, NULL, _("Cache and Data Maintenance"), NULL, FALSE);
+ generic_dialog_add_message(gd, nullptr, _("Cache and Data Maintenance"), nullptr, FALSE);
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
}
buf[p] = '\0';
- cd->date = strtol(buf, NULL, 10);
+ cd->date = strtol(buf, nullptr, 10);
cd->have_date = TRUE;
{
/* use current sim that may already contain data we will not touch here */
sd = cd->sim;
- cd->sim = NULL;
+ cd->sim = nullptr;
cd->similarity = FALSE;
}
else
CacheData *cache_sim_data_load(const gchar *path)
{
FILE *f;
- CacheData *cd = NULL;
+ CacheData *cd = nullptr;
gchar buf[32];
gint success = CACHE_LOAD_LINE_NOISE;
gchar *pathl;
- if (!path) return NULL;
+ if (!path) return nullptr;
pathl = path_from_utf8(path);
f = fopen(pathl, "r");
g_free(pathl);
- if (!f) return NULL;
+ if (!f) return nullptr;
cd = cache_sim_data_new();
cd->path = g_strdup(path);
!cd->similarity)
{
cache_sim_data_free(cd);
- cd = NULL;
+ cd = nullptr;
}
return cd;
gchar *cache_get_location(CacheType type, const gchar *source, gint include_name, mode_t *mode)
{
- gchar *path = NULL;
+ gchar *path = nullptr;
gchar *base;
- gchar *name = NULL;
+ gchar *name = nullptr;
const gchar *cache_rc;
const gchar *cache_local;
const gchar *cache_ext;
- if (!source) return NULL;
+ if (!source) return nullptr;
cache_path_parts(type, &cache_rc, &cache_local, &cache_ext);
const gchar *cache_ext;
gboolean prefer_local;
- if (!source) return NULL;
+ if (!source) return nullptr;
cache_path_parts(type, &cache_rc, &cache_local, &cache_ext);
if (!isfile(path))
{
g_free(path);
- path = NULL;
+ path = nullptr;
}
}
const gchar *get_thumbnails_cache_dir(void)
{
- static gchar *thumbnails_cache_dir = NULL;
+ static gchar *thumbnails_cache_dir = nullptr;
if (thumbnails_cache_dir) return thumbnails_cache_dir;
const gchar *get_thumbnails_standard_cache_dir(void)
{
- static gchar *thumbnails_standard_cache_dir = NULL;
+ static gchar *thumbnails_standard_cache_dir = nullptr;
if (thumbnails_standard_cache_dir) return thumbnails_standard_cache_dir;
const gchar *get_metadata_cache_dir(void)
{
- static gchar *metadata_cache_dir = NULL;
+ static gchar *metadata_cache_dir = nullptr;
if (metadata_cache_dir) return metadata_cache_dir;
static const GTypeInfo cell_icon_info =
{
sizeof(GQvCellRendererIconClass), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
+ nullptr, /* base_init */
+ nullptr, /* base_finalize */
static_cast<GClassInitFunc>(gqv_cell_renderer_icon_class_init_wrapper), /* class_init */
- NULL, /* class_finalize */
- NULL, /* class_data */
+ nullptr, /* class_finalize */
+ nullptr, /* class_data */
sizeof(GQvCellRendererIcon), /* instance_size */
0, /* n_preallocs */
reinterpret_cast<GInstanceInitFunc>(gqv_cell_renderer_icon_init_wrapper), /* instance_init */
- NULL, /* value_table */
+ nullptr, /* value_table */
};
cell_icon_type = g_type_register_static(GTK_TYPE_CELL_RENDERER,
g_param_spec_string("text",
"Text",
"Text to render",
- NULL,
+ nullptr,
G_PARAM_READWRITE));
g_object_class_install_property(object_class,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GQvCellRendererIconClass, toggled),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
switch (param_id)
{
case PROP_PIXBUF:
- g_value_set_object(value, cellicon->pixbuf ? G_OBJECT(cellicon->pixbuf) : NULL);
+ g_value_set_object(value, cellicon->pixbuf ? G_OBJECT(cellicon->pixbuf) : nullptr);
break;
case PROP_TEXT:
g_value_set_string(value, cellicon->text);
GtkCellRenderer *
gqv_cell_renderer_icon_new(void)
{
- return static_cast<GtkCellRenderer *>(g_object_new(GQV_TYPE_CELL_RENDERER_ICON, NULL));
+ return static_cast<GtkCellRenderer *>(g_object_new(GQV_TYPE_CELL_RENDERER_ICON, nullptr));
}
static void gqv_cell_renderer_icon_get_size(GtkCellRenderer *cell,
PangoRectangle rect;
layout = gqv_cell_renderer_icon_get_layout(cellicon, widget, FALSE);
- pango_layout_get_pixel_extents(layout, NULL, &rect);
+ pango_layout_get_pixel_extents(layout, nullptr, &rect);
g_object_unref(layout);
calc_width = MAX(calc_width, rect.width);
GdkRectangle pix_rect;
GdkRectangle draw_rect;
layout = gqv_cell_renderer_icon_get_layout(cellicon, widget, TRUE);
- pango_layout_get_pixel_extents(layout, NULL, &text_rect);
+ pango_layout_get_pixel_extents(layout, nullptr, &text_rect);
pix_rect.width = text_rect.width;
pix_rect.height = text_rect.height;
"border-width: 1px;\n"
"border-radius: 0px;\n"
"}\n"
- ,-1, NULL);
+ ,-1, nullptr);
gtk_style_context_add_provider(context, provider,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
{
auto cd = static_cast<CollectionData *>(data);
gboolean err = FALSE;
- gchar *text = NULL;
+ gchar *text = nullptr;
if (!isname(fd->dest_path))
{
if (err) {
if (text)
{
- file_util_warning_dialog(_("Can not open collection file"), text, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Can not open collection file"), text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
}
return;
gint type, CollectionData *cd)
{
FileDialog *fd;
- GtkWidget *parent = NULL;
+ GtkWidget *parent = nullptr;
CollectWindow *cw;
const gchar *title;
const gchar *btntext;
{
if (!cd) return;
title = _("Save collection");
- btntext = NULL;
+ btntext = nullptr;
btnfunc = reinterpret_cast<gpointer>(collection_save_cb);
stock_id = GTK_STOCK_SAVE;
}
else if (type == DIALOG_LOAD)
{
title = _("Open collection");
- btntext = NULL;
+ btntext = nullptr;
btnfunc = reinterpret_cast<gpointer>(collection_load_cb);
stock_id = GTK_STOCK_OPEN;
}
fd = file_util_file_dlg(title, "dlg_collection", parent,
collection_save_or_load_dialog_close_cb, cd);
- generic_dialog_add_message(GENERIC_DIALOG(fd), NULL, title, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(fd), nullptr, title, nullptr, FALSE);
file_dialog_add_button(fd, stock_id, btntext, reinterpret_cast<void (*)(FileDialog *, gpointer)>(btnfunc), TRUE);
file_dialog_add_path_widgets(fd, get_collections_dir(), path,
void collection_dialog_load(gchar *path)
{
- collection_save_or_load_dialog(path, DIALOG_LOAD, NULL);
+ collection_save_or_load_dialog(path, DIALOG_LOAD, nullptr);
}
void collection_dialog_append(gchar *path, CollectionData *cd)
guint total = 0;
guint fail = 0;
gboolean changed = FALSE;
- CollectManagerEntry *entry = NULL;
+ CollectManagerEntry *entry = nullptr;
guint flush = !!(flags & COLLECTION_LOAD_FLUSH);
guint append = !!(flags & COLLECTION_LOAD_APPEND);
guint only_geometry = !!(flags & COLLECTION_LOAD_GEOMETRY);
gboolean reading_extended_filename = FALSE;
- GString *extended_filename_buffer = g_string_new(NULL);
+ GString *extended_filename_buffer = g_string_new(nullptr);
gchar *buffer2;
if (!only_geometry)
if (!append)
{
collection_list_free(cd->list);
- cd->list = NULL;
+ cd->list = nullptr;
}
}
if (!flush)
{
- gchar *buf = NULL;
+ gchar *buf = nullptr;
while (collect_manager_process_action(entry, &buf))
{
collection_add_check(cd, file_data_new_group(buf), FALSE, TRUE);
changed = TRUE;
g_free(buf);
- buf = NULL;
+ buf = nullptr;
}
}
collection_load_stop(cd);
/* send a NULL CollectInfo to notify end */
- if (cd->info_updated_func) cd->info_updated_func(cd, NULL, cd->info_updated_data);
+ if (cd->info_updated_func) cd->info_updated_func(cd, nullptr, cd->info_updated_data);
return;
}
thumb_loader_set_callbacks(cd->thumb_loader,
collection_load_thumb_done_cb,
collection_load_thumb_error_cb,
- NULL,
+ nullptr,
cd);
/* start it */
if (!cd->thumb_loader) return;
thumb_loader_free(cd->thumb_loader);
- cd->thumb_loader = NULL;
+ cd->thumb_loader = nullptr;
}
static gboolean collection_save_private(CollectionData *cd, const gchar *path)
};
-static GList *collection_manager_entry_list = NULL;
-static GList *collection_manager_action_list = NULL;
-static GList *collection_manager_action_tail = NULL;
+static GList *collection_manager_entry_list = nullptr;
+static GList *collection_manager_action_list = nullptr;
+static GList *collection_manager_action_tail = nullptr;
static guint collection_manager_timer_id = 0; /* event source id */
static void collect_manager_entry_init_data(CollectManagerEntry *entry)
{
- entry->add_list = NULL;
- entry->oldpath_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, reinterpret_cast<GDestroyNotify>(collect_manager_action_unref));
+ entry->add_list = nullptr;
+ entry->oldpath_hash = g_hash_table_new_full(g_str_hash, g_str_equal, nullptr, reinterpret_cast<GDestroyNotify>(collect_manager_action_unref));
entry->newpath_hash = g_hash_table_new(g_str_hash, g_str_equal);
entry->empty = TRUE;
return entry;
}
}
- return NULL;
+ return nullptr;
}
entry->empty = FALSE;
- if (action->oldpath == NULL)
+ if (action->oldpath == nullptr)
{
/* add file */
- if (action->newpath == NULL)
+ if (action->newpath == nullptr)
{
return;
}
gchar *path = *path_ptr;
CollectManagerAction *action;
- if (path == NULL)
+ if (path == nullptr)
{
/* get new files */
if (entry->add_list)
{
action = static_cast<CollectManagerAction *>(entry->add_list->data);
- g_assert(action->oldpath == NULL);
+ g_assert(action->oldpath == nullptr);
entry->add_list = g_list_remove(entry->add_list, action);
path = g_strdup(action->newpath);
g_hash_table_remove(entry->newpath_hash, path);
collect_manager_action_unref(action);
}
*path_ptr = path;
- return (path != NULL);
+ return (path != nullptr);
}
action = static_cast<CollectManagerAction *>(g_hash_table_lookup(entry->oldpath_hash, path));
FileData *dir_fd;
dir_fd = file_data_new_dir(get_collections_dir());
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
file_data_unref(dir_fd);
work = collection_manager_entry_list;
list = g_list_remove(list, fd);
file_data_unref(fd);
- entry = NULL;
+ entry = nullptr;
}
else
{
collect_manager_entry_free(entry);
- entry = NULL;
+ entry = nullptr;
}
}
}
{
if (collection_manager_action_list) DEBUG_1("collection manager processing actions");
- while (collection_manager_action_list != NULL && max > 0)
+ while (collection_manager_action_list != nullptr && max > 0)
{
CollectManagerAction *action;
GList *work;
if (action->type == COLLECTION_MANAGER_ADD)
{
action->newpath = action->oldpath;
- action->oldpath = NULL;
+ action->oldpath = nullptr;
}
else if (action->type == COLLECTION_MANAGER_REMOVE)
{
- action->newpath = NULL;
+ action->newpath = nullptr;
}
collect_manager_entry_add_action(entry, action);
}
if (collection_manager_action_tail == collection_manager_action_list)
{
- collection_manager_action_tail = NULL;
+ collection_manager_action_tail = nullptr;
}
collection_manager_action_list = g_list_remove(collection_manager_action_list, action);
collect_manager_action_unref(action);
{
DEBUG_1("collection manager timer expired");
- g_idle_add_full(G_PRIORITY_LOW, collect_manager_process_cb, NULL, NULL);
+ g_idle_add_full(G_PRIORITY_LOW, collect_manager_process_cb, nullptr, nullptr);
collection_manager_timer_id = 0;
return FALSE;
if (!stop)
{
collection_manager_timer_id = g_timeout_add(COLLECT_MANAGER_FLUSH_DELAY,
- collect_manager_timer_cb, NULL);
+ collect_manager_timer_cb, nullptr);
DEBUG_1("collection manager timer started");
}
}
cw = collection_window_find_by_path(collection);
if (cw)
{
- if (collection_list_find_fd(cw->cd->list, fd) == NULL)
+ if (collection_list_find_fd(cw->cd->list, fd) == nullptr)
{
collection_add(cw->cd, fd, FALSE);
}
collect_manager_timer_push(TRUE);
DEBUG_1("collection manager flushing");
- while (collect_manager_process_cb(NULL));
+ while (collect_manager_process_cb(nullptr));
}
void collect_manager_notify_cb(FileData *fd, NotifyType type, gpointer UNUSED(data))
void collect_manager_list(GList **names_exc, GList **names_inc, GList **paths)
{
FileData *dir_fd;
- GList *list = NULL;
+ GList *list = nullptr;
gchar *name;
FileData *fd;
gchar *filename;
- if (names_exc == NULL && names_inc == NULL && paths == NULL)
+ if (names_exc == nullptr && names_inc == nullptr && paths == nullptr)
{
return;
}
dir_fd = file_data_new_dir((get_collections_dir()));
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
while (list)
{
{
name = remove_extension_from_path(filename);
- if (names_exc != NULL)
+ if (names_exc != nullptr)
{
*names_exc = g_list_insert_sorted(*names_exc, g_strdup(name),
collection_manager_sort_cb);
*names_exc = g_list_first(*names_exc);
}
- if (names_inc != NULL)
+ if (names_inc != nullptr)
{
*names_inc = g_list_insert_sorted(*names_inc,filename,
collection_manager_sort_cb);
*names_inc = g_list_first(*names_inc);
}
- if (paths != NULL)
+ if (paths != nullptr)
{
*paths = g_list_insert_sorted(*paths,fd->path,
collection_manager_sort_cb);
{static_cast<GdkModifierType>(0), 'B', N_("Sort by size")},
{static_cast<GdkModifierType>(0), 'P', N_("Sort by path")},
{GDK_SHIFT_MASK, 'P', N_("Print")},
- {static_cast<GdkModifierType>(0), 0, NULL}
+ {static_cast<GdkModifierType>(0), 0, nullptr}
};
/*
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ct->listview));
if (!collection_table_find_position(ct, info, &row, &col)) return FALSE;
- if (!gtk_tree_model_iter_nth_child(store, iter, NULL, row)) return FALSE;
+ if (!gtk_tree_model_iter_nth_child(store, iter, nullptr, row)) return FALSE;
if (column) *column = col;
return TRUE;
GtkTreeModel *store;
GtkTreeIter p;
- if (row < 0 || col < 0) return NULL;
+ if (row < 0 || col < 0) return nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ct->listview));
- if (gtk_tree_model_iter_nth_child(store, &p, NULL, row))
+ if (gtk_tree_model_iter_nth_child(store, &p, nullptr, row))
{
GList *list;
gtk_tree_model_get(store, &p, CTABLE_COLUMN_POINTER, &list, -1);
- if (!list) return NULL;
+ if (!list) return nullptr;
if (iter) *iter = p;
return static_cast<CollectInfo *>(g_list_nth_data(list, col));
}
- return NULL;
+ return nullptr;
}
static CollectInfo *collection_table_find_data_by_coord(CollectTable *ct, gint x, gint y, GtkTreeIter *iter)
gint n;
if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(ct->listview), x, y,
- &tpath, &column, NULL, NULL))
- return NULL;
+ &tpath, &column, nullptr, nullptr))
+ return nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ct->listview));
gtk_tree_model_get_iter(store, &row, tpath);
gtk_tree_path_free(tpath);
gtk_tree_model_get(store, &row, CTABLE_COLUMN_POINTER, &list, -1);
- if (!list) return NULL;
+ if (!list) return nullptr;
n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_number"));
if (iter) *iter = row;
{
GtkTreeIter row;
- if (collection_table_find_iter(ct, info, &row, NULL))
+ if (collection_table_find_iter(ct, info, &row, nullptr))
{
gtk_tree_model_get(store, &row, CTABLE_COLUMN_POINTER, &list, -1);
if (list) gtk_list_store_set(GTK_LIST_STORE(store), &row, CTABLE_COLUMN_POINTER, list, -1);
GList *work;
g_list_free(ct->selection);
- ct->selection = NULL;
+ ct->selection = nullptr;
work = ct->cd->list;
while (work)
{
ct->selection = g_list_append(ct->selection, work->data);
- collection_table_selection_add(ct, static_cast<CollectInfo *>(work->data), SELECTION_SELECTED, NULL);
+ collection_table_selection_add(ct, static_cast<CollectInfo *>(work->data), SELECTION_SELECTED, nullptr);
work = work->next;
}
work = ct->selection;
while (work)
{
- collection_table_selection_remove(ct, static_cast<CollectInfo *>(work->data), SELECTION_SELECTED, NULL);
+ collection_table_selection_remove(ct, static_cast<CollectInfo *>(work->data), SELECTION_SELECTED, nullptr);
work = work->next;
}
g_list_free(ct->selection);
- ct->selection = NULL;
+ ct->selection = nullptr;
collection_table_update_status(ct);
}
static void collection_table_select_invert_all(CollectTable *ct)
{
GList *work;
- GList *new_selection = NULL;
+ GList *new_selection = nullptr;
work = ct->cd->list;
while (work)
if (INFO_SELECTED(info))
{
- collection_table_selection_remove(ct, info, SELECTION_SELECTED, NULL);
+ collection_table_selection_remove(ct, info, SELECTION_SELECTED, nullptr);
}
else
{
new_selection = g_list_append(new_selection, info);
- collection_table_selection_add(ct, info, SELECTION_SELECTED, NULL);
+ collection_table_selection_add(ct, info, SELECTION_SELECTED, nullptr);
}
if (!info || INFO_SELECTED(info)) return;
ct->selection = g_list_append(ct->selection, info);
- collection_table_selection_add(ct, info, SELECTION_SELECTED, NULL);
+ collection_table_selection_add(ct, info, SELECTION_SELECTED, nullptr);
collection_table_update_status(ct);
}
if (!info || !INFO_SELECTED(info) ) return;
ct->selection = g_list_remove(ct->selection, info);
- collection_table_selection_remove(ct, info, SELECTION_SELECTED, NULL);
+ collection_table_selection_remove(ct, info, SELECTION_SELECTED, nullptr);
collection_table_update_status(ct);
}
if (work->data != end)
work = work->next;
else
- work = NULL;
+ work = nullptr;
}
return;
}
{
for (j = col1; j <= col2; j++)
{
- CollectInfo *info = collection_table_find_data(ct, i, j, NULL);
+ CollectInfo *info = collection_table_find_data(ct, i, j, nullptr);
if (info) collection_table_select_util(ct, info, select);
}
}
seat = gdk_display_get_default_seat(gdk_window_get_display(gtk_widget_get_window(ct->listview)));
device = gdk_seat_get_pointer(seat);
gdk_window_get_device_position(gtk_widget_get_window(ct->listview),
- device, &x, &y, NULL);
+ device, &x, &y, nullptr);
- ct->tip_info = collection_table_find_data_by_coord(ct, x, y, NULL);
+ ct->tip_info = collection_table_find_data_by_coord(ct, x, y, nullptr);
if (!ct->tip_info) return;
ct->tip_window = gtk_window_new(GTK_WINDOW_POPUP);
display = gdk_display_get_default();
seat = gdk_display_get_default_seat(display);
device = gdk_seat_get_pointer(seat);
- gdk_device_get_position(device, NULL, &x, &y);
+ gdk_device_get_position(device, nullptr, &x, &y);
if (!gtk_widget_get_realized(ct->tip_window)) gtk_widget_realize(ct->tip_window);
gtk_window_move(GTK_WINDOW(ct->tip_window), x + 16, y + 16);
static void tip_hide(CollectTable *ct)
{
if (ct->tip_window) gtk_widget_destroy(ct->tip_window);
- ct->tip_window = NULL;
+ ct->tip_window = nullptr;
}
static gboolean tip_schedule_cb(gpointer data)
if (ct->tip_window)
{
gint x, y;
- gdk_device_get_position(device, NULL, &x, &y);
+ gdk_device_get_position(device, nullptr, &x, &y);
gtk_window_move(GTK_WINDOW(ct->tip_window), x + 16, y + 16);
{
auto ct = static_cast<CollectTable *>(data);
- collection_dialog_save_as(NULL, ct->cd);
+ collection_dialog_save_as(nullptr, ct->cd);
}
static void collection_table_popup_save_cb(GtkWidget *widget, gpointer data)
static GList *collection_table_popup_file_list(CollectTable *ct)
{
- if (!ct->click_info) return NULL;
+ if (!ct->click_info) return nullptr;
if (INFO_SELECTED(ct->click_info))
{
return collection_table_selection_get_list(ct);
}
- return g_list_append(NULL, file_data_ref(ct->click_info->fd));
+ return g_list_append(nullptr, file_data_ref(ct->click_info->fd));
}
static void collection_table_popup_edit_cb(GtkWidget *widget, gpointer data)
if (!ct) return;
- file_util_start_editor_from_filelist(key, collection_table_popup_file_list(ct), NULL, ct->listview);
+ file_util_start_editor_from_filelist(key, collection_table_popup_file_list(ct), nullptr, ct->listview);
}
static void collection_table_popup_copy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto ct = static_cast<CollectTable *>(data);
- file_util_copy(NULL, collection_table_popup_file_list(ct), NULL, ct->listview);
+ file_util_copy(nullptr, collection_table_popup_file_list(ct), nullptr, ct->listview);
}
static void collection_table_popup_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto ct = static_cast<CollectTable *>(data);
- file_util_move(NULL, collection_table_popup_file_list(ct), NULL, ct->listview);
+ file_util_move(nullptr, collection_table_popup_file_list(ct), nullptr, ct->listview);
}
static void collection_table_popup_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto ct = static_cast<CollectTable *>(data);
- file_util_rename(NULL, collection_table_popup_file_list(ct), ct->listview);
+ file_util_rename(nullptr, collection_table_popup_file_list(ct), ct->listview);
}
static void collection_table_popup_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
auto ct = static_cast<CollectTable *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(NULL, collection_table_popup_file_list(ct), ct->listview);
+ file_util_delete(nullptr, collection_table_popup_file_list(ct), ct->listview);
}
static void collection_table_popup_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
auto ct = static_cast<CollectTable *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, collection_table_popup_file_list(ct), ct->listview);
+ file_util_delete(nullptr, collection_table_popup_file_list(ct), ct->listview);
}
static void collection_table_popup_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
if (ct->click_info && g_list_find(ct->cd->list, ct->click_info))
{
- layout_image_set_collection(NULL, ct->cd, ct->click_info);
+ layout_image_set_collection(nullptr, ct->cd, ct->click_info);
}
}
}
else
{
- list = g_list_append(NULL, ct->click_info);
+ list = g_list_append(nullptr, ct->click_info);
}
collection_remove_by_info_list(ct->cd, list);
{
auto ct = static_cast<CollectTable *>(data);
GList *list;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
if (!layout_valid(&lw)) return;
{
auto ct = static_cast<CollectTable *>(data);
- collection_dialog_append(NULL, ct->cd);
+ collection_dialog_append(nullptr, ct->cd);
}
static void collection_table_popup_goto_original_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto ct = static_cast<CollectTable *>(data);
GList *list;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
FileData *fd;
if (!layout_valid(&lw)) return;
auto ct = static_cast<CollectTable *>(data);
FileData *fd;
- fd = (ct->click_info) ? ct->click_info->fd : NULL;
+ fd = (ct->click_info) ? ct->click_info->fd : nullptr;
print_window_new(fd, collection_table_selection_get_list(ct), collection_table_get_list(ct), gtk_widget_get_toplevel(ct->listview));
}
{
auto ct = static_cast<CollectTable *>(data);
- collection_table_selection_remove(ct, ct->click_info, SELECTION_PRELIGHT, NULL);
- ct->click_info = NULL;
- ct->popup = NULL;
+ collection_table_selection_remove(ct, ct->click_info, SELECTION_PRELIGHT, nullptr);
+ ct->click_info = nullptr;
+ ct->popup = nullptr;
filelist_free(ct->drop_list);
- ct->drop_list = NULL;
- ct->drop_info = NULL;
+ ct->drop_list = nullptr;
+ ct->drop_info = nullptr;
filelist_free(ct->editmenu_fd_list);
- ct->editmenu_fd_list = NULL;
+ ct->editmenu_fd_list = nullptr;
}
static GtkWidget *collection_table_popup_menu(CollectTable *ct, gboolean over_icon)
G_CALLBACK(collection_table_popup_add_collection_cb), ct);
menu_item_add_divider(menu);
- item = menu_item_add(menu, _("_Selection"), NULL, NULL);
+ item = menu_item_add(menu, _("_Selection"), nullptr, nullptr);
submenu = gtk_menu_new();
menu_item_add(submenu, _("Select all"),
G_CALLBACK(collection_table_popup_selectall_cb), ct);
G_CALLBACK(collection_table_popup_delete_cb), ct);
menu_item_add_divider(menu);
- submenu = submenu_add_sort(NULL, G_CALLBACK(collection_table_popup_sort_cb), ct, FALSE, TRUE, FALSE, SORT_NONE);
+ submenu = submenu_add_sort(nullptr, G_CALLBACK(collection_table_popup_sort_cb), ct, FALSE, TRUE, FALSE, SORT_NONE);
menu_item_add_divider(submenu);
menu_item_add(submenu, _("Randomize"),
G_CALLBACK(collection_table_popup_randomize_cb), ct);
- item = menu_item_add(menu, _("_Sort"), NULL, NULL);
+ item = menu_item_add(menu, _("_Sort"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
menu_item_add_check(menu, _("Show filename _text"), ct->show_text,
&ct->focus_row, &ct->focus_column);
return;
}
- collection_table_selection_remove(ct, ct->focus_info, SELECTION_FOCUS, NULL);
+ collection_table_selection_remove(ct, ct->focus_info, SELECTION_FOCUS, nullptr);
}
if (!collection_table_find_position(ct, info, &row, &col))
{
- ct->focus_info = NULL;
+ ct->focus_info = nullptr;
ct->focus_row = -1;
ct->focus_column = -1;
return;
ct->focus_info = info;
ct->focus_row = row;
ct->focus_column = col;
- collection_table_selection_add(ct, ct->focus_info, SELECTION_FOCUS, NULL);
+ collection_table_selection_add(ct, ct->focus_info, SELECTION_FOCUS, nullptr);
- if (collection_table_find_iter(ct, ct->focus_info, &iter, NULL))
+ if (collection_table_find_iter(ct, ct->focus_info, &iter, nullptr))
{
GtkTreePath *tpath;
GtkTreeViewColumn *column;
new_row = new_col = 0;
}
- collection_table_set_focus(ct, collection_table_find_data(ct, new_row, new_col, NULL));
+ collection_table_set_focus(ct, collection_table_find_data(ct, new_row, new_col, nullptr));
}
static void collection_table_update_focus(CollectTable *ct)
focus_col = ct->columns - 1 - ct->focus_column;
break;
case GDK_KEY_space:
- info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, NULL);
+ info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, nullptr);
if (info)
{
ct->click_info = info;
break;
case GDK_KEY_Menu:
case GDK_KEY_F10:
- info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, NULL);
+ info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, nullptr);
ct->click_info = info;
- collection_table_selection_add(ct, ct->click_info, SELECTION_PRELIGHT, NULL);
+ collection_table_selection_add(ct, ct->click_info, SELECTION_PRELIGHT, nullptr);
tip_unschedule(ct);
- ct->popup = collection_table_popup_menu(ct, (info != NULL));
- gtk_menu_popup_at_widget(GTK_MENU(ct->popup), widget, GDK_GRAVITY_SOUTH, GDK_GRAVITY_CENTER, NULL);
+ ct->popup = collection_table_popup_menu(ct, (info != nullptr));
+ gtk_menu_popup_at_widget(GTK_MENU(ct->popup), widget, GDK_GRAVITY_SOUTH, GDK_GRAVITY_CENTER, nullptr);
break;
default:
CollectInfo *new_info;
CollectInfo *old_info;
- old_info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, NULL);
+ old_info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, nullptr);
collection_table_move_focus(ct, focus_row, focus_col, TRUE);
- new_info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, NULL);
+ new_info = collection_table_find_data(ct, ct->focus_row, ct->focus_column, nullptr);
if (new_info != old_info)
{
static CollectInfo *collection_table_insert_find(CollectTable *ct, CollectInfo *source, gboolean *after, GdkRectangle *cell,
gboolean use_coord, gint x, gint y)
{
- CollectInfo *info = NULL;
+ CollectInfo *info = nullptr;
GtkTreeModel *store;
GtkTreeIter iter;
GtkTreePath *tpath;
seat = gdk_display_get_default_seat(gdk_window_get_display(gtk_widget_get_window(ct->listview)));
device = gdk_seat_get_pointer(seat);
gdk_window_get_device_position(gtk_widget_get_window(ct->listview),
- device, &x, &y, NULL);
+ device, &x, &y, nullptr);
}
if (source)
}
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(ct->listview), x, y,
- &tpath, &column, NULL, NULL))
+ &tpath, &column, nullptr, nullptr))
{
GList *list;
gint n;
gtk_tree_path_free(tpath);
}
- if (info == NULL)
+ if (info == nullptr)
{
GList *work;
GdkRectangle cell;
gboolean after = FALSE;
- info = collection_table_insert_find(ct, NULL, &after, &cell, TRUE, x, y);
+ info = collection_table_insert_find(ct, nullptr, &after, &cell, TRUE, x, y);
if (info && after)
{
}
else
{
- info = NULL;
+ info = nullptr;
}
}
GdkRectangle cell;
GdkWindow *parent;
gint x_parent, y_parent;
- GError *error = NULL;
+ GError *error = nullptr;
GInputStream *in_stream;
GdkPixbuf *pb;
gchar *path;
if (!enable)
{
if (ct->marker_window) gdk_window_destroy(ct->marker_window);
- ct->marker_window = NULL;
+ ct->marker_window = nullptr;
return;
}
in_stream = g_resources_open_stream(path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
g_free(path);
- pb = gdk_pixbuf_new_from_stream(in_stream, NULL, &error);
+ pb = gdk_pixbuf_new_from_stream(in_stream, nullptr, &error);
g_object_unref(in_stream);
if (error)
attributes.event_mask = gtk_widget_get_events(ct->listview);
attributes_mask = 0;
- ct->marker_window = gdk_window_new(NULL, &attributes, attributes_mask);
+ ct->marker_window = gdk_window_new(nullptr, &attributes, attributes_mask);
cairo_region_t *mask;
cairo_pattern_t *pattern;
{
CollectInfo *info;
- info = collection_table_find_data_by_coord(ct, x, y, NULL);
+ info = collection_table_find_data_by_coord(ct, x, y, nullptr);
if (drop_event)
{
window = gtk_widget_get_window(ct->listview);
seat = gdk_display_get_default_seat(gdk_window_get_display(window));
device = gdk_seat_get_pointer(seat);
- gdk_window_get_device_position(window, device, &x, &y, NULL);
+ gdk_window_get_device_position(window, device, &x, &y, nullptr);
w = gdk_window_get_width(window);
h = gdk_window_get_height(window);
ct->drop_idle_id = 0;
}
widget_auto_scroll_stop(ct->listview);
- collection_table_insert_marker(ct, NULL, FALSE);
+ collection_table_insert_marker(ct, nullptr, FALSE);
}
else
{
{
if (info)
{
- layout_image_set_collection(NULL, ct->cd, info);
+ layout_image_set_collection(nullptr, ct->cd, info);
}
}
else if (!gtk_widget_has_focus(ct->listview))
}
break;
case MOUSE_BUTTON_RIGHT:
- ct->popup = collection_table_popup_menu(ct, (info != NULL));
- gtk_menu_popup_at_pointer(GTK_MENU(ct->popup), NULL);
+ ct->popup = collection_table_popup_menu(ct, (info != nullptr));
+ gtk_menu_popup_at_pointer(GTK_MENU(ct->popup), nullptr);
break;
default:
break;
{
auto ct = static_cast<CollectTable *>(data);
GtkTreeIter iter;
- CollectInfo *info = NULL;
+ CollectInfo *info = nullptr;
tip_schedule(ct);
if (ct->click_info)
{
- collection_table_selection_remove(ct, ct->click_info, SELECTION_PRELIGHT, NULL);
+ collection_table_selection_remove(ct, ct->click_info, SELECTION_PRELIGHT, nullptr);
}
if (bevent->button == MOUSE_BUTTON_LEFT &&
GtkTreeModel *store;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ct->listview));
- gtk_tree_model_foreach(store, collection_table_destroy_node_cb, NULL);
+ gtk_tree_model_foreach(store, collection_table_destroy_node_cb, nullptr);
gtk_list_store_clear(GTK_LIST_STORE(store));
}
static GList *collection_table_add_row(CollectTable *ct, GtkTreeIter *iter)
{
GtkListStore *store;
- GList *list = NULL;
+ GList *list = nullptr;
gint i;
- for (i = 0; i < ct->columns; i++) list = g_list_prepend(list, NULL);
+ for (i = 0; i < ct->columns; i++) list = g_list_prepend(list, nullptr);
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(ct->listview)));
gtk_list_store_append(store, iter);
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 = static_cast<GtkCellRenderer *>((list) ? list->data : NULL);
+ cell = static_cast<GtkCellRenderer *>((list) ? list->data : nullptr);
g_list_free(list);
if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
GList *list;
r++;
c = 0;
- if (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
+ if (gtk_tree_model_iter_nth_child(store, &iter, nullptr, r))
{
gtk_tree_model_get(store, &iter, CTABLE_COLUMN_POINTER, &list, -1);
gtk_list_store_set(GTK_LIST_STORE(store), &iter, CTABLE_COLUMN_POINTER, list, -1);
}
else
{
- info = NULL;
+ info = nullptr;
}
if (list)
{
}
r++;
- while (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
+ while (gtk_tree_model_iter_nth_child(store, &iter, nullptr, r))
{
GList *list;
/* high priority, the view needs to be resynced before a redraw
* may contain invalid pointers at this time
*/
- ct->sync_idle_id = g_idle_add_full(G_PRIORITY_HIGH, collection_table_sync_idle_cb, ct, NULL);
+ ct->sync_idle_id = g_idle_add_full(G_PRIORITY_HIGH, collection_table_sync_idle_cb, ct, nullptr);
}
}
static void collection_table_move_by_info_list(CollectTable *ct, GList *info_list, gint row, gint col)
{
GList *work;
- GList *insert_pos = NULL;
+ GList *insert_pos = nullptr;
GList *temp;
CollectInfo *info;
if (!info_list) return;
- info = collection_table_find_data(ct, row, col, NULL);
+ info = collection_table_find_data(ct, row, col, nullptr);
if (!info_list->next && info_list->data == info) return;
collection_table_update_extras(ct, TRUE, value);
- if (collection_table_find_iter(ct, info, &iter, NULL))
+ if (collection_table_find_iter(ct, info, &iter, nullptr))
{
GtkTreeModel *store;
GList *list;
GList *f;
GList *work;
- if (!filelist_read(dir_fd, &f, recursive ? &d : NULL))
+ if (!filelist_read(dir_fd, &f, recursive ? &d : nullptr))
return;
f = filelist_filter(f, FALSE);
g_signal_connect(G_OBJECT(menu), "destroy",
G_CALLBACK(collection_table_popup_destroy_cb), ct);
- menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, NULL, NULL);
+ menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, nullptr, nullptr);
menu_item_add_divider(menu);
menu_item_add_stock(menu, _("_Add contents"), GTK_STOCK_OK,
G_CALLBACK(confirm_dir_list_add), ct);
menu_item_add_stock(menu, _("_Skip folders"), GTK_STOCK_REMOVE,
G_CALLBACK(confirm_dir_list_skip), ct);
menu_item_add_divider(menu);
- menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, NULL, ct);
+ menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, nullptr, ct);
return menu;
}
{
auto ct = static_cast<CollectTable *>(data);
gboolean selected;
- GList *list = NULL;
- gchar *uri_text = NULL;
+ GList *list = nullptr;
+ gchar *uri_text = nullptr;
gint total;
if (!ct->click_info) return;
}
else
{
- list = g_list_append(NULL, ct->click_info);
+ list = g_list_append(nullptr, ct->click_info);
uri_text = collection_info_list_to_dnd_data(ct->cd, list, &total);
g_list_free(list);
}
}
else
{
- list = g_list_append(NULL, file_data_ref(ct->click_info->fd));
+ list = g_list_append(nullptr, file_data_ref(ct->click_info->fd));
}
if (!list) return;
guint UNUSED(time), gpointer data)
{
auto ct = static_cast<CollectTable *>(data);
- GList *list = NULL;
- GList *info_list = NULL;
+ GList *list = nullptr;
+ GList *info_list = nullptr;
CollectionData *source;
CollectInfo *drop_info;
GList *work;
DEBUG_1("%s", gtk_selection_data_get_data(selection_data));
collection_table_scroll(ct, FALSE);
- collection_table_insert_marker(ct, NULL, FALSE);
+ collection_table_insert_marker(ct, nullptr, FALSE);
drop_info = collection_table_insert_point(ct, x, y);
/* it is a move within a collection */
filelist_free(list);
- list = NULL;
+ list = nullptr;
if (!drop_info)
{
ct->drop_list = list;
ct->drop_info = drop_info;
menu = collection_table_drop_menu(ct);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
return;
}
work = work->next;
}
break;
default:
- list = NULL;
+ list = nullptr;
break;
}
CollectInfo *info;
GdkColor color_fg;
GdkColor color_bg;
- gchar *star_rating = NULL;
- gchar *display_text = NULL;
+ gchar *star_rating = nullptr;
+ gchar *display_text = nullptr;
ct = cd->ct;
if (ct->popup)
{
g_signal_handlers_disconnect_matched(G_OBJECT(ct->popup), G_SIGNAL_MATCH_DATA,
- 0, 0, 0, NULL, ct);
+ 0, 0, nullptr, nullptr, ct);
gtk_widget_destroy(ct->popup);
}
ct->show_text = options->show_icon_names;
ct->show_stars = options->show_star_rating;
- ct->scrolled = gtk_scrolled_window_new(NULL, NULL);
+ ct->scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(ct->scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ct->scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
CollectInfo *collection_table_get_focus_info(CollectTable *ct)
{
- return collection_table_find_data(ct, ct->focus_row, ct->focus_column, NULL);
+ return collection_table_find_data(ct, ct->focus_row, ct->focus_column, nullptr);
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
*
* Type ::_CollectionData
*/
-static GList *collection_list = NULL;
+static GList *collection_list = nullptr;
/**
* @brief List of currently open Collection windows.
*
* Type ::_CollectWindow
*/
-static GList *collection_window_list = NULL;
+static GList *collection_window_list = nullptr;
static void collection_window_get_geometry(CollectWindow *cw);
static void collection_window_refresh(CollectWindow *cw);
{
CollectInfo *ci;
- if (!fd) return NULL;
+ if (!fd) return nullptr;
ci = g_new0(CollectInfo, 1);
ci->fd = file_data_ref(fd);
void collection_info_free_thumb(CollectInfo *ci)
{
if (ci->pixbuf) g_object_unref(ci->pixbuf);
- ci->pixbuf = NULL;
+ ci->pixbuf = nullptr;
}
void collection_info_free(CollectInfo *ci)
GList *nlist, *olist;
length = g_list_length(list);
- if (!length) return NULL;
+ if (!length) return nullptr;
- srand(static_cast<unsigned int>(time(NULL))); // Initialize random generator (hasn't to be that much strong)
+ srand(static_cast<unsigned int>(time(nullptr))); // Initialize random generator (hasn't to be that much strong)
for (i = 0; i < length; i++)
{
work = work->next;
}
- return NULL;
+ return nullptr;
}
GList *collection_list_to_filelist(GList *list)
{
- GList *filelist = NULL;
+ GList *filelist = nullptr;
GList *work = list;
while (work)
work = work->next;
}
- return NULL;
+ return nullptr;
}
CollectWindow *collection_window_find_by_path(const gchar *path)
{
GList *work;
- if (!path) return NULL;
+ if (!path) return nullptr;
work = collection_window_list;
while (work)
work = work->next;
}
- return NULL;
+ return nullptr;
}
/**
*/
gchar *collection_path(const gchar *param)
{
- gchar *path = NULL;
- gchar *full_name = NULL;
+ gchar *path = nullptr;
+ gchar *full_name = nullptr;
if (file_extension_match(param, GQ_COLLECTION_EXT))
{
path = g_build_filename(get_collections_dir(), param, NULL);
}
- else if (file_extension_match(param, NULL))
+ else if (file_extension_match(param, nullptr))
{
full_name = g_strconcat(param, GQ_COLLECTION_EXT, NULL);
path = g_build_filename(get_collections_dir(), full_name, NULL);
if (!isfile(path))
{
g_free(path);
- path = NULL;
+ path = nullptr;
}
g_free(full_name);
*/
gboolean is_collection(const gchar *param)
{
- gchar *name = NULL;
+ gchar *name = nullptr;
name = collection_path(param);
if (name)
CollectionData *cd;
CollectInfo *ci;
GList *work;
- GList *list = NULL;
+ GList *list = nullptr;
if (is_collection(name))
{
cd->sort_method = SORT_NONE;
cd->window_w = COLLECT_DEF_WIDTH;
cd->window_h = COLLECT_DEF_HEIGHT;
- cd->existence = g_hash_table_new(NULL, NULL);
+ cd->existence = g_hash_table_new(nullptr, nullptr);
if (path)
{
gint collection_number;
const gchar *ptr;
- if (list) *list = NULL;
- if (info_list) *info_list = NULL;
+ if (list) *list = nullptr;
+ if (info_list) *info_list = nullptr;
- if (strncmp(data, "COLLECTION:", 11) != 0) return NULL;
+ if (strncmp(data, "COLLECTION:", 11) != 0) return nullptr;
ptr = data + 11;
collection_number = atoi(ptr);
cd = collection_from_number(collection_number);
- if (!cd) return NULL;
+ if (!cd) return nullptr;
if (!list && !info_list) return cd;
gchar *collection_info_list_to_dnd_data(CollectionData *cd, GList *list, gint *length)
{
GList *work;
- GList *temp = NULL;
+ GList *temp = nullptr;
gchar *ptr;
gchar *text;
gchar *uri_text;
gint collection_number;
*length = 0;
- if (!list) return NULL;
+ if (!list) return nullptr;
collection_number = collection_to_number(cd);
- if (collection_number < 0) return NULL;
+ if (collection_number < 0) return nullptr;
text = g_strdup_printf("COLLECTION:%d\n", collection_number);
*length += strlen(text);
work = g_list_find(cd->list, info);
- if (!work) return NULL;
+ if (!work) return nullptr;
work = work->next;
if (work) return static_cast<CollectInfo *>(work->data);
- return NULL;
+ return nullptr;
}
CollectInfo *collection_prev_by_info(CollectionData *cd, CollectInfo *info)
work = g_list_find(cd->list, info);
- if (!work) return NULL;
+ if (!work) return nullptr;
work = work->prev;
if (work) return static_cast<CollectInfo *>(work->data);
- return NULL;
+ return nullptr;
}
CollectInfo *collection_get_first(CollectionData *cd)
{
if (cd->list) return static_cast<CollectInfo *>(cd->list->data);
- return NULL;
+ return nullptr;
}
CollectInfo *collection_get_last(CollectionData *cd)
if (list) return static_cast<CollectInfo *>(list->data);
- return NULL;
+ return nullptr;
}
void collection_set_sort_method(CollectionData *cd, SortType method)
{
CollectInfo *ci;
- if (g_hash_table_lookup(cd->existence, fd->path)) return NULL;
+ if (g_hash_table_lookup(cd->existence, fd->path)) return nullptr;
- ci = collection_info_new(fd, st, NULL);
+ ci = collection_info_new(fd, st, nullptr);
if (ci) g_hash_table_insert(cd->existence, fd->path, g_strdup(""));
return ci;
}
if (!info || !g_list_find(cd->list, info)) return;
cd->list = g_list_remove(cd->list, info);
- cd->changed = (cd->list != NULL);
+ cd->changed = (cd->list != nullptr);
collection_window_remove(collection_window_find(cd), info);
collection_info_free(info);
cd->list = collection_list_remove(cd->list, static_cast<CollectInfo *>(work->data));
work = work->next;
}
- cd->changed = (cd->list != NULL);
+ cd->changed = (cd->list != nullptr);
collection_window_refresh(collection_window_find(cd));
}
}
break;
case 'L': case 'l':
- list = layout_list(NULL);
+ list = layout_list(nullptr);
if (list)
{
collection_table_add_filelist(cw->table, list);
}
break;
case 'C': case 'c':
- file_util_copy(NULL, collection_table_selection_get_list(cw->table), NULL, cw->window);
+ file_util_copy(nullptr, collection_table_selection_get_list(cw->table), nullptr, cw->window);
break;
case 'M': case 'm':
- file_util_move(NULL, collection_table_selection_get_list(cw->table), NULL, cw->window);
+ file_util_move(nullptr, collection_table_selection_get_list(cw->table), nullptr, cw->window);
break;
case 'R': case 'r':
- file_util_rename(NULL, collection_table_selection_get_list(cw->table), cw->window);
+ file_util_rename(nullptr, collection_table_selection_get_list(cw->table), cw->window);
break;
case 'D': case 'd':
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, collection_table_selection_get_list(cw->table), cw->window);
+ file_util_delete(nullptr, collection_table_selection_get_list(cw->table), cw->window);
break;
case 'S': case 's':
- collection_dialog_save_as(NULL, cw->cd);
+ collection_dialog_save_as(nullptr, cw->cd);
break;
case 'W': case 'w':
collection_window_close(cw);
switch (event->keyval)
{
case GDK_KEY_Return: case GDK_KEY_KP_Enter:
- layout_image_set_collection(NULL, cw->cd,
+ layout_image_set_collection(nullptr, cw->cd,
collection_table_get_focus_info(cw->table));
break;
case 'V': case 'v':
case 'S': case 's':
if (!cw->cd->path)
{
- collection_dialog_save_as(NULL, cw->cd);
+ collection_dialog_save_as(nullptr, cw->cd);
}
else if (!collection_save(cw->cd, cw->cd->path))
{
}
break;
case 'A': case 'a':
- collection_dialog_append(NULL, cw->cd);
+ collection_dialog_append(nullptr, cw->cd);
break;
case 'N': case 'n':
collection_set_sort_method(cw->cd, SORT_NAME);
if (!cw) return;
collection_table_file_update(cw->table, ci);
- collection_table_file_update(cw->table, NULL);
+ collection_table_file_update(cw->table, nullptr);
}
static void collection_window_close_final(CollectWindow *cw)
gtk_widget_destroy(cw->window);
- collection_set_update_info_func(cw->cd, NULL, NULL);
+ collection_set_update_info_func(cw->cd, nullptr, nullptr);
collection_unref(cw->cd);
g_free(cw);
{
auto cw = static_cast<CollectWindow *>(data);
- cw->close_dialog = NULL;
+ cw->close_dialog = nullptr;
generic_dialog_close(gd);
if (!cw->cd->path)
{
- collection_dialog_save_close(NULL, cw->cd);
+ collection_dialog_save_close(nullptr, cw->cd);
return;
}
else if (!collection_save(cw->cd, cw->cd->path))
{
auto cw = static_cast<CollectWindow *>(data);
- cw->close_dialog = NULL;
+ cw->close_dialog = nullptr;
generic_dialog_close(gd);
collection_window_close_final(cw);
{
auto cw = static_cast<CollectWindow *>(data);
- cw->close_dialog = NULL;
+ cw->close_dialog = nullptr;
generic_dialog_close(gd);
}
_("Close collection"),
_("Collection has been modified.\nSave first?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_SAVE, NULL, collection_close_save_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_SAVE, nullptr, collection_close_save_cb, TRUE);
generic_dialog_add_button(gd, GTK_STOCK_DELETE, _("_Discard"), collection_close_close_cb, FALSE);
cw->close_dialog = gd->dialog;
cw->cd = collection_new(path);
- cw->window = window_new(GTK_WINDOW_TOPLEVEL, "collection", PIXBUF_INLINE_ICON_BOOK, NULL, NULL);
+ cw->window = window_new(GTK_WINDOW_TOPLEVEL, "collection", PIXBUF_INLINE_ICON_BOOK, nullptr, nullptr);
DEBUG_NAME(cw->window);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = COLLECT_DEF_WIDTH;
geometry.base_height = COLLECT_DEF_HEIGHT;
- gtk_window_set_geometry_hints(GTK_WINDOW(cw->window), NULL, &geometry,
+ gtk_window_set_geometry_hints(GTK_WINDOW(cw->window), nullptr, &geometry,
static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE));
if (options->collections_on_top)
gtk_box_pack_start(GTK_BOX(vbox), cw->status_box, FALSE, FALSE, 0);
gtk_widget_show(cw->status_box);
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(cw->status_box), frame, TRUE, TRUE, 0);
collection_set_update_info_func(cw->cd, collection_window_update_info, cw);
- if (path && *path == G_DIR_SEPARATOR) collection_load_begin(cw->cd, NULL, COLLECTION_LOAD_NONE);
+ if (path && *path == G_DIR_SEPARATOR) collection_load_begin(cw->cd, nullptr, COLLECTION_LOAD_NONE);
return cw;
}
guchar *UNUSED(screen_data), guint UNUSED(screen_data_len))
{
/* no op */
- return NULL;
+ return nullptr;
}
ColorMan *color_man_new_embedded(ImageWindow *UNUSED(imd), GdkPixbuf *UNUSED(pixbuf),
guchar *UNUSED(screen_data), guint UNUSED(screen_data_len))
{
/* no op */
- return NULL;
+ return nullptr;
}
void color_man_free(ColorMan *UNUSED(cm))
guchar *heif_color_profile(FileData *UNUSED(fd), guint *UNUSED(profile_len))
{
- return NULL;
+ return nullptr;
}
#endif /* define HAVE_LCMS */
/*
* Logging functions
*/
-static gchar *regexp = NULL;
+static gchar *regexp = nullptr;
static gboolean log_msg_cb(gpointer data)
{
ret_comp = regcomp(®ex, regexp, 0);
if (!ret_comp)
{
- ret_exec = regexec(®ex, buf_nl, 0, NULL, 0);
+ ret_exec = regexec(®ex, buf_nl, 0, nullptr, 0);
if (!ret_exec)
{
struct timeval tv = {0, 0};
static struct timeval delta = {0, 0};
- gettimeofday(&tv, NULL);
+ gettimeofday(&tv, nullptr);
if (start_tv.tv_sec == 0) start_tv = tv;
gchar *address_offset;
gchar *cmd_line;
gchar *exe_path;
- gchar *function_name = NULL;
+ gchar *function_name = nullptr;
gchar *paren_end;
gchar *paren_start;
gint bt_size;
cmd_line = g_strconcat("addr2line -p -f -C -e ", gq_executable_path, " ", address_offset, NULL);
fp = popen(cmd_line, "r");
- if (fp == NULL)
+ if (fp == nullptr)
{
log_printf("Failed to run command: %s", cmd_line);
}
else
{
- while (fgets(path, sizeof(path), fp) != NULL)
+ while (fgets(path, sizeof(path), fp) != nullptr)
{
/* Remove redundant newline */
path[strlen(path) - 1] = '\0';
- if (g_strstr_len(path, strlen(path), "(") != NULL)
+ if (g_strstr_len(path, strlen(path), "(") != nullptr)
{
function_name = g_strndup(path, g_strstr_len(path, strlen(path), "(") - path);
}
gchar *path;
};
-static EditorListWindow *editor_list_window = NULL;
+static EditorListWindow *editor_list_window = nullptr;
static gboolean editor_window_save(EditorWindow *ew)
{
gchar *path;
gchar *text;
GtkTextIter start, end;
- GError *error = NULL;
+ GError *error = nullptr;
gboolean ret = TRUE;
const gchar *name = gtk_entry_get_text(GTK_ENTRY(ew->entry));
if (!name || !name[0])
{
- file_util_warning_dialog(_("Can't save"), _("Please specify file name."), GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Can't save"), _("Please specify file name."), GTK_STOCK_DIALOG_ERROR, nullptr);
return FALSE;
}
if (!recursive_mkdir_if_not_exists(dir, 0755))
{
- file_util_warning_dialog(_("Can't save"), _("Could not create directory"), GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Can't save"), _("Could not create directory"), GTK_STOCK_DIALOG_ERROR, nullptr);
ret = FALSE;
}
if (ret && !g_file_set_contents(path, text, -1, &error))
{
- file_util_warning_dialog(_("Can't save"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Can't save"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
g_error_free(error);
ret = FALSE;
}
ew = g_new0(EditorWindow, 1);
- ew->window = window_new(GTK_WINDOW_TOPLEVEL, "Desktop", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Desktop file"));
+ ew->window = window_new(GTK_WINDOW_TOPLEVEL, "Desktop", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Desktop file"));
DEBUG_NAME(ew->window);
gtk_window_set_type_hint(GTK_WINDOW(ew->window), GDK_WINDOW_TYPE_HINT_DIALOG);
ew->entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), ew->entry, TRUE, TRUE, 0);
- ew->desktop_name = NULL;
+ ew->desktop_name = nullptr;
if (desktop_name)
{
gtk_entry_set_text(GTK_ENTRY(ew->entry), desktop_name);
gtk_box_pack_end(GTK_BOX(hbox), button_hbox, FALSE, FALSE, 0);
gtk_widget_show(button_hbox);
- ew->save_button = pref_button_new(NULL, GTK_STOCK_SAVE, NULL, FALSE,
+ ew->save_button = pref_button_new(nullptr, GTK_STOCK_SAVE, nullptr, FALSE,
G_CALLBACK(editor_window_save_cb), ew);
gtk_container_add(GTK_CONTAINER(button_hbox), ew->save_button);
gtk_widget_set_can_default(ew->save_button, TRUE);
gtk_widget_show(ew->save_button);
ct_button = ew->save_button;
- button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_CLOSE, nullptr, FALSE,
G_CALLBACK(editor_window_close_cb), ew);
gtk_container_add(GTK_CONTAINER(button_hbox), button);
gtk_widget_set_can_default(button, TRUE);
}
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show(text_view);
ew->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
- if (g_file_get_contents(src_path, &text, &size, NULL))
+ if (g_file_get_contents(src_path, &text, &size, nullptr))
{
gtk_text_buffer_set_text(ew->buffer, text, size);
}
{
gtk_widget_destroy(editor_list_window->window);
g_free(editor_list_window);
- editor_list_window = NULL;
+ editor_list_window = nullptr;
}
static gboolean editor_list_window_delete(GtkWidget *UNUSED(widget), GdkEventAny *UNUSED(event), gpointer UNUSED(data))
{
- editor_list_window_close_cb(NULL, NULL);
+ editor_list_window_close_cb(nullptr, nullptr);
return TRUE;
}
{
auto ewdl = static_cast<EditorWindowDel_Data *>(data);
- ewdl->ewl->gd = NULL;
+ ewdl->ewl->gd = nullptr;
g_free(ewdl->path);
g_free(ewdl);
}
if (!unlink_file(ewdl->path))
{
gchar *text = g_strdup_printf(_("Unable to delete file:\n%s"), ewdl->path);
- warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_WARNING, nullptr);
g_free(text);
}
else
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
GtkTreeIter iter;
- if (gtk_tree_selection_get_selected(sel, NULL, &iter))
+ if (gtk_tree_selection_get_selected(sel, nullptr, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
gchar *path;
}
ewl->gd = generic_dialog_new(_("Delete file"), "dlg_confirm",
- NULL, TRUE,
+ nullptr, TRUE,
editor_list_window_delete_dlg_cancel, ewdl);
- generic_dialog_add_button(ewl->gd, GTK_STOCK_DELETE, NULL, editor_list_window_delete_dlg_ok_cb, TRUE);
+ generic_dialog_add_button(ewl->gd, GTK_STOCK_DELETE, nullptr, editor_list_window_delete_dlg_ok_cb, TRUE);
text = g_strdup_printf(_("About to delete the file:\n %s"), path);
generic_dialog_add_message(ewl->gd, GTK_STOCK_DIALOG_QUESTION,
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
GtkTreeIter iter;
- if (gtk_tree_selection_get_selected(sel, NULL, &iter))
+ if (gtk_tree_selection_get_selected(sel, nullptr, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
gchar *path;
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
GtkTreeIter iter;
- if (gtk_tree_selection_get_selected(sel, NULL, &iter))
+ if (gtk_tree_selection_get_selected(sel, nullptr, &iter))
{
GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
gchar *path;
editor_list_window = ewl = g_new0(EditorListWindow, 1);
- ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Plugins"));
+ ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Plugins"));
DEBUG_NAME(ewl->window);
gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(ewl->window), "delete_event",
gtk_widget_show(hbox);
- button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
G_CALLBACK(editor_list_window_help_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_NEW, nullptr, FALSE,
G_CALLBACK(editor_list_window_new_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_EDIT, nullptr, FALSE,
G_CALLBACK(editor_list_window_edit_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
ewl->edit_button = button;
- button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_DELETE, nullptr, FALSE,
G_CALLBACK(editor_list_window_delete_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
ewl->delete_button = button;
- button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_CLOSE, nullptr, FALSE,
G_CALLBACK(editor_list_window_close_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
G_CALLBACK(plugin_disable_cb), ewl);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, plugin_disable_set_func,
- NULL, NULL);
+ nullptr, nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_DISABLED);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb,
- GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL);
+ GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), nullptr);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb,
- GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL);
+ GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), nullptr);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb,
- GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL);
+ GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), nullptr);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb,
- GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL);
+ GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), nullptr);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_DISABLED, editor_list_window_sort_cb,
- GINT_TO_POINTER(DESKTOP_FILE_COLUMN_DISABLED), NULL);
+ GINT_TO_POINTER(DESKTOP_FILE_COLUMN_DISABLED), nullptr);
/* set initial sort order */
gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_NAME, GTK_SORT_ASCENDING);
GdkPixbuf *dest;
gint w, h;
gint sw, sh;
- PangoLayout *layout = NULL;
+ PangoLayout *layout = nullptr;
gint x, y;
x = y = 0;
gchar *buf;
gint lw,lh;
- layout = gtk_widget_create_pango_layout(widget, NULL);
+ layout = gtk_widget_create_pango_layout(widget, nullptr);
buf = g_strdup_printf("<small> %d </small>", items);
pango_layout_set_markup(layout, buf, -1);
g_free(buf);
if (layout)
{
- pixbuf_draw_layout(dest, layout, NULL, x+1, y+1, 0, 0, 0, 255);
- pixbuf_draw_layout(dest, layout, NULL, x, y, 255, 255, 255, 255);
+ pixbuf_draw_layout(dest, layout, nullptr, x+1, y+1, 0, 0, 0, 255);
+ pixbuf_draw_layout(dest, layout, nullptr, x, y, 255, 255, 255, 255);
g_object_unref(G_OBJECT(layout));
}
};
static DupeMatchType param_match_mask;
-static GList *dupe_window_list = NULL; /**< list of open DupeWindow *s */
+static GList *dupe_window_list = nullptr; /**< list of open DupeWindow *s */
/*
* Well, after adding the 'compare two sets' option things got a little sloppy in here
{static_cast<GdkModifierType>(0), '0', N_("Select none")},
{static_cast<GdkModifierType>(0), '1', N_("Select group 1 duplicates")},
{static_cast<GdkModifierType>(0), '2', N_("Select group 2 duplicates")},
- {static_cast<GdkModifierType>(0), 0, NULL}
+ {static_cast<GdkModifierType>(0), 0, nullptr}
};
/**
auto dw = static_cast<DupeWindow *>(d2);
DupeSearchMatch *dsm;
DupeItem *di;
- GList *matches = NULL;
+ GList *matches = nullptr;
gdouble rank = 0;
if (!dw->abort)
{
struct timeval tv;
- if (gettimeofday(&tv, NULL) == -1) return 0;
+ if (gettimeofday(&tv, nullptr) == -1) return 0;
return static_cast<guint64>(tv.tv_sec) * 1000000 + static_cast<guint64>(tv.tv_usec);
}
}
else
{
- status_text = NULL;
+ status_text = nullptr;
}
}
else
if (icon == -1)
{
- cursor = NULL;
+ cursor = nullptr;
}
else
{
GtkTreeModel *store;
GtkTreeIter iter;
gboolean color_set = TRUE;
- DupeItem *parent = NULL;
+ DupeItem *parent = nullptr;
gboolean valid;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
if (!di->simd && cd->sim)
{
di->simd = cd->sim;
- cd->sim = NULL;
+ cd->sim = nullptr;
}
if (di->width == 0 && di->height == 0 && cd->dimensions)
{
CacheData *cd;
cd = cache_sim_data_new();
- cd->path = cache_get_location(CACHE_TYPE_SIM, di->fd->path, TRUE, NULL);
+ cd->path = cache_get_location(CACHE_TYPE_SIM, di->fd->path, TRUE, nullptr);
if (di->width != 0) cache_sim_data_set_dimensions(cd, di->width, di->height);
if (di->md5sum)
text[DUPE_COLUMN_DIMENSIONS] = g_strdup("");
}
text[DUPE_COLUMN_PATH] = di->fd->path;
- text[DUPE_COLUMN_COLOR] = NULL;
+ text[DUPE_COLUMN_COLOR] = nullptr;
gtk_list_store_insert(store, &iter, row);
gtk_list_store_set(store, &iter,
auto parent = static_cast<DupeItem *>(work->data);
GList *temp;
- dupe_listview_add(dw, parent, NULL);
+ dupe_listview_add(dw, parent, nullptr);
temp = g_list_last(parent->group);
while (temp)
tree_view_move_cursor_away(GTK_TREE_VIEW(dw->listview), &iter, TRUE);
gtk_list_store_remove(store, &iter);
- if (g_list_find(dw->dupes, di) != NULL)
+ if (g_list_find(dw->dupes, di) != nullptr)
{
if (!dw->color_frozen) dupe_listview_realign_colors(dw);
}
GtkTreeModel *store;
GtkTreeIter iter;
gboolean valid;
- GList *list = NULL;
+ GList *list = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
valid = gtk_tree_model_get_iter_first(store, &iter);
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
while (work)
{
auto tpath = static_cast<GtkTreePath *>(work->data);
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
GtkTreeIter iter;
gtk_tree_model_get_iter(store, &iter, tpath);
}
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return g_list_reverse(list);
if (di_n == di) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return found;
if (dm->di == child) return dm;
work = work->next;
}
- return NULL;
+ return nullptr;
}
/**
}
g_list_free(parent->group);
- parent->group = NULL;
+ parent->group = nullptr;
parent->group_rank = 0.0;
}
*/
static gint dupe_match_link_exists(DupeItem *child, DupeItem *parent)
{
- return (dupe_match_find_match(child, parent) != NULL);
+ return (dupe_match_find_match(child, parent) != nullptr);
}
/**
DupeMatch *dr;
GList *work;
- dr = NULL;
+ dr = nullptr;
work = child->group;
while (work)
{
work = work->next;
}
- return (dr) ? dr->di : NULL;
+ return (dr) ? dr->di : nullptr;
}
/**
work = work->next;
}
- return NULL;
+ return nullptr;
}
/**
}
new_parent->group = old_parent->group;
- old_parent->group = NULL;
+ old_parent->group = nullptr;
work = g_list_find(dw->dupes, old_parent);
if (work) work->data = new_parent;
*/
static GList *dupe_match_unlink_by_rank(DupeItem *child, DupeItem *parent, GList *list, DupeWindow *dw)
{
- DupeItem *best = NULL;
+ DupeItem *best = nullptr;
best = dupe_match_highest_rank(parent); // highest rank in parent->group
if (best == child || dupe_match_highest_rank(child) == parent)
*/
static GList *dupe_match_rank_sort(GList *source_list)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
work = source_list;
for (i_set1 = 0; i_set1 <= static_cast<gint>(array_set1->len) - 1; i_set1++)
{
auto di1 = static_cast<DupeItem *>(g_array_index(array_set1, gpointer, i_set1));
- DupeItem *di2 = NULL;
+ DupeItem *di2 = nullptr;
/* If multiple identical entries in set 1, use the last one */
if (i_set1 < static_cast<gint>(array_set1->len) - 2)
{
{
/* File set 1 only */
g_list_free(dw->dupes);
- dw->dupes = NULL;
+ dw->dupes = nullptr;
if (static_cast<gint>(array_set1->len) > 1)
{
dqi->dw = dw;
dqi->work = work;
dqi->index = dw->queue_count;
- g_thread_pool_push(dw->dupe_comparison_thread_pool, dqi, NULL);
+ g_thread_pool_push(dw->dupe_comparison_thread_pool, dqi, nullptr);
}
/*
if (di->pixbuf) g_object_unref(di->pixbuf);
di->pixbuf = thumb_loader_get_pixbuf(dw->thumb_loader);
- dupe_listview_set_thumb(dw, di, NULL);
+ dupe_listview_set_thumb(dw, di, nullptr);
}
static void dupe_thumb_error_cb(ThumbLoader *UNUSED(tl), gpointer data)
{
GtkTreeModel *store;
GtkTreeIter iter;
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
gboolean valid;
gint row = 0;
gint length = 0;
{
if (!pixbuf) gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, di->pixbuf, -1);
row++;
- di = NULL;
+ di = nullptr;
}
valid = gtk_tree_model_iter_next(store, &iter);
}
if (!di)
{
- dw->thumb_item = NULL;
+ dw->thumb_item = nullptr;
thumb_loader_free(dw->thumb_loader);
- dw->thumb_loader = NULL;
+ dw->thumb_loader = nullptr;
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
return;
}
thumb_loader_set_callbacks(dw->thumb_loader,
dupe_thumb_done_cb,
dupe_thumb_error_cb,
- NULL,
+ nullptr,
dw);
/* start it */
while (dw->thread_count < dw->queue_count) // Wait for the queue to empty
{
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
widget_set_cursor(dw->listview, -1);
}
g_list_free(dw->search_matches);
- dw->search_matches = NULL;
+ dw->search_matches = nullptr;
if (dw->idle_id || dw->img_loader || dw->thumb_loader)
{
g_source_remove(dw->idle_id);
dw->idle_id = 0;
}
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
widget_set_cursor(dw->listview, -1);
}
{
filelist_free(dw->add_files_queue);
}
- dw->add_files_queue = NULL;
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dw->add_files_queue = nullptr;
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
widget_set_cursor(dw->listview, -1);
}
thumb_loader_free(dw->thumb_loader);
- dw->thumb_loader = NULL;
+ dw->thumb_loader = nullptr;
image_loader_free(dw->img_loader);
- dw->img_loader = NULL;
+ dw->img_loader = nullptr;
}
static void dupe_check_stop_cb(GtkWidget *UNUSED(widget), gpointer data)
}
image_loader_free(dw->img_loader);
- dw->img_loader = NULL;
+ dw->img_loader = nullptr;
dw->idle_id = g_idle_add(dupe_check_cb, dw);
}
static void dupe_setup_reset(DupeWindow *dw)
{
- dw->setup_point = NULL;
+ dw->setup_point = nullptr;
dw->setup_n = 0;
dw->setup_time = msec_time();
dw->setup_time_count = 0;
static GList *dupe_setup_point_step(DupeWindow *dw, GList *p)
{
- if (!p) return NULL;
+ if (!p) return nullptr;
if (p->next) return p->next;
if (dw->second_set && g_list_first(p) == dw->list) return dw->second_list;
- return NULL;
+ return nullptr;
}
/**
image_sim_free(di->simd);
di->simd = image_sim_new();
image_loader_free(dw->img_loader);
- dw->img_loader = NULL;
+ dw->img_loader = nullptr;
return G_SOURCE_CONTINUE;
}
dw->idle_id = 0;
return G_SOURCE_CONTINUE;
}
- if (dw->search_matches_sorted == NULL)
+ if (dw->search_matches_sorted == nullptr)
{
dw->search_matches_sorted = g_list_sort(dw->search_matches, sort_func);
dupe_setup_reset(dw);
dw->search_matches_sorted = dw->search_matches_sorted->next;
- if (dw->search_matches_sorted != NULL)
+ if (dw->search_matches_sorted != nullptr)
{
return G_SOURCE_CONTINUE;
}
}
g_list_free(dw->search_matches);
- dw->search_matches = NULL;
+ dw->search_matches = nullptr;
g_list_free(dw->search_matches_sorted);
- dw->search_matches_sorted = NULL;
+ dw->search_matches_sorted = nullptr;
dw->setup_count = 0;
}
else
}
dw->idle_id = 0;
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
dupe_match_rank(dw);
dupe_window_update_count(dw, FALSE);
/* This is the comparison for all other parameters.
* dupe_array_check() processes the entire list in one go
*/
- dw->working = NULL;
+ dw->working = nullptr;
dupe_window_update_progress(dw, _("Comparing..."), 0.0, FALSE);
dupe_array_check(dw);
}
widget_set_cursor(dw->listview, GDK_WATCH);
dw->queue_count = 0;
dw->thread_count = 0;
- dw->search_matches_sorted = NULL;
+ dw->search_matches_sorted = nullptr;
dw->abort = FALSE;
if (dw->idle_id) return;
if (dw->img_loader)
{
image_loader_free(dw->img_loader);
- dw->img_loader = NULL;
+ dw->img_loader = nullptr;
dw->idle_id = g_idle_add(dupe_check_cb, dw);
}
}
static gboolean dupe_files_add_queue_cb(gpointer data)
{
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
auto dw = static_cast<DupeWindow *>(data);
FileData *fd;
GList *queue = dw->add_files_queue;
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(dw->extra_label));
- if (queue == NULL)
+ if (queue == nullptr)
{
dw->add_files_queue_id = 0;
dupe_destroy_list_cache(dw);
dw->list = g_list_prepend(dw->list, di);
}
- if (dw->add_files_queue != NULL)
+ if (dw->add_files_queue != nullptr)
{
return TRUE;
}
static void dupe_files_add(DupeWindow *dw, CollectionData *UNUSED(collection), CollectInfo *info,
FileData *fd, gboolean recurse)
{
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
if (info)
{
work = f;
while (work)
{
- dupe_files_add(dw, NULL, NULL, static_cast<FileData *>(work->data), TRUE);
+ dupe_files_add(dw, nullptr, nullptr, static_cast<FileData *>(work->data), TRUE);
work = work->next;
}
filelist_free(f);
work = d;
while (work)
{
- dupe_files_add(dw, NULL, NULL, static_cast<FileData *>(work->data), TRUE);
+ dupe_files_add(dw, nullptr, nullptr, static_cast<FileData *>(work->data), TRUE);
work = work->next;
}
filelist_free(d);
dw->list_cache = g_hash_table_new(g_direct_hash, g_direct_equal);
dw->second_list_cache = g_hash_table_new(g_direct_hash, g_direct_equal);
- for (GList *i = dw->list; i != NULL; i = i->next)
+ for (GList *i = dw->list; i != nullptr; i = i->next)
{
auto 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)
+ for (GList *i = dw->second_list; i != nullptr; i = i->next)
{
auto di = static_cast<DupeItem *>(i->data);
dw->second_drop ? dw->second_list_cache : dw->list_cache;
/* We do this as a lookup + add as we don't want to overwrite
items as that would leak the old value. */
- if (g_hash_table_lookup(table, fd) != NULL)
+ if (g_hash_table_lookup(table, fd) != nullptr)
return FALSE;
return g_hash_table_add(table, fd);
}
info = collection_get_first(collection);
while (info)
{
- dupe_files_add(dw, collection, info, NULL, FALSE);
+ dupe_files_add(dw, collection, info, nullptr, FALSE);
info = collection_next_by_info(collection, info);
}
gd = file_util_gen_dlg("Image thumbprint debug info", "thumbprint",
dw->window, TRUE,
- NULL, NULL);
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
+ nullptr, nullptr);
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr, nullptr, TRUE);
dupe_display_label(gd->vbox, "name:", di->fd->name);
buf = text_from_size(di->fd->size);
gtk_list_store_clear(store);
g_list_free(dw->dupes);
- dw->dupes = NULL;
+ dw->dupes = nullptr;
dupe_match_reset_list(dw->list);
dupe_match_reset_list(dw->second_list);
}
else
{
- layout_image_set_collection(NULL, di->collection, di->info);
+ layout_image_set_collection(nullptr, di->collection, di->info);
}
}
else
}
else
{
- layout_set_fd(NULL, di->fd);
+ layout_set_fd(nullptr, di->fd);
}
}
}
GtkTreeModel *store;
GtkTreeIter iter;
GList *slist;
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
while (work)
{
auto tpath = static_cast<GtkTreePath *>(work->data);
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
if (di) list = g_list_prepend(list, di);
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
dw->color_frozen = TRUE;
static void dupe_window_edit_selected(DupeWindow *dw, const gchar *key)
{
- file_util_start_editor_from_filelist(key, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
+ file_util_start_editor_from_filelist(key, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
}
static void dupe_window_collection_from_selection(DupeWindow *dw)
GList *list;
list = dupe_listview_get_selection(dw, dw->listview);
- w = collection_window_new(NULL);
+ w = collection_window_new(nullptr);
collection_table_add_filelist(w->table, list);
filelist_free(list);
}
dw->second_drop = (dw->second_set && on_second);
- list = layout_list(NULL);
+ list = layout_list(nullptr);
dupe_window_add_files(dw, list, FALSE);
filelist_free(list);
}
auto dw = static_cast<DupeWindow *>(data);
FileData *fd;
- fd = (dw->click_item) ? dw->click_item->fd : NULL;
+ fd = (dw->click_item) ? dw->click_item->fd : nullptr;
print_window_new(fd,
dupe_listview_get_selection(dw, dw->listview),
{
auto dw = static_cast<DupeWindow *>(data);
- file_util_copy(NULL, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
+ file_util_copy(nullptr, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
}
static void dupe_menu_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto dw = static_cast<DupeWindow *>(data);
- file_util_move(NULL, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
+ file_util_move(nullptr, dupe_listview_get_selection(dw, dw->listview), nullptr, dw->window);
}
static void dupe_menu_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto dw = static_cast<DupeWindow *>(data);
- file_util_rename(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window);
+ file_util_rename(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window);
}
static void dupe_menu_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
auto dw = static_cast<DupeWindow *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete_notify_done(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
+ file_util_delete_notify_done(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
}
static void dupe_menu_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
auto dw = static_cast<DupeWindow *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete_notify_done(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
+ file_util_delete_notify_done(nullptr, dupe_listview_get_selection(dw, dw->listview), dw->window, delete_finished_cb, dw);
}
static void dupe_menu_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
GList *editmenu_fd_list;
GtkAccelGroup *accel_group;
- on_row = (di != NULL);
+ on_row = (di != nullptr);
menu = popup_menu_short_lived();
menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, on_row,
G_CALLBACK(dupe_menu_viewnew_cb), dw);
menu_item_add_divider(menu);
- menu_item_add_sensitive(menu, _("Select all"), (dw->dupes != NULL),
+ menu_item_add_sensitive(menu, _("Select all"), (dw->dupes != nullptr),
G_CALLBACK(dupe_menu_select_all_cb), dw);
- menu_item_add_sensitive(menu, _("Select none"), (dw->dupes != NULL),
+ menu_item_add_sensitive(menu, _("Select none"), (dw->dupes != nullptr),
G_CALLBACK(dupe_menu_select_none_cb), dw);
- menu_item_add_sensitive(menu, _("Select group _1 duplicates"), (dw->dupes != NULL),
+ menu_item_add_sensitive(menu, _("Select group _1 duplicates"), (dw->dupes != nullptr),
G_CALLBACK(dupe_menu_select_dupes_set1_cb), dw);
- menu_item_add_sensitive(menu, _("Select group _2 duplicates"), (dw->dupes != NULL),
+ menu_item_add_sensitive(menu, _("Select group _2 duplicates"), (dw->dupes != nullptr),
G_CALLBACK(dupe_menu_select_dupes_set2_cb), dw);
menu_item_add_divider(menu);
menu_item_add_divider(menu);
menu_item_add_stock_sensitive(menu, _("Rem_ove"), GTK_STOCK_REMOVE, on_row,
G_CALLBACK(dupe_menu_remove_cb), dw);
- menu_item_add_stock_sensitive(menu, _("C_lear"), GTK_STOCK_CLEAR, (dw->list != NULL),
+ menu_item_add_stock_sensitive(menu, _("C_lear"), GTK_STOCK_CLEAR, (dw->list != nullptr),
G_CALLBACK(dupe_menu_clear_cb), dw);
menu_item_add_divider(menu);
menu_item_add_stock(menu, _("Close _window"), GTK_STOCK_CLOSE,
GtkTreeModel *store;
GtkTreePath *tpath;
GtkTreeIter iter;
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
{
menu = dupe_menu_popup_second(dw, di);
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
if (!di) return FALSE;
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
GtkTreeModel *store;
GtkTreePath *tpath;
GtkTreeIter iter;
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
if ((bevent->x != 0 || bevent->y != 0) &&
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
return TRUE;
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->second_listview));
g_list_free(dw->dupes);
- dw->dupes = NULL;
+ dw->dupes = nullptr;
dupe_list_free(dw->second_list);
- dw->second_list = NULL;
+ dw->second_list = nullptr;
dupe_match_reset_list(dw->list);
static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di)
{
GtkWidget *menu;
- gboolean notempty = (dw->second_list != NULL);
- gboolean on_row = (di != NULL);
+ gboolean notempty = (dw->second_list != nullptr);
+ gboolean on_row = (di != nullptr);
GtkAccelGroup *accel_group;
menu = popup_menu_short_lived();
static GdkColor *dupe_listview_color_shifted(GtkWidget *widget)
{
static GdkColor color;
- static GtkWidget *done = NULL;
+ static GtkWidget *done = nullptr;
if (done != widget)
{
if (listview == dw->listview)
{
/* sets background before rendering */
- gtk_tree_view_column_set_cell_data_func(column, renderer, dupe_listview_color_cb, dw, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, dupe_listview_color_cb, dw, nullptr);
}
gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);
gboolean valid;
thumb_loader_free(dw->thumb_loader);
- dw->thumb_loader = NULL;
+ dw->thumb_loader = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
valid = gtk_tree_model_get_iter_first(store, &iter);
gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, NULL, -1);
valid = gtk_tree_model_iter_next(store, &iter);
}
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
}
dupe_listview_set_height(dw->listview, dw->show_thumbs);
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
- DupeItem *di = NULL;
+ DupeItem *di = nullptr;
on_second = gtk_widget_has_focus(dw->second_listview);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
if (event->state & GDK_CONTROL_MASK)
case '0':
break;
case 'C': case 'c':
- file_util_copy(NULL, dupe_listview_get_selection(dw, listview),
- NULL, dw->window);
+ file_util_copy(nullptr, dupe_listview_get_selection(dw, listview),
+ nullptr, dw->window);
break;
case 'M': case 'm':
- file_util_move(NULL, dupe_listview_get_selection(dw, listview),
- NULL, dw->window);
+ file_util_move(nullptr, dupe_listview_get_selection(dw, listview),
+ nullptr, dw->window);
break;
case 'R': case 'r':
- file_util_rename(NULL, dupe_listview_get_selection(dw, listview), dw->window);
+ file_util_rename(nullptr, dupe_listview_get_selection(dw, listview), dw->window);
break;
case 'D': case 'd':
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, dupe_listview_get_selection(dw, listview), dw->window);
+ file_util_delete(nullptr, dupe_listview_get_selection(dw, listview), dw->window);
break;
default:
stop_signal = FALSE;
GtkWidget *menu;
menu = dupe_menu_popup_main(dw, di);
- gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
}
else
{
GtkWidget *menu;
menu = dupe_menu_popup_second(dw, di);
- gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
}
break;
default:
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->listview));
g_list_free(dw->dupes);
- dw->dupes = NULL;
+ dw->dupes = nullptr;
dupe_list_free(dw->list);
- dw->list = NULL;
+ dw->list = nullptr;
dw->set_count = 0;
dupe_match_reset_list(dw->second_list);
dupe_window_update_count(dw, FALSE);
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
}
static void dupe_window_get_geometry(DupeWindow *dw)
{
GdkWindow *window;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
GtkListStore *store;
GtkTreeSelection *selection;
GdkGeometry geometry;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
dw = g_new0(DupeWindow, 1);
- dw->add_files_queue = NULL;
+ dw->add_files_queue = nullptr;
dw->add_files_queue_id = 0;
dw->match_mask = DUPE_MATCH_NAME;
if (options->duplicates_match == DUPE_MATCH_NAME_CI_CONTENT) dw->match_mask = DUPE_MATCH_NAME_CI_CONTENT;
if (options->duplicates_match == DUPE_MATCH_ALL) dw->match_mask = DUPE_MATCH_ALL;
- dw->window = window_new(GTK_WINDOW_TOPLEVEL, "dupe", NULL, NULL, _("Find duplicates"));
+ dw->window = window_new(GTK_WINDOW_TOPLEVEL, "dupe", nullptr, nullptr, _("Find duplicates"));
DEBUG_NAME(dw->window);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = DUPE_DEF_WIDTH;
geometry.base_height = DUPE_DEF_HEIGHT;
- gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), NULL, &geometry,
+ gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), nullptr, &geometry,
static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE));
if (lw && options->save_window_positions)
gtk_box_pack_start(GTK_BOX(vbox), dw->table, TRUE, TRUE, 0);
gtk_widget_show(dw->table);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_table_attach_defaults(GTK_TABLE(dw->table), scrolled, 0, 2, 0, 1);
dw->sortable = GTK_TREE_SORTABLE(store);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_RANK, column_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SET, default_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_THUMB, default_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_NAME, column_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SIZE, column_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DATE, column_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DIMENSIONS, column_sort_cb, dw->sortable, NULL);
- gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_PATH, column_sort_cb, dw->sortable, NULL);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_RANK, column_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SET, default_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_THUMB, default_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_NAME, column_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_SIZE, column_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DATE, column_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_DIMENSIONS, column_sort_cb, dw->sortable, nullptr);
+ gtk_tree_sortable_set_sort_func(dw->sortable, DUPE_COLUMN_PATH, column_sort_cb, dw->sortable, nullptr);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
gtk_table_set_col_spacings(GTK_TABLE(dw->table), 0);
}
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(dw->second_vbox), scrolled, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
gtk_widget_show(status_box);
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(status_box), frame, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(button_box), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
- button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE, G_CALLBACK(dupe_help_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE, G_CALLBACK(dupe_help_cb), nullptr);
gtk_widget_set_tooltip_text(GTK_WIDGET(button), "F1");
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_STOP, NULL, FALSE, G_CALLBACK(dupe_check_stop_cb), dw);
+ button = pref_button_new(nullptr, GTK_STOCK_STOP, nullptr, FALSE, G_CALLBACK(dupe_check_stop_cb), dw);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(dupe_window_close_cb), dw);
+ button = pref_button_new(nullptr, GTK_STOCK_CLOSE, nullptr, FALSE, G_CALLBACK(dupe_window_close_cb), dw);
gtk_widget_set_tooltip_text(GTK_WIDGET(button), "Ctrl-W");
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
g_signal_emit_by_name(G_OBJECT(dw->combo), "changed");
dupe_window_update_count(dw, TRUE);
- dupe_window_update_progress(dw, NULL, 0.0, FALSE);
+ dupe_window_update_progress(dw, nullptr, 0.0, FALSE);
dupe_window_list = g_list_append(dupe_window_list, dw);
g_mutex_init(&dw->thread_count_mutex);
g_mutex_init(&dw->search_matches_mutex);
- dw->dupe_comparison_thread_pool = g_thread_pool_new(dupe_comparison_func, dw, options->threads.duplicates, FALSE, NULL);
+ dw->dupe_comparison_thread_pool = g_thread_pool_new(dupe_comparison_func, dw, options->threads.duplicates, FALSE, nullptr);
return dw;
}
{
GList *list;
- filelist_read(fd, &list, NULL);
+ filelist_read(fd, &list, nullptr);
list = filelist_filter(list, FALSE);
if (list)
{
g_signal_connect(G_OBJECT(menu), "destroy",
G_CALLBACK(confirm_dir_list_destroy), d);
- menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, NULL, NULL);
+ menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, nullptr, nullptr);
menu_item_add_divider(menu);
menu_item_add_stock(menu, _("_Add contents"), GTK_STOCK_OK, G_CALLBACK(confirm_dir_list_add), d);
menu_item_add_stock(menu, _("Add contents _recursive"), GTK_STOCK_ADD, G_CALLBACK(confirm_dir_list_recurse), d);
{
auto dw = static_cast<DupeWindow *>(data);
GtkWidget *source;
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
if (dw->add_files_queue_id > 0)
switch (info)
{
case TARGET_APP_COLLECTION_MEMBER:
- collection_from_dnd_data(reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)), &list, NULL);
+ collection_from_dnd_data(reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)), &list, nullptr);
break;
case TARGET_URI_LIST:
list = uri_filelist_from_gtk_selection_data(selection_data);
{
GtkWidget *menu;
menu = dupe_confirm_dir_list(dw, list);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
return;
}
work = work->next;
}
break;
default:
- list = NULL;
+ list = nullptr;
break;
}
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
}
static void export_duplicates_close(ExportDupesData *edd)
{
if (edd->dialog) file_dialog_close(edd->dialog);
- edd->dialog = NULL;
+ edd->dialog = nullptr;
}
static void export_duplicates_data_cancel_cb(FileDialog *UNUSED(fdlg), gpointer data)
static void export_duplicates_data_save_cb(FileDialog *fdlg, gpointer data)
{
auto edd = static_cast<ExportDupesData *>(data);
- GError *error = NULL;
+ GError *error = nullptr;
GtkTreeModel *store;
GtkTreeIter iter;
DupeItem *di;
out_file = g_file_new_for_path(fdlg->dest_path);
- gfstream = g_file_replace(out_file, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &error);
+ gfstream = g_file_replace(out_file, nullptr, TRUE, G_FILE_CREATE_NONE, nullptr, &error);
if (error)
{
log_printf(_("Error creating Export duplicates data file: Error: %s\n"), error->message);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_RANK, &rank, -1);
rank_split = g_strsplit_set(rank, " [(", -1);
- if (rank_split[0] == NULL)
+ if (rank_split[0] == nullptr)
{
output_string = g_string_append(output_string, "");
}
work = work->next;
}
- g_output_stream_write(G_OUTPUT_STREAM(gfstream), output_string->str, strlen(output_string->str), NULL, &error);
+ g_output_stream_write(G_OUTPUT_STREAM(gfstream), output_string->str, strlen(output_string->str), nullptr, &error);
g_free(sep);
g_string_free(output_string, TRUE);
const gchar *previous_path;
edd = g_new0(ExportDupesData, 1);
- edd->dialog = file_util_file_dlg(title, "export_duplicates", NULL, export_duplicates_data_cancel_cb, edd);
+ edd->dialog = file_util_file_dlg(title, "export_duplicates", nullptr, export_duplicates_data_cancel_cb, edd);
switch (index)
{
stock_id = GTK_STOCK_SAVE;
- generic_dialog_add_message(GENERIC_DIALOG(edd->dialog), NULL, title, NULL, FALSE);
- file_dialog_add_button(edd->dialog, stock_id, NULL, export_duplicates_data_save_cb, TRUE);
+ generic_dialog_add_message(GENERIC_DIALOG(edd->dialog), nullptr, title, nullptr, FALSE);
+ file_dialog_add_button(edd->dialog, stock_id, nullptr, export_duplicates_data_save_cb, TRUE);
previous_path = history_list_find_last_path_by_key("export_duplicates");
GtkWidget *item;
GtkWidget *submenu;
- item = menu_item_add(menu, _("_Export"), NULL, NULL);
+ item = menu_item_add(menu, _("_Export"), nullptr, nullptr);
submenu = gtk_menu_new();
g_object_set_data(G_OBJECT(submenu), "submenu_data", data);
*-----------------------------------------------------------------------------
*/
-GHashTable *editors = NULL;
+GHashTable *editors = nullptr;
GtkListStore *desktop_file_list;
gboolean editors_finished = FALSE;
{"image/x-x3f", ".x3f"},
{"application/x-navi-animation", ".ani"},
{"application/x-ptoptimizer-script", ".pto"},
- {NULL, NULL}};
+ {nullptr, nullptr}};
gint i, j;
- GList *list = NULL;
+ GList *list = nullptr;
for (i = 0; mime_types[i]; i++)
for (j = 0; conv_table[j][0]; j++)
if (g_hash_table_lookup(editors, key)) return FALSE; /* the file found earlier wins */
key_file = g_key_file_new();
- if (!g_key_file_load_from_file(key_file, path, static_cast<GKeyFileFlags>(0), NULL))
+ if (!g_key_file_load_from_file(key_file, path, static_cast<GKeyFileFlags>(0), nullptr))
{
g_key_file_free(key_file);
return FALSE;
}
- type = g_key_file_get_string(key_file, DESKTOP_GROUP, "Type", NULL);
+ type = g_key_file_get_string(key_file, DESKTOP_GROUP, "Type", nullptr);
if (!type || strcmp(type, "Application") != 0)
{
/* We only consider desktop entries of Application type */
g_hash_table_insert(editors, editor->key, editor);
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Hidden", NULL)
- || g_key_file_get_boolean(key_file, DESKTOP_GROUP, "NoDisplay", NULL))
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Hidden", nullptr)
+ || g_key_file_get_boolean(key_file, DESKTOP_GROUP, "NoDisplay", nullptr))
{
editor->hidden = TRUE;
}
- categories = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "Categories", NULL, NULL);
+ categories = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "Categories", nullptr, nullptr);
if (categories)
{
gboolean found = FALSE;
editor->ignored = TRUE;
}
- only_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "OnlyShowIn", NULL, NULL);
+ only_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "OnlyShowIn", nullptr, nullptr);
if (only_show_in)
{
gboolean found = FALSE;
g_strfreev(only_show_in);
}
- not_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "NotShowIn", NULL, NULL);
+ not_show_in = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "NotShowIn", nullptr, nullptr);
if (not_show_in)
{
gboolean found = FALSE;
}
- try_exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "TryExec", NULL);
+ try_exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "TryExec", nullptr);
if (try_exec && !editor->hidden && !editor->ignored)
{
gchar *try_exec_res = g_find_program_in_path(try_exec);
return TRUE;
}
- editor->name = g_key_file_get_locale_string(key_file, DESKTOP_GROUP, "Name", NULL, NULL);
- editor->icon = g_key_file_get_string(key_file, DESKTOP_GROUP, "Icon", NULL);
+ editor->name = g_key_file_get_locale_string(key_file, DESKTOP_GROUP, "Name", nullptr, nullptr);
+ editor->icon = g_key_file_get_string(key_file, DESKTOP_GROUP, "Icon", nullptr);
/* Icon key can be either a full path (absolute with file name extension) or an icon name (without extension) */
if (editor->icon && !g_path_is_absolute(editor->icon))
if (editor->icon && !register_theme_icon_as_stock(editor->key, editor->icon))
{
g_free(editor->icon);
- editor->icon = NULL;
+ editor->icon = nullptr;
}
- editor->exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "Exec", NULL);
+ editor->exec = g_key_file_get_string(key_file, DESKTOP_GROUP, "Exec", nullptr);
- editor->menu_path = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Menu-Path", NULL);
+ editor->menu_path = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Menu-Path", nullptr);
if (!editor->menu_path) editor->menu_path = g_strdup("PluginsMenu");
- editor->hotkey = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Hotkey", NULL);
+ editor->hotkey = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-Hotkey", nullptr);
- editor->comment = g_key_file_get_string(key_file, DESKTOP_GROUP, "Comment", NULL);
+ editor->comment = g_key_file_get_string(key_file, DESKTOP_GROUP, "Comment", nullptr);
- extensions = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-File-Extensions", NULL);
+ extensions = g_key_file_get_string(key_file, DESKTOP_GROUP, "X-Geeqie-File-Extensions", nullptr);
if (extensions)
editor->ext_list = filter_to_list(extensions);
else
{
- gchar **mime_types = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "MimeType", NULL, NULL);
+ gchar **mime_types = g_key_file_get_string_list(key_file, DESKTOP_GROUP, "MimeType", nullptr, nullptr);
if (mime_types)
{
editor->ext_list = editor_mime_types_to_extensions(mime_types);
}
}
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Keep-Fullscreen", NULL)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_KEEP_FS);
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose", NULL)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_VERBOSE);
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose-Multi", NULL)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_VERBOSE_MULTI);
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Filter", NULL)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_DEST);
- if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Terminal", NULL)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_TERMINAL);
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Keep-Fullscreen", nullptr)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_KEEP_FS);
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose", nullptr)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_VERBOSE);
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Verbose-Multi", nullptr)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_VERBOSE_MULTI);
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "X-Geeqie-Filter", nullptr)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_DEST);
+ if (g_key_file_get_boolean(key_file, DESKTOP_GROUP, "Terminal", nullptr)) editor->flags = static_cast<EditorFlags>(editor->flags | EDITOR_TERMINAL);
- editor->flags = static_cast<EditorFlags>(editor->flags | editor_command_parse(editor, NULL, FALSE, NULL));
+ editor->flags = static_cast<EditorFlags>(editor->flags | editor_command_parse(editor, nullptr, FALSE, nullptr));
if ((editor->flags & EDITOR_NO_PARAM) && !category_geeqie) editor->hidden = TRUE;
void editor_table_finish(void)
{
- g_hash_table_foreach_remove(editors, editor_remove_desktop_file_cb, NULL);
+ g_hash_table_foreach_remove(editors, editor_remove_desktop_file_cb, nullptr);
editors_finished = TRUE;
}
{
g_hash_table_destroy(editors);
}
- editors = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, reinterpret_cast<GDestroyNotify>(editor_description_free));
+ editors = g_hash_table_new_full(g_str_hash, g_str_equal, nullptr, reinterpret_cast<GDestroyNotify>(editor_description_free));
editors_finished = FALSE;
}
/* dir not found */
return list;
}
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
gchar *namel = dir->d_name;
gchar *all_dirs;
gchar **split_dirs;
gint i;
- GList *list = NULL;
+ GList *list = nullptr;
xdg_data_dirs = getenv("XDG_DATA_DIRS");
if (xdg_data_dirs && xdg_data_dirs[0])
GList *editor_list_get(void)
{
- GList *editors_list = NULL;
+ GList *editors_list = nullptr;
- if (!editors_finished) return NULL;
+ if (!editors_finished) return nullptr;
g_hash_table_foreach(editors, editor_list_add_cb, &editors_list);
editors_list = g_list_sort(editors_list, editor_sort);
{
if (!ed->vd) return;
g_free(ed->vd);
- ed->vd = NULL;
+ ed->vd = nullptr;
}
static void editor_data_free(EditorData *ed)
vd = g_new0(EditorVerboseData, 1);
vd->gd = file_util_gen_dlg(_("Edit command results"), "editor_results",
- NULL, FALSE,
- NULL, ed);
+ nullptr, FALSE,
+ nullptr, ed);
buf = g_strdup_printf(_("Output of %s"), text);
- generic_dialog_add_message(vd->gd, NULL, buf, NULL, FALSE);
+ generic_dialog_add_message(vd->gd, nullptr, buf, nullptr, FALSE);
g_free(buf);
//~ vd->button_stop = generic_dialog_add_button(vd->gd, GTK_STOCK_STOP, NULL,
//~ editor_verbose_window_stop, FALSE);
- vd->button_stop = generic_dialog_add_button(vd->gd, "process-stop", NULL,
+ vd->button_stop = generic_dialog_add_button(vd->gd, "process-stop", nullptr,
editor_verbose_window_stop, FALSE);
gtk_widget_set_sensitive(vd->button_stop, FALSE);
- vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, NULL,
+ vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, nullptr,
editor_verbose_window_close, TRUE);
gtk_widget_set_sensitive(vd->button_close, FALSE);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(vd->progress), TRUE);
gtk_widget_show(vd->progress);
- vd->spinner = spinner_new(NULL, SPINNER_SPEED);
+ vd->spinner = spinner_new(nullptr, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0);
gtk_widget_show(vd->spinner);
if (condition & G_IO_IN)
{
- while (g_io_channel_read_chars(source, buf, sizeof(buf), &count, NULL) == G_IO_STATUS_NORMAL)
+ while (g_io_channel_read_chars(source, buf, sizeof(buf), &count, nullptr) == G_IO_STATUS_NORMAL)
{
- if (!g_utf8_validate(buf, count, NULL))
+ if (!g_utf8_validate(buf, count, nullptr))
{
gchar *utf8;
- utf8 = g_locale_to_utf8(buf, count, NULL, NULL, NULL);
+ utf8 = g_locale_to_utf8(buf, count, nullptr, nullptr, nullptr);
if (utf8)
{
editor_verbose_window_fill(ed->vd, utf8, -1);
if (condition & (G_IO_ERR | G_IO_HUP))
{
- g_io_channel_shutdown(source, TRUE, NULL);
+ g_io_channel_shutdown(source, TRUE, nullptr);
return FALSE;
}
{
GString *string;
gchar *pathl;
- const gchar *p = NULL;
+ const gchar *p = nullptr;
DEBUG_2("editor_command_path_parse: %s %d %d %s", fd->path, consider_sidecars, type, editor->key);
break;
}
- work2 = consider_sidecars ? fd->sidecar_files : NULL;
+ work2 = consider_sidecars ? fd->sidecar_files : nullptr;
while (work2)
{
auto sfd = static_cast<FileData *>(work2->data);
}
if (p) break;
}
- if (!p) return NULL;
+ if (!p) return nullptr;
}
}
else if (type == PATH_DEST)
if (pathl && !pathl[0]) /* empty string case */
{
g_free(pathl);
- pathl = NULL;
+ pathl = nullptr;
}
DEBUG_2("editor_command_path_parse: return %s", pathl);
{
auto flags = static_cast<EditorFlags>(0);
const gchar *p;
- GString *result = NULL;
+ GString *result = nullptr;
gboolean escape = FALSE;
gboolean single_quotes = FALSE;
gboolean double_quotes = FALSE;
if (output)
result = g_string_new("");
- if (editor->exec == NULL || editor->exec[0] == '\0')
+ if (editor->exec == nullptr || editor->exec[0] == '\0')
{
flags = static_cast<EditorFlags>(flags | EDITOR_ERROR_EMPTY);
goto err;
}
else if (*p == '%' && p[1])
{
- gchar *pathl = NULL;
+ gchar *pathl = nullptr;
p++;
if (output)
{
g_string_free(result, TRUE);
- *output = NULL;
+ *output = nullptr;
}
return flags;
}
static EditorFlags editor_command_one(const EditorDescription *editor, GList *list, EditorData *ed)
{
gchar *command;
- auto fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? NULL : list->data);;
+ auto fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? nullptr : list->data);;
GPid pid;
gint standard_output;
gint standard_error;
if (options->shell.options && *options->shell.options)
args[n++] = options->shell.options;
args[n++] = command;
- args[n] = NULL;
+ args[n] = nullptr;
if ((ed->flags & EDITOR_DEST) && fd && fd->change && fd->change->dest) /** @FIXME error handling */
{
g_unsetenv("GEEQIE_DESTINATION");
}
- ok = g_spawn_async_with_pipes(working_directory, args, NULL,
+ ok = g_spawn_async_with_pipes(working_directory, args, nullptr,
G_SPAWN_DO_NOT_REAP_CHILD, /* GSpawnFlags */
- NULL, NULL,
+ nullptr, nullptr,
&pid,
- NULL,
- ed->vd ? &standard_output : NULL,
- ed->vd ? &standard_error : NULL,
- NULL);
+ nullptr,
+ ed->vd ? &standard_output : nullptr,
+ ed->vd ? &standard_error : nullptr,
+ nullptr);
g_free(working_directory);
GIOChannel *channel_error;
channel_output = g_io_channel_unix_new(standard_output);
- g_io_channel_set_flags(channel_output, G_IO_FLAG_NONBLOCK, NULL);
- g_io_channel_set_encoding(channel_output, NULL, NULL);
+ g_io_channel_set_flags(channel_output, G_IO_FLAG_NONBLOCK, nullptr);
+ g_io_channel_set_encoding(channel_output, nullptr, nullptr);
g_io_add_watch_full(channel_output, G_PRIORITY_HIGH, static_cast<GIOCondition>(G_IO_IN | G_IO_ERR | G_IO_HUP),
- editor_verbose_io_cb, ed, NULL);
+ editor_verbose_io_cb, ed, nullptr);
g_io_add_watch_full(channel_output, G_PRIORITY_HIGH, static_cast<GIOCondition>(G_IO_IN | G_IO_ERR | G_IO_HUP),
- editor_verbose_io_cb, ed, NULL);
+ editor_verbose_io_cb, ed, nullptr);
g_io_channel_unref(channel_output);
channel_error = g_io_channel_unix_new(standard_error);
- g_io_channel_set_flags(channel_error, G_IO_FLAG_NONBLOCK, NULL);
- g_io_channel_set_encoding(channel_error, NULL, NULL);
+ g_io_channel_set_flags(channel_error, G_IO_FLAG_NONBLOCK, nullptr);
+ g_io_channel_set_encoding(channel_error, nullptr, nullptr);
g_io_add_watch_full(channel_error, G_PRIORITY_HIGH, static_cast<GIOCondition>(G_IO_IN | G_IO_ERR | G_IO_HUP),
- editor_verbose_io_cb, ed, NULL);
+ editor_verbose_io_cb, ed, nullptr);
g_io_channel_unref(channel_error);
}
}
FileData *fd;
EditorFlags error;
- fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? NULL : ed->list->data);
+ fd = static_cast<FileData *>((ed->flags & EDITOR_NO_PARAM) ? nullptr : ed->list->data);
if (ed->vd)
{
error = editor_command_one(ed->editor, ed->list, ed);
if (!error && ed->vd)
{
- gtk_widget_set_sensitive(ed->vd->button_stop, (ed->list != NULL) );
+ gtk_widget_set_sensitive(ed->vd->button_stop, (ed->list != nullptr) );
if ((ed->flags & EDITOR_FOR_EACH) && fd)
{
editor_verbose_window_fill(ed->vd, fd->path, strlen(fd->path));
ed->list = g_list_remove_link(ed->list, fd_element);
if (ed->callback)
{
- cont = ed->callback(ed->list ? ed : NULL, ed->flags, fd_element, ed->data);
+ cont = ed->callback(ed->list ? ed : nullptr, ed->flags, fd_element, ed->data);
if (ed->stopping && cont == EDITOR_CB_CONTINUE) cont = EDITOR_CB_SKIP;
}
filelist_free(fd_element);
{
/* handle whole list */
if (ed->callback)
- cont = ed->callback(NULL, ed->flags, ed->list, ed->data);
+ cont = ed->callback(nullptr, ed->flags, ed->list, ed->data);
filelist_free(ed->list);
- ed->list = NULL;
+ ed->list = nullptr;
}
switch (cont)
if (ed->list)
{
ed->flags = static_cast<EditorFlags>(ed->flags | EDITOR_ERROR_SKIPPED);
- if (ed->callback) ed->callback(NULL, ed->flags, ed->list, ed->data);
+ if (ed->callback) ed->callback(nullptr, ed->flags, ed->list, ed->data);
filelist_free(ed->list);
- ed->list = NULL;
+ ed->list = nullptr;
}
ed->count = 0;
gboolean is_valid_editor_command(const gchar *key)
{
if (!key) return FALSE;
- return g_hash_table_lookup(editors, key) != NULL;
+ return g_hash_table_lookup(editors, key) != nullptr;
}
EditorFlags start_editor_from_filelist_full(const gchar *key, GList *list, const gchar *working_directory, EditorCallback cb, gpointer data)
if (!editor) return EDITOR_ERROR_EMPTY;
if (!list && !(editor->flags & EDITOR_NO_PARAM)) return EDITOR_ERROR_NO_FILE;
- error = editor_command_parse(editor, list, TRUE, NULL);
+ error = editor_command_parse(editor, list, TRUE, nullptr);
if (EDITOR_ERRORS(error)) return error;
{
gchar *text = g_strdup_printf(_("%s\n\"%s\""), editor_get_error_str(error), editor->file);
- file_util_warning_dialog(_("Invalid editor command"), text, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Invalid editor command"), text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
}
EditorFlags start_editor_from_filelist(const gchar *key, GList *list)
{
- return start_editor_from_filelist_full(key, list, NULL, NULL, NULL);
+ return start_editor_from_filelist_full(key, list, nullptr, nullptr, nullptr);
}
EditorFlags start_editor_from_file_full(const gchar *key, FileData *fd, EditorCallback cb, gpointer data)
if (!fd) return static_cast<EditorFlags>(FALSE);
- list = g_list_append(NULL, fd);
- error = start_editor_from_filelist_full(key, list, NULL, cb, data);
+ list = g_list_append(nullptr, fd);
+ error = start_editor_from_filelist_full(key, list, nullptr, cb, data);
g_list_free(list);
return error;
}
EditorFlags start_editor_from_file(const gchar *key, FileData *fd)
{
- return start_editor_from_file_full(key, fd, NULL, NULL);
+ return start_editor_from_file_full(key, fd, nullptr, nullptr);
}
EditorFlags start_editor(const gchar *key, const gchar *working_directory)
{
- return start_editor_from_filelist_full(key, NULL, working_directory, NULL, NULL);
+ return start_editor_from_filelist_full(key, nullptr, working_directory, nullptr, nullptr);
}
gboolean editor_window_flag_set(const gchar *key)
static gchar *exif_build_formatted_DateTime(ExifData *exif)
{
gchar *text = exif_get_data_as_text(exif, "Exif.Photo.DateTimeOriginal");
- gchar *subsec = NULL;
+ gchar *subsec = nullptr;
gchar buf[128];
gchar *tmp;
gint buflen;
struct tm tm;
- GError *error = NULL;
+ GError *error = nullptr;
if (text)
{
buflen = strftime(buf, sizeof(buf), "%x %X", &tm);
if (buflen > 0)
{
- tmp = g_locale_to_utf8(buf, buflen, NULL, NULL, &error);
+ tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
if (error)
{
log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
static gchar *exif_build_formatted_DateTimeDigitized(ExifData *exif)
{
gchar *text = exif_get_data_as_text(exif, "Exif.Photo.DateTimeDigitized");
- gchar *subsec = NULL;
+ gchar *subsec = nullptr;
gchar buf[128];
gchar *tmp;
gint buflen;
struct tm tm;
- GError *error = NULL;
+ GError *error = nullptr;
if (text)
{
buflen = strftime(buf, sizeof(buf), "%x %X", &tm);
if (buflen > 0)
{
- tmp = g_locale_to_utf8(buf, buflen, NULL, NULL, &error);
+ tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
if (error)
{
log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
{
ExifRational *r;
- r = exif_get_rational(exif, "Exif.Photo.ExposureTime", NULL);
+ r = exif_get_rational(exif, "Exif.Photo.ExposureTime", nullptr);
if (r && r->num && r->den)
{
gdouble n = static_cast<gdouble>(r->den) / static_cast<gdouble>(r->num);
return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
n > 1.0 ? n : 1.0 / n);
}
- r = exif_get_rational(exif, "Exif.Photo.ShutterSpeedValue", NULL);
+ r = exif_get_rational(exif, "Exif.Photo.ShutterSpeedValue", nullptr);
if (r && r->num && r->den)
{
gdouble n = pow(2.0, exif_rational_to_double(r, TRUE));
return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
n > 1.0 ? floor(n) : 1.0 / n);
}
- return NULL;
+ return nullptr;
}
static gchar *exif_build_formatted_Aperture(ExifData *exif)
n = exif_get_rational_as_double(exif, "Exif.Photo.FNumber");
if (n == 0.0) n = exif_get_rational_as_double(exif, "Exif.Photo.ApertureValue");
- if (n == 0.0) return NULL;
+ if (n == 0.0) return nullptr;
return g_strdup_printf("f/%.1f", n);
}
gdouble n;
r = exif_get_rational(exif, "Exif.Photo.ExposureBiasValue", &sign);
- if (!r) return NULL;
+ if (!r) return nullptr;
n = exif_rational_to_double(r, sign);
return g_strdup_printf("%+.1f", n);
gdouble n;
n = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
- if (n == 0.0) return NULL;
+ if (n == 0.0) return nullptr;
return g_strdup_printf("%.0f mm", n);
}
}
f = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
- if (f == 0.0) return NULL;
+ if (f == 0.0) return nullptr;
c = get_crop_factor(exif);
- if (c == 0.0) return NULL;
+ if (c == 0.0) return nullptr;
return g_strdup_printf("%.0f mm", f * c);
}
gdouble n;
r = exif_get_rational(exif, "Exif.Photo.SubjectDistance", &sign);
- if (!r) return NULL;
+ if (!r) return nullptr;
if (static_cast<glong>(r->num) == static_cast<glong>(0xffffffff)) return g_strdup(_("infinity"));
if (static_cast<glong>(r->num) == 0) return g_strdup(_("unknown"));
gint n;
gint v;
- if (!exif_get_integer(exif, "Exif.Photo.Flash", &n)) return NULL;
+ if (!exif_get_integer(exif, "Exif.Photo.Flash", &n)) return nullptr;
/* Exif 2.1 only defines first 3 bits */
if (n <= 0x07) return exif_get_data_as_text(exif, "Exif.Photo.Flash");
gchar *units;
gchar *text;
- rx = exif_get_rational(exif, "Exif.Image.XResolution", NULL);
- ry = exif_get_rational(exif, "Exif.Image.YResolution", NULL);
- if (!rx || !ry) return NULL;
+ rx = exif_get_rational(exif, "Exif.Image.XResolution", nullptr);
+ ry = exif_get_rational(exif, "Exif.Image.YResolution", nullptr);
+ if (!rx || !ry) return nullptr;
units = exif_get_data_as_text(exif, "Exif.Image.ResolutionUnit");
text = g_strdup_printf("%0.f x %0.f (%s/%s)", rx->den ? static_cast<gdouble>(rx->num) / rx->den : 1.0,
}
#endif
}
- if (name[0] == 0 && source[0] == 0) return NULL;
+ if (name[0] == 0 && source[0] == 0) return nullptr;
return g_strdup_printf("%s (%s)", name, source);
}
p = 0;
for (i = 0; i < exif_item_get_elements(item); i++)
{
- value = exif_item_get_rational(item, NULL, i);
+ value = exif_item_get_rational(item, nullptr, i);
if (value && value->num && value->den)
p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
}
p = 0;
for (i = 0; i < exif_item_get_elements(item); i++)
{
- value = exif_item_get_rational(item, NULL, i);
+ value = exif_item_get_rational(item, nullptr, i);
if (value && value->num && value->den)
p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
}
gint ref;
item = exif_get_item(exif, "Exif.GPSInfo.GPSAltitudeRef");
- r = exif_get_rational(exif, "Exif.GPSInfo.GPSAltitude", NULL);
+ r = exif_get_rational(exif, "Exif.GPSInfo.GPSAltitude", nullptr);
- if (!r || !item) return NULL;
+ if (!r || !item) return nullptr;
alt = exif_rational_to_double(r, 0);
exif_item_get_integer(item, &ref);
*/
static void zd_tz(ZoneDetectResult *results, gchar **timezone, gchar **countryname, gchar **countryalpha2)
{
- gchar *timezone_pre = NULL;
- gchar *timezone_id = NULL;
+ gchar *timezone_pre = nullptr;
+ gchar *timezone_id = nullptr;
unsigned int index = 0;
while(results[index].lookupResult != ZD_LOOKUP_END)
if (text_latitude && text_longitude && text_latitude_ref && text_longitude_ref)
{
lat_deg = strtok(text_latitude, "deg'");
- lat_min = strtok(NULL, "deg'");
+ lat_min = strtok(nullptr, "deg'");
if (!lat_deg || !lat_min)
{
return FALSE;
latitude = -latitude;
}
lon_deg = strtok(text_longitude, "deg'");
- lon_min = strtok(NULL, "deg'");
+ lon_min = strtok(nullptr, "deg'");
if (!lon_deg || !lon_min)
{
return FALSE;
cd = ZDOpenDatabase(timezone_path);
if (cd)
{
- results = ZDLookup(cd, latitude, longitude, NULL);
+ results = ZDLookup(cd, latitude, longitude, nullptr);
if (results)
{
zd_tz(results, timezone, countryname, countryalpha2);
gchar buf[128];
gchar *tmp;
gint buflen;
- GError *error = NULL;
+ GError *error = nullptr;
gchar *time_zone_image;
gchar *time_zone_org;
struct tm *tm_local;
struct tm tm_utc;
time_t stamp;
- gchar *exif_date_time = NULL;
- gchar *timezone = NULL;
- gchar *countryname = NULL;
- gchar *countryalpha2 = NULL;
+ gchar *exif_date_time = nullptr;
+ gchar *timezone = nullptr;
+ gchar *countryname = nullptr;
+ gchar *countryalpha2 = nullptr;
if (exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2))
{
buflen = strftime(buf, sizeof(buf), "%x %X", tm_local);
if (buflen > 0)
{
- tmp = g_locale_to_utf8(buf, buflen, NULL, NULL, &error);
+ tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
if (error)
{
log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
*/
static gchar *exif_build_formatted_timezone(ExifData *exif)
{
- gchar *exif_date_time = NULL;
- gchar *timezone = NULL;
- gchar *countryname = NULL;
- gchar *countryalpha2 = NULL;
+ gchar *exif_date_time = nullptr;
+ gchar *timezone = nullptr;
+ gchar *countryname = nullptr;
+ gchar *countryalpha2 = nullptr;
exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
*/
static gchar *exif_build_formatted_countryname(ExifData *exif)
{
- gchar *exif_date_time = NULL;
- gchar *timezone = NULL;
- gchar *countryname = NULL;
- gchar *countryalpha2 = NULL;
+ gchar *exif_date_time = nullptr;
+ gchar *timezone = nullptr;
+ gchar *countryname = nullptr;
+ gchar *countryalpha2 = nullptr;
exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
*/
static gchar *exif_build_formatted_countrycode(ExifData *exif)
{
- gchar *exif_date_time = NULL;
- gchar *timezone = NULL;
- gchar *countryname = NULL;
- gchar *countryalpha2 = NULL;
+ gchar *exif_date_time = nullptr;
+ gchar *timezone = nullptr;
+ gchar *countryname = nullptr;
+ gchar *countryalpha2 = nullptr;
exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
EXIF_FORMATTED_TAG(countryname, N_("Country name")),
EXIF_FORMATTED_TAG(countrycode, N_("Country code")),
EXIF_FORMATTED_TAG(star_rating, N_("Star rating")),
- {"file.size", N_("File size"), NULL},
- {"file.date", N_("File date"), NULL},
- {"file.mode", N_("File mode"), NULL},
- {"file.ctime", N_("File ctime"), NULL},
- {"file.owner", N_("File owner"), NULL},
- {"file.group", N_("File group"), NULL},
- {"file.link", N_("File link"), NULL},
- {"file.class", N_("File class"), NULL},
- {"file.page_no", N_("Page no."), NULL},
- {"lua.lensID", N_("Lens"), NULL},
- { NULL, NULL, NULL }
+ {"file.size", N_("File size"), nullptr},
+ {"file.date", N_("File date"), nullptr},
+ {"file.mode", N_("File mode"), nullptr},
+ {"file.ctime", N_("File ctime"), nullptr},
+ {"file.owner", N_("File owner"), nullptr},
+ {"file.group", N_("File group"), nullptr},
+ {"file.link", N_("File link"), nullptr},
+ {"file.class", N_("File class"), nullptr},
+ {"file.page_no", N_("Page no."), nullptr},
+ {"lua.lensID", N_("Lens"), nullptr},
+ { nullptr, nullptr, nullptr }
};
gchar *exif_get_formatted_by_key(ExifData *exif, const gchar *key, gboolean *key_valid)
}
if (key_valid) *key_valid = FALSE;
- return NULL;
+ return nullptr;
}
gchar *exif_get_description_by_key(const gchar *key)
{
- if (!key) return NULL;
+ if (!key) return nullptr;
if (strncmp(key, EXIF_FORMATTED(), EXIF_FORMATTED_LEN) == 0 || strncmp(key, "file.", 5) == 0 || strncmp(key, "lua.", 4) == 0)
{
gchar *text;
gboolean key_valid;
- if (!key) return NULL;
+ if (!key) return nullptr;
text = exif_get_formatted_by_key(exif, key, &key_valid);
if (key_valid) return text;
item = exif_get_item(exif, key);
if (item) return exif_item_get_data_as_text(item);
- return NULL;
+ return nullptr;
}
void exif_release_cb(FileData *fd)
{
exif_free(fd->exif);
- fd->exif = NULL;
+ fd->exif = nullptr;
}
void exif_init_cache(void)
if (!exif_cache) exif_init_cache();
- if (!fd) return NULL;
+ if (!fd) return nullptr;
if (file_cache_get(exif_cache, fd)) return fd->exif;
- g_assert(fd->exif == NULL);
+ g_assert(fd->exif == nullptr);
/* CACHE_TYPE_XMP_METADATA file should exist only if the metadata are
* not writable directly, thus it should contain the most up-to-date version */
- sidecar_path = NULL;
+ sidecar_path = nullptr;
#ifdef HAVE_EXIV2
/* we are not able to handle XMP sidecars without exiv2 */
}
else
{
- return NULL;
+ return nullptr;
}
}
return g_strdup("");
/* this is a list of keys that should be converted, even with the older Exiv2 which does not support it directly */
static const AltKey alt_keys[] = {
- {"Xmp.tiff.Orientation", "Exif.Image.Orientation", NULL},
- {"Xmp.dc.title", NULL, "Iptc.Application2.ObjectName" },
- {"Xmp.photoshop.Urgency", NULL, "Iptc.Application2.Urgency" },
- {"Xmp.photoshop.Category", NULL, "Iptc.Application2.Category" },
- {"Xmp.photoshop.SupplementalCategory", NULL, "Iptc.Application2.SuppCategory" },
- {"Xmp.dc.subject", NULL, "Iptc.Application2.Keywords" },
- {"Xmp.iptc.Location", NULL, "Iptc.Application2.LocationName" },
- {"Xmp.photoshop.Instruction", NULL, "Iptc.Application2.SpecialInstructions" },
- {"Xmp.photoshop.DateCreated", NULL, "Iptc.Application2.DateCreated" },
- {"Xmp.dc.creator", NULL, "Iptc.Application2.Byline" },
- {"Xmp.photoshop.AuthorsPosition", NULL, "Iptc.Application2.BylineTitle" },
- {"Xmp.photoshop.City", NULL, "Iptc.Application2.City" },
- {"Xmp.photoshop.State", NULL, "Iptc.Application2.ProvinceState" },
- {"Xmp.iptc.CountryCode", NULL, "Iptc.Application2.CountryCode" },
- {"Xmp.photoshop.Country", NULL, "Iptc.Application2.CountryName" },
- {"Xmp.photoshop.TransmissionReference", NULL, "Iptc.Application2.TransmissionReference"},
- {"Xmp.photoshop.Headline", NULL, "Iptc.Application2.Headline" },
- {"Xmp.photoshop.Credit", NULL, "Iptc.Application2.Credit" },
- {"Xmp.photoshop.Source", NULL, "Iptc.Application2.Source" },
- {"Xmp.dc.rights", NULL, "Iptc.Application2.Copyright" },
- {"Xmp.dc.description", NULL, "Iptc.Application2.Caption" },
- {"Xmp.photoshop.CaptionWriter", NULL, "Iptc.Application2.Writer" },
- {NULL, NULL, NULL}
+ {"Xmp.tiff.Orientation", "Exif.Image.Orientation", nullptr},
+ {"Xmp.dc.title", nullptr, "Iptc.Application2.ObjectName" },
+ {"Xmp.photoshop.Urgency", nullptr, "Iptc.Application2.Urgency" },
+ {"Xmp.photoshop.Category", nullptr, "Iptc.Application2.Category" },
+ {"Xmp.photoshop.SupplementalCategory", nullptr, "Iptc.Application2.SuppCategory" },
+ {"Xmp.dc.subject", nullptr, "Iptc.Application2.Keywords" },
+ {"Xmp.iptc.Location", nullptr, "Iptc.Application2.LocationName" },
+ {"Xmp.photoshop.Instruction", nullptr, "Iptc.Application2.SpecialInstructions" },
+ {"Xmp.photoshop.DateCreated", nullptr, "Iptc.Application2.DateCreated" },
+ {"Xmp.dc.creator", nullptr, "Iptc.Application2.Byline" },
+ {"Xmp.photoshop.AuthorsPosition", nullptr, "Iptc.Application2.BylineTitle" },
+ {"Xmp.photoshop.City", nullptr, "Iptc.Application2.City" },
+ {"Xmp.photoshop.State", nullptr, "Iptc.Application2.ProvinceState" },
+ {"Xmp.iptc.CountryCode", nullptr, "Iptc.Application2.CountryCode" },
+ {"Xmp.photoshop.Country", nullptr, "Iptc.Application2.CountryName" },
+ {"Xmp.photoshop.TransmissionReference", nullptr, "Iptc.Application2.TransmissionReference"},
+ {"Xmp.photoshop.Headline", nullptr, "Iptc.Application2.Headline" },
+ {"Xmp.photoshop.Credit", nullptr, "Iptc.Application2.Credit" },
+ {"Xmp.photoshop.Source", nullptr, "Iptc.Application2.Source" },
+ {"Xmp.dc.rights", nullptr, "Iptc.Application2.Copyright" },
+ {"Xmp.dc.description", nullptr, "Iptc.Application2.Caption" },
+ {"Xmp.photoshop.CaptionWriter", nullptr, "Iptc.Application2.Writer" },
+ {nullptr, nullptr, nullptr}
};
static void _debug_exception(const char* file,
const char* func,
Exiv2::AnyError& e)
{
- gchar *str = g_locale_from_utf8(e.what(), -1, NULL, NULL, NULL);
+ gchar *str = g_locale_from_utf8(e.what(), -1, nullptr, nullptr, nullptr);
DEBUG_1("%s:%d:%s:Exiv2: %s", file, line, func, str);
g_free(str);
}
virtual ~_ExifData() = default;
- virtual void writeMetadata(gchar *UNUSED(path) = NULL)
+ virtual void writeMetadata(gchar *UNUSED(path) = nullptr)
{
g_critical("Unsupported method of writing metadata");
}
virtual ExifData *original()
{
- return NULL;
+ return nullptr;
}
virtual Exiv2::Image *image() = 0;
public:
_ExifDataOriginal(Exiv2::Image::AutoPtr image)
{
- cp_data_ = NULL;
+ cp_data_ = nullptr;
cp_length_ = 0;
image_ = std::move(image);
valid_ = TRUE;
_ExifDataOriginal(gchar *path)
{
- cp_data_ = NULL;
+ cp_data_ = nullptr;
cp_length_ = 0;
valid_ = TRUE;
Exiv2::Image *image() override
{
- if (!valid_) return NULL;
+ if (!valid_) return nullptr;
return image_.get();
}
return static_cast<unsigned char *>(g_memdup(cp_data_, cp_length_));
#endif
}
- return NULL;
+ return nullptr;
}
std::string image_comment() const override
_ExifDataProcessed(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp)
{
imageData_ = std::make_unique<_ExifDataOriginal>(path);
- sidecarData_ = NULL;
+ sidecarData_ = nullptr;
#if EXIV2_TEST_VERSION(0,16,0)
if (sidecar_path)
{
return imageData_.get();
}
- void writeMetadata(gchar *path = NULL) override
+ void writeMetadata(gchar *path = nullptr) override
{
if (!path)
{
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
ExifItem *exif_get_item(ExifData *exif, const gchar *key)
{
try {
- Exiv2::Metadatum *item = NULL;
+ Exiv2::Metadatum *item = nullptr;
try {
Exiv2::ExifKey ekey(key);
auto pos = exif->exifData().findKey(ekey);
- if (pos == exif->exifData().end()) return NULL;
+ if (pos == exif->exifData().end()) return nullptr;
item = &*pos;
}
catch (Exiv2::AnyError& e) {
try {
Exiv2::IptcKey ekey(key);
auto pos = exif->iptcData().findKey(ekey);
- if (pos == exif->iptcData().end()) return NULL;
+ if (pos == exif->iptcData().end()) return nullptr;
item = &*pos;
}
catch (Exiv2::AnyError& e) {
#if EXIV2_TEST_VERSION(0,16,0)
Exiv2::XmpKey ekey(key);
auto pos = exif->xmpData().findKey(ekey);
- if (pos == exif->xmpData().end()) return NULL;
+ if (pos == exif->xmpData().end()) return nullptr;
item = &*pos;
#endif
}
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
ExifItem *exif_add_item(ExifData *exif, const gchar *key)
{
try {
- Exiv2::Metadatum *item = NULL;
+ Exiv2::Metadatum *item = nullptr;
try {
Exiv2::ExifKey ekey(key);
- exif->exifData().add(ekey, NULL);
+ exif->exifData().add(ekey, nullptr);
auto pos = exif->exifData().end(); // a hack, there should be a better way to get the currently added item
pos--;
item = &*pos;
catch (Exiv2::AnyError& e) {
try {
Exiv2::IptcKey ekey(key);
- exif->iptcData().add(ekey, NULL);
+ exif->iptcData().add(ekey, nullptr);
auto pos = exif->iptcData().end();
pos--;
item = &*pos;
catch (Exiv2::AnyError& e) {
#if EXIV2_TEST_VERSION(0,16,0)
Exiv2::XmpKey ekey(key);
- exif->xmpData().add(ekey, NULL);
+ exif->xmpData().add(ekey, nullptr);
auto pos = exif->xmpData().end();
pos--;
item = &*pos;
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
return (ExifItem *)item;
}
#endif
- return NULL;
+ return nullptr;
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
return (ExifItem *)item;
}
#endif
- return NULL;
+ return nullptr;
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
char *exif_item_get_tag_name(ExifItem *item)
{
try {
- if (!item) return NULL;
+ if (!item) return nullptr;
return g_strdup((reinterpret_cast<Exiv2::Metadatum *>(item))->key().c_str());
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
char *exif_item_get_data(ExifItem *item, guint *data_len)
{
try {
- if (!item) return 0;
+ if (!item) return nullptr;
auto md = reinterpret_cast<Exiv2::Metadatum *>(item);
if (data_len) *data_len = md->size();
auto data = static_cast<char *>(g_malloc(md->size()));
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
char *exif_item_get_description(ExifItem *item)
{
try {
- if (!item) return NULL;
+ if (!item) return nullptr;
return utf8_validate_or_convert((reinterpret_cast<Exiv2::Metadatum *>(item))->tagLabel().c_str());
}
catch (std::exception& e) {
// debug_exception(e);
- return NULL;
+ return nullptr;
}
}
const char *exif_item_get_format_name(ExifItem *item, gboolean UNUSED(brief))
{
try {
- if (!item) return NULL;
+ if (!item) return nullptr;
return (reinterpret_cast<Exiv2::Metadatum *>(item))->typeName();
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
gchar *exif_item_get_data_as_text(ExifItem *item)
{
try {
- if (!item) return NULL;
+ if (!item) return nullptr;
auto metadatum = reinterpret_cast<Exiv2::Metadatum *>(item);
#if EXIV2_TEST_VERSION(0,17,0)
return utf8_validate_or_convert(metadatum->print().c_str());
#endif
}
catch (Exiv2::AnyError& e) {
- return NULL;
+ return nullptr;
}
}
gchar *exif_item_get_string(ExifItem *item, int idx)
{
try {
- if (!item) return NULL;
+ if (!item) return nullptr;
auto em = reinterpret_cast<Exiv2::Metadatum *>(item);
#if EXIV2_TEST_VERSION(0,16,0)
std::string str = em->toString(idx);
return utf8_validate_or_convert(str.c_str());
}
catch (Exiv2::AnyError& e) {
- return NULL;
+ return nullptr;
}
}
ExifRational *exif_item_get_rational(ExifItem *item, gint *sign, guint n)
{
try {
- if (!item) return NULL;
- if (n >= exif_item_get_elements(item)) return NULL;
+ if (!item) return nullptr;
+ if (n >= exif_item_get_elements(item)) return nullptr;
Exiv2::Rational v = (reinterpret_cast<Exiv2::Metadatum *>(item))->toRational(n);
static ExifRational ret;
ret.num = v.first;
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
}
- return NULL;
+ return nullptr;
}
static const AltKey *find_alt_key(const gchar *xmp_key)
if (strcmp(xmp_key, alt_keys[i].xmp_key) == 0) return &alt_keys[i];
i++;
}
- return NULL;
+ return nullptr;
}
static gint exif_update_metadata_simple(ExifData *exif, const gchar *key, const GList *values)
static GList *exif_get_metadata_simple(ExifData *exif, const gchar *key, MetadataFormat format)
{
- GList *list = NULL;
+ GList *list = nullptr;
try {
try {
Exiv2::ExifKey ekey(key);
while (pos != exif->iptcData().end())
{
if (pos->key() == key)
- list = exif_add_value_to_glist(list, *pos, format, NULL);
+ list = exif_add_value_to_glist(list, *pos, format, nullptr);
++pos;
}
Exiv2::XmpKey ekey(key);
auto pos = exif->xmpData().findKey(ekey);
if (pos != exif->xmpData().end())
- list = exif_add_value_to_glist(list, *pos, format, NULL);
+ list = exif_add_value_to_glist(list, *pos, format, nullptr);
#endif
}
}
GList *exif_get_metadata(ExifData *exif, const gchar *key, MetadataFormat format)
{
- GList *list = NULL;
+ GList *list = nullptr;
- if (!key) return NULL;
+ if (!key) return nullptr;
if (format == METADATA_FORMATTED)
{
gchar *text;
gint key_valid;
text = exif_get_formatted_by_key(exif, key, &key_valid);
- if (key_valid) return g_list_append(NULL, text);
+ if (key_valid) return g_list_append(nullptr, text);
}
list = exif_get_metadata_simple(exif, key, format);
guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height)
{
- if (!exif) return NULL;
+ if (!exif) return nullptr;
- if (!exif->image()) return NULL;
+ if (!exif->image()) return nullptr;
std::string const path = exif->image()->io().path();
/* given image pathname, first do simple (and fast) file extension test */
gboolean is_raw = filter_file_class(path.c_str(), FORMAT_CLASS_RAWIMAGE);
- if (!is_raw && requested_width == 0) return NULL;
+ if (!is_raw && requested_width == 0) return nullptr;
try {
// we are not interested in smaller thumbnails in normal image formats - we can use full image instead
if (!is_raw)
{
- if (pos->width_ < static_cast<uint32_t>(requested_width) || pos->height_ < static_cast<uint32_t>(requested_height)) return NULL;
+ if (pos->width_ < static_cast<uint32_t>(requested_width) || pos->height_ < static_cast<uint32_t>(requested_height)) return nullptr;
}
}
return p.first;
#endif
}
- return NULL;
+ return nullptr;
}
catch (Exiv2::AnyError& e) {
debug_exception(e);
- return NULL;
+ return nullptr;
}
}
auto fc = g_new(FileCacheData, 1);
fc->release = release;
- fc->list = NULL;
+ fc->list = nullptr;
fc->max_size = max_size;
fc->size = 0;
gint global_file_data_count = 0;
#endif
-static GHashTable *file_data_pool = NULL;
-static GHashTable *file_data_planned_change_hash = NULL;
+static GHashTable *file_data_pool = nullptr;
+static GHashTable *file_data_planned_change_hash = nullptr;
static gint sidecar_file_priority(const gchar *extension);
static void file_data_check_sidecars(const GList *basename_list);
/* note: returned string is valid until next call to text_from_time() */
const gchar *text_from_time(time_t t)
{
- static gchar *ret = NULL;
+ static gchar *ret = nullptr;
gchar buf[128];
gint buflen;
struct tm *btime;
- GError *error = NULL;
+ GError *error = nullptr;
btime = localtime(&t);
if (buflen < 1) return "";
g_free(ret);
- ret = g_locale_to_utf8(buf, buflen, NULL, NULL, &error);
+ ret = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
if (error)
{
log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
fd->cdate = st->st_ctime;
fd->mode = st->st_mode;
if (fd->thumb_pixbuf) g_object_unref(fd->thumb_pixbuf);
- fd->thumb_pixbuf = NULL;
+ fd->thumb_pixbuf = nullptr;
file_data_increment_version(fd);
file_data_send_notification(fd, NOTIFY_REREAD);
return TRUE;
{
GList *sidecars;
GList *work;
- FileData *sfd = NULL;
+ FileData *sfd = nullptr;
/* parent is missing, we have to rebuild whole group */
ret = TRUE;
}
fd->extension = registered_extension_from_path(fd->path);
- if (fd->extension == NULL)
+ if (fd->extension == nullptr)
{
fd->extension = fd->name + strlen(fd->name);
}
}
else
{
- fd = NULL;
+ fd = nullptr;
}
}
}
FileData *file_data_ref(FileData *fd)
#endif
{
- if (fd == NULL) return NULL;
+ if (fd == nullptr) return nullptr;
if (fd->magick != FD_MAGICK)
#ifdef DEBUG_FILEDATA
log_printf("Error: fd magick mismatch @ %s:%d fd=%p", file, line, (void *)fd);
g_free(fd->group);
g_free(fd->sym_link);
g_free(fd->format_name);
- g_assert(fd->sidecar_files == NULL); /* sidecar files must be freed before calling this */
+ g_assert(fd->sidecar_files == nullptr); /* sidecar files must be freed before calling this */
- file_data_change_info_free(NULL, fd);
+ file_data_change_info_free(nullptr, fd);
g_free(fd);
}
}
g_list_free(parent->sidecar_files);
- parent->sidecar_files = NULL;
+ parent->sidecar_files = nullptr;
file_data_free(parent);
}
void file_data_unref(FileData *fd)
#endif
{
- if (fd == NULL) return;
+ if (fd == nullptr) return;
if (fd->magick != FD_MAGICK)
#ifdef DEBUG_FILEDATA
log_printf("Error: fd magick mismatch @ %s:%d fd=%p", file, line, (void *)fd);
*/
void file_data_lock(FileData *fd)
{
- if (fd == NULL) return;
+ if (fd == nullptr) return;
if (fd->magick != FD_MAGICK) log_printf("Error: fd magick mismatch fd=%p", (void *)fd);
g_assert(fd->magick == FD_MAGICK);
*/
void file_data_unlock(FileData *fd)
{
- if (fd == NULL) return;
+ if (fd == nullptr) return;
if (fd->magick != FD_MAGICK) log_printf("Error: fd magick mismatch fd=%p", (void *)fd);
g_assert(fd->magick == FD_MAGICK);
gint i = 1;
GList *work;
- if (extension == NULL)
+ if (extension == nullptr)
return 0;
work = sidecar_ext_get_list();
DEBUG_2(" sidecar: %p %s", (void *)sfd, sfd->name);
}
- g_assert(fd->parent == NULL || fd->sidecar_files == NULL);
+ g_assert(fd->parent == nullptr || fd->sidecar_files == nullptr);
}
parent_fd = static_cast<FileData *>(basename_list->data);
{
auto fd = static_cast<FileData *>(work->data);
work = work->next;
- g_assert(fd->parent == NULL || fd->sidecar_files == NULL);
+ g_assert(fd->parent == nullptr || fd->sidecar_files == nullptr);
if (fd->parent)
{
FileData *old_parent = fd->parent;
- g_assert(old_parent->parent == NULL || old_parent->sidecar_files == NULL);
+ g_assert(old_parent->parent == nullptr || old_parent->sidecar_files == nullptr);
file_data_ref(old_parent);
file_data_disconnect_sidecar_file(old_parent, fd);
file_data_send_notification(old_parent, NOTIFY_REREAD);
while (fd->sidecar_files)
{
auto sfd = static_cast<FileData *>(fd->sidecar_files->data);
- g_assert(sfd->parent == NULL || sfd->sidecar_files == NULL);
+ g_assert(sfd->parent == nullptr || sfd->sidecar_files == nullptr);
file_data_ref(sfd);
file_data_disconnect_sidecar_file(fd, sfd);
file_data_send_notification(sfd, NOTIFY_REREAD);
}
file_data_send_notification(fd, NOTIFY_GROUPING);
- g_assert(fd->parent == NULL && fd->sidecar_files == NULL);
+ g_assert(fd->parent == nullptr && fd->sidecar_files == nullptr);
}
/* now we can form the new group */
work = basename_list->next;
- new_sidecars = NULL;
+ new_sidecars = nullptr;
while (work)
{
auto sfd = static_cast<FileData *>(work->data);
g_assert(sfd->magick == FD_MAGICK);
- g_assert(sfd->parent == NULL && sfd->sidecar_files == NULL);
+ g_assert(sfd->parent == nullptr && sfd->sidecar_files == nullptr);
sfd->parent = parent_fd;
new_sidecars = g_list_prepend(new_sidecars, sfd);
work = work->next;
}
- g_assert(parent_fd->sidecar_files == NULL);
+ g_assert(parent_fd->sidecar_files == nullptr);
parent_fd->sidecar_files = g_list_reverse(new_sidecars);
DEBUG_1("basename group changed for %s", parent_fd->path);
}
file_data_increment_version(sfd); /* increments both sfd and target */
target->sidecar_files = g_list_remove(target->sidecar_files, sfd);
- sfd->parent = NULL;
+ sfd->parent = nullptr;
g_free(sfd->extended_extension);
- sfd->extended_extension = NULL;
+ sfd->extended_extension = nullptr;
file_data_unref(target);
file_data_unref(sfd);
static GHashTable *file_data_basename_hash_new(void)
{
- return g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+ return g_hash_table_new_full(g_str_hash, g_str_equal, g_free, nullptr);
}
static GList * file_data_basename_hash_insert(GHashTable *basename_hash, FileData *fd)
{
DEBUG_1("TG: parent fd doesn't fit");
g_free(parent_basename);
- list = NULL;
+ list = nullptr;
}
else
{
static void file_data_basename_hash_free(GHashTable *basename_hash)
{
- g_hash_table_foreach(basename_hash, file_data_basename_hash_remove_list, NULL);
+ g_hash_table_foreach(basename_hash, file_data_basename_hash_remove_list, nullptr);
g_hash_table_destroy(basename_hash);
}
static GList *filelist_filter_out_sidecars(GList *flist)
{
GList *work = flist;
- GList *flist_filtered = NULL;
+ GList *flist_filtered = nullptr;
while (work)
{
DIR *dp;
struct dirent *dir;
gchar *pathl;
- GList *dlist = NULL;
- GList *flist = NULL;
- GList *xmp_files = NULL;
+ GList *dlist = nullptr;
+ GList *flist = nullptr;
+ GList *xmp_files = nullptr;
gint (*stat_func)(const gchar *path, struct stat *buf);
- GHashTable *basename_hash = NULL;
+ GHashTable *basename_hash = nullptr;
g_assert(files || dirs);
- if (files) *files = NULL;
- if (dirs) *dirs = NULL;
+ if (files) *files = nullptr;
+ if (dirs) *dirs = nullptr;
pathl = path_from_utf8(dir_path);
if (!pathl) return FALSE;
dp = opendir(pathl);
- if (dp == NULL)
+ if (dp == nullptr)
{
g_free(pathl);
return FALSE;
else
stat_func = lstat;
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
struct stat ent_sbuf;
const gchar *name = dir->d_name;
if (files)
{
- g_hash_table_foreach(basename_hash, file_data_basename_hash_to_sidecars, NULL);
+ g_hash_table_foreach(basename_hash, file_data_basename_hash_to_sidecars, nullptr);
*files = filelist_filter_out_sidecars(flist);
}
dir = remove_level_from_path(path_utf8);
- filelist_read_real(dir, &files, NULL, TRUE);
+ filelist_read_real(dir, &files, nullptr, TRUE);
fd = static_cast<FileData *>(g_hash_table_lookup(file_data_pool, path_utf8));
if (!fd) fd = file_data_new(path_utf8, &st, TRUE);
GList *filelist_copy(GList *list)
{
- GList *new_list = NULL;
+ GList *new_list = nullptr;
GList *work;
work = list;
GList *filelist_from_path_list(GList *list)
{
- GList *new_list = NULL;
+ GList *new_list = nullptr;
GList *work;
work = list;
GList *filelist_to_path_list(GList *list)
{
- GList *new_list = NULL;
+ GList *new_list = nullptr;
GList *work;
work = list;
GList *list;
GList *d;
- if (!filelist_read(dir_fd, &list, &d)) return NULL;
+ if (!filelist_read(dir_fd, &list, &d)) return nullptr;
list = filelist_filter(list, FALSE);
list = filelist_sort_path(list);
GList *list;
GList *d;
- if (!filelist_read(dir_fd, &list, &d)) return NULL;
+ if (!filelist_read(dir_fd, &list, &d)) return nullptr;
list = filelist_filter(list, FALSE);
list = filelist_sort_full(list, method, ascend, reinterpret_cast<GCompareFunc>(filelist_sort_file_cb));
g_free(fdci);
- if (fd) fd->change = NULL;
+ if (fd) fd->change = nullptr;
}
static gboolean file_data_can_write_directly(FileData *fd)
gchar *file_data_get_sidecar_path(FileData *fd, gboolean existing_only)
{
- gchar *sidecar_path = NULL;
+ gchar *sidecar_path = nullptr;
GList *work;
- if (!file_data_can_write_sidecar(fd)) return NULL;
+ if (!file_data_can_write_sidecar(fd)) return nullptr;
work = fd->parent ? fd->parent->sidecar_files : fd->sidecar_files;
gchar *extended_extension = g_strconcat(fd->parent ? fd->parent->extension : fd->extension, ".xmp", NULL);
gboolean file_data_filter_file_filter(FileData *fd, GRegex *filter)
{
- return g_regex_match(filter, fd->name, static_cast<GRegexMatchFlags>(0), NULL);
+ return g_regex_match(filter, fd->name, static_cast<GRegexMatchFlags>(0), nullptr);
}
GList *file_data_filter_file_filter_list(GList *list, GRegex *filter)
if (get_mark_func && file_data_pool)
{
/* this effectively changes all known files */
- g_hash_table_foreach(file_data_pool, file_data_notify_mark_func, NULL);
+ g_hash_table_foreach(file_data_pool, file_data_notify_mark_func, nullptr);
}
return TRUE;
if (g_hash_table_size(file_data_planned_change_hash) == 0)
{
g_hash_table_destroy(file_data_planned_change_hash);
- file_data_planned_change_hash = NULL;
+ file_data_planned_change_hash = nullptr;
DEBUG_1("planned change: empty");
}
}
g_free(fdci);
- fd->change = NULL;
+ fd->change = nullptr;
}
void file_data_set_regroup_when_finished(FileData *fd, gboolean enable)
work = work->next;
}
- file_data_add_ci(fd, type, NULL, NULL);
+ file_data_add_ci(fd, type, nullptr, nullptr);
work = fd->sidecar_files;
while (work)
{
auto sfd = static_cast<FileData *>(work->data);
- file_data_add_ci(sfd, type, NULL, NULL);
+ file_data_add_ci(sfd, type, nullptr, nullptr);
work = work->next;
}
gboolean file_data_add_ci_write_metadata(FileData *fd)
{
- return file_data_add_ci(fd, FILEDATA_CHANGE_WRITE_METADATA, NULL, NULL);
+ return file_data_add_ci(fd, FILEDATA_CHANGE_WRITE_METADATA, nullptr, nullptr);
}
void file_data_sc_free_ci(FileData *fd)
static void file_data_sc_update_ci(FileData *fd, const gchar *dest_path)
{
GList *work;
- gchar *dest_path_full = NULL;
+ gchar *dest_path_full = nullptr;
if (fd->parent) fd = fd->parent;
{
gint ret = CHANGE_OK;
gchar *dir;
- GList *work = NULL;
- FileData *fd1 = NULL;
+ GList *work = nullptr;
+ FileData *fd1 = nullptr;
if (!fd->change)
{
{
/* determine destination file */
gboolean have_dest = FALSE;
- gchar *dest_dir = NULL;
+ gchar *dest_dir = nullptr;
if (options->metadata.save_in_image_file)
{
/* If an existing metadata file exists, we will try writing to
* it's location regardless of the user's preference.
*/
- gchar *metadata_path = NULL;
+ gchar *metadata_path = nullptr;
#ifdef HAVE_EXIV2
/* but ignore XMP if we are not able to write it */
metadata_path = cache_find_location(CACHE_TYPE_XMP_METADATA, fd->path);
if (metadata_path && !access_file(metadata_path, W_OK))
{
g_free(metadata_path);
- metadata_path = NULL;
+ metadata_path = nullptr;
}
if (!metadata_path)
{
fd1 = static_cast<FileData *>(work->data);
work = work->next;
- if (fd1 != NULL && fd != fd1 )
+ if (fd1 != nullptr && fd != fd1 )
{
if (!strcmp(fd->change->dest, fd1->change->dest))
{
GList *file_data_process_groups_in_selection(GList *list, gboolean ungroup, GList **ungrouped_list)
{
- GList *out = NULL;
+ GList *out = nullptr;
GList *work = list;
/* change partial groups to independent files */
NotifyPriority priority;
};
-static GList *notify_func_list = NULL;
+static GList *notify_func_list = nullptr;
static gint file_data_notify_sort(gconstpointer a, gconstpointer b)
{
*/
}
-static GHashTable *file_data_monitor_pool = NULL;
+static GHashTable *file_data_monitor_pool = nullptr;
static guint realtime_monitor_id = 0; /* event source id */
static void realtime_monitor_check_cb(gpointer key, gpointer UNUSED(value), gpointer UNUSED(data))
static gboolean realtime_monitor_cb(gpointer UNUSED(data))
{
if (!options->update_on_time_change) return TRUE;
- g_hash_table_foreach(file_data_monitor_pool, realtime_monitor_check_cb, NULL);
+ g_hash_table_foreach(file_data_monitor_pool, realtime_monitor_check_cb, nullptr);
return TRUE;
}
if (!realtime_monitor_id)
{
- realtime_monitor_id = g_timeout_add(5000, realtime_monitor_cb, NULL);
+ realtime_monitor_id = g_timeout_add(5000, realtime_monitor_cb, nullptr);
}
return TRUE;
{
if (s_buf[0]=='#') continue;
file_path = strtok(s_buf, ",");
- marks_value = strtok(NULL, ",");
+ marks_value = strtok(nullptr, ",");
if (isfile(file_path))
{
FileData *fd = file_data_new_no_grouping(file_path);
void marks_clear_all()
{
- g_hash_table_foreach(file_data_pool, marks_clear, NULL);
+ g_hash_table_foreach(file_data_pool, marks_clear, nullptr);
}
void file_data_set_page_num(FileData *fd, gint page_num)
*-----------------------------------------------------------------------------
*/
-static GList *filter_list = NULL;
-static GList *extension_list = NULL;
-static GList *sidecar_ext_list = NULL;
+static GList *filter_list = nullptr;
+static GList *extension_list = nullptr;
+static GList *sidecar_ext_list = nullptr;
static GList *file_class_extension_list[FILE_FORMAT_CLASSES];
-static GList *file_writable_list = NULL; /* writable files */
-static GList *file_sidecar_list = NULL; /* files with allowed sidecar */
+static GList *file_writable_list = nullptr; /* writable files */
+static GList *file_sidecar_list = nullptr; /* files with allowed sidecar */
static FilterEntry *filter_entry_new(const gchar *key, const gchar *description,
{
GList *work;
- if (!key) return NULL;
+ if (!key) return nullptr;
work = filter_list;
while (work)
if (strcmp(fe->key, key) == 0) return fe;
}
- return NULL;
+ return nullptr;
}
static gboolean filter_key_exists(const gchar *key)
{
- return (filter_get_by_key(key) != NULL);
+ return (filter_get_by_key(key) != nullptr);
}
void filter_add(const gchar *key, const gchar *description, const gchar *extensions, FileFormatClass file_class, gboolean writable, gboolean allow_sidecar, gboolean enabled)
}
g_list_free(filter_list);
- filter_list = NULL;
+ filter_list = nullptr;
}
void filter_add_defaults(void)
gchar *name;
gchar *desc;
gchar **extensions;
- GString *filter = NULL;
+ GString *filter = nullptr;
guint i;
format = static_cast<GdkPixbufFormat *>(work->data);
GList *filter_to_list(const gchar *extensions)
{
- GList *list = NULL;
+ GList *list = nullptr;
const gchar *p;
- if (!extensions) return NULL;
+ if (!extensions) return nullptr;
p = extensions;
while (*p != '\0')
guint i;
string_list_free(extension_list);
- extension_list = NULL;
+ extension_list = nullptr;
string_list_free(file_writable_list);
- file_writable_list = NULL;
+ file_writable_list = nullptr;
string_list_free(file_sidecar_list);
- file_sidecar_list = NULL;
+ file_sidecar_list = nullptr;
for (i = 0; i < FILE_FORMAT_CLASSES; i++)
{
string_list_free(file_class_extension_list[i]);
- file_class_extension_list[i] = NULL;
+ file_class_extension_list[i] = nullptr;
}
work = filter_list;
work = work->next;
}
- return NULL;
+ return nullptr;
}
const gchar *registered_extension_from_path(const gchar *name)
{
{
old_fe = filter_get_by_key(fe.key);
- if (old_fe != NULL) filter_remove_entry(old_fe);
+ if (old_fe != nullptr) filter_remove_entry(old_fe);
filter_add(fe.key, fe.description, fe.extensions, fe.file_class, fe.writable, fe.allow_sidecar, fe.enabled);
}
g_free(fe.key);
g_free(ext);
}
g_list_free(sidecar_ext_list);
- sidecar_ext_list = NULL;
+ sidecar_ext_list = nullptr;
}
void sidecar_ext_parse(const gchar *text)
{
sidecar_ext_free_list();
- if (text == NULL) return;
+ if (text == nullptr) return;
sidecar_ext_list = filter_to_list(text);
}
}
else if (state & FULLSCREEN_CURSOR_NORMAL)
{
- gdk_window_set_cursor(window, NULL);
+ gdk_window_set_cursor(window, nullptr);
}
else
{
gint w, h;
GdkGeometry geometry;
- if (!window || !imd) return NULL;
+ if (!window || !imd) return nullptr;
fs = g_new0(FullScreenData, 1);
fullscreen_prefs_get_geometry(options->fullscreen.screen, window, &x, &y, &w, &h,
&screen, &fs->same_region);
- fs->window = window_new(GTK_WINDOW_TOPLEVEL, "fullscreen", NULL, NULL, _("Full screen"));
+ fs->window = window_new(GTK_WINDOW_TOPLEVEL, "fullscreen", nullptr, nullptr, _("Full screen"));
DEBUG_NAME(fs->window);
g_signal_connect(G_OBJECT(fs->window), "delete_event",
{
GdkWindow *gdkwin;
gdkwin = gtk_widget_get_window(fs->window);
- if (gdkwin != NULL)
+ if (gdkwin != nullptr)
gdk_window_set_fullscreen_mode(gdkwin, GDK_FULLSCREEN_ON_ALL_MONITORS);
}
{
gtk_widget_hide(fs->normal_window);
}
- image_change_fd(fs->normal_imd, NULL, image_zoom_get(fs->normal_imd));
+ image_change_fd(fs->normal_imd, nullptr, image_zoom_get(fs->normal_imd));
}
return fs;
GList *fullscreen_prefs_list(void)
{
- GList *list = NULL;
+ GList *list = nullptr;
GdkDisplay *display;
gint number;
gint i;
{
gdk_screen_get_monitor_geometry(screen, j, &rect);
subname = gdk_screen_get_monitor_plug_name(screen, j);
- if (subname == NULL)
+ if (subname == nullptr)
{
subname = g_strdup_printf("%s %d", _("Monitor"), j + 1);
}
if (sd->number == screen) return sd;
}
- return NULL;
+ return nullptr;
}
/* screen is interpreted as such:
}
else
{
- sd = NULL;
+ sd = nullptr;
if (screen < 0) screen = 1;
}
gint current = 0;
gint n;
- if (!screen_value) return NULL;
+ if (!screen_value) return nullptr;
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
DEBUG_NAME(vbox);
{
const gchar *t1 = "";
- if (!histogram) return NULL;
+ if (!histogram) return nullptr;
if (histogram->histogram_mode)
switch (histogram->histogram_channel)
{
if (fd->histmap && !fd->histmap->idle_id) return fd->histmap; /* histmap exists and is finished */
- return NULL;
+ return nullptr;
}
static gboolean histmap_idle_cb(gpointer data)
{
/* finished */
g_object_unref(fd->histmap->pixbuf); /*pixbuf is no longer needed */
- fd->histmap->pixbuf = NULL;
+ fd->histmap->pixbuf = nullptr;
fd->histmap->idle_id = 0;
file_data_send_notification(fd, NOTIFY_HISTMAP);
return G_SOURCE_REMOVE;
fd->histmap->pixbuf = fd->pixbuf;
g_object_ref(fd->histmap->pixbuf);
- fd->histmap->idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, histmap_idle_cb, fd, NULL);
+ fd->histmap->idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, histmap_idle_cb, fd, nullptr);
return TRUE;
}
{
DEBUG_1("Notify histogram: %s %04x", fd->path, type);
histmap_free(fd->histmap);
- fd->histmap = NULL;
+ fd->histmap = nullptr;
}
}
*-----------------------------------------------------------------------------
*/
-static GList *history_chain = NULL;
+static GList *history_chain = nullptr;
static guint chain_index = G_MAXUINT;
static gboolean nav_button = FALSE; /** Used to prevent the nav buttons making entries to the chain **/
*
*-----------------------------------------------------------------------------
*/
-static GList *image_chain = NULL;
+static GList *image_chain = nullptr;
static guint image_chain_index = G_MAXUINT;
static gboolean image_nav_button = FALSE; /** Used to prevent the nav buttons making entries to the chain **/
const gchar *image_chain_back()
GList *list;
};
-static GList *history_list = NULL;
+static GList *history_list = nullptr;
static gchar *quoted_from_text(const gchar *text)
gint c = 0;
gint l = strlen(text);
- if (l == 0) return NULL;
+ if (l == 0) return nullptr;
while (c < l && text[c] !='"') c++;
if (text[c] == '"')
}
}
}
- return NULL;
+ return nullptr;
}
gboolean history_list_load(const gchar *path)
{
FILE *f;
- gchar *key = NULL;
+ gchar *key = nullptr;
gchar s_buf[1024];
gchar *pathl;
{
GList *work = history_list;
- if (!key) return NULL;
+ if (!key) return nullptr;
while (work)
{
if (strcmp(hd->key, key) == 0) return hd;
work = work->next;
}
- return NULL;
+ return nullptr;
}
const gchar *history_list_find_last_path_by_key(const gchar *key)
HistoryData *hd;
hd = history_list_find_by_key(key);
- if (!hd || !hd->list) return NULL;
+ if (!hd || !hd->list) return nullptr;
return static_cast<const gchar *>(hd->list->data);
}
{
hd = g_new(HistoryData, 1);
hd->key = g_strdup(key);
- hd->list = NULL;
+ hd->list = nullptr;
history_list = g_list_prepend(history_list, hd);
}
{
gint len = 0;
GList *work = hd->list;
- GList *last = NULL;
+ GList *last = nullptr;
while (work)
{
void history_list_item_remove(const gchar *key, const gchar *path)
{
- history_list_item_change(key, path, NULL);
+ history_list_item_change(key, path, nullptr);
}
GList *history_list_get_by_key(const gchar *key)
HistoryData *hd;
hd = history_list_find_by_key(key);
- if (!hd) return NULL;
+ if (!hd) return nullptr;
return hd->list;
}
HistoryData *hd;
GList *work;
gchar *dirname;
- gchar *ret = NULL;
+ gchar *ret = nullptr;
if (options->recent_folder_image_list_maxsize == 0)
{
- return NULL;
+ return nullptr;
}
hd = history_list_find_by_key("image_list");
{
hd = g_new(HistoryData, 1);
hd->key = g_strdup("image_list");
- hd->list = NULL;
+ hd->list = nullptr;
history_list = g_list_prepend(history_list, hd);
}
{
HistoryData *hd;
GList *work;
- gchar *image_dir = NULL;
- gchar *list_dir = NULL;
+ gchar *image_dir = nullptr;
+ gchar *list_dir = nullptr;
gboolean found = FALSE;
if (options->recent_folder_image_list_maxsize == 0)
{
hd = g_new(HistoryData, 1);
hd->key = g_strdup("image_list");
- hd->list = NULL;
+ hd->list = nullptr;
history_list = g_list_prepend(history_list, hd);
}
gboolean ret = FALSE;
gchar *randname;
gchar *cmd_line;
- FILE *fp = NULL;
+ FILE *fp = nullptr;
gint line_count = 0;
- GString *file_names = g_string_new(NULL);
+ GString *file_names = g_string_new(nullptr);
gchar line[LINE_LENGTH];
- gchar **split_line = NULL;
+ gchar **split_line = nullptr;
gchar *cache_found;
gchar *pathl;
{
g_strfreev(split_line);
}
- split_line = NULL;
+ split_line = nullptr;
}
fclose(fp);
cmd_line = g_strdup_printf("montage %s -geometry %dx%d+1+1 %s >/dev/null 2>&1", file_names->str, options->thumbnails.max_width, options->thumbnails.max_height, randname);
runcmd(cmd_line);
- ld->pixbuf = gdk_pixbuf_new_from_file(randname, NULL);
+ ld->pixbuf = gdk_pixbuf_new_from_file(randname, nullptr);
if (ld->pixbuf)
{
ld->area_updated_cb(loader, 0, 0, gdk_pixbuf_get_width(ld->pixbuf), gdk_pixbuf_get_height(ld->pixbuf), ld->data);
}
static gchar** image_loader_collection_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/png", NULL};
+ static const gchar *mime[] = {"image/png", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_collection_new;
funcs->set_size = image_loader_collection_set_size;
funcs->load = image_loader_collection_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_collection_get_pixbuf;
funcs->close = image_loader_collection_close;
funcs->abort = image_loader_collection_abort;
gint i, j;
guint w;
- g_return_if_fail (cinfo != NULL);
+ g_return_if_fail (cinfo != nullptr);
g_return_if_fail (cinfo->output_components == 1);
g_return_if_fail (cinfo->out_color_space == JCS_GRAYSCALE);
gint i;
guint j;
- g_return_if_fail (cinfo != NULL);
+ g_return_if_fail (cinfo != nullptr);
g_return_if_fail (cinfo->output_components == 4);
g_return_if_fail (cinfo->out_color_space == JCS_CMYK);
/* broken check for *error == NULL for robustness against
* crappy JPEG library
*/
- if (errmgr->error && *errmgr->error == NULL) {
+ if (errmgr->error && *errmgr->error == nullptr) {
g_set_error (errmgr->error,
GDK_PIXBUF_ERROR,
cinfo->err->msg_code == JERR_OUT_OF_MEMORY
{
struct jpeg_source_mgr* src;
- if (cinfo->src == NULL)
+ if (cinfo->src == nullptr)
{ /* first time for this JPEG object? */
cinfo->src = static_cast<struct jpeg_source_mgr *>((*cinfo->mem->alloc_small) (
reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT,
struct jpeg_decompress_struct cinfo2;
guchar *dptr, *dptr2;
guint rowstride;
- guchar *stereo_buf2 = NULL;
+ guchar *stereo_buf2 = nullptr;
guint stereo_length = 0;
struct error_handler_data jerr;
}
static gchar** image_loader_cr3_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/x-canon-cr3", NULL};
+ static const gchar *mime[] = {"image/x-canon-cr3", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_cr3_new;
funcs->set_size = image_loader_cr3_set_size;
funcs->load = image_loader_cr3_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_cr3_get_pixbuf;
funcs->close = image_loader_cr3_close;
funcs->abort = image_loader_cr3_abort;
guchar *ddsDecodeDXT1(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
uint w = (width + 3) / 4;
uint h = (height + 3) / 4;
guchar *ddsDecodeDXT3(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
uint w = (width + 3) / 4;
uint h = (height + 3) / 4;
guchar *ddsDecodeDXT5(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
uint w = (width + 3) / 4;
uint h = (height + 3) / 4;
guchar *ddsReadA1R5G5B5(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint rgba = (buffer[index] & 0xFF) | (buffer[index + 1] & 0xFF) << 8; index += 2;
guchar *ddsReadX1R5G5B5(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint rgba = (buffer[index] & 0xFF) | (buffer[index + 1] & 0xFF) << 8; index += 2;
guchar *ddsReadA4R4G4B4(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint rgba = (buffer[index] & 0xFF) | (buffer[index + 1] & 0xFF) << 8; index += 2;
guchar *ddsReadX4R4G4B4(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint rgba = (buffer[index] & 0xFF) | (buffer[index + 1] & 0xFF) << 8; index += 2;
guchar *ddsReadR5G6B5(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint rgba = (buffer[index] & 0xFF) | (buffer[index + 1] & 0xFF) << 8; index += 2;
guchar *ddsReadR8G8B8(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint b = buffer[index++] & 0xFF;
guchar *ddsReadA8B8G8R8(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint r = buffer[index++] & 0xFF;
guchar *ddsReadX8B8G8R8(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint r = buffer[index++] & 0xFF;
guchar *ddsReadA8R8G8B8(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint b = buffer[index++] & 0xFF;
guchar *ddsReadX8R8G8B8(uint width, uint height, const unsigned char *buffer) {
auto pixels = static_cast<uint *>(g_try_malloc(4 * width*height));
- if (pixels == NULL) return NULL;
+ if (pixels == nullptr) return nullptr;
uint index = 128;
for (uint i = 0; i<height*width; i++) {
uint b = buffer[index++] & 0xFF;
uint type = ddsGetType(buf);
if (type == 0) return FALSE;
{
- guchar *pixels = NULL;
+ guchar *pixels = nullptr;
guint rowstride = width * 4;
switch (type) {
case DXT1: pixels = ddsDecodeDXT1(width, height, buf); break;
case A8R8G8B8: pixels = ddsReadA8R8G8B8(width, height, buf); break;
case X8R8G8B8: pixels = ddsReadX8R8G8B8(width, height, buf); break;
}
- ld->pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8, width, height, rowstride, free_buffer, NULL);
+ ld->pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8, width, height, rowstride, free_buffer, nullptr);
ld->area_updated_cb(loader, 0, 0, width, height, ld->data);
return TRUE;
}
}
static gchar** image_loader_dds_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/vnd-ms.dds", NULL};
+ static const gchar *mime[] = {"image/vnd-ms.dds", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_dds_new;
funcs->set_size = image_loader_dds_set_size;
funcs->load = image_loader_dds_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_dds_get_pixbuf;
funcs->close = image_loader_dds_close;
funcs->abort = image_loader_dds_abort;
runcmd(cmd_line);
- ld->pixbuf = gdk_pixbuf_new_from_file(randname, NULL);
+ ld->pixbuf = gdk_pixbuf_new_from_file(randname, nullptr);
ld->area_updated_cb(loader, 0, 0, gdk_pixbuf_get_width(ld->pixbuf), gdk_pixbuf_get_height(ld->pixbuf), ld->data);
static gchar** image_loader_external_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"application/octet-stream", NULL};
+ static const gchar *mime[] = {"application/octet-stream", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_external_new;
funcs->set_size = image_loader_external_set_size;
funcs->load = image_loader_external_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_external_get_pixbuf;
funcs->close = image_loader_external_close;
funcs->abort = image_loader_external_abort;
static gchar** image_loader_ft_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"video/mp4", NULL};
+ static const gchar *mime[] = {"video/mp4", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
lft->area_updated_cb(loader, 0, 0, image->image_data_width, image->image_data_height, lft->data);
#else
GInputStream *image_stream;
- image_stream = g_memory_input_stream_new_from_data (image->image_data_ptr, image->image_data_size, NULL);
+ image_stream = g_memory_input_stream_new_from_data (image->image_data_ptr, image->image_data_size, nullptr);
- if (image_stream == NULL)
+ if (image_stream == nullptr)
{
video_thumbnailer_destroy_image_data (image);
DEBUG_1("FFmpegthumbnailer: cannot open stream for %s", il->fd->path);
return FALSE;
}
- lft->pixbuf = gdk_pixbuf_new_from_stream (image_stream, NULL, NULL);
+ lft->pixbuf = gdk_pixbuf_new_from_stream (image_stream, nullptr, nullptr);
lft->size_cb(loader, gdk_pixbuf_get_width(lft->pixbuf), gdk_pixbuf_get_height(lft->pixbuf), lft->data);
g_object_unref (image_stream);
video_thumbnailer_destroy_image_data (image);
funcs->loader_new = image_loader_ft_new;
funcs->set_size = image_loader_ft_set_size;
funcs->load = image_loader_ft_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_ft_get_pixbuf;
funcs->close = image_loader_ft_close;
funcs->abort = image_loader_ft_abort;
}
else
{
- return NULL;
+ return nullptr;
}
}
static gchar** image_loader_gdk_get_format_mime_types(gpointer loader)
{
funcs->loader_new = image_loader_gdk_new;
funcs->set_size = reinterpret_cast<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
- funcs->load = NULL;
+ funcs->load = nullptr;
funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
gint i, j;
guint w;
- g_return_if_fail (cinfo != NULL);
+ g_return_if_fail (cinfo != nullptr);
g_return_if_fail (cinfo->output_components == 1);
g_return_if_fail (cinfo->out_color_space == JCS_GRAYSCALE);
gint i;
guint j;
- g_return_if_fail (cinfo != NULL);
+ g_return_if_fail (cinfo != nullptr);
g_return_if_fail (cinfo->output_components == 4);
g_return_if_fail (cinfo->out_color_space == JCS_CMYK);
/* broken check for *error == NULL for robustness against
* crappy JPEG library
*/
- if (errmgr->error && *errmgr->error == NULL) {
+ if (errmgr->error && *errmgr->error == nullptr) {
g_set_error (errmgr->error,
GDK_PIXBUF_ERROR,
cinfo->err->msg_code == JERR_OUT_OF_MEMORY
{
struct jpeg_source_mgr* src;
- if (cinfo->src == NULL)
+ if (cinfo->src == nullptr)
{ /* first time for this JPEG object? */
cinfo->src = static_cast<struct jpeg_source_mgr *>((*cinfo->mem->alloc_small) (
reinterpret_cast<j_common_ptr>(cinfo), JPOOL_PERMANENT,
struct jpeg_decompress_struct cinfo2;
guchar *dptr, *dptr2;
guint rowstride;
- guchar *stereo_buf2 = NULL;
+ guchar *stereo_buf2 = nullptr;
guint stereo_length = 0;
struct error_handler_data jerr;
}
static gchar** image_loader_jpeg_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/jpeg", NULL};
+ static const gchar *mime[] = {"image/jpeg", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_jpeg_new;
funcs->set_size = image_loader_jpeg_set_size;
funcs->load = image_loader_jpeg_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_jpeg_get_pixbuf;
funcs->close = image_loader_jpeg_close;
funcs->abort = image_loader_jpeg_abort;
guchar *libraw_get_preview(ImageLoader *UNUSED(il), guint *UNUSED(data_len))
{
- return NULL;
+ return nullptr;
}
#endif
ctx->buffer = static_cast<guchar *>(g_malloc(PSD_HEADER_SIZE));
reset_context_buffer(ctx);
- ctx->ch_bufs = NULL;
+ ctx->ch_bufs = nullptr;
ctx->curr_ch = 0;
ctx->curr_row = 0;
ctx->pos = 0;
- ctx->lines_lengths = NULL;
+ ctx->lines_lengths = nullptr;
ctx->finalized = FALSE;
while (size > 0) {
ctx->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
FALSE, 8, ctx->width, ctx->height);
- if (ctx->lines_lengths == NULL || ctx->buffer == NULL ||
- ctx->pixbuf == NULL)
+ if (ctx->lines_lengths == nullptr || ctx->buffer == nullptr ||
+ ctx->pixbuf == nullptr)
{
log_printf("warning: Insufficient memory to load PSD image file\n");
free_context(ctx);
ctx->ch_bufs[i] =
static_cast<guchar *>(g_malloc(ctx->width*ctx->height*ctx->depth_bytes));
- if (ctx->ch_bufs[i] == NULL) {
+ if (ctx->ch_bufs[i] == nullptr) {
log_printf("warning: Insufficient memory to load PSD image file\n");
free_context(ctx);
return FALSE;
static gchar** image_loader_psd_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"application/psd", NULL};
+ static const gchar *mime[] = {"application/psd", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_psd_new;
funcs->set_size = image_loader_psd_set_size;
funcs->load = image_loader_psd_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_psd_get_pixbuf;
funcs->close = image_loader_psd_close;
funcs->abort = image_loader_psd_abort;
}
static gchar** image_loader_svgz_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/svg", NULL};
+ static const gchar *mime[] = {"image/svg", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
static gpointer image_loader_svgz_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
{
- GError *error = NULL;
+ GError *error = nullptr;
GdkPixbufLoader *loader = gdk_pixbuf_loader_new_with_mime_type("image/svg", &error);
if (error)
{
g_error_free(error);
- return NULL;
+ return nullptr;
}
g_signal_connect(G_OBJECT(loader), "area_updated", G_CALLBACK(area_updated_cb), data);
{
funcs->loader_new = image_loader_svgz_new;
funcs->set_size = reinterpret_cast<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
- funcs->load = NULL;
+ funcs->load = nullptr;
funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
return FALSE;
}
- ld->pixbuf = gdk_pixbuf_new_from_data(pixels, GDK_COLORSPACE_RGB, FALSE, 8, width, height, width * 3, free_buffer, NULL);
+ ld->pixbuf = gdk_pixbuf_new_from_data(pixels, GDK_COLORSPACE_RGB, FALSE, 8, width, height, width * 3, free_buffer, nullptr);
if (!ld->pixbuf)
{
static gchar **image_loader_zxscr_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"application/octet-stream", NULL};
+ static const gchar *mime[] = {"application/octet-stream", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
funcs->loader_new = image_loader_zxscr_new;
funcs->set_size = image_loader_zxscr_set_size;
funcs->load = image_loader_zxscr_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_zxscr_get_pixbuf;
funcs->close = image_loader_zxscr_close;
funcs->abort = image_loader_zxscr_abort;
{
static const GTypeInfo info = {
sizeof(ImageLoaderClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
+ nullptr, /* base_init */
+ nullptr, /* base_finalize */
static_cast<GClassInitFunc>(image_loader_class_init_wrapper), /* class_init */
- NULL, /* class_finalize */
- NULL, /* class_data */
+ nullptr, /* class_finalize */
+ nullptr, /* class_data */
sizeof(ImageLoader),
0, /* n_preallocs */
static_cast<GInstanceInitFunc>(image_loader_init), /* instance_init */
- NULL /* value_table */
+ nullptr /* value_table */
};
type = g_type_register_static(G_TYPE_OBJECT, "ImageLoaderType", &info, GTypeFlags(0));
}
{
auto il = reinterpret_cast<ImageLoader *>(instance);
- il->pixbuf = NULL;
+ il->pixbuf = nullptr;
il->idle_id = 0;
il->idle_priority = G_PRIORITY_DEFAULT_IDLE;
il->done = FALSE;
- il->loader = NULL;
+ il->loader = nullptr;
il->bytes_read = 0;
il->bytes_total = 0;
il->idle_read_loop_count = IMAGE_LOADER_IDLE_READ_LOOP_COUNT_DEFAULT;
il->read_buffer_size = IMAGE_LOADER_READ_BUFFER_SIZE_DEFAULT;
- il->mapped_file = NULL;
+ il->mapped_file = nullptr;
il->preview = IMAGE_LOADER_PREVIEW_NONE;
il->requested_width = 0;
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(ImageLoaderClass, area_ready),
- NULL, NULL,
+ nullptr, nullptr,
gq_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(ImageLoaderClass, error),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(ImageLoaderClass, done),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(ImageLoaderClass, percent),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__DOUBLE,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(ImageLoaderClass, area_ready),
- NULL, NULL,
+ nullptr, nullptr,
gq_marshal_VOID__INT_INT,
G_TYPE_NONE, 2,
G_TYPE_INT,
{
ImageLoader *il;
- if (!fd) return NULL;
+ if (!fd) return nullptr;
- il = static_cast<ImageLoader *>(g_object_new(TYPE_IMAGE_LOADER, NULL));
+ il = static_cast<ImageLoader *>(g_object_new(TYPE_IMAGE_LOADER, nullptr));
il->fd = file_data_ref(fd);
static void image_loader_emit_done(ImageLoader *il)
{
- g_idle_add_full(il->idle_priority, image_loader_emit_done_cb, il, NULL);
+ g_idle_add_full(il->idle_priority, image_loader_emit_done_cb, il, nullptr);
}
static void image_loader_emit_error(ImageLoader *il)
{
- g_idle_add_full(il->idle_priority, image_loader_emit_error_cb, il, NULL);
+ g_idle_add_full(il->idle_priority, image_loader_emit_error_cb, il, nullptr);
}
static void image_loader_emit_percent(ImageLoader *il)
{
- g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_percent_cb, il, NULL);
+ g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_percent_cb, il, nullptr);
}
static void image_loader_emit_size(ImageLoader *il)
{
- g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_size_cb, il, NULL);
+ g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_size_cb, il, nullptr);
}
static ImageLoaderAreaParam *image_loader_queue_area_ready(ImageLoader *il, GList **list, guint x, guint y, guint w, guint h)
{
/* we can merge the notifications */
prev_par->h += h;
- return NULL;
+ return nullptr;
}
if (prev_par->x == x && prev_par->w == w &&
y + h == prev_par->y)
/* we can merge the notifications */
prev_par->h += h;
prev_par->y = y;
- return NULL;
+ return nullptr;
}
if (prev_par->y == y && prev_par->h == h &&
prev_par->x + prev_par->w == x)
{
/* we can merge the notifications */
prev_par->w += w;
- return NULL;
+ return nullptr;
}
if (prev_par->y == y && prev_par->h == h &&
x + w == prev_par->x)
/* we can merge the notifications */
prev_par->w += w;
prev_par->x = x;
- return NULL;
+ return nullptr;
}
}
if (par)
{
- g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_area_ready_cb, par, NULL);
+ g_idle_add_full(G_PRIORITY_HIGH, image_loader_emit_area_ready_cb, par, nullptr);
}
}
if (il->loader)
{
/* some loaders do not have a pixbuf till close, order is important here */
- il->backend.close(il->loader, il->error ? NULL : &il->error); /* we are interested in the first error only */
+ il->backend.close(il->loader, il->error ? nullptr : &il->error); /* we are interested in the first error only */
image_loader_sync_pixbuf(il);
il->backend.free(il->loader);
- il->loader = NULL;
+ il->loader = nullptr;
}
g_mutex_lock(il->data_mutex);
il->done = TRUE;
if (!il || il->loader || il->mapped_file) return FALSE;
- il->mapped_file = NULL;
+ il->mapped_file = nullptr;
if (il->fd)
{
* section that is not a jpeg */
if (!(il->mapped_file[0] == 0xFF && il->mapped_file[1] == 0xD8))
{
- il->mapped_file = NULL;
+ il->mapped_file = nullptr;
}
else
{
* section that is not a jpeg */
if (!(il->mapped_file[0] == 0xFF && il->mapped_file[1] == 0xD8))
{
- il->mapped_file = NULL;
+ il->mapped_file = nullptr;
}
else
{
return FALSE;
}
- il->mapped_file = static_cast<guchar *>(mmap(0, il->bytes_total, PROT_READ|PROT_WRITE, MAP_PRIVATE, load_fd, 0));
+ il->mapped_file = static_cast<guchar *>(mmap(nullptr, il->bytes_total, PROT_READ|PROT_WRITE, MAP_PRIVATE, load_fd, 0));
close(load_fd);
if (il->mapped_file == MAP_FAILED)
{
- il->mapped_file = 0;
+ il->mapped_file = nullptr;
return FALSE;
}
il->preview = IMAGE_LOADER_PREVIEW_NONE;
{
munmap(il->mapped_file, il->bytes_total);
}
- il->mapped_file = NULL;
+ il->mapped_file = nullptr;
}
}
/* send delayed */
GList *list, *work;
list = g_list_reverse(il->area_param_delayed_list);
- il->area_param_delayed_list = NULL;
+ il->area_param_delayed_list = nullptr;
g_mutex_unlock(il->data_mutex);
work = list;
ret = image_loader_begin(il);
- if (ret && !il->done) il->idle_id = g_idle_add_full(il->idle_priority, image_loader_idle_cb, il, NULL);
+ if (ret && !il->done) il->idle_id = g_idle_add_full(il->idle_priority, image_loader_idle_cb, il, nullptr);
return ret;
}
/**************************************************************************************/
/* execution via thread */
-static GThreadPool *image_loader_thread_pool = NULL;
+static GThreadPool *image_loader_thread_pool = nullptr;
-static GCond *image_loader_prio_cond = NULL;
-static GMutex *image_loader_prio_mutex = NULL;
+static GCond *image_loader_prio_cond = nullptr;
+static GMutex *image_loader_prio_mutex = nullptr;
static gint image_loader_prio_num = 0;
if (!image_loader_thread_pool)
{
- image_loader_thread_pool = g_thread_pool_new(image_loader_thread_run, NULL, -1, FALSE, NULL);
+ image_loader_thread_pool = g_thread_pool_new(image_loader_thread_run, nullptr, -1, FALSE, nullptr);
if (!image_loader_prio_cond) image_loader_prio_cond = g_new(GCond, 1);
g_cond_init(image_loader_prio_cond);
if (!image_loader_prio_mutex) image_loader_prio_mutex = g_new(GMutex, 1);
il->can_destroy = FALSE; /* ImageLoader can't be freed until image_loader_thread_run finishes */
- g_thread_pool_push(image_loader_thread_pool, il, NULL);
+ g_thread_pool_push(image_loader_thread_pool, il, nullptr);
DEBUG_1("Thread pool num threads: %d", g_thread_pool_get_num_threads(image_loader_thread_pool));
return TRUE;
GdkPixbuf *image_loader_get_pixbuf(ImageLoader *il)
{
GdkPixbuf *ret;
- if (!il) return NULL;
+ if (!il) return nullptr;
g_mutex_lock(il->data_mutex);
ret = il->pixbuf;
FileData *image_loader_get_fd(ImageLoader *il)
{
FileData *ret;
- if (!il) return NULL;
+ if (!il) return nullptr;
g_mutex_lock(il->data_mutex);
ret = il->fd;
const gchar *image_loader_get_error(ImageLoader *il)
{
- const gchar *ret = NULL;
- if (!il) return NULL;
+ const gchar *ret = nullptr;
+ if (!il) return nullptr;
g_mutex_lock(il->data_mutex);
if (il->error) ret = il->error->message;
g_mutex_unlock(il->data_mutex);
};
static OSDIcon osd_icons[] = {
- { TRUE, 0, 0, NULL }, /* none */
- { TRUE, -10, -10, NULL }, /* auto rotated */
- { TRUE, -10, -10, NULL }, /* user rotated */
- { TRUE, -40, -10, NULL }, /* color embedded */
- { TRUE, -70, -10, NULL }, /* first image */
- { TRUE, -70, -10, NULL }, /* last image */
- { FALSE, -70, -10, NULL }, /* osd enabled */
- { FALSE, 0, 0, NULL }
+ { TRUE, 0, 0, nullptr }, /* none */
+ { TRUE, -10, -10, nullptr }, /* auto rotated */
+ { TRUE, -10, -10, nullptr }, /* user rotated */
+ { TRUE, -40, -10, nullptr }, /* color embedded */
+ { TRUE, -70, -10, nullptr }, /* first image */
+ { TRUE, -70, -10, nullptr }, /* last image */
+ { FALSE, -70, -10, nullptr }, /* osd enabled */
+ { FALSE, 0, 0, nullptr }
};
#define OSD_DATA "overlay-data"
{
OverlayStateData *osd;
- if (!imd) return NULL;
+ if (!imd) return nullptr;
g_assert(imd->pr);
static GdkPixbuf *image_osd_info_render(OverlayStateData *osd)
{
- GdkPixbuf *pixbuf = NULL;
+ GdkPixbuf *pixbuf = nullptr;
gint width, height;
PangoLayout *layout;
const gchar *name;
gchar *text;
gboolean with_hist;
- const HistMap *histmap = NULL;
+ const HistMap *histmap = nullptr;
ImageWindow *imd = osd->imd;
FileData *fd = image_get_fd(imd);
PangoFontDescription *font_desc;
- if (!fd) return NULL;
+ if (!fd) return nullptr;
name = image_get_name(imd);
if (name)
CollectInfo *info;
GHashTable *vars;
- vars = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
+ vars = g_hash_table_new_full(g_str_hash, g_str_equal, nullptr, g_free);
cd = image_get_collection(imd, &info);
if (cd)
}
else
{
- t = layout_list_count(lw, NULL);
+ t = layout_list_count(lw, nullptr);
n = layout_list_get_index(lw, image_get_fd(lw->image)) + 1;
}
}
if (n < 1) n = 1;
if (t < 1) t = 1;
- osd_template_insert(vars, "collection", NULL, OSDT_NONE);
+ osd_template_insert(vars, "collection", nullptr, OSDT_NONE);
}
osd_template_insert(vars, "number", g_strdup_printf("%d", n), OSDT_NO_DUP);
}
else
{
- osd_template_insert(vars, "width", NULL, OSDT_NONE);
- osd_template_insert(vars, "height", NULL, OSDT_NONE);
- osd_template_insert(vars, "res", NULL, OSDT_NONE);
+ osd_template_insert(vars, "width", nullptr, OSDT_NONE);
+ osd_template_insert(vars, "height", nullptr, OSDT_NONE);
+ osd_template_insert(vars, "res", nullptr, OSDT_NONE);
}
text = image_osd_mkinfo(options->image_overlay.template_string, imd->image_fd, vars);
}
font_desc = pango_font_description_from_string(options->image_overlay.font);
- layout = gtk_widget_create_pango_layout(imd->pr, NULL);
+ layout = gtk_widget_create_pango_layout(imd->pr, nullptr);
pango_layout_set_font_description(layout, font_desc);
pango_layout_set_markup(layout, text, -1);
static GdkPixbuf *image_osd_icon_pixbuf(ImageOSDFlag flag)
{
- static GdkPixbuf **icons = NULL;
- GdkPixbuf *icon = NULL;
+ static GdkPixbuf **icons = nullptr;
+ GdkPixbuf *icon = nullptr;
if (!icons) icons = g_new0(GdkPixbuf *, IMAGE_OSD_COUNT);
if (icons[flag]) return icons[flag];
if (!osd->idle_id)
{
- osd->idle_id = g_idle_add_full(G_PRIORITY_HIGH, image_osd_update_cb, osd, NULL);
+ osd->idle_id = g_idle_add_full(G_PRIORITY_HIGH, image_osd_update_cb, osd, nullptr);
}
}
if (osd->imd)
{
- image_set_osd_data(osd->imd, NULL);
+ image_set_osd_data(osd->imd, nullptr);
g_signal_handler_disconnect(osd->imd->pr, osd->destroy_id);
- image_set_state_func(osd->imd, NULL, NULL);
+ image_set_state_func(osd->imd, nullptr, nullptr);
image_osd_info_hide(osd);
image_osd_icons_hide(osd);
{
auto osd = static_cast<OverlayStateData *>(data);
- osd->imd = NULL;
+ osd->imd = nullptr;
image_osd_free(osd);
}
{
OverlayStateData *osd = image_get_osd_data(imd);
- return osd ? osd->histogram : NULL;
+ return osd ? osd->histogram : nullptr;
}
void image_osd_copy_status(ImageWindow *src, ImageWindow *dest)
#include <math.h>
-static GList *image_list = NULL;
+static GList *image_list = nullptr;
void image_update_title(ImageWindow *imd);
static void image_read_ahead_start(ImageWindow *imd);
void image_update_title(ImageWindow *imd)
{
- gchar *title = NULL;
- gchar *zoom = NULL;
- gchar *collection = NULL;
+ gchar *title = nullptr;
+ gchar *zoom = nullptr;
+ gchar *collection = nullptr;
LayoutWindow *lw;
- gchar *lw_ident = NULL;
+ gchar *lw_ident = nullptr;
if (!imd->top_window) return;
ColorMan *cm;
ColorManProfileType input_type;
ColorManProfileType screen_type;
- const gchar *input_file = NULL;
- const gchar *screen_file = NULL;
- guchar *profile = NULL;
+ const gchar *input_file = nullptr;
+ const gchar *screen_file = nullptr;
+ guchar *profile = nullptr;
guint profile_len;
- guchar *screen_profile = NULL;
+ guchar *screen_profile = nullptr;
gint screen_profile_len;
ExifData *exif;
imd->color_profile_input < COLOR_PROFILE_FILE)
{
input_type = static_cast<ColorManProfileType>(imd->color_profile_input);
- input_file = NULL;
+ input_file = nullptr;
}
else
{
else
{
screen_type = COLOR_PROFILE_SRGB;
- screen_file = NULL;
+ screen_file = nullptr;
}
if (!imd->color_profile_use_image)
{
g_free(profile);
- profile = NULL;
+ profile = nullptr;
}
DEBUG_1("Found embedded color profile");
imd->color_profile_from_image = COLOR_PROFILE_MEM;
if (imd->color_profile_use_image && imd->color_profile_from_image != COLOR_PROFILE_NONE)
{
input_type = static_cast<ColorManProfileType>(imd->color_profile_from_image);
- input_file = NULL;
+ input_file = nullptr;
}
}
if (profile)
{
- cm = color_man_new_embedded(run_in_bg ? imd : NULL, NULL,
+ cm = color_man_new_embedded(run_in_bg ? imd : nullptr, nullptr,
profile, profile_len,
screen_type, screen_file, screen_profile, screen_profile_len);
g_free(profile);
}
else
{
- cm = color_man_new(run_in_bg ? imd : NULL, NULL,
+ cm = color_man_new(run_in_bg ? imd : nullptr, nullptr,
input_type, input_file,
screen_type, screen_file, screen_profile, screen_profile_len);
}
if (screen_profile)
{
g_free(screen_profile);
- screen_profile = NULL;
+ screen_profile = nullptr;
}
return !!cm;
{
imd->desaturate = desaturate;
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != nullptr) );
else
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), nullptr, nullptr, TRUE);
pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
}
{
imd->overunderexposed = overunderexposed;
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != nullptr) );
else
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), nullptr, nullptr, TRUE);
pixbuf_renderer_set_orientation(reinterpret_cast<PixbufRenderer *>(imd->pr), imd->orientation);
}
DEBUG_1("%s read ahead cancelled for :%s", get_exec_time(), imd->read_ahead_fd ? imd->read_ahead_fd->path : "null");
image_loader_free(imd->read_ahead_il);
- imd->read_ahead_il = NULL;
+ imd->read_ahead_il = nullptr;
file_data_unref(imd->read_ahead_fd);
- imd->read_ahead_fd = NULL;
+ imd->read_ahead_fd = nullptr;
}
static void image_read_ahead_done_cb(ImageLoader *UNUSED(il), gpointer data)
}
}
image_loader_free(imd->read_ahead_il);
- imd->read_ahead_il = NULL;
+ imd->read_ahead_il = nullptr;
image_complete_util(imd, TRUE);
}
static void image_cache_release_cb(FileData *fd)
{
g_object_unref(fd->pixbuf);
- fd->pixbuf = NULL;
+ fd->pixbuf = nullptr;
}
static FileCacheData *image_get_cache(void)
{
- static FileCacheData *cache = NULL;
+ static FileCacheData *cache = nullptr;
if (!cache) cache = file_cache_new(image_cache_release_cb, 1);
file_cache_set_max_size(cache, static_cast<gulong>(options->image.image_cache_max) * 1048576); /* update from options */
return cache;
}
image_loader_free(imd->il);
- imd->il = NULL;
+ imd->il = nullptr;
// image_post_process(imd, TRUE);
if (override_old_signals)
{
/* override the old signals */
- g_signal_handlers_disconnect_matched(G_OBJECT(imd->il), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, imd);
+ g_signal_handlers_disconnect_matched(G_OBJECT(imd->il), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, imd);
}
g_signal_connect(G_OBJECT(imd->il), "area_ready", (GCallback)image_load_area_cb, imd);
if (imd->read_ahead_il)
{
imd->il = imd->read_ahead_il;
- imd->read_ahead_il = NULL;
+ imd->read_ahead_il = nullptr;
image_load_set_signals(imd, TRUE);
image_loader_delay_area_ready(imd->il, FALSE); /* send the delayed area_ready signals */
file_data_unref(imd->read_ahead_fd);
- imd->read_ahead_fd = NULL;
+ imd->read_ahead_fd = nullptr;
return TRUE;
}
else if (imd->read_ahead_fd->pixbuf)
image_change_pixbuf(imd, imd->read_ahead_fd->pixbuf, image_zoom_get(imd), FALSE);
file_data_unref(imd->read_ahead_fd);
- imd->read_ahead_fd = NULL;
+ imd->read_ahead_fd = nullptr;
// image_post_process(imd, FALSE);
return TRUE;
pr = PIXBUF_RENDERER(imd->pr);
if (pr->pixbuf) g_object_unref(pr->pixbuf);
- pr->pixbuf = NULL;
+ pr->pixbuf = nullptr;
}
g_object_set(G_OBJECT(imd->pr), "loading", TRUE, NULL);
g_object_set(G_OBJECT(imd->pr), "loading", FALSE, NULL);
image_loader_free(imd->il);
- imd->il = NULL;
+ imd->il = nullptr;
image_complete_util(imd, FALSE);
g_object_set(G_OBJECT(imd->pr), "loading", FALSE, NULL);
image_loader_free(imd->il);
- imd->il = NULL;
+ imd->il = nullptr;
color_man_free(static_cast<ColorMan *>(imd->cm));
- imd->cm = NULL;
+ imd->cm = nullptr;
imd->delay_alter_type = ALTER_NONE;
if (!imd->image_fd)
{
- image_change_pixbuf(imd, NULL, zoom, FALSE);
+ image_change_pixbuf(imd, nullptr, zoom, FALSE);
}
else
{
auto imd = static_cast<ImageWindow *>(data);
gboolean in_lw = FALSE;
gint i = 0;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
if (imd->func_scroll && event && event->type == GDK_SCROLL)
{
lw = layout_find_by_image(imd);
- if (!(options->image.fit_window_to_image && lw && (lw->options.tools_float || lw->options.tools_hidden))) window = NULL;
+ if (!(options->image.fit_window_to_image && lw && (lw->options.tools_float || lw->options.tools_hidden))) window = nullptr;
pixbuf_renderer_set_parent(reinterpret_cast<PixbufRenderer *>(imd->pr), reinterpret_cast<GtkWindow *>(window));
const gchar *image_get_path(ImageWindow *imd)
{
- if (imd->image_fd == NULL) return NULL;
+ if (imd->image_fd == nullptr) return nullptr;
return imd->image_fd->path;
}
const gchar *image_get_name(ImageWindow *imd)
{
- if (imd->image_fd == NULL) return NULL;
+ if (imd->image_fd == nullptr) return nullptr;
return imd->image_fd->name;
}
{
if (imd->image_fd == fd) return;
- image_change_real(imd, fd, NULL, NULL, zoom);
+ image_change_real(imd, fd, nullptr, nullptr, zoom);
}
gboolean image_get_image_size(ImageWindow *imd, gint *width, gint *height)
}
}
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, FALSE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), nullptr, nullptr, FALSE);
if (imd->cm)
{
color_man_free(static_cast<ColorMan *>(imd->cm));
- imd->cm = NULL;
+ imd->cm = nullptr;
}
if (lazy)
}
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != nullptr) );
image_state_set(imd, IMAGE_STATE_IMAGE);
}
{
if (collection_to_number(imd->collection) >= 0)
{
- if (g_list_find(imd->collection->list, imd->collection_info) != NULL)
+ if (g_list_find(imd->collection->list, imd->collection_info) != nullptr)
{
if (info) *info = imd->collection_info;
}
else
{
- if (info) *info = NULL;
+ if (info) *info = nullptr;
}
return imd->collection;
}
- if (info) *info = NULL;
- return NULL;
+ if (info) *info = nullptr;
+ return nullptr;
}
static void image_loader_sync_read_ahead_data(ImageLoader *il, gpointer old_data, gpointer data)
imd->collection_info = source->collection_info;
image_loader_free(imd->il);
- imd->il = NULL;
+ imd->il = nullptr;
image_set_fd(imd, image_get_fd(source));
if (source->il)
{
imd->il = source->il;
- source->il = NULL;
+ source->il = nullptr;
image_loader_sync_data(imd->il, source, imd);
imd->color_profile_input = source->color_profile_input;
imd->color_profile_use_image = source->color_profile_use_image;
color_man_free(static_cast<ColorMan *>(imd->cm));
- imd->cm = NULL;
+ imd->cm = nullptr;
if (source->cm)
{
ColorMan *cm;
imd->cm = source->cm;
- source->cm = NULL;
+ source->cm = nullptr;
cm = static_cast<ColorMan *>(imd->cm);
cm->imd = imd;
}
file_data_unref(imd->read_ahead_fd);
- source->read_ahead_fd = NULL;
+ source->read_ahead_fd = nullptr;
imd->orientation = source->orientation;
imd->desaturate = source->desaturate;
pixbuf_renderer_move(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != nullptr) );
else
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), nullptr, nullptr, TRUE);
}
imd->collection_info = source->collection_info;
image_loader_free(imd->il);
- imd->il = NULL;
+ imd->il = nullptr;
image_set_fd(imd, image_get_fd(source));
imd->color_profile_input = source->color_profile_input;
imd->color_profile_use_image = source->color_profile_use_image;
color_man_free(static_cast<ColorMan *>(imd->cm));
- imd->cm = NULL;
+ imd->cm = nullptr;
if (source->cm)
{
ColorMan *cm;
imd->cm = source->cm;
- source->cm = NULL;
+ source->cm = nullptr;
cm = static_cast<ColorMan *>(imd->cm);
cm->imd = imd;
image_loader_free(imd->read_ahead_il);
imd->read_ahead_il = source->read_ahead_il;
- source->read_ahead_il = NULL;
+ source->read_ahead_il = nullptr;
if (imd->read_ahead_il) image_loader_sync_read_ahead_data(imd->read_ahead_il, source, imd);
file_data_unref(imd->read_ahead_fd);
imd->read_ahead_fd = source->read_ahead_fd;
- source->read_ahead_fd = NULL;
+ source->read_ahead_fd = nullptr;
imd->completed = source->completed;
imd->state = source->state;
pixbuf_renderer_copy(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
if (imd->cm || imd->desaturate || imd->overunderexposed)
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != NULL) );
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), image_post_process_tile_color_cb, imd, (imd->cm != nullptr) );
else
- pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), NULL, NULL, TRUE);
+ pixbuf_renderer_set_post_process_func(reinterpret_cast<PixbufRenderer *>(imd->pr), nullptr, nullptr, TRUE);
}
void image_background_set_color_from_options(ImageWindow *imd, gboolean fullscreen)
{
- GdkColor *color = NULL;
+ GdkColor *color = nullptr;
GdkColor theme_color;
GdkRGBA bg_color;
GtkStyleContext *style_context;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
if ((options->image.use_custom_border_color && !fullscreen) ||
(options->image.use_custom_border_color_in_fullscreen && fullscreen))
pr = PIXBUF_RENDERER(imd->pr);
if (pr->pixbuf) g_object_unref(pr->pixbuf);
- pr->pixbuf = NULL;
+ pr->pixbuf = nullptr;
image_load_pixbuf_ready(imd);
}
gtk_widget_get_state(widget),
gtk_frame_get_shadow_type(GTK_FRAME(widget)),
widget,
- NULL,
+ nullptr,
allocation.x + 3, allocation.y + 3,
allocation.width - 6, allocation.height - 6);
if (frame)
{
- imd->frame = gtk_frame_new(NULL);
+ imd->frame = gtk_frame_new(nullptr);
DEBUG_NAME(imd->frame);
g_object_ref(imd->pr);
if (imd->has_frame != -1) gtk_container_remove(GTK_CONTAINER(imd->widget), imd->pr);
{
gtk_container_remove(GTK_CONTAINER(imd->frame), imd->pr);
gtk_widget_destroy(imd->frame);
- imd->frame = NULL;
+ imd->frame = nullptr;
}
gtk_box_pack_start(GTK_BOX(imd->widget), imd->pr, TRUE, TRUE, 0);
};
-static GList *view_window_list = NULL;
+static GList *view_window_list = nullptr;
static GtkWidget *view_popup_menu(ViewWindow *vw);
{static_cast<GdkModifierType>(0), GDK_KEY_Escape, N_("Close window")},
{GDK_SHIFT_MASK, 'G', N_("Desaturate")},
{GDK_SHIFT_MASK, 'P', N_("Print")},
- {static_cast<GdkModifierType>(0), 0, NULL}
+ {static_cast<GdkModifierType>(0), 0, nullptr}
};
{
filelist_free(vw->list);
- vw->list = NULL;
- vw->list_pointer = NULL;
+ vw->list = nullptr;
+ vw->list_pointer = nullptr;
vw->list = filelist_copy(list);
}
ImageWindow *imd = view_window_active_image(vw);
CollectionData *cd;
CollectInfo *info;
- CollectInfo *read_ahead_info = NULL;
+ CollectInfo *read_ahead_info = nullptr;
cd = image_get_collection(imd, &info);
ImageWindow *imd = view_window_active_image(vw);
CollectionData *cd;
CollectInfo *info;
- CollectInfo *read_ahead_info = NULL;
+ CollectInfo *read_ahead_info = nullptr;
cd = image_get_collection(imd, &info);
}
if (!work) return;
- work_ahead = NULL;
+ work_ahead = nullptr;
if (next)
{
work = work->next;
case '0':
break;
case 'C': case 'c':
- file_util_copy(image_get_fd(imd), NULL, NULL, imd->widget);
+ file_util_copy(image_get_fd(imd), nullptr, nullptr, imd->widget);
break;
case 'M': case 'm':
- file_util_move(image_get_fd(imd), NULL, NULL, imd->widget);
+ file_util_move(image_get_fd(imd), nullptr, nullptr, imd->widget);
break;
case 'R': case 'r':
- file_util_rename(image_get_fd(imd), NULL, imd->widget);
+ file_util_rename(image_get_fd(imd), nullptr, imd->widget);
break;
case 'D': case 'd':
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(image_get_fd(imd), NULL, imd->widget);
+ file_util_delete(image_get_fd(imd), nullptr, imd->widget);
break;
case 'W': case 'w':
view_window_close(vw);
imd = view_window_active_image(vw);
fd = image_get_fd(imd);
print_window_new(fd,
- fd ? g_list_append(NULL, file_data_ref(fd)) : NULL,
+ fd ? g_list_append(nullptr, file_data_ref(fd)) : nullptr,
filelist_copy(vw->list), vw->window);
}
break;
if (options->file_ops.enable_delete_key)
{
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(image_get_fd(imd), NULL, imd->widget);
+ file_util_delete(image_get_fd(imd), nullptr, imd->widget);
}
break;
default:
if (options->file_ops.enable_delete_key)
{
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(image_get_fd(imd), NULL, imd->widget);
+ file_util_delete(image_get_fd(imd), nullptr, imd->widget);
}
break;
case GDK_KEY_Escape:
case GDK_KEY_Menu:
case GDK_KEY_F10:
menu = view_popup_menu(vw);
- gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
break;
default:
stop_signal = FALSE;
}
else
{
- warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
}
else if (options->image_l_click_video && options->image_l_click_video_editor && imd->image_fd->format_class == FORMAT_CLASS_VIDEO)
break;
case MOUSE_BUTTON_RIGHT:
menu = view_popup_menu(vw);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
break;
default:
break;
{
auto vw = static_cast<ViewWindow *>(data);
- vw->fs = NULL;
+ vw->fs = nullptr;
if (vw->ss) vw->ss->imd = vw->imd;
}
GList *work;
FileData *fd;
- vw->ss = NULL;
+ vw->ss = nullptr;
work = vw->list;
fd = image_get_fd(view_window_active_image(vw));
if (fd == temp)
{
vw->list_pointer = work;
- work = NULL;
+ work = nullptr;
}
else
{
if (vw->list)
{
- vw->ss = slideshow_start_from_filelist(NULL, view_window_active_image(vw),
+ vw->ss = slideshow_start_from_filelist(nullptr, view_window_active_image(vw),
filelist_copy(vw->list),
view_slideshow_stop_func, vw);
- vw->list_pointer = NULL;
+ vw->list_pointer = nullptr;
return;
}
cd = image_get_collection(view_window_active_image(vw), &info);
if (cd && info)
{
- vw->ss = slideshow_start_from_collection(NULL, view_window_active_image(vw), cd,
+ vw->ss = slideshow_start_from_collection(nullptr, view_window_active_image(vw), cd,
view_slideshow_stop_func, vw, info);
}
}
GdkGeometry geometry;
gint w, h;
- if (!fd && !list && (!cd || !info)) return NULL;
+ if (!fd && !list && (!cd || !info)) return nullptr;
vw = g_new0(ViewWindow, 1);
- vw->window = window_new(GTK_WINDOW_TOPLEVEL, "view", PIXBUF_INLINE_ICON_VIEW, NULL, NULL);
+ vw->window = window_new(GTK_WINDOW_TOPLEVEL, "view", PIXBUF_INLINE_ICON_VIEW, nullptr, nullptr);
DEBUG_NAME(vw->window);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
- gtk_window_set_geometry_hints(GTK_WINDOW(vw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
+ gtk_window_set_geometry_hints(GTK_WINDOW(vw->window), nullptr, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(vw->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(vw->window), 0);
image_background_set_color_from_options(vw->imd, FALSE);
- image_attach_window(vw->imd, vw->window, NULL, GQ_APPNAME, TRUE);
+ image_attach_window(vw->imd, vw->window, nullptr, GQ_APPNAME, TRUE);
image_auto_refresh_enable(vw->imd, TRUE);
image_top_window_set_sync(vw->imd, TRUE);
if (cd && info)
{
- image_change_from_collection(vw->imd, cd, info, image_zoom_get_default(NULL));
+ image_change_from_collection(vw->imd, cd, info, image_zoom_get_default(nullptr));
/* Grab the fd so we can correctly size the window in
the call to image_load_dimensions() below. */
fd = info->fd;
{
view_window_set_list(vw, list);
vw->list_pointer = vw->list;
- image_change_fd(vw->imd, static_cast<FileData *>(vw->list->data), image_zoom_get_default(NULL));
+ image_change_fd(vw->imd, static_cast<FileData *>(vw->list->data), image_zoom_get_default(nullptr));
/* Set fd to first in list */
fd = static_cast<FileData *>(vw->list->data);
}
else
{
- image_change_fd(vw->imd, fd, image_zoom_get_default(NULL));
+ image_change_fd(vw->imd, fd, image_zoom_get_default(nullptr));
}
/* Wait until image is loaded otherwise size is not defined */
else
{
collection_unref(cd);
- cd = NULL;
- info = NULL;
+ cd = nullptr;
+ info = nullptr;
}
- vw = real_view_window_new(NULL, NULL, cd, info);
+ vw = real_view_window_new(nullptr, nullptr, cd, info);
if (vw && cd)
{
g_signal_connect(G_OBJECT(vw->window), "destroy",
G_CALLBACK(view_window_collection_unref_cb), cd);
}
}
- else if (isdir(fd->path) && filelist_read(fd, &list, NULL))
+ else if (isdir(fd->path) && filelist_read(fd, &list, nullptr))
{
list = filelist_sort_path(list);
list = filelist_filter(list, FALSE);
- real_view_window_new(NULL, list, NULL, NULL);
+ real_view_window_new(nullptr, list, nullptr, nullptr);
filelist_free(list);
}
else
{
- real_view_window_new(fd, NULL, NULL, NULL);
+ real_view_window_new(fd, nullptr, nullptr, nullptr);
}
}
}
void view_window_new_from_list(GList *list)
{
- real_view_window_new(NULL, list, NULL, NULL);
+ real_view_window_new(nullptr, list, nullptr, nullptr);
}
void view_window_new_from_collection(CollectionData *cd, CollectInfo *info)
{
- real_view_window_new(NULL, NULL, cd, info);
+ real_view_window_new(nullptr, nullptr, cd, info);
}
/*
ImageWindow *imd;
imd = view_window_active_image(vw);
- file_util_copy(image_get_fd(imd), NULL, NULL, imd->widget);
+ file_util_copy(image_get_fd(imd), nullptr, nullptr, imd->widget);
}
static void view_move_cb(GtkWidget *UNUSED(widget), gpointer data)
ImageWindow *imd;
imd = view_window_active_image(vw);
- file_util_move(image_get_fd(imd), NULL, NULL, imd->widget);
+ file_util_move(image_get_fd(imd), nullptr, nullptr, imd->widget);
}
static void view_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
ImageWindow *imd;
imd = view_window_active_image(vw);
- file_util_rename(image_get_fd(imd), NULL, imd->widget);
+ file_util_rename(image_get_fd(imd), nullptr, imd->widget);
}
static void view_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
imd = view_window_active_image(vw);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(image_get_fd(imd), NULL, imd->widget);
+ file_util_delete(image_get_fd(imd), nullptr, imd->widget);
}
static void view_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
imd = view_window_active_image(vw);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(image_get_fd(imd), NULL, imd->widget);
+ file_util_delete(image_get_fd(imd), nullptr, imd->widget);
}
static void view_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
{
LayoutWindow *nw;
- nw = layout_new(NULL, NULL);
+ nw = layout_new(nullptr, nullptr);
layout_sort_set(nw, options->file_sort.method, options->file_sort.ascending);
layout_set_fd(nw, fd);
return nw;
static GList *view_window_get_fd_list(ViewWindow *vw)
{
- GList *list = NULL;
+ GList *list = nullptr;
ImageWindow *imd = view_window_active_image(vw);
if (imd)
{
FileData *fd = image_get_fd(imd);
- if (fd) list = g_list_append(NULL, file_data_ref(fd));
+ if (fd) list = g_list_append(nullptr, file_data_ref(fd));
}
return list;
ViewWindow *vw;
ImageWindow *imd;
FileData *fd;
- GList *selection_list = NULL;
+ GList *selection_list = nullptr;
vw = static_cast<ViewWindow *>(submenu_item_get_data(widget));
imd = view_window_active_image(vw);
editmenu_fd_list = view_window_get_fd_list(vw);
g_signal_connect(G_OBJECT(menu), "destroy",
G_CALLBACK(view_popup_menu_destroy_cb), editmenu_fd_list);
- item = submenu_add_edit(menu, NULL, G_CALLBACK(view_edit_cb), vw, editmenu_fd_list);
+ item = submenu_add_edit(menu, nullptr, G_CALLBACK(view_edit_cb), vw, editmenu_fd_list);
menu_item_add_divider(item);
submenu_add_alter(menu, G_CALLBACK(view_alter_cb), vw);
else
{
item = menu_item_add(menu, _("Toggle _slideshow"), G_CALLBACK(view_slideshow_start_cb), vw);
- gtk_widget_set_sensitive(item, (vw->list != NULL) || view_window_contains_collection(vw));
+ gtk_widget_set_sensitive(item, (vw->list != nullptr) || view_window_contains_collection(vw));
item = menu_item_add(menu, _("Pause slides_how"), G_CALLBACK(view_slideshow_pause_cb), vw);
gtk_widget_set_sensitive(item, FALSE);
}
{
GList *work;
- view_window_set_list(vw, NULL);
+ view_window_set_list(vw, nullptr);
work = list;
while (work)
{
if (!skip)
{
- GList *list = NULL;
+ GList *list = nullptr;
if (recurse)
{
}
else
{ /** @FIXME ?? */
- filelist_read(fd, &list, NULL);
+ filelist_read(fd, &list, nullptr);
list = filelist_sort_path(list);
list = filelist_filter(list, FALSE);
}
}
else
{
- image_change_fd(vw->imd, NULL, image_zoom_get_default(vw->imd));
+ image_change_fd(vw->imd, nullptr, image_zoom_get_default(vw->imd));
}
}
g_signal_connect(G_OBJECT(menu), "destroy",
G_CALLBACK(view_dir_list_destroy), d);
- menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, NULL, NULL);
+ menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, nullptr, nullptr);
menu_item_add_divider(menu);
menu_item_add_stock(menu, _("_Add contents"), GTK_STOCK_OK, G_CALLBACK(view_dir_list_add), d);
menu_item_add_stock(menu, _("Add contents _recursive"), GTK_STOCK_ADD, G_CALLBACK(view_dir_list_recurse), d);
{
GtkWidget *menu;
menu = view_confirm_dir_list(vw, list);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
return;
}
work = work->next;
list = filelist_filter(list, FALSE);
- source = NULL;
- info_list = NULL;
+ source = nullptr;
+ info_list = nullptr;
}
else
{
if (isfile(fd->path))
{
view_slideshow_stop(vw);
- view_window_set_list(vw, NULL);
+ view_window_set_list(vw, nullptr);
if (source && info_list)
{
if (list->next)
{
vw->list = list;
- list = NULL;
+ list = nullptr;
vw->list_pointer = vw->list;
}
{
GList *list;
- list = g_list_append(NULL, fd);
+ list = g_list_append(nullptr, fd);
uri_selection_data_set_uris_from_filelist(selection_data, list);
g_list_free(list);
}
else
{
gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
- 8, NULL, 0);
+ 8, nullptr, 0);
}
}
}
if (image_get_fd(imd) == image_fd)
{
- image_change_fd(imd, NULL, image_zoom_get_default(imd));
+ image_change_fd(imd, nullptr, image_zoom_get_default(imd));
}
}
}
else
{
- fd = NULL;
+ fd = nullptr;
}
image_change_fd(imd, fd, image_zoom_get_default(imd));
seg_offset += 4;
seg_size -= 4;
- if (!tiff_directory_offset(data + seg_offset, seg_size, &offset, &bo)) return NULL;
+ if (!tiff_directory_offset(data + seg_offset, seg_size, &offset, &bo)) return nullptr;
mpo = g_new0(MPOData, 1);
mpo->mpo_offset = seg_offset;
}
}
- tiff_parse_IFD_table(data + mpo->images[i].offset + seg_offset, offset , seg_size, bo, NULL, mpo_parse_Attributes_IFD_entry, &mpo->images[i]);
+ tiff_parse_IFD_table(data + mpo->images[i].offset + seg_offset, offset , seg_size, bo, nullptr, mpo_parse_Attributes_IFD_entry, &mpo->images[i]);
}
return mpo;
}
- return NULL;
+ return nullptr;
}
void jpeg_mpo_data_free(MPOData *mpo)
" y=\"468.38324\" /></text>",
" </g>",
"</svg>",
-NULL,
+nullptr,
};
lc = static_cast<LayoutConfig *>(g_object_get_data(G_OBJECT(widget), "layout_config"));
/* this should not happen */
- if (!lc) return NULL;
+ if (!lc) return nullptr;
*style = lc->style;
}
else
{
- group = gtk_radio_button_new(NULL);
+ group = gtk_radio_button_new(nullptr);
}
g_object_set_data(G_OBJECT(group), "layout_config", lc);
g_signal_connect(G_OBJECT(group), "clicked",
{
LayoutConfig *lc;
GtkWidget *hbox;
- GtkWidget *group = NULL;
+ GtkWidget *group = nullptr;
GtkWidget *scrolled;
GtkListStore *store;
GtkTreeViewColumn *column;
}
gtk_widget_show(hbox);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
- gtk_tree_view_column_set_cell_data_func(column, renderer, layout_config_number_cb, lc, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, layout_config_number_cb, lc, nullptr);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
if (lw->image == fs->imd)
lw->image = fs->normal_imd;
- lw->full_screen = NULL;
+ lw->full_screen = nullptr;
}
void layout_image_full_screen_start(LayoutWindow *lw)
{
if (!layout_valid(&lw)) return FALSE;
- return (lw->full_screen != NULL);
+ return (lw->full_screen != nullptr);
}
/*
{
auto lw = static_cast<LayoutWindow *>(data);
- lw->slideshow = NULL;
- layout_status_update_info(lw, NULL);
+ lw->slideshow = nullptr;
+ layout_status_update_info(lw, nullptr);
}
void layout_image_slideshow_start(LayoutWindow *lw)
if (cd && info)
{
- lw->slideshow = slideshow_start_from_collection(lw, NULL, cd,
+ lw->slideshow = slideshow_start_from_collection(lw, nullptr, cd,
layout_image_slideshow_stop_func, lw, info);
}
else
layout_image_slideshow_stop_func, lw);
}
- layout_status_update_info(lw, NULL);
+ layout_status_update_info(lw, nullptr);
}
/* note that slideshow will take ownership of the list, do not free it */
return;
}
- lw->slideshow = slideshow_start_from_filelist(lw, NULL, list,
+ lw->slideshow = slideshow_start_from_filelist(lw, nullptr, list,
layout_image_slideshow_stop_func, lw);
- layout_status_update_info(lw, NULL);
+ layout_status_update_info(lw, nullptr);
}
void layout_image_slideshow_stop(LayoutWindow *lw)
{
if (!layout_valid(&lw)) return FALSE;
- return (lw->slideshow != NULL);
+ return (lw->slideshow != nullptr);
}
gboolean layout_image_slideshow_pause_toggle(LayoutWindow *lw)
ret = slideshow_pause_toggle(lw->slideshow);
- layout_status_update_info(lw, NULL);
+ layout_status_update_info(lw, nullptr);
return ret;
}
pr = reinterpret_cast<PixbufRenderer*>(fd->iw->pr);
- if (gdk_pixbuf_animation_iter_advance(fd->iter,NULL)==FALSE)
+ if (gdk_pixbuf_animation_iter_advance(fd->iter,nullptr)==FALSE)
{
/* This indicates the animation is complete.
Return FALSE here to disable looping. */
{
if (!layout_valid(&lw)) return FALSE;
- if(!lw->options.animate || lw->image->image_fd == NULL || lw->image->image_fd->extension == NULL || (g_ascii_strcasecmp(lw->image->image_fd->extension,".GIF")!=0 && g_ascii_strcasecmp(lw->image->image_fd->extension,".WEBP")!=0))
+ if(!lw->options.animate || lw->image->image_fd == nullptr || lw->image->image_fd->extension == nullptr || (g_ascii_strcasecmp(lw->image->image_fd->extension,".GIF")!=0 && g_ascii_strcasecmp(lw->image->image_fd->extension,".WEBP")!=0))
{
if(lw->animation)
{
{
g_cancellable_cancel(lw->animation->cancellable);
}
- lw->animation = NULL;
+ lw->animation = nullptr;
}
return FALSE;
}
static void animation_async_ready_cb(GObject *UNUSED(source_object), GAsyncResult *res, gpointer data)
{
- GError *error = NULL;
+ GError *error = nullptr;
auto animation = static_cast<AnimationData *>(data);
if (animation)
{
if (g_cancellable_is_cancelled(animation->cancellable))
{
- gdk_pixbuf_animation_new_from_stream_finish(res, NULL);
+ gdk_pixbuf_animation_new_from_stream_finish(res, nullptr);
g_object_unref(animation->in_file);
g_object_unref(animation->gfstream);
image_animation_data_free(animation);
{
if (!gdk_pixbuf_animation_is_static_image(animation->gpa))
{
- animation->iter = gdk_pixbuf_animation_get_iter(animation->gpa, NULL);
+ animation->iter = gdk_pixbuf_animation_get_iter(animation->gpa, nullptr);
if (animation->iter)
{
animation->data_adr = animation->lw->image->image_fd;
static gboolean layout_image_animate_new_file(LayoutWindow *lw)
{
GFileInputStream *gfstream;
- GError *error = NULL;
+ GError *error = nullptr;
AnimationData *animation;
GFile *in_file;
in_file = g_file_new_for_path(lw->image->image_fd->path);
animation->in_file = in_file;
- gfstream = g_file_read(in_file, NULL, &error);
+ gfstream = g_file_read(in_file, nullptr, &error);
if (gfstream)
{
animation->gfstream = gfstream;
GtkWidget *parent;
menu = gtk_widget_get_toplevel(widget);
- if (!menu) return NULL;
+ if (!menu) return nullptr;
parent = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(menu), "click_parent"));
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_copy(layout_image_get_fd(lw), NULL, NULL,
+ file_util_copy(layout_image_get_fd(lw), nullptr, nullptr,
li_pop_menu_click_parent(widget, lw));
}
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_move(layout_image_get_fd(lw), NULL, NULL,
+ file_util_move(layout_image_get_fd(lw), nullptr, nullptr,
li_pop_menu_click_parent(widget, lw));
}
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_rename(layout_image_get_fd(lw), NULL,
+ file_util_rename(layout_image_get_fd(lw), nullptr,
li_pop_menu_click_parent(widget, lw));
}
auto lw = static_cast<LayoutWindow *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(layout_image_get_fd(lw), NULL,
+ file_util_delete(layout_image_get_fd(lw), nullptr,
li_pop_menu_click_parent(widget, lw));
}
auto lw = static_cast<LayoutWindow *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(layout_image_get_fd(lw), NULL,
+ file_util_delete(layout_image_get_fd(lw), nullptr,
li_pop_menu_click_parent(widget, lw));
}
}
else
{
- warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
}
static GList *layout_image_get_fd_list(LayoutWindow *lw)
{
- GList *list = NULL;
+ GList *list = nullptr;
FileData *fd = layout_image_get_fd(lw);
if (fd)
/* optionally include sidecars if the filelist entry is not expanded */
list = vf_selection_get_one(lw->vf, fd);
else
- list = g_list_append(NULL, file_data_ref(fd));
+ list = g_list_append(nullptr, file_data_ref(fd));
}
return list;
static void layout_pop_menu_collections_cb(GtkWidget *widget, gpointer data)
{
LayoutWindow *lw;
- GList *selection_list = NULL;
+ GList *selection_list = nullptr;
lw = static_cast<LayoutWindow *>(submenu_item_get_data(widget));
selection_list = g_list_append(selection_list, layout_image_get_fd(lw));
accel_group = gtk_accel_group_new();
gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
- g_object_set_data(G_OBJECT(menu), "window_keys", NULL);
+ g_object_set_data(G_OBJECT(menu), "window_keys", nullptr);
g_object_set_data(G_OBJECT(menu), "accel_group", accel_group);
menu_item_add_stock(menu, _("Zoom _in"), GTK_STOCK_ZOOM_IN, G_CALLBACK(li_pop_menu_zoom_in_cb), lw);
GtkWidget *menu;
menu = layout_image_pop_menu(lw);
- gtk_menu_popup_at_widget(GTK_MENU(menu), lw->image->widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), lw->image->widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, nullptr);
}
/*
if (info == TARGET_URI_LIST)
{
list = uri_filelist_from_gtk_selection_data(selection_data);
- source = NULL;
- info_list = NULL;
+ source = nullptr;
+ info_list = nullptr;
}
else
{
else if (isdir(fd->path))
{
layout_set_fd(lw, fd);
- layout_image_set_fd(lw, NULL);
+ layout_image_set_fd(lw, nullptr);
}
}
{
GList *list;
- list = g_list_append(NULL, fd);
+ list = g_list_append(nullptr, fd);
uri_selection_data_set_uris_from_filelist(selection_data, list);
g_list_free(list);
}
else
{
gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
- 8, NULL, 0);
+ 8, nullptr, 0);
}
}
if (!isfile(fd->path))
{
- if (static_cast<guint>(row) < layout_list_count(lw, NULL) - 1)
+ if (static_cast<guint>(row) < layout_list_count(lw, nullptr) - 1)
{
layout_image_next(lw);
}
const gchar *layout_image_get_path(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
return image_get_path(lw->image);
}
FileData *layout_image_get_fd(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
return image_get_fd(lw->image);
}
CollectionData *layout_image_get_collection(LayoutWindow *lw, CollectInfo **info)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
return image_get_collection(lw->image, info);
}
read_ahead_fd = layout_list_get_fd(lw, index + 1);
}
- if (layout_selection_count(lw, 0) > 1)
+ if (layout_selection_count(lw, nullptr) > 1)
{
GList *x = layout_selection_list_by_index(lw);
GList *y;
return;
}
- if (layout_selection_count(lw, 0) > 1)
+ if (layout_selection_count(lw, nullptr) > 1)
{
GList *x = layout_selection_list_by_index(lw);
gint old = layout_list_get_index(lw, layout_image_get_fd(lw));
if (current >= 0)
{
- if (static_cast<guint>(current) < layout_list_count(lw, NULL) - 1)
+ if (static_cast<guint>(current) < layout_list_count(lw, nullptr) - 1)
{
layout_image_set_index(lw, current + 1);
}
return;
}
- if (layout_selection_count(lw, 0) > 1)
+ if (layout_selection_count(lw, nullptr) > 1)
{
GList *x = layout_selection_list_by_index(lw);
gint old = layout_list_get_index(lw, layout_image_get_fd(lw));
}
else
{
- layout_image_set_index(lw, layout_list_count(lw, NULL) - 1);
+ layout_image_set_index(lw, layout_list_count(lw, nullptr) - 1);
}
}
}
current = layout_image_get_index(lw);
- if (current != 0 && layout_list_count(lw, NULL) > 0)
+ if (current != 0 && layout_list_count(lw, nullptr) > 0)
{
layout_image_set_index(lw, 0);
}
}
current = layout_image_get_index(lw);
- count = layout_list_count(lw, NULL);
+ count = layout_list_count(lw, nullptr);
if (current != count - 1 && count > 0)
{
layout_image_set_index(lw, count - 1);
}
else
{
- warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
}
else if (options->image_l_click_video && options->image_l_click_video_editor && imd-> image_fd && imd->image_fd->format_class == FORMAT_CLASS_VIDEO)
{
g_object_set_data(G_OBJECT(menu), "click_parent", imd->widget);
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
break;
default:
break;
{
g_object_set_data(G_OBJECT(menu), "click_parent", imd->widget);
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
break;
default:
break;
void layout_image_deactivate(LayoutWindow *lw, gint i)
{
if (!lw->split_images[i]) return;
- image_set_update_func(lw->split_images[i], NULL, NULL);
+ image_set_update_func(lw->split_images[i], nullptr, nullptr);
layout_image_set_buttons_inactive(lw, i);
image_set_drag_func(lw->split_images[i], layout_image_drag_inactive_cb, lw);
- image_attach_window(lw->split_images[i], NULL, NULL, NULL, FALSE);
+ image_attach_window(lw->split_images[i], nullptr, nullptr, nullptr, FALSE);
image_select(lw->split_images[i], FALSE);
}
layout_image_set_buttons(lw);
image_set_drag_func(lw->image, layout_image_drag_cb, lw);
- image_attach_window(lw->image, lw->window, NULL, GQ_APPNAME, FALSE);
+ image_attach_window(lw->image, lw->window, nullptr, GQ_APPNAME, FALSE);
/* do not highlight selected image in SPLIT_NONE */
/* maybe the image should be selected always and highlight should be controlled by
for (i = 0; i < n; i++)
if (!lw->split_images[i])
{
- FileData *img_fd = NULL;
+ FileData *img_fd = nullptr;
double zoom = 0.0;
layout_image_new(lw, i);
image_osd_copy_status(lw->image, lw->split_images[i]);
}
- if (layout_selection_count(lw, 0) > 1)
+ if (layout_selection_count(lw, nullptr) > 1)
{
GList *work = g_list_last(layout_selection_list(lw));
gint j = 0;
if (lw->split_images[i])
{
g_object_unref(lw->split_images[i]->widget);
- lw->split_images[i] = NULL;
+ lw->split_images[i] = nullptr;
}
}
layout_image_set_collection(lw, cd, next_collection);
return;
}
- layout_image_set_fd(lw, NULL);
+ layout_image_set_fd(lw, nullptr);
}
/* the image will be set to the next image from the list soon,
GenericDialog *gd;
gd = generic_dialog_new(_("Clear Marks"),
- "marks_clear", NULL, FALSE, clear_marks_cancel_cb, NULL);
+ "marks_clear", nullptr, FALSE, clear_marks_cancel_cb, nullptr);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, "Clear all marks?",
"This will clear all marks for all images,\nincluding those linked to keywords",
TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, layout_menu_clear_marks_ok_cb, TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, layout_menu_clear_marks_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_HELP, nullptr,
clear_marks_help_cb, FALSE);
gtk_widget_show(gd->dialog);
auto lw = static_cast<LayoutWindow *>(data);
layout_exit_fullscreen(lw);
- collection_window_new(NULL);
+ collection_window_new(nullptr);
}
static void layout_menu_open_cb(GtkAction *UNUSED(action), gpointer data)
auto lw = static_cast<LayoutWindow *>(data);
layout_exit_fullscreen(lw);
- collection_dialog_load(NULL);
+ collection_dialog_load(nullptr);
}
static void layout_menu_search_cb(GtkAction *UNUSED(action), gpointer data)
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_copy(NULL, layout_selection_list(lw), NULL, layout_window(lw));
+ file_util_copy(nullptr, layout_selection_list(lw), nullptr, layout_window(lw));
}
static void layout_menu_copy_path_cb(GtkAction *UNUSED(action), gpointer data)
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_move(NULL, layout_selection_list(lw), NULL, layout_window(lw));
+ file_util_move(nullptr, layout_selection_list(lw), nullptr, layout_window(lw));
}
static void layout_menu_rename_cb(GtkAction *UNUSED(action), gpointer data)
{
auto lw = static_cast<LayoutWindow *>(data);
- file_util_rename(NULL, layout_selection_list(lw), layout_window(lw));
+ file_util_rename(nullptr, layout_selection_list(lw), layout_window(lw));
}
static void layout_menu_delete_cb(GtkAction *UNUSED(action), gpointer data)
auto lw = static_cast<LayoutWindow *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
+ file_util_delete(nullptr, layout_selection_list(lw), layout_window(lw));
}
static void layout_menu_move_to_trash_cb(GtkAction *UNUSED(action), gpointer data)
auto lw = static_cast<LayoutWindow *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
+ file_util_delete(nullptr, layout_selection_list(lw), layout_window(lw));
}
static void layout_menu_move_to_trash_key_cb(GtkAction *UNUSED(action), gpointer data)
if (options->file_ops.enable_delete_key)
{
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
+ file_util_delete(nullptr, layout_selection_list(lw), layout_window(lw));
}
}
message = g_string_append(message, fd_n->name);
gd = generic_dialog_new(_("Image orientation"),
- "Image orientation", NULL, TRUE, NULL, NULL);
+ "Image orientation", nullptr, TRUE, nullptr, nullptr);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_ERROR,
"Image orientation", message->str, TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, NULL, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, nullptr, TRUE);
gtk_widget_show(gd->dialog);
}
else
{
- warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
}
}
{"ScrollDown", "<Shift>MW5"},
{"ZoomIn", "<Primary>MW4"},
{"ZoomOut", "<Primary>MW5"},
- {NULL, NULL}
+ {nullptr, nullptr}
};
static void layout_menu_foreach_func(
gchar *subset_lt, *converted_name;
auto array = static_cast<GPtrArray *>(data);
- path = g_strescape(accel_path, NULL);
+ path = g_strescape(accel_path, nullptr);
name = gtk_accelerator_name(accel_key, accel_mods);
menu_name = g_strdup(g_strrstr(path, "/")+1);
gint fd = -1;
GPtrArray *array;
char * tmp_file;
- GError *error = NULL;
+ GError *error = nullptr;
GIOChannel *channel;
char **pre_key, **post_key;
const char *key_name;
}
converted_line = g_strconcat(pre_key[0], ">", key_name, "<", post_key[1], "\n", NULL);
- g_io_channel_write_chars(channel, converted_line, -1, NULL, &error);
+ g_io_channel_write_chars(channel, converted_line, -1, nullptr, &error);
if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
g_free(converted_line);
}
else
{
- g_io_channel_write_chars(channel, keymap_template[keymap_index], -1, NULL, &error);
+ g_io_channel_write_chars(channel, keymap_template[keymap_index], -1, nullptr, &error);
if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
- g_io_channel_write_chars(channel, "\n", -1, NULL, &error);
+ g_io_channel_write_chars(channel, "\n", -1, nullptr, &error);
if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
}
keymap_index++;
static void layout_menu_metadata_write_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
{
- metadata_write_queue_confirm(TRUE, NULL, NULL);
+ metadata_write_queue_confirm(TRUE, nullptr, nullptr);
}
-static GtkWidget *last_focussed = NULL;
+static GtkWidget *last_focussed = nullptr;
static void layout_menu_keyword_autocomplete_cb(GtkAction *UNUSED(action), gpointer data)
{
auto lw = static_cast<LayoutWindow *>(data);
if (n == 0)
{
- menu_item_add(menu, _("Empty"), NULL, NULL);
+ menu_item_add(menu, _("Empty"), nullptr, nullptr);
}
recent = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/FileMenu/OpenRecent");
return listin;
}
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
gchar *name_file = dir->d_name;
gint n;
n = GPOINTER_TO_INT(data);
- GList *menulist = NULL;
+ GList *menulist = nullptr;
menulist = layout_window_menu_list(menulist);
auto wn = static_cast<WindowNames *>(g_list_nth(menulist, n )->data);
GtkWidget *item;
GList *children, *iter;
gint n;
- GList *list = NULL;
+ GList *list = nullptr;
gint i = 0;
WindowNames *wn;
sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
- for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
+ for (iter = children; iter != nullptr; iter = g_list_next(iter), i++)
{
if (i >= 4) // separator, default, from current, separator
{
auto rw = static_cast<RenameWindow *>(data);
gchar *path;
gboolean window_layout_name_exists = FALSE;
- GList *list = NULL;
+ GList *list = nullptr;
gchar *xml_name;
gchar *new_id;
{
i = 0;
children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
- for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
+ for (iter = children; iter != nullptr; iter = g_list_next(iter), i++)
{
menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
if (g_strcmp0(menu_label, _("Delete window")) == 0)
i = 0;
children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
- for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
+ for (iter = children; iter != nullptr; iter = g_list_next(iter), i++)
{
menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
if (g_strcmp0(menu_label, _("Open archive")) == 0)
id_name = layout_get_unique_id();
in_file = g_file_new_for_path(infile);
- in_file_stream = g_file_read(in_file, NULL, NULL);
+ in_file_stream = g_file_read(in_file, nullptr, nullptr);
in_data_stream = g_data_input_stream_new(G_INPUT_STREAM(in_file_stream));
out_file = g_file_new_for_path(outfile);
- out_file_stream = g_file_append_to(out_file, G_FILE_CREATE_PRIVATE, NULL, NULL);
+ out_file_stream = g_file_append_to(out_file, G_FILE_CREATE_PRIVATE, nullptr, nullptr);
out_data_stream = g_data_output_stream_new(G_OUTPUT_STREAM(out_file_stream));
- while ((line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL)))
+ while ((line = g_data_input_stream_read_line(in_data_stream, nullptr, nullptr, nullptr)))
{
if (g_str_has_suffix(line, "<layout"))
{
- g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
- g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
+ g_data_output_stream_put_string(out_data_stream, line, nullptr, nullptr);
+ g_data_output_stream_put_string(out_data_stream, "\n", nullptr, nullptr);
g_free(line);
- line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL);
- g_data_output_stream_put_string(out_data_stream, "id = \"", NULL, NULL);
- g_data_output_stream_put_string(out_data_stream, id_name, NULL, NULL);
- g_data_output_stream_put_string(out_data_stream, "\"\n", NULL, NULL);
+ line = g_data_input_stream_read_line(in_data_stream, nullptr, nullptr, nullptr);
+ g_data_output_stream_put_string(out_data_stream, "id = \"", nullptr, nullptr);
+ g_data_output_stream_put_string(out_data_stream, id_name, nullptr, nullptr);
+ g_data_output_stream_put_string(out_data_stream, "\"\n", nullptr, nullptr);
}
else
{
- g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
- g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
+ g_data_output_stream_put_string(out_data_stream, line, nullptr, nullptr);
+ g_data_output_stream_put_string(out_data_stream, "\n", nullptr, nullptr);
}
g_free(line);
}
gint fd_out = -1;
char * tmp_file_in;
char * tmp_file_out;
- GError *error = NULL;
+ GError *error = nullptr;
fd_in = g_file_open_tmp("geeqie_layout_name_XXXXXX.xml", &tmp_file_in, &error);
if (error)
rw = g_new0(RenameWindow, 1);
rw->lw = lw;
- rw->gd = generic_dialog_new(_("Rename window"), "rename_window", NULL, FALSE, window_rename_cancel_cb, rw);
+ rw->gd = generic_dialog_new(_("Rename window"), "rename_window", nullptr, FALSE, window_rename_cancel_cb, rw);
rw->button_ok = generic_dialog_add_button(rw->gd, GTK_STOCK_OK, _("OK"), window_rename_ok_cb, TRUE);
- generic_dialog_add_message(rw->gd, NULL, _("rename window"), NULL, FALSE);
+ generic_dialog_add_message(rw->gd, nullptr, _("rename window"), nullptr, FALSE);
hbox = pref_box_new(rw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
dw = g_new0(DeleteWindow, 1);
dw->lw = lw;
- dw->gd = generic_dialog_new(_("Delete window"), "delete_window", NULL, TRUE, window_delete_cancel_cb, dw);
+ dw->gd = generic_dialog_new(_("Delete window"), "delete_window", nullptr, TRUE, window_delete_cancel_cb, dw);
dw->button_ok = generic_dialog_add_button(dw->gd, GTK_STOCK_OK, _("OK"), window_delete_ok_cb, TRUE);
- generic_dialog_add_message(dw->gd, NULL, _("Delete window layout"), NULL, FALSE);
+ generic_dialog_add_message(dw->gd, nullptr, _("Delete window layout"), nullptr, FALSE);
hbox = pref_box_new(dw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
* name, stock_id, label, accelerator, tooltip, callback
*/
static GtkActionEntry menu_entries[] = {
- { "FileMenu", NULL, N_("_File"), NULL, NULL, NULL },
- { "GoMenu", NULL, N_("_Go"), NULL, NULL, NULL },
- { "EditMenu", NULL, N_("_Edit"), NULL, NULL, NULL },
- { "SelectMenu", NULL, N_("_Select"), NULL, NULL, NULL },
- { "OrientationMenu", NULL, N_("_Orientation"), NULL, NULL, NULL },
- { "RatingMenu", NULL, N_("_Rating"), NULL, NULL, NULL },
- { "PreferencesMenu", NULL, N_("P_references"), NULL, NULL, NULL },
- { "ViewMenu", NULL, N_("_View"), NULL, NULL, CB(layout_menu_view_menu_cb) },
- { "FileDirMenu", NULL, N_("_Files and Folders"), NULL, NULL, NULL },
- { "ZoomMenu", NULL, N_("_Zoom"), NULL, NULL, NULL },
- { "ColorMenu", NULL, N_("_Color Management"), NULL, NULL, NULL },
- { "ConnectZoomMenu", NULL, N_("_Connected Zoom"), NULL, NULL, NULL },
- { "SplitMenu", NULL, N_("Spli_t"), NULL, NULL, NULL },
- { "StereoMenu", NULL, N_("Stere_o"), NULL, NULL, NULL },
- { "OverlayMenu", NULL, N_("Image _Overlay"), NULL, NULL, NULL },
- { "PluginsMenu", NULL, N_("_Plugins"), NULL, NULL, NULL },
- { "WindowsMenu", NULL, N_("_Windows"), NULL, NULL, CB(layout_menu_windows_menu_cb) },
- { "HelpMenu", NULL, N_("_Help"), NULL, NULL, NULL },
+ { "FileMenu", nullptr, N_("_File"), nullptr, nullptr, nullptr },
+ { "GoMenu", nullptr, N_("_Go"), nullptr, nullptr, nullptr },
+ { "EditMenu", nullptr, N_("_Edit"), nullptr, nullptr, nullptr },
+ { "SelectMenu", nullptr, N_("_Select"), nullptr, nullptr, nullptr },
+ { "OrientationMenu", nullptr, N_("_Orientation"), nullptr, nullptr, nullptr },
+ { "RatingMenu", nullptr, N_("_Rating"), nullptr, nullptr, nullptr },
+ { "PreferencesMenu", nullptr, N_("P_references"), nullptr, nullptr, nullptr },
+ { "ViewMenu", nullptr, N_("_View"), nullptr, nullptr, CB(layout_menu_view_menu_cb) },
+ { "FileDirMenu", nullptr, N_("_Files and Folders"), nullptr, nullptr, nullptr },
+ { "ZoomMenu", nullptr, N_("_Zoom"), nullptr, nullptr, nullptr },
+ { "ColorMenu", nullptr, N_("_Color Management"), nullptr, nullptr, nullptr },
+ { "ConnectZoomMenu", nullptr, N_("_Connected Zoom"), nullptr, nullptr, nullptr },
+ { "SplitMenu", nullptr, N_("Spli_t"), nullptr, nullptr, nullptr },
+ { "StereoMenu", nullptr, N_("Stere_o"), nullptr, nullptr, nullptr },
+ { "OverlayMenu", nullptr, N_("Image _Overlay"), nullptr, nullptr, nullptr },
+ { "PluginsMenu", nullptr, N_("_Plugins"), nullptr, nullptr, nullptr },
+ { "WindowsMenu", nullptr, N_("_Windows"), nullptr, nullptr, CB(layout_menu_windows_menu_cb) },
+ { "HelpMenu", nullptr, N_("_Help"), nullptr, nullptr, nullptr },
{ "Copy", GTK_STOCK_COPY, N_("_Copy..."), "<control>C", N_("Copy..."), CB(layout_menu_copy_cb) },
{ "Move", PIXBUF_INLINE_ICON_MOVE, N_("_Move..."), "<control>M", N_("Move..."), CB(layout_menu_move_cb) },
{ "NextImage", GTK_STOCK_GO_DOWN, N_("_Next Image"), "space", N_("Next Image"), CB(layout_menu_image_next_cb) },
{ "NextImageAlt1", GTK_STOCK_GO_DOWN, N_("_Next Image"), "Page_Down", N_("Next Image"), CB(layout_menu_image_next_cb) },
- { "ImageForward", GTK_STOCK_GOTO_LAST, N_("Image Forward"), NULL, N_("Forward in image history"), CB(layout_menu_image_forward_cb) },
- { "ImageBack", GTK_STOCK_GOTO_FIRST, N_("Image Back"), NULL, N_("Back in image history"), CB(layout_menu_image_back_cb) },
+ { "ImageForward", GTK_STOCK_GOTO_LAST, N_("Image Forward"), nullptr, N_("Forward in image history"), CB(layout_menu_image_forward_cb) },
+ { "ImageBack", GTK_STOCK_GOTO_FIRST, N_("Image Back"), nullptr, N_("Back in image history"), CB(layout_menu_image_back_cb) },
- { "FirstPage",GTK_STOCK_MEDIA_PREVIOUS, N_("_First Page"), NULL, N_( "First Page of multi-page image"), CB(layout_menu_page_first_cb) },
- { "LastPage", GTK_STOCK_MEDIA_NEXT, N_("_Last Page"), NULL, N_("Last Page of multi-page image"), CB(layout_menu_page_last_cb) },
- { "NextPage", GTK_STOCK_MEDIA_FORWARD, N_("_Next Page"), NULL, N_("Next Page of multi-page image"), CB(layout_menu_page_next_cb) },
- { "PrevPage", GTK_STOCK_MEDIA_REWIND, N_("_Previous Page"), NULL, N_("Previous Page of multi-page image"), CB(layout_menu_page_previous_cb) },
+ { "FirstPage",GTK_STOCK_MEDIA_PREVIOUS, N_("_First Page"), nullptr, N_( "First Page of multi-page image"), CB(layout_menu_page_first_cb) },
+ { "LastPage", GTK_STOCK_MEDIA_NEXT, N_("_Last Page"), nullptr, N_("Last Page of multi-page image"), CB(layout_menu_page_last_cb) },
+ { "NextPage", GTK_STOCK_MEDIA_FORWARD, N_("_Next Page"), nullptr, N_("Next Page of multi-page image"), CB(layout_menu_page_next_cb) },
+ { "PrevPage", GTK_STOCK_MEDIA_REWIND, N_("_Previous Page"), nullptr, N_("Previous Page of multi-page image"), CB(layout_menu_page_previous_cb) },
{ "NextImageAlt2", GTK_STOCK_GO_DOWN, N_("_Next Image"), "KP_Page_Down", N_("Next Image"), CB(layout_menu_image_next_cb) },
{ "LastImage", GTK_STOCK_GOTO_BOTTOM, N_("_Last Image"), "End", N_("Last Image"), CB(layout_menu_image_last_cb) },
- { "Back", GTK_STOCK_GO_BACK, N_("_Back"), NULL, N_("Back in folder history"), CB(layout_menu_back_cb) },
- { "Forward", GTK_STOCK_GO_FORWARD, N_("_Forward"), NULL, N_("Forward in folder history"), CB(layout_menu_forward_cb) },
- { "Home", GTK_STOCK_HOME, N_("_Home"), NULL, N_("Home"), CB(layout_menu_home_cb) },
- { "Up", GTK_STOCK_GO_UP, N_("_Up"), NULL, N_("Up one folder"), CB(layout_menu_up_cb) },
- { "NewWindow", NULL, N_("New window"), NULL, N_("New window"), CB(layout_menu_window_cb) },
- { "NewWindowDefault", NULL, N_("default"), "<control>N", N_("New window (default)"), CB(layout_menu_window_default_cb) },
- { "NewWindowFromCurrent", NULL, N_("from current"), NULL, N_("from current"), CB(layout_menu_window_from_current_cb) },
- { "RenameWindow", GTK_STOCK_EDIT, N_("Rename window"), NULL, N_("Rename window"), CB(layout_menu_window_rename_cb) },
- { "DeleteWindow", GTK_STOCK_DELETE, N_("Delete window"), NULL, N_("Delete window"), CB(layout_menu_window_delete_cb) },
+ { "Back", GTK_STOCK_GO_BACK, N_("_Back"), nullptr, N_("Back in folder history"), CB(layout_menu_back_cb) },
+ { "Forward", GTK_STOCK_GO_FORWARD, N_("_Forward"), nullptr, N_("Forward in folder history"), CB(layout_menu_forward_cb) },
+ { "Home", GTK_STOCK_HOME, N_("_Home"), nullptr, N_("Home"), CB(layout_menu_home_cb) },
+ { "Up", GTK_STOCK_GO_UP, N_("_Up"), nullptr, N_("Up one folder"), CB(layout_menu_up_cb) },
+ { "NewWindow", nullptr, N_("New window"), nullptr, N_("New window"), CB(layout_menu_window_cb) },
+ { "NewWindowDefault", nullptr, N_("default"), "<control>N", N_("New window (default)"), CB(layout_menu_window_default_cb) },
+ { "NewWindowFromCurrent", nullptr, N_("from current"), nullptr, N_("from current"), CB(layout_menu_window_from_current_cb) },
+ { "RenameWindow", GTK_STOCK_EDIT, N_("Rename window"), nullptr, N_("Rename window"), CB(layout_menu_window_rename_cb) },
+ { "DeleteWindow", GTK_STOCK_DELETE, N_("Delete window"), nullptr, N_("Delete window"), CB(layout_menu_window_delete_cb) },
{ "NewCollection", GTK_STOCK_INDEX, N_("_New collection"), "C", N_("New collection"), CB(layout_menu_new_cb) },
{ "OpenCollection", GTK_STOCK_OPEN, N_("_Open collection..."), "O", N_("Open collection..."), CB(layout_menu_open_cb) },
- { "OpenRecent", NULL, N_("Open recen_t"), NULL, N_("Open recent collection"), NULL },
+ { "OpenRecent", nullptr, N_("Open recen_t"), nullptr, N_("Open recent collection"), nullptr },
{ "Search", GTK_STOCK_FIND, N_("_Search..."), "F3", N_("Search..."), CB(layout_menu_search_cb) },
{ "FindDupes", GTK_STOCK_FIND, N_("_Find duplicates..."), "D", N_("Find duplicates..."), CB(layout_menu_dupes_cb) },
{ "PanView", PIXBUF_INLINE_ICON_PANORAMA, N_("Pa_n view"), "<control>J", N_("Pan view"), CB(layout_menu_pan_cb) },
{ "Print", GTK_STOCK_PRINT, N_("_Print..."), "<shift>P", N_("Print..."), CB(layout_menu_print_cb) },
{ "NewFolder", GTK_STOCK_DIRECTORY, N_("N_ew folder..."), "<control>F", N_("New folder..."), CB(layout_menu_dir_cb) },
- { "EnableGrouping", NULL, N_("Enable file _grouping"), NULL, N_("Enable file grouping"), CB(layout_menu_enable_grouping_cb) },
- { "DisableGrouping", NULL, N_("Disable file groupi_ng"), NULL, N_("Disable file grouping"), CB(layout_menu_disable_grouping_cb) },
- { "CopyPath", NULL, N_("_Copy path to clipboard"), NULL, N_("Copy path to clipboard"), CB(layout_menu_copy_path_cb) },
- { "CopyPathUnquoted", NULL, N_("_Copy path unquoted to clipboard"), NULL, N_("Copy path unquoted to clipboard"), CB(layout_menu_copy_path_unquoted_cb) },
- { "Rating0",
NULL, N_("_Rating 0"), "<alt>KP_0", N_("Rating 0"), CB(layout_menu_rating_0_cb) },
- { "Rating1",
NULL, N_("_Rating 1"), "<alt>KP_1", N_("Rating 1"), CB(layout_menu_rating_1_cb) },
- { "Rating2",
NULL, N_("_Rating 2"), "<alt>KP_2", N_("Rating 2"), CB(layout_menu_rating_2_cb) },
- { "Rating3",
NULL, N_("_Rating 3"), "<alt>KP_3", N_("Rating 3"), CB(layout_menu_rating_3_cb) },
- { "Rating4",
NULL, N_("_Rating 4"), "<alt>KP_4", N_("Rating 4"), CB(layout_menu_rating_4_cb) },
- { "Rating5",
NULL, N_("_Rating 5"), "<alt>KP_5", N_("Rating 5"), CB(layout_menu_rating_5_cb) },
- { "RatingM1",
NULL, N_("_Rating -1"), "<alt>KP_Subtract", N_("Rating -1"), CB(layout_menu_rating_m1_cb) },
+ { "EnableGrouping", nullptr, N_("Enable file _grouping"), nullptr, N_("Enable file grouping"), CB(layout_menu_enable_grouping_cb) },
+ { "DisableGrouping", nullptr, N_("Disable file groupi_ng"), nullptr, N_("Disable file grouping"), CB(layout_menu_disable_grouping_cb) },
+ { "CopyPath", nullptr, N_("_Copy path to clipboard"), nullptr, N_("Copy path to clipboard"), CB(layout_menu_copy_path_cb) },
+ { "CopyPathUnquoted", nullptr, N_("_Copy path unquoted to clipboard"), nullptr, N_("Copy path unquoted to clipboard"), CB(layout_menu_copy_path_unquoted_cb) },
+ { "Rating0",
nullptr, N_("_Rating 0"), "<alt>KP_0", N_("Rating 0"), CB(layout_menu_rating_0_cb) },
+ { "Rating1",
nullptr, N_("_Rating 1"), "<alt>KP_1", N_("Rating 1"), CB(layout_menu_rating_1_cb) },
+ { "Rating2",
nullptr, N_("_Rating 2"), "<alt>KP_2", N_("Rating 2"), CB(layout_menu_rating_2_cb) },
+ { "Rating3",
nullptr, N_("_Rating 3"), "<alt>KP_3", N_("Rating 3"), CB(layout_menu_rating_3_cb) },
+ { "Rating4",
nullptr, N_("_Rating 4"), "<alt>KP_4", N_("Rating 4"), CB(layout_menu_rating_4_cb) },
+ { "Rating5",
nullptr, N_("_Rating 5"), "<alt>KP_5", N_("Rating 5"), CB(layout_menu_rating_5_cb) },
+ { "RatingM1",
nullptr, N_("_Rating -1"), "<alt>KP_Subtract", N_("Rating -1"), CB(layout_menu_rating_m1_cb) },
{ "RotateCW", PIXBUF_INLINE_ICON_CW, N_("_Rotate clockwise 90°"), "bracketright", N_("Image Rotate clockwise 90°"), CB(layout_menu_alter_90_cb) },
{ "RotateCCW", PIXBUF_INLINE_ICON_CCW, N_("Rotate _counterclockwise 90°"), "bracketleft", N_("Rotate counterclockwise 90°"), CB(layout_menu_alter_90cc_cb) },
{ "Rotate180", PIXBUF_INLINE_ICON_180, N_("Rotate 1_80°"), "<shift>R", N_("Image Rotate 180°"), CB(layout_menu_alter_180_cb) },
{ "Flip", PIXBUF_INLINE_ICON_FLIP, N_("_Flip"), "<shift>F", N_("Image Flip"), CB(layout_menu_alter_flip_cb) },
{ "AlterNone", PIXBUF_INLINE_ICON_ORIGINAL, N_("_Original state"), "<shift>O", N_("Image rotate Original state"), CB(layout_menu_alter_none_cb) },
{ "Preferences", GTK_STOCK_PREFERENCES, N_("P_references..."), "<control>O", N_("Preferences..."), CB(layout_menu_config_cb) },
- { "Plugins", GTK_STOCK_PREFERENCES, N_("Configure _Plugins..."), NULL, N_("Configure Plugins..."), CB(layout_menu_editors_cb) },
- { "LayoutConfig", GTK_STOCK_PREFERENCES, N_("_Configure this window..."), NULL, N_("Configure this window..."), CB(layout_menu_layout_config_cb) },
- { "Maintenance", PIXBUF_INLINE_ICON_MAINTENANCE, N_("_Cache maintenance..."), NULL, N_("Cache maintenance..."), CB(layout_menu_remove_thumb_cb) },
- { "Wallpaper", NULL, N_("Set as _wallpaper"), NULL, N_("Set as wallpaper"), CB(layout_menu_wallpaper_cb) },
+ { "Plugins", GTK_STOCK_PREFERENCES, N_("Configure _Plugins..."), nullptr, N_("Configure Plugins..."), CB(layout_menu_editors_cb) },
+ { "LayoutConfig", GTK_STOCK_PREFERENCES, N_("_Configure this window..."), nullptr, N_("Configure this window..."), CB(layout_menu_layout_config_cb) },
+ { "Maintenance", PIXBUF_INLINE_ICON_MAINTENANCE, N_("_Cache maintenance..."), nullptr, N_("Cache maintenance..."), CB(layout_menu_remove_thumb_cb) },
+ { "Wallpaper", nullptr, N_("Set as _wallpaper"), nullptr, N_("Set as wallpaper"), CB(layout_menu_wallpaper_cb) },
{ "SaveMetadata", GTK_STOCK_SAVE, N_("_Save metadata"), "<control>S", N_("Save metadata"), CB(layout_menu_metadata_write_cb) },
- { "KeywordAutocomplete",
NULL, N_("Keyword autocomplete"), "<alt>K", N_("Keyword Autocomplete"), CB(layout_menu_keyword_autocomplete_cb) },
+ { "KeywordAutocomplete",
nullptr, N_("Keyword autocomplete"), "<alt>K", N_("Keyword Autocomplete"), CB(layout_menu_keyword_autocomplete_cb) },
{ "ZoomInAlt1", GTK_STOCK_ZOOM_IN, N_("Zoom _in"), "KP_Add", N_("Zoom in"), CB(layout_menu_zoom_in_cb) },
{ "ZoomIn", GTK_STOCK_ZOOM_IN, N_("Zoom _in"), "equal", N_("Zoom in"), CB(layout_menu_zoom_in_cb) },
{ "ZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _out"), "minus", N_("Zoom out"), CB(layout_menu_zoom_out_cb) },
{ "ZoomFit", GTK_STOCK_ZOOM_FIT, N_("_Zoom to fit"), "X", N_("Zoom to fit"), CB(layout_menu_zoom_fit_cb) },
{ "ZoomFillHor", PIXBUF_INLINE_ICON_ZOOMFILLHOR, N_("Fit _Horizontally"), "H", N_("Fit Horizontally"), CB(layout_menu_zoom_fit_hor_cb) },
{ "ZoomFillVert", PIXBUF_INLINE_ICON_ZOOMFILLVERT, N_("Fit _Vertically"), "W", N_("Fit Vertically"), CB(layout_menu_zoom_fit_vert_cb) },
- { "Zoom200", GTK_STOCK_FILE, N_("Zoom _2:1"), NULL, N_("Zoom 2:1"), CB(layout_menu_zoom_2_1_cb) },
- { "Zoom300", GTK_STOCK_FILE, N_("Zoom _3:1"), NULL, N_("Zoom 3:1"), CB(layout_menu_zoom_3_1_cb) },
- { "Zoom400", GTK_STOCK_FILE, N_("Zoom _4:1"), NULL, N_("Zoom 4:1"), CB(layout_menu_zoom_4_1_cb) },
- { "Zoom50", GTK_STOCK_FILE, N_("Zoom 1:2"), NULL, N_("Zoom 1:2"), CB(layout_menu_zoom_1_2_cb) },
- { "Zoom33", GTK_STOCK_FILE, N_("Zoom 1:3"), NULL, N_("Zoom 1:3"), CB(layout_menu_zoom_1_3_cb) },
- { "Zoom25", GTK_STOCK_FILE, N_("Zoom 1:4"), NULL, N_("Zoom 1:4"), CB(layout_menu_zoom_1_4_cb) },
+ { "Zoom200", GTK_STOCK_FILE, N_("Zoom _2:1"), nullptr, N_("Zoom 2:1"), CB(layout_menu_zoom_2_1_cb) },
+ { "Zoom300", GTK_STOCK_FILE, N_("Zoom _3:1"), nullptr, N_("Zoom 3:1"), CB(layout_menu_zoom_3_1_cb) },
+ { "Zoom400", GTK_STOCK_FILE, N_("Zoom _4:1"), nullptr, N_("Zoom 4:1"), CB(layout_menu_zoom_4_1_cb) },
+ { "Zoom50", GTK_STOCK_FILE, N_("Zoom 1:2"), nullptr, N_("Zoom 1:2"), CB(layout_menu_zoom_1_2_cb) },
+ { "Zoom33", GTK_STOCK_FILE, N_("Zoom 1:3"), nullptr, N_("Zoom 1:3"), CB(layout_menu_zoom_1_3_cb) },
+ { "Zoom25", GTK_STOCK_FILE, N_("Zoom 1:4"), nullptr, N_("Zoom 1:4"), CB(layout_menu_zoom_1_4_cb) },
{ "ConnectZoomIn", GTK_STOCK_ZOOM_IN, N_("Zoom _in"), "plus", N_("Connected Zoom in"), CB(layout_menu_connect_zoom_in_cb) },
{ "ConnectZoomInAlt1",GTK_STOCK_ZOOM_IN, N_("Zoom _in"), "<shift>KP_Add", N_("Connected Zoom in"), CB(layout_menu_connect_zoom_in_cb) },
{ "ConnectZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _out"), "underscore", N_("Connected Zoom out"), CB(layout_menu_connect_zoom_out_cb) },
{ "ConnectZoom100Alt1",GTK_STOCK_ZOOM_100, N_("Zoom _1:1"), "<shift>KP_Divide", N_("Connected Zoom 1:1"), CB(layout_menu_connect_zoom_1_1_cb) },
{ "ConnectZoomFit", GTK_STOCK_ZOOM_FIT, N_("_Zoom to fit"), "<shift>X", N_("Connected Zoom to fit"), CB(layout_menu_connect_zoom_fit_cb) },
{ "ConnectZoomFitAlt1",GTK_STOCK_ZOOM_FIT, N_("_Zoom to fit"), "<shift>KP_Multiply", N_("Connected Zoom to fit"), CB(layout_menu_connect_zoom_fit_cb) },
- { "ConnectZoomFillHor",NULL, N_("Fit _Horizontally"), "<shift>H", N_("Connected Fit Horizontally"), CB(layout_menu_connect_zoom_fit_hor_cb) },
- { "ConnectZoomFillVert",NULL, N_("Fit _Vertically"), "<shift>W", N_("Connected Fit Vertically"), CB(layout_menu_connect_zoom_fit_vert_cb) },
- { "ConnectZoom200", NULL, N_("Zoom _2:1"), NULL, N_("Connected Zoom 2:1"), CB(layout_menu_connect_zoom_2_1_cb) },
- { "ConnectZoom300", NULL, N_("Zoom _3:1"), NULL, N_("Connected Zoom 3:1"), CB(layout_menu_connect_zoom_3_1_cb) },
- { "ConnectZoom400", NULL, N_("Zoom _4:1"), NULL, N_("Connected Zoom 4:1"), CB(layout_menu_connect_zoom_4_1_cb) },
- { "ConnectZoom50", NULL, N_("Zoom 1:2"), NULL, N_("Connected Zoom 1:2"), CB(layout_menu_connect_zoom_1_2_cb) },
- { "ConnectZoom33", NULL, N_("Zoom 1:3"), NULL, N_("Connected Zoom 1:3"), CB(layout_menu_connect_zoom_1_3_cb) },
- { "ConnectZoom25", NULL, N_("Zoom 1:4"), NULL, N_("Connected Zoom 1:4"), CB(layout_menu_connect_zoom_1_4_cb) },
- { "ViewInNewWindow", NULL, N_("_View in new window"), "<control>V", N_("View in new window"), CB(layout_menu_view_in_new_window_cb) },
- { "OpenArchive", GTK_STOCK_OPEN, N_("Open archive"), NULL, N_("Open archive"), CB(layout_menu_open_archive_cb) },
+ { "ConnectZoomFillHor",nullptr, N_("Fit _Horizontally"), "<shift>H", N_("Connected Fit Horizontally"), CB(layout_menu_connect_zoom_fit_hor_cb) },
+ { "ConnectZoomFillVert",nullptr, N_("Fit _Vertically"), "<shift>W", N_("Connected Fit Vertically"), CB(layout_menu_connect_zoom_fit_vert_cb) },
+ { "ConnectZoom200", nullptr, N_("Zoom _2:1"), nullptr, N_("Connected Zoom 2:1"), CB(layout_menu_connect_zoom_2_1_cb) },
+ { "ConnectZoom300", nullptr, N_("Zoom _3:1"), nullptr, N_("Connected Zoom 3:1"), CB(layout_menu_connect_zoom_3_1_cb) },
+ { "ConnectZoom400", nullptr, N_("Zoom _4:1"), nullptr, N_("Connected Zoom 4:1"), CB(layout_menu_connect_zoom_4_1_cb) },
+ { "ConnectZoom50", nullptr, N_("Zoom 1:2"), nullptr, N_("Connected Zoom 1:2"), CB(layout_menu_connect_zoom_1_2_cb) },
+ { "ConnectZoom33", nullptr, N_("Zoom 1:3"), nullptr, N_("Connected Zoom 1:3"), CB(layout_menu_connect_zoom_1_3_cb) },
+ { "ConnectZoom25", nullptr, N_("Zoom 1:4"), nullptr, N_("Connected Zoom 1:4"), CB(layout_menu_connect_zoom_1_4_cb) },
+ { "ViewInNewWindow", nullptr, N_("_View in new window"), "<control>V", N_("View in new window"), CB(layout_menu_view_in_new_window_cb) },
+ { "OpenArchive", GTK_STOCK_OPEN, N_("Open archive"), nullptr, N_("Open archive"), CB(layout_menu_open_archive_cb) },
{ "FullScreen", GTK_STOCK_FULLSCREEN, N_("F_ull screen"), "F", N_("Full screen"), CB(layout_menu_fullscreen_cb) },
{ "FullScreenAlt1", GTK_STOCK_FULLSCREEN, N_("F_ull screen"), "V", N_("Full screen"), CB(layout_menu_fullscreen_cb) },
{ "FullScreenAlt2", GTK_STOCK_FULLSCREEN, N_("F_ull screen"), "F11", N_("Full screen"), CB(layout_menu_fullscreen_cb) },
{ "Escape", GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"), "Escape", N_("Leave full screen"), CB(layout_menu_escape_cb) },
{ "EscapeAlt1", GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"), "Q", N_("Leave full screen"), CB(layout_menu_escape_cb) },
- { "ImageOverlayCycle",NULL, N_("_Cycle through overlay modes"), "I", N_("Cycle through Overlay modes"), CB(layout_menu_overlay_toggle_cb) },
- { "HistogramChanCycle",NULL, N_("Cycle through histogram ch_annels"),"K", N_("Cycle through histogram channels"), CB(layout_menu_histogram_toggle_channel_cb) },
- { "HistogramModeCycle",NULL, N_("Cycle through histogram mo_des"), "J", N_("Cycle through histogram modes"), CB(layout_menu_histogram_toggle_mode_cb) },
+ { "ImageOverlayCycle",nullptr, N_("_Cycle through overlay modes"), "I", N_("Cycle through Overlay modes"), CB(layout_menu_overlay_toggle_cb) },
+ { "HistogramChanCycle",nullptr, N_("Cycle through histogram ch_annels"),"K", N_("Cycle through histogram channels"), CB(layout_menu_histogram_toggle_channel_cb) },
+ { "HistogramModeCycle",nullptr, N_("Cycle through histogram mo_des"), "J", N_("Cycle through histogram modes"), CB(layout_menu_histogram_toggle_mode_cb) },
{ "HideTools", PIXBUF_INLINE_ICON_HIDETOOLS, N_("_Hide file list"), "<control>H", N_("Hide file list"), CB(layout_menu_hide_cb) },
{ "SlideShowPause", GTK_STOCK_MEDIA_PAUSE, N_("_Pause slideshow"), "P", N_("Pause slideshow"), CB(layout_menu_slideshow_pause_cb) },
{ "SlideShowFaster", GTK_STOCK_FILE, N_("Faster"), "<control>equal", N_("Slideshow Faster"), CB(layout_menu_slideshow_faster_cb) },
{ "SlideShowSlower", GTK_STOCK_FILE, N_("Slower"), "<control>minus", N_("Slideshow Slower"), CB(layout_menu_slideshow_slower_cb) },
{ "Refresh", GTK_STOCK_REFRESH, N_("_Refresh"), "R", N_("Refresh"), CB(layout_menu_refresh_cb) },
{ "HelpContents", GTK_STOCK_HELP, N_("_Help manual"), "F1", N_("Help manual"), CB(layout_menu_help_cb) },
- { "HelpSearch", NULL, N_("On-line help search"), NULL, N_("On-line help search"), CB(layout_menu_help_search_cb) },
- { "HelpShortcuts", NULL, N_("_Keyboard shortcuts"), NULL, N_("Keyboard shortcuts"), CB(layout_menu_help_keys_cb) },
- { "HelpKbd", NULL, N_("_Keyboard map"), NULL, N_("Keyboard map"), CB(layout_menu_kbd_map_cb) },
- { "HelpNotes", NULL, N_("_Readme"), NULL, N_("Readme"), CB(layout_menu_notes_cb) },
- { "HelpChangeLog", NULL, N_("_ChangeLog"), NULL, N_("ChangeLog notes"), CB(layout_menu_changelog_cb) },
+ { "HelpSearch", nullptr, N_("On-line help search"), nullptr, N_("On-line help search"), CB(layout_menu_help_search_cb) },
+ { "HelpShortcuts", nullptr, N_("_Keyboard shortcuts"), nullptr, N_("Keyboard shortcuts"), CB(layout_menu_help_keys_cb) },
+ { "HelpKbd", nullptr, N_("_Keyboard map"), nullptr, N_("Keyboard map"), CB(layout_menu_kbd_map_cb) },
+ { "HelpNotes", nullptr, N_("_Readme"), nullptr, N_("Readme"), CB(layout_menu_notes_cb) },
+ { "HelpChangeLog", nullptr, N_("_ChangeLog"), nullptr, N_("ChangeLog notes"), CB(layout_menu_changelog_cb) },
{ "SearchAndRunCommand", GTK_STOCK_FIND, N_("Search and Run command"), "slash", N_("Search commands by keyword and run them"), CB(layout_menu_search_and_run_cb) },
- { "About", GTK_STOCK_ABOUT, N_("_About"), NULL, N_("About"), CB(layout_menu_about_cb) },
- { "LogWindow", NULL, N_("_Log Window"), NULL, N_("Log Window"), CB(layout_menu_log_window_cb) },
+ { "About", GTK_STOCK_ABOUT, N_("_About"), nullptr, N_("About"), CB(layout_menu_about_cb) },
+ { "LogWindow", nullptr, N_("_Log Window"), nullptr, N_("Log Window"), CB(layout_menu_log_window_cb) },
{ "ExifWin", PIXBUF_INLINE_ICON_EXIF, N_("_Exif window"), "<control>E", N_("Exif window"), CB(layout_menu_bar_exif_cb) },
- { "StereoCycle", NULL, N_("_Cycle through stereo modes"), NULL, N_("Cycle through stereo modes"), CB(layout_menu_stereo_mode_next_cb) },
- { "SplitNextPane",
NULL, N_("_Next Pane"), "<alt>Right", N_("Next Split Pane"), CB(layout_menu_split_pane_next_cb) },
- { "SplitPreviousPane",
NULL, N_("_Previous Pane"), "<alt>Left", N_("Previous Split Pane"), CB(layout_menu_split_pane_prev_cb) },
- { "SplitUpPane",
NULL, N_("_Up Pane"), "<alt>Up", N_("Up Split Pane"), CB(layout_menu_split_pane_updown_cb) },
- { "SplitDownPane",
NULL, N_("_Down Pane"), "<alt>Down", N_("Down Split Pane"), CB(layout_menu_split_pane_updown_cb) },
- { "WriteRotation", NULL, N_("_Write orientation to file"), NULL, N_("Write orientation to file"), CB(layout_menu_write_rotate_cb) },
- { "WriteRotationKeepDate", NULL, N_("_Write orientation to file (preserve timestamp)"), NULL, N_("Write orientation to file (preserve timestamp)"), CB(layout_menu_write_rotate_keep_date_cb) },
- { "ClearMarks", NULL, N_("Clear Marks..."), NULL, N_("Clear Marks"), CB(layout_menu_clear_marks_cb) },
+ { "StereoCycle", nullptr, N_("_Cycle through stereo modes"), nullptr, N_("Cycle through stereo modes"), CB(layout_menu_stereo_mode_next_cb) },
+ { "SplitNextPane",
nullptr, N_("_Next Pane"), "<alt>Right", N_("Next Split Pane"), CB(layout_menu_split_pane_next_cb) },
+ { "SplitPreviousPane",
nullptr, N_("_Previous Pane"), "<alt>Left", N_("Previous Split Pane"), CB(layout_menu_split_pane_prev_cb) },
+ { "SplitUpPane",
nullptr, N_("_Up Pane"), "<alt>Up", N_("Up Split Pane"), CB(layout_menu_split_pane_updown_cb) },
+ { "SplitDownPane",
nullptr, N_("_Down Pane"), "<alt>Down", N_("Down Split Pane"), CB(layout_menu_split_pane_updown_cb) },
+ { "WriteRotation", nullptr, N_("_Write orientation to file"), nullptr, N_("Write orientation to file"), CB(layout_menu_write_rotate_cb) },
+ { "WriteRotationKeepDate", nullptr, N_("_Write orientation to file (preserve timestamp)"), nullptr, N_("Write orientation to file (preserve timestamp)"), CB(layout_menu_write_rotate_keep_date_cb) },
+ { "ClearMarks", nullptr, N_("Clear Marks..."), nullptr, N_("Clear Marks"), CB(layout_menu_clear_marks_cb) },
};
static GtkToggleActionEntry menu_toggle_entries[] = {
{ "Thumbnails", PIXBUF_INLINE_ICON_THUMB,N_("Show _Thumbnails"), "T", N_("Show Thumbnails"), CB(layout_menu_thumb_cb), FALSE },
{ "ShowMarks", PIXBUF_INLINE_ICON_MARKS, N_("Show _Marks"), "M", N_("Show Marks"), CB(layout_menu_marks_cb), FALSE },
- { "ShowFileFilter", PIXBUF_INLINE_ICON_FILE_FILTER, N_("Show File Filter"), NULL, N_("Show File Filter"), CB(layout_menu_file_filter_cb), FALSE },
- { "ShowInfoPixel", GTK_STOCK_COLOR_PICKER, N_("Pi_xel Info"), NULL, N_("Show Pixel Info"), CB(layout_menu_info_pixel_cb), FALSE },
+ { "ShowFileFilter", PIXBUF_INLINE_ICON_FILE_FILTER, N_("Show File Filter"), nullptr, N_("Show File Filter"), CB(layout_menu_file_filter_cb), FALSE },
+ { "ShowInfoPixel", GTK_STOCK_COLOR_PICKER, N_("Pi_xel Info"), nullptr, N_("Show Pixel Info"), CB(layout_menu_info_pixel_cb), FALSE },
{ "IgnoreAlpha", GTK_STOCK_STRIKETHROUGH, N_("Hide _alpha"), "<shift>A", N_("Hide alpha channel"), CB(layout_menu_alter_ignore_alpha_cb), FALSE},
{ "FloatTools", PIXBUF_INLINE_ICON_FLOAT,N_("_Float file list"), "L", N_("Float file list"), CB(layout_menu_float_cb), FALSE },
- { "HideToolbar", NULL, N_("Hide tool_bar"), NULL, N_("Hide toolbar"), CB(layout_menu_toolbar_cb), FALSE },
+ { "HideToolbar", nullptr, N_("Hide tool_bar"), nullptr, N_("Hide toolbar"), CB(layout_menu_toolbar_cb), FALSE },
{ "SBar", PIXBUF_INLINE_ICON_INFO, N_("_Info sidebar"), "<control>K", N_("Info sidebar"), CB(layout_menu_bar_cb), FALSE },
{ "SBarSort", PIXBUF_INLINE_ICON_SORT, N_("Sort _manager"), "<shift>S", N_("Sort manager"), CB(layout_menu_bar_sort_cb), FALSE },
- { "HideBars", NULL, N_("Hide Bars"), "grave", N_("Hide Bars"), CB(layout_menu_hide_bars_cb), FALSE },
+ { "HideBars", nullptr, N_("Hide Bars"), "grave", N_("Hide Bars"), CB(layout_menu_hide_bars_cb), FALSE },
{ "SlideShow", GTK_STOCK_MEDIA_PLAY, N_("Toggle _slideshow"), "S", N_("Toggle slideshow"), CB(layout_menu_slideshow_cb), FALSE },
- { "UseColorProfiles", GTK_STOCK_SELECT_COLOR, N_("Use _color profiles"), NULL, N_("Use color profiles"), CB(layout_color_menu_enable_cb), FALSE},
- { "UseImageProfile", NULL, N_("Use profile from _image"), NULL, N_("Use profile from image"), CB(layout_color_menu_use_image_cb), FALSE},
+ { "UseColorProfiles", GTK_STOCK_SELECT_COLOR, N_("Use _color profiles"), nullptr, N_("Use color profiles"), CB(layout_color_menu_enable_cb), FALSE},
+ { "UseImageProfile", nullptr, N_("Use profile from _image"), nullptr, N_("Use profile from image"), CB(layout_color_menu_use_image_cb), FALSE},
{ "Grayscale", PIXBUF_INLINE_ICON_GRAYSCALE, N_("Toggle _grayscale"), "<shift>G", N_("Toggle grayscale"), CB(layout_menu_alter_desaturate_cb), FALSE},
- { "ImageOverlay", NULL, N_("Image _Overlay"), NULL, N_("Image Overlay"), CB(layout_menu_overlay_cb), FALSE },
- { "ImageHistogram", NULL, N_("_Show Histogram"), NULL, N_("Show Histogram"), CB(layout_menu_histogram_cb), FALSE },
+ { "ImageOverlay", nullptr, N_("Image _Overlay"), nullptr, N_("Image Overlay"), CB(layout_menu_overlay_cb), FALSE },
+ { "ImageHistogram", nullptr, N_("_Show Histogram"), nullptr, N_("Show Histogram"), CB(layout_menu_histogram_cb), FALSE },
{ "RectangularSelection", PIXBUF_INLINE_ICON_SELECT_RECTANGLE, N_("Rectangular Selection"), "<alt>R", N_("Rectangular Selection"), CB(layout_menu_rectangular_selection_cb), FALSE },
- { "Animate", NULL, N_("_Animation"), "A", N_("Toggle animation"), CB(layout_menu_animate_cb), FALSE },
+ { "Animate", nullptr, N_("_Animation"), "A", N_("Toggle animation"), CB(layout_menu_animate_cb), FALSE },
{ "ExifRotate", GTK_STOCK_ORIENTATION_PORTRAIT, N_("_Exif rotate"), "<alt>X", N_("Toggle Exif rotate"), CB(layout_menu_exif_rotate_cb), FALSE },
- { "DrawRectangle", PIXBUF_INLINE_ICON_DRAW_RECTANGLE, N_("Draw Rectangle"), NULL, N_("Draw Rectangle"), CB(layout_menu_select_rectangle_cb), FALSE },
+ { "DrawRectangle", PIXBUF_INLINE_ICON_DRAW_RECTANGLE, N_("Draw Rectangle"), nullptr, N_("Draw Rectangle"), CB(layout_menu_select_rectangle_cb), FALSE },
{ "OverUnderExposed", PIXBUF_INLINE_ICON_EXPOSURE, N_("Over/Under Exposed"), "<shift>E", N_("Highlight over/under exposed"), CB(layout_menu_select_overunderexposed_cb), FALSE },
- { "SplitPaneSync", PIXBUF_INLINE_SPLIT_PANE_SYNC, N_("Split Pane Sync"), NULL, N_("Split Pane Sync"), CB(layout_menu_split_pane_sync_cb), FALSE },
+ { "SplitPaneSync", PIXBUF_INLINE_SPLIT_PANE_SYNC, N_("Split Pane Sync"), nullptr, N_("Split Pane Sync"), CB(layout_menu_split_pane_sync_cb), FALSE },
};
static GtkRadioActionEntry menu_radio_entries[] = {
- { "ViewList", NULL, N_("Images as _List"), "<control>L", N_("View Images as List"), FILEVIEW_LIST },
- { "ViewIcons", NULL, N_("Images as I_cons"), "<control>I", N_("View Images as Icons"), FILEVIEW_ICON }
+ { "ViewList", nullptr, N_("Images as _List"), "<control>L", N_("View Images as List"), FILEVIEW_LIST },
+ { "ViewIcons", nullptr, N_("Images as I_cons"), "<control>I", N_("View Images as Icons"), FILEVIEW_ICON }
};
static GtkToggleActionEntry menu_view_dir_toggle_entries[] = {
- { "FolderTree", NULL, N_("T_oggle Folder View"), "<control>T", N_("Toggle Folders View"), CB(layout_menu_view_dir_as_cb),FALSE },
+ { "FolderTree", nullptr, N_("T_oggle Folder View"), "<control>T", N_("Toggle Folders View"), CB(layout_menu_view_dir_as_cb),FALSE },
};
static GtkRadioActionEntry menu_split_radio_entries[] = {
- { "SplitHorizontal", NULL, N_("_Horizontal"), "E", N_("Split panes horizontal."), SPLIT_HOR },
- { "SplitVertical", NULL, N_("_Vertical"), "U", N_("Split panes vertical"), SPLIT_VERT },
- { "SplitTriple", NULL, N_("_Triple"), NULL, N_("Split panes triple"), SPLIT_TRIPLE },
- { "SplitQuad", NULL, N_("_Quad"), NULL, N_("Split panes quad"), SPLIT_QUAD },
- { "SplitSingle", NULL, N_("_Single"), "Y", N_("Single pane"), SPLIT_NONE }
+ { "SplitHorizontal", nullptr, N_("_Horizontal"), "E", N_("Split panes horizontal."), SPLIT_HOR },
+ { "SplitVertical", nullptr, N_("_Vertical"), "U", N_("Split panes vertical"), SPLIT_VERT },
+ { "SplitTriple", nullptr, N_("_Triple"), nullptr, N_("Split panes triple"), SPLIT_TRIPLE },
+ { "SplitQuad", nullptr, N_("_Quad"), nullptr, N_("Split panes quad"), SPLIT_QUAD },
+ { "SplitSingle", nullptr, N_("_Single"), "Y", N_("Single pane"), SPLIT_NONE }
};
static GtkRadioActionEntry menu_color_radio_entries[] = {
- { "ColorProfile0", NULL, N_("Input _0: sRGB"), NULL, N_("Input 0: sRGB"), COLOR_PROFILE_SRGB },
- { "ColorProfile1", NULL, N_("Input _1: AdobeRGB compatible"), NULL, N_("Input 1: AdobeRGB compatible"), COLOR_PROFILE_ADOBERGB },
- { "ColorProfile2", NULL, N_("Input _2"), NULL, N_("Input 2"), COLOR_PROFILE_FILE },
- { "ColorProfile3", NULL, N_("Input _3"), NULL, N_("Input 3"), COLOR_PROFILE_FILE + 1 },
- { "ColorProfile4", NULL, N_("Input _4"), NULL, N_("Input 4"), COLOR_PROFILE_FILE + 2 },
- { "ColorProfile5", NULL, N_("Input _5"), NULL, N_("Input 5"), COLOR_PROFILE_FILE + 3 }
+ { "ColorProfile0", nullptr, N_("Input _0: sRGB"), nullptr, N_("Input 0: sRGB"), COLOR_PROFILE_SRGB },
+ { "ColorProfile1", nullptr, N_("Input _1: AdobeRGB compatible"), nullptr, N_("Input 1: AdobeRGB compatible"), COLOR_PROFILE_ADOBERGB },
+ { "ColorProfile2", nullptr, N_("Input _2"), nullptr, N_("Input 2"), COLOR_PROFILE_FILE },
+ { "ColorProfile3", nullptr, N_("Input _3"), nullptr, N_("Input 3"), COLOR_PROFILE_FILE + 1 },
+ { "ColorProfile4", nullptr, N_("Input _4"), nullptr, N_("Input 4"), COLOR_PROFILE_FILE + 2 },
+ { "ColorProfile5", nullptr, N_("Input _5"), nullptr, N_("Input 5"), COLOR_PROFILE_FILE + 3 }
};
static GtkRadioActionEntry menu_histogram_channel[] = {
- { "HistogramChanR", NULL, N_("Histogram on _Red"), NULL, N_("Histogram on Red"), HCHAN_R },
- { "HistogramChanG", NULL, N_("Histogram on _Green"), NULL, N_("Histogram on Green"), HCHAN_G },
- { "HistogramChanB", NULL, N_("Histogram on _Blue"), NULL, N_("Histogram on Blue"), HCHAN_B },
- { "HistogramChanRGB", NULL, N_("_Histogram on RGB"), NULL, N_("Histogram on RGB"), HCHAN_RGB },
- { "HistogramChanV", NULL, N_("Histogram on _Value"), NULL, N_("Histogram on Value"), HCHAN_MAX }
+ { "HistogramChanR", nullptr, N_("Histogram on _Red"), nullptr, N_("Histogram on Red"), HCHAN_R },
+ { "HistogramChanG", nullptr, N_("Histogram on _Green"), nullptr, N_("Histogram on Green"), HCHAN_G },
+ { "HistogramChanB", nullptr, N_("Histogram on _Blue"), nullptr, N_("Histogram on Blue"), HCHAN_B },
+ { "HistogramChanRGB", nullptr, N_("_Histogram on RGB"), nullptr, N_("Histogram on RGB"), HCHAN_RGB },
+ { "HistogramChanV", nullptr, N_("Histogram on _Value"), nullptr, N_("Histogram on Value"), HCHAN_MAX }
};
static GtkRadioActionEntry menu_histogram_mode[] = {
- { "HistogramModeLin", NULL, N_("Li_near Histogram"), NULL, N_("Linear Histogram"), 0 },
- { "HistogramModeLog", NULL, N_("_Log Histogram"), NULL, N_("Log Histogram"), 1 },
+ { "HistogramModeLin", nullptr, N_("Li_near Histogram"), nullptr, N_("Linear Histogram"), 0 },
+ { "HistogramModeLog", nullptr, N_("_Log Histogram"), nullptr, N_("Log Histogram"), 1 },
};
static GtkRadioActionEntry menu_stereo_mode_entries[] = {
- { "StereoAuto", NULL, N_("_Auto"), NULL, N_("Stereo Auto"), STEREO_PIXBUF_DEFAULT },
- { "StereoSBS", NULL, N_("_Side by Side"), NULL, N_("Stereo Side by Side"), STEREO_PIXBUF_SBS },
- { "StereoCross", NULL, N_("_Cross"), NULL, N_("Stereo Cross"), STEREO_PIXBUF_CROSS },
- { "StereoOff", NULL, N_("_Off"), NULL, N_("Stereo Off"), STEREO_PIXBUF_NONE }
+ { "StereoAuto", nullptr, N_("_Auto"), nullptr, N_("Stereo Auto"), STEREO_PIXBUF_DEFAULT },
+ { "StereoSBS", nullptr, N_("_Side by Side"), nullptr, N_("Stereo Side by Side"), STEREO_PIXBUF_SBS },
+ { "StereoCross", nullptr, N_("_Cross"), nullptr, N_("Stereo Cross"), STEREO_PIXBUF_CROSS },
+ { "StereoOff", nullptr, N_("_Off"), nullptr, N_("Stereo Off"), STEREO_PIXBUF_NONE }
};
gchar label[100];
gchar accel[50];
gchar tooltip[100];
- GtkActionEntry entry = { name, NULL, label, accel, tooltip, cb };
+ GtkActionEntry entry = { name, nullptr, label, accel, tooltip, cb };
GtkAction *action;
g_snprintf(name, sizeof(name), name_tmpl, mark);
if (accel_tmpl)
g_snprintf(accel, sizeof(accel), accel_tmpl, mark % 10);
else
- entry.accelerator = NULL;
+ entry.accelerator = nullptr;
if (tooltip_tmpl)
g_snprintf(tooltip, sizeof(tooltip), tooltip_tmpl, mark);
else
- entry.tooltip = NULL;
+ entry.tooltip = nullptr;
gtk_action_group_add_actions(lw->action_group, &entry, 1, lw);
action = gtk_action_group_get_action(lw->action_group, name);
{
gint i = (mark < 10 ? mark : 0);
- layout_actions_setup_mark(lw, i, "Mark%d", _("Mark _%d"), NULL, NULL, NULL);
- layout_actions_setup_mark(lw, i, "SetMark%d", _("_Set mark %d"), NULL, _("Set mark %d"), G_CALLBACK(layout_menu_set_mark_sel_cb));
- layout_actions_setup_mark(lw, i, "ResetMark%d", _("_Reset mark %d"), NULL, _("Reset mark %d"), G_CALLBACK(layout_menu_res_mark_sel_cb));
+ layout_actions_setup_mark(lw, i, "Mark%d", _("Mark _%d"), nullptr, nullptr, nullptr);
+ layout_actions_setup_mark(lw, i, "SetMark%d", _("_Set mark %d"), nullptr, _("Set mark %d"), G_CALLBACK(layout_menu_set_mark_sel_cb));
+ layout_actions_setup_mark(lw, i, "ResetMark%d", _("_Reset mark %d"), nullptr, _("Reset mark %d"), G_CALLBACK(layout_menu_res_mark_sel_cb));
layout_actions_setup_mark(lw, i, "ToggleMark%d", _("_Toggle mark %d"), "%d", _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
layout_actions_setup_mark(lw, i, "ToggleMark%dAlt1", _("_Toggle mark %d"), "KP_%d", _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
layout_actions_setup_mark(lw, i, "SelectMark%d", _("Se_lect mark %d"), "<control>%d", _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
layout_actions_setup_mark(lw, i, "SelectMark%dAlt1", _("_Select mark %d"), "<control>KP_%d", _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
- layout_actions_setup_mark(lw, i, "AddMark%d", _("_Add mark %d"), NULL, _("Add mark %d"), G_CALLBACK(layout_menu_sel_mark_or_cb));
- layout_actions_setup_mark(lw, i, "IntMark%d", _("_Intersection with mark %d"), NULL, _("Intersection with mark %d"), G_CALLBACK(layout_menu_sel_mark_and_cb));
- layout_actions_setup_mark(lw, i, "UnselMark%d", _("_Unselect mark %d"), NULL, _("Unselect mark %d"), G_CALLBACK(layout_menu_sel_mark_minus_cb));
- layout_actions_setup_mark(lw, i, "FilterMark%d", _("_Filter mark %d"), NULL, _("Filter mark %d"), G_CALLBACK(layout_menu_mark_filter_toggle_cb));
+ layout_actions_setup_mark(lw, i, "AddMark%d", _("_Add mark %d"), nullptr, _("Add mark %d"), G_CALLBACK(layout_menu_sel_mark_or_cb));
+ layout_actions_setup_mark(lw, i, "IntMark%d", _("_Intersection with mark %d"), nullptr, _("Intersection with mark %d"), G_CALLBACK(layout_menu_sel_mark_and_cb));
+ layout_actions_setup_mark(lw, i, "UnselMark%d", _("_Unselect mark %d"), nullptr, _("Unselect mark %d"), G_CALLBACK(layout_menu_sel_mark_minus_cb));
+ layout_actions_setup_mark(lw, i, "FilterMark%d", _("_Filter mark %d"), nullptr, _("Filter mark %d"), G_CALLBACK(layout_menu_mark_filter_toggle_cb));
g_string_append_printf(desc,
" <menu action='Mark%d'>"
}
g_string_append(desc, "</ui>" );
- error = NULL;
+ error = nullptr;
if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error))
{
g_message("building menus failed: %s", error->message);
{
gchar **split = g_strsplit(editor->menu_path, "/", 0);
gint i = 0;
- GList *ret = NULL;
+ GList *ret = nullptr;
- if (split[0] == NULL)
+ if (split[0] == nullptr)
{
g_strfreev(split);
- return NULL;
+ return nullptr;
}
while (split[i])
editors_list = editor_list_get();
- old_path = NULL;
+ old_path = nullptr;
work = editors_list;
while (work)
{
GList *path;
auto editor = static_cast<EditorDescription *>(work->data);
GtkActionEntry entry = { editor->key,
- NULL,
+ nullptr,
editor->name,
editor->hotkey,
editor->comment ? editor->comment : editor->name,
work = work->next;
}
- layout_actions_editor_add(desc, NULL, old_path);
+ layout_actions_editor_add(desc, nullptr, old_path);
string_list_free(old_path);
g_string_append(desc, " </menubar>"
"</ui>" );
- error = NULL;
+ error = nullptr;
lw->ui_editors_id = gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error);
if (!lw->ui_editors_id)
if (lw->ui_manager) return;
lw->action_group = gtk_action_group_new("MenuActions");
- gtk_action_group_set_translate_func(lw->action_group, menu_translate, NULL, NULL);
+ gtk_action_group_set_translate_func(lw->action_group, menu_translate, nullptr, nullptr);
gtk_action_group_add_actions(lw->action_group,
menu_entries, G_N_ELEMENTS(menu_entries), lw);
gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group, 0);
DEBUG_1("%s layout_actions_setup: add menu", get_exec_time());
- error = NULL;
+ error = nullptr;
if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, menu_ui_description, -1, &error))
{
g_message("building menus failed: %s", error->message);
}
static gint layout_editors_reload_idle_id = -1;
-static GList *layout_editors_desktop_files = NULL;
+static GList *layout_editors_desktop_files = nullptr;
static gboolean layout_editors_reload_idle_cb(gpointer UNUSED(data))
{
}
editor_table_clear();
- layout_editors_reload_idle_id = g_idle_add(layout_editors_reload_idle_cb, NULL);
+ layout_editors_reload_idle_id = g_idle_add(layout_editors_reload_idle_cb, nullptr);
}
void layout_editors_reload_finish(void)
g_source_remove(layout_editors_reload_idle_id);
while (layout_editors_reload_idle_id != -1)
{
- layout_editors_reload_idle_cb(NULL);
+ layout_editors_reload_idle_cb(nullptr);
}
}
}
gtk_ui_manager_ensure_update(lw->ui_manager);
}
string_list_free(lw->toolbar_actions[type]);
- lw->toolbar_actions[type] = NULL;
+ lw->toolbar_actions[type] = nullptr;
lw->toolbar_merge_id[type] = gtk_ui_manager_new_merge_id(lw->ui_manager);
}
void layout_toolbar_add(LayoutWindow *lw, ToolbarType type, const gchar *action)
{
- const gchar *path = NULL;
+ const gchar *path = nullptr;
if (!action || !lw->ui_manager) return;
GtkActionEntry entry = { action,
GTK_STOCK_MISSING_IMAGE,
action,
- NULL,
- NULL,
- NULL };
+ nullptr,
+ nullptr,
+ nullptr };
DEBUG_1("Creating temporary action %s", action);
gtk_action_group_add_actions(lw->action_group_editors, &entry, 1, lw);
}
void layout_toolbar_write_config(LayoutWindow *lw, ToolbarType type, GString *outstr, gint indent)
{
- const gchar *name = NULL;
+ const gchar *name = nullptr;
GList *work = lw->toolbar_actions[type];
switch (type)
void layout_toolbar_add_from_config(LayoutWindow *lw, ToolbarType type, const char **attribute_names, const gchar **attribute_values)
{
- gchar *action = NULL;
+ gchar *action = nullptr;
while (*attribute_names)
{
{
auto lw = static_cast<LayoutWindow *>(data);
- lw->bar = NULL;
+ lw->bar = nullptr;
/*
do not call layout_util_sync_views(lw) here
this is called either when whole layout is destroyed - no need for update
if (lw->bar)
{
bar_close(lw->bar);
- lw->bar = NULL;
+ lw->bar = nullptr;
}
}
{
auto lw = static_cast<LayoutWindow *>(data);
- lw->bar_sort = NULL;
+ lw->bar_sort = nullptr;
/*
do not call layout_util_sync_views(lw) here
if (lw->bar_sort)
{
bar_sort_close(lw->bar_sort);
- lw->bar_sort = NULL;
+ lw->bar_sort = nullptr;
}
}
/* this should be called here to handle the metadata edited in bars */
if (options->metadata.confirm_on_image_change)
- metadata_write_queue_confirm(FALSE, NULL, NULL);
+ metadata_write_queue_confirm(FALSE, nullptr, nullptr);
}
void layout_bars_new_selection(LayoutWindow *lw, gint count)
static gboolean layout_exif_window_destroy(GtkWidget *UNUSED(widget), gpointer data)
{
auto lw = static_cast<LayoutWindow *>(data);
- lw->exif_window = NULL;
+ lw->exif_window = nullptr;
return TRUE;
}
#define PANE_DIVIDER_SIZE 10
-GList *layout_window_list = NULL;
-LayoutWindow *current_lw = NULL;
+GList *layout_window_list = nullptr;
+LayoutWindow *current_lw = nullptr;
static void layout_list_scroll_to_subpart(LayoutWindow *lw, const gchar *needle);
gboolean layout_valid(LayoutWindow **lw)
{
- if (*lw == NULL)
+ if (*lw == nullptr)
{
if (current_lw) *lw = current_lw;
else if (layout_window_list) *lw = static_cast<LayoutWindow *>(layout_window_list->data);
- return (*lw != NULL);
+ return (*lw != nullptr);
}
- return (g_list_find(layout_window_list, *lw) != NULL);
+ return (g_list_find(layout_window_list, *lw) != nullptr);
}
LayoutWindow *layout_find_by_image(ImageWindow *imd)
if (lw->image == imd) return lw;
}
- return NULL;
+ return nullptr;
}
LayoutWindow *layout_find_by_image_fd(ImageWindow *imd)
return lw;
}
- return NULL;
+ return nullptr;
}
LayoutWindow *layout_find_by_layout_id(const gchar *id)
{
GList *work;
- if (!id || !id[0]) return NULL;
+ if (!id || !id[0]) return nullptr;
if (strcmp(id, LAYOUT_ID_CURRENT) == 0)
{
if (current_lw) return current_lw;
if (layout_window_list) return static_cast<LayoutWindow *>(layout_window_list->data);
- return NULL;
+ return nullptr;
}
work = layout_window_list;
return lw;
}
- return NULL;
+ return nullptr;
}
gchar *layout_get_unique_id()
if (lw->options.id && lw->options.id[0]) return; /* id is already set */
g_free(lw->options.id);
- lw->options.id = NULL;
+ lw->options.id = nullptr;
i = 1;
while (TRUE)
menu_bar = layout_actions_menu_bar(lw);
toolbar = layout_actions_toolbar(lw, TOOLBAR_MAIN);
- scroll_window = gtk_scrolled_window_new(NULL, NULL);
+ scroll_window = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC,GTK_POLICY_NEVER);
gtk_container_add(GTK_CONTAINER(scroll_window), menu_bar);
if (lw->options.toolbar_hidden) gtk_widget_hide(lw->toolbar[TOOLBAR_MAIN]);
}
- tabcomp = tab_completion_new_with_history(&lw->path_entry, NULL, "path_list", -1,
+ tabcomp = tab_completion_new_with_history(&lw->path_entry, nullptr, "path_list", -1,
layout_path_entry_cb, lw);
DEBUG_NAME(tabcomp);
tab_completion_add_tab_func(lw->path_entry, layout_path_entry_tab_cb, lw);
auto lw = static_cast<LayoutWindow *>(data);
GtkWidget *menu;
- menu = submenu_add_sort(NULL, G_CALLBACK(layout_sort_menu_cb), lw, FALSE, FALSE, TRUE, lw->sort_method);
+ menu = submenu_add_sort(nullptr, G_CALLBACK(layout_sort_menu_cb), lw, FALSE, FALSE, TRUE, lw->sort_method);
/* take ownership of menu */
#ifdef GTK_OBJECT_FLOATING
g_signal_connect(G_OBJECT(menu), "selection_done",
G_CALLBACK(layout_sort_menu_hide_cb), NULL);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static GtkWidget *layout_sort_button(LayoutWindow *lw, GtkWidget *box)
GtkWidget *frame;
GtkWidget *image;
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
auto lw = static_cast<LayoutWindow *>(data);
GtkWidget *menu;
- menu = submenu_add_zoom(NULL, G_CALLBACK(layout_zoom_menu_cb),
+ menu = submenu_add_zoom(nullptr, G_CALLBACK(layout_zoom_menu_cb),
lw, FALSE, FALSE, TRUE, options->image.zoom_mode);
/* take ownership of menu */
g_signal_connect(G_OBJECT(menu), "selection_done",
G_CALLBACK(layout_zoom_menu_hide_cb), NULL);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static GtkWidget *layout_zoom_button(LayoutWindow *lw, GtkWidget *box, gint size, gboolean UNUSED(expand))
GtkWidget *frame;
GtkWidget *image;
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
if (size) gtk_widget_set_size_request(frame, size, -1);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
void layout_status_update_info(LayoutWindow *lw, const gchar *text)
{
- gchar *buf = NULL;
+ gchar *buf = nullptr;
gint hrs;
gint min;
gdouble sec;
if (!layout_valid(&lw) || !lw->image) return;
if (!lw->info_zoom || !lw->info_details) return; /*called from layout_style_set */
- n = layout_list_count(lw, NULL);
+ n = layout_list_count(lw, nullptr);
if (!n)
{
void layout_status_update_all(LayoutWindow *lw)
{
- layout_status_update_progress(lw, 0.0, NULL);
- layout_status_update_info(lw, NULL);
+ layout_status_update_progress(lw, 0.0, nullptr);
+ layout_status_update_info(lw, nullptr);
layout_status_update_image(lw);
layout_util_status_update_write(lw);
}
GtkWidget *label;
GtkWidget *frame;
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
if (size) gtk_widget_set_size_request(frame, size, -1);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_tooltip_text(GTK_WIDGET(lw->info_sort), _("Select sort order"));
gtk_widget_show(lw->info_sort);
- lw->info_status = layout_status_label(NULL, lw->info_box, TRUE, 0, (!small_format));
+ lw->info_status = layout_status_label(nullptr, lw->info_box, TRUE, 0, (!small_format));
DEBUG_NAME(lw->info_status);
gtk_widget_set_tooltip_text(GTK_WIDGET(lw->info_status), _("Folder contents (files selected)\nSlideshow [time interval]"));
gtk_box_pack_start(GTK_BOX(lw->info_box), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
}
- lw->info_details = layout_status_label(NULL, hbox, TRUE, 0, TRUE);
+ lw->info_details = layout_status_label(nullptr, hbox, TRUE, 0, TRUE);
DEBUG_NAME(lw->info_details);
gtk_widget_set_tooltip_text(GTK_WIDGET(lw->info_details), _("(Image dimensions) Image size [page n of m]"));
toolbar = layout_actions_toolbar(lw, TOOLBAR_STATUS);
- toolbar_frame = gtk_frame_new(NULL);
+ toolbar_frame = gtk_frame_new(nullptr);
DEBUG_NAME(toolbar_frame);
gtk_frame_set_shadow_type(GTK_FRAME(toolbar_frame), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(toolbar_frame), toolbar);
gtk_box_pack_start(GTK_BOX(lw->info_box), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
}
- lw->info_pixel = layout_status_label(NULL, hbox, FALSE, 0, small_format); /* expand only in small format */
+ lw->info_pixel = layout_status_label(nullptr, hbox, FALSE, 0, small_format); /* expand only in small format */
DEBUG_NAME(lw->info_pixel);
gtk_widget_set_tooltip_text(GTK_WIDGET(lw->info_pixel), _("[Pixel x,y coord]: (Pixel R,G,B value)"));
if (!lw->options.show_info_pixel) gtk_widget_hide(gtk_widget_get_parent(lw->info_pixel));
{
auto lw = static_cast<LayoutWindow *>(data);
- layout_status_update_info(lw, NULL);
+ layout_status_update_info(lw, nullptr);
}
static void layout_list_thumb_cb(ViewFile *UNUSED(vf), gdouble val, const gchar *text, gpointer data)
static GtkWidget *layout_list_new(LayoutWindow *lw)
{
- lw->vf = vf_new(lw->options.file_view_type, NULL);
+ lw->vf = vf_new(lw->options.file_view_type, nullptr);
vf_set_layout(lw->vf, lw);
vf_set_status_func(lw->vf, layout_list_status_cb, lw);
GList *layout_list(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
if (lw->vf) return vf_get_list(lw->vf);
- return NULL;
+ return nullptr;
}
guint layout_list_count(LayoutWindow *lw, gint64 *bytes)
FileData *layout_list_get_fd(LayoutWindow *lw, gint index)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
if (lw->vf) return vf_index_get_data(lw->vf, index);
- return NULL;
+ return nullptr;
}
gint layout_list_get_index(LayoutWindow *lw, FileData *fd)
GList *layout_selection_list(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
- if (layout_image_get_collection(lw, NULL))
+ if (layout_image_get_collection(lw, nullptr))
{
FileData *fd;
fd = layout_image_get_fd(lw);
- if (fd) return g_list_append(NULL, file_data_ref(fd));
- return NULL;
+ if (fd) return g_list_append(nullptr, file_data_ref(fd));
+ return nullptr;
}
if (lw->vf) return vf_selection_get_list(lw->vf);
- return NULL;
+ return nullptr;
}
GList *layout_selection_list_by_index(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
+ if (!layout_valid(&lw)) return nullptr;
if (lw->vf) return vf_selection_get_list_by_index(lw->vf);
- return NULL;
+ return nullptr;
}
guint layout_selection_count(LayoutWindow *lw, gint64 *bytes)
if (lw->vf) vf_selection_to_mark(lw->vf, mark, mode);
- layout_status_update_info(lw, NULL); /* osd in fullscreen mode */
+ layout_status_update_info(lw, nullptr); /* osd in fullscreen mode */
}
void layout_mark_filter_toggle(LayoutWindow *lw, gint mark)
const gchar *layout_get_path(LayoutWindow *lw)
{
- if (!layout_valid(&lw)) return NULL;
- return lw->dir_fd ? lw->dir_fd->path : NULL;
+ if (!layout_valid(&lw)) return nullptr;
+ return lw->dir_fd ? lw->dir_fd->path : nullptr;
}
static void layout_sync_path(LayoutWindow *lw)
}
if (options->metadata.confirm_on_dir_change && dir_changed)
- metadata_write_queue_confirm(FALSE, NULL, NULL);
+ metadata_write_queue_confirm(FALSE, nullptr, nullptr);
if (lw->vf && (options->read_metadata_in_idle || (lw->sort_method == SORT_EXIFTIME || lw->sort_method == SORT_EXIFTIMEDIGITIZED || lw->sort_method == SORT_RATING)))
{
lw->options.dir_view_type = dir_view_type;
lw->options.file_view_type = file_view_type;
- layout_style_set(lw, -1, NULL);
+ layout_style_set(lw, -1, nullptr);
}
void layout_views_set_sort(LayoutWindow *lw, SortType method, gboolean ascend)
lw->options.dir_view_list_sort.method = method;
lw->options.dir_view_list_sort.ascend = ascend;
- layout_style_set(lw, -1, NULL);
+ layout_style_set(lw, -1, nullptr);
}
//gboolean layout_views_get(LayoutWindow *lw, DirViewType *dir_view_type, FileViewType *file_view_type)
GdkGeometry geometry;
GdkWindowHints hints;
- lw->tools = window_new(GTK_WINDOW_TOPLEVEL, "tools", PIXBUF_INLINE_ICON_TOOLS, NULL, _("Tools"));
+ lw->tools = window_new(GTK_WINDOW_TOPLEVEL, "tools", PIXBUF_INLINE_ICON_TOOLS, nullptr, _("Tools"));
DEBUG_NAME(lw->tools);
g_signal_connect(G_OBJECT(lw->tools), "delete_event",
G_CALLBACK(layout_tools_delete_cb), lw);
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = TOOLWINDOW_DEF_WIDTH;
geometry.base_height = TOOLWINDOW_DEF_HEIGHT;
- gtk_window_set_geometry_hints(GTK_WINDOW(lw->tools), NULL, &geometry,
+ gtk_window_set_geometry_hints(GTK_WINDOW(lw->tools), nullptr, &geometry,
static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | hints));
{
layout_tools_geometry_sync(lw);
gtk_widget_destroy(lw->tools);
- lw->tools = NULL;
- lw->tools_pane = NULL;
+ lw->tools = nullptr;
+ lw->tools_pane = nullptr;
}
layout_status_setup(lw, lw->group_box, FALSE);
dir_fd = lw->dir_fd;
if (dir_fd) file_data_unregister_real_time_monitor(dir_fd);
- lw->dir_fd = NULL;
+ lw->dir_fd = nullptr;
layout_geometry_get_dividers(lw, &lw->options.main_window.hdivider_pos, &lw->options.main_window.vdivider_pos);
/* clear it all */
- lw->h_pane = NULL;
- lw->v_pane = NULL;
+ lw->h_pane = nullptr;
+ lw->v_pane = nullptr;
- lw->path_entry = NULL;
- lw->dir_view = NULL;
- lw->vd = NULL;
+ lw->path_entry = nullptr;
+ lw->dir_view = nullptr;
+ lw->vd = nullptr;
- lw->file_view = NULL;
- lw->vf = NULL;
+ lw->file_view = nullptr;
+ lw->vf = nullptr;
- lw->info_box = NULL;
- lw->info_progress_bar = NULL;
- lw->info_sort = NULL;
- lw->info_status = NULL;
- lw->info_details = NULL;
- lw->info_pixel = NULL;
- lw->info_zoom = NULL;
+ lw->info_box = nullptr;
+ lw->info_progress_bar = nullptr;
+ lw->info_sort = nullptr;
+ lw->info_status = nullptr;
+ lw->info_details = nullptr;
+ lw->info_pixel = nullptr;
+ lw->info_zoom = nullptr;
/*
if (lw->ui_manager) g_object_unref(lw->ui_manager);
*/
gtk_container_remove(GTK_CONTAINER(lw->main_box), lw->group_box);
- lw->group_box = NULL;
+ lw->group_box = nullptr;
/* re-fill */
lw->options.tools_float = popped;
lw->options.tools_hidden = hidden;
- layout_style_set(lw, -1, NULL);
+ layout_style_set(lw, -1, nullptr);
}
gboolean layout_tools_float_get(LayoutWindow *lw, gboolean *popped, gboolean *hidden)
layout_sync_options_with_current_state(lw);
copy_layout_options(&lc->options, &lw->options);
- lc->configwindow = window_new(GTK_WINDOW_TOPLEVEL, "Layout", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Window options and layout"));
+ lc->configwindow = window_new(GTK_WINDOW_TOPLEVEL, "Layout", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Window options and layout"));
DEBUG_NAME(lc->configwindow);
gtk_window_set_type_hint(GTK_WINDOW(lc->configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
- button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_OK, nullptr, FALSE,
G_CALLBACK(layout_config_ok_cb), lc);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
*/
- button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
G_CALLBACK(layout_config_help_cb), lc);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_APPLY, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_APPLY, nullptr, FALSE,
G_CALLBACK(layout_config_apply_cb), lc);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_CANCEL, nullptr, FALSE,
G_CALLBACK(layout_config_close_cb), lc);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_box_reorder_child(GTK_BOX(hbox), ct_button, -1);
}
- frame = pref_frame_new(win_vbox, TRUE, NULL, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
+ frame = pref_frame_new(win_vbox, TRUE, nullptr, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
DEBUG_NAME(frame);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
pref_label_new(group, _("Home path (empty to use your home directory)"));
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
- tabcomp = tab_completion_new(&lc->home_path_entry, lc->options.home_path, NULL, NULL, NULL, NULL);
- tab_completion_add_select_button(lc->home_path_entry, NULL, TRUE);
+ tabcomp = tab_completion_new(&lc->home_path_entry, lc->options.home_path, nullptr, nullptr, nullptr, nullptr);
+ tab_completion_add_select_button(lc->home_path_entry, nullptr, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
- button = pref_button_new(hbox, NULL, _("Use current"), FALSE,
+ button = pref_button_new(hbox, nullptr, _("Use current"), FALSE,
G_CALLBACK(home_path_set_current_cb), lc);
pref_checkbox_new_int(group, _("Show date in directories list view"),
group = pref_group_new(vbox, FALSE, _("Start-up directory:"), GTK_ORIENTATION_VERTICAL);
- button = pref_radiobutton_new(group, NULL, _("No change"),
+ button = pref_radiobutton_new(group, nullptr, _("No change"),
(lc->options.startup_path == STARTUP_PATH_CURRENT),
G_CALLBACK(startup_path_set_current_cb), lc);
button = pref_radiobutton_new(group, button, _("Restore last path"),
if (!lw) return;
layout_window_list = g_list_remove(layout_window_list, lw);
- if (current_lw == lw) current_lw = NULL;
+ if (current_lw == lw) current_lw = nullptr;
- if (lw->exif_window) g_signal_handlers_disconnect_matched(G_OBJECT(lw->exif_window), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, lw);
+ if (lw->exif_window) g_signal_handlers_disconnect_matched(G_OBJECT(lw->exif_window), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, lw);
layout_bars_close(lw);
LayoutWindow *layout_new(FileData *dir_fd, LayoutOptions *lop)
{
- return layout_new_with_geometry(dir_fd, lop, NULL);
+ return layout_new_with_geometry(dir_fd, lop, nullptr);
}
gboolean release_cb(GtkWidget *widget, GdkEventButton *event, gpointer data)
/* window */
- lw->window = window_new(GTK_WINDOW_TOPLEVEL, GQ_APPNAME_LC, NULL, NULL, NULL);
+ lw->window = window_new(GTK_WINDOW_TOPLEVEL, GQ_APPNAME_LC, nullptr, nullptr, nullptr);
DEBUG_NAME(lw->window);
gtk_window_set_resizable(GTK_WINDOW(lw->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(lw->window), 0);
hint.min_height = 32;
hint.base_width = 0;
hint.base_height = 0;
- gtk_window_set_geometry_hints(GTK_WINDOW(lw->window), NULL, &hint,
+ gtk_window_set_geometry_hints(GTK_WINDOW(lw->window), nullptr, &hint,
static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | hint_mask));
if (options->save_window_positions || isfile(default_path))
void layout_load_attributes(LayoutOptions *layout, const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *id = NULL;
+ gchar *id = nullptr;
while (*attribute_names)
{
if (command_line->startup_blank)
{
- *path = NULL;
+ *path = nullptr;
}
else if (command_line->file)
{
{
LayoutOptions lop;
LayoutWindow *lw;
- gchar *path = NULL;
+ gchar *path = nullptr;
init_layout_options(&lop);
layout_config_startup_path(&lop, &path);
}
- lw = layout_new_with_geometry(NULL, &lop, use_commandline ? command_line->geometry : NULL);
+ lw = layout_new_with_geometry(nullptr, &lop, use_commandline ? command_line->geometry : nullptr);
layout_sort_set(lw, options->file_sort.method, options->file_sort.ascending);
layout_set_path(lw, path);
}
else
{
- lw = layout_new_from_config(NULL, NULL, TRUE);
+ lw = layout_new_from_config(nullptr, nullptr, TRUE);
}
return lw;
}
LOGWINDOW_SEARCH_FORWARDS
} LogWindowSearchDirection;
-static LogWindow *logwindow = NULL;
+static LogWindow *logwindow = nullptr;
static void hide_cb(GtkWidget *UNUSED(widget), LogWindow *UNUSED(logwin))
{
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
gtk_text_buffer_get_start_iter(buffer, &start_find);
- while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
+ while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
{
list = gtk_text_iter_get_tags(&start_match);
while (list)
{
gtk_text_buffer_get_start_iter(buffer, &start_find);
- while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
+ while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
{
gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
offset = gtk_text_iter_get_offset(&end_match);
cursor_mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &cursor_iter, cursor_mark);
- if (gtk_text_iter_forward_search(&cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
+ if (gtk_text_iter_forward_search(&cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
{
gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
}
if (logwin->highlight_all)
{
- while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL))
+ while (gtk_text_iter_forward_search(&start_find, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr))
{
gtk_text_buffer_apply_tag_by_name(buffer, "gray_bg", &start_match, &end_match);
offset = gtk_text_iter_get_offset(&end_match);
if (direction == LOGWINDOW_SEARCH_BACKWARDS)
{
- match_found = gtk_text_iter_backward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL);
+ match_found = gtk_text_iter_backward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr);
}
else
{
- match_found = gtk_text_iter_forward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, NULL);
+ match_found = gtk_text_iter_forward_search( &cursor_iter, text, GTK_TEXT_SEARCH_VISIBLE_ONLY, &start_match, &end_match, nullptr);
}
if (match_found)
GtkWidget *win_vbox;
GtkWidget *textbox;
GtkWidget *hbox;
- GtkWidget *label = NULL;
+ GtkWidget *label = nullptr;
GtkWidget *search_box;
GtkWidget *backwards_button;
GtkWidget *forwards_button;
GtkWidget *all_button;
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
- GtkWidget *image = NULL;
+ GtkWidget *image = nullptr;
logwin = g_new0(LogWindow, 1);
- window = window_new(GTK_WINDOW_TOPLEVEL, "log", NULL, NULL, _("Log"));
+ window = window_new(GTK_WINDOW_TOPLEVEL, "log", nullptr, nullptr, _("Log"));
DEBUG_NAME(window);
win_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(window), win_vbox);
G_CALLBACK(hide_cb), logwin);
gtk_widget_realize(window);
- scrolledwin = gtk_scrolled_window_new(NULL, NULL);
+ scrolledwin = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
hbox = pref_box_new(win_vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
gtk_widget_show(hbox);
- logwin->debug_level = pref_spin_new_int(hbox, _("Debug level:"), NULL, 0, 4, 1, get_debug_level(), &logwin->debug_value);
+ logwin->debug_level = pref_spin_new_int(hbox, _("Debug level:"), nullptr, 0, 4, 1, get_debug_level(), &logwin->debug_value);
g_signal_connect(logwin->debug_level, "value-changed", G_CALLBACK(debug_changed_cb), logwin);
logwin->pause = gtk_toggle_button_new();
g_signal_connect(logwin->search_entry_box, "activate", G_CALLBACK(search_activate_event), logwin);
theme = gtk_icon_theme_get_default();
- pixbuf = gtk_icon_theme_load_icon(theme, "pan-up-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+ pixbuf = gtk_icon_theme_load_icon(theme, "pan-up-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
image = gtk_image_new_from_pixbuf(pixbuf);
backwards_button = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(backwards_button), GTK_WIDGET(image));
g_signal_connect(backwards_button, "button_release_event", G_CALLBACK(backwards_keypress_event_cb), logwin);
g_object_unref(pixbuf);
- pixbuf = gtk_icon_theme_load_icon(theme, "pan-down-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+ pixbuf = gtk_icon_theme_load_icon(theme, "pan-down-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
image = gtk_image_new_from_pixbuf(pixbuf);
forwards_button = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(forwards_button), GTK_WIDGET(image));
g_signal_connect(forwards_button, "button_release_event", G_CALLBACK(forwards_keypress_event_cb), logwin);
g_object_unref(pixbuf);
- pixbuf = gtk_icon_theme_load_icon(theme, "edit-select-all-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+ pixbuf = gtk_icon_theme_load_icon(theme, "edit-select-all-symbolic", 20, GTK_ICON_LOOKUP_GENERIC_FALLBACK, nullptr);
image = gtk_image_new_from_pixbuf(pixbuf);
all_button = gtk_toggle_button_new();
gtk_button_set_image(GTK_BUTTON(all_button), GTK_WIDGET(image));
{
GtkTextBuffer *buffer;
- g_assert(logwin != NULL);
+ g_assert(logwin != nullptr);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(logwin->text));
log_window_append("", LOG_NORMAL); // to flush memorized lines
regexp = g_strdup(get_regexp());
- if (regexp != NULL)
+ if (regexp != nullptr)
{
gtk_entry_set_text(GTK_ENTRY(logwin->regexp_box), regexp);
g_free(regexp);
void log_window_new(LayoutWindow *lw)
{
- if (logwindow == NULL)
+ if (logwindow == nullptr)
{
LogWindow *logwin;
GtkTextView *text;
GtkTextBuffer *buffer;
GtkTextIter iter;
- static GList *memory = NULL;
+ static GList *memory = nullptr;
- if (logwindow == NULL)
+ if (logwindow == nullptr)
{
if (*str) {
auto msg = g_new(LogMsg, 1);
#endif
gboolean thumb_format_changed = FALSE;
-static RemoteConnection *remote_connection = NULL;
+static RemoteConnection *remote_connection = nullptr;
gchar *gq_prefix;
gchar *gq_localedir;
void sig_handler_cb(int signo, siginfo_t *info, void *UNUSED(context))
{
gchar hex_char[16];
- const gchar *signal_name = NULL;
+ const gchar *signal_name = nullptr;
gint i = 0;
guint64 addr;
guint64 char_index;
len = write(STDERR_FILENO, "Address: ", 9);
- if (info->si_addr == 0)
+ if (info->si_addr == nullptr)
{
len = write(STDERR_FILENO, "0x0\n", 4);
}
{
parse_command_line_add_dir(*first_dir, path, file, list);
g_free(*first_dir);
- *first_dir = NULL;
+ *first_dir = nullptr;
}
parse_command_line_add_dir(dir, path, file, list);
}
{
parse_command_line_add_dir(*first_dir, path, file, list);
g_free(*first_dir);
- *first_dir = NULL;
+ *first_dir = nullptr;
}
parse_command_line_add_file(file_path, path, file, list, collection_list);
}
static void parse_command_line(gint argc, gchar *argv[])
{
- GList *list = NULL;
- GList *remote_list = NULL;
- GList *remote_errors = NULL;
+ GList *list = nullptr;
+ GList *remote_list = nullptr;
+ GList *remote_errors = nullptr;
gboolean remote_do = FALSE;
- gchar *first_dir = NULL;
+ gchar *first_dir = nullptr;
gchar *app_lock;
gchar *pwd;
gchar *current_dir;
- gchar *geometry = NULL;
+ gchar *geometry = nullptr;
GtkWidget *dialog_warning;
- GString *command_line_errors = g_string_new(NULL);
+ GString *command_line_errors = g_string_new(nullptr);
command_line = g_new0(CommandLine, 1);
command_line->argc = argc;
command_line->argv = argv;
- command_line->regexp = NULL;
+ command_line->regexp = nullptr;
if (argc > 1)
{
parse_command_line_process_file(cmd_all, &command_line->path, &command_line->file,
&list, &command_line->collection_list, &first_dir);
}
- else if (download_web_file(cmd_line, FALSE, NULL))
+ else if (download_web_file(cmd_line, FALSE, nullptr))
{
}
else if (is_collection(cmd_line))
{
- gchar *path = NULL;
+ gchar *path = nullptr;
path = collection_path(cmd_line);
parse_command_line_process_file(path, &command_line->path, &command_line->file,
if (command_line_errors->len > 0)
{
- dialog_warning = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", "Invalid parameter(s):");
+ dialog_warning = gtk_message_dialog_new(nullptr, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", "Invalid parameter(s):");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog_warning), "%s", command_line_errors->str);
gtk_window_set_title(GTK_WINDOW(dialog_warning), GQ_APPNAME);
gtk_window_set_keep_above(GTK_WINDOW(dialog_warning), TRUE);
if (!command_line->path && first_dir)
{
command_line->path = first_dir;
- first_dir = NULL;
+ first_dir = nullptr;
parse_out_relatives(command_line->path);
}
work = work->next;
}
- dialog_warning = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", "Invalid parameter(s):");
+ dialog_warning = gtk_message_dialog_new(nullptr, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", "Invalid parameter(s):");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog_warning), "%s", command_line_errors->str);
gtk_window_set_title(GTK_WINDOW(dialog_warning), GQ_APPNAME);
gtk_window_set_keep_above(GTK_WINDOW(dialog_warning), TRUE);
else
{
string_list_free(list);
- command_line->cmd_list = NULL;
+ command_line->cmd_list = nullptr;
}
if (command_line->startup_blank)
{
g_free(command_line->path);
- command_line->path = NULL;
+ command_line->path = nullptr;
g_free(command_line->file);
- command_line->file = NULL;
+ command_line->file = nullptr;
filelist_free(command_line->cmd_list);
- command_line->cmd_list = NULL;
+ command_line->cmd_list = nullptr;
string_list_free(command_line->collection_list);
- command_line->collection_list = NULL;
+ command_line->collection_list = nullptr;
}
}
static void process_command_line_for_cache_maintenance_option(gint argc, gchar *argv[])
{
gchar *rc_path;
- gchar *folder_path = NULL;
+ gchar *folder_path = nullptr;
gsize size;
gsize i = 0;
gchar *buf_config_file;
if (isfile(rc_path))
{
- if (g_file_get_contents(rc_path, &buf_config_file, &size, NULL))
+ if (g_file_get_contents(rc_path, &buf_config_file, &size, nullptr))
{
while (i < size)
{
GdkModifierType accel_mods,
gboolean changed)
{
- GString *gstring = g_string_new(changed ? NULL : "; ");
+ GString *gstring = g_string_new(changed ? nullptr : "; ");
auto ssi = static_cast<SecureSaveInfo *>(data);
gchar *tmp, *name;
g_string_append(gstring, "(gtk_accel_path \"");
- tmp = g_strescape(accel_path, NULL);
+ tmp = g_strescape(accel_path, nullptr);
g_string_append(gstring, tmp);
g_free(tmp);
g_string_append(gstring, "\" \"");
name = gtk_accelerator_name(accel_key, accel_mods);
- tmp = g_strescape(name, NULL);
+ tmp = g_strescape(name, nullptr);
g_free(name);
g_string_append(gstring, tmp);
g_free(tmp);
static void exit_program_final(void)
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
GList *list;
LayoutWindow *tmp_lw;
gchar *archive_dir;
if (isdir(archive_dir))
{
archive_file = g_file_new_for_path(archive_dir);
- rmdir_recursive(archive_file, NULL, NULL);
+ rmdir_recursive(archive_file, nullptr, nullptr);
g_free(archive_dir);
g_object_unref(archive_file);
}
if (isdir(archive_dir))
{
archive_file = g_file_new_for_path(archive_dir);
- g_file_delete(archive_file, NULL, NULL);
+ g_file_delete(archive_file, nullptr, nullptr);
g_free(archive_dir);
g_object_unref(archive_file);
}
gtk_main_quit();
}
-static GenericDialog *exit_dialog = NULL;
+static GenericDialog *exit_dialog = nullptr;
static void exit_confirm_cancel_cb(GenericDialog *gd, gpointer UNUSED(data))
{
- exit_dialog = NULL;
+ exit_dialog = nullptr;
generic_dialog_close(gd);
}
static void exit_confirm_exit_cb(GenericDialog *gd, gpointer UNUSED(data))
{
- exit_dialog = NULL;
+ exit_dialog = nullptr;
generic_dialog_close(gd);
exit_program_final();
}
if (!collection_window_modified_exists()) return FALSE;
- parent = NULL;
- lw = NULL;
+ parent = nullptr;
+ lw = nullptr;
if (layout_valid(&lw))
{
parent = lw->window;
msg = g_strdup_printf("%s - %s", GQ_APPNAME, _("exit"));
exit_dialog = generic_dialog_new(msg,
"exit", parent, FALSE,
- exit_confirm_cancel_cb, NULL);
+ exit_confirm_cancel_cb, nullptr);
g_free(msg);
msg = g_strdup_printf(_("Quit %s"), GQ_APPNAME);
generic_dialog_add_message(exit_dialog, GTK_STOCK_DIALOG_QUESTION,
msg, _("Collections have been modified. Quit anyway?"), TRUE);
g_free(msg);
- generic_dialog_add_button(exit_dialog, GTK_STOCK_QUIT, NULL, exit_confirm_exit_cb, TRUE);
+ generic_dialog_add_button(exit_dialog, GTK_STOCK_QUIT, nullptr, exit_confirm_exit_cb, TRUE);
gtk_widget_show(exit_dialog->dialog);
void exit_program(void)
{
- layout_image_full_screen_stop(NULL);
+ layout_image_full_screen_stop(nullptr);
- if (metadata_write_queue_confirm(FALSE, exit_program_write_metadata_cb, NULL)) return;
+ if (metadata_write_queue_confirm(FALSE, exit_program_write_metadata_cb, nullptr)) return;
options->marks_save ? marks_save(TRUE) : marks_save(FALSE);
sigsegv_action.sa_sigaction = sig_handler_cb;
sigsegv_action.sa_flags = SA_SIGINFO;
- sigaction(SIGABRT, &sigsegv_action, NULL);
- sigaction(SIGBUS, &sigsegv_action, NULL);
- sigaction(SIGFPE, &sigsegv_action, NULL);
- sigaction(SIGILL, &sigsegv_action, NULL);
- sigaction(SIGIOT, &sigsegv_action, NULL);
- sigaction(SIGSEGV, &sigsegv_action, NULL);
+ sigaction(SIGABRT, &sigsegv_action, nullptr);
+ sigaction(SIGBUS, &sigsegv_action, nullptr);
+ sigaction(SIGFPE, &sigsegv_action, nullptr);
+ sigaction(SIGILL, &sigsegv_action, nullptr);
+ sigaction(SIGIOT, &sigsegv_action, nullptr);
+ sigaction(SIGSEGV, &sigsegv_action, nullptr);
}
static void set_theme_bg_color()
gint length;
gchar *path;
- length = wai_getExecutablePath(NULL, 0, NULL);
+ length = wai_getExecutablePath(nullptr, 0, nullptr);
path = static_cast<gchar *>(malloc(length + 1));
- wai_getExecutablePath(path, length, NULL);
+ wai_getExecutablePath(path, length, nullptr);
path[length] = '\0';
gq_executable_path = g_strdup(path);
gint main(gint argc, gchar *argv[])
{
- CollectionData *first_collection = NULL;
+ CollectionData *first_collection = nullptr;
gchar *buf;
- CollectionData *cd = NULL;
+ CollectionData *cd = nullptr;
gboolean disable_clutter = FALSE;
gboolean single_dir = TRUE;
LayoutWindow *lw;
#endif
/* setup random seed for random slideshow */
- srand(time(NULL));
+ srand(time(nullptr));
#if 0
/* See later comment; this handler leads to UB. */
#endif
/* register global notify functions */
- file_data_register_notify_func(cache_notify_cb, NULL, NOTIFY_PRIORITY_HIGH);
- file_data_register_notify_func(thumb_notify_cb, NULL, NOTIFY_PRIORITY_HIGH);
- file_data_register_notify_func(histogram_notify_cb, NULL, NOTIFY_PRIORITY_HIGH);
- file_data_register_notify_func(collect_manager_notify_cb, NULL, NOTIFY_PRIORITY_LOW);
- file_data_register_notify_func(metadata_notify_cb, NULL, NOTIFY_PRIORITY_LOW);
+ file_data_register_notify_func(cache_notify_cb, nullptr, NOTIFY_PRIORITY_HIGH);
+ file_data_register_notify_func(thumb_notify_cb, nullptr, NOTIFY_PRIORITY_HIGH);
+ file_data_register_notify_func(histogram_notify_cb, nullptr, NOTIFY_PRIORITY_HIGH);
+ file_data_register_notify_func(collect_manager_notify_cb, nullptr, NOTIFY_PRIORITY_LOW);
+ file_data_register_notify_func(metadata_notify_cb, nullptr, NOTIFY_PRIORITY_LOW);
gtkrc_load();
pixbuf_inline_register_stock_icons();
DEBUG_1("%s main: setting default options before commandline handling", get_exec_time());
- options = init_options(NULL);
+ options = init_options(nullptr);
setup_default_options(options);
if (disable_clutter)
{
if (command_line->cmd_list && !(command_line->startup_command_line_collection))
{
GList *work;
- gchar *path = NULL;
+ gchar *path = nullptr;
work = command_line->cmd_list;
GList *work;
CollectWindow *cw;
- cw = collection_window_new(NULL);
+ cw = collection_window_new(nullptr);
cd = cw->cd;
collection_path_changed(cd);
work = work->next;
}
- if (cd->list) layout_image_set_collection(NULL, cd, static_cast<CollectInfo *>(cd->list->data));
+ if (cd->list) layout_image_set_collection(nullptr, cd, static_cast<CollectInfo *>(cd->list->data));
/* mem leak, we never unref this collection when !startup_command_line_collection
* (the image view of the main window does not hold a ref to the collection)
}
else if (first_collection)
{
- layout_image_set_collection(NULL, first_collection,
+ layout_image_set_collection(nullptr, first_collection,
collection_get_first(first_collection));
}
/* If the files on the command line are from one folder, select those files
* unless it is a command line collection - then leave focus on collection window
*/
- lw = NULL;
+ lw = nullptr;
layout_valid(&lw);
if (single_dir && command_line->cmd_list && !command_line->startup_command_line_collection)
GList *selected;
FileData *fd;
- selected = NULL;
+ selected = nullptr;
work = command_line->cmd_list;
while (work)
{
gpointer submenu_item_get_data(GtkWidget *menu)
{
- if (!gtk_widget_get_parent(menu) || !GTK_IS_MENU(gtk_widget_get_parent(menu))) return NULL;
+ if (!gtk_widget_get_parent(menu) || !GTK_IS_MENU(gtk_widget_get_parent(menu))) return nullptr;
return g_object_get_data(G_OBJECT(gtk_widget_get_parent(menu)), "submenu_data");
}
work = work->next;
gboolean active = TRUE;
- if (fd_list && EDITOR_ERRORS(editor_command_parse(editor, fd_list, FALSE, NULL)))
+ if (fd_list && EDITOR_ERRORS(editor_command_parse(editor, fd_list, FALSE, nullptr)))
active = FALSE;
if (active)
{
GtkWidget *item;
- const gchar *stock_id = NULL;
+ const gchar *stock_id = nullptr;
gchar *key = g_strdup(editor->key);
if (editor->icon && register_theme_icon_as_stock(key, editor->icon))
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
- item = menu_item_add(menu, _("_Plugins"), NULL, NULL);
+ item = menu_item_add(menu, _("_Plugins"), nullptr, nullptr);
submenu = gtk_menu_new();
g_object_set_data(G_OBJECT(submenu), "submenu_data", data);
{
GtkWidget *item;
- item = menu_item_add(menu, _("Sort"), NULL, NULL);
+ item = menu_item_add(menu, _("Sort"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
return item;
}
{
GtkWidget *item;
- item = menu_item_add(menu, _("Sort"), NULL, NULL);
+ item = menu_item_add(menu, _("Sort"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
return item;
}
{
GtkWidget *item;
- item = menu_item_add(menu, _("Zoom"), NULL, NULL);
+ item = menu_item_add(menu, _("Zoom"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
return item;
}
{
GtkWidget *item;
- item = menu_item_add(menu, _("_Orientation"), NULL, NULL);
+ item = menu_item_add(menu, _("_Orientation"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
return item;
}
{
GtkWidget *item;
GtkWidget *submenu;
- GList *collection_list = NULL;
+ GList *collection_list = nullptr;
- item = menu_item_add(menu, _("_Add to Collection"), NULL, NULL);
+ item = menu_item_add(menu, _("_Add to Collection"), nullptr, nullptr);
submenu = gtk_menu_new();
g_object_set_data(G_OBJECT(submenu), "submenu_data", data);
GTK_STOCK_INDEX, TRUE, G_CALLBACK(func), GINT_TO_POINTER(-1));
menu_item_add_divider(submenu);
- collect_manager_list(&collection_list,NULL,NULL);
+ collect_manager_list(&collection_list,nullptr,nullptr);
add_collection_list(submenu, func, collection_list, data);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
{
CollectWindow *cw;
gchar *collection_name;
- GList *collection_list = NULL;
+ GList *collection_list = nullptr;
gchar *name;
const gint index = GPOINTER_TO_INT(data);
if (index >= 0)
{
- collect_manager_list(&collection_list, NULL, NULL);
+ collect_manager_list(&collection_list, nullptr, nullptr);
collection_name = static_cast<gchar *>(g_list_nth_data(collection_list, index));
name = collection_path(collection_name);
cw = collection_window_new(name);
}
else
{
- cw = collection_window_new(NULL);
+ cw = collection_window_new(nullptr);
}
collection_table_add_filelist(cw->table, selection_list);
"Xmp.dc.rights",
"Xmp.dc.description",
"Xmp.photoshop.CaptionWriter",
- NULL};
+ nullptr};
static gboolean metadata_write_queue_idle_cb(gpointer data);
static gboolean metadata_legacy_write(FileData *fd);
{
/* key found - just replace values */
GList *old_values = entry->next;
- entry->next = NULL;
- old_values->prev = NULL;
+ entry->next = nullptr;
+ old_values->prev = nullptr;
string_list_free(old_values);
work->data = g_list_append(entry, string_list_copy(values));
DEBUG_1("updated %s %s\n", key, fd->path);
}
work = work->next;
}
- return NULL;
+ return nullptr;
DEBUG_1("not found %s %s\n", key, fd->path);
}
work = work->next;
}
g_list_free(fd->cached_metadata);
- fd->cached_metadata = NULL;
+ fd->cached_metadata = nullptr;
}
*-------------------------------------------------------------------
*/
-static GList *metadata_write_queue = NULL;
+static GList *metadata_write_queue = nullptr;
static guint metadata_write_idle_id = 0; /* event source id */
static void metadata_write_queue_add(FileData *fd)
if (options->metadata.confirm_after_timeout)
{
- metadata_write_idle_id = g_timeout_add(options->metadata.confirm_timeout * 1000, metadata_write_queue_idle_cb, NULL);
+ metadata_write_idle_id = g_timeout_add(options->metadata.confirm_timeout * 1000, metadata_write_queue_idle_cb, nullptr);
}
}
gboolean metadata_write_queue_remove(FileData *fd)
{
g_hash_table_destroy(fd->modified_xmp);
- fd->modified_xmp = NULL;
+ fd->modified_xmp = nullptr;
metadata_write_queue = g_list_remove(metadata_write_queue, fd);
gboolean metadata_write_queue_confirm(gboolean force_dialog, FileUtilDoneFunc done_func, gpointer done_data)
{
GList *work;
- GList *to_approve = NULL;
+ GList *to_approve = nullptr;
work = metadata_write_queue;
while (work)
to_approve = g_list_prepend(to_approve, file_data_ref(fd));
}
- file_util_write_metadata(NULL, to_approve, NULL, force_dialog, done_func, done_data);
+ file_util_write_metadata(nullptr, to_approve, nullptr, force_dialog, done_func, done_data);
- return (metadata_write_queue != NULL);
+ return (metadata_write_queue != nullptr);
}
static gboolean metadata_write_queue_idle_cb(gpointer UNUSED(data))
{
- metadata_write_queue_confirm(FALSE, NULL, NULL);
+ metadata_write_queue_confirm(FALSE, nullptr, nullptr);
metadata_write_idle_id = 0;
return FALSE;
}
gboolean metadata_write_string(FileData *fd, const gchar *key, const char *value)
{
- GList *list = g_list_append(NULL, g_strdup(value));
+ GList *list = g_list_append(nullptr, g_strdup(value));
gboolean ret = metadata_write_list(fd, key, list);
string_list_free(list);
return ret;
gboolean have_keywords;
gboolean have_comment;
const gchar *comment;
- GList *orig_keywords = NULL;
- gchar *orig_comment = NULL;
+ GList *orig_keywords = nullptr;
+ gchar *orig_comment = nullptr;
g_assert(fd->change && fd->change->dest);
metadata_pathl = path_from_utf8(fd->change->dest);
- have_keywords = g_hash_table_lookup_extended(fd->modified_xmp, KEYWORD_KEY, NULL, &keywords);
- have_comment = g_hash_table_lookup_extended(fd->modified_xmp, COMMENT_KEY, NULL, &comment_l);
- comment = static_cast<const gchar *>((have_comment && comment_l) ? (static_cast<GList *>(comment_l))->data : NULL);
+ have_keywords = g_hash_table_lookup_extended(fd->modified_xmp, KEYWORD_KEY, nullptr, &keywords);
+ have_comment = g_hash_table_lookup_extended(fd->modified_xmp, COMMENT_KEY, nullptr, &comment_l);
+ comment = static_cast<const gchar *>((have_comment && comment_l) ? (static_cast<GList *>(comment_l))->data : nullptr);
if (!have_keywords || !have_comment) metadata_file_read(metadata_pathl, &orig_keywords, &orig_comment);
FILE *f;
gchar s_buf[1024];
MetadataKey key = MK_NONE;
- GList *list = NULL;
- GString *comment_build = NULL;
+ GList *list = nullptr;
+ GString *comment_build = nullptr;
f = fopen(path, "r");
if (!f) return FALSE;
{
GList *work = list;
GHashTable *hashtable = g_hash_table_new(g_str_hash, g_str_equal);
- GList *newlist = NULL;
+ GList *newlist = nullptr;
while (work)
{
auto key = static_cast<gchar *>(work->data);
- if (g_hash_table_lookup(hashtable, key) == NULL)
+ if (g_hash_table_lookup(hashtable, key) == nullptr)
{
g_hash_table_insert(hashtable, key, GINT_TO_POINTER(1));
newlist = g_list_prepend(newlist, key);
GList *metadata_read_list(FileData *fd, const gchar *key, MetadataFormat format)
{
ExifData *exif;
- GList *list = NULL;
+ GList *list = nullptr;
const GList *cache_entry;
- if (!fd) return NULL;
+ if (!fd) return nullptr;
/* unwritten data override everything */
if (fd->modified_xmp && format == METADATA_PLAIN)
*/
if (strcmp(key, KEYWORD_KEY) == 0)
{
- if (metadata_legacy_read(fd, &list, NULL))
+ if (metadata_legacy_read(fd, &list, nullptr))
{
if (format == METADATA_PLAIN)
{
}
else if (strcmp(key, COMMENT_KEY) == 0)
{
- gchar *comment = NULL;
- if (metadata_legacy_read(fd, NULL, &comment)) return g_list_append(NULL, comment);
+ gchar *comment = nullptr;
+ if (metadata_legacy_read(fd, nullptr, &comment)) return g_list_append(nullptr, comment);
}
else if (strncmp(key, "file.", 5) == 0)
{
- return g_list_append(NULL, metadata_file_info(fd, key, format));
+ return g_list_append(nullptr, metadata_file_info(fd, key, format));
}
#ifdef HAVE_LUA
else if (strncmp(key, "lua.", 4) == 0)
#endif
exif = exif_read_fd(fd); /* this is cached, thus inexpensive */
- if (!exif) return NULL;
+ if (!exif) return nullptr;
list = exif_get_metadata(exif, key, format);
exif_free_fd(fd, exif);
if (string_list)
{
auto str = static_cast<gchar *>(string_list->data);
- string_list->data = NULL;
+ string_list->data = nullptr;
string_list_free(string_list);
return str;
}
- return NULL;
+ return nullptr;
}
guint64 metadata_read_int(FileData *fd, const gchar *key, guint64 fallback)
if (ok)
{
/* Avoid locale problems with commas and decimal points in numbers */
- old_locale = setlocale(LC_ALL, NULL);
+ old_locale = setlocale(LC_ALL, nullptr);
saved_locale = strdup(old_locale);
- if (saved_locale == NULL)
+ if (saved_locale == nullptr)
{
return FALSE;
}
}
g_free(string_casefold);
- return NULL;
+ return nullptr;
}
/**
list = list->next;
} // while (list)
- return NULL;
+ return nullptr;
} // gchar *find_string_in_list_utf...
/**
GList *string_to_keywords_list(const gchar *text)
{
- GList *list = NULL;
+ GList *list = nullptr;
const gchar *ptr = text;
while (*ptr != '\0')
gboolean meta_data_set_keyword_mark(FileData *fd, gint UNUSED(n), gboolean value, gpointer data)
{
auto path = static_cast<GList *>(data);
- GList *keywords = NULL;
+ GList *keywords = nullptr;
GtkTreeIter iter;
if (!keyword_tree_get_iter(GTK_TREE_MODEL(keyword_tree), &iter, path)) return FALSE;
(i == mark || /* release any previous connection of given mark */
keyword_compare(keyword_tree, &old_kw_iter, kw_iter) == 0)) /* or given keyword */
{
- file_data_register_mark_func(i, NULL, NULL, NULL, NULL);
+ file_data_register_mark_func(i, nullptr, nullptr, nullptr, nullptr);
gtk_tree_store_set(GTK_TREE_STORE(keyword_tree), &old_kw_iter, KEYWORD_COLUMN_MARK, "", -1);
}
}
toplevel = TRUE;
}
- if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(keyword_tree), &iter, toplevel ? NULL : &parent)) return FALSE;
+ if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(keyword_tree), &iter, toplevel ? nullptr : &parent)) return FALSE;
casefold = g_utf8_casefold(name, -1);
ret = FALSE;
GList *keyword_tree_get_path(GtkTreeModel *keyword_tree, GtkTreeIter *iter_ptr)
{
- GList *path = NULL;
+ GList *path = nullptr;
GtkTreeIter iter = *iter_ptr;
while (TRUE)
gboolean keyword_tree_is_set(GtkTreeModel *keyword_tree, GtkTreeIter *iter, GList *kw_list)
{
gboolean ret;
- GList *casefold_list = NULL;
+ GList *casefold_list = nullptr;
GList *work;
if (options->metadata.keywords_case_sensitive)
GList *keyword_tree_get(GtkTreeModel *keyword_tree, GtkTreeIter *iter_ptr)
{
GtkTreeIter iter = *iter_ptr;
- GList *kw_list = NULL;
+ GList *kw_list = nullptr;
while (TRUE)
{
if (!keyword_tree) keyword_tree_new();
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("People"), TRUE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("People"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Family"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Free time"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Children"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Sport"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Culture"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Festival"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Nature"), TRUE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Nature"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Animal"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Bird"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Insect"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Lake"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Sea"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Landscape"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Art"), TRUE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Art"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Statue"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Painting"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Historic"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Modern"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("City"), TRUE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("City"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Park"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Street"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Square"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Architecture"), TRUE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Architecture"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Buildings"), FALSE);
keyword_tree_default_append(keyword_tree, &i2, _("House"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Cathedral"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Interior"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Historic"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Modern"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Places"), FALSE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Conditions"), FALSE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Places"), FALSE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Conditions"), FALSE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Night"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Lights"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Reflections"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Clouds"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Snow"), TRUE);
keyword_tree_default_append(keyword_tree, &i2, _("Sunny weather"), TRUE);
- i1 = keyword_tree_default_append(keyword_tree, NULL, _("Photo"), FALSE);
+ i1 = keyword_tree_default_append(keyword_tree, nullptr, _("Photo"), FALSE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Edited"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Detail"), TRUE);
i2 = keyword_tree_default_append(keyword_tree, &i1, _("Macro"), TRUE);
GtkTreeIter *keyword_add_from_config(GtkTreeStore *keyword_tree, GtkTreeIter *parent, const gchar **attribute_names, const gchar **attribute_values)
{
- gchar *name = NULL;
+ gchar *name = nullptr;
gboolean is_kw = TRUE;
- gchar *mark_str = NULL;
+ gchar *mark_str = nullptr;
while (*attribute_names)
{
{
GtkTreeIter iter;
/* re-use existing keyword if any */
- if (!keyword_exists(GTK_TREE_MODEL(keyword_tree), parent, NULL, name, FALSE, &iter))
+ if (!keyword_exists(GTK_TREE_MODEL(keyword_tree), parent, nullptr, name, FALSE, &iter))
{
gtk_tree_store_append(keyword_tree, &iter, parent);
}
return gtk_tree_iter_copy(&iter);
}
g_free(name);
- return NULL;
+ return nullptr;
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
{
gint len;
- if (!text) return NULL;
+ if (!text) return nullptr;
len = strlen(text);
- if (!g_utf8_validate(text, len, NULL))
- return g_convert(text, len, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
+ if (!g_utf8_validate(text, len, nullptr))
+ return g_convert(text, len, "UTF-8", "ISO-8859-1", nullptr, nullptr, nullptr);
return g_strdup(text);
}
gchar *s1_t, *s2_t;
gint ret;
- g_assert(g_utf8_validate(s1, -1, NULL));
- g_assert(g_utf8_validate(s2, -1, NULL));
+ g_assert(g_utf8_validate(s1, -1, nullptr));
+ g_assert(g_utf8_validate(s2, -1, nullptr));
if (!case_sensitive)
{
gchar buf[BUFSIZE];
FILE *fp;
- if ((fp = popen(cmd, "r")) == NULL)
+ if ((fp = popen(cmd, "r")) == nullptr)
{
message = g_strconcat("Error: opening pipe\n", input_text, NULL);
}
*/
gchar *date_get_abbreviated_day_name(gint day)
{
- gchar *abday = NULL;
+ gchar *abday = nullptr;
switch (day)
{
gchar *convert_rating_to_stars(gint rating)
{
gchar *ret;
- GString *str = g_string_new(NULL);
+ GString *str = g_string_new(nullptr);
if (rating == -1)
{
{
log_printf("%s%s%s", _("Open Archive - Cannot create directory: "), destination_dir, "\n");
g_free(destination_dir);
- return NULL;
+ return nullptr;
}
current_dir = g_get_current_dir();
log_printf("%s%s%s%s%s", _("Open Archive - Cannot change directory to: "), destination_dir, _("\n Error code: "), strerror(errno), "\n");
g_free(destination_dir);
g_free(current_dir);
- return NULL;
+ return nullptr;
}
flags = ARCHIVE_EXTRACT_TIME;
log_printf("%s%s%s%s%s", _("Open Archive - Cannot change directory to: "), current_dir, _("\n Error code: "), strerror(errno), "\n");
g_free(destination_dir);
g_free(current_dir);
- return NULL;
+ return nullptr;
}
g_free(current_dir);
if (!success)
{
g_free(destination_dir);
- destination_dir = NULL;
+ destination_dir = nullptr;
}
return destination_dir;
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
- if (filename != NULL && strcmp(filename, "-") == 0)
+ if (filename != nullptr && strcmp(filename, "-") == 0)
{
- filename = NULL;
+ filename = nullptr;
}
if ((r = archive_read_open_filename(a, filename, 10240)))
{
static void errmsg(const char *m)
{
- if (m == NULL)
+ if (m == nullptr)
{
m = "Error: No error description provided.\n";
}
options->color_profile.enabled = TRUE;
options->color_profile.input_type = 0;
- options->color_profile.screen_file = NULL;
+ options->color_profile.screen_file = nullptr;
options->color_profile.use_image = TRUE;
options->color_profile.use_x11_screen_profile = TRUE;
options->color_profile.render_intent = 0;
options->file_ops.enable_in_place_rename = TRUE;
options->file_ops.safe_delete_enable = TRUE;
options->file_ops.safe_delete_folder_maxsize = 128;
- options->file_ops.safe_delete_path = NULL;
+ options->file_ops.safe_delete_path = nullptr;
options->file_ops.no_trash = FALSE;
options->file_sort.ascending = TRUE;
options->image.zoom_style = ZOOM_GEOMETRIC;
options->image.tile_size = 128;
- options->image_overlay.template_string = NULL;
+ options->image_overlay.template_string = nullptr;
options->image_overlay.x = 10;
options->image_overlay.y = -10;
- options->image_overlay.font = NULL;
+ options->image_overlay.font = nullptr;
options->image_overlay.text_red = 0;
options->image_overlay.text_green = 0;
options->image_overlay.text_blue = 0;
options->image_lm_click_nav = TRUE;
options->image_l_click_archive = FALSE;
options->image_l_click_video = FALSE;
- options->image_l_click_video_editor = NULL;
+ options->image_l_click_video_editor = nullptr;
options->open_recent_list_maxsize = 10;
options->recent_folder_image_list_maxsize = 10;
options->place_dialogs_under_mouse = FALSE;
options->star_rating.star = STAR_RATING_STAR;
options->star_rating.rejected = STAR_RATING_REJECTED;
- options->printer.template_string = NULL;
+ options->printer.template_string = nullptr;
options->printer.image_font = g_strdup("Serif 10");
options->printer.page_font = g_strdup("Serif 10");
- options->printer.page_text = NULL;
+ options->printer.page_text = nullptr;
options->printer.image_text_position = 1;
options->printer.page_text_position = 3;
options->threads.duplicates = -1;
- options->disabled_plugins = NULL;
+ options->disabled_plugins = nullptr;
options->mouse_button_8 = g_strdup("Back");
options->mouse_button_9 = g_strdup("Forward");
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
- options->color_profile.input_file[i] = NULL;
- options->color_profile.input_name[i] = NULL;
+ options->color_profile.input_file[i] = nullptr;
+ options->color_profile.input_name[i] = nullptr;
}
set_default_image_overlay_template_string(&options->image_overlay.template_string);
options->float_window.w = 260;
options->float_window.x = 0;
options->float_window.y = 0;
- options->home_path = NULL;
+ options->home_path = nullptr;
options->id = g_strdup("lw1");
options->main_window.h = 540;
options->main_window.hdivider_pos = -1;
static void sync_options_with_current_state(ConfOptions *options)
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
if (layout_valid(&lw))
{
sync_options_with_current_state(options);
rc_path = g_build_filename(get_rc_dir(), RC_FILE_NAME, NULL);
- save_config_to_file(rc_path, options, NULL);
+ save_config_to_file(rc_path, options, nullptr);
g_free(rc_path);
}
{"%Xmp.dc.creator%", N_("© Creator")},
{"%Xmp.dc.contributor%", N_("© Contributor")},
{"%Xmp.dc.rights%", N_("© Rights")},
- {NULL, NULL}};
+ {nullptr, nullptr}};
static GtkTargetEntry osd_drag_types[] = {
{ const_cast<gchar *>("text/plain"), GTK_TARGET_SAME_APP, TARGET_TEXT_PLAIN }
pref_label_new(vbox, _("To include predefined tags in the template, click a button or drag-and-drop"));
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
gtk_widget_show(scrolled);
gtk_widget_set_size_request(scrolled, -1, 140);
- viewport = gtk_viewport_new(NULL, NULL);
+ viewport = gtk_viewport_new(nullptr, nullptr);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled), viewport);
gtk_widget_show(viewport);
static gchar *keywords_to_string(FileData *fd)
{
GList *keywords;
- GString *kwstr = NULL;
- gchar *ret = NULL;
+ GString *kwstr = nullptr;
+ gchar *ret = nullptr;
g_assert(fd);
while (TRUE)
{
guint limit = 0;
- gchar *trunc = NULL;
- gchar *limpos = NULL;
- gchar *extra = NULL;
- gchar *extrapos = NULL;
+ gchar *trunc = nullptr;
+ gchar *limpos = nullptr;
+ gchar *extra = nullptr;
+ gchar *extrapos = nullptr;
gchar *p;
start = strchr(osd_info->str + (prev + 1), delim);
name = g_strndup(start+1, (trunc ? trunc : end)-start-1);
pos = start - osd_info->str;
- data = NULL;
+ data = nullptr;
if (strcmp(name, "keywords") == 0)
{
/** @FIXME using background / foreground colors lead to weird results.
*/
gchar *new_data;
- gchar *left = NULL;
+ gchar *left = nullptr;
gchar *right = extra;
gchar *p;
guint len = strlen(extra);
x = pi_day->x + pi_day->width + 4;
y = pi_day->y;
- pbox = pan_item_box_new(pw, NULL, x, y, PAN_BOX_BORDER, PAN_BOX_BORDER,
+ pbox = pan_item_box_new(pw, nullptr, x, y, PAN_BOX_BORDER, PAN_BOX_BORDER,
PAN_CAL_POPUP_BORDER,
PAN_CAL_POPUP_COLOR, PAN_CAL_POPUP_ALPHA,
PAN_CAL_POPUP_BORDER_COLOR, PAN_CAL_POPUP_ALPHA);
util_clip_triangle(x1, y1, x2, y2, x3, y3,
&x, &y, &w, &h);
- pi = pan_item_tri_new(pw, NULL, x, y, w, h,
+ pi = pan_item_tri_new(pw, nullptr, x, y, w, h,
x1, y1, x2, y2, x3, y3,
PAN_CAL_POPUP_COLOR, PAN_CAL_POPUP_ALPHA);
pan_item_tri_border(pi, PAN_BORDER_1 | PAN_BORDER_3, PAN_CAL_POPUP_BORDER_COLOR, PAN_CAL_POPUP_ALPHA);
x = PAN_BOX_BORDER;
- pi_month = pan_item_box_new(pw, NULL, x, y, PAN_CAL_DAY_WIDTH * 7, PAN_CAL_DAY_HEIGHT / 4,
+ pi_month = pan_item_box_new(pw, nullptr, x, y, PAN_CAL_DAY_WIDTH * 7, PAN_CAL_DAY_HEIGHT / 4,
PAN_CAL_MONTH_BORDER,
PAN_CAL_MONTH_COLOR, PAN_CAL_MONTH_ALPHA,
PAN_CAL_MONTH_BORDER_COLOR, PAN_CAL_MONTH_ALPHA);
dx = x + PAN_CAL_DOT_GAP * 2;
dy = y + PAN_CAL_DOT_GAP * 2;
- fd = static_cast<FileData *>((work) ? work->data : NULL);
+ fd = static_cast<FileData *>((work) ? work->data : nullptr);
while (fd && pan_date_compare(fd->date, dt, PAN_DATE_LENGTH_DAY))
{
PanItem *pi;
n++;
work = work->next;
- fd = static_cast<FileData *>((work) ? work->data : NULL);
+ fd = static_cast<FileData *>((work) ? work->data : nullptr);
}
if (n > 0)
x2 = MAX(px, gx + 5);
y2 = MAX(py, gy + 5);
- pi = pan_item_tri_new(pw, NULL, x1, y1, x2 - x1, y2 - y1,
+ pi = pan_item_tri_new(pw, nullptr, x1, y1, x2 - x1, y2 - y1,
px, py, gx, gy, gx + 5, gy + 5,
255, 40, 40, 128);
pan_item_tri_border(pi, PAN_BORDER_1 | PAN_BORDER_3,
}
pw->list = g_list_concat(group->items, pw->list);
- group->items = NULL;
+ group->items = nullptr;
group->circumference = 0;
work = group->children;
gint grid_size;
gint grid_count;
- if (!filelist_read(dir_fd, &f, &d)) return NULL;
- if (!f && !d) return NULL;
+ if (!filelist_read(dir_fd, &f, &d)) return nullptr;
+ if (!f && !d) return nullptr;
f = filelist_sort(f, SORT_NAME, TRUE);
d = filelist_sort(d, SORT_NAME, TRUE);
group = g_new0(FlowerGroup, 1);
group->items = pw->list;
- pw->list = NULL;
+ pw->list = nullptr;
group->width = pi_box->width;
group->height = pi_box->y + pi_box->height;
group->diameter = static_cast<gint>(sqrt(group->width * group->width + group->height * group->height));
- group->children = NULL;
+ group->children = nullptr;
work = d;
while (work)
g_list_free(group->items);
g_free(group);
- group = NULL;
+ group = nullptr;
}
g_list_free(f);
GList *list;
group = pan_flower_group(pw, dir_fd, 0, 0);
- pan_flower_build(pw, group, NULL);
+ pan_flower_build(pw, group, nullptr);
pan_flower_size(pw, width, height);
w = PAN_BOX_BORDER * 2;
h = PAN_BOX_BORDER * 2;
- pan_folder_tree_path(pw, dir_fd, &x, &y, &level, NULL, &w, &h);
+ pan_folder_tree_path(pw, dir_fd, &x, &y, &level, nullptr, &w, &h);
if (width) *width = w;
if (height) *height = h;
{
if (!pi) return;
- if (pw->click_pi == pi) pw->click_pi = NULL;
- if (pw->queue_pi == pi) pw->queue_pi = NULL;
- if (pw->search_pi == pi) pw->search_pi = NULL;
+ if (pw->click_pi == pi) pw->click_pi = nullptr;
+ if (pw->queue_pi == pi) pw->queue_pi = nullptr;
+ if (pw->search_pi == pi) pw->search_pi = nullptr;
pw->queue = g_list_remove(pw->queue, pi);
pw->list = g_list_remove(pw->list, pi);
{
PangoLayout *layout;
- layout = gtk_widget_create_pango_layout(widget, NULL);
+ layout = gtk_widget_create_pango_layout(widget, nullptr);
if (pi->text_attr & PAN_TEXT_ATTR_MARKUP)
{
}
}
- return (pi->pixbuf == NULL);
+ return (pi->pixbuf == nullptr);
}
}
}
- return (pi->pixbuf == NULL);
+ return (pi->pixbuf == nullptr);
}
{
GList *work;
- if (!key) return NULL;
+ if (!key) return nullptr;
work = g_list_last(pw->list);
while (work)
work = work->prev;
}
- return NULL;
+ return nullptr;
}
/* when ignore_case and partial are TRUE, path should be converted to lower case */
gchar *haystack;
haystack = g_utf8_strdown(pi->fd->name, -1);
- match = (strstr(haystack, path) != NULL);
+ match = (strstr(haystack, path) != nullptr);
g_free(haystack);
}
else
GList *pan_item_find_by_path(PanWindow *pw, PanItemType type, const gchar *path,
gboolean ignore_case, gboolean partial)
{
- GList *list = NULL;
+ GList *list = nullptr;
- if (!path) return NULL;
- if (partial && path[0] == G_DIR_SEPARATOR) return NULL;
+ if (!path) return nullptr;
+ if (partial && path[0] == G_DIR_SEPARATOR) return nullptr;
list = pan_item_find_by_path_l(list, pw->list_static, type, path, ignore_case, partial);
list = pan_item_find_by_path_l(list, pw->list, type, path, ignore_case, partial);
GList *pan_item_find_by_fd(PanWindow *pw, PanItemType type, FileData *fd,
gboolean ignore_case, gboolean partial)
{
- if (!fd) return NULL;
+ if (!fd) return nullptr;
return pan_item_find_by_path(pw, type, fd->path, ignore_case, partial);
}
work = work->next;
}
- return NULL;
+ return nullptr;
}
PanItem *pan_item_find_by_coord(PanWindow *pw, PanItemType type,
}
else
{
- item = NULL;
+ item = nullptr;
}
ta->column1 = g_list_append(ta->column1, item);
}
else
{
- item = NULL;
+ item = nullptr;
}
ta->column2 = g_list_append(ta->column2, item);
time_t group_start_date;
gint total;
gint count;
- PanItem *pi_month = NULL;
- PanItem *pi_day = NULL;
+ PanItem *pi_month = nullptr;
+ PanItem *pi_day = nullptr;
gint month_start;
gint day_start;
gint x_width;
if (!pan_date_compare(fd->date, group_start_date, PAN_DATE_LENGTH_MONTH))
{
// FD starts a new month group.
- pi_day = NULL;
+ pi_day = nullptr;
if (pi_month)
{
}
else
{
- needle = NULL;
+ needle = nullptr;
}
}
{
struct tm td;
gchar buf[128];
- const gchar *format = NULL;
+ const gchar *format = nullptr;
if (!localtime_r(&d, &td)) return g_strdup("");
if (format && strftime(buf, sizeof(buf), format, &td) > 0)
{
- gchar *ret = g_locale_to_utf8(buf, -1, NULL, NULL, NULL);
+ gchar *ret = g_locale_to_utf8(buf, -1, nullptr, nullptr, nullptr);
if (ret) return ret;
}
void pan_filter_ui_destroy(PanViewFilterUi **ui_ptr)
{
- if (ui_ptr == NULL || *ui_ptr == NULL) return;
+ if (ui_ptr == nullptr || *ui_ptr == nullptr) return;
// Note that g_clear_pointer handles already-NULL pointers.
//g_clear_pointer(&(*ui_ptr)->filter_kw_table, g_hash_table_destroy);
g_free(*ui_ptr);
- *ui_ptr = NULL;
+ *ui_ptr = nullptr;
}
static void pan_filter_status(PanWindow *pw, const gchar *text)
if (g_strcmp0(text, g_regex_escape_string(text, -1)))
{
// It's an actual regex, so compile
- element->kw_regex = g_regex_new(text, static_cast<GRegexCompileFlags>(G_REGEX_ANCHORED | G_REGEX_OPTIMIZE), G_REGEX_MATCH_ANCHORED, NULL);
+ element->kw_regex = g_regex_new(text, static_cast<GRegexCompileFlags>(G_REGEX_ANCHORED | G_REGEX_OPTIMIZE), G_REGEX_MATCH_ANCHORED, nullptr);
}
ui->filter_elements = g_list_append(ui->filter_elements, element);
{
auto keyword = static_cast<gchar *>(work->data);
work = work->next;
- if (g_regex_match(filter->kw_regex, keyword, GRegexMatchFlags(0), NULL))
+ if (g_regex_match(filter->kw_regex, keyword, GRegexMatchFlags(0), nullptr))
{
if (found_kw) *found_kw = keyword;
return TRUE;
{
GList *work;
gboolean modified = FALSE;
- GHashTable *seen_kw_table = NULL;
+ GHashTable *seen_kw_table = nullptr;
if (!fd_list || !*fd_list) return modified;
// seen_kw_table is only valid in this scope, so don't take ownership of any strings.
if (filter_elements)
- seen_kw_table = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
+ seen_kw_table = g_hash_table_new_full(g_str_hash, g_str_equal, nullptr, nullptr);
work = *fd_list;
while (work)
work = work->next;
gboolean should_reject = FALSE;
- gchar *group_kw = NULL;
+ gchar *group_kw = nullptr;
if (!((1 << fd -> format_class) & filter_classes))
{
{
auto filter = static_cast<PanViewFilterElement *>(filter_element->data);
filter_element = filter_element->next;
- gchar *found_kw = NULL;
+ gchar *found_kw = nullptr;
gboolean has_kw = pan_view_list_contains_kw_pattern(img_keywords, filter, &found_kw);
switch (filter->mode)
{
should_reject = TRUE;
}
- else if (group_kw == NULL)
+ else if (group_kw == nullptr)
{
group_kw = found_kw;
}
}
}
string_list_free(img_keywords);
- if (!should_reject && group_kw != NULL) g_hash_table_add(seen_kw_table, group_kw);
- group_kw = NULL; // group_kw references an item from img_keywords.
+ if (!should_reject && group_kw != nullptr) g_hash_table_add(seen_kw_table, group_kw);
+ group_kw = nullptr; // group_kw references an item from img_keywords.
}
if (should_reject)
void pan_search_ui_destroy(PanViewSearchUi **ui_ptr)
{
- if (ui_ptr == NULL || *ui_ptr == NULL) return;
+ if (ui_ptr == nullptr || *ui_ptr == nullptr) return;
g_free(*ui_ptr);
- *ui_ptr = NULL;
+ *ui_ptr = nullptr;
}
static void pan_search_status(PanWindow *pw, const gchar *text)
gint year, gint month, gint day,
const gchar *key)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
work = g_list_last(pw->list_static);
static gboolean pan_search_by_date(PanWindow *pw, const gchar *text)
{
- PanItem *pi = NULL;
- GList *list = NULL;
+ PanItem *pi = nullptr;
+ GList *list = nullptr;
GList *found;
gint year;
gint month = -1;
ptr++;
}
- t = time(NULL);
+ t = time(nullptr);
if (t == -1) return FALSE;
lt = localtime(&t);
if (!lt) return FALSE;
PanItemType type;
type = (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB;
- list = pan_search_by_date_val(pw, type, year, month, day, NULL);
+ list = pan_search_by_date_val(pw, type, year, month, day, nullptr);
}
if (list)
if (pw->layout == PAN_LAYOUT_CALENDAR && pi && pi->type == PAN_ITEM_BOX)
{
- pan_info_update(pw, NULL);
+ pan_info_update(pw, nullptr);
pan_calendar_update(pw, pi);
image_scroll_to_point(pw->imd,
pi->x + pi->width / 2,
#define PAN_PREF_INFO_EXIF "info_includes_exif"
-static GList *pan_window_list = NULL;
+static GList *pan_window_list = nullptr;
static void pan_layout_update_idle(PanWindow *pw);
{static_cast<GdkModifierType>(0), GDK_KEY_Page_Down, N_("Scroll display half screen down")},
{static_cast<GdkModifierType>(0), GDK_KEY_Home, N_("Scroll display half screen left")},
{static_cast<GdkModifierType>(0), GDK_KEY_End, N_("Scroll display half screen right")},
- {static_cast<GdkModifierType>(0), 0, NULL}
+ {static_cast<GdkModifierType>(0), 0, nullptr}
};
/*
gint rc;
pi = pw->queue_pi;
- pw->queue_pi = NULL;
+ pw->queue_pi = nullptr;
pi->queued = FALSE;
}
thumb_loader_free(pw->tl);
- pw->tl = NULL;
+ pw->tl = nullptr;
while (pan_queue_step(pw));
}
static void pan_queue_image_done_cb(ImageLoader *il, gpointer data)
{
auto pw = static_cast<PanWindow *>(data);
- GdkPixbuf *rotated = NULL;
+ GdkPixbuf *rotated = nullptr;
if (pw->queue_pi)
{
gint rc;
pi = pw->queue_pi;
- pw->queue_pi = NULL;
+ pw->queue_pi = nullptr;
pi->queued = FALSE;
}
image_loader_free(pw->il);
- pw->il = NULL;
+ pw->il = nullptr;
while (pan_queue_step(pw));
}
if (!pw->queue_pi->fd)
{
pw->queue_pi->queued = FALSE;
- pw->queue_pi = NULL;
+ pw->queue_pi = nullptr;
return TRUE;
}
image_loader_free(pw->il);
- pw->il = NULL;
+ pw->il = nullptr;
thumb_loader_free(pw->tl);
- pw->tl = NULL;
+ pw->tl = nullptr;
if (pi->type == PAN_ITEM_IMAGE)
{
if (image_loader_start(pw->il)) return FALSE;
image_loader_free(pw->il);
- pw->il = NULL;
+ pw->il = nullptr;
}
else if (pi->type == PAN_ITEM_THUMB)
{
thumb_loader_set_callbacks(pw->tl,
pan_queue_thumb_done_cb,
pan_queue_thumb_done_cb,
- NULL, pw);
+ nullptr, pw);
if (thumb_loader_start(pw->tl, pi->fd)) return FALSE;
thumb_loader_free(pw->tl);
- pw->tl = NULL;
+ pw->tl = nullptr;
}
pw->queue_pi->queued = FALSE;
- pw->queue_pi = NULL;
+ pw->queue_pi = nullptr;
return TRUE;
}
pw->queue = g_list_remove(pw->queue, pi);
pi->queued = FALSE;
}
- if (pw->queue_pi == pi) pw->queue_pi = NULL;
+ if (pw->queue_pi == pi) pw->queue_pi = nullptr;
if (pi->pixbuf)
{
g_object_unref(pi->pixbuf);
- pi->pixbuf = NULL;
+ pi->pixbuf = nullptr;
}
}
}
}
g_list_free(pw->cache_list);
- pw->cache_list = NULL;
+ pw->cache_list = nullptr;
filelist_free(pw->cache_todo);
- pw->cache_todo = NULL;
+ pw->cache_todo = nullptr;
pw->cache_count = 0;
pw->cache_total = 0;
pw->cache_tick = 0;
cache_loader_free(pw->cache_cl);
- pw->cache_cl = NULL;
+ pw->cache_cl = nullptr;
}
static void pan_cache_fill(PanWindow *pw, FileData *dir_fd)
if (!pc->cd)
{
pc->cd = cl->cd;
- cl->cd = NULL;
+ cl->cd = nullptr;
}
}
cache_loader_free(cl);
- pw->cache_cl = NULL;
+ pw->cache_cl = nullptr;
pan_layout_update_idle(pw);
}
pc = g_new0(PanCacheData, 1);
pc->fd = file_data_ref(fd);
- pc->cd = NULL;
+ pc->cd = nullptr;
pw->cache_list = g_list_prepend(pw->cache_list, pc);
if (pw->exif_date_enable) load_mask = static_cast<CacheDataType>(load_mask | CACHE_LOADER_DATE);
pw->cache_cl = cache_loader_new(pc->fd, load_mask,
pan_cache_step_done_cb, pw);
- return (pw->cache_cl == NULL);
+ return (pw->cache_cl == nullptr);
}
/* This sync date function is optimized for lists with a common sort */
}
haystack = g_list_delete_link(haystack, needle);
- needle = NULL;
+ needle = nullptr;
}
else
{
}
g_list_free(pw->list_grid);
- pw->list_grid = NULL;
+ pw->list_grid = nullptr;
pw->list = g_list_concat(pw->list, pw->list_static);
- pw->list_static = NULL;
+ pw->list_static = nullptr;
}
static void pan_grid_build(PanWindow *pw, gint width, gint height, gint grid_size)
}
pw->list_static = pw->list;
- pw->list = NULL;
+ pw->list = nullptr;
}
}
g_list_free(pw->list);
- pw->list = NULL;
+ pw->list = nullptr;
g_list_free(pw->queue);
- pw->queue = NULL;
- pw->queue_pi = NULL;
+ pw->queue = nullptr;
+ pw->queue_pi = nullptr;
image_loader_free(pw->il);
- pw->il = NULL;
+ pw->il = nullptr;
thumb_loader_free(pw->tl);
- pw->tl = NULL;
+ pw->tl = nullptr;
- pw->click_pi = NULL;
- pw->search_pi = NULL;
+ pw->click_pi = nullptr;
+ pw->search_pi = nullptr;
}
GList *pan_layout_intersect(PanWindow *pw, gint x, gint y, gint width, gint height)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *grid;
- PanGrid *pg = NULL;
+ PanGrid *pg = nullptr;
grid = pw->list_grid;
while (grid && !pg)
if (x < pg->x || x + width > pg->x + pg->w ||
y < pg->y || y + height > pg->y + pg->h)
{
- pg = NULL;
+ pg = nullptr;
}
}
pixbuf_renderer_scroll_to_point(PIXBUF_RENDERER(pw->imd->pr), scroll_x, scroll_y, align, align);
}
- pan_window_message(pw, NULL);
+ pan_window_message(pw, nullptr);
pw->idle_id = 0;
return G_SOURCE_REMOVE;
FileData *pan_menu_click_fd(PanWindow *pw)
{
if (pw->click_pi && pw->click_pi->fd) return pw->click_pi->fd;
- return NULL;
+ return nullptr;
}
static gboolean pan_window_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
case '0':
break;
case 'C': case 'c':
- if (fd) file_util_copy(fd, NULL, NULL, GTK_WIDGET(pr));
+ if (fd) file_util_copy(fd, nullptr, nullptr, GTK_WIDGET(pr));
break;
case 'M': case 'm':
- if (fd) file_util_move(fd, NULL, NULL, GTK_WIDGET(pr));
+ if (fd) file_util_move(fd, nullptr, nullptr, GTK_WIDGET(pr));
break;
case 'R': case 'r':
- if (fd) file_util_rename(fd, NULL, GTK_WIDGET(pr));
+ if (fd) file_util_rename(fd, nullptr, GTK_WIDGET(pr));
break;
case 'D': case 'd':
if (fd)
{
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(fd, NULL, GTK_WIDGET(pr));
+ file_util_delete(fd, nullptr, GTK_WIDGET(pr));
}
break;
case 'F': case 'f':
case GDK_KEY_Menu:
case GDK_KEY_F10:
menu = pan_popup_menu(pw);
- gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_SOUTH, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_SOUTH, GDK_GRAVITY_CENTER, nullptr);
break;
case '/':
gint x, y, w, h;
if (pw->click_pi == pi) return;
- if (pi && !pi->fd) pi = NULL;
+ if (pi && !pi->fd) pi = nullptr;
while ((p = pan_item_find_by_key(pw, PAN_ITEM_NONE, "info"))) pan_item_remove(pw, p);
pw->click_pi = pi;
DEBUG_1("info set to %s", pi->fd->path);
- pbox = pan_item_box_new(pw, NULL, pi->x + pi->width + 4, pi->y, 10, 10,
+ pbox = pan_item_box_new(pw, nullptr, pi->x + pi->width + 4, pi->y, 10, 10,
PAN_POPUP_BORDER,
PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
util_clip_triangle(x1, y1, x2, y2, x3, y3,
&x, &y, &w, &h);
- p = pan_item_tri_new(pw, NULL, x, y, w, h,
+ p = pan_item_tri_new(pw, nullptr, x, y, w, h,
x1, y1, x2, y2, x3, y3,
PAN_POPUP_COLOR, PAN_POPUP_ALPHA);
pan_item_tri_border(p, PAN_BORDER_1 | PAN_BORDER_3, PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
iw = MAX(1, iw * scale / 100);
ih = MAX(1, ih * scale / 100);
- pbox = pan_item_box_new(pw, NULL, pbox->x, pbox->y + pbox->height + 8, 10, 10,
+ pbox = pan_item_box_new(pw, nullptr, pbox->x, pbox->y + pbox->height + 8, 10, 10,
PAN_POPUP_BORDER,
PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
static void button_cb(PixbufRenderer *pr, GdkEventButton *event, gpointer data)
{
auto pw = static_cast<PanWindow *>(data);
- PanItem *pi = NULL;
+ PanItem *pi = nullptr;
GtkWidget *menu;
gint rx, ry;
pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "info");
if (pi && event->button == MOUSE_BUTTON_LEFT)
{
- pan_info_update(pw, NULL);
+ pan_info_update(pw, nullptr);
return;
}
pi = pan_item_find_by_coord(pw, (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB,
- rx, ry, NULL);
+ rx, ry, nullptr);
switch (event->button)
{
case MOUSE_BUTTON_RIGHT:
pan_info_update(pw, pi);
menu = pan_popup_menu(pw);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
break;
default:
break;
{
auto pw = static_cast<PanWindow *>(data);
- pw->fs = NULL;
+ pw->fs = nullptr;
pw->imd = pw->imd_normal;
}
pw->idle_id = 0;
- pw->window = window_new(GTK_WINDOW_TOPLEVEL, "panview", NULL, NULL, _("Pan View"));
+ pw->window = window_new(GTK_WINDOW_TOPLEVEL, "panview", nullptr, nullptr, _("Pan View"));
DEBUG_NAME(pw->window);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
- gtk_window_set_geometry_hints(GTK_WINDOW(pw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
+ gtk_window_set_geometry_hints(GTK_WINDOW(pw->window), nullptr, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(pw->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(pw->window), 0);
pan_image_set_buttons(pw, pw->imd);
- pw->scrollbar_h = gtk_hscrollbar_new(NULL);
+ pw->scrollbar_h = gtk_hscrollbar_new(nullptr);
g_signal_connect(G_OBJECT(pw->scrollbar_h), "value_changed",
G_CALLBACK(pan_window_scrollbar_h_value_cb), pw);
gtk_table_attach(GTK_TABLE(table), pw->scrollbar_h, 0, 1, 1, 2,
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(pw->scrollbar_h);
- pw->scrollbar_v = gtk_vscrollbar_new(NULL);
+ pw->scrollbar_v = gtk_vscrollbar_new(nullptr);
g_signal_connect(G_OBJECT(pw->scrollbar_v), "value_changed",
G_CALLBACK(pan_window_scrollbar_v_value_cb), pw);
gtk_table_attach(GTK_TABLE(table), pw->scrollbar_v, 1, 2, 0, 1,
box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
pref_spacer(hbox, 0);
pw->label_message = pref_label_new(hbox, "");
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
if (dir_fd && strcmp(dir_fd->path, G_DIR_SEPARATOR_S) == 0)
{
- pan_warning_folder(dir_fd->path, NULL);
+ pan_warning_folder(dir_fd->path, nullptr);
return TRUE;
}
if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_HIDE_WARNING, &hide_dlg)) hide_dlg = FALSE;
if (hide_dlg) return FALSE;
- gd = generic_dialog_new(_("Pan View Performance"), "pan_view_warning", NULL, FALSE,
- NULL, NULL);
+ gd = generic_dialog_new(_("Pan View Performance"), "pan_view_warning", nullptr, FALSE,
+ nullptr, nullptr);
gd->data = file_data_ref(dir_fd);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr,
pan_warning_ok_cb, TRUE);
box = generic_dialog_add_message(gd, GTK_STOCK_DIALOG_INFO,
pref_line(box, 0);
pref_checkbox_new(box, _("Do not show this dialog again"), hide_dlg,
- G_CALLBACK(pan_warning_hide_cb), NULL);
+ G_CALLBACK(pan_warning_hide_cb), nullptr);
gtk_widget_show(gd->dialog);
static void pan_go_to_original_cb(GtkWidget *UNUSED(widget), gpointer data)
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
auto pw = static_cast<PanWindow *>(data);
FileData *fd;
FileData *fd;
fd = pan_menu_click_fd(pw);
- if (fd) file_util_copy(fd, NULL, NULL, pw->imd->widget);
+ if (fd) file_util_copy(fd, nullptr, nullptr, pw->imd->widget);
}
static void pan_move_cb(GtkWidget *UNUSED(widget), gpointer data)
FileData *fd;
fd = pan_menu_click_fd(pw);
- if (fd) file_util_move(fd, NULL, NULL, pw->imd->widget);
+ if (fd) file_util_move(fd, nullptr, nullptr, pw->imd->widget);
}
static void pan_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
FileData *fd;
fd = pan_menu_click_fd(pw);
- if (fd) file_util_rename(fd, NULL, pw->imd->widget);
+ if (fd) file_util_rename(fd, nullptr, pw->imd->widget);
}
static void pan_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
if (fd)
{
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(fd, NULL, pw->imd->widget);
+ file_util_delete(fd, nullptr, pw->imd->widget);
}
}
if (fd)
{
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(fd, NULL, pw->imd->widget);
+ file_util_delete(fd, nullptr, pw->imd->widget);
}
}
static GList *pan_view_get_fd_list(PanWindow *pw)
{
- GList *list = NULL;
+ GList *list = nullptr;
FileData *fd = pan_menu_click_fd(pw);
if (fd) list = g_list_prepend(filelist_copy(fd->sidecar_files), file_data_ref(fd));
static void pan_pop_menu_collections_cb(GtkWidget *widget, gpointer data)
{
PanWindow *pw;
- GList *selection_list = NULL;
+ GList *selection_list = nullptr;
pw = static_cast<PanWindow *>(submenu_item_get_data(widget));
selection_list = g_list_append(selection_list, pan_menu_click_fd(pw));
GList *editmenu_fd_list;
GtkAccelGroup *accel_group;
- active = (pw->click_pi != NULL);
+ active = (pw->click_pi != nullptr);
video = (active && pw->click_pi->fd && pw->click_pi->fd->format_class == FORMAT_CLASS_VIDEO);
menu = popup_menu_short_lived();
menu_item_add_check(menu, _("_Show Exif information"), pw->info_includes_exif,
G_CALLBACK(pan_info_toggle_exif_cb), pw);
- item = menu_item_add(menu, _("Show im_age"), NULL, NULL);
+ item = menu_item_add(menu, _("Show im_age"), nullptr, nullptr);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
{
GList *list;
- list = g_list_append(NULL, fd);
+ list = g_list_append(nullptr, fd);
uri_selection_data_set_uris_from_filelist(selection_data, list);
g_list_free(list);
}
else
{
gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
- 8, NULL, 0);
+ 8, nullptr, 0);
}
}
} PrZoomFlags;
static guint signals[SIGNAL_COUNT] = { 0 };
-static GtkEventBoxClass *parent_class = NULL;
+static GtkEventBoxClass *parent_class = nullptr;
static const GTypeInfo pixbuf_renderer_info =
{
sizeof(PixbufRendererClass), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
+ nullptr, /* base_init */
+ nullptr, /* base_finalize */
static_cast<GClassInitFunc>(pixbuf_renderer_class_init_wrapper),
- NULL, /* class_finalize */
- NULL, /* class_data */
+ nullptr, /* class_finalize */
+ nullptr, /* class_data */
sizeof(PixbufRenderer), /* instance_size */
0, /* n_preallocs */
reinterpret_cast<GInstanceInitFunc>(pixbuf_renderer_init_wrapper), /* instance_init */
- NULL, /* value_table */
+ nullptr, /* value_table */
};
pixbuf_renderer_type = g_type_register_static(GTK_TYPE_EVENT_BOX, "PixbufRenderer",
PROP_ZOOM_MIN,
g_param_spec_double("zoom_min",
"Zoom minimum",
- NULL,
+ nullptr,
-1000.0,
1000.0,
PR_ZOOM_MIN,
PROP_ZOOM_MAX,
g_param_spec_double("zoom_max",
"Zoom maximum",
- NULL,
+ nullptr,
-1000.0,
1000.0,
PR_ZOOM_MIN,
PROP_ZOOM_QUALITY,
g_param_spec_uint("zoom_quality",
"Zoom quality",
- NULL,
+ nullptr,
GDK_INTERP_NEAREST,
GDK_INTERP_BILINEAR,
GDK_INTERP_BILINEAR,
PROP_ZOOM_2PASS,
g_param_spec_boolean("zoom_2pass",
"2 pass zoom",
- NULL,
+ nullptr,
TRUE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_ZOOM_EXPAND,
g_param_spec_boolean("zoom_expand",
"Expand image in autozoom.",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_SCROLL_RESET,
g_param_spec_uint("scroll_reset",
"New image scroll reset",
- NULL,
+ nullptr,
PR_SCROLL_RESET_TOPLEFT,
PR_SCROLL_RESET_NOCHANGE,
PR_SCROLL_RESET_TOPLEFT,
PROP_DELAY_FLIP,
g_param_spec_boolean("delay_flip",
"Delay image update",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_LOADING,
g_param_spec_boolean("loading",
"Image actively loading",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_COMPLETE,
g_param_spec_boolean("complete",
"Image rendering complete",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_CACHE_SIZE_DISPLAY,
g_param_spec_uint("cache_display",
"Display cache size MiB",
- NULL,
+ nullptr,
0,
128,
PR_CACHE_SIZE_DEFAULT,
PROP_WINDOW_FIT,
g_param_spec_boolean("window_fit",
"Fit window to image size",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_WINDOW_LIMIT,
g_param_spec_boolean("window_limit",
"Limit size of parent window",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_WINDOW_LIMIT_VALUE,
g_param_spec_uint("window_limit_value",
"Size limit of parent window",
- NULL,
+ nullptr,
10,
150,
100,
PROP_AUTOFIT_LIMIT,
g_param_spec_boolean("autofit_limit",
"Limit size of image when autofitting",
- NULL,
+ nullptr,
FALSE,
static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
PROP_AUTOFIT_LIMIT_VALUE,
g_param_spec_uint("autofit_limit_value",
"Size limit of image when autofitting",
- NULL,
+ nullptr,
10,
150,
100,
PROP_ENLARGEMENT_LIMIT_VALUE,
g_param_spec_uint("enlargement_limit_value",
"Size increase limit of image when autofitting",
- NULL,
+ nullptr,
100,
999,
500,
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, zoom),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__DOUBLE,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, clicked),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, scroll_notify),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, render_complete),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, drag),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, update_pixel),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
pr->y_mouse = -1;
pr->source_tiles_enabled = FALSE;
- pr->source_tiles = NULL;
+ pr->source_tiles = nullptr;
pr->orientation = 1;
pr->renderer = pr_backend_renderer_new(pr);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
gtk_widget_set_double_buffered(box, FALSE);
gtk_widget_set_app_paintable(box, TRUE);
PixbufRenderer *pixbuf_renderer_new(void)
{
- return static_cast<PixbufRenderer *>(g_object_new(TYPE_PIXBUF_RENDERER, NULL));
+ return static_cast<PixbufRenderer *>(g_object_new(TYPE_PIXBUF_RENDERER, nullptr));
}
static void pixbuf_renderer_set_property(GObject *object, guint prop_id,
if (icon == -1)
{
- cursor = NULL;
+ cursor = nullptr;
}
else
{
void pixbuf_renderer_set_parent(PixbufRenderer *pr, GtkWindow *window)
{
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
- g_return_if_fail(window == NULL || GTK_IS_WINDOW(window));
+ g_return_if_fail(window == nullptr || GTK_IS_WINDOW(window));
pr->parent_window = GTK_WIDGET(window);
}
void pixbuf_renderer_overlay_remove(PixbufRenderer *pr, gint id)
{
- pr->renderer->overlay_set(pr->renderer, id, NULL, 0, 0);
- if (pr->renderer2) pr->renderer2->overlay_set(pr->renderer2, id, NULL, 0, 0);
+ pr->renderer->overlay_set(pr->renderer, id, nullptr, 0, 0);
+ if (pr->renderer2) pr->renderer2->overlay_set(pr->renderer2, id, nullptr, 0, 0);
}
/*
resource_path = g_build_filename(GQ_RESOURCE_PATH_ICONS, PIXBUF_INLINE_SCROLLER ".png", NULL);
- pixbuf = gdk_pixbuf_new_from_resource(resource_path, NULL);
+ pixbuf = gdk_pixbuf_new_from_resource(resource_path, nullptr);
g_free(resource_path);
#else
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
}
g_list_free(pr->source_tiles);
- pr->source_tiles = NULL;
+ pr->source_tiles = nullptr;
}
static void pr_source_tile_unset(PixbufRenderer *pr)
static SourceTile *pr_source_tile_new(PixbufRenderer *pr, gint x, gint y)
{
- SourceTile *st = NULL;
+ SourceTile *st = nullptr;
gint count;
g_return_val_if_fail(pr->source_tile_width >= 1 && pr->source_tile_height >= 1, NULL);
SourceTile *st;
st = pr_source_tile_new(pr, x, y);
- if (!st) return NULL;
+ if (!st) return nullptr;
if (pr->func_tile_request &&
pr->func_tile_request(pr, st->x, st->y,
work = work->next;
}
- return NULL;
+ return nullptr;
}
GList *pr_source_tile_compute_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h, gboolean request)
{
gint x1, y1;
- GList *list = NULL;
+ GList *list = nullptr;
gint sx, sy;
if (x < 0) x = 0;
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
g_return_if_fail(tile_width >= 32 && tile_height >= 32);
g_return_if_fail(width >= 32 && height > 32);
- g_return_if_fail(func_request != NULL);
+ g_return_if_fail(func_request != nullptr);
if (pr->pixbuf) g_object_unref(pr->pixbuf);
- pr->pixbuf = NULL;
+ pr->pixbuf = nullptr;
pr_source_tile_unset(pr);
{
GdkPixbuf *pixbuf;
- if (pixbuf_renderer_overlay_get(pr, pr->scroller_overlay, &pixbuf, NULL, NULL))
+ if (pixbuf_renderer_overlay_get(pr, pr->scroller_overlay, &pixbuf, nullptr, nullptr))
{
gint w, h;
seat = gdk_display_get_default_seat(gdk_window_get_display(event->window));
device = gdk_seat_get_pointer(seat);
- gdk_window_get_device_position(event->window, device, &x, &y, NULL);
+ gdk_window_get_device_position(event->window, device, &x, &y, nullptr);
event->x = x;
event->y = y;
pr->drag_moved = 0;
gdk_pointer_grab(gtk_widget_get_window(widget), FALSE,
static_cast<GdkEventMask>(GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK),
- NULL, NULL, bevent->time);
+ nullptr, nullptr, bevent->time);
gtk_grab_add(widget);
break;
case MOUSE_BUTTON_MIDDLE:
pr->func_tile_data = source->func_tile_data;
pr->source_tiles = source->source_tiles;
- source->source_tiles = NULL;
+ source->source_tiles = nullptr;
pr_zoom_sync(pr, source->zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
pr->scroll_reset = scroll_reset;
- pixbuf_renderer_set_pixbuf(source, NULL, source->zoom);
+ pixbuf_renderer_set_pixbuf(source, nullptr, source->zoom);
}
void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source)
pr->func_tile_data = source->func_tile_data;
pr->source_tiles = source->source_tiles;
- source->source_tiles = NULL;
+ source->source_tiles = nullptr;
pr_zoom_sync(pr, source->zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
else
{
if (pr->renderer2) pr->renderer2->free(pr->renderer2);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
}
if (pr->stereo_mode & PR_STEREO_HALF)
{
if (!pr->renderer) pr->renderer = pr_backend_renderer_new(pr);
pr->renderer->stereo_set(pr->renderer, PR_STEREO_NONE);
if (pr->renderer2) pr->renderer2->free(pr->renderer2);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
pr->aspect_ratio = 1.0;
}
else
size_t xoff, yoff;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(r_mouse != NULL && g_mouse != NULL && b_mouse != NULL, FALSE);
+ g_return_val_if_fail(r_mouse != nullptr && g_mouse != nullptr && b_mouse != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled)
{
gint x_pixel, y_pixel, x_pixel_clamped, y_pixel_clamped;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(x_pixel_return != NULL && y_pixel_return != NULL, FALSE);
+ g_return_val_if_fail(x_pixel_return != nullptr && y_pixel_return != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled)
{
gboolean pixbuf_renderer_get_image_size(PixbufRenderer *pr, gint *width, gint *height)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(width != NULL && height != NULL, FALSE);
+ g_return_val_if_fail(width != nullptr && height != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
{
gboolean pixbuf_renderer_get_scaled_size(PixbufRenderer *pr, gint *width, gint *height)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(width != NULL && height != NULL, FALSE);
+ g_return_val_if_fail(width != nullptr && height != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
{
gboolean pixbuf_renderer_get_visible_rect(PixbufRenderer *pr, GdkRectangle *rect)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(rect != NULL, FALSE);
+ g_return_val_if_fail(rect != nullptr, FALSE);
if ((!pr->pixbuf && !pr->source_tiles_enabled) ||
!pr->scale)
gboolean pixbuf_to_file_as_png(GdkPixbuf *pixbuf, const gchar *filename)
{
- GError *error = NULL;
+ GError *error = nullptr;
gboolean ret;
if (!pixbuf || !filename) return FALSE;
{ PIXBUF_INLINE_SPLIT_PANE_SYNC, "gq-icon-split-pane-sync.png" },
{ PIXBUF_INLINE_UNKNOWN, "gq-sheet-unknown.png" },
{ PIXBUF_INLINE_VIDEO, "gq-sheet-video.png" },
- { NULL, NULL }
+ { nullptr, nullptr }
};
GdkPixbuf *pixbuf_inline(const gchar *key)
{
- GError *error = NULL;
+ GError *error = nullptr;
GInputStream *in_stream;
GdkPixbuf *icon_pixbuf;
gchar *path;
gint i;
- if (!key) return NULL;
+ if (!key) return nullptr;
i = 0;
while (inline_pixbuf_data[i].key)
log_printf("warning: inline pixbuf error: %s", error->message);
g_error_free(error);
g_object_unref(in_stream);
- return NULL;
+ return nullptr;
}
- icon_pixbuf = gdk_pixbuf_new_from_stream(in_stream, NULL, &error);
+ icon_pixbuf = gdk_pixbuf_new_from_stream(in_stream, nullptr, &error);
g_object_unref(in_stream);
if (error)
{
log_printf("warning: inline pixbuf error: %s", error->message);
g_error_free(error);
- return NULL;
+ return nullptr;
}
return icon_pixbuf;
log_printf("warning: inline pixbuf key \"%s\" not found.\n", key);
- return NULL;
+ return nullptr;
}
static void register_stock_icon(const gchar *key, GdkPixbuf *pixbuf)
{
- static GtkIconFactory *icon_factory = NULL;
+ static GtkIconFactory *icon_factory = nullptr;
GtkIconSet *icon_set;
if (!icon_factory)
{
GtkIconTheme *icon_theme;
GdkPixbuf *pixbuf;
- GError *error = NULL;
+ GError *error = nullptr;
icon_theme = gtk_icon_theme_get_default();
{
DEBUG_1("Couldn't load icon %s: %s", icon, error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
}
if (strchr(icon, '.'))
{
DEBUG_1("Couldn't load icon %s: %s", icon2, error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
/* try as an absolute path */
pixbuf = gdk_pixbuf_new_from_file(icon, &error);
gint brs;
gint w, h;
- if (!src) return NULL;
+ if (!src) return nullptr;
sw = gdk_pixbuf_get_width(src);
sh = gdk_pixbuf_get_height(src);
gint i, j;
gint a;
- if (!src) return NULL;
+ if (!src) return nullptr;
w = gdk_pixbuf_get_width(src);
h = gdk_pixbuf_get_height(src);
GdkPixbuf *pixbuf_apply_orientation(GdkPixbuf *pixbuf, gint orientation)
{
GdkPixbuf *dest;
- GdkPixbuf *tmp = NULL;
+ GdkPixbuf *tmp = nullptr;
switch (orientation)
{
cairo_image_surface_get_width (source),
cairo_image_surface_get_height (source),
cairo_image_surface_get_stride (source),
- NULL,
- NULL);
+ nullptr,
+ nullptr);
sx = 0;
sy = 0;
};
/* config memory values */
-static ConfOptions *c_options = NULL;
+static ConfOptions *c_options = nullptr;
#ifdef DEBUG
static gint debug_c;
#endif
-static GtkWidget *configwindow = NULL;
-static GtkListStore *filter_store = NULL;
-static GtkTreeStore *accel_store = NULL;
+static GtkWidget *configwindow = nullptr;
+static GtkListStore *filter_store = nullptr;
+static GtkTreeStore *accel_store = nullptr;
static GtkWidget *safe_delete_path_entry;
const gchar *buf;
g_free(*option);
- *option = NULL;
+ *option = nullptr;
buf = gtk_entry_get_text(GTK_ENTRY(entry));
if (buf && strlen(buf) > 0)
{
options->file_sort.natural = c_options->file_sort.natural;
options->file_filter.disable = c_options->file_filter.disable;
- config_entry_to_option(sidecar_ext_entry, &options->sidecar.ext, NULL);
+ config_entry_to_option(sidecar_ext_entry, &options->sidecar.ext, nullptr);
sidecar_ext_parse(options->sidecar.ext);
options->slideshow.random = c_options->slideshow.random;
options->with_rename = c_options->with_rename;
options->collections_on_top = c_options->collections_on_top;
options->hide_window_in_fullscreen = c_options->hide_window_in_fullscreen;
- config_entry_to_option(help_search_engine_entry, &options->help_search_engine, NULL);
+ config_entry_to_option(help_search_engine_entry, &options->help_search_engine, nullptr);
options->external_preview.enable = c_options->external_preview.enable;
- config_entry_to_option(external_preview_select_entry, &options->external_preview.select, NULL);
- config_entry_to_option(external_preview_extract_entry, &options->external_preview.extract, NULL);
+ config_entry_to_option(external_preview_select_entry, &options->external_preview.select, nullptr);
+ config_entry_to_option(external_preview_extract_entry, &options->external_preview.extract, nullptr);
options->read_metadata_in_idle = c_options->read_metadata_in_idle;
if (refresh)
{
filter_rebuild();
- layout_refresh(NULL);
+ layout_refresh(nullptr);
}
- if (accel_store) gtk_tree_model_foreach(GTK_TREE_MODEL(accel_store), accel_apply_cb, NULL);
+ if (accel_store) gtk_tree_model_foreach(GTK_TREE_MODEL(accel_store), accel_apply_cb, nullptr);
toolbar_apply(TOOLBAR_MAIN);
toolbar_apply(TOOLBAR_STATUS);
static void config_window_close_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
gtk_widget_destroy(configwindow);
- configwindow = NULL;
- filter_store = NULL;
+ configwindow = nullptr;
+ filter_store = nullptr;
}
static void config_window_help_cb(GtkWidget *UNUSED(widget), gpointer data)
static gboolean config_window_delete(GtkWidget *UNUSED(widget), GdkEventAny *UNUSED(event), gpointer UNUSED(data))
{
- config_window_close_cb(NULL, NULL);
+ config_window_close_cb(nullptr, nullptr);
return TRUE;
}
config_window_apply();
layout_util_sync(lw);
save_options(options);
- config_window_close_cb(NULL, NULL);
+ config_window_close_cb(nullptr, nullptr);
}
/*
};
static const UseableMouseItems useable_mouse_items[] = {
- {"", "", NULL},
+ {"", "", nullptr},
{"FirstImage", N_("First Image"), GTK_STOCK_GOTO_TOP},
{"PrevImage", N_("Previous Image"), GTK_STOCK_GO_UP},
{"NextImage", N_("Next Image"), GTK_STOCK_GO_DOWN},
{"SBar", N_("Info sidebar"), PIXBUF_INLINE_ICON_INFO},
{"SBarSort", N_("Sort manager"), PIXBUF_INLINE_ICON_SORT},
{"Quit", N_("Quit"), GTK_STOCK_QUIT},
- {NULL, NULL, NULL}
+ {nullptr, nullptr, nullptr}
};
static void mouse_buttons_selection_menu_cb(GtkWidget *combo, gpointer data)
gboolean valid;
FilterEntry *filter;
- rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(filter_store), NULL);
+ rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(filter_store), nullptr);
path = gtk_tree_path_new_from_indices(rows-1, -1);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(data), 0);
if (!filter_store) return;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
- if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
+ if (!gtk_tree_selection_get_selected(selection, nullptr, &iter)) return;
gtk_tree_model_get(GTK_TREE_MODEL(filter_store), &iter, 0, &fe, -1);
if (!fe) return;
dummy_cancel_cb, data);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset filters"),
_("This will reset the file filters to the defaults.\nContinue?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, filter_default_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, filter_default_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
static void safe_delete_view_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
- layout_set_path(NULL, gtk_entry_get_text(GTK_ENTRY(safe_delete_path_entry)));
+ layout_set_path(nullptr, gtk_entry_get_text(GTK_ENTRY(safe_delete_path_entry)));
}
static void safe_delete_clear_ok_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
GtkWidget *entry;
gd = generic_dialog_new(_("Clear trash"),
"clear_trash", widget, TRUE,
- dummy_cancel_cb, NULL);
+ dummy_cancel_cb, nullptr);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear trash"),
_("This will remove the trash contents."), FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, safe_delete_clear_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, safe_delete_clear_ok_cb, TRUE);
entry = gtk_entry_new();
gtk_widget_set_can_focus(entry, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
dummy_cancel_cb, data);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset image overlay template string"),
_("This will reset the image overlay template string to the default.\nContinue?"), TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, image_overlay_default_template_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, image_overlay_default_template_ok_cb, TRUE);
gtk_widget_show(gd->dialog);
}
"label", &label,
NULL);
- if (pango_parse_markup(label, -1, '_', NULL, &label2, NULL, NULL) && label2)
+ if (pango_parse_markup(label, -1, '_', nullptr, &label2, nullptr, nullptr) && label2)
{
g_free(label);
label = label2;
if (tooltip)
{
- gtk_tree_store_append(accel_store, &iter, NULL);
+ gtk_tree_store_append(accel_store, &iter, nullptr);
gtk_tree_store_set(accel_store, &iter,
AE_ACTION, label,
AE_KEY, accel,
if (!accel_store) return;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data));
- gtk_tree_selection_selected_foreach(selection, &accel_clear_selection, NULL);
+ gtk_tree_selection_selected_foreach(selection, &accel_clear_selection, nullptr);
}
static void accel_reset_cb(GtkWidget *UNUSED(widget), gpointer data)
if (!accel_store) return;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data));
- gtk_tree_selection_selected_foreach(selection, &accel_reset_selection, NULL);
+ gtk_tree_selection_selected_foreach(selection, &accel_reset_selection, nullptr);
}
GtkWidget *scrolled;
GtkWidget *viewport;
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled, label);
gtk_widget_show(scrolled);
- viewport = gtk_viewport_new(NULL, NULL);
+ viewport = gtk_viewport_new(nullptr, nullptr);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled), viewport);
gtk_widget_show(viewport);
static guint star_rating_symbol_test(GtkWidget *UNUSED(widget), gpointer data)
{
auto hbox = static_cast<GtkContainer *>(data);
- GString *str = g_string_new(NULL);
+ GString *str = g_string_new(nullptr);
GtkEntry *hex_code_entry;
gchar *hex_code_full;
gchar **hex_code;
hex_code = g_strsplit(hex_code_full, "+", 2);
if (hex_code[0] && hex_code[1])
{
- hex_value = strtoull(hex_code[1], NULL, 16);
+ hex_value = strtoull(hex_code[1], nullptr, 16);
}
if (!hex_value || hex_value > 0x10FFFF)
{
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Custom size: "));
- pref_spin_new_int(hbox, _("Width:"), NULL, 1, 512, 1, options->thumbnails.max_width, &c_options->thumbnails.max_width);
- pref_spin_new_int(hbox, _("Height:"), NULL, 1, 512, 1, options->thumbnails.max_height, &c_options->thumbnails.max_height);
+ pref_spin_new_int(hbox, _("Width:"), nullptr, 1, 512, 1, options->thumbnails.max_width, &c_options->thumbnails.max_width);
+ pref_spin_new_int(hbox, _("Height:"), nullptr, 1, 512, 1, options->thumbnails.max_height, &c_options->thumbnails.max_height);
ct_button = pref_checkbox_new_int(group, _("Cache thumbnails and sim. files"),
options->thumbnails.enable_caching, &c_options->thumbnails.enable_caching);
c_options->thumbnails.cache_into_dirs = options->thumbnails.cache_into_dirs;
group_frame = pref_frame_new(subgroup, TRUE, _("Use Geeqie thumbnail style and cache"),
GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
- button = pref_radiobutton_new(group_frame, NULL, get_thumbnails_cache_dir(),
+ button = pref_radiobutton_new(group_frame, nullptr, get_thumbnails_cache_dir(),
!options->thumbnails.spec_standard && !options->thumbnails.cache_into_dirs,
- G_CALLBACK(cache_geeqie_cb), NULL);
+ G_CALLBACK(cache_geeqie_cb), nullptr);
group_frame = pref_frame_new(subgroup, TRUE,
_("Store thumbnails local to image folder (non-standard)"),
GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_radiobutton_new(group_frame, button, "*/.thumbnails",
!options->thumbnails.spec_standard && options->thumbnails.cache_into_dirs,
- G_CALLBACK(cache_local_cb), NULL);
+ G_CALLBACK(cache_local_cb), nullptr);
group_frame = pref_frame_new(subgroup, TRUE,
_("Use standard thumbnail style and cache, shared with other applications"),
GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_radiobutton_new(group_frame, button, get_thumbnails_standard_cache_dir(),
options->thumbnails.spec_standard && !options->thumbnails.cache_into_dirs,
- G_CALLBACK(cache_standard_cb), NULL);
+ G_CALLBACK(cache_standard_cb), nullptr);
pref_checkbox_new_int(group, _("Use EXIF thumbnails when available (EXIF thumbnails may be outdated)"),
options->thumbnails.use_exif, &c_options->thumbnails.use_exif);
pref_checkbox_new_int(group, _("Thumbnail color management"),
options->thumbnails.use_color_management, &c_options->thumbnails.use_color_management);
- spin = pref_spin_new_int(group, _("Collection preview:"), NULL,
+ spin = pref_spin_new_int(group, _("Collection preview:"), nullptr,
1, 999, 1,
options->thumbnails.collection_preview, &c_options->thumbnails.collection_preview);
gtk_widget_set_tooltip_text(spin, _("The maximum number of thumbnails shown in a Collection preview montage"));
c_options->star_rating.star = options->star_rating.star;
c_options->star_rating.rejected = options->star_rating.rejected;
- str = g_string_new(NULL);
+ str = g_string_new(nullptr);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Star character: "));
str = g_string_append_unichar(str, options->star_rating.star);
gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
gtk_widget_show(star_rating_entry);
- button = pref_button_new(NULL, NULL, _("Set"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Set"), FALSE,
G_CALLBACK(star_rating_star_test_cb), hbox);
gtk_widget_set_tooltip_text(button, _("Display selected character"));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_string_free(str, TRUE);
g_free(rating_symbol);
- str = g_string_new(NULL);
+ str = g_string_new(nullptr);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Rejected character: "));
str = g_string_append_unichar(str, options->star_rating.rejected);
gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
gtk_widget_show(star_rating_entry);
- button = pref_button_new(NULL, NULL, _("Set"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Set"), FALSE,
G_CALLBACK(star_rating_rejected_test_cb), hbox);
gtk_widget_set_tooltip_text(button, _("Display selected character"));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
- spin = pref_spin_new(hbox, _("Delay between image change hrs:mins:secs.dec"), NULL,
+ spin = pref_spin_new(hbox, _("Delay between image change hrs:mins:secs.dec"), nullptr,
0, 23, 1.0, 0,
options->slideshow.delay ? hours : 0.0,
- G_CALLBACK(slideshow_delay_hours_cb), NULL);
+ G_CALLBACK(slideshow_delay_hours_cb), nullptr);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
- spin = pref_spin_new(hbox, ":" , NULL,
+ spin = pref_spin_new(hbox, ":" , nullptr,
0, 59, 1.0, 0,
options->slideshow.delay ? minutes: 0.0,
- G_CALLBACK(slideshow_delay_minutes_cb), NULL);
+ G_CALLBACK(slideshow_delay_minutes_cb), nullptr);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
- spin = pref_spin_new(hbox, ":", NULL,
+ spin = pref_spin_new(hbox, ":", nullptr,
SLIDESHOW_MIN_SECONDS, 59, 1.0, 1,
options->slideshow.delay ? seconds : 10.0,
- G_CALLBACK(slideshow_delay_seconds_cb), NULL);
+ G_CALLBACK(slideshow_delay_seconds_cb), nullptr);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
pref_checkbox_new_int(group, _("Random"), options->slideshow.random, &c_options->slideshow.random);
group = pref_group_new(vbox, FALSE, _("Image loading and caching"), GTK_ORIENTATION_VERTICAL);
- pref_spin_new_int(group, _("Decoded image cache size (MiB):"), NULL,
+ pref_spin_new_int(group, _("Decoded image cache size (MiB):"), nullptr,
0, 99999, 1, options->image.image_cache_max, &c_options->image.image_cache_max);
pref_checkbox_new_int(group, _("Preload next image"),
options->image.enable_read_ahead, &c_options->image.enable_read_ahead);
net_mon = g_network_monitor_get_default();
- tz_org = g_network_address_parse_uri(TIMEZONE_DATABASE_WEB, 80, NULL);
+ tz_org = g_network_address_parse_uri(TIMEZONE_DATABASE_WEB, 80, nullptr);
if (tz_org)
{
- internet_available = g_network_monitor_can_reach(net_mon, tz_org, NULL, NULL);
+ internet_available = g_network_monitor_can_reach(net_mon, tz_org, nullptr, nullptr);
g_object_unref(tz_org);
}
if (isfile(tz->timezone_database_user))
{
- button = pref_button_new(GTK_WIDGET(hbox), NULL, _("Update"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
+ button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Update"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
}
else
{
- button = pref_button_new(GTK_WIDGET(hbox), NULL, _("Install"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
+ button = pref_button_new(GTK_WIDGET(hbox), nullptr, _("Install"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
}
download_locn = g_strconcat(_("Download database from: "), TIMEZONE_DATABASE_WEB, NULL);
//~ }
c_options->image.zoom_increment = options->image.zoom_increment;
- spin = pref_spin_new(group, _("Zoom increment:"), NULL,
+ spin = pref_spin_new(group, _("Zoom increment:"), nullptr,
0.01, 4.0, 0.01, 2, static_cast<gdouble>(options->image.zoom_increment) / 100.0,
- G_CALLBACK(zoom_increment_cb), NULL);
+ G_CALLBACK(zoom_increment_cb), nullptr);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
c_options->image.zoom_style = options->image.zoom_style;
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
enlargement_button = pref_checkbox_new_int(hbox, _("Allow enlargement of image (max. size in %)"),
options->image.zoom_to_fit_allow_expand, &c_options->image.zoom_to_fit_allow_expand);
- spin = pref_spin_new_int(hbox, NULL, NULL,
+ spin = pref_spin_new_int(hbox, nullptr, nullptr,
100, 999, 1,
options->image.max_enlargement_size, &c_options->image.max_enlargement_size);
pref_checkbox_link_sensitivity(enlargement_button, spin);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
ct_button = pref_checkbox_new_int(hbox, _("Virtual window size (% of actual window):"),
options->image.limit_autofit_size, &c_options->image.limit_autofit_size);
- spin = pref_spin_new_int(hbox, NULL, NULL,
+ spin = pref_spin_new_int(hbox, nullptr, nullptr,
10, 150, 1,
options->image.max_autofit_size, &c_options->image.max_autofit_size);
pref_checkbox_link_sensitivity(ct_button, spin);
static void save_default_window_layout_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
gchar *default_path;
gchar *tmp_id;
subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(subgroup, _("Use current layout for default: "));
- button = pref_button_new(subgroup, NULL, _("Set"), FALSE, G_CALLBACK(save_default_window_layout_cb), NULL);
+ button = pref_button_new(subgroup, nullptr, _("Set"), FALSE, G_CALLBACK(save_default_window_layout_cb), nullptr);
GtkWidget *popover;
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
ct_button = pref_checkbox_new_int(hbox, _("Limit size when auto-sizing window (%):"),
options->image.limit_window_size, &c_options->image.limit_window_size);
- spin = pref_spin_new_int(hbox, NULL, NULL,
+ spin = pref_spin_new_int(hbox, nullptr, nullptr,
10, 150, 1,
options->image.max_window_size, &c_options->image.max_window_size);
pref_checkbox_link_sensitivity(ct_button, spin);
pref_label_new(group, _("Image overlay template"));
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_widget_set_size_request(scrolled, 200, 150);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(NULL, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
G_CALLBACK(image_overlay_set_font_cb), notebook);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_COLOR_PICKER, _("Text"), FALSE,
- G_CALLBACK(image_overlay_set_text_colour_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_COLOR_PICKER, _("Text"), FALSE,
+ G_CALLBACK(image_overlay_set_text_colour_cb), nullptr);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_COLOR_PICKER, _("Background"), FALSE,
- G_CALLBACK(image_overlay_set_background_colour_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_COLOR_PICKER, _("Background"), FALSE,
+ G_CALLBACK(image_overlay_set_background_colour_cb), nullptr);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
image_overlay_set_text_colours();
- button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
G_CALLBACK(image_overlay_default_template_cb), image_overlay_template_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
- G_CALLBACK(image_overlay_help_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
+ G_CALLBACK(image_overlay_help_cb), nullptr);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
G_CALLBACK(filter_disable_cb), frame);
gtk_widget_set_sensitive(frame, !options->file_filter.disable);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
G_CALLBACK(filter_store_enable_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_ENABLE), NULL);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_ENABLED, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_ENABLED), NULL);
+ GINT_TO_POINTER(FE_ENABLE), nullptr);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_ENABLED, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_ENABLED), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_ENABLED);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Filter"));
gtk_tree_view_column_set_resizable(column, TRUE);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_FILTER, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_FILTER), NULL);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_FILTER, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_FILTER), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_FILTER);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_object_set(G_OBJECT(renderer), "editable", static_cast<gboolean>TRUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_EXTENSION), NULL);
+ GINT_TO_POINTER(FE_EXTENSION), nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(filter_view), FILETYPES_COLUMN_FILTER);
- gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(filter_view), search_function_cb, NULL, NULL);
+ gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(filter_view), search_function_cb, nullptr, nullptr);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Description"));
g_object_set(G_OBJECT(renderer), "editable", static_cast<gboolean>TRUE, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_DESCRIPTION), NULL);
+ GINT_TO_POINTER(FE_DESCRIPTION), nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_DESCRIPTION, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_DESCRIPTION), NULL);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_DESCRIPTION, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_DESCRIPTION), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_DESCRIPTION);
column = gtk_tree_view_column_new();
G_CALLBACK(filter_store_class_edit_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_CLASS), NULL);
+ GINT_TO_POINTER(FE_CLASS), nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_CLASS, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_CLASS), NULL);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_CLASS, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_CLASS), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_CLASS);
column = gtk_tree_view_column_new();
G_CALLBACK(filter_store_writable_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_WRITABLE), NULL);
+ GINT_TO_POINTER(FE_WRITABLE), nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_WRITABLE, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_WRITABLE), NULL);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_WRITABLE, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_WRITABLE), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_WRITABLE);
column = gtk_tree_view_column_new();
G_CALLBACK(filter_store_sidecar_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
- GINT_TO_POINTER(FE_ALLOW_SIDECAR), NULL);
+ GINT_TO_POINTER(FE_ALLOW_SIDECAR), nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
- gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_SIDECAR, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_SIDECAR), NULL);
+ gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_SIDECAR, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_SIDECAR), nullptr);
gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_SIDECAR);
filter_store_populate();
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
G_CALLBACK(filter_default_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_REMOVE, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_REMOVE, nullptr, FALSE,
G_CALLBACK(filter_remove_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_ADD, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_ADD, nullptr, FALSE,
G_CALLBACK(filter_add_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(ct_button, hbox);
- pref_spin_new_int(hbox, _("Timeout (seconds):"), NULL, 0, 900, 1, options->metadata.confirm_timeout, &c_options->metadata.confirm_timeout);
+ pref_spin_new_int(hbox, _("Timeout (seconds):"), nullptr, 0, 900, 1, options->metadata.confirm_timeout, &c_options->metadata.confirm_timeout);
pref_checkbox_new_int(group, _("Write metadata on image change"), options->metadata.confirm_on_image_change, &c_options->metadata.confirm_on_image_change);
static void keywords_find_folder(KeywordFindData *kfd, FileData *dir_fd)
{
- GList *list_d = NULL;
- GList *list_f = NULL;
+ GList *list_d = nullptr;
+ GList *list_f = nullptr;
if (kfd->recurse)
{
}
else
{
- filelist_read(dir_fd, &list_f, NULL);
+ filelist_read(dir_fd, &list_f, nullptr);
}
list_f = filelist_filter(list_f, FALSE);
static void keywords_find_reset(KeywordFindData *kfd)
{
filelist_free(kfd->list);
- kfd->list = NULL;
+ kfd->list = nullptr;
filelist_free(kfd->list_dir);
- kfd->list_dir = NULL;
+ kfd->list_dir = nullptr;
}
static void keywords_find_close_cb(GenericDialog *UNUSED(fd), gpointer data)
kfd->gd = generic_dialog_new(_("Search for keywords"),
"search_for_keywords",
widget, FALSE,
- NULL, kfd);
+ nullptr, kfd);
gtk_window_set_default_size(GTK_WINDOW(kfd->gd->dialog), KEYWORD_DIALOG_WIDTH, -1);
kfd->gd->cancel_cb = keywords_find_close_cb;
- kfd->button_close = generic_dialog_add_button(kfd->gd, GTK_STOCK_CLOSE, NULL,
+ kfd->button_close = generic_dialog_add_button(kfd->gd, GTK_STOCK_CLOSE, nullptr,
keywords_find_close_cb, FALSE);
kfd->button_start = generic_dialog_add_button(kfd->gd, GTK_STOCK_OK, _("S_tart"),
keywords_find_start_cb, FALSE);
- kfd->button_stop = generic_dialog_add_button(kfd->gd, GTK_STOCK_STOP, NULL,
+ kfd->button_stop = generic_dialog_add_button(kfd->gd, GTK_STOCK_STOP, nullptr,
keywords_find_stop_cb, FALSE);
gtk_widget_set_sensitive(kfd->button_stop, FALSE);
- generic_dialog_add_message(kfd->gd, NULL, _("Search for keywords"), NULL, FALSE);
+ generic_dialog_add_message(kfd->gd, nullptr, _("Search for keywords"), nullptr, FALSE);
hbox = pref_box_new(kfd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
hbox = pref_box_new(kfd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- label = tab_completion_new(&kfd->entry, path, NULL, NULL, NULL, NULL);
+ label = tab_completion_new(&kfd->entry, path, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(kfd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), kfd->progress, TRUE, TRUE, 0);
gtk_widget_show(kfd->progress);
- kfd->spinner = spinner_new(NULL, -1);
+ kfd->spinner = spinner_new(nullptr, -1);
gtk_box_pack_start(GTK_BOX(hbox), kfd->spinner, FALSE, FALSE, 0);
gtk_widget_show(kfd->spinner);
- kfd->list = NULL;
+ kfd->list = nullptr;
gtk_widget_show(kfd->gd->dialog);
}
static void keywords_find_cb(GtkWidget *widget, gpointer UNUSED(data))
{
- const gchar *path = layout_get_path(NULL);
+ const gchar *path = layout_get_path(nullptr);
if (!path || !*path) path = homedir();
keywords_find_dialog(widget, path);
{
GtkTextIter start, end;
GtkTextBuffer *buffer;
- GList *kw_list = NULL;
+ GList *kw_list = nullptr;
GList *work;
gchar *buffer_text;
gchar *kw_split;
buffer_text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
kw_split = strtok(buffer_text, "\n");
- while (kw_split != NULL)
+ while (kw_split != nullptr)
{
work = kw_list;
found = FALSE;
{
kw_list = g_list_append(kw_list, g_strdup(kw_split));
}
- kw_split = strtok(NULL, "\n");
+ kw_split = strtok(nullptr, "\n");
}
keyword_list_set(kw_list);
keyword_text = gtk_text_view_new();
gtk_widget_set_size_request(keyword_text, 20, 20);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
gtk_widget_show(entry);
color_profile_input_name_entry[i] = entry;
- tabcomp = tab_completion_new(&entry, options->color_profile.input_file[i], NULL, ".icc", "ICC Files", NULL);
+ tabcomp = tab_completion_new(&entry, options->color_profile.input_file[i], nullptr, ".icc", "ICC Files", nullptr);
tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
pref_table_label(table, 0, 0, _("Screen:"), 1.0);
tabcomp = tab_completion_new(&color_profile_screen_file_entry,
- options->color_profile.screen_file, NULL, ".icc", "ICC Files", NULL);
+ options->color_profile.screen_file, nullptr, ".icc", "ICC Files", nullptr);
tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
#ifdef HAVE_LCMS
pref_checkbox_new_int(group, _("Enable Delete key"),
options->file_ops.enable_delete_key, &c_options->file_ops.enable_delete_key);
- ct_button = pref_radiobutton_new(group, NULL, _("Use Geeqie trash location"),
- !options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_geeqie_trash_cb),NULL);
+ ct_button = pref_radiobutton_new(group, nullptr, _("Use Geeqie trash location"),
+ !options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_geeqie_trash_cb),nullptr);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
- tabcomp = tab_completion_new(&safe_delete_path_entry, options->file_ops.safe_delete_path, NULL, NULL, NULL, NULL);
- tab_completion_add_select_button(safe_delete_path_entry, NULL, TRUE);
+ tabcomp = tab_completion_new(&safe_delete_path_entry, options->file_ops.safe_delete_path, nullptr, nullptr, nullptr, nullptr);
+ tab_completion_add_select_button(safe_delete_path_entry, nullptr, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
spin = pref_spin_new_int(hbox, _("Maximum size:"), _("MiB"),
0, 2048, 1, options->file_ops.safe_delete_folder_maxsize, &c_options->file_ops.safe_delete_folder_maxsize);
gtk_widget_set_tooltip_markup(spin, _("Set to 0 for unlimited size"));
- button = pref_button_new(NULL, NULL, _("View"), FALSE,
- G_CALLBACK(safe_delete_view_cb), NULL);
+ button = pref_button_new(nullptr, nullptr, _("View"), FALSE,
+ G_CALLBACK(safe_delete_view_cb), nullptr);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_CLEAR, NULL, FALSE,
- G_CALLBACK(safe_delete_clear_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_CLEAR, nullptr, FALSE,
+ G_CALLBACK(safe_delete_clear_cb), nullptr);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
c_options->file_ops.no_trash = options->file_ops.no_trash;
c_options->file_ops.use_system_trash = options->file_ops.use_system_trash;
pref_radiobutton_new(group, ct_button, _("Use system Trash bin"),
- options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_system_trash_cb), NULL);
+ options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_system_trash_cb), nullptr);
pref_radiobutton_new(group, ct_button, _("Use no trash at all"),
- options->file_ops.no_trash, G_CALLBACK(use_no_cache_cb), NULL);
+ options->file_ops.no_trash, G_CALLBACK(use_no_cache_cb), nullptr);
gtk_widget_show(button);
options->hide_window_in_fullscreen, &c_options->hide_window_in_fullscreen);
gtk_widget_set_tooltip_text(hide_window_in_fullscreen,"When alt-tabbing, prevent Geeqie window showing twice");
- pref_spin_new_int(group, _("Recent folder list maximum size"), NULL,
+ pref_spin_new_int(group, _("Recent folder list maximum size"), nullptr,
1, 50, 1, options->open_recent_list_maxsize, &c_options->open_recent_list_maxsize);
- tmp = pref_spin_new_int(group, _("Recent folder-image list maximum size"), NULL, 0, 50, 1, options->recent_folder_image_list_maxsize, &c_options->recent_folder_image_list_maxsize);
+ tmp = pref_spin_new_int(group, _("Recent folder-image list maximum size"), nullptr, 0, 50, 1, options->recent_folder_image_list_maxsize, &c_options->recent_folder_image_list_maxsize);
gtk_widget_set_tooltip_text(tmp, _("List of the last image viewed in each recent folder.\nRe-opening a folder will set focus to the last image viewed."));
- pref_spin_new_int(group, _("Drag'n drop icon size"), NULL,
+ pref_spin_new_int(group, _("Drag'n drop icon size"), nullptr,
16, 256, 16, options->dnd_icon_size, &c_options->dnd_icon_size);
table = pref_table_new(group, 2, 1, FALSE, FALSE);
pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
options->progressive_key_scrolling, &c_options->progressive_key_scrolling);
- pref_spin_new_int(group, _("Keyboard scrolling step multiplier:"), NULL,
+ pref_spin_new_int(group, _("Keyboard scrolling step multiplier:"), nullptr,
1, 32, 1, options->keyboard_scroll_step, reinterpret_cast<int *>(&c_options->keyboard_scroll_step));
pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
options->mousewheel_scrolls, &c_options->mousewheel_scrolls);
group = pref_group_new(vbox, FALSE, _("Debugging"), GTK_ORIENTATION_VERTICAL);
- pref_spin_new_int(group, _("Debug level:"), NULL,
+ pref_spin_new_int(group, _("Debug level:"), nullptr,
DEBUG_LEVEL_MIN, DEBUG_LEVEL_MAX, 1, get_debug_level(), &debug_c);
pref_checkbox_new_int(group, _("Timer data"),
options->log_window.timer_data, &c_options->log_window.timer_data);
- pref_spin_new_int(group, _("Log Window max. lines:"), NULL,
+ pref_spin_new_int(group, _("Log Window max. lines:"), nullptr,
1, 99999, 1, options->log_window_lines, &options->log_window_lines);
#endif
}
group = pref_group_new(vbox, TRUE, _("Accelerators"), GTK_ORIENTATION_VERTICAL);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Defaults"), FALSE,
G_CALLBACK(accel_default_cb), accel_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, NULL, _("Reset selected"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Reset selected"), FALSE,
G_CALLBACK(accel_reset_cb), accel_view);
gtk_widget_set_tooltip_text(button, _("Will only reset changes made before the settings are saved"));
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- button = pref_button_new(NULL, NULL, _("Clear selected"), FALSE,
+ button = pref_button_new(nullptr, nullptr, _("Clear selected"), FALSE,
G_CALLBACK(accel_clear_cb), accel_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
GtkWidget *vbox;
GtkWidget *group;
GSList *formats_list;
- GList *extensions_list = NULL;
+ GList *extensions_list = nullptr;
gchar **extensions;
GtkWidget *tabcomp;
GdkPixbufFormat *fm;
gint i;
- GString *types_string = g_string_new(NULL);
+ GString *types_string = g_string_new(nullptr);
GtkWidget *types_string_label;
GtkWidget *threads_string_label;
GtkWidget *dupes_threads_spin;
group = pref_group_new(vbox, FALSE, _("File identification tool"), GTK_ORIENTATION_VERTICAL);
external_preview_select_entry = gtk_entry_new();
- tabcomp = tab_completion_new(&external_preview_select_entry, options->external_preview.select, NULL, NULL, NULL, NULL);
+ tabcomp = tab_completion_new(&external_preview_select_entry, options->external_preview.select, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(external_preview_select_entry, _("Select file identification tool"), FALSE);
gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
group = pref_group_new(vbox, FALSE, _("Preview extraction tool"), GTK_ORIENTATION_VERTICAL);
external_preview_extract_entry = gtk_entry_new();
- tabcomp = tab_completion_new(&external_preview_extract_entry, options->external_preview.extract, NULL, NULL, NULL, NULL);
+ tabcomp = tab_completion_new(&external_preview_extract_entry, options->external_preview.extract, nullptr, nullptr, nullptr, nullptr);
tab_completion_add_select_button(external_preview_extract_entry, _("Select preview extraction tool"), FALSE);
gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
add_stereo_mode_menu(table, 0, 0, _("Windowed stereo mode"), options->stereo.mode, &c_options->stereo.mode, FALSE);
table = pref_table_new(group, 2, 2, TRUE, FALSE);
- box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Mirror left image"),
options->stereo.mode & PR_STEREO_MIRROR_LEFT, &c_options->stereo.tmp.mirror_left);
- box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Flip left image"),
options->stereo.mode & PR_STEREO_FLIP_LEFT, &c_options->stereo.tmp.flip_left);
- box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Mirror right image"),
options->stereo.mode & PR_STEREO_MIRROR_RIGHT, &c_options->stereo.tmp.mirror_right);
- box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Flip right image"),
options->stereo.mode & PR_STEREO_FLIP_RIGHT, &c_options->stereo.tmp.flip_right);
pref_checkbox_new_int(group, _("Swap left and right images"),
table = pref_table_new(box2, 2, 1, FALSE, FALSE);
add_stereo_mode_menu(table, 0, 0, _("Fullscreen stereo mode"), options->stereo.fsmode, &c_options->stereo.fsmode, TRUE);
table = pref_table_new(box2, 2, 2, TRUE, FALSE);
- box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Mirror left image"),
options->stereo.fsmode & PR_STEREO_MIRROR_LEFT, &c_options->stereo.tmp.fs_mirror_left);
- box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Flip left image"),
options->stereo.fsmode & PR_STEREO_FLIP_LEFT, &c_options->stereo.tmp.fs_flip_left);
- box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Mirror right image"),
options->stereo.fsmode & PR_STEREO_MIRROR_RIGHT, &c_options->stereo.tmp.fs_mirror_right);
- box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
+ box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_checkbox_new_int(box, _("Flip right image"),
options->stereo.fsmode & PR_STEREO_FLIP_RIGHT, &c_options->stereo.tmp.fs_flip_right);
pref_checkbox_new_int(box2, _("Swap left and right images"),
group2 = pref_group_new(box2, FALSE, _("Fixed position"), GTK_ORIENTATION_VERTICAL);
table = pref_table_new(group2, 5, 3, FALSE, FALSE);
- pref_table_spin_new_int(table, 0, 0, _("Width"), NULL,
+ pref_table_spin_new_int(table, 0, 0, _("Width"), nullptr,
1, 5000, 1, options->stereo.fixed_w, &c_options->stereo.fixed_w);
- pref_table_spin_new_int(table, 3, 0, _("Height"), NULL,
+ pref_table_spin_new_int(table, 3, 0, _("Height"), nullptr,
1, 5000, 1, options->stereo.fixed_h, &c_options->stereo.fixed_h);
- pref_table_spin_new_int(table, 0, 1, _("Left X"), NULL,
+ pref_table_spin_new_int(table, 0, 1, _("Left X"), nullptr,
0, 5000, 1, options->stereo.fixed_x1, &c_options->stereo.fixed_x1);
- pref_table_spin_new_int(table, 3, 1, _("Left Y"), NULL,
+ pref_table_spin_new_int(table, 3, 1, _("Left Y"), nullptr,
0, 5000, 1, options->stereo.fixed_y1, &c_options->stereo.fixed_y1);
- pref_table_spin_new_int(table, 0, 2, _("Right X"), NULL,
+ pref_table_spin_new_int(table, 0, 2, _("Right X"), nullptr,
0, 5000, 1, options->stereo.fixed_x2, &c_options->stereo.fixed_x2);
- pref_table_spin_new_int(table, 3, 2, _("Right Y"), NULL,
+ pref_table_spin_new_int(table, 3, 2, _("Right Y"), nullptr,
0, 5000, 1, options->stereo.fixed_y2, &c_options->stereo.fixed_y2);
}
GtkWidget *button;
GtkWidget *ct_button;
- if (!c_options) c_options = init_options(NULL);
+ if (!c_options) c_options = init_options(nullptr);
- configwindow = window_new(GTK_WINDOW_TOPLEVEL, "preferences", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Preferences"));
+ configwindow = window_new(GTK_WINDOW_TOPLEVEL, "preferences", PIXBUF_INLINE_ICON_CONFIG, nullptr, _("Preferences"));
DEBUG_NAME(configwindow);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(configwindow), "delete_event",
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
- button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_HELP, nullptr, FALSE,
G_CALLBACK(config_window_help_cb), notebook);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
- button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_OK, nullptr, FALSE,
G_CALLBACK(config_window_ok_cb), notebook);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
ct_button = button;
- button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
- G_CALLBACK(config_window_close_cb), NULL);
+ button = pref_button_new(nullptr, GTK_STOCK_CANCEL, nullptr, FALSE,
+ G_CALLBACK(config_window_close_cb), nullptr);
gtk_container_add(GTK_CONTAINER(hbox), button);
gtk_widget_set_can_default(button, TRUE);
gtk_widget_show(button);
gsize size;
guint32 flags;
- copyright = g_string_new(NULL);
+ copyright = g_string_new(nullptr);
copyright = g_string_append(copyright, "This program comes with absolutely no warranty.\nGNU General Public License, version 2 or later.\nSee https://www.gnu.org/licenses/old-licenses/gpl-2.0.html\n\n");
timezone_path = g_build_filename(get_rc_dir(), TIMEZONE_DATABASE_FILE, NULL);
authors_path = g_build_filename(GQ_RESOURCE_PATH_CREDITS, "authors", NULL);
- in_stream_authors = g_resources_open_stream(authors_path, G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
+ in_stream_authors = g_resources_open_stream(authors_path, G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr);
data_stream = g_data_input_stream_new(in_stream_authors);
- authors[0] = NULL;
- while ((author_line = g_data_input_stream_read_line(G_DATA_INPUT_STREAM(data_stream), &length, NULL, NULL)))
+ authors[0] = nullptr;
+ while ((author_line = g_data_input_stream_read_line(G_DATA_INPUT_STREAM(data_stream), &length, nullptr, nullptr)))
{
authors[i_authors] = g_strdup(author_line);
i_authors++;
g_free(author_line);
}
- authors[i_authors] = NULL;
+ authors[i_authors] = nullptr;
- g_input_stream_close(in_stream_authors, NULL, NULL);
+ g_input_stream_close(in_stream_authors, nullptr, nullptr);
translators_path = g_build_filename(GQ_RESOURCE_PATH_CREDITS, "translators", NULL);
- g_resources_get_info(translators_path, G_RESOURCE_LOOKUP_FLAGS_NONE, &size, &flags, NULL);
+ g_resources_get_info(translators_path, G_RESOURCE_LOOKUP_FLAGS_NONE, &size, &flags, nullptr);
- in_stream_translators = g_resources_open_stream(translators_path, G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
+ in_stream_translators = g_resources_open_stream(translators_path, G_RESOURCE_LOOKUP_FLAGS_NONE, nullptr);
translators = static_cast<gchar *>(g_malloc0(size));
- g_input_stream_read_all(in_stream_translators, translators, size, &bytes_read, NULL, NULL);
- g_input_stream_close(in_stream_translators, NULL, NULL);
+ g_input_stream_read_all(in_stream_translators, translators, size, &bytes_read, nullptr, nullptr);
+ g_input_stream_close(in_stream_translators, nullptr, nullptr);
comment = g_strconcat("Project created by John Ellis\nGQview 1998\nGeeqie 2007\n\n\nDevelopment and bug reports:\n", GQ_EMAIL_ADDRESS, "\nhttps://github.com/BestImageViewer/geeqie/issues",NULL);
artists[0] = g_strdup("Néstor DÃaz Valencia <nestor@estudionexos.com>");
- artists[1] = NULL;
+ artists[1] = nullptr;
pixbuf_logo = pixbuf_inline(PIXBUF_INLINE_LOGO);
pixbuf_icon = pixbuf_inline(PIXBUF_INLINE_ICON);
static void timezone_async_ready_cb(GObject *source_object, GAsyncResult *res, gpointer data)
{
- GError *error = NULL;
+ GError *error = nullptr;
auto tz = static_cast<TZData *>(data);
gchar *tmp_filename;
gchar *timezone_bin;
- gchar *tmp_dir = NULL;
+ gchar *tmp_dir = nullptr;
FileData *fd;
if (!g_cancellable_is_cancelled(tz->cancellable))
}
else
{
- warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
g_free(timezone_bin);
}
else
{
- warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
g_free(tmp_filename);
file_data_unref(fd);
}
else
{
- file_util_warning_dialog(_("Error: Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Error: Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
}
- g_file_delete(tz->tmp_g_file, NULL, &error);
+ g_file_delete(tz->tmp_g_file, nullptr, &error);
g_object_unref(tz->tmp_g_file);
- tz->tmp_g_file = NULL;
+ tz->tmp_g_file = nullptr;
g_object_unref(tz->cancellable);
g_object_unref(tz->timezone_database_gq);
}
static void timezone_database_install_cb(GtkWidget *widget, gpointer data)
{
auto tz = static_cast<TZData *>(data);
- GError *error = NULL;
+ GError *error = nullptr;
GFileIOStream *io_stream;
if (tz->tmp_g_file)
if (error)
{
- file_util_warning_dialog(_("Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
log_printf("Error: Download timezone database failed:\n%s", error->message);
g_error_free(error);
g_object_unref(tz->tmp_g_file);
{
tz->timezone_database_gq = g_file_new_for_uri(TIMEZONE_DATABASE_WEB);
- tz->gd = generic_dialog_new(_("Timezone database"), "download_timezone_database", NULL, TRUE, timezone_cancel_button_cb, tz);
+ tz->gd = generic_dialog_new(_("Timezone database"), "download_timezone_database", nullptr, TRUE, timezone_cancel_button_cb, tz);
- generic_dialog_add_message(tz->gd, GTK_STOCK_DIALOG_INFO, _("Downloading timezone database"), NULL, FALSE);
+ generic_dialog_add_message(tz->gd, GTK_STOCK_DIALOG_INFO, _("Downloading timezone database"), nullptr, FALSE);
tz->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(tz->gd->vbox), tz->progress, FALSE, FALSE, 0);
pw->print_pixbuf_queue = g_list_append(pw->print_pixbuf_queue, pixbuf);
image_loader_free(pw->job_loader);
- pw->job_loader = NULL;
+ pw->job_loader = nullptr;
pw->job_page++;
static gboolean print_job_render_image(PrintWindow *pw)
{
- FileData *fd = NULL;
+ FileData *fd = nullptr;
fd = static_cast<FileData *>(g_list_nth_data(pw->source_selection, pw->job_page));
if (!fd) return FALSE;
image_loader_free(pw->job_loader);
- pw->job_loader = NULL;
+ pw->job_loader = nullptr;
pw->job_loader = image_loader_new(fd);
g_signal_connect(G_OBJECT(pw->job_loader), "done",
if (!image_loader_start(pw->job_loader))
{
image_loader_free(pw->job_loader);
- pw->job_loader= NULL;
+ pw->job_loader= nullptr;
}
return TRUE;
gtk_box_pack_start(GTK_BOX(subgroup), hbox, FALSE, FALSE, 0);
/* order is important */
- button1 = pref_radiobutton_new(hbox, NULL, "Header 1",
+ button1 = pref_radiobutton_new(hbox, nullptr, "Header 1",
options->printer.image_text_position == HEADER_1,
G_CALLBACK(image_text_position_h1_cb), pw);
button1 = pref_radiobutton_new(hbox, button1, "Header 2",
gtk_widget_set_tooltip_markup(image_text_template_view,
_("Extensive formatting options are shown in the Help file"));
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_widget_set_size_request(scrolled, 200, 50);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
hbox = pref_box_new(subgroup, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(NULL, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
G_CALLBACK(print_set_font_cb), const_cast<char *>("Image text font"));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(subgroup), hbox, FALSE, FALSE, 0);
/* order is important */
- button2 = pref_radiobutton_new(hbox, NULL, "Header 1",
+ button2 = pref_radiobutton_new(hbox, nullptr, "Header 1",
options->printer.page_text_position == HEADER_1,
G_CALLBACK(page_text_position_h1_cb), pw);
button2 = pref_radiobutton_new(hbox, button2, "Header 2",
gtk_widget_show(hbox);
pw->page_group = (gtk_radio_button_get_group(GTK_RADIO_BUTTON(button2)));
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_widget_set_size_request(scrolled, 50, 50);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
hbox = pref_box_new(subgroup, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
- button = pref_button_new(NULL, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
+ button = pref_button_new(nullptr, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
G_CALLBACK(print_set_font_cb), const_cast<char *>("Page text font"));
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gchar *form_image_text(const gchar *template_string, FileData *fd, PrintWindow *pw, gint page_nr, gint total)
{
const gchar *name;
- gchar *text = NULL;
+ gchar *text = nullptr;
GHashTable *vars;
gchar *window_title;
gchar *delimiter;
gchar *collection_name;
- if (!fd) return NULL;
+ if (!fd) return nullptr;
name = fd->name;
- vars = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
+ vars = g_hash_table_new_full(g_str_hash, g_str_equal, nullptr, g_free);
window_title = g_strdup(gtk_window_get_title(GTK_WINDOW(pw->parent)));
delimiter = g_strstr_len(window_title, -1, " - Collection - ");
}
else
{
- collection_name = NULL;
+ collection_name = nullptr;
}
g_free(window_title);
}
else
{
- osd_template_insert(vars, "width", NULL, OSDT_NONE);
- osd_template_insert(vars, "height", NULL, OSDT_NONE);
- osd_template_insert(vars, "res", NULL, OSDT_NONE);
+ osd_template_insert(vars, "width", nullptr, OSDT_NONE);
+ osd_template_insert(vars, "height", nullptr, OSDT_NONE);
+ osd_template_insert(vars, "res", nullptr, OSDT_NONE);
}
text = image_osd_mkinfo(template_string, fd, vars);
gdouble width_offset;
gdouble height_offset;
GdkPixbuf *pixbuf;
- GdkPixbuf *rotated = NULL;
- PangoLayout *layout_image = NULL;
- PangoLayout *layout_page = NULL;
+ GdkPixbuf *rotated = nullptr;
+ PangoLayout *layout_image = nullptr;
+ PangoLayout *layout_page = nullptr;
PangoFontDescription *desc;
- GString *image_text = g_string_new(NULL);
- GString *page_text = g_string_new(NULL);
+ GString *image_text = g_string_new(nullptr);
+ GString *page_text = g_string_new(nullptr);
PangoRectangle ink_rect, logical_rect;
gdouble w, h, scale;
gdouble image_text_width, image_text_height, page_text_width, page_text_height;
gchar *path;
GtkPrintSettings *print_settings;
GtkPageSetup *page_setup;
- GError *error = NULL;
+ GError *error = nullptr;
print_settings = gtk_print_operation_get_print_settings(operation);
path = g_build_filename(get_rc_dir(), PRINT_SETTINGS, NULL);
{
log_printf("Error: Print settings save failed:\n%s", error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
}
g_free(path);
g_object_unref(print_settings);
{
log_printf("Error: Print page setup save failed:\n%s", error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
}
g_free(path);
g_object_unref(page_setup);
GtkPageSetup *page_setup;
gchar *uri;
const gchar *dir;
- GError *error = NULL;
+ GError *error = nullptr;
gchar *path;
GtkPrintSettings *settings;
pw = g_new0(PrintWindow, 1);
- pw->source_selection = file_data_process_groups_in_selection(selection, FALSE, NULL);
+ pw->source_selection = file_data_process_groups_in_selection(selection, FALSE, nullptr);
if (print_layout_page_count(pw) == 0)
{
print_text_menu(vbox, pw);
pw->vbox = vbox;
- pw->print_pixbuf_queue = NULL;
+ pw->print_pixbuf_queue = nullptr;
pw->job_render_finished = FALSE;
pw->job_page = 0;
gtk_print_operation_set_embed_page_setup(operation, TRUE);
gtk_print_operation_set_allow_async (operation, TRUE);
dir = g_get_user_special_dir(G_USER_DIRECTORY_DOCUMENTS);
- if (dir == NULL)
+ if (dir == nullptr)
{
dir = g_get_home_dir();
}
{
log_printf("Error: Printer settings load failed:\n%s", error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
}
gtk_print_operation_set_print_settings(operation, settings);
g_free(path);
{
log_printf("Error: Print page setup load failed:\n%s", error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
}
gtk_print_operation_set_default_page_setup(operation, page_setup);
g_free(path);
if (g_ascii_isdigit(value[0]) || (value[0] == '-' && g_ascii_isdigit(value[1])))
{
- *n = strtol(value, NULL, 10);
+ *n = strtol(value, nullptr, 10);
}
else
{
if (g_ascii_isdigit(value[0]))
{
- *n = strtoul(value, NULL, 10);
+ *n = strtoul(value, nullptr, 10);
}
else
{
if (g_ascii_isdigit(value[0]))
{
- *n = strtoul(value, NULL, 10);
+ *n = strtoul(value, nullptr, 10);
}
else
{
if (*ptr == '.')
{
*ptr = '\0';
- l = strtol(value, NULL, 10);
+ l = strtol(value, nullptr, 10);
*ptr = '.';
ptr++;
- r = strtol(ptr, NULL, 10);
+ r = strtol(ptr, nullptr, 10);
}
else
{
- l = strtol(value, NULL, 10);
+ l = strtol(value, nullptr, 10);
r = 0;
}
{
const gchar *option = *attribute_names++;
const gchar *value = *attribute_values++;
- tmp.path = NULL;
+ tmp.path = nullptr;
if (READ_CHAR_FULL("path", tmp.path))
{
options->disabled_plugins = g_list_append(options->disabled_plugins, g_strdup(tmp.path));
if (strcmp(option, "id") == 0) return value;
}
- return NULL;
+ return nullptr;
}
void options_parse_leaf(GQParserData *parser_data, GMarkupParseContext *UNUSED(context), const gchar *element_name, const gchar **UNUSED(attribute_names), const gchar **UNUSED(attribute_values), gpointer UNUSED(data), GError **UNUSED(error))
{
log_printf("unexpected: %s\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
static void options_parse_color_profiles(GQParserData *parser_data, GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer data, GError **error)
if (g_ascii_strcasecmp(element_name, "profile") == 0)
{
options_load_profile(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <profile>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "tooltip") == 0)
{
options_load_marks_tooltips(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <profile>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
// attribute_names will be {"enabled", "filter"} and attribute_values
// will be {"true", "RAW Image"}.
- const gchar *enabled_name = NULL;
- const gchar *enabled_value = NULL;
+ const gchar *enabled_name = nullptr;
+ const gchar *enabled_value = nullptr;
int format_class_index = -1;
// In this loop, we iterate through matching attribute/value pairs in
log_printf("unknown attribute %s = %s\n", option, value);
}
- if (enabled_name == NULL || enabled_value == NULL || format_class_index < 0)
+ if (enabled_name == nullptr || enabled_value == nullptr || format_class_index < 0)
{
log_printf("Failed to parse <filter_type> config element\n");
return;
if (g_ascii_strcasecmp(element_name, "filter_type") == 0)
{
class_filter_load_filter_type(attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <profile>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "plugin") == 0)
{
options_load_disabled_plugins(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <profile>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "file_type") == 0)
{
filter_load_file_type(attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <filter>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
else
{
log_printf("unexpected in <keyword>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
{
if (g_ascii_strcasecmp(element_name, "keyword") == 0)
{
- GtkTreeIter *iter_ptr = keyword_add_from_config(keyword_tree, NULL, attribute_names, attribute_values);
+ GtkTreeIter *iter_ptr = keyword_add_from_config(keyword_tree, nullptr, attribute_names, attribute_values);
options_parse_func_push(parser_data, options_parse_keyword, options_parse_keyword_end, iter_ptr);
}
else
{
log_printf("unexpected in <keyword_tree>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "color_profiles") == 0)
{
options_load_color_profiles(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_color_profiles, NULL, GINT_TO_POINTER(0));
+ options_parse_func_push(parser_data, options_parse_color_profiles, nullptr, GINT_TO_POINTER(0));
}
else if (g_ascii_strcasecmp(element_name, "filter") == 0)
{
- options_parse_func_push(parser_data, options_parse_filter, options_parse_filter_end, NULL);
+ options_parse_func_push(parser_data, options_parse_filter, options_parse_filter_end, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "marks_tooltips") == 0)
{
options_load_marks_tooltips(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_marks_tooltips, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_marks_tooltips, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "class_filter") == 0)
{
- options_parse_func_push(parser_data, options_parse_class_filter, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_class_filter, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "keyword_tree") == 0)
{
if (!keyword_tree) keyword_tree_new();
- options_parse_func_push(parser_data, options_parse_keyword_tree, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_keyword_tree, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "disabled_plugins") == 0)
{
options_load_disabled_plugins(parser_data, context, element_name, attribute_names, attribute_values, data, error);
- options_parse_func_push(parser_data, options_parse_disabled_plugins, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_disabled_plugins, nullptr, nullptr);
}
else
{
log_printf("unexpected in <global>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "entry") == 0)
{
bar_pane_exif_entry_add_from_config(pane, attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <pane_exif>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "expanded") == 0)
{
bar_pane_keywords_entry_add_from_config(pane, attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <pane_keywords>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
pane = bar_pane_comment_new_from_config(attribute_names, attribute_values);
bar_add(bar, pane);
}
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
#ifdef HAVE_LIBCHAMPLAIN
#ifdef HAVE_LIBCHAMPLAIN_GTK
pane = bar_pane_exif_new_from_config(attribute_names, attribute_values);
bar_add(bar, pane);
}
- options_parse_func_push(parser_data, options_parse_pane_exif, NULL, pane);
+ options_parse_func_push(parser_data, options_parse_pane_exif, nullptr, pane);
}
else if (g_ascii_strcasecmp(element_name, "pane_histogram") == 0)
{
pane = bar_pane_histogram_new_from_config(attribute_names, attribute_values);
bar_add(bar, pane);
}
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "pane_rating") == 0)
{
pane = bar_pane_rating_new_from_config(attribute_names, attribute_values);
bar_add(bar, pane);
}
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "pane_keywords") == 0)
{
pane = bar_pane_keywords_new_from_config(attribute_names, attribute_values);
bar_add(bar, pane);
}
- options_parse_func_push(parser_data, options_parse_pane_keywords, NULL, pane);
+ options_parse_func_push(parser_data, options_parse_pane_keywords, nullptr, pane);
}
else if (g_ascii_strcasecmp(element_name, "clear") == 0)
{
bar_clear(bar);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <bar>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "toolitem") == 0)
{
layout_toolbar_add_from_config(lw, TOOLBAR_MAIN, attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "clear") == 0)
{
layout_toolbar_clear(lw, TOOLBAR_MAIN);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <toolbar>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "toolitem") == 0)
{
layout_toolbar_add_from_config(lw, TOOLBAR_STATUS, attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "clear") == 0)
{
layout_toolbar_clear(lw, TOOLBAR_STATUS);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <statusbar>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "window") == 0)
{
generic_dialog_windows_load_config(attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else
{
log_printf("unexpected in <dialogs>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
bar_update_from_config(lw->bar, attribute_names, attribute_values, lw, FALSE);
}
- options_parse_func_push(parser_data, options_parse_bar, NULL, lw->bar);
+ options_parse_func_push(parser_data, options_parse_bar, nullptr, lw->bar);
}
else if (g_ascii_strcasecmp(element_name, "bar_sort") == 0)
{
bar_sort_cold_start(lw, attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
else if (g_ascii_strcasecmp(element_name, "toolbar") == 0)
{
- options_parse_func_push(parser_data, options_parse_toolbar, NULL, lw);
+ options_parse_func_push(parser_data, options_parse_toolbar, nullptr, lw);
}
else if (g_ascii_strcasecmp(element_name, "statusbar") == 0)
{
- options_parse_func_push(parser_data, options_parse_statusbar, NULL, lw);
+ options_parse_func_push(parser_data, options_parse_statusbar, nullptr, lw);
}
else if (g_ascii_strcasecmp(element_name, "dialogs") == 0)
{
- options_parse_func_push(parser_data, options_parse_dialogs, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_dialogs, nullptr, nullptr);
}
else
{
log_printf("unexpected in <layout>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
if (g_ascii_strcasecmp(element_name, "gq") == 0)
{
/* optional top-level node */
- options_parse_func_push(parser_data, options_parse_toplevel, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_toplevel, nullptr, nullptr);
return;
}
if (g_ascii_strcasecmp(element_name, "global") == 0)
{
load_global_params(attribute_names, attribute_values);
- options_parse_func_push(parser_data, options_parse_global, options_parse_global_end, NULL);
+ options_parse_func_push(parser_data, options_parse_global, options_parse_global_end, nullptr);
return;
}
else
{
log_printf("unexpected in <toplevel>: <%s>\n", element_name);
- options_parse_func_push(parser_data, options_parse_leaf, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_leaf, nullptr, nullptr);
}
}
static GMarkupParser parser = {
start_element,
end_element,
- NULL,
- NULL,
- NULL
+ nullptr,
+ nullptr,
+ nullptr
};
/*
parser_data = g_new0(GQParserData, 1);
parser_data->startup = startup;
- options_parse_func_push(parser_data, options_parse_toplevel, NULL, NULL);
+ options_parse_func_push(parser_data, options_parse_toplevel, nullptr, nullptr);
- context = g_markup_parse_context_new(&parser, GMarkupParseFlags(0), parser_data, NULL);
+ context = g_markup_parse_context_new(&parser, GMarkupParseFlags(0), parser_data, nullptr);
- if (g_markup_parse_context_parse(context, buf, size, NULL) == FALSE)
+ if (g_markup_parse_context_parse(context, buf, size, nullptr) == FALSE)
{
ret = FALSE;
DEBUG_1("Parse failed");
gchar *buf;
gboolean ret = TRUE;
- if (g_file_get_contents(utf8_path, &buf, &size, NULL) == FALSE)
+ if (g_file_get_contents(utf8_path, &buf, &size, nullptr) == FALSE)
{
return FALSE;
}
static gint remote_client_send(RemoteConnection *rc, const gchar *text);
static void gr_raise(const gchar *text, GIOChannel *channel, gpointer data);
-static LayoutWindow *lw_id = NULL; /* points to the window set by the --id option */
+static LayoutWindow *lw_id = nullptr; /* points to the window set by the --id option */
typedef struct _RemoteClient RemoteClient;
struct _RemoteClient {
* command was made from. Some remote commands require this. The
* value is stored here
*/
-static gchar *pwd = NULL;
+static gchar *pwd = nullptr;
/**
* @brief Ensures file path is absolute.
RemoteConnection *rc;
GIOStatus status = G_IO_STATUS_NORMAL;
- lw_id = NULL;
+ lw_id = nullptr;
rc = client->rc;
if (condition & G_IO_IN)
{
- gchar *buffer = NULL;
- GError *error = NULL;
+ gchar *buffer = nullptr;
+ GError *error = nullptr;
gsize termpos;
/** @FIXME it should be possible to terminate the command with a null character */
g_io_channel_set_line_term(source, "<gq_end_of_command>", -1);
- while ((status = g_io_channel_read_line(source, &buffer, NULL, &termpos, &error)) == G_IO_STATUS_NORMAL)
+ while ((status = g_io_channel_read_line(source, &buffer, nullptr, &termpos, &error)) == G_IO_STATUS_NORMAL)
{
if (buffer)
{
if (strlen(buffer) > 0)
{
if (rc->read_func) rc->read_func(rc, buffer, source, rc->read_data);
- g_io_channel_write_chars(source, "<gq_end_of_command>", -1, NULL, NULL); /* empty line finishes the command */
- g_io_channel_flush(source, NULL);
+ g_io_channel_write_chars(source, "<gq_end_of_command>", -1, nullptr, nullptr); /* empty line finishes the command */
+ g_io_channel_flush(source, nullptr);
}
g_free(buffer);
- buffer = NULL;
+ buffer = nullptr;
}
}
channel = g_io_channel_unix_new(fd);
client->channel_id = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, static_cast<GIOCondition>(G_IO_IN | G_IO_HUP),
- remote_server_client_cb, client, NULL);
+ remote_server_client_cb, client, nullptr);
g_io_channel_unref(channel);
rc->clients = g_list_append(rc->clients, client);
gint fd;
guint alen;
- fd = accept(rc->fd, NULL, &alen);
+ fd = accept(rc->fd, nullptr, &alen);
if (fd == -1)
{
log_printf("error accepting socket: %s\n", strerror(errno));
if (remote_server_exists(path))
{
log_printf("Address already in use: %s\n", path);
- return NULL;
+ return nullptr;
}
fd = socket(PF_UNIX, SOCK_STREAM, 0);
- if (fd == -1) return NULL;
+ if (fd == -1) return nullptr;
addr.sun_family = AF_UNIX;
sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX);
{
log_printf("error subscribing to socket: %s\n", strerror(errno));
close(fd);
- return NULL;
+ return nullptr;
}
rc = g_new0(RemoteConnection, 1);
rc->path = g_strdup(path);
channel = g_io_channel_unix_new(rc->fd);
- g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, nullptr);
rc->channel_id = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, G_IO_IN,
- remote_server_read_cb, rc, NULL);
+ remote_server_read_cb, rc, nullptr);
g_io_channel_unref(channel);
return rc;
gint sun_path_len;
gint fd;
- if (stat(path, &st) != 0 || !S_ISSOCK(st.st_mode)) return NULL;
+ if (stat(path, &st) != 0 || !S_ISSOCK(st.st_mode)) return nullptr;
fd = socket(PF_UNIX, SOCK_STREAM, 0);
- if (fd == -1) return NULL;
+ if (fd == -1) return nullptr;
addr.sun_family = AF_UNIX;
sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX);
{
DEBUG_1("error connecting to socket: %s", strerror(errno));
close(fd);
- return NULL;
+ return nullptr;
}
rc = g_new0(RemoteConnection, 1);
{
struct sigaction new_action, old_action;
gboolean ret = FALSE;
- GError *error = NULL;
+ GError *error = nullptr;
GIOChannel *channel;
if (!rc || rc->server) return FALSE;
channel = g_io_channel_unix_new(rc->fd);
- g_io_channel_write_chars(channel, text, -1, NULL, &error);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, &error);
+ g_io_channel_write_chars(channel, text, -1, nullptr, &error);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, &error);
g_io_channel_flush(channel, &error);
if (error)
if (ret)
{
- gchar *buffer = NULL;
+ gchar *buffer = nullptr;
gsize termpos;
g_io_channel_set_line_term(channel, "<gq_end_of_command>", -1);
- while (g_io_channel_read_line(channel, &buffer, NULL, &termpos, &error) == G_IO_STATUS_NORMAL)
+ while (g_io_channel_read_line(channel, &buffer, nullptr, &termpos, &error) == G_IO_STATUS_NORMAL)
{
if (buffer)
{
break;
}
buffer[termpos] = '\0';
- if (g_strstr_len(buffer, -1, "print0") != 0)
+ if (g_strstr_len(buffer, -1, "print0") != nullptr)
{
print0 = TRUE;
}
}
}
g_free(buffer);
- buffer = NULL;
+ buffer = nullptr;
}
}
/* restore the original signal handler */
- sigaction(SIGPIPE, &old_action, NULL);
+ sigaction(SIGPIPE, &old_action, nullptr);
g_io_channel_unref(channel);
return ret;
}
static void gr_new_window(const gchar *UNUSED(text), GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
if (!layout_valid(&lw)) return;
{
if (!layout_valid(&lw_id)) return FALSE;
- layout_menu_close_cb(NULL, lw_id);
+ layout_menu_close_cb(nullptr, lw_id);
return G_SOURCE_REMOVE;
}
static void gr_close_window(const gchar *UNUSED(text), GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- g_idle_add((gr_close_window_cb), NULL);
+ g_idle_add((gr_close_window_cb), nullptr);
}
static void gr_image_prev(const gchar *UNUSED(text), GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
if (!g_strcmp0(text, "clear"))
{
- cache_maintain_home_remote(FALSE, TRUE, NULL);
+ cache_maintain_home_remote(FALSE, TRUE, nullptr);
}
else if (!g_strcmp0(text, "clean"))
{
- cache_maintain_home_remote(FALSE, FALSE, NULL);
+ cache_maintain_home_remote(FALSE, FALSE, nullptr);
}
}
static void gr_cache_metadata(const gchar *UNUSED(text), GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- cache_maintain_home_remote(TRUE, FALSE, NULL);
+ cache_maintain_home_remote(TRUE, FALSE, nullptr);
}
static void gr_cache_render(const gchar *text, GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- cache_manager_render_remote(text, FALSE, FALSE, NULL);
+ cache_manager_render_remote(text, FALSE, FALSE, nullptr);
}
static void gr_cache_render_recurse(const gchar *text, GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- cache_manager_render_remote(text, TRUE, FALSE, NULL);
+ cache_manager_render_remote(text, TRUE, FALSE, nullptr);
}
static void gr_cache_render_standard(const gchar *text, GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
if(options->thumbnails.spec_standard)
{
- cache_manager_render_remote(text, FALSE, TRUE, NULL);
+ cache_manager_render_remote(text, FALSE, TRUE, nullptr);
}
}
{
if(options->thumbnails.spec_standard)
{
- cache_manager_render_remote(text, TRUE, TRUE, NULL);
+ cache_manager_render_remote(text, TRUE, TRUE, nullptr);
}
}
/* schedule exit when idle, if done from within a
* remote handler remote_close will crash
*/
- g_idle_add(gr_quit_idle_cb, NULL);
+ g_idle_add(gr_quit_idle_cb, nullptr);
}
static void gr_file_load_no_raise(const gchar *text, GIOChannel *UNUSED(channel), gpointer UNUSED(data))
gchar *filename;
gchar *tilde_filename;
- if (!download_web_file(text, TRUE, NULL))
+ if (!download_web_file(text, TRUE, nullptr))
{
tilde_filename = expand_tilde(text);
filename = set_pwd(tilde_filename);
x_pixel, y_pixel,
r_mouse, g_mouse, b_mouse);
- g_io_channel_write_chars(channel, pixel_info, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, pixel_info, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_free(pixel_info);
}
(x2 > x1) ? x1 : x2,
(y2 > y1) ? y1 : y2);
- g_io_channel_write_chars(channel, rectangle_info, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, rectangle_info, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_free(rectangle_info);
}
break;
}
- g_io_channel_write_chars(channel, render_intent, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, render_intent, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_free(render_intent);
}
static void get_filelist(const gchar *text, GIOChannel *channel, gboolean recurse)
{
- GList *list = NULL;
+ GList *list = nullptr;
FileFormatClass format_class;
FileData *dir_fd;
FileData *fd;
- GString *out_string = g_string_new(NULL);
+ GString *out_string = g_string_new(nullptr);
GList *work;
gchar *tilde_filename;
}
else
{
- filelist_read(dir_fd, &list, NULL);
+ filelist_read(dir_fd, &list, nullptr);
}
work = list;
work = work->next;
}
- g_io_channel_write_chars(channel, out_string->str, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, out_string->str, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_string_free(out_string, TRUE);
filelist_free(list);
if (!layout_valid(&lw_id)) return;
GList *selected = layout_selection_list(lw_id); // Keep copy to free.
- GString *out_string = g_string_new(NULL);
+ GString *out_string = g_string_new(nullptr);
GList *work = selected;
while (work)
work = work->next;
}
- g_io_channel_write_chars(channel, out_string->str, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, out_string->str, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
filelist_free(selected);
g_string_free(out_string, TRUE);
{
if (!layout_valid(&lw_id)) return;
- FileData *fd_to_select = NULL;
+ FileData *fd_to_select = nullptr;
if (strcmp(text, "") == 0)
{
// No file specified, use current fd.
if (fd_to_select)
{
- GList *to_select = g_list_append(NULL, fd_to_select);
+ GList *to_select = g_list_append(nullptr, fd_to_select);
// Using the "_list" variant doesn't clear the existing selection.
layout_select_list(lw_id, to_select);
filelist_free(to_select);
return;
}
- FileData *fd_to_deselect = NULL;
- gchar *path = NULL;
- gchar *filename = NULL;
- gchar *slash_plus_filename = NULL;
+ FileData *fd_to_deselect = nullptr;
+ gchar *path = nullptr;
+ gchar *filename = nullptr;
+ gchar *slash_plus_filename = nullptr;
if (strcmp(text, "") == 0)
{
// No file specified, use current fd.
slash_plus_filename = g_strdup_printf("%s%s", G_DIR_SEPARATOR_S, filename);
}
- GList *prior_link = NULL; // Stash base for link removal to avoid a second traversal.
- GList *link_to_remove = NULL;
+ GList *prior_link = nullptr; // Stash base for link removal to avoid a second traversal.
+ GList *link_to_remove = nullptr;
for (GList *work = selected; work; prior_link = work, work = work->next)
{
auto fd = static_cast<FileData *>(work->data);
// Remove first link.
selected = g_list_remove_link(selected, link_to_remove);
filelist_free(link_to_remove);
- link_to_remove = NULL;
+ link_to_remove = nullptr;
}
else
{
// Remove a subsequent link.
prior_link = g_list_remove_link(prior_link, link_to_remove);
filelist_free(link_to_remove);
- link_to_remove = NULL;
+ link_to_remove = nullptr;
}
// Re-select all but the deselected item.
static void gr_collection(const gchar *text, GIOChannel *channel, gpointer UNUSED(data))
{
- GString *contents = g_string_new(NULL);
+ GString *contents = g_string_new(nullptr);
if (is_collection(text))
{
return;
}
- g_io_channel_write_chars(channel, contents->str, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, contents->str, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_string_free(contents, TRUE);
}
static void gr_collection_list(const gchar *UNUSED(text), GIOChannel *channel, gpointer UNUSED(data))
{
- GList *collection_list = NULL;
+ GList *collection_list = nullptr;
GList *work;
- GString *out_string = g_string_new(NULL);
+ GString *out_string = g_string_new(nullptr);
- collect_manager_list(&collection_list, NULL, NULL);
+ collect_manager_list(&collection_list, nullptr, nullptr);
work = collection_list;
while (work)
work = work->next;
}
- g_io_channel_write_chars(channel, out_string->str, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, out_string->str, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
string_list_free(collection_list);
g_string_free(out_string, TRUE);
if (text[0] == '+')
{
geometry = g_strsplit_set(text, "+", 3);
- if (geometry[1] != NULL && geometry[2] != NULL )
+ if (geometry[1] != nullptr && geometry[2] != nullptr )
{
gtk_window_move(GTK_WINDOW(lw_id->window), atoi(geometry[1]), atoi(geometry[2]));
}
else
{
geometry = g_strsplit_set(text, "+x", 4);
- if (geometry[0] != NULL && geometry[1] != NULL)
+ if (geometry[0] != nullptr && geometry[1] != nullptr)
{
gtk_window_resize(GTK_WINDOW(lw_id->window), atoi(geometry[0]), atoi(geometry[1]));
}
- if (geometry[2] != NULL && geometry[3] != NULL)
+ if (geometry[2] != nullptr && geometry[3] != nullptr)
{
/* There is an occasional problem with a window_move immediately after a window_resize */
g_idle_add(wait_cb, GINT_TO_POINTER((atoi(geometry[2]) << 16) + atoi(geometry[3])));
static void gr_file_tell(const gchar *UNUSED(text), GIOChannel *channel, gpointer UNUSED(data))
{
gchar *out_string;
- gchar *collection_name = NULL;
+ gchar *collection_name = nullptr;
if (!layout_valid(&lw_id)) return;
out_string = g_strconcat(lw_id->dir_fd->path, G_DIR_SEPARATOR_S, NULL);
}
- g_io_channel_write_chars(channel, out_string, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, out_string, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_free(collection_name);
g_free(out_string);
{
filename = g_strdup(image_get_path(lw_id->image));
fd = file_data_new_group(filename);
- out_string = g_string_new(NULL);
+ out_string = g_string_new(nullptr);
format_class = filter_file_get_class(image_get_path(lw_id->image));
if (format_class)
}
}
- g_io_channel_write_chars(channel, out_string->str, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, out_string->str, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_string_free(out_string, TRUE);
file_data_unref(fd);
static gchar *config_file_path(const gchar *param)
{
- gchar *path = NULL;
- gchar *full_name = NULL;
+ gchar *path = nullptr;
+ gchar *full_name = nullptr;
if (file_extension_match(param, ".xml"))
{
path = g_build_filename(get_window_layouts_dir(), param, NULL);
}
- else if (file_extension_match(param, NULL))
+ else if (file_extension_match(param, nullptr))
{
full_name = g_strconcat(param, ".xml", NULL);
path = g_build_filename(get_window_layouts_dir(), full_name, NULL);
if (!isfile(path))
{
g_free(path);
- path = NULL;
+ path = nullptr;
}
g_free(full_name);
static gboolean is_config_file(const gchar *param)
{
- gchar *name = NULL;
+ gchar *name = nullptr;
name = config_file_path(param);
if (name)
else
{
log_printf("remote sent filename that does not exist:\"%s\"\n", filename);
- layout_set_path(NULL, homedir());
+ layout_set_path(nullptr, homedir());
}
g_free(filename);
GList *work;
if (fd->parent) fd = fd->parent;
- g_io_channel_write_chars(channel, fd->path, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, fd->path, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
work = fd->sidecar_files;
{
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);
+ g_io_channel_write_chars(channel, fd->path, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
}
g_free(filename);
}
if (fd->change && fd->change->dest)
{
- g_io_channel_write_chars(channel, fd->change->dest, -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, fd->change->dest, -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
}
g_free(filename);
}
{
auto remote_data = static_cast<RemoteData *>(data);
- remote_data->command_collection = NULL;
- remote_data->file_list = NULL;
+ remote_data->command_collection = nullptr;
+ remote_data->file_list = nullptr;
remote_data->single_dir = TRUE;
}
{
auto remote_data = static_cast<RemoteData *>(data);
gboolean is_new = TRUE;
- gchar *path = NULL;
+ gchar *path = nullptr;
FileData *fd;
FileData *first;
if (!remote_data->command_collection && !remote_data->single_dir)
{
- cw = collection_window_new(NULL);
+ cw = collection_window_new(nullptr);
cd = cw->cd;
collection_path_changed(cd);
static void gr_pwd(const gchar *text, GIOChannel *UNUSED(channel), gpointer UNUSED(data))
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
static void gr_print0(const gchar *UNUSED(text), GIOChannel *channel, gpointer UNUSED(data))
{
- g_io_channel_write_chars(channel, "print0", -1, NULL, NULL);
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, "print0", -1, nullptr, nullptr);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
}
#ifdef HAVE_LUA
static RemoteCommandEntry remote_commands[] = {
/* short, long callback, extra, prefer, parameter, description */
- { "-b", "--back", gr_image_prev, FALSE, FALSE, NULL, N_("previous image") },
- { NULL, "--close-window", gr_close_window, FALSE, FALSE, NULL, N_("close window") },
- { NULL, "--config-load:", gr_config_load, TRUE, FALSE, N_("<FILE>|layout ID"), N_("load configuration from FILE") },
- { "-cm","--cache-metadata", gr_cache_metadata, FALSE, FALSE, NULL, N_("clean the metadata cache") },
+ { "-b", "--back", gr_image_prev, FALSE, FALSE, nullptr, N_("previous image") },
+ { nullptr, "--close-window", gr_close_window, FALSE, FALSE, nullptr, N_("close window") },
+ { nullptr, "--config-load:", gr_config_load, TRUE, FALSE, N_("<FILE>|layout ID"), N_("load configuration from FILE") },
+ { "-cm","--cache-metadata", gr_cache_metadata, FALSE, FALSE, nullptr, N_("clean the metadata cache") },
{ "-cr:", "--cache-render:", gr_cache_render, TRUE, FALSE, N_("<folder> "), N_(" render thumbnails") },
{ "-crr:", "--cache-render-recurse:", gr_cache_render_recurse, TRUE, FALSE, N_("<folder> "), N_("render thumbnails recursively") },
{ "-crs:", "--cache-render-shared:", gr_cache_render_standard, TRUE, FALSE, N_("<folder> "), N_(" render thumbnails (see Help)") },
{ "-cs:", "--cache-shared:", gr_cache_shared, TRUE, FALSE, N_("clear|clean"), N_("clear or clean shared thumbnail cache") },
{ "-ct:", "--cache-thumbs:", gr_cache_thumb, TRUE, FALSE, N_("clear|clean"), N_("clear or clean thumbnail cache") },
{ "-d", "--delay=", gr_slideshow_delay, TRUE, FALSE, N_("<[H:][M:][N][.M]>"), N_("set slide show delay to Hrs Mins N.M seconds") },
- { NULL, "--first", gr_image_first, FALSE, FALSE, NULL, N_("first image") },
- { "-f", "--fullscreen", gr_fullscreen_toggle, FALSE, TRUE, NULL, N_("toggle full screen") },
- { NULL, "--file:", gr_file_load, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, bring Geeqie window to the top") },
- { NULL, "file:", gr_file_load, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, bring Geeqie window to the top") },
- { NULL, "--File:", gr_file_load_no_raise, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, do not bring Geeqie window to the top") },
- { NULL, "File:", gr_file_load_no_raise, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, do not bring Geeqie window to the top") },
- { "-fs","--fullscreen-start", gr_fullscreen_start, FALSE, FALSE, NULL, N_("start full screen") },
- { "-fS","--fullscreen-stop", gr_fullscreen_stop, FALSE, FALSE, NULL, N_("stop full screen") },
- { NULL, "--geometry=", gr_geometry, TRUE, FALSE, N_("<GEOMETRY>"), N_("set window geometry") },
- { NULL, "--get-collection:", gr_collection, TRUE, FALSE, N_("<COLLECTION>"), N_("get collection content") },
- { NULL, "--get-collection-list", gr_collection_list, FALSE, FALSE, NULL, N_("get collection list") },
- { NULL, "--get-destination:", gr_get_destination, TRUE, FALSE, N_("<FILE>"), N_("get destination path of FILE (See Plugins Configuration)") },
- { NULL, "--get-file-info", gr_file_info, FALSE, FALSE, NULL, N_("get file info") },
- { NULL, "--get-filelist:", gr_filelist, TRUE, FALSE, N_("[<FOLDER>]"), N_("get list of files and class") },
- { NULL, "--get-filelist-recurse:", gr_filelist_recurse, TRUE, FALSE, N_("[<FOLDER>]"), N_("get list of files and class recursive") },
- { NULL, "--get-rectangle", gr_rectangle, FALSE, FALSE, NULL, N_("get rectangle co-ordinates") },
- { NULL, "--get-render-intent", gr_render_intent, FALSE, FALSE, NULL, N_("get render intent") },
- { NULL, "--get-selection", gr_get_selection, FALSE, FALSE, NULL, N_("get list of selected files") },
- { NULL, "--get-sidecars:", gr_get_sidecars, TRUE, FALSE, N_("<FILE>"), N_("get list of sidecars of FILE") },
- { NULL, "--id:", gr_lw_id, TRUE, FALSE, N_("<ID>"), N_("window id for following commands") },
- { NULL, "--last", gr_image_last, FALSE, FALSE, NULL, N_("last image") },
- { NULL, "--list-add:", gr_list_add, TRUE, FALSE, N_("<FILE>"), N_("add FILE to command line collection list") },
- { NULL, "--list-clear", gr_list_clear, FALSE, FALSE, NULL, N_("clear command line collection list") },
+ { nullptr, "--first", gr_image_first, FALSE, FALSE, nullptr, N_("first image") },
+ { "-f", "--fullscreen", gr_fullscreen_toggle, FALSE, TRUE, nullptr, N_("toggle full screen") },
+ { nullptr, "--file:", gr_file_load, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, bring Geeqie window to the top") },
+ { nullptr, "file:", gr_file_load, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, bring Geeqie window to the top") },
+ { nullptr, "--File:", gr_file_load_no_raise, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, do not bring Geeqie window to the top") },
+ { nullptr, "File:", gr_file_load_no_raise, TRUE, FALSE, N_("<FILE>|<URL>"), N_("open FILE or URL, do not bring Geeqie window to the top") },
+ { "-fs","--fullscreen-start", gr_fullscreen_start, FALSE, FALSE, nullptr, N_("start full screen") },
+ { "-fS","--fullscreen-stop", gr_fullscreen_stop, FALSE, FALSE, nullptr, N_("stop full screen") },
+ { nullptr, "--geometry=", gr_geometry, TRUE, FALSE, N_("<GEOMETRY>"), N_("set window geometry") },
+ { nullptr, "--get-collection:", gr_collection, TRUE, FALSE, N_("<COLLECTION>"), N_("get collection content") },
+ { nullptr, "--get-collection-list", gr_collection_list, FALSE, FALSE, nullptr, N_("get collection list") },
+ { nullptr, "--get-destination:", gr_get_destination, TRUE, FALSE, N_("<FILE>"), N_("get destination path of FILE (See Plugins Configuration)") },
+ { nullptr, "--get-file-info", gr_file_info, FALSE, FALSE, nullptr, N_("get file info") },
+ { nullptr, "--get-filelist:", gr_filelist, TRUE, FALSE, N_("[<FOLDER>]"), N_("get list of files and class") },
+ { nullptr, "--get-filelist-recurse:", gr_filelist_recurse, TRUE, FALSE, N_("[<FOLDER>]"), N_("get list of files and class recursive") },
+ { nullptr, "--get-rectangle", gr_rectangle, FALSE, FALSE, nullptr, N_("get rectangle co-ordinates") },
+ { nullptr, "--get-render-intent", gr_render_intent, FALSE, FALSE, nullptr, N_("get render intent") },
+ { nullptr, "--get-selection", gr_get_selection, FALSE, FALSE, nullptr, N_("get list of selected files") },
+ { nullptr, "--get-sidecars:", gr_get_sidecars, TRUE, FALSE, N_("<FILE>"), N_("get list of sidecars of FILE") },
+ { nullptr, "--id:", gr_lw_id, TRUE, FALSE, N_("<ID>"), N_("window id for following commands") },
+ { nullptr, "--last", gr_image_last, FALSE, FALSE, nullptr, N_("last image") },
+ { nullptr, "--list-add:", gr_list_add, TRUE, FALSE, N_("<FILE>"), N_("add FILE to command line collection list") },
+ { nullptr, "--list-clear", gr_list_clear, FALSE, FALSE, nullptr, N_("clear command line collection list") },
#ifdef HAVE_LUA
{ NULL, "--lua:", gr_lua, TRUE, FALSE, N_("<FILE>,<lua script>"), N_("run lua script on FILE") },
#endif
- { NULL, "--new-window", gr_new_window, FALSE, FALSE, NULL, N_("new window") },
- { "-n", "--next", gr_image_next, FALSE, FALSE, NULL, N_("next image") },
- { NULL, "--pixel-info", gr_pixel_info, FALSE, FALSE, NULL, N_("print pixel info of mouse pointer on current image") },
- { NULL, "--print0", gr_print0, TRUE, FALSE, NULL, N_("terminate returned data with null character instead of newline") },
- {
NULL, "--PWD:", gr_pwd, TRUE, FALSE, N_("<PWD>"), N_("use PWD as working directory for following commands") },
- { "-q", "--quit", gr_quit, FALSE, FALSE, NULL, N_("quit") },
- { NULL, "--raise", gr_raise, FALSE, FALSE, NULL, N_("bring the Geeqie window to the top") },
- { NULL, "raise", gr_raise, FALSE, FALSE, NULL, N_("bring the Geeqie window to the top") },
- { NULL, "--selection-add:", gr_selection_add, TRUE, FALSE, N_("[<FILE>]"), N_("adds the current file (or the specified file) to the current selection") },
- { NULL, "--selection-clear", gr_selection_clear, FALSE, FALSE, NULL, N_("clears the current selection") },
- { NULL, "--selection-remove:", gr_selection_remove, TRUE, FALSE, N_("[<FILE>]"), N_("removes the current file (or the specified file) from the current selection") },
- { "-s", "--slideshow", gr_slideshow_toggle, FALSE, TRUE, NULL, N_("toggle slide show") },
- { NULL, "--slideshow-recurse:", gr_slideshow_start_rec, TRUE, FALSE, N_("<FOLDER>"), N_("start recursive slide show in FOLDER") },
- { "-ss","--slideshow-start", gr_slideshow_start, FALSE, FALSE, NULL, N_("start slide show") },
- { "-sS","--slideshow-stop", gr_slideshow_stop, FALSE, FALSE, NULL, N_("stop slide show") },
- { NULL, "--tell", gr_file_tell, FALSE, FALSE, NULL, N_("print filename [and Collection] of current image") },
- { "+t", "--tools-show", gr_tools_show, FALSE, TRUE, NULL, N_("show tools") },
- { "-t", "--tools-hide", gr_tools_hide, FALSE, TRUE, NULL, N_("hide tools") },
- { NULL, "--view:", gr_file_view, TRUE, FALSE, N_("<FILE>"), N_("open FILE in new window") },
- { NULL, "view:", gr_file_view, TRUE, FALSE, N_("<FILE>"), N_("open FILE in new window") },
- { NULL, NULL, NULL, FALSE, FALSE, NULL, NULL }
+ { nullptr, "--new-window", gr_new_window, FALSE, FALSE, nullptr, N_("new window") },
+ { "-n", "--next", gr_image_next, FALSE, FALSE, nullptr, N_("next image") },
+ { nullptr, "--pixel-info", gr_pixel_info, FALSE, FALSE, nullptr, N_("print pixel info of mouse pointer on current image") },
+ { nullptr, "--print0", gr_print0, TRUE, FALSE, nullptr, N_("terminate returned data with null character instead of newline") },
+ {
nullptr, "--PWD:", gr_pwd, TRUE, FALSE, N_("<PWD>"), N_("use PWD as working directory for following commands") },
+ { "-q", "--quit", gr_quit, FALSE, FALSE, nullptr, N_("quit") },
+ { nullptr, "--raise", gr_raise, FALSE, FALSE, nullptr, N_("bring the Geeqie window to the top") },
+ { nullptr, "raise", gr_raise, FALSE, FALSE, nullptr, N_("bring the Geeqie window to the top") },
+ { nullptr, "--selection-add:", gr_selection_add, TRUE, FALSE, N_("[<FILE>]"), N_("adds the current file (or the specified file) to the current selection") },
+ { nullptr, "--selection-clear", gr_selection_clear, FALSE, FALSE, nullptr, N_("clears the current selection") },
+ { nullptr, "--selection-remove:", gr_selection_remove, TRUE, FALSE, N_("[<FILE>]"), N_("removes the current file (or the specified file) from the current selection") },
+ { "-s", "--slideshow", gr_slideshow_toggle, FALSE, TRUE, nullptr, N_("toggle slide show") },
+ { nullptr, "--slideshow-recurse:", gr_slideshow_start_rec, TRUE, FALSE, N_("<FOLDER>"), N_("start recursive slide show in FOLDER") },
+ { "-ss","--slideshow-start", gr_slideshow_start, FALSE, FALSE, nullptr, N_("start slide show") },
+ { "-sS","--slideshow-stop", gr_slideshow_stop, FALSE, FALSE, nullptr, N_("stop slide show") },
+ { nullptr, "--tell", gr_file_tell, FALSE, FALSE, nullptr, N_("print filename [and Collection] of current image") },
+ { "+t", "--tools-show", gr_tools_show, FALSE, TRUE, nullptr, N_("show tools") },
+ { "-t", "--tools-hide", gr_tools_hide, FALSE, TRUE, nullptr, N_("hide tools") },
+ { nullptr, "--view:", gr_file_view, TRUE, FALSE, N_("<FILE>"), N_("open FILE in new window") },
+ { nullptr, "view:", gr_file_view, TRUE, FALSE, N_("<FILE>"), N_("open FILE in new window") },
+ { nullptr, nullptr, nullptr, FALSE, FALSE, nullptr, nullptr }
};
static RemoteCommandEntry *remote_command_find(const gchar *text, const gchar **offset)
gint i;
i = 0;
- while (!match && remote_commands[i].func != NULL)
+ while (!match && remote_commands[i].func != nullptr)
{
if (remote_commands[i].needs_extra)
{
i++;
}
- return NULL;
+ return nullptr;
}
static void remote_cb(RemoteConnection *UNUSED(rc), const gchar *text, GIOChannel *channel, gpointer data)
print_term(FALSE, _("Remote command list:\n"));
i = 0;
- while (remote_commands[i].func != NULL)
+ while (remote_commands[i].func != nullptr)
{
if (remote_commands[i].description)
{
{
RemoteCommandEntry *entry;
- entry = remote_command_find(argv[i], NULL);
+ entry = remote_command_find(argv[i], nullptr);
if (entry)
{
list = g_list_append(list, argv[i]);
text = static_cast<gchar *>(work->data);
work = work->next;
- entry = remote_command_find(text, NULL);
+ entry = remote_command_find(text, nullptr);
if (entry)
{
/* If Geeqie is not running, stop the --new-window command opening a second window */
text = static_cast<gchar *>(work->data);
work = work->next;
- entry = remote_command_find(text, NULL);
+ entry = remote_command_find(text, nullptr);
if (entry &&
entry->opt_l &&
strcmp(entry->opt_l, "file:") == 0) use_path = FALSE;
cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
cairo_destroy(cr);
return;
cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
if (pr->viewport_width - pr->vis_width - pr->x_offset > 0 &&
pr_clip_region(x, y, w, h,
cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
}
if (pr->vis_height < pr->viewport_height)
cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
if (pr->viewport_height - pr->vis_height - pr->y_offset > 0 &&
pr_clip_region(x, y, w, h,
cairo_set_source_rgb(cr, static_cast<double>(pr->color.red)/65535, static_cast<double>(pr->color.green)/65535, static_cast<double>(pr->color.blue)/65535);
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
}
cairo_destroy(cr);
}
g_list_free(rt->tiles);
- rt->tiles = NULL;
+ rt->tiles = nullptr;
rt->tile_cache_size = 0;
}
{
QueueData *qd = it->qd;
- it->qd = NULL;
+ it->qd = nullptr;
rt->draw_queue = g_list_remove(rt->draw_queue, qd);
g_free(qd);
}
{
QueueData *qd = it->qd2;
- it->qd2 = NULL;
+ it->qd2 = nullptr;
rt->draw_queue_2pass = g_list_remove(rt->draw_queue_2pass, qd);
g_free(qd);
}
work = work->next;
}
- if (only_existing) return NULL;
+ if (only_existing) return nullptr;
return rt_tile_add(rt, x, y);
}
double y)
{
cairo_surface_t *surface;
- surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, rt->hidpi_scale, NULL);
+ surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, rt->hidpi_scale, nullptr);
cairo_set_source_surface(cr, surface, x, y);
cairo_fill(cr);
cairo_surface_destroy(surface);
if (od->id == id) return od;
}
- return NULL;
+ return nullptr;
}
gint id;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), -1);
- g_return_val_if_fail(pixbuf != NULL, -1);
+ g_return_val_if_fail(pixbuf != nullptr, -1);
id = 1;
while (rt_overlay_find(rt, id)) id++;
if (!rt->overlay_list && rt->overlay_buffer)
{
cairo_surface_destroy(rt->overlay_buffer);
- rt->overlay_buffer = NULL;
+ rt->overlay_buffer = nullptr;
}
}
GList *work;
if (rt->overlay_buffer) cairo_surface_destroy(rt->overlay_buffer);
- rt->overlay_buffer = NULL;
+ rt->overlay_buffer = nullptr;
work = rt->overlay_list;
while (work)
auto od = static_cast<OverlayData *>(work->data);
work = work->next;
if (od->window) gdk_window_destroy(od->window);
- od->window = NULL;
+ od->window = nullptr;
}
}
{
/* 2pass prio */
DEBUG_2("redraw priority: 2pass");
- rt->draw_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, rt_queue_draw_idle_cb, rt, NULL);
+ rt->draw_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, rt_queue_draw_idle_cb, rt, nullptr);
return G_SOURCE_REMOVE;
}
{
/* we have enough data for starting intensive redrawing */
DEBUG_2("redraw priority: high %.2f %%", percent);
- rt->draw_idle_id = g_idle_add_full(GDK_PRIORITY_REDRAW, rt_queue_draw_idle_cb, rt, NULL);
+ rt->draw_idle_id = g_idle_add_full(GDK_PRIORITY_REDRAW, rt_queue_draw_idle_cb, rt, nullptr);
return G_SOURCE_REMOVE;
}
{
/* queue is (almost) empty, wait 50 ms*/
DEBUG_2("redraw priority: wait %.2f %%", percent);
- rt->draw_idle_id = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 50, rt_queue_draw_idle_cb, rt, NULL);
+ rt->draw_idle_id = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 50, rt_queue_draw_idle_cb, rt, nullptr);
return G_SOURCE_REMOVE;
}
if (rt->draw_queue)
{
- qd->it->qd = NULL;
+ qd->it->qd = nullptr;
rt->draw_queue = g_list_remove(rt->draw_queue, qd);
if (fast)
{
}
else
{
- qd->it->qd2 = NULL;
+ qd->it->qd2 = nullptr;
rt->draw_queue_2pass = g_list_remove(rt->draw_queue_2pass, qd);
g_free(qd);
}
qd = static_cast<QueueData *>(work->data);
work = work->next;
- qd->it->qd = NULL;
- qd->it->qd2 = NULL;
+ qd->it->qd = nullptr;
+ qd->it->qd2 = nullptr;
g_free(qd);
}
static void rt_queue_clear(RendererTiles *rt)
{
rt_queue_list_free(rt->draw_queue);
- rt->draw_queue = NULL;
+ rt->draw_queue = nullptr;
rt_queue_list_free(rt->draw_queue_2pass);
- rt->draw_queue_2pass = NULL;
+ rt->draw_queue_2pass = nullptr;
if (rt->draw_idle_id)
{
rt_overlay_list_clear(rt);
/* disconnect "hierarchy-changed" */
g_signal_handlers_disconnect_matched(G_OBJECT(rt->pr), G_SIGNAL_MATCH_DATA,
- 0, 0, 0, NULL, rt);
+ 0, 0, nullptr, nullptr, rt);
g_free(rt);
}
rt->tile_width = options->image.tile_size;
rt->tile_height = options->image.tile_size;
- rt->tiles = NULL;
+ rt->tiles = nullptr;
rt->tile_cache_size = 0;
rt->tile_cache_max = PR_CACHE_SIZE_DEFAULT;
gtk_tree_model_get(model, a, SAR_LABEL, &label1, -1);
gtk_tree_model_get(model, b, SAR_LABEL, &label2, -1);
- if (label1 == NULL || label2 == NULL)
+ if (label1 == nullptr || label2 == nullptr)
{
- if (label1 == NULL && label2 == NULL)
+ if (label1 == nullptr && label2 == nullptr)
{
ret = 0;
}
else
{
- ret = (label1 == NULL) ? -1 : 1;
+ ret = (label1 == nullptr) ? -1 : 1;
}
}
else
sar->command_store = gtk_list_store_new(SAR_COUNT, G_TYPE_STRING, G_TYPE_OBJECT);
sortable = GTK_TREE_SORTABLE(sar->command_store);
- gtk_tree_sortable_set_sort_func(sortable, SAR_LABEL, sort_iter_compare_func, NULL, NULL);
+ gtk_tree_sortable_set_sort_func(sortable, SAR_LABEL, sort_iter_compare_func, nullptr, nullptr);
gtk_tree_sortable_set_sort_column_id(sortable, SAR_LABEL, GTK_SORT_ASCENDING);
accel = gtk_accelerator_get_label(key.accel_key, key.accel_mods);
/* menu items with no tooltip are placeholders */
- if (g_strrstr(accel_path, ".desktop") != NULL || tooltip != NULL)
+ if (g_strrstr(accel_path, ".desktop") != nullptr || tooltip != nullptr)
{
- if (pango_parse_markup(label, -1, '_', NULL, &label2, NULL, NULL) && label2)
+ if (pango_parse_markup(label, -1, '_', nullptr, &label2, nullptr, nullptr) && label2)
{
g_free(label);
label = label2;
}
if (tooltip)
{
- if (pango_parse_markup(tooltip, -1, '_', NULL, &tooltip2, NULL, NULL) && label2)
+ if (pango_parse_markup(tooltip, -1, '_', nullptr, &tooltip2, nullptr, nullptr) && label2)
{
g_free(tooltip);
tooltip = tooltip2;
}
}
- new_command = g_string_new(NULL);
+ new_command = g_string_new(nullptr);
if (g_strcmp0(label, tooltip) == 0)
{
g_string_append_printf(new_command, "%s : %s",label, accel);
{
auto sar = static_cast<SarData *>(data);
- sar->lw->sar_window = NULL;
+ sar->lw->sar_window = nullptr;
gtk_widget_destroy(sar->window);
return G_SOURCE_CONTINUE;
break;
default:
sar->match_found = FALSE;
- sar->action = NULL;
+ sar->action = nullptr;
}
return ret;
gchar *label;
GString *reg_exp_str;
GRegex *reg_exp;
- GError *error = NULL;
+ GError *error = nullptr;
model = gtk_entry_completion_get_model(completion);
gtk_tree_model_get(GTK_TREE_MODEL(model), iter, SAR_LABEL, &label, -1);
{
log_printf("Error: could not compile regular expression %s\n%s\n", reg_exp_str->str, error->message);
g_error_free(error);
- error = NULL;
- reg_exp = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ error = nullptr;
+ reg_exp = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
- ret = g_regex_match(reg_exp, normalized, GRegexMatchFlags(0), NULL);
+ ret = g_regex_match(reg_exp, normalized, GRegexMatchFlags(0), nullptr);
if (sar->match_found == FALSE && ret == TRUE)
{
sar = g_new0(SarData, 1);
sar->lw = lw;
- sar->window = window_new(GTK_WINDOW_TOPLEVEL, "sar_window", NULL, NULL, _("Search and Run command"));
+ sar->window = window_new(GTK_WINDOW_TOPLEVEL, "sar_window", nullptr, nullptr, _("Search and Run command"));
DEBUG_NAME(sar->window);
geometry.min_width = 500;
geometry.max_width = 1500;
geometry.min_height = 10;
geometry.max_height = 10;
- gtk_window_set_geometry_hints(GTK_WINDOW(sar->window), NULL, &geometry, static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
+ gtk_window_set_geometry_hints(GTK_WINDOW(sar->window), nullptr, &geometry, static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
gtk_window_set_resizable(GTK_WINDOW(sar->window), TRUE);
gtk_entry_completion_set_inline_completion(sar->completion, FALSE);
gtk_entry_completion_set_inline_selection(sar->completion, FALSE);
gtk_entry_completion_set_minimum_key_length(sar->completion, 1);
- gtk_entry_completion_set_match_func(sar->completion, match_func, sar, NULL);
+ gtk_entry_completion_set_match_func(sar->completion, match_func, sar, nullptr);
g_signal_connect(G_OBJECT(sar->completion), "match-selected", G_CALLBACK(match_selected_cb), sar);
gtk_entry_completion_set_model(sar->completion, GTK_TREE_MODEL(sar->command_store));
gtk_entry_completion_set_text_column(sar->completion, SAR_LABEL);
{ N_("is not"), SEARCH_MATCH_NONE }
};
-static GList *search_window_list = NULL;
+static GList *search_window_list = nullptr;
static gint search_result_selection_count(SearchData *sd, gint64 *bytes);
{static_cast<GdkModifierType>(0), 'C', N_("Collection from selection")},
{GDK_CONTROL_MASK, GDK_KEY_Return, N_("Start/stop search")},
{static_cast<GdkModifierType>(0), GDK_KEY_F3, N_("Find duplicates")},
- {static_cast<GdkModifierType>(0), 0, NULL}
+ {static_cast<GdkModifierType>(0), 0, nullptr}
};
/*
*-------------------------------------------------------------------
if (mfd_n->fd == fd) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return found;
GList *work;
gint n = 0;
gint64 total = 0;
- GList *plist = NULL;
+ GList *plist = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
if (bytes) *bytes = total;
{
GList *list;
- search_result_selection_util(sd, NULL, &list);
+ search_result_selection_util(sd, nullptr, &list);
return list;
}
static gint search_result_selection_count(SearchData *sd, gint64 *bytes)
{
- return search_result_selection_util(sd, bytes, NULL);
+ return search_result_selection_util(sd, bytes, nullptr);
}
static gint search_result_util(SearchData *sd, gint64 *bytes, GList **list)
gboolean valid;
gint n = 0;
gint64 total = 0;
- GList *plist = NULL;
+ GList *plist = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
static GList *search_result_get_filelist(SearchData *sd)
{
- GList *list = NULL;
+ GList *list = nullptr;
- search_result_util(sd, NULL, &list);
+ search_result_util(sd, nullptr, &list);
return list;
}
static gint search_result_count(SearchData *sd, gint64 *bytes)
{
- return search_result_util(sd, bytes, NULL);
+ return search_result_util(sd, bytes, nullptr);
}
static void search_result_append(SearchData *sd, MatchFileData *mfd)
GtkListStore *store;
GtkTreeIter iter;
gchar *text_size;
- gchar *text_dim = NULL;
+ gchar *text_dim = nullptr;
fd = mfd->fd;
static GList *search_result_refine_list(SearchData *sd)
{
- GList *list = NULL;
+ GList *list = nullptr;
GtkTreeModel *store;
GtkTreeIter iter;
gboolean valid;
gtk_tree_model_foreach(GTK_TREE_MODEL(store), search_result_free_node, sd);
gtk_list_store_clear(store);
- sd->click_fd = NULL;
+ sd->click_fd = nullptr;
thumb_loader_free(sd->thumb_loader);
- sd->thumb_loader = NULL;
- sd->thumb_fd = NULL;
+ sd->thumb_loader = nullptr;
+ sd->thumb_fd = nullptr;
search_status_update(sd);
}
tree_view_move_cursor_away(GTK_TREE_VIEW(sd->result_view), iter, TRUE);
gtk_list_store_remove(GTK_LIST_STORE(store), iter);
- if (sd->click_fd == mfd->fd) sd->click_fd = NULL;
- if (sd->thumb_fd == mfd->fd) sd->thumb_fd = NULL;
+ if (sd->click_fd == mfd->fd) sd->click_fd = nullptr;
+ if (sd->thumb_fd == mfd->fd) sd->thumb_fd = nullptr;
file_data_unref(mfd->fd);
g_free(mfd);
}
GtkTreeSelection *selection;
GtkTreeModel *store;
GList *slist;
- GList *flist = NULL;
+ GList *flist = nullptr;
GList *work;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
flist = g_list_prepend(flist, mfd->fd);
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
work = flist;
static void search_result_edit_selected(SearchData *sd, const gchar *key)
{
- file_util_start_editor_from_filelist(key, search_result_selection_list(sd), NULL, sd->window);
+ file_util_start_editor_from_filelist(key, search_result_selection_list(sd), nullptr, sd->window);
}
static void search_result_collection_from_selection(SearchData *sd)
GList *list;
list = search_result_selection_list(sd);
- w = collection_window_new(NULL);
+ w = collection_window_new(nullptr);
collection_table_add_filelist(w->table, list);
filelist_free(list);
}
if (!sd->thumb_loader || !sd->thumb_fd) return;
fd = sd->thumb_fd;
- search_result_thumb_set(sd, fd, NULL);
+ search_result_thumb_set(sd, fd, nullptr);
}
static void search_result_thumb_done_cb(ThumbLoader *UNUSED(tl), gpointer data)
{
GtkTreeModel *store;
GtkTreeIter iter;
- MatchFileData *mfd = NULL;
+ MatchFileData *mfd = nullptr;
gboolean valid;
gint row = 0;
gint length = 0;
{
if (!pixbuf) gtk_list_store_set(GTK_LIST_STORE(store), &iter, SEARCH_COLUMN_THUMB, mfd->fd->thumb_pixbuf, -1);
row++;
- mfd = NULL;
+ mfd = nullptr;
}
valid = gtk_tree_model_iter_next(store, &iter);
}
if (!mfd)
{
- sd->thumb_fd = NULL;
+ sd->thumb_fd = nullptr;
thumb_loader_free(sd->thumb_loader);
- sd->thumb_loader = NULL;
+ sd->thumb_loader = nullptr;
search_progress_update(sd, TRUE, -1.0);
return;
thumb_loader_set_callbacks(sd->thumb_loader,
search_result_thumb_done_cb,
search_result_thumb_done_cb,
- NULL,
+ nullptr,
sd);
if (!thumb_loader_start(sd->thumb_loader, mfd->fd))
{
gboolean valid;
thumb_loader_free(sd->thumb_loader);
- sd->thumb_loader = NULL;
+ sd->thumb_loader = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(sd->result_view));
valid = gtk_tree_model_get_iter_first(store, &iter);
{
auto sd = static_cast<SearchData *>(data);
- if (sd->click_fd) layout_set_fd(NULL, sd->click_fd);
+ if (sd->click_fd) layout_set_fd(nullptr, sd->click_fd);
}
static void sr_menu_viewnew_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto sd = static_cast<SearchData *>(data);
- file_util_copy(NULL, search_result_selection_list(sd), NULL, sd->window);
+ file_util_copy(nullptr, search_result_selection_list(sd), nullptr, sd->window);
}
static void sr_menu_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto sd = static_cast<SearchData *>(data);
- file_util_move(NULL, search_result_selection_list(sd), NULL, sd->window);
+ file_util_move(nullptr, search_result_selection_list(sd), nullptr, sd->window);
}
static void sr_menu_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto sd = static_cast<SearchData *>(data);
- file_util_rename(NULL, search_result_selection_list(sd), sd->window);
+ file_util_rename(nullptr, search_result_selection_list(sd), sd->window);
}
static void sr_menu_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
auto sd = static_cast<SearchData *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(NULL, search_result_selection_list(sd), sd->window);
+ file_util_delete(nullptr, search_result_selection_list(sd), sd->window);
}
static void sr_menu_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
auto sd = static_cast<SearchData *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, search_result_selection_list(sd), sd->window);
+ file_util_delete(nullptr, search_result_selection_list(sd), sd->window);
}
static void sr_menu_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
GtkTreeModel *store;
GtkTreePath *tpath;
GtkTreeIter iter;
- MatchFileData *mfd = NULL;
+ MatchFileData *mfd = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
gtk_tree_path_free(tpath);
}
- sd->click_fd = mfd ? mfd->fd : NULL;
+ sd->click_fd = mfd ? mfd->fd : nullptr;
if (bevent->button == MOUSE_BUTTON_RIGHT)
{
GtkWidget *menu;
- menu = search_result_menu(sd, (mfd != NULL), (search_result_count(sd, NULL) == 0));
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ menu = search_result_menu(sd, (mfd != nullptr), (search_result_count(sd, nullptr) == 0));
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
if (!mfd) return FALSE;
if (bevent->button == MOUSE_BUTTON_LEFT && bevent->type == GDK_2BUTTON_PRESS)
{
- layout_set_fd(NULL, mfd->fd);
+ layout_set_fd(nullptr, mfd->fd);
}
if (bevent->button == MOUSE_BUTTON_MIDDLE) return TRUE;
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
return TRUE;
GtkTreePath *tpath;
GtkTreeIter iter;
- MatchFileData *mfd = NULL;
+ MatchFileData *mfd = nullptr;
if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
if ((bevent->x != 0 || bevent->y != 0) &&
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
return TRUE;
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
- MatchFileData *mfd = NULL;
+ MatchFileData *mfd = nullptr;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
slist = gtk_tree_selection_get_selected_rows(selection, &store);
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, SEARCH_COLUMN_POINTER, &mfd, -1);
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
if (event->state & GDK_CONTROL_MASK)
case '0':
break;
case 'C': case 'c':
- file_util_copy(NULL, search_result_selection_list(sd), NULL, widget);
+ file_util_copy(nullptr, search_result_selection_list(sd), nullptr, widget);
break;
case 'M': case 'm':
- file_util_move(NULL, search_result_selection_list(sd), NULL, widget);
+ file_util_move(nullptr, search_result_selection_list(sd), nullptr, widget);
break;
case 'R': case 'r':
- file_util_rename(NULL, search_result_selection_list(sd), widget);
+ file_util_rename(nullptr, search_result_selection_list(sd), widget);
break;
case 'D': case 'd':
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, search_result_selection_list(sd), widget);
+ file_util_delete(nullptr, search_result_selection_list(sd), widget);
break;
case 'A': case 'a':
if (event->state & GDK_SHIFT_MASK)
switch (event->keyval)
{
case GDK_KEY_Return: case GDK_KEY_KP_Enter:
- if (mfd) layout_set_fd(NULL, mfd->fd);
+ if (mfd) layout_set_fd(nullptr, mfd->fd);
break;
case 'V': case 'v':
{
if (mfd)
sd->click_fd = mfd->fd;
else
- sd->click_fd = NULL;
+ sd->click_fd = nullptr;
- menu = search_result_menu(sd, (mfd != NULL), (search_result_count(sd, NULL) > 0));
+ menu = search_result_menu(sd, (mfd != nullptr), (search_result_count(sd, nullptr) > 0));
- gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, nullptr);
}
break;
default:
search_window_close(sd);
break;
case GDK_KEY_Return: case GDK_KEY_KP_Enter:
- search_start_cb(NULL, sd);
+ search_start_cb(nullptr, sd);
break;
default:
stop_signal = FALSE;
gtk_tree_selection_select_iter(selection, &iter);
tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
}
if (sd->thumb_enable &&
sd->click_fd && sd->click_fd->thumb_pixbuf)
{
- dnd_set_drag_icon(widget, context, sd->click_fd->thumb_pixbuf, search_result_selection_count(sd, NULL));
+ dnd_set_drag_icon(widget, context, sd->click_fd->thumb_pixbuf, search_result_selection_count(sd, nullptr));
}
}
/* If more than one file, use only the first file in a list.
*/
- if (list != NULL)
+ if (list != nullptr)
{
fd = static_cast<FileData *>(list->data);
latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);
list = uri_filelist_from_gtk_selection_data(selection_data);
/* If more than one file, use only the first file in a list.
*/
- if (list != NULL)
+ if (list != nullptr)
{
fd = static_cast<FileData *>(list->data);
gtk_entry_set_text(GTK_ENTRY(sd->path_entry),
list = uri_filelist_from_gtk_selection_data(selection_data);
/* If more than one file, use only the first file in a list.
*/
- if (list != NULL)
+ if (list != nullptr)
{
fd = static_cast<FileData *>(list->data);
gtk_entry_set_text(GTK_ENTRY(sd->entry_similarity),
}
g_list_free(sd->search_buffer_list);
- sd->search_buffer_list = NULL;
+ sd->search_buffer_list = nullptr;
sd->search_buffer_count = 0;
}
}
image_loader_free(sd->img_loader);
- sd->img_loader = NULL;
+ sd->img_loader = nullptr;
cache_sim_data_free(sd->img_cd);
- sd->img_cd = NULL;
+ sd->img_cd = nullptr;
cache_sim_data_free(sd->search_similarity_cd);
- sd->search_similarity_cd = NULL;
+ sd->search_similarity_cd = nullptr;
search_buffer_flush(sd);
filelist_free(sd->search_folder_list);
- sd->search_folder_list = NULL;
+ sd->search_folder_list = nullptr;
g_list_free(sd->search_done_list);
- sd->search_done_list = NULL;
+ sd->search_done_list = nullptr;
filelist_free(sd->search_file_list);
- sd->search_file_list = NULL;
+ sd->search_file_list = nullptr;
sd->match_broken_enable = FALSE;
if (recursive_mkdir_if_not_exists(base, mode))
{
g_free(cd->path);
- cd->path = cache_get_location(CACHE_TYPE_SIM, path, TRUE, NULL);
+ cd->path = cache_get_location(CACHE_TYPE_SIM, path, TRUE, nullptr);
if (cache_sim_data_save(cd))
{
filetime_set(cd->path, filetime(image_loader_get_fd(sd->img_loader)->path));
}
image_loader_free(sd->img_loader);
- sd->img_loader = NULL;
+ sd->img_loader = nullptr;
sd->search_idle_id = g_idle_add(search_step_cb, sd);
}
else
{
image_loader_free(sd->img_loader);
- sd->img_loader = NULL;
+ sd->img_loader = nullptr;
}
}
}
}
cache_sim_data_free(sd->img_cd);
- sd->img_cd = NULL;
+ sd->img_cd = nullptr;
*match = (tmatch && tested);
}
if (sd->search_name_match_case)
{
- match = g_regex_match(sd->search_name_regex, fd_name_or_path, GRegexMatchFlags(0), NULL);
+ match = g_regex_match(sd->search_name_regex, fd_name_or_path, GRegexMatchFlags(0), nullptr);
}
else
{
/* sd->search_name is converted in search_start() */
gchar *haystack = g_utf8_strdown(fd_name_or_path, -1);
- match = g_regex_match(sd->search_name_regex, haystack, GRegexMatchFlags(0), NULL);
+ match = g_regex_match(sd->search_name_regex, haystack, GRegexMatchFlags(0), nullptr);
g_free(haystack);
}
}
if (sd->match_comment == SEARCH_MATCH_CONTAINS)
{
- match = g_regex_match(sd->search_comment_regex, comment, GRegexMatchFlags(0), NULL);
+ match = g_regex_match(sd->search_comment_regex, comment, GRegexMatchFlags(0), nullptr);
}
else if (sd->match_comment == SEARCH_MATCH_NONE)
{
- match = !g_regex_match(sd->search_comment_regex, comment, GRegexMatchFlags(0), NULL);
+ match = !g_regex_match(sd->search_comment_regex, comment, GRegexMatchFlags(0), nullptr);
}
g_free(comment);
}
match = FALSE;
gint search_marks = -1;
gint i = 0;
- gchar *marks_string = NULL;
+ gchar *marks_string = nullptr;
if (g_strcmp0(gtk_combo_box_text_get_active_text(
GTK_COMBO_BOX_TEXT(sd->marks_type)), _("Any mark")) == 0)
search_marks = 1 << i;
}
g_free(marks_string);
- marks_string = NULL;
+ marks_string = nullptr;
}
}
fd = static_cast<FileData *>(sd->search_folder_list->data);
- if (g_list_find(sd->search_done_list, fd) == NULL)
+ if (g_list_find(sd->search_done_list, fd) == nullptr)
{
- GList *list = NULL;
- GList *dlist = NULL;
+ GList *list = nullptr;
+ GList *dlist = nullptr;
gboolean success = FALSE;
sd->search_done_list = g_list_prepend(sd->search_done_list, fd);
if (path != fd->path)
{
FileData *dir_fd = file_data_new_dir(path);
- success = filelist_read(dir_fd, &list, NULL);
+ success = filelist_read(dir_fd, &list, nullptr);
file_data_unref(dir_fd);
}
- success |= filelist_read(fd, NULL, &dlist);
+ success |= filelist_read(fd, nullptr, &dlist);
if (success)
{
GList *work;
static void search_start(SearchData *sd)
{
- GError *error = NULL;
+ GError *error = nullptr;
search_stop(sd);
search_result_clear(sd);
{
log_printf("Error: could not compile regular expression %s\n%s\n", sd->search_name, error->message);
g_error_free(error);
- error = NULL;
- sd->search_name_regex = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ error = nullptr;
+ sd->search_name_regex = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
if (!sd->search_comment_match_case)
{
log_printf("Error: could not compile regular expression %s\n%s\n", sd->search_comment, error->message);
g_error_free(error);
- error = NULL;
- sd->search_comment_regex = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ error = nullptr;
+ sd->search_comment_regex = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
sd->search_count = 0;
return;
}
image_loader_free(sd->img_loader);
- sd->img_loader = NULL;
+ sd->img_loader = nullptr;
}
}
return;
}
- if (sd->match_name_enable) history_combo_append_history(sd->entry_name, NULL);
+ if (sd->match_name_enable) history_combo_append_history(sd->entry_name, nullptr);
g_free(sd->search_name);
sd->search_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(sd->entry_name)));
sd->search_lat = 1000;
sd->search_lon = 1000;
sscanf(entry_text," %lf %lf ", &sd->search_lat, &sd->search_lon );
- if (!(entry_text != NULL && !g_strstr_len(entry_text, -1, "Error") &&
+ if (!(entry_text != nullptr && !g_strstr_len(entry_text, -1, "Error") &&
sd->search_lat >= -90 && sd->search_lat <= 90 &&
sd->search_lon >= -180 && sd->search_lon <= 180))
{
list = search_result_refine_list(sd);
file_data_unref(sd->search_dir_fd);
- sd->search_dir_fd = NULL;
+ sd->search_dir_fd = nullptr;
search_start(sd);
if (is_collection(collection))
{
- GList *list = NULL;
+ GList *list = nullptr;
list = collection_contents_fd(collection);
file_data_unref(sd->search_dir_fd);
- sd->search_dir_fd = NULL;
+ sd->search_dir_fd = nullptr;
search_start(sd);
static void search_window_get_geometry(SearchData *sd)
{
GdkWindow *window;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
search_result_update_idle_cancel(sd);
mfd_list_free(sd->search_buffer_list);
- sd->search_buffer_list = NULL;
+ sd->search_buffer_list = nullptr;
search_stop(sd);
search_result_clear(sd);
const gchar *stock_id;
title = _("Select collection");
- btntext = NULL;
+ btntext = nullptr;
btnfunc = reinterpret_cast<void *>(select_collection_dialog_ok_cb);
stock_id = GTK_STOCK_OK;
fdlg = file_util_file_dlg(title, "dlg_collection", sd->window, select_collection_dialog_close_cb, sd);
- generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, title, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(fdlg), nullptr, title, nullptr, FALSE);
file_dialog_add_button(fdlg, stock_id, btntext, reinterpret_cast<void(*)(FileDialog *, gpointer)>(btnfunc), TRUE);
- file_dialog_add_path_widgets(fdlg, get_collections_dir(), NULL, "search_collection", GQ_COLLECTION_EXT, _("Collection Files"));
+ file_dialog_add_path_widgets(fdlg, get_collections_dir(), nullptr, "search_collection", GQ_COLLECTION_EXT, _("Collection Files"));
gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog);
}
GdkGeometry geometry;
gint i;
gchar *marks_string;
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
sd->search_similarity_path = g_strdup(example_file->path);
}
- sd->window = window_new(GTK_WINDOW_TOPLEVEL, "search", NULL, NULL, _("Image search"));
+ sd->window = window_new(GTK_WINDOW_TOPLEVEL, "search", nullptr, nullptr, _("Image search"));
DEBUG_NAME(sd->window);
gtk_window_set_resizable(GTK_WINDOW(sd->window), TRUE);
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = DEF_SEARCH_WIDTH;
geometry.base_height = DEF_SEARCH_HEIGHT;
- gtk_window_set_geometry_hints(GTK_WINDOW(sd->window), NULL, &geometry,
+ gtk_window_set_geometry_hints(GTK_WINDOW(sd->window), nullptr, &geometry,
static_cast<GdkWindowHints>(GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE));
if (lw && options->save_window_positions)
hbox2 = pref_box_new(hbox, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
combo = tab_completion_new_with_history(&sd->path_entry, sd->search_dir_fd->path,
"search_path", -1,
- NULL, NULL);
- tab_completion_add_select_button(sd->path_entry, NULL, TRUE);
+ nullptr, nullptr);
+ tab_completion_add_select_button(sd->path_entry, nullptr, TRUE);
gtk_box_pack_start(GTK_BOX(hbox2), combo, TRUE, TRUE, 0);
gtk_widget_show(combo);
sd->check_recurse = pref_checkbox_new_int(hbox2, _("Recurse"),
G_CALLBACK(menu_choice_date_cb), sd);
sd->date_sel = date_selection_new();
- date_selection_time_set(sd->date_sel, time(NULL));
+ date_selection_time_set(sd->date_sel, time(nullptr));
gtk_box_pack_start(GTK_BOX(hbox), sd->date_sel, FALSE, FALSE, 0);
gtk_widget_show(sd->date_sel);
gtk_box_pack_start(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
pref_label_new(hbox2, _("and"));
sd->date_sel_end = date_selection_new();
- date_selection_time_set(sd->date_sel_end, time(NULL));
+ date_selection_time_set(sd->date_sel_end, time(nullptr));
gtk_box_pack_start(GTK_BOX(hbox2), sd->date_sel_end, FALSE, FALSE, 0);
gtk_widget_show(sd->date_sel_end);
G_CALLBACK(menu_choice_spin_cb), &sd->search_height_end);
/* Search for image similarity */
- hbox = menu_choice(sd->box_search, &sd->check_similarity, NULL,
+ hbox = menu_choice(sd->box_search, &sd->check_similarity, nullptr,
_("Image content is"), &sd->match_similarity_enable,
- NULL, 0, NULL, sd);
+ nullptr, 0, nullptr, sd);
sd->spin_similarity = menu_spin(hbox, 80, 100, sd->search_similarity,
G_CALLBACK(menu_choice_spin_cb), &sd->search_similarity);
combo = tab_completion_new_with_history(&sd->entry_similarity,
(sd->search_similarity_path) ? sd->search_similarity_path : "",
- "search_similarity_path", -1, NULL, NULL);
- tab_completion_add_select_button(sd->entry_similarity, NULL, FALSE);
+ "search_similarity_path", -1, nullptr, nullptr);
+ tab_completion_add_select_button(sd->entry_similarity, nullptr, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
gtk_widget_show(combo);
pref_checkbox_new_int(hbox, _("Ignore rotation"),
/* Done the types of searches */
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* set up sorting */
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_RANK, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_RANK), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_RANK), nullptr);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_NAME, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_NAME), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_NAME), nullptr);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_SIZE, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_SIZE), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_SIZE), nullptr);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_DATE, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_DATE), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_DATE), nullptr);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_DIMENSIONS, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_DIMENSIONS), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_DIMENSIONS), nullptr);
gtk_tree_sortable_set_sort_func(sortable, SEARCH_COLUMN_PATH, search_result_sort_cb,
- GINT_TO_POINTER(SEARCH_COLUMN_PATH), NULL);
+ GINT_TO_POINTER(SEARCH_COLUMN_PATH), nullptr);
#if 0
/* by default, search results are unsorted until user selects a sort column - for speed,
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(sd->result_view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
- gtk_tree_selection_set_select_function(selection, search_result_select_cb, sd, NULL);
+ gtk_tree_selection_set_select_function(selection, search_result_select_cb, sd, nullptr);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(sd->result_view), TRUE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(sd->result_view), FALSE);
G_CALLBACK(search_thumb_toggle_cb), sd);
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->button_thumbs), "Ctrl-T");
- frame = gtk_frame_new(NULL);
+ frame = gtk_frame_new(nullptr);
DEBUG_NAME(frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, PREF_PAD_SPACE);
gtk_box_pack_start(GTK_BOX(hbox), sd->label_progress, TRUE, TRUE, 0);
gtk_widget_show(sd->label_progress);
- sd->spinner = spinner_new(NULL, -1);
+ sd->spinner = spinner_new(nullptr, -1);
gtk_box_pack_start(GTK_BOX(hbox), sd->spinner, FALSE, FALSE, 0);
gtk_widget_show(sd->spinner);
- sd->button_help = pref_button_new(hbox, GTK_STOCK_HELP, NULL, FALSE, G_CALLBACK(search_window_help_cb), sd);
+ sd->button_help = pref_button_new(hbox, GTK_STOCK_HELP, nullptr, FALSE, G_CALLBACK(search_window_help_cb), sd);
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->button_help), "F1");
gtk_widget_set_sensitive(sd->button_help, TRUE);
pref_spacer(hbox, PREF_PAD_BUTTON_GAP);
- sd->button_start = pref_button_new(hbox, GTK_STOCK_FIND, NULL, FALSE,
+ sd->button_start = pref_button_new(hbox, GTK_STOCK_FIND, nullptr, FALSE,
G_CALLBACK(search_start_cb), sd);
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->button_start), "Ctrl-Return");
pref_spacer(hbox, PREF_PAD_BUTTON_GAP);
- sd->button_stop = pref_button_new(hbox, GTK_STOCK_STOP, NULL, FALSE,
+ sd->button_stop = pref_button_new(hbox, GTK_STOCK_STOP, nullptr, FALSE,
G_CALLBACK(search_start_cb), sd);
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->button_stop), "Ctrl-Return");
gtk_widget_set_sensitive(sd->button_stop, FALSE);
pref_spacer(hbox, PREF_PAD_BUTTON_GAP);
- sd->button_close = pref_button_new(hbox, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(search_window_close_cb), sd);
+ sd->button_close = pref_button_new(hbox, GTK_STOCK_CLOSE, nullptr, FALSE, G_CALLBACK(search_window_close_cb), sd);
gtk_widget_set_tooltip_text(GTK_WIDGET(sd->button_close), "Ctrl-W");
gtk_widget_set_sensitive(sd->button_close, TRUE);
free_file_name:
g_free(ssi->file_name);
- ssi->file_name = NULL;
+ ssi->file_name = nullptr;
free_f:
g_free(ssi);
- ssi = NULL;
+ ssi = nullptr;
end:
- return NULL;
+ return nullptr;
}
SecureSaveInfo *
static void shortcuts_add_close(ShortcutsData *scd)
{
if (scd->dialog) file_dialog_close(scd->dialog);
- scd->dialog_name_entry = NULL;
- scd->dialog = NULL;
+ scd->dialog_name_entry = nullptr;
+ scd->dialog = nullptr;
}
static void shortcuts_add_ok_cb(FileDialog *fd, gpointer data)
scd->dialog = file_util_file_dlg(title,
"add_shortcuts", button,
shortcuts_add_cancel_cb, scd);
- file_dialog_add_button(scd->dialog, GTK_STOCK_OK, NULL, shortcuts_add_ok_cb, TRUE);
+ file_dialog_add_button(scd->dialog, GTK_STOCK_OK, nullptr, shortcuts_add_ok_cb, TRUE);
- generic_dialog_add_message(GENERIC_DIALOG(scd->dialog), NULL, title, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(scd->dialog), nullptr, title, nullptr, FALSE);
- file_dialog_add_path_widgets(scd->dialog, NULL, NULL, "add_shortcuts", NULL, NULL);
+ file_dialog_add_path_widgets(scd->dialog, nullptr, nullptr, "add_shortcuts", nullptr, nullptr);
hbox = pref_box_new(GENERIC_DIALOG(scd->dialog)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
ShortcutsData *scd;
GtkWidget *tbar;
- if (!lw) return NULL;
+ if (!lw) return nullptr;
scd = g_new0(ShortcutsData, 1);
tbar = pref_toolbar_new(scd->vbox, GTK_TOOLBAR_ICONS);
- scd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, NULL, FALSE,
+ scd->add_button = pref_toolbar_button(tbar, GTK_STOCK_ADD, nullptr, FALSE,
_("Add Shortcut"),
G_CALLBACK(shortcuts_add_cb), scd);
GtkWidget *shortcuts_new_default(LayoutWindow *lw)
{
- return shortcuts_new_from_config(lw, NULL, NULL);
+ return shortcuts_new_from_config(lw, nullptr, nullptr);
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
static GList *generate_list(SlideShowData *ss)
{
- GList *list = NULL;
+ GList *list = nullptr;
if (ss->from_selection)
{
{
GList *src_list;
GPtrArray *src_array;
- GList *list = NULL;
+ GList *list = nullptr;
src_list = generate_list(ss);
src_array = generate_ptr_array_from_list(src_list);
if (ss->list_done)
{
g_list_free(ss->list_done);
- ss->list_done = NULL;
+ ss->list_done = nullptr;
}
if (ss->list) g_list_free(ss->list);
else
imd_fd = image_get_fd(ss->imd);
- if ( ((imd_fd == NULL) != (ss->slide_fd == NULL)) ||
+ if ( ((imd_fd == nullptr) != (ss->slide_fd == nullptr)) ||
(imd_fd && ss->slide_fd && imd_fd != ss->slide_fd) ) return FALSE;
if (ss->filelist) return TRUE;
if (dir_fd && ss->dir_fd && dir_fd == ss->dir_fd)
{
- if (ss->from_selection && ss->slide_count == layout_selection_count(ss->lw, NULL)) return TRUE;
- if (!ss->from_selection && ss->slide_count == layout_list_count(ss->lw, NULL)) return TRUE;
+ if (ss->from_selection && ss->slide_count == layout_selection_count(ss->lw, nullptr)) return TRUE;
+ if (!ss->from_selection && ss->slide_count == layout_list_count(ss->lw, nullptr)) return TRUE;
}
return FALSE;
}
file_data_unref(ss->slide_fd);
- ss->slide_fd = NULL;
+ ss->slide_fd = nullptr;
if (ss->filelist)
{
if (ss->from_selection)
{
layout_set_fd(ss->lw, ss->slide_fd);
- layout_status_update_info(ss->lw, NULL);
+ layout_status_update_info(ss->lw, nullptr);
}
else
{
SlideShowData *ss;
gint start_index = -1;
- if (!filelist && !cd && layout_list_count(target_lw, NULL) < 1) return NULL;
+ if (!filelist && !cd && layout_list_count(target_lw, nullptr) < 1) return nullptr;
ss = g_new0(SlideShowData, 1);
{
/* layout method */
- ss->slide_count = layout_selection_count(ss->lw, NULL);
+ ss->slide_count = layout_selection_count(ss->lw, nullptr);
ss->dir_fd = file_data_ref(ss->lw->dir_fd);
if (ss->slide_count < 2)
{
- ss->slide_count = layout_list_count(ss->lw, NULL);
+ ss->slide_count = layout_list_count(ss->lw, nullptr);
if (!options->slideshow.random && start_point >= 0 && static_cast<guint>(start_point) < ss->slide_count)
{
start_index = start_point;
else
{
slideshow_free(ss);
- ss = NULL;
+ ss = nullptr;
}
return ss;
SlideShowData *slideshow_start_from_filelist(LayoutWindow *target_lw, ImageWindow *imd, GList *list,
void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data)
{
- return real_slideshow_start(target_lw, imd, list, -1, NULL, NULL, stop_func, stop_data);
+ return real_slideshow_start(target_lw, imd, list, -1, nullptr, nullptr, stop_func, stop_data);
}
SlideShowData *slideshow_start_from_collection(LayoutWindow *target_lw, ImageWindow *imd, CollectionData *cd,
void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data,
CollectInfo *start_info)
{
- return real_slideshow_start(target_lw, imd, NULL, -1, cd, start_info, stop_func, stop_data);
+ return real_slideshow_start(target_lw, imd, nullptr, -1, cd, start_info, stop_func, stop_data);
}
SlideShowData *slideshow_start(LayoutWindow *lw, gint start_point,
void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data)
{
- return real_slideshow_start(lw, NULL, NULL, start_point, NULL, NULL, stop_func, stop_data);
+ return real_slideshow_start(lw, nullptr, nullptr, start_point, nullptr, nullptr, stop_func, stop_data);
}
gboolean slideshow_paused(SlideShowData *ss)
static void thumb_loader_std_reset(ThumbLoaderStd *tl)
{
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
file_data_unref(tl->fd);
- tl->fd = NULL;
+ tl->fd = nullptr;
g_free(tl->thumb_path);
- tl->thumb_path = NULL;
+ tl->thumb_path = nullptr;
g_free(tl->thumb_uri);
- tl->thumb_uri = NULL;
- tl->local_uri = NULL;
+ tl->thumb_uri = nullptr;
+ tl->local_uri = nullptr;
tl->thumb_path_local = FALSE;
static gchar *thumb_std_cache_path(const gchar *path, const gchar *uri, gboolean local,
const gchar *cache_subfolder)
{
- gchar *result = NULL;
+ gchar *result = nullptr;
gchar *md5_text;
guchar digest[16];
gchar *name;
- if (!path || !uri || !cache_subfolder) return NULL;
+ if (!path || !uri || !cache_subfolder) return nullptr;
md5_get_digest(reinterpret_cast<const guchar *>(uri), strlen(uri), digest);
md5_text = md5_digest_to_text(digest);
- if (!md5_text) return NULL;
+ if (!md5_text) return nullptr;
name = g_strconcat(md5_text, THUMB_NAME_EXTENSION, NULL);
const gchar *folder;
gint w, h;
- if (!tl->fd || !tl->thumb_uri) return NULL;
+ if (!tl->fd || !tl->thumb_uri) return nullptr;
if (pixbuf)
{
gchar *fail_path;
gboolean result = FALSE;
- fail_path = thumb_loader_std_cache_path(tl, FALSE, NULL, TRUE);
+ fail_path = thumb_loader_std_cache_path(tl, FALSE, nullptr, TRUE);
if (isfile(fail_path))
{
GdkPixbuf *pixbuf;
if (tl->cache_retry)
{
- pixbuf = NULL;
+ pixbuf = nullptr;
}
else
{
gchar *pathl;
pathl = path_from_utf8(fail_path);
- pixbuf = gdk_pixbuf_new_from_file(pathl, NULL);
+ pixbuf = gdk_pixbuf_new_from_file(pathl, nullptr);
g_free(pathl);
}
const gchar *mtime_str;
mtime_str = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_MTIME);
- if (mtime_str && strtol(mtime_str, NULL, 10) == tl->source_mtime)
+ if (mtime_str && strtol(mtime_str, nullptr, 10) == tl->source_mtime)
{
result = TRUE;
DEBUG_1("thumb fail valid: %s", tl->fd->path);
if (!mtime_str || !uri || !valid_uri) return FALSE;
if (strcmp(uri, valid_uri) != 0) return FALSE;
- mtime = strtol(mtime_str, NULL, 10);
+ mtime = strtol(mtime_str, nullptr, 10);
if (tl->source_mtime != mtime) return FALSE;
return TRUE;
mark_app = g_strdup_printf("%s %s", GQ_APPNAME, VERSION);
mark_mtime = g_strdup_printf("%llu", static_cast<unsigned long long>(tl->source_mtime));
pathl = path_from_utf8(tmp_path);
- success = gdk_pixbuf_save(pixbuf, pathl, "png", NULL,
+ success = gdk_pixbuf_save(pixbuf, pathl, "png", nullptr,
THUMB_MARKER_URI, mark_uri,
THUMB_MARKER_MTIME, mark_mtime,
THUMB_MARKER_APP, mark_app,
void thumb_loader_std_calibrate_pixbuf(FileData *fd, GdkPixbuf *pixbuf) {
- ColorMan *cm = NULL;
- ExifData *exif = NULL;
+ ColorMan *cm = nullptr;
+ ExifData *exif = nullptr;
gint color_profile_from_image = COLOR_PROFILE_NONE;
ColorManProfileType input_type = COLOR_PROFILE_MEM;
ColorManProfileType screen_type;
- const gchar *input_file = NULL;
- guchar *profile = NULL;
+ const gchar *input_file = nullptr;
+ guchar *profile = nullptr;
guint profile_len;
gint sw, sh;
if (profile)
{
- cm = color_man_new_embedded(NULL, pixbuf,
+ cm = color_man_new_embedded(nullptr, pixbuf,
profile, profile_len,
- screen_type, NULL, NULL, 0);
+ screen_type, nullptr, nullptr, 0);
g_free(profile);
}
else
{
- cm = color_man_new(NULL, pixbuf,
+ cm = color_man_new(nullptr, pixbuf,
input_type, input_file,
- screen_type, NULL, NULL, 0);
+ screen_type, nullptr, nullptr, 0);
}
if(cm) {
static GdkPixbuf *thumb_loader_std_finish(ThumbLoaderStd *tl, GdkPixbuf *pixbuf, gboolean shrunk)
{
- GdkPixbuf *pixbuf_thumb = NULL;
+ GdkPixbuf *pixbuf_thumb = nullptr;
GdkPixbuf *result;
- GdkPixbuf *rotated = NULL;
+ GdkPixbuf *rotated = nullptr;
gint sw, sh;
* so specifically save as a local thumbnail.
*/
g_free(tl->thumb_path);
- tl->thumb_path = NULL;
+ tl->thumb_path = nullptr;
tl->cache_hit = FALSE;
static gboolean thumb_loader_std_next_source(ThumbLoaderStd *tl, gboolean remove_broken)
{
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
if (tl->thumb_path)
{
}
g_free(tl->thumb_path);
- tl->thumb_path = NULL;
+ tl->thumb_path = nullptr;
if (!tl->thumb_path_local)
{
- tl->thumb_path = thumb_loader_std_cache_path(tl, TRUE, NULL, FALSE);
+ tl->thumb_path = thumb_loader_std_cache_path(tl, TRUE, nullptr, FALSE);
if (isfile(tl->thumb_path))
{
FileData *fd = file_data_new_no_grouping(tl->thumb_path);
}
g_free(tl->thumb_path);
- tl->thumb_path = NULL;
+ tl->thumb_path = nullptr;
}
if (thumb_loader_std_setup(tl, tl->fd)) return TRUE;
}
- thumb_loader_std_save(tl, NULL);
+ thumb_loader_std_save(tl, nullptr);
return FALSE;
}
return;
}
- tl->cache_hit = (tl->thumb_path != NULL);
+ tl->cache_hit = (tl->thumb_path != nullptr);
if (tl->fd)
{
auto tl = static_cast<ThumbLoaderStd *>(data);
/* if at least some of the image is available, go to done */
- if (image_loader_get_pixbuf(tl->il) != NULL)
+ if (image_loader_get_pixbuf(tl->il) != nullptr)
{
thumb_loader_std_done_cb(il, data);
return;
}
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
return FALSE;
}
gboolean thumb_loader_std_start(ThumbLoaderStd *tl, FileData *fd)
{
- static gchar *thumb_cache = NULL;
+ static gchar *thumb_cache = nullptr;
struct stat st;
if (!tl || !fd) return FALSE;
gchar *pathl;
pathl = path_from_utf8(fd->path);
- tl->thumb_uri = g_filename_to_uri(pathl, NULL, NULL);
+ tl->thumb_uri = g_filename_to_uri(pathl, nullptr, nullptr);
tl->local_uri = filename_from_path(tl->thumb_uri);
g_free(pathl);
}
{
gint found;
- tl->thumb_path = thumb_loader_std_cache_path(tl, FALSE, NULL, FALSE);
+ tl->thumb_path = thumb_loader_std_cache_path(tl, FALSE, nullptr, FALSE);
tl->thumb_path_local = FALSE;
found = isfile(tl->thumb_path);
if (!thumb_loader_std_setup(tl, tl->fd))
{
- thumb_loader_std_save(tl, NULL);
+ thumb_loader_std_save(tl, nullptr);
thumb_loader_std_set_fallback(tl);
return FALSE;
}
}
else
{
- pixbuf = pixbuf_fallback(NULL, tl->requested_width, tl->requested_height);
+ pixbuf = pixbuf_fallback(nullptr, tl->requested_width, tl->requested_height);
}
return pixbuf;
struct stat st;
gchar *target;
- target = g_filename_from_uri(uri, NULL, NULL);
+ target = g_filename_from_uri(uri, nullptr, nullptr);
if (stat(target, &st) == 0 &&
- st.st_mtime == strtol(mtime_str, NULL, 10))
+ st.st_mtime == strtol(mtime_str, nullptr, 10))
{
valid = TRUE;
}
{
time_t now;
- now = time(NULL);
+ now = time(nullptr);
if (st.st_atime >= now - static_cast<time_t>(tv->days) * 24 * 60 * 60)
{
valid = TRUE;
thumb_loader_std_set_callbacks(tv->tl,
thumb_loader_std_thumb_file_validate_done_cb,
thumb_loader_std_thumb_file_validate_error_cb,
- NULL,
+ nullptr,
tv);
thumb_loader_std_reset(tv->tl);
gchar *sourcel;
sourcel = path_from_utf8(source);
- uri = g_filename_to_uri(sourcel, NULL, NULL);
+ uri = g_filename_to_uri(sourcel, nullptr, nullptr);
g_free(sourcel);
/* all this to remove a thumbnail? */
gint pass;
};
-static GList *thumb_std_maint_move_list = NULL;
-static GList *thumb_std_maint_move_tail = NULL;
+static GList *thumb_std_maint_move_list = nullptr;
+static GList *thumb_std_maint_move_tail = nullptr;
static void thumb_std_maint_move_step(TMaintMove *tm);
tm->tl->cache_local = FALSE;
file_data_unref(tm->tl->fd);
tm->tl->fd = file_data_new_group(tm->dest);
- tm->tl->source_mtime = strtol(mtime_str, NULL, 10);
+ tm->tl->source_mtime = strtol(mtime_str, nullptr, 10);
pathl = path_from_utf8(tm->tl->fd->path);
g_free(tm->tl->thumb_uri);
- tm->tl->thumb_uri = g_filename_to_uri(pathl, NULL, NULL);
+ tm->tl->thumb_uri = g_filename_to_uri(pathl, nullptr, nullptr);
tm->tl->local_uri = filename_from_path(tm->tl->thumb_uri);
g_free(pathl);
g_free(tm->tl->thumb_path);
- tm->tl->thumb_path = NULL;
+ tm->tl->thumb_path = nullptr;
tm->tl->thumb_path_local = FALSE;
DEBUG_1("thumb move attempting save:");
if (thumb_std_maint_move_list)
{
- g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, NULL, NULL);
+ g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, nullptr, nullptr);
}
return;
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;
+ if (!thumb_std_maint_move_list) thumb_std_maint_move_tail = nullptr;
pathl = path_from_utf8(tm->source);
- tm->source_uri = g_filename_to_uri(pathl, NULL, NULL);
+ tm->source_uri = g_filename_to_uri(pathl, nullptr, nullptr);
g_free(pathl);
tm->pass = 0;
if (!thumb_std_maint_move_list)
{
- g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, NULL, NULL);
+ g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, nullptr, nullptr);
}
if (thumb_std_maint_move_tail)
GdkPixbuf *pixbuf;
gint pw, ph;
gint save;
- GdkPixbuf *rotated = NULL;
+ GdkPixbuf *rotated = nullptr;
DEBUG_1("thumb done: %s", tl->fd->path);
if (!image_loader_start(tl->il))
{
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
DEBUG_1("regeneration failure: %s", tl->fd->path);
thumb_loader_error_cb(tl->il, tl);
auto tl = static_cast<ThumbLoader *>(data);
/* if at least some of the image is available, go to done_cb */
- if (image_loader_get_pixbuf(tl->il) != NULL)
+ if (image_loader_get_pixbuf(tl->il) != nullptr)
{
thumb_loader_done_cb(il, data);
return;
DEBUG_1("thumb error: %s", tl->fd->path);
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
thumb_loader_set_fallback(tl);
gboolean thumb_loader_start(ThumbLoader *tl, FileData *fd)
{
- gchar *cache_path = NULL;
+ gchar *cache_path = nullptr;
if (!tl) return FALSE;
else
{
g_free(cache_path);
- cache_path = NULL;
+ cache_path = nullptr;
}
}
}
}
image_loader_free(tl->il);
- tl->il = NULL;
+ tl->il = nullptr;
thumb_loader_set_fallback(tl);
return FALSE;
}
}
else
{
- pixbuf = pixbuf_fallback(NULL, tl->max_w, tl->max_h);
+ pixbuf = pixbuf_fallback(nullptr, tl->max_w, tl->max_h);
}
return pixbuf;
{
DEBUG_1("Notify thumb: %s %04x", fd->path, type);
g_object_unref(fd->thumb_pixbuf);
- fd->thumb_pixbuf = NULL;
+ fd->thumb_pixbuf = nullptr;
}
}
{
FILE *file;
gchar buffer[XV_BUFFER];
- guchar *data = NULL;
+ guchar *data = nullptr;
file = fopen(filename, "rt");
- if (!file) return NULL;
+ if (!file) return nullptr;
- if (fgets(buffer, XV_BUFFER, file) != NULL
+ if (fgets(buffer, XV_BUFFER, file) != nullptr
&& strncmp(buffer, "P7 332", 6) == 0)
{
gint width, height, depth;
g_free(packed_data);
pixbuf = gdk_pixbuf_new_from_data(rgb_data, GDK_COLORSPACE_RGB, FALSE, 8,
- width, height, 3 * width, free_rgb_buffer, NULL);
+ width, height, 3 * width, free_rgb_buffer, nullptr);
if (pixbuf_scale_aspect(width, height, max_w, max_h, &width, &height))
{
return pixbuf;
}
- return NULL;
+ return nullptr;
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
{"SBar", N_("Info sidebar"), PIXBUF_INLINE_ICON_INFO},
{"SBarSort", N_("Sort manager"), PIXBUF_INLINE_ICON_SORT},
{"Quit", N_("Quit"), GTK_STOCK_QUIT},
- {NULL, NULL, NULL}
+ {nullptr, nullptr, nullptr}
};
/**
menu_item_add_divider(menu);
}
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static gboolean toolbar_press_cb(GtkGesture *UNUSED(gesture), int UNUSED(n_press), double UNUSED(x), double UNUSED(y), gpointer data)
static void get_toolbar_item(const gchar *name, gchar **label, gchar **stock_id)
{
const UseableToolbarItems *list = useable_toolbar_items;
- *label = NULL;
- *stock_id = NULL;
+ *label = nullptr;
+ *stock_id = nullptr;
while (list->name)
{
GdkPixbuf *pixbuf;
gchar *iconl;
iconl = path_from_utf8(toolbar_entry->stock_id);
- pixbuf = gdk_pixbuf_new_from_file(iconl, NULL);
+ pixbuf = gdk_pixbuf_new_from_file(iconl, nullptr);
g_free(iconl);
if (pixbuf)
{
{
GList *editors_list;
GList *work;
- *label = NULL;
- *stock_id = NULL;
+ *label = nullptr;
+ *stock_id = nullptr;
editors_list = editor_list_get();
work = editors_list;
}
g_list_free(editors_list);
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
static gboolean toolbar_menu_add_cb(GtkWidget *widget, gpointer data)
GtkWidget *tbar;
GtkWidget *add_box;
- if (!lw) return NULL;
+ if (!lw) return nullptr;
if (!toolbarlist[bar])
{
toolbarlist[bar]->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
gtk_widget_show(toolbarlist[bar]->widget);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_NONE);
FileData *dir_fd;
dir_fd = file_data_new_dir(options->file_ops.safe_delete_path);
- if (!filelist_read(dir_fd, &list, NULL))
+ if (!filelist_read(dir_fd, &list, nullptr))
{
file_data_unref(dir_fd);
return 0;
fd = static_cast<FileData *>(work->data);
work = work->next;
- v = static_cast<gint>(strtol(fd->name, NULL, 10));
+ v = static_cast<gint>(strtol(fd->name, nullptr, 10));
if (v >= n) n = v + 1;
total += fd->size;
{
file_util_warning_dialog(_("Delete failed"),
_("Unable to remove old file from trash folder"),
- GTK_STOCK_DIALOG_WARNING, NULL);
+ GTK_STOCK_DIALOG_WARNING, nullptr);
warned = TRUE;
}
total -= fd->size;
gboolean file_util_safe_unlink(const gchar *path)
{
- static GenericDialog *gd = NULL;
- gchar *result = NULL;
+ static GenericDialog *gd = nullptr;
+ gchar *result = nullptr;
gboolean success = TRUE;
gchar *message;
{
file_util_warning_dialog(_("Delete failed"),
_("Unable to remove file"),
- GTK_STOCK_DIALOG_WARNING, NULL);
+ GTK_STOCK_DIALOG_WARNING, nullptr);
success = FALSE;
}
}
gchar *buf;
buf = g_strdup_printf(_("Unable to access or create the trash folder.\n\"%s\""), options->file_ops.safe_delete_path);
- gd = file_util_warning_dialog(result, buf, GTK_STOCK_DIALOG_WARNING, NULL);
+ gd = file_util_warning_dialog(result, buf, GTK_STOCK_DIALOG_WARNING, nullptr);
g_free(buf);
}
}
else
{
GFile *tmp = g_file_new_for_path(path);
- GError *error = NULL;
+ GError *error = nullptr;
if (!g_file_trash(tmp, FALSE, &error) )
{
message = g_strconcat("See the Help file for a possible workaround.\n\n", error->message, NULL);
- gd = warning_dialog(_("Move to trash failed\n\n"), message, GTK_STOCK_DIALOG_ERROR, NULL);
+ gd = warning_dialog(_("Move to trash failed\n\n"), message, GTK_STOCK_DIALOG_ERROR, nullptr);
generic_dialog_add_button(gd, GTK_STOCK_HELP, "Help", move_to_trash_failed_cb, FALSE);
g_free(message);
gchar *file_util_safe_delete_status(void)
{
- gchar *buf = NULL;
+ gchar *buf = nullptr;
if (is_valid_editor_command(CMD_DELETE))
{
#define bookmark_drag_types_n 2
-static GList *bookmark_widget_list = NULL;
-static GList *bookmark_default_list = NULL;
+static GList *bookmark_widget_list = nullptr;
+static GList *bookmark_default_list = nullptr;
static void bookmark_populate_all(const gchar *key);
{
b->name = g_strdup(_("New Bookmark"));
b->path = g_strdup(homedir());
- b->key = NULL;
+ b->key = nullptr;
return b;
}
if (path_ptr && icon_ptr && icon_ptr < path_ptr)
{
log_printf("warning, bookmark icon must be after path\n");
- return NULL;
+ return nullptr;
}
if (path_ptr)
g_signal_connect(G_OBJECT(gd->dialog), "destroy",
G_CALLBACK(bookmark_edit_destroy_cb), p);
- generic_dialog_add_message(gd, NULL, _("Edit Bookmark"), NULL, FALSE);
+ generic_dialog_add_message(gd, nullptr, _("Edit Bookmark"), nullptr, FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr,
bookmark_edit_ok_cb, TRUE);
table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
pref_table_label(table, 0, 1, _("Path:"), 1.0);
label = tab_completion_new_with_history(&p->path_entry, p->bb->path,
- "bookmark_path", -1, NULL, NULL);
- tab_completion_add_select_button(p->path_entry, NULL, TRUE);
+ "bookmark_path", -1, nullptr, nullptr);
+ tab_completion_add_select_button(p->path_entry, nullptr, TRUE);
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2);
generic_dialog_attach_default(gd, p->path_entry);
gtk_widget_show(label);
icon = p->bb->icon;
if (!icon) icon = "";
label = tab_completion_new_with_history(&p->icon_entry, icon,
- "bookmark_icons", -1, NULL, NULL);
+ "bookmark_icons", -1, nullptr, nullptr);
tab_completion_add_select_button(p->icon_entry, _("Select icon"), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3);
generic_dialog_attach_default(gd, p->icon_entry);
if (local)
{
- gtk_menu_popup_at_widget(GTK_MENU(menu), button, GDK_GRAVITY_NORTH_EAST, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), button, GDK_GRAVITY_NORTH_EAST, GDK_GRAVITY_CENTER, nullptr);
}
else
{
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
}
{
auto bm = static_cast<BookMarkData *>(data);
BookButtonData *b;
- GList *list = NULL;
+ GList *list = nullptr;
return;
if (gdk_drag_context_get_dest_window(context) == gtk_widget_get_window(bm->widget)) return;
if (!bookmark_default_list)
{
- buf = bookmark_string(_("Home"), homedir(), NULL);
+ buf = bookmark_string(_("Home"), homedir(), nullptr);
history_list_add_to_key(bm->key, buf, 0);
g_free(buf);
if (g_strcmp0(bm->key, "shortcuts") != 0)
{
- buf = bookmark_string(".", g_strdup(history_list_find_last_path_by_key("path_list")), NULL);
+ buf = bookmark_string(".", g_strdup(history_list_find_last_path_by_key("path_list")), nullptr);
history_list_add_to_key(bm->key, buf, 0);
g_free(buf);
}
path = g_build_filename(homedir(), "Desktop", NULL);
if (isname(path))
{
- buf = bookmark_string(_("Desktop"), path, NULL);
+ buf = bookmark_string(_("Desktop"), path, nullptr);
history_list_add_to_key(bm->key, buf, 0);
g_free(buf);
}
{
if (g_strcmp0(bm->key, "shortcuts") != 0)
{
- buf = bookmark_string(name, g_strdup(history_list_find_last_path_by_key("path_list")), NULL);
+ buf = bookmark_string(name, g_strdup(history_list_find_last_path_by_key("path_list")), nullptr);
}
else
{
}
else
{
- buf = bookmark_string(name, path, NULL);
+ buf = bookmark_string(name, path, nullptr);
}
history_list_add_to_key(bm->key, buf, 0);
g_free(buf);
if (b->icon)
{
- GdkPixbuf *pixbuf = NULL;
+ GdkPixbuf *pixbuf = nullptr;
gchar *iconl;
iconl = path_from_utf8(b->icon);
- pixbuf = gdk_pixbuf_new_from_file(iconl, NULL);
+ pixbuf = gdk_pixbuf_new_from_file(iconl, nullptr);
if (isfile(b->icon))
{
- pixbuf = gdk_pixbuf_new_from_file(iconl, NULL);
+ pixbuf = gdk_pixbuf_new_from_file(iconl, nullptr);
}
else
{
w = h = 16;
gtk_icon_size_lookup(GTK_ICON_SIZE_BUTTON, &w, &h);
- pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), b->icon, w, GTK_ICON_LOOKUP_NO_SVG, NULL);
+ pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), b->icon, w, GTK_ICON_LOOKUP_NO_SVG, nullptr);
}
g_free(iconl);
guint UNUSED(time), gpointer data)
{
auto bm = static_cast<BookMarkData *>(data);
- GList *list = NULL;
- GList *errors = NULL;
+ GList *list = nullptr;
+ GList *errors = nullptr;
GList *work;
gchar *real_path;
gchar **uris;
if (bm->only_directories && !isdir(path)) continue;
- real_path = realpath(path, NULL);
+ real_path = realpath(path, nullptr);
if (strstr(real_path, get_collections_dir()) && isfile(path))
{
}
else
{
- buf = bookmark_string(filename_from_path(path), path, NULL);
+ buf = bookmark_string(filename_from_path(path), path, nullptr);
}
history_list_add_to_key(bm->key, buf, 0);
g_free(buf);
bm->editable = TRUE;
bm->only_directories = FALSE;
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
PangoLayout *layout;
gint width, height;
bm = static_cast<BookMarkData *>(g_object_get_data(G_OBJECT(list), BOOKMARK_DATA_KEY));
if (!bm) return;
- buf = bookmark_string(name, path, NULL);
- real_path = realpath(path, NULL);
+ buf = bookmark_string(name, path, nullptr);
+ real_path = realpath(path, nullptr);
if (strstr(real_path, get_collections_dir()) && isfile(path))
{
}
else
{
- buf = bookmark_string(name, path, NULL);
+ buf = bookmark_string(name, path, nullptr);
}
}
{
gchar *text_l;
- text_l = g_locale_from_utf8(text_utf8, -1, NULL, NULL, NULL);
+ text_l = g_locale_from_utf8(text_utf8, -1, nullptr, nullptr, nullptr);
if (err)
{
fputs((text_l) ? text_l : text_utf8, stderr);
if (lc && (strstr(lc, "UTF-8") || strstr(lc, "utf-8")))
{
gchar *name;
- name = g_convert(path, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
+ name = g_convert(path, -1, "UTF-8", "ISO-8859-1", nullptr, nullptr, nullptr);
string = g_string_append(string, _("\nPreferred encoding appears to be UTF-8, however the file:\n"));
g_string_append_printf(string, "\"%s\"\n", (name) ? name : _("[name not displayable]"));
- if (g_utf8_validate(path, -1, NULL))
+ if (g_utf8_validate(path, -1, nullptr))
g_string_append_printf(string, _("\"%s\" is encoded in valid UTF-8."), (name) ? name : _("[name not displayable]"));
else
g_string_append_printf(string, _("\"%s\" is not encoded in valid UTF-8."), (name) ? name : _("[name not displayable]"));
}
gd = generic_dialog_new(_("Filename encoding locale mismatch"),
- "locale warning", NULL, TRUE, NULL, NULL);
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
+ "locale warning", nullptr, TRUE, nullptr, nullptr);
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr, nullptr, TRUE);
generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
_("Filename encoding locale mismatch"), string->str, TRUE);
#endif
{
gchar *utf8;
- GError *error = NULL;
+ GError *error = nullptr;
- if (!path) return NULL;
+ if (!path) return nullptr;
- utf8 = g_filename_to_utf8(path, -1, NULL, NULL, &error);
+ utf8 = g_filename_to_utf8(path, -1, nullptr, nullptr, &error);
if (error)
{
#if GQ_DEBUG_PATH_UTF8
#endif
{
gchar *path;
- GError *error = NULL;
+ GError *error = nullptr;
- if (!utf8) return NULL;
+ if (!utf8) return nullptr;
- path = g_filename_from_utf8(utf8, -1, NULL, NULL, &error);
+ path = g_filename_from_utf8(utf8, -1, nullptr, nullptr, &error);
if (error)
{
#if GQ_DEBUG_PATH_UTF8
/* first we try the HOME environment var, if that doesn't work, we try g_get_homedir(). */
const gchar *homedir(void)
{
- static gchar *home = NULL;
+ static gchar *home = nullptr;
if (!home)
home = path_to_utf8(getenv("HOME"));
const gchar *xdg_data_home_get(void)
{
- static const gchar *xdg_data_home = NULL;
+ static const gchar *xdg_data_home = nullptr;
if (xdg_data_home) return xdg_data_home;
const gchar *xdg_config_home_get(void)
{
- static const gchar *xdg_config_home = NULL;
+ static const gchar *xdg_config_home = nullptr;
if (xdg_config_home) return xdg_config_home;
const gchar *xdg_cache_home_get(void)
{
- static const gchar *xdg_cache_home = NULL;
+ static const gchar *xdg_cache_home = nullptr;
if (xdg_cache_home) return xdg_cache_home;
const gchar *get_rc_dir(void)
{
- static gchar *rc_dir = NULL;
+ static gchar *rc_dir = nullptr;
if (rc_dir) return rc_dir;
const gchar *get_collections_dir(void)
{
- static gchar *collections_dir = NULL;
+ static gchar *collections_dir = nullptr;
if (collections_dir) return collections_dir;
const gchar *get_trash_dir(void)
{
- static gchar *trash_dir = NULL;
+ static gchar *trash_dir = nullptr;
if (trash_dir) return trash_dir;
const gchar *get_window_layouts_dir(void)
{
- static gchar *window_layouts_dir = NULL;
+ static gchar *window_layouts_dir = nullptr;
if (window_layouts_dir) return window_layouts_dir;
gboolean copy_file(const gchar *s, const gchar *t)
{
- FILE *fi = NULL;
- FILE *fo = NULL;
- gchar *sl = NULL;
- gchar *tl = NULL;
- gchar *randname = NULL;
+ FILE *fi = nullptr;
+ FILE *fo = nullptr;
+ gchar *sl = nullptr;
+ gchar *tl = nullptr;
+ gchar *randname = nullptr;
gchar buf[16384];
size_t b;
gint ret = FALSE;
link_target = absolute;
gchar *realPath;
- realPath = realpath(link_target, NULL);
+ realPath = realpath(link_target, nullptr);
- if (realPath != NULL) // successfully resolved into an absolute path
+ if (realPath != nullptr) // successfully resolved into an absolute path
{
g_free(link_target);
link_target = g_strdup(realPath);
}
}
- fclose(fi); fi = NULL;
- fclose(fo); fo = NULL;
+ fclose(fi); fi = nullptr;
+ fclose(fo); fo = nullptr;
if (rename(randname, tl) < 0) {
unlink(randname);
void string_list_free(GList *list)
{
- g_list_foreach(list, static_cast<GFunc>(list_free_wrapper), NULL);
+ g_list_foreach(list, static_cast<GFunc>(list_free_wrapper), nullptr);
g_list_free(list);
}
GList *string_list_copy(const GList *list)
{
- GList *new_list = NULL;
+ GList *new_list = nullptr;
auto work = const_cast<GList *>(list);
while (work)
{
/* well, we tried */
g_free(unique);
- return NULL;
+ return nullptr;
}
}
{
const gchar *base;
- if (!path) return NULL;
+ if (!path) return nullptr;
base = strrchr(path, G_DIR_SEPARATOR);
if (base) return base + 1;
{
const gchar *reg_ext;
- if (!path) return NULL;
+ if (!path) return nullptr;
reg_ext = registered_extension_from_path(path);
- return g_strndup(path, strlen(path) - (reg_ext == NULL ? 0 : strlen(reg_ext)));
+ return g_strndup(path, strlen(path) - (reg_ext == nullptr ? 0 : strlen(reg_ext)));
}
void parse_out_relatives(gchar *path)
static void web_file_async_ready_cb(GObject *source_object, GAsyncResult *res, gpointer data)
{
- GError *error = NULL;
+ GError *error = nullptr;
auto web = static_cast<WebData *>(data);
gchar *tmp_filename;
}
else
{
- file_util_warning_dialog(_("Web file download failed"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(_("Web file download failed"), error->message, GTK_STOCK_DIALOG_ERROR, nullptr);
}
g_object_unref(web->tmp_g_file);
- web->tmp_g_file = NULL;
+ web->tmp_g_file = nullptr;
g_object_unref(web->cancellable);
g_object_unref(web->web_file);
}
gchar *scheme;
auto lw = static_cast<LayoutWindow *>(data);
gchar *tmp_dir;
- GError *error = NULL;
+ GError *error = nullptr;
WebData *web;
gchar *base;
gboolean ret = FALSE;
{
log_printf("Error: could not create temporary file n%s\n", error->message);
g_error_free(error);
- error = NULL;
+ error = nullptr;
ret = TRUE;
}
else
base = g_strdup(g_file_get_basename(web->web_file));
web->tmp_g_file = g_file_new_for_path(g_build_filename(tmp_dir, base, NULL));
- web->gd = generic_dialog_new(_("Download web file"), "download_web_file", NULL, TRUE, download_web_file_cancel_button_cb, web);
+ web->gd = generic_dialog_new(_("Download web file"), "download_web_file", nullptr, TRUE, download_web_file_cancel_button_cb, web);
message = g_strconcat(_("Downloading "), base, NULL);
- generic_dialog_add_message(web->gd, GTK_STOCK_DIALOG_INFO, message, NULL, FALSE);
+ generic_dialog_add_message(web->gd, GTK_STOCK_DIALOG_INFO, message, nullptr, FALSE);
web->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(web->gd->vbox), web->progress, FALSE, FALSE, 0);
gboolean rmdir_recursive(GFile *file, GCancellable *cancellable, GError **error)
{
- g_autoptr(GFileEnumerator) enumerator = NULL;
+ g_autoptr(GFileEnumerator) enumerator = nullptr;
- enumerator = g_file_enumerate_children(file, G_FILE_ATTRIBUTE_STANDARD_NAME, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, cancellable, NULL);
+ enumerator = g_file_enumerate_children(file, G_FILE_ATTRIBUTE_STANDARD_NAME, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, cancellable, nullptr);
- while (enumerator != NULL)
+ while (enumerator != nullptr)
{
GFile *child;
- if (!g_file_enumerator_iterate(enumerator, NULL, &child, cancellable, error))
+ if (!g_file_enumerator_iterate(enumerator, nullptr, &child, cancellable, error))
return FALSE;
- if (child == NULL)
+ if (child == nullptr)
break;
if (!rmdir_recursive(child, cancellable, error))
return FALSE;
*/
gint scale_factor()
{
- LayoutWindow *lw = NULL;
+ LayoutWindow *lw = nullptr;
layout_valid(&lw);
return gtk_widget_get_scale_factor(lw->window);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
if (gtk_text_iter_forward_search(&iter, needle, GTK_TEXT_SEARCH_TEXT_ONLY,
- &start, &end, NULL))
+ &start, &end, nullptr))
{
gint line;
GtkTextMark *mark;
l = strlen(s_buf);
- if (!g_utf8_validate(s_buf, l, NULL))
+ if (!g_utf8_validate(s_buf, l, nullptr))
{
- buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL);
+ buf = g_locale_to_utf8(s_buf, l, nullptr, nullptr, nullptr);
if (!buf) buf = g_strdup("\n");
}
else
{
- buf = NULL;
+ buf = nullptr;
}
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
(buf) ? buf : s_buf, -1,
/* window */
- window = window_new(GTK_WINDOW_TOPLEVEL, subclass, NULL, NULL, title);
+ window = window_new(GTK_WINDOW_TOPLEVEL, subclass, nullptr, nullptr, title);
DEBUG_NAME(window);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_window_set_default_size(GTK_WINDOW(window), HELP_WINDOW_WIDTH, HELP_WINDOW_HEIGHT);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(menu)));
- pango_parse_markup(label, -1, '_', NULL, &label_text, NULL, NULL);
+ pango_parse_markup(label, -1, '_', nullptr, &label_text, nullptr, nullptr);
label_stripped = g_strsplit(label_text, "...", 2);
- while (window_keys[i].text != NULL)
+ while (window_keys[i].text != nullptr)
{
if (g_strcmp0(window_keys[i].text, label_stripped[0]) == 0)
{
menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(menu)));
- pango_parse_markup(menu_label, -1, '_', NULL, &menu_label_text, NULL, NULL);
+ pango_parse_markup(menu_label, -1, '_', nullptr, &menu_label_text, nullptr, nullptr);
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_object_get(action, "label", &action_label, NULL);
- pango_parse_markup(action_label, -1, '_', NULL, &action_label_text, NULL, NULL);
+ pango_parse_markup(action_label, -1, '_', nullptr, &action_label_text, nullptr, nullptr);
if (g_strcmp0(action_label_text, menu_label_text) == 0)
{
GtkOrientation orientation, gboolean padding)
{
GtkWidget *box;
- GtkWidget *frame = NULL;
+ GtkWidget *frame = nullptr;
frame = gtk_frame_new(text);
gtk_box_pack_start(GTK_BOX(parent_box), frame, fill, fill, 0);
}
else
{
- GtkWidget *image = NULL;
- GtkWidget *label = NULL;
+ GtkWidget *image = nullptr;
+ GtkWidget *label = nullptr;
button = gtk_button_new();
}
else
{
- group = NULL;
+ group = nullptr;
}
if (mnemonic_text)
void pref_signal_block_data(GtkWidget *widget, gpointer data)
{
g_signal_handlers_block_matched(widget, G_SIGNAL_MATCH_DATA,
- 0, 0, NULL, NULL, data);
+ 0, 0, nullptr, nullptr, data);
}
void pref_signal_unblock_data(GtkWidget *widget, gpointer data)
{
g_signal_handlers_unblock_matched(widget, G_SIGNAL_MATCH_DATA,
- 0, 0, NULL, NULL, data);
+ 0, 0, nullptr, nullptr, data);
}
GtkWidget *pref_table_new(GtkWidget *parent_box, gint columns, gint rows,
{
GtkWidget *button;
- button = pref_button_new(NULL, stock_id, text, hide_stock_text, func, data);
+ button = pref_button_new(nullptr, stock_id, text, hide_stock_text, func, data);
gtk_table_attach(GTK_TABLE(table), button, column, column + 1, row, row + 1,
GTK_FILL, static_cast<GtkAttachOptions>(0), 0, 0);
gtk_widget_show(button);
}
else
{
- item = GTK_WIDGET(gtk_tool_button_new(NULL, NULL));
+ item = GTK_WIDGET(gtk_tool_button_new(nullptr, nullptr));
}
}
gtk_tool_button_set_use_underline(GTK_TOOL_BUTTON(item), TRUE);
gtk_widget_hide(ds->window);
gtk_widget_destroy(ds->window);
- ds->window = NULL;
- ds->calendar = NULL;
+ ds->window = nullptr;
+ ds->calendar = nullptr;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ds->button), FALSE);
}
gtk_widget_grab_focus(ds->calendar);
gdk_pointer_grab(gtk_widget_get_window(ds->window), TRUE,
static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK),
- NULL, NULL, GDK_CURRENT_TIME);
+ nullptr, nullptr, GDK_CURRENT_TIME);
gdk_keyboard_grab(gtk_widget_get_window(ds->window), TRUE, GDK_CURRENT_TIME);
gtk_grab_add(ds->window);
switch (date_format[i])
{
case 'd':
- ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
+ ds->spin_d = pref_spin_new(ds->box, nullptr, nullptr, 1, 31, 1, 0, 1, nullptr, nullptr);
break;
case 'm':
- ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
+ ds->spin_m = pref_spin_new(ds->box, nullptr, nullptr, 1, 12, 1, 0, 1, nullptr, nullptr);
break;
case 'y': case 'Y':
- ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
+ ds->spin_y = pref_spin_new(ds->box, nullptr, nullptr, 1900, 9999, 1, 0, 1900, nullptr, nullptr);
break;
default:
log_printf("Warning: Date locale %s is unknown", date_format);
}
else
{
- ds->spin_m = pref_spin_new(ds->box, NULL, NULL, 1, 12, 1, 0, 1, NULL, NULL);
- ds->spin_d = pref_spin_new(ds->box, NULL, NULL, 1, 31, 1, 0, 1, NULL, NULL);
- ds->spin_y = pref_spin_new(ds->box, NULL, NULL, 1900, 9999, 1, 0, 1900, NULL, NULL);
+ ds->spin_m = pref_spin_new(ds->box, nullptr, nullptr, 1, 12, 1, 0, 1, nullptr, nullptr);
+ ds->spin_d = pref_spin_new(ds->box, nullptr, nullptr, 1, 31, 1, 0, 1, nullptr, nullptr);
+ ds->spin_y = pref_spin_new(ds->box, nullptr, nullptr, 1900, 9999, 1, 0, 1900, nullptr, nullptr);
}
spin_increase(ds->spin_y, 5);
work = work->next;
}
- return NULL;
+ return nullptr;
}
static gboolean pref_list_get(const gchar *group, const gchar *key, const gchar *marker, const gchar **result)
if (!group || !key || !marker)
{
- *result = NULL;
+ *result = nullptr;
return FALSE;
}
if (work)
{
*result = static_cast<const gchar *>(work->data) + strlen(token);
- if (strlen(*result) == 0) *result = NULL;
+ if (strlen(*result) == 0) *result = nullptr;
ret = TRUE;
}
else
{
- *result = NULL;
+ *result = nullptr;
ret = FALSE;
}
if (text)
{
work->data = path;
- path = NULL;
+ path = nullptr;
g_free(old_path);
}
if (pref_list_get(group, key, PREF_LIST_MARKER_INT, &text) && text)
{
- *result = static_cast<gint>(strtol(text, NULL, 10));
+ *result = static_cast<gint>(strtol(text, nullptr, 10));
return TRUE;
}
}
else
{
- return NULL;
+ return nullptr;
}
}
}
else
{
- return NULL;
+ return nullptr;
}
}
DIR *dp;
struct dirent *dir;
struct stat ent_sbuf;
- GList *path_list = NULL;
- GList *file_list = NULL;
+ GList *path_list = nullptr;
+ GList *file_list = nullptr;
GList *list;
GtkListStore *store;
gchar *pathl;
g_free(pathl);
return;
}
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
if (!options->file_filter.show_dot_directory
&& dir->d_name[0] == '.' && dir->d_name[1] == '\0')
static void dest_change_dir(Dest_Data *dd, const gchar *path, gboolean retain_name)
{
- const gchar *old_name = NULL;
+ const gchar *old_name = nullptr;
gchar *full_path;
gchar *new_directory;
GdkDragContext *UNUSED(context), GtkSelectionData *selection_data,
guint UNUSED(info), guint UNUSED(time), gpointer UNUSED(data))
{
- gchar *path = NULL;
- GList *list = NULL;
+ gchar *path = nullptr;
+ GList *list = nullptr;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreeIter iter;
if (dd->right_click_path) gtk_tree_path_free(dd->right_click_path);
- dd->right_click_path = NULL;
+ dd->right_click_path = nullptr;
selection = gtk_tree_view_get_selection(view);
if (!gtk_tree_selection_get_selected(selection, &model, &iter))
{
auto dl = static_cast<DestDel_Data *>(data);
- dl->dd->gd = NULL;
+ dl->dd->gd = nullptr;
g_free(dl->path);
g_free(dl);
}
dd->entry, TRUE,
dest_view_delete_dlg_cancel, dl);
- generic_dialog_add_button(dd->gd, GTK_STOCK_DELETE, NULL, dest_view_delete_dlg_ok_cb, TRUE);
+ generic_dialog_add_button(dd->gd, GTK_STOCK_DELETE, nullptr, dest_view_delete_dlg_ok_cb, TRUE);
text = g_strdup_printf(_("About to delete the file:\n %s"), path);
generic_dialog_add_message(dd->gd, GTK_STOCK_DIALOG_QUESTION,
if (local)
{
g_object_set_data(G_OBJECT(menu), "active_view", view);
- gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(view), GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(view), GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
}
else
{
- gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
}
path = new_folder(GTK_WINDOW(dialog_window), dd->path);
gtk_window_present(GTK_WINDOW(dialog_window));
- if (path == NULL)
+ if (path == nullptr)
{
return;
}
GtkTreeIter iter;
gchar *path;
- if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
+ if (!gtk_tree_selection_get_selected(selection, nullptr, &iter)) return;
view = gtk_tree_selection_get_tree_view(selection);
store = gtk_tree_view_get_model(view);
if (view == GTK_TREE_VIEW(dd->d_view))
{
- dest_change_dir(dd, path, (dd->f_view != NULL));
+ dest_change_dir(dd, path, (dd->f_view != nullptr));
}
else
{
if (view == dd->d_view)
{
- dest_change_dir(dd, path, (dd->f_view != NULL));
+ dest_change_dir(dd, path, (dd->f_view != nullptr));
}
else
{
{
auto dd = static_cast<Dest_Data *>(data);
- dest_change_dir(dd, homedir(), (dd->f_view != NULL));
+ dest_change_dir(dd, homedir(), (dd->f_view != nullptr));
}
static void dest_show_hidden_cb(GtkWidget *UNUSED(widget), gpointer data)
static void dest_filter_clear(Dest_Data *dd)
{
string_list_free(dd->filter_list);
- dd->filter_list = NULL;
+ dd->filter_list = nullptr;
string_list_free(dd->filter_text_list);
- dd->filter_text_list = NULL;
+ dd->filter_text_list = nullptr;
dest_filter_add(dd, "*", _("All Files"), TRUE);
}
buf = gtk_entry_get_text(GTK_ENTRY(entry));
g_free(dd->filter);
- dd->filter = NULL;
+ dd->filter = nullptr;
if (strlen(buf) > 0) dd->filter = g_strdup(buf);
path = g_strdup(dd->path);
if (isdir(path))
{
- dest_change_dir(dd, path, (dd->f_view != NULL));
+ dest_change_dir(dd, path, (dd->f_view != nullptr));
}
else if (isfile(path) && dd->f_view)
{
dd = g_new0(Dest_Data, 1);
- table = gtk_table_new(4, (filter != NULL) ? 3 : 1, FALSE);
+ table = gtk_table_new(4, (filter != nullptr) ? 3 : 1, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
gtk_table_set_row_spacing(GTK_TABLE(table), 0, PREF_PAD_GAP);
gtk_widget_show(table);
dd->entry = entry;
g_object_set_data(G_OBJECT(dd->entry), "destination_data", dd);
- hbox2 = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ hbox2 = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
gtk_box_set_spacing(GTK_BOX(hbox2), PREF_PAD_BUTTON_GAP);
- pref_button_new(hbox2, NULL, _("Home"), FALSE,
+ pref_button_new(hbox2, nullptr, _("Home"), FALSE,
G_CALLBACK(dest_home_cb), dd);
- pref_button_new(hbox2, NULL, _("New folder"), FALSE,
+ pref_button_new(hbox2, nullptr, _("New folder"), FALSE,
G_CALLBACK(dest_new_dir_cb), dd);
dd->hidden_button = gtk_check_button_new_with_label(_("Show hidden"));
}
else
{
- paned = NULL;
+ paned = nullptr;
gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, 1, 2,
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 0, 0);
}
gtk_widget_show(hbox2);
/* bookmarks */
- scrolled = bookmark_list_new(NULL, dest_bookmark_select_cb, dd);
+ scrolled = bookmark_list_new(nullptr, dest_bookmark_select_cb, dd);
gtk_box_pack_start(GTK_BOX(hbox2), scrolled, FALSE, FALSE, 0);
gtk_widget_show(scrolled);
dd->bookmark_list = scrolled;
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
{
GtkListStore *store;
- hbox2 = pref_table_box(table, 2, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
+ hbox2 = pref_table_box(table, 2, 0, GTK_ORIENTATION_HORIZONTAL, nullptr);
pref_label_new(hbox2, _("Filter:"));
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
gtk_box_pack_start(GTK_BOX(hbox2), dd->filter_combo, TRUE, TRUE, 0);
gtk_widget_show(dd->filter_combo);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
n = 0;
buf = g_strdup_printf("%s%02d.png", pathl, n);
- while ((pb = gdk_pixbuf_new_from_file(buf, NULL)))
+ while ((pb = gdk_pixbuf_new_from_file(buf, nullptr)))
{
sp->list = g_list_append(sp->list, pb);
gint n;
gint w, h;
- pb = gdk_pixbuf_new_from_inline(-1, icon_spinner, FALSE, NULL);
+ pb = gdk_pixbuf_new_from_inline(-1, icon_spinner, FALSE, nullptr);
w = gdk_pixbuf_get_width(pb);
h = gdk_pixbuf_get_height(pb) / SPINNER_FRAMES;
for (n = 0; n < SPINNER_FRAMES; n++)
GList *list;
g_free(td->dir_path);
- td->dir_path = NULL;
+ td->dir_path = nullptr;
list = td->file_list;
}
g_list_free(td->file_list);
- td->file_list = NULL;
+ td->file_list = nullptr;
}
static void tab_completion_read_dir(TabCompData *td, const gchar *path)
{
DIR *dp;
struct dirent *dir;
- GList *list = NULL;
+ GList *list = nullptr;
gchar *pathl;
tab_completion_free_list(td);
g_free(pathl);
return;
}
- while ((dir = readdir(dp)) != NULL)
+ while ((dir = readdir(dp)) != nullptr)
{
gchar *name = dir->d_name;
if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0 &&
g_signal_connect(G_OBJECT(menu), "key_press_event",
G_CALLBACK(tab_completion_popup_key_press), td);
- gtk_menu_popup_at_widget(GTK_MENU(menu), td->entry, GDK_GRAVITY_NORTH_EAST, GDK_GRAVITY_NORTH, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(menu), td->entry, GDK_GRAVITY_NORTH_EAST, GDK_GRAVITY_NORTH, nullptr);
}
#ifndef CASE_SORT
if (isdir(entry_dir))
{
GList *list;
- GList *poss = NULL;
+ GList *poss = nullptr;
gint l = strlen(entry_file);
if (!td->dir_path || !td->file_list || strcmp(td->dir_path, entry_dir) != 0)
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(tab_completion_button_pressed), entry);
- pixbuf = gdk_pixbuf_new_from_inline(-1, icon_tabcomp, FALSE, NULL);
+ pixbuf = gdk_pixbuf_new_from_inline(-1, icon_tabcomp, FALSE, nullptr);
icon = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
gtk_widget_show(button);
- tab_completion_add_to_entry(combo_entry, enter_func, NULL, NULL, data);
+ tab_completion_add_to_entry(combo_entry, enter_func, nullptr, nullptr, data);
td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(combo_entry), "tab_completion_data"));
- if (!td) return NULL; /* this should never happen! */
+ if (!td) return nullptr; /* this should never happen! */
td->combo = combo;
td->has_history = TRUE;
auto td = static_cast<TabCompData *>(g_object_get_data(G_OBJECT(entry), "tab_completion_data"));
const gchar *buf;
- if (!td || !td->has_history) return NULL;
+ if (!td || !td->has_history) return nullptr;
buf = history_list_find_last_path_by_key(td->history_key);
if (buf)
{
gint l;
- if (!path) return NULL;
+ if (!path) return nullptr;
l = strlen(path);
while (l > 1 && path[l - 1] == G_DIR_SEPARATOR) l--;
{
auto td = static_cast<TabCompData *>(data);
- td->fd = NULL;
+ td->fd = nullptr;
file_dialog_close(fd);
}
{
const gchar *title;
const gchar *path;
- const gchar *filter = NULL;
- gchar *filter_desc = NULL;
+ const gchar *filter = nullptr;
+ gchar *filter_desc = nullptr;
if (td->fd)
{
title = (td->fd_title) ? td->fd_title : _("Select path");
td->fd = file_dialog_new(title, "select_path", td->entry,
tab_completion_select_cancel_cb, td);
- file_dialog_add_button(td->fd, GTK_STOCK_OK, NULL,
+ file_dialog_add_button(td->fd, GTK_STOCK_OK, nullptr,
tab_completion_select_ok_cb, TRUE);
- generic_dialog_add_message(GENERIC_DIALOG(td->fd), NULL, title, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(td->fd), nullptr, title, nullptr, FALSE);
if (td->filter)
{
}
path = gtk_entry_get_text(GTK_ENTRY(td->entry));
- if (strlen(path) == 0) path = NULL;
+ if (strlen(path) == 0) path = nullptr;
if (td->fd_folders_only)
{
- file_dialog_add_path_widgets(td->fd, NULL, path, td->history_key, NULL, NULL);
+ file_dialog_add_path_widgets(td->fd, nullptr, path, td->history_key, nullptr, nullptr);
}
else
{
- file_dialog_add_path_widgets(td->fd, NULL, path, td->history_key, filter, filter_desc);
+ file_dialog_add_path_widgets(td->fd, nullptr, path, td->history_key, filter, filter_desc);
}
gtk_widget_show(GENERIC_DIALOG(td->fd)->dialog);
gtk_grab_add(ted->window);
gdk_pointer_grab(gtk_widget_get_window(ted->window), TRUE,
static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK),
- NULL, NULL, GDK_CURRENT_TIME);
+ nullptr, nullptr, GDK_CURRENT_TIME);
gdk_keyboard_grab(gtk_widget_get_window(ted->window), TRUE, GDK_CURRENT_TIME);
return G_SOURCE_REMOVE;
{
TreeEditData *ted;
GtkTreeViewColumn *tcolumn;
- GtkCellRenderer *cell = NULL;
+ GtkCellRenderer *cell = nullptr;
GList *list;
GList *work;
cell = static_cast<GtkCellRenderer *>(work->data);
if (!GTK_IS_CELL_RENDERER_TEXT(cell))
{
- cell = NULL;
+ cell = nullptr;
}
work = work->next;
}
/* due to the fact that gtktreeview scrolls in an idle loop, we cannot
* reliably get the cell position until those scroll priority signals are processed
*/
- g_idle_add_full(G_PRIORITY_DEFAULT_IDLE - 2, tree_edit_by_path_idle_cb, ted, NULL);
+ g_idle_add_full(G_PRIORITY_DEFAULT_IDLE - 2, tree_edit_by_path_idle_cb, ted, nullptr);
return TRUE;
}
if (text_cell_only)
{
- GtkCellRenderer *cell = NULL;
+ GtkCellRenderer *cell = nullptr;
GList *renderers;
GList *work;
gint cell_x;
{
cell = static_cast<GtkCellRenderer *>(work->data);
work = work->next;
- if (!GTK_IS_CELL_RENDERER_TEXT(cell)) cell = NULL;
+ if (!GTK_IS_CELL_RENDERER_TEXT(cell)) cell = nullptr;
}
g_list_free(renderers);
tpath = gtk_tree_model_get_path(gtk_tree_view_get_model(widget), iter);
if (center && vis != 0)
{
- gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 0.5, 0.0);
+ gtk_tree_view_scroll_to_cell(widget, tpath, nullptr, TRUE, 0.5, 0.0);
}
else if (vis < 0)
{
- gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 0.0, 0.0);
+ gtk_tree_view_scroll_to_cell(widget, tpath, nullptr, TRUE, 0.0, 0.0);
}
else if (vis > 0)
{
- gtk_tree_view_scroll_to_cell(widget, tpath, NULL, TRUE, 1.0, 0.0);
+ gtk_tree_view_scroll_to_cell(widget, tpath, nullptr, TRUE, 1.0, 0.0);
}
gtk_tree_path_free(tpath);
store = gtk_tree_view_get_model(widget);
tpath = gtk_tree_model_get_path(store, iter);
- gtk_tree_view_get_cursor(widget, &fpath, NULL);
+ gtk_tree_view_get_cursor(widget, &fpath, nullptr);
if (fpath && gtk_tree_path_compare(tpath, fpath) == 0)
{
if (move)
{
- gtk_tree_view_set_cursor(widget, tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(widget, tpath, nullptr, FALSE);
}
}
}
sd = static_cast<AutoScrollData *>(g_object_get_data(G_OBJECT(widget), "autoscroll"));
if (!sd) return;
- g_object_set_data(G_OBJECT(widget), "autoscroll", NULL);
+ g_object_set_data(G_OBJECT(widget), "autoscroll", nullptr);
if (sd->timer_id) g_source_remove(sd->timer_id);
g_free(sd);
window = gtk_widget_get_window(sd->widget);
seat = gdk_display_get_default_seat(gdk_window_get_display(window));
device = gdk_seat_get_pointer(seat);
- gdk_window_get_device_position(window, device, &x, &y, NULL);
+ gdk_window_get_device_position(window, device, &x, &y, nullptr);
w = gdk_window_get_width(window);
h = gdk_window_get_height(window);
gchar *role;
};
-static GList *dialog_windows = NULL;
+static GList *dialog_windows = nullptr;
static void generic_dialog_save_window(const gchar *title, const gchar *role, gint x, gint y, gint h, gint w)
{
GtkWidget *button;
gboolean alternative_order;
- button = pref_button_new(NULL, stock_id, text, FALSE,
+ button = pref_button_new(nullptr, stock_id, text, FALSE,
G_CALLBACK(generic_dialog_click_cb), gd);
gtk_widget_set_can_default(button, TRUE);
void generic_dialog_windows_load_config(const gchar **attribute_names, const gchar **attribute_values)
{
auto dw = g_new0(DialogWindow, 1);
- gchar *title = NULL;
- gchar *role = NULL;
+ gchar *title = nullptr;
+ gchar *role = nullptr;
gint x = 0;
gint y = 0;
gint w = 0;
gd->data = data;
gd->cancel_cb = cancel_cb;
- gd->dialog = window_new(GTK_WINDOW_TOPLEVEL, role, NULL, NULL, title);
+ gd->dialog = window_new(GTK_WINDOW_TOPLEVEL, role, nullptr, nullptr, title);
DEBUG_NAME(gd->dialog);
gtk_window_set_type_hint(GTK_WINDOW(gd->dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
if (parent)
{
- GtkWindow *window = NULL;
+ GtkWindow *window = nullptr;
if (GTK_IS_WINDOW(parent))
{
gtk_window_set_resizable(GTK_WINDOW(gd->dialog), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(gd->dialog), PREF_PAD_BORDER);
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_propagate_natural_height(GTK_SCROLLED_WINDOW(scrolled), TRUE);
gtk_scrolled_window_set_propagate_natural_width(GTK_SCROLLED_WINDOW(scrolled), TRUE);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_BUTTON_SPACE);
if (gd->cancel_cb)
{
- gd->cancel_button = generic_dialog_add_button(gd, GTK_STOCK_CANCEL, NULL, gd->cancel_cb, TRUE);
+ gd->cancel_button = generic_dialog_add_button(gd, GTK_STOCK_CANCEL, nullptr, gd->cancel_cb, TRUE);
}
else
{
- gd->cancel_button = NULL;
+ gd->cancel_button = nullptr;
}
if (generic_dialog_get_alternative_button_order(gd->hbox))
G_CALLBACK(generic_dialog_show_cb), gd);
}
- gd->default_cb = NULL;
+ gd->default_cb = nullptr;
}
GenericDialog *generic_dialog_new(const gchar *title,
{
GenericDialog *gd;
- gd = generic_dialog_new(heading, "warning", parent, TRUE, NULL, NULL);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, warning_dialog_ok_cb, TRUE);
+ gd = generic_dialog_new(heading, "warning", parent, TRUE, nullptr, nullptr);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, warning_dialog_ok_cb, TRUE);
generic_dialog_add_message(gd, icon_stock_id, heading, text, TRUE);
gsize length;
gchar *result;
- result = g_data_input_stream_read_line_finish(appimage_data->data_input_stream, res, &length, NULL);
+ result = g_data_input_stream_read_line_finish(appimage_data->data_input_stream, res, &length, nullptr);
if (result && strstr(result, "-aarch64.AppImage"))
{
gsize length;
gchar *result;
- result = g_data_input_stream_read_line_finish(appimage_data->data_input_stream, res, &length, NULL);
+ result = g_data_input_stream_read_line_finish(appimage_data->data_input_stream, res, &length, nullptr);
#ifdef __x86_64__
if (result && strstr(result, "-x86_64.AppImage"))
#endif
#ifdef __arm__
- g_data_input_stream_read_line_async(appimage_data->data_input_stream, G_PRIORITY_LOW, NULL, appimage_data_arm_read_line_async_ready_cb, appimage_data);
+ g_data_input_stream_read_line_async(appimage_data->data_input_stream, G_PRIORITY_LOW, nullptr, appimage_data_arm_read_line_async_ready_cb, appimage_data);
#endif
g_free(result);
gboolean internet_available = FALSE;
net_mon = g_network_monitor_get_default();
- geeqie_github_io = g_network_address_parse_uri(APPIMAGE_VERSION_FILE, 80, NULL);
+ geeqie_github_io = g_network_address_parse_uri(APPIMAGE_VERSION_FILE, 80, nullptr);
if (geeqie_github_io)
{
- internet_available = g_network_monitor_can_reach(net_mon, geeqie_github_io, NULL, NULL);
+ internet_available = g_network_monitor_can_reach(net_mon, geeqie_github_io, nullptr, nullptr);
g_object_unref(geeqie_github_io);
}
if (internet_available)
{
appimage_data->version_file = g_file_new_for_uri(APPIMAGE_VERSION_FILE);
- appimage_data->file_input_stream = g_file_read(appimage_data->version_file, NULL, NULL);
+ appimage_data->file_input_stream = g_file_read(appimage_data->version_file, nullptr, nullptr);
appimage_data->data_input_stream = g_data_input_stream_new(G_INPUT_STREAM(appimage_data->file_input_stream));
- g_data_input_stream_read_line_async(appimage_data->data_input_stream, G_PRIORITY_LOW, NULL, appimage_data_x86_read_line_async_ready_cb, appimage_data);
+ g_data_input_stream_read_line_async(appimage_data->data_input_stream, G_PRIORITY_LOW, nullptr, appimage_data_x86_read_line_async_ready_cb, appimage_data);
}
else
{
appimage_data = g_new0(AppImageData, 1);
- appimage_data->thread_pool = g_thread_pool_new(appimage_notification_func, appimage_data, 1, FALSE, NULL);
- g_thread_pool_push(appimage_data->thread_pool, appimage_data, NULL);
+ appimage_data->thread_pool = g_thread_pool_new(appimage_notification_func, appimage_data, 1, FALSE, nullptr);
+ g_thread_pool_push(appimage_data->thread_pool, appimage_data, nullptr);
}
/*
GtkWidget *parent,
void (*cancel_cb)(FileDialog *, gpointer), gpointer data)
{
- FileDialog *fdlg = NULL;
+ FileDialog *fdlg = nullptr;
fdlg = g_new0(FileDialog, 1);
{
auto gd = static_cast<GenericDialog *>(data);
- file_dialog_entry_cb(NULL, data);
+ file_dialog_entry_cb(nullptr, data);
if (gd->default_cb) gd->default_cb(gd, gd->data);
}
if (fdlg->entry) return;
- tabcomp = tab_completion_new_with_history(&fdlg->entry, NULL,
+ tabcomp = tab_completion_new_with_history(&fdlg->entry, nullptr,
history_key, -1, file_dialog_entry_enter_cb, fdlg);
gtk_box_pack_end(GTK_BOX(GENERIC_DIALOG(fdlg)->vbox), tabcomp, FALSE, FALSE, 0);
generic_dialog_attach_default(GENERIC_DIALOG(fdlg), fdlg->entry);
g_free(prev);
}
}
- warning_dialog(_("Drag and Drop failed"), msg, GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Drag and Drop failed"), msg, GTK_STOCK_DIALOG_WARNING, nullptr);
g_free(msg);
}
{
auto path = static_cast<const gchar *>(work->data);
gchar *local_path = path_from_utf8(path);
- uris[i] = g_filename_to_uri(local_path, NULL, NULL);
+ uris[i] = g_filename_to_uri(local_path, nullptr, nullptr);
g_free(local_path);
i++;
work = work->next;
}
- uris[i] = NULL;
+ uris[i] = nullptr;
return uris;
}
GList *uri_pathlist_from_uris(gchar **uris, GList **uri_error_list)
{
- GList *list = NULL;
+ GList *list = nullptr;
guint i = 0;
- GError *error = NULL;
+ GError *error = nullptr;
while (uris[i])
{
- gchar *local_path = g_filename_from_uri(uris[i], NULL, &error);
+ gchar *local_path = g_filename_from_uri(uris[i], nullptr, &error);
if (error)
{
DEBUG_1("g_filename_from_uri failed on uri \"%s\"", uris[i]);
DEBUG_1(" error %d: %s", error->code, error->message);
if (error->code == G_CONVERT_ERROR_BAD_URI)
{
- GError *retry_error = NULL;
+ GError *retry_error = nullptr;
gchar *escaped = g_uri_escape_string(uris[i], ":/", TRUE);
- local_path = g_filename_from_uri(escaped, NULL, &retry_error);
+ local_path = g_filename_from_uri(escaped, nullptr, &retry_error);
if(retry_error)
{
DEBUG_1("manually escaped uri \"%s\" also failed g_filename_from_uri", escaped);
g_free(escaped);
}
g_error_free(error);
- error = NULL;
+ error = nullptr;
if (!local_path)
{
*uri_error_list = g_list_prepend(*uri_error_list, g_strdup(uris[i]));
GList *uri_filelist_from_gtk_selection_data(GtkSelectionData *selection_data)
{
- GList *errors = NULL;
+ GList *errors = nullptr;
gchar **uris = gtk_selection_data_get_uris(selection_data);
GList *ret = uri_filelist_from_uris(uris, &errors);
if(errors)
gboolean show_filename)
{
ImageWindow *imd;
- GtkWidget *preview_box = NULL;
+ GtkWidget *preview_box = nullptr;
GtkWidget *vbox;
- GtkWidget *label = NULL;
+ GtkWidget *label = nullptr;
if (!box) box = gd->vbox;
if (show_filename)
{
- label = pref_label_new(vbox, (fd1 == NULL) ? "" : fd1->name);
+ label = pref_label_new(vbox, (fd1 == nullptr) ? "" : fd1->name);
}
/* only the first image is stored (for use in gd_image_set) */
if (show_filename)
{
- label = pref_label_new(vbox, (fd2 == NULL) ? "" : fd2->name);
+ label = pref_label_new(vbox, (fd2 == nullptr) ? "" : fd2->name);
}
g_object_set_data(G_OBJECT(gd->dialog), "img_image2", imd);
g_object_set_data(G_OBJECT(gd->dialog), "img_label2", label);
{
GenericDialog *gd;
- gd = file_util_gen_dlg(heading, "warning", parent, TRUE, NULL, NULL);
+ gd = file_util_gen_dlg(heading, "warning", parent, TRUE, nullptr, nullptr);
generic_dialog_add_message(gd, icon_stock_id, heading, message, TRUE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, file_util_warning_dialog_ok_cb, TRUE);
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr, file_util_warning_dialog_ok_cb, TRUE);
if (options->place_dialogs_under_mouse)
{
gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE);
{
ImageWindow *imd;
GtkWidget *label;
- FileData *fd2 = NULL;
+ FileData *fd2 = nullptr;
gchar *buf;
imd = static_cast<ImageWindow *>(g_object_get_data(G_OBJECT(ud->gd->dialog), "img_image"));
}
else
{
- image_change_fd(imd, NULL, 0.0);
+ image_change_fd(imd, nullptr, 0.0);
if (label) gtk_label_set_text(GTK_LABEL(label), "");
}
}
GtkTreeSelection *selection;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
- if (gtk_tree_model_iter_nth_child(store, &iter, NULL, n))
+ if (gtk_tree_model_iter_nth_child(store, &iter, nullptr, n))
{
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_select_iter(selection, &iter);
GtkWidget *view;
GtkListStore *store;
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkTreeIter iter;
gchar *sidecars;
- sidecars = with_sidecars ? file_data_sc_list_to_string(fd) : NULL;
+ sidecars = with_sidecars ? file_data_sc_list_to_string(fd) : nullptr;
GdkPixbuf *icon = file_util_get_error_icon(fd, list, view);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
if (ud->external)
editor_skip(ud->resume_data);
else
- file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud);
+ file_util_perform_ci_cb(nullptr, EDITOR_ERROR_SKIPPED, ud->flist, ud);
}
{
g_string_append(msg, _("\n Continue multiple file operation?"));
d = file_util_gen_dlg(ud->messages.fail, "dlg_confirm",
- NULL, TRUE,
+ nullptr, TRUE,
file_util_abort_cb, ud);
- generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, NULL, msg->str, TRUE);
+ generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, nullptr, msg->str, TRUE);
generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
file_util_resume_cb, TRUE);
}
else
{
- file_util_warning_dialog(ud->messages.fail, msg->str, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(ud->messages.fail, msg->str, GTK_STOCK_DIALOG_ERROR, nullptr);
}
g_string_free(msg, TRUE);
}
gint ret;
/* take a single entry each time, this allows better control over the operation */
- GList *single_entry = g_list_append(NULL, ud->flist->data);
+ GList *single_entry = g_list_append(nullptr, ud->flist->data);
gboolean last = !ud->flist->next;
EditorFlags status = EDITOR_ERROR_STATUS;
if (ret == EDITOR_CB_SKIP)
{
- file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud);
+ file_util_perform_ci_cb(nullptr, EDITOR_ERROR_SKIPPED, ud->flist, ud);
return G_SOURCE_REMOVE;
}
}
{
case UTILITY_TYPE_DELETE_LINK:
{
- g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars
+ g_assert(ud->dir_fd->sidecar_files == nullptr); // directories should not have sidecars
if ((internal && file_data_perform_ci(ud->dir_fd)) ||
(!internal && ext_result))
{
gchar *text;
text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path);
- file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
}
file_data_free_ci(ud->dir_fd);
}
case UTILITY_TYPE_DELETE_FOLDER:
{
- FileData *fail = NULL;
+ FileData *fail = nullptr;
GList *work;
work = ud->content_list;
while (work)
if (!fail)
{
- g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars
+ g_assert(ud->dir_fd->sidecar_files == nullptr); // directories should not have sidecars
if ((internal && file_data_sc_perform_ci(ud->dir_fd)) ||
(!internal && ext_result))
{
GenericDialog *gd;
text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path);
- gd = file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
+ gd = file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
if (fail != ud->dir_fd)
}
case UTILITY_TYPE_RENAME_FOLDER:
{
- FileData *fail = NULL;
+ FileData *fail = nullptr;
GList *work;
- g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars
+ g_assert(ud->dir_fd->sidecar_files == nullptr); // directories should not have sidecars
if ((internal && file_data_sc_perform_ci(ud->dir_fd)) ||
(!internal && ext_result))
gchar *text;
text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path);
- (void) file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
+ (void) file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
file_data_unref(fail);
gchar *text;
text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path);
- (void) file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
+ (void) file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
}
break;
case UTILITY_TYPE_FILTER:
case UTILITY_TYPE_EDITOR:
- g_assert(ud->external_command != NULL); /* it should be already set */
+ g_assert(ud->external_command != nullptr); /* it should be already set */
break;
case UTILITY_TYPE_WRITE_METADATA:
- ud->external_command = NULL;
+ ud->external_command = nullptr;
}
if (is_valid_editor_command(ud->external_command))
if (editor_blocks_file(ud->external_command))
{
DEBUG_1("Starting %s and waiting for results", ud->external_command);
- flags = start_editor_from_filelist_full(ud->external_command, ud->flist, NULL, file_util_perform_ci_cb, ud);
+ flags = start_editor_from_filelist_full(ud->external_command, ud->flist, nullptr, file_util_perform_ci_cb, ud);
}
else
{
if (EDITOR_ERRORS(flags))
{
gchar *text = g_strdup_printf(_("%s\nUnable to start external command.\n"), editor_get_error_str(flags));
- file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, nullptr);
g_free(text);
- ud->gd = NULL;
+ ud->gd = nullptr;
ud->phase = UTILITY_PHASE_CANCEL;
file_util_dialog_run(ud);
}
if (!pb_warning)
{
- pb_warning = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU, NULL);
+ pb_warning = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU, nullptr);
}
if (!pb_error)
{
- pb_error = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_MENU, NULL);
+ pb_error = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_MENU, nullptr);
}
if (!pb_apply)
{
- pb_apply = gtk_widget_render_icon(widget, GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU, NULL);
+ pb_apply = gtk_widget_render_icon(widget, GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU, nullptr);
}
error = file_data_sc_verify_ci(fd, list);
void file_util_check_ci(UtilityData *ud)
{
gint error = CHANGE_OK;
- gchar *desc = NULL;
+ gchar *desc = nullptr;
if (ud->type != UTILITY_TYPE_CREATE_FOLDER &&
ud->type != UTILITY_TYPE_RENAME_FOLDER)
}
else if (ud->dir_fd)
{
- g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars
+ g_assert(ud->dir_fd->sidecar_files == nullptr); // directories should not have sidecars
error = file_data_verify_ci(ud->dir_fd, ud->flist);
if (error) desc = file_data_get_error_string(error);
}
generic_dialog_close(gd);
- ud->gd = NULL;
+ ud->gd = nullptr;
ud->phase = UTILITY_PHASE_CANCEL;
file_util_dialog_run(ud);
generic_dialog_close(gd);
- ud->gd = NULL;
+ ud->gd = nullptr;
ud->phase = UTILITY_PHASE_DISCARD;
file_util_dialog_run(ud);
generic_dialog_close(gd);
- ud->gd = NULL;
+ ud->gd = nullptr;
file_util_dialog_run(ud);
}
file_dialog_close(fdlg);
- ud->fdlg = NULL;
+ ud->fdlg = nullptr;
ud->phase = UTILITY_PHASE_CANCEL;
file_util_dialog_run(ud);
static void file_util_fdlg_rename_cb(FileDialog *fdlg, gpointer data)
{
auto ud = static_cast<UtilityData *>(data);
- gchar *desc = NULL;
- GenericDialog *d = NULL;
+ gchar *desc = nullptr;
+ GenericDialog *d = nullptr;
file_util_dest_folder_update_path(ud);
if (isdir(ud->dest_path))
{
file_dialog_sync_history(fdlg, TRUE);
file_dialog_close(fdlg);
- ud->fdlg = NULL;
+ ud->fdlg = nullptr;
file_util_dialog_run(ud);
}
else
ud->phase = UTILITY_PHASE_START;
file_dialog_close(fdlg);
- ud->fdlg = NULL;
+ ud->fdlg = nullptr;
g_free(desc);
}
}
if (isdir(ud->dest_path)) file_dialog_sync_history(fdlg, TRUE);
file_dialog_close(fdlg);
- ud->fdlg = NULL;
+ ud->fdlg = nullptr;
ud->phase = UTILITY_PHASE_ENTERING;
file_util_dialog_run(ud);
gchar *pad_end;
gint padding;
- if (!format || !name) return NULL;
+ if (!format || !name) return nullptr;
tmp = g_strdup(format);
pad_start = strchr(tmp, '#');
{
auto ud = static_cast<UtilityData *>(data);
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (path_currently_selected ||
!gtk_tree_model_get_iter(store, &iter, tpath)) return TRUE;
if (ud->discard_func) generic_dialog_add_button(ud->gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_discard_cb, FALSE);
if (ud->details_func) generic_dialog_add_button(ud->gd, GTK_STOCK_INFO, _("File details"), file_util_details_cb, FALSE);
- generic_dialog_add_button(ud->gd, stock_id, NULL, file_util_ok_cb, TRUE);
+ generic_dialog_add_button(ud->gd, stock_id, nullptr, file_util_ok_cb, TRUE);
if (ud->dir_fd)
{
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
- gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL);
+ gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, nullptr);
- generic_dialog_add_image(ud->gd, box, NULL, NULL, FALSE, NULL, NULL, FALSE);
+ generic_dialog_add_image(ud->gd, box, nullptr, nullptr, FALSE, nullptr, nullptr, FALSE);
if (ud->type == UTILITY_TYPE_DELETE ||
ud->type == UTILITY_TYPE_DELETE_LINK ||
ud->fdlg = fdlg;
- generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, ud->messages.question, NULL, FALSE);
+ generic_dialog_add_message(GENERIC_DIALOG(fdlg), nullptr, ud->messages.question, nullptr, FALSE);
label = pref_label_new(GENERIC_DIALOG(fdlg)->vbox, _("Choose the destination folder."));
gtk_label_set_xalign(GTK_LABEL(label), 0.0);
file_dialog_add_button(fdlg, stock_id, ud->messages.title, file_util_fdlg_ok_cb, TRUE);
}
- file_dialog_add_path_widgets(fdlg, NULL, ud->dest_path, "move_copy", NULL, NULL);
+ file_dialog_add_path_widgets(fdlg, nullptr, ud->dest_path, "move_copy", nullptr, nullptr);
g_signal_connect(G_OBJECT(fdlg->entry), "changed",
G_CALLBACK(file_util_dest_folder_entry_cb), ud);
ud->gd = file_util_gen_dlg(ud->messages.title, "dlg_confirm",
ud->parent, FALSE, file_util_cancel_cb, ud);
- box = generic_dialog_add_message(ud->gd, NULL, ud->messages.question, NULL, TRUE);
+ box = generic_dialog_add_message(ud->gd, nullptr, ud->messages.question, nullptr, TRUE);
if (ud->discard_func) generic_dialog_add_button(ud->gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_discard_cb, FALSE);
if (ud->details_func) generic_dialog_add_button(ud->gd, GTK_STOCK_INFO, _("File details"), file_util_details_cb, FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
- gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL);
+ gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, nullptr);
// column = file_util_rename_multiple_add_column(rd, _("Preview"), RENAME_COLUMN_PREVIEW);
if (second_image)
{
- generic_dialog_add_image(ud->gd, box, NULL, "Source", TRUE, NULL, "Destination", TRUE);
+ generic_dialog_add_image(ud->gd, box, nullptr, "Source", TRUE, nullptr, "Destination", TRUE);
}
else
{
- generic_dialog_add_image(ud->gd, box, NULL, NULL, FALSE, NULL, NULL, FALSE);
+ generic_dialog_add_image(ud->gd, box, nullptr, nullptr, FALSE, nullptr, nullptr, FALSE);
}
// gtk_container_add(GTK_CONTAINER(scrolled), view);
box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
- ud->auto_spin_start = pref_spin_new(box2, NULL, NULL,
+ ud->auto_spin_start = pref_spin_new(box2, nullptr, nullptr,
0.0, 1000000.0, 1.0, 0, options->cp_mv_rn.auto_start,
G_CALLBACK(file_util_rename_preview_adj_cb), ud);
gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
gtk_widget_show(combo);
- ud->auto_spin_pad = pref_spin_new(page, _("Padding:"), NULL,
+ ud->auto_spin_pad = pref_spin_new(page, _("Padding:"), nullptr,
1.0, 8.0, 1.0, 0, options->cp_mv_rn.auto_padding,
G_CALLBACK(file_util_rename_preview_adj_cb), ud);
box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
- ud->format_spin = pref_spin_new(box2, NULL, NULL,
+ ud->format_spin = pref_spin_new(box2, nullptr, nullptr,
0.0, 1000000.0, 1.0, 0, options->cp_mv_rn.formatted_start,
G_CALLBACK(file_util_rename_preview_adj_cb), ud);
static void file_util_warn_op_in_progress(const gchar *title)
{
- file_util_warning_dialog(title, _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, NULL);
+ file_util_warning_dialog(title, _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, nullptr);
}
static void file_util_details_dialog_close_cb(GtkWidget *UNUSED(widget), gpointer data)
gchar *message;
const gchar *stock_id;
- gd = file_util_gen_dlg(_("File details"), "details", ud->gd->dialog, TRUE, NULL, ud);
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, file_util_details_dialog_ok_cb, TRUE);
+ gd = file_util_gen_dlg(_("File details"), "details", ud->gd->dialog, TRUE, nullptr, ud);
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr, file_util_details_dialog_ok_cb, TRUE);
generic_dialog_add_button(gd, GTK_STOCK_REMOVE, _("Exclude file"), file_util_details_dialog_exclude_cb, FALSE);
g_object_set_data(G_OBJECT(gd->dialog), "file_data", fd);
box = generic_dialog_add_message(gd, stock_id, _("File details"), message, TRUE);
- generic_dialog_add_image(gd, box, fd, NULL, FALSE, NULL, NULL, FALSE);
+ generic_dialog_add_image(gd, box, fd, nullptr, FALSE, nullptr, nullptr, FALSE);
gtk_widget_show(gd->dialog);
GtkWidget *table;
GtkWidget *frame;
GtkWidget *label;
- GList *keys = NULL;
+ GList *keys = nullptr;
GList *work;
gchar *message1;
gchar *message2;
g_assert(keys);
- gd = file_util_gen_dlg(_("Overview of changed metadata"), "details", ud->gd->dialog, TRUE, NULL, ud);
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, file_util_details_dialog_ok_cb, TRUE);
+ gd = file_util_gen_dlg(_("Overview of changed metadata"), "details", ud->gd->dialog, TRUE, nullptr, ud);
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr, file_util_details_dialog_ok_cb, TRUE);
generic_dialog_add_button(gd, GTK_STOCK_REMOVE, _("Exclude file"), file_util_details_dialog_exclude_cb, FALSE);
generic_dialog_add_button(gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_details_dialog_discard_cb, FALSE);
box = pref_group_new(box, TRUE, message2, GTK_ORIENTATION_HORIZONTAL);
- frame = pref_frame_new(box, TRUE, NULL, GTK_ORIENTATION_HORIZONTAL, 2);
+ frame = pref_frame_new(box, TRUE, nullptr, GTK_ORIENTATION_HORIZONTAL, 2);
table = pref_table_new(frame, 2, g_list_length(keys), FALSE, TRUE);
work = keys;
i++;
}
- generic_dialog_add_image(gd, box, fd, NULL, FALSE, NULL, NULL, FALSE);
+ generic_dialog_add_image(gd, box, fd, nullptr, FALSE, nullptr, nullptr, FALSE);
gtk_widget_set_size_request(gd->dialog, DIALOG_WIDTH, -1);
gtk_widget_show(gd->dialog);
static void file_util_delete_full(FileData *source_fd, GList *flist, GtkWidget *parent, UtilityPhase phase, FileUtilDoneFunc done_func, gpointer done_data)
{
UtilityData *ud;
- GList *ungrouped = NULL;
+ GList *ungrouped = nullptr;
gchar *message;
if (source_fd)
ud->with_sidecars = TRUE;
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->done_data = done_data;
ud->done_func = done_func;
ud->with_sidecars = FALSE; /* operate on individual files, not groups */
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->done_func = done_func;
static void file_util_move_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
{
UtilityData *ud;
- GList *ungrouped = NULL;
+ GList *ungrouped = nullptr;
if (source_fd)
flist = g_list_append(flist, file_data_ref(source_fd));
ud->with_sidecars = TRUE;
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->details_func = file_util_details_dialog;
static void file_util_copy_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
{
UtilityData *ud;
- GList *ungrouped = NULL;
+ GList *ungrouped = nullptr;
if (source_fd)
flist = g_list_append(flist, file_data_ref(source_fd));
if (!flist) return;
- if (file_util_write_metadata_first(UTILITY_TYPE_COPY, phase, flist, dest_path, NULL, parent))
+ if (file_util_write_metadata_first(UTILITY_TYPE_COPY, phase, flist, dest_path, nullptr, parent))
return;
flist = file_data_process_groups_in_selection(flist, TRUE, &ungrouped);
ud->with_sidecars = TRUE;
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->details_func = file_util_details_dialog;
static void file_util_rename_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
{
UtilityData *ud;
- GList *ungrouped = NULL;
+ GList *ungrouped = nullptr;
if (source_fd)
flist = g_list_append(flist, file_data_ref(source_fd));
ud->with_sidecars = TRUE;
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->details_func = file_util_details_dialog;
static void file_util_start_editor_full(const gchar *key, FileData *source_fd, GList *flist, const gchar *dest_path, const gchar *working_directory, GtkWidget *parent, UtilityPhase phase)
{
UtilityData *ud;
- GList *ungrouped = NULL;
+ GList *ungrouped = nullptr;
if (editor_no_param(key))
{
- gchar *file_directory = NULL;
+ gchar *file_directory = nullptr;
if (!working_directory)
{
/* working directory was not specified, try to extract it from the files */
/* ask for destination if we don't have it */
- if (ud->type == UTILITY_TYPE_FILTER && dest_path == NULL) phase = UTILITY_PHASE_START;
+ if (ud->type == UTILITY_TYPE_FILTER && dest_path == nullptr) phase = UTILITY_PHASE_START;
ud->phase = phase;
ud->external_command = g_strdup(key);
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
ud->flist = flist;
- ud->content_list = NULL;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->details_func = file_util_details_dialog;
static GList *file_util_delete_dir_remaining_folders(GList *dlist)
{
- GList *rlist = NULL;
+ GList *rlist = nullptr;
while (dlist)
{
ud->phase = phase;
ud->with_sidecars = TRUE;
ud->dir_fd = file_data_ref(fd);
- ud->content_list = NULL;
- ud->flist = NULL;
+ ud->content_list = nullptr;
+ ud->flist = nullptr;
ud->parent = parent;
gchar *text;
gd = file_util_gen_dlg(_("Folder contains subfolders"), "dlg_warning",
- parent, TRUE, NULL, NULL);
- generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
+ parent, TRUE, nullptr, nullptr);
+ generic_dialog_add_button(gd, GTK_STOCK_CLOSE, nullptr, nullptr, TRUE);
text = g_strdup_printf(_("Unable to delete the folder:\n\n%s\n\n"
"This folder contains subfolders which must be moved before it can be deleted."),
ud->phase = phase;
ud->with_sidecars = TRUE;
ud->dir_fd = file_data_ref(fd);
- ud->content_list = NULL; /* will be filled by file_util_delete_dir_prepare */
+ ud->content_list = nullptr; /* will be filled by file_util_delete_dir_prepare */
ud->flist = flist = filelist_sort_path(flist);
ud->parent = parent;
and the content must be handled including sidecars */
ud->dir_fd = file_data_ref(fd);
- ud->flist = NULL;
- ud->content_list = NULL;
+ ud->flist = nullptr;
+ ud->content_list = nullptr;
ud->parent = parent;
ud->done_func = done_func;
ud->phase = phase;
ud->with_sidecars = TRUE;
- ud->dir_fd = NULL;
- ud->flist = NULL;
- ud->content_list = NULL;
+ ud->dir_fd = nullptr;
+ ud->flist = nullptr;
+ ud->content_list = nullptr;
ud->parent = parent;
if (dest_path)
if (!buf)
{
ud->phase = UTILITY_PHASE_CANCEL;
- ud->dir_fd = NULL;
+ ud->dir_fd = nullptr;
}
else
{
{
case UTILITY_TYPE_FILTER:
case UTILITY_TYPE_EDITOR:
- file_util_start_editor_full(dd->editor_key, NULL, dd->flist, dd->dest_path, NULL, dd->parent, dd->phase);
+ file_util_start_editor_full(dd->editor_key, nullptr, dd->flist, dd->dest_path, nullptr, dd->parent, dd->phase);
break;
case UTILITY_TYPE_COPY:
- file_util_copy_full(NULL, dd->flist, dd->dest_path, dd->parent, dd->phase);
+ file_util_copy_full(nullptr, dd->flist, dd->dest_path, dd->parent, dd->phase);
break;
default:
g_warning("unsupported type");
static gboolean file_util_write_metadata_first(UtilityType type, UtilityPhase phase, GList *flist, const gchar *dest_path, const gchar *editor_key, GtkWidget *parent)
{
- GList *unsaved = NULL;
+ GList *unsaved = nullptr;
UtilityDelayData *dd;
GList *work;
dd->editor_key = g_strdup(editor_key);
dd->parent = parent;
- file_util_write_metadata(NULL, unsaved, parent, FALSE, file_util_write_metadata_first_done, dd);
+ file_util_write_metadata(nullptr, unsaved, parent, FALSE, file_util_write_metadata_first_done, dd);
return TRUE;
}
void file_util_delete(FileData *source_fd, GList *source_list, GtkWidget *parent)
{
- file_util_delete_full(source_fd, source_list, parent, options->file_ops.confirm_delete ? UTILITY_PHASE_START : UTILITY_PHASE_ENTERING, NULL, NULL);
+ file_util_delete_full(source_fd, source_list, parent, options->file_ops.confirm_delete ? UTILITY_PHASE_START : UTILITY_PHASE_ENTERING, nullptr, nullptr);
}
void file_util_delete_notify_done(FileData *source_fd, GList *source_list, GtkWidget *parent, FileUtilDoneFunc done_func, gpointer done_data)
void file_util_rename(FileData *source_fd, GList *source_list, GtkWidget *parent)
{
- file_util_rename_full(source_fd, source_list, NULL, parent, UTILITY_PHASE_START);
+ file_util_rename_full(source_fd, source_list, nullptr, parent, UTILITY_PHASE_START);
}
/* these avoid the location entry dialog unless there is an error, list must be files only and
*/
void file_util_move_simple(GList *list, const gchar *dest_path, GtkWidget *parent)
{
- file_util_move_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING);
+ file_util_move_full(nullptr, list, dest_path, parent, UTILITY_PHASE_ENTERING);
}
void file_util_copy_simple(GList *list, const gchar *dest_path, GtkWidget *parent)
{
- file_util_copy_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING);
+ file_util_copy_full(nullptr, list, dest_path, parent, UTILITY_PHASE_ENTERING);
}
void file_util_rename_simple(FileData *fd, const gchar *dest_path, GtkWidget *parent)
{
- file_util_rename_full(fd, NULL, dest_path, parent, UTILITY_PHASE_ENTERING);
+ file_util_rename_full(fd, nullptr, dest_path, parent, UTILITY_PHASE_ENTERING);
}
void file_util_start_editor_from_file(const gchar *key, FileData *fd, GtkWidget *parent)
{
- file_util_start_editor_full(key, fd, NULL, NULL, NULL, parent, UTILITY_PHASE_ENTERING);
+ file_util_start_editor_full(key, fd, nullptr, nullptr, nullptr, parent, UTILITY_PHASE_ENTERING);
}
void file_util_start_editor_from_filelist(const gchar *key, GList *list, const gchar *working_directory, GtkWidget *parent)
{
- file_util_start_editor_full(key, NULL, list, NULL, working_directory, parent, UTILITY_PHASE_ENTERING);
+ file_util_start_editor_full(key, nullptr, list, nullptr, working_directory, parent, UTILITY_PHASE_ENTERING);
}
//void file_util_start_filter_from_file(const gchar *key, FileData *fd, const gchar *dest_path, GtkWidget *parent)
void file_util_start_filter_from_filelist(const gchar *key, GList *list, const gchar *dest_path, GtkWidget *parent)
{
- file_util_start_editor_full(key, NULL, list, dest_path, NULL, parent, UTILITY_PHASE_ENTERING);
+ file_util_start_editor_full(key, nullptr, list, dest_path, nullptr, parent, UTILITY_PHASE_ENTERING);
}
void file_util_delete_dir(FileData *fd, GtkWidget *parent)
void file_util_create_dir(FileData *dir_fd, GtkWidget *parent, FileUtilDoneFunc done_func, gpointer done_data)
{
- file_util_create_dir_full(dir_fd, NULL, parent, UTILITY_PHASE_ENTERING, done_func, done_data);
+ file_util_create_dir_full(dir_fd, nullptr, parent, UTILITY_PHASE_ENTERING, done_func, done_data);
}
void file_util_rename_dir(FileData *source_fd, const gchar *new_path, GtkWidget *parent, FileUtilDoneFunc done_func, gpointer done_data)
{
auto cbd = static_cast<ClipboardData *>(data);
gchar *file_path;
- gchar *file_path_quoted = NULL;
+ gchar *file_path_quoted = nullptr;
gchar *file_path_uri;
GString *path_list_str;
GList *work;
file_path = static_cast<gchar *>(work->data);
work = work->next;
- file_path_uri = g_filename_to_uri(file_path, NULL, NULL);
+ file_path_uri = g_filename_to_uri(file_path, nullptr, nullptr);
g_string_append(path_list_str, "\n");
g_string_append(path_list_str, file_path_uri);
g_free(file_path_uri);
if (options->clipboard_selection == CLIPBOARD_PRIMARY || options->clipboard_selection == CLIPBOARD_BOTH)
{
cbd = g_new0(ClipboardData, 1);
- cbd->path_list = NULL;
+ cbd->path_list = nullptr;
cbd->quoted = quoted;
cbd->path_list = g_list_append(cbd->path_list, g_strdup(fd->path));
if (options->clipboard_selection == CLIPBOARD_CLIPBOARD || options->clipboard_selection == CLIPBOARD_BOTH)
{
cbd = g_new0(ClipboardData, 1);
- cbd->path_list = NULL;
+ cbd->path_list = nullptr;
cbd->quoted = quoted;
cbd->path_list = g_list_append(cbd->path_list, g_strdup(fd->path));
if (options->clipboard_selection == CLIPBOARD_PRIMARY || options->clipboard_selection == CLIPBOARD_BOTH)
{
cbd = g_new0(ClipboardData, 1);
- cbd->path_list = NULL;
+ cbd->path_list = nullptr;
cbd->quoted = quoted;
work = fd_list;
if (options->clipboard_selection == CLIPBOARD_CLIPBOARD || options->clipboard_selection == CLIPBOARD_BOTH)
{
cbd = g_new0(ClipboardData, 1);
- cbd->path_list = NULL;
+ cbd->path_list = nullptr;
cbd->quoted = quoted;
work = fd_list;
gboolean ok_or_cancel = FALSE;
gint result;
gchar *new_folder_name;
- gchar *new_folder_path_full = NULL;
+ gchar *new_folder_path_full = nullptr;
gchar *window_title;
PangoLayout *layout;
gint width, height;
buf = g_build_filename(path, _("New folder"), NULL);
- folder_path = unique_filename(buf, NULL, " ", FALSE);
+ folder_path = unique_filename(buf, nullptr, " ", FALSE);
folder_name = g_path_get_basename(folder_path);
window_title = g_strconcat(_("Create Folder - "), GQ_APPNAME, NULL);
gtk_widget_destroy(dialog_warning);
g_free(new_folder_path_full);
- new_folder_path_full = NULL;
+ new_folder_path_full = nullptr;
g_free(new_folder_name);
ok_or_cancel = FALSE;
}
if (!path)
{
if (row) *row = -1;
- return NULL;
+ return nullptr;
}
n = 0;
}
if (row) *row = -1;
- return NULL;
+ return nullptr;
}
/*
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vd->view), tpath, NULL, TRUE, y_align, 0.0);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
+ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vd->view), tpath, nullptr, TRUE, y_align, 0.0);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
if (!gtk_widget_has_focus(vd->view)) gtk_widget_grab_focus(vd->view);
if (fd) return fd->path;
- return NULL;
+ return nullptr;
}
static gboolean vdlist_populate(ViewDir *vd, gboolean clear)
FileData *fd;
SortType sort_type = SORT_NAME;
gboolean sort_ascend = TRUE;
- gchar *link = NULL;
+ gchar *link = nullptr;
if (vd->layout)
{
old_list = VDLIST(vd)->list;
- ret = filelist_read(vd->dir_fd, NULL, &VDLIST(vd)->list);
+ ret = filelist_read(vd->dir_fd, nullptr, &VDLIST(vd)->list);
VDLIST(vd)->list = filelist_sort(VDLIST(vd)->list, sort_type, sort_ascend);
/* add . and .. */
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
if (clear) gtk_list_store_clear(store);
- valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &iter, NULL);
+ valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(store), &iter, nullptr);
work = VDLIST(vd)->list;
while (work)
while (!done)
{
- FileData *old_fd = NULL;
+ FileData *old_fd = nullptr;
if (valid)
{
if (islink(fd->path))
{
- link = realpath(fd->path, NULL);
+ link = realpath(fd->path, nullptr);
}
else
{
- link = NULL;
+ link = nullptr;
}
if (match < 0)
}
- vd->click_fd = NULL;
- vd->drop_fd = NULL;
+ vd->click_fd = nullptr;
+ vd->drop_fd = nullptr;
filelist_free(old_list);
g_free(link);
gboolean vdlist_set_fd(ViewDir *vd, FileData *dir_fd)
{
gboolean ret;
- gchar *old_path = NULL; /* Used to store directory for walking up */
+ gchar *old_path = nullptr; /* Used to store directory for walking up */
if (!dir_fd) return FALSE;
if (vd->dir_fd == dir_fd) return TRUE;
ret = vdlist_populate(vd, TRUE);
/* scroll to make last path visible */
- FileData *found = NULL;
+ FileData *found = nullptr;
GList *work;
work = VDLIST(vd)->list;
if (event->keyval != GDK_KEY_Menu) return FALSE;
- gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, NULL);
+ gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, nullptr);
if (tpath)
{
GtkTreeModel *store;
}
else
{
- vd->click_fd = NULL;
+ vd->click_fd = nullptr;
}
vd_color_set(vd, vd->click_fd, TRUE);
vd->popup = vd_pop_menu(vd, vd->click_fd);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
return TRUE;
}
auto vd = static_cast<ViewDir *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &fd, -1);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
if (bevent->button == MOUSE_BUTTON_RIGHT)
{
vd->popup = vd_pop_menu(vd, vd->click_fd);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
return TRUE;
}
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DIR_COLUMN_ICON);
- gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, nullptr);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_NAME);
- gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, nullptr);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_DATE);
- gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(vd->view), column);
static void set_cursor(GtkWidget *widget, GdkCursorType cursor_type)
{
- GdkCursor *cursor = NULL;
+ GdkCursor *cursor = nullptr;
if (!widget || !gtk_widget_get_window(widget)) return;
GtkTreeModel *store;
GtkTreePath *tpath;
NodeData *nd;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
tpath = gtk_tree_model_get_path(store, iter);
g_signal_handlers_block_by_func(G_OBJECT(vd->view), (gpointer)vdtree_row_expanded, vd);
gtk_tree_view_expand_row(GTK_TREE_VIEW(vd->view), tpath, FALSE);
gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
if (fd && islink(fd->path))
{
static GList *parts_list(const gchar *path)
{
- GList *list = NULL;
+ GList *list = nullptr;
const gchar *strb, *strp;
gint l;
strp = path;
- if (*strp != G_DIR_SEPARATOR) return NULL;
+ if (*strp != G_DIR_SEPARATOR) return nullptr;
strp++;
strb = strp;
while (work)
{
PathData *pd;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
pd = g_new0(PathData, 1);
pd->name = static_cast<gchar *>(work->data);
GtkTreeModel *store;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
- if (!name || !gtk_tree_model_iter_children(store, iter, parent)) return NULL;
+ if (!name || !gtk_tree_model_iter_children(store, iter, parent)) return nullptr;
do {
NodeData *nd;
if (nd && strcmp(nd->fd->name, name) == 0) return nd;
} while (gtk_tree_model_iter_next(store, iter));
- return NULL;
+ return nullptr;
}
static NodeData *vdtree_find_iter_by_fd(ViewDir *vd, GtkTreeIter *parent, FileData *fd, GtkTreeIter *iter)
GtkTreeModel *store;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
- if (!fd || !gtk_tree_model_iter_children(store, iter, parent)) return NULL;
+ if (!fd || !gtk_tree_model_iter_children(store, iter, parent)) return nullptr;
do {
NodeData *nd;
if (nd && nd->fd == fd) return nd;
} while (gtk_tree_model_iter_next(store, iter));
- return NULL;
+ return nullptr;
}
static void vdtree_add_by_data(ViewDir *vd, FileData *fd, GtkTreeIter *parent)
GdkPixbuf *pixbuf;
NodeData *end;
GtkTreeIter empty;
- gchar *link = NULL;
+ gchar *link = nullptr;
if (!fd) return;
nd->fd = fd;
nd->version = fd->version;
nd->expanded = FALSE;
- nd->last_update = time(NULL);
+ nd->last_update = time(nullptr);
if (islink(fd->path))
{
- link = realpath(fd->path, NULL);
+ link = realpath(fd->path, nullptr);
}
else
{
- link = NULL;
+ link = nullptr;
}
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
/* all nodes are created with an "empty" node, so that the expander is shown
* this is removed when the child is populated */
end = g_new0(NodeData, 1);
- end->fd = NULL;
+ end->fd = nullptr;
end->expanded = TRUE;
gtk_tree_store_append(store, &empty, &child);
GtkTreeIter child;
NodeData *nd;
gboolean add_hidden = FALSE;
- gchar *link = NULL;
+ gchar *link = nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
if (!nd) return FALSE;
- current_time = time(NULL);
+ current_time = time(nullptr);
if (nd->expanded)
{
if (!nd->fd || !isdir(nd->fd->path))
{
- if (vd->click_fd == nd->fd) vd->click_fd = NULL;
- if (vd->drop_fd == nd->fd) vd->drop_fd = NULL;
+ if (vd->click_fd == nd->fd) vd->click_fd = nullptr;
+ if (vd->drop_fd == nd->fd) vd->drop_fd = nullptr;
gtk_tree_store_remove(GTK_TREE_STORE(store), iter);
vdtree_node_free(nd);
return FALSE;
vdtree_busy_push(vd);
- filelist_read(nd->fd, NULL, &list);
+ filelist_read(nd->fd, nullptr, &list);
if (add_hidden)
{
g_free(name8);
}
- old = NULL;
+ old = nullptr;
if (gtk_tree_model_iter_children(store, &child, iter))
{
do {
if (islink(fd->path))
{
- link = realpath(fd->path, NULL);
+ link = realpath(fd->path, nullptr);
}
else
{
- link = NULL;
+ link = nullptr;
}
gtk_tree_store_set(GTK_TREE_STORE(store), &child, DIR_COLUMN_LINK, link, -1);
auto cnd = static_cast<NodeData *>(work->data);
work = work->next;
- if (vd->click_fd == cnd->fd) vd->click_fd = NULL;
- if (vd->drop_fd == cnd->fd) vd->drop_fd = NULL;
+ if (vd->click_fd == cnd->fd) vd->click_fd = nullptr;
+ if (vd->drop_fd == cnd->fd) vd->drop_fd = nullptr;
if (vdtree_find_iter_by_data(vd, iter, cnd, &child))
{
{
GList *list;
GList *work;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
- if (!target_fd) return NULL;
+ if (!target_fd) return nullptr;
vdtree_busy_push(vd);
while (work)
{
auto pd = static_cast<PathData *>(work->data);
- if (pd->node == NULL)
+ if (pd->node == nullptr)
{
PathData *parent_pd;
GtkTreeIter parent_iter;
log_printf("vdtree warning, root node not found\n");
parts_list_free(list);
vdtree_busy_pop(vd);
- return NULL;
+ return nullptr;
}
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) ||
- (nd = vdtree_find_iter_by_name(vd, &parent_iter, pd->name, &iter)) == NULL)
+ (nd = vdtree_find_iter_by_name(vd, &parent_iter, pd->name, &iter)) == nullptr)
{
log_printf("vdtree warning, aborted at %s\n", parent_pd->name);
parts_list_free(list);
vdtree_busy_pop(vd);
- return NULL;
+ return nullptr;
}
pd->node = nd->fd;
gtk_tree_selection_select_iter(selection, &iter);
selection_is_ok = FALSE;
- gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
+ gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, nullptr);
tpath = gtk_tree_model_get_path(store, &iter);
if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
{
/* setting the cursor scrolls the view; do not do that unless it is necessary */
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, nullptr, FALSE);
/* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
does not work (switch from dir_list to dir_tree) */
{
/** @FIXME no get row path */
log_printf("FIXME: no get row path\n");
- return NULL;
+ return nullptr;
}
/*
auto vd = static_cast<ViewDir *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
- gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, NULL);
+ gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, nullptr);
if (tpath)
{
GtkTreeModel *store;
gtk_tree_path_free(tpath);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
}
switch (event->keyval)
vd_color_set(vd, vd->click_fd, TRUE);
vd->popup = vd_pop_menu(vd, vd->click_fd);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
return TRUE;
break;
GtkTreePath *tpath;
GtkTreeViewColumn *column;
GtkTreeIter iter;
- NodeData *nd = NULL;
+ NodeData *nd = nullptr;
FileData *fd;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, &column, NULL, NULL))
+ &tpath, &column, nullptr, nullptr))
{
GtkTreeModel *store;
gint left_of_expander;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, nullptr, FALSE);
if (vdtree_clicked_on_expander(GTK_TREE_VIEW(widget), tpath, column, bevent->x, bevent->y, &left_of_expander))
{
- vd->click_fd = NULL;
+ vd->click_fd = nullptr;
/* clicking this region should automatically reveal an expander, if necessary
* treeview bug: the expander will not expand until a button_motion_event highlights it.
{
vdtree_populate_path_by_iter(vd, &iter, FALSE, vd->dir_fd);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
if (fd && islink(fd->path))
{
vdtree_icon_set_by_iter(vd, &iter, vd->pf->link);
gtk_tree_path_free(tpath);
}
- vd->click_fd = (nd) ? nd->fd : NULL;
+ vd->click_fd = (nd) ? nd->fd : nullptr;
vd_color_set(vd, vd->click_fd, TRUE);
if (bevent->button == MOUSE_BUTTON_RIGHT)
{
vd->popup = vd_pop_menu(vd, vd->click_fd);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
}
return (bevent->button != MOUSE_BUTTON_LEFT);
{
auto vd = static_cast<ViewDir *>(data);
GtkTreeModel *store;
- NodeData *nd = NULL;
+ NodeData *nd = nullptr;
FileData *fd;
gtk_tree_view_set_tooltip_column(treeview, DIR_COLUMN_LINK);
- vdtree_populate_path_by_iter(vd, iter, FALSE, NULL);
+ vdtree_populate_path_by_iter(vd, iter, FALSE, nullptr);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
gtk_tree_model_get_iter(store, iter, tpath);
gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
if (fd && islink(fd->path))
{
vdtree_icon_set_by_iter(vd, iter, vd->pf->link);
{
auto vd = static_cast<ViewDir *>(data);
GtkTreeModel *store;
- NodeData *nd = NULL;
+ NodeData *nd = nullptr;
FileData *fd;
- vdtree_populate_path_by_iter(vd, iter, FALSE, NULL);
+ vdtree_populate_path_by_iter(vd, iter, FALSE, nullptr);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
gtk_tree_model_get_iter(store, iter, tpath);
gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
if (fd && islink(fd->path))
{
vdtree_icon_set_by_iter(vd, iter, vd->pf->link);
fd = file_data_new_dir(path);
- vdtree_add_by_data(vd, fd, NULL);
+ vdtree_add_by_data(vd, fd, nullptr);
vdtree_expand_by_data(vd, fd, TRUE);
vdtree_populate_path(vd, fd, FALSE, FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vd->view), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vd->view), FALSE);
- gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), vdtree_sort_cb, vd, NULL);
+ gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), vdtree_sort_cb, vd, nullptr);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
- gtk_tree_selection_set_select_function(selection, vdtree_select_cb, vd, NULL);
+ gtk_tree_selection_set_select_function(selection, vdtree_select_cb, vd, nullptr);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DIR_COLUMN_ICON);
- gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, nullptr);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_NAME);
- gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, nullptr);
gtk_tree_view_append_column(GTK_TREE_VIEW(vd->view), column);
static PixmapFolders *folder_icons_new(GtkWidget *widget)
{
auto pf = g_new0(PixmapFolders, 1);
- GError *error = NULL;
+ GError *error = nullptr;
GdkPixbuf *icon;
gint scale;
*/
/* Attempt to use stock gtk icons */
- pf->close = gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL);
- pf->open = gtk_widget_render_icon(widget, GTK_STOCK_OPEN, size, NULL);
- pf->parent = gtk_widget_render_icon(widget, GTK_STOCK_GO_UP, size, NULL);
+ pf->close = gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, nullptr);
+ pf->open = gtk_widget_render_icon(widget, GTK_STOCK_OPEN, size, nullptr);
+ pf->parent = gtk_widget_render_icon(widget, GTK_STOCK_GO_UP, size, nullptr);
if (gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "emblem-unreadable"))
{
log_printf("Error: %s\n", error->message);
g_error_free(error);
- pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_STOP, size, NULL));
+ pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_STOP, size, nullptr));
}
else
{
- pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL));
+ pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, nullptr));
scale = gdk_pixbuf_get_width(icon) / 2;
gdk_pixbuf_composite(icon, pf->deny, scale, scale, scale, scale, scale, scale, 0.5, 0.5, GDK_INTERP_HYPER, 255);
}
else
{
- pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_STOP, size, NULL));
+ pf->deny = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_STOP, size, nullptr));
}
if (gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "emblem-symbolic-link"))
log_printf("Error: %s\n", error->message);
g_error_free(error);
- pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_REDO, size, NULL));
+ pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_REDO, size, nullptr));
}
else
{
- pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL));
+ pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, nullptr));
scale = gdk_pixbuf_get_width(icon) / 2;
gdk_pixbuf_composite(icon, pf->link, scale, scale, scale, scale, scale, scale, 0.5, 0.5, GDK_INTERP_HYPER, 255);
}
}
else
{
- pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_REDO, size, NULL));
+ pf->link = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_REDO, size, nullptr));
}
- pf->read_only = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL));
+ pf->read_only = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, nullptr));
if (gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "emblem-readonly"))
{
log_printf("Error: %s\n", error->message);
g_error_free(error);
- pf->read_only = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL));
+ pf->read_only = gdk_pixbuf_copy(gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, nullptr));
}
else
{
if (vd->popup)
{
g_signal_handlers_disconnect_matched(G_OBJECT(vd->popup), G_SIGNAL_MATCH_DATA,
- 0, 0, 0, NULL, vd);
+ 0, 0, nullptr, nullptr, vd);
gtk_widget_destroy(vd->popup);
}
{
auto vd = g_new0(ViewDir, 1);
- vd->widget = gtk_scrolled_window_new(NULL, NULL);
+ vd->widget = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(vd->widget), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vd->widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
switch (vd->type)
{
case DIRVIEW_LIST: ret = vdlist_find_row(vd, fd, iter); break;
- case DIRVIEW_TREE: ret = vdtree_find_row(vd, fd, iter, NULL); break;
+ case DIRVIEW_TREE: ret = vdtree_find_row(vd, fd, iter, nullptr); break;
}
return ret;
FileData *vd_get_fd_from_tree_path(ViewDir *vd, GtkTreeView *tview, GtkTreePath *tpath)
{
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
GtkTreeModel *store;
store = gtk_tree_view_get_model(tview);
{
NodeData *nd;
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
- fd = (nd) ? nd->fd : NULL;
+ fd = (nd) ? nd->fd : nullptr;
};
break;
}
auto vd = static_cast<ViewDir *>(data);
vd_color_set(vd, vd->click_fd, FALSE);
- vd->click_fd = NULL;
- vd->popup = NULL;
+ vd->click_fd = nullptr;
+ vd->popup = nullptr;
vd_color_set(vd, vd->drop_fd, FALSE);
filelist_free(vd->drop_list);
- vd->drop_list = NULL;
- vd->drop_fd = NULL;
+ vd->drop_list = nullptr;
+ vd->drop_fd = nullptr;
}
/*
path = vd->drop_fd->path;
list = vd->drop_list;
- vd->drop_list = NULL;
+ vd->drop_list = nullptr;
file_util_copy_simple(list, path, vd->widget);
}
path = vd->drop_fd->path;
list = vd->drop_list;
- vd->drop_list = NULL;
+ vd->drop_list = nullptr;
file_util_move_simple(list, path, vd->widget);
}
path = vd->drop_fd->path;
list = vd->drop_list;
- vd->drop_list = NULL;
+ vd->drop_list = nullptr;
file_util_start_filter_from_filelist(key, list, path, vd->widget);
}
g_list_free(editors_list);
menu_item_add_divider(menu);
- menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, NULL, vd);
+ menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, nullptr, vd);
return menu;
}
static void vd_pop_menu_dupe(ViewDir *vd, gint recursive)
{
DupeWindow *dw;
- GList *list = NULL;
+ GList *list = nullptr;
if (!vd->click_fd) return;
}
else
{
- filelist_read(vd->click_fd, &list, NULL);
+ filelist_read(vd->click_fd, &list, nullptr);
list = filelist_filter(list, FALSE);
}
static void vd_pop_menu_new_folder_cb(gboolean success, const gchar *new_path, gpointer data)
{
auto vd = static_cast<ViewDir *>(data);
- FileData *fd = NULL;
+ FileData *fd = nullptr;
GtkTreeIter iter;
GtkTreePath *tpath;
GtkTreeModel *store;
case DIRVIEW_LIST:
{
vd_refresh(vd);
- fd = vdlist_row_by_path(vd, new_path, NULL);
+ fd = vdlist_row_by_path(vd, new_path, nullptr);
};
break;
case DIRVIEW_TREE:
if (!fd || !vd_find_row(vd, fd, &iter)) return;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
static void vd_pop_menu_new_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto vd = static_cast<ViewDir *>(data);
- FileData *dir_fd = NULL;
+ FileData *dir_fd = nullptr;
switch (vd->type)
{
GtkWidget *submenu;
GtkWidget *item;
- active = (fd != NULL);
+ active = (fd != nullptr);
switch (vd->type)
{
case DIRVIEW_LIST:
if (vd->type == DIRVIEW_LIST)
{
- submenu = submenu_add_dir_sort(NULL, G_CALLBACK(vd_pop_menu_sort_cb), vd, FALSE, FALSE, TRUE, vd->layout->options.dir_view_list_sort.method);
+ submenu = submenu_add_dir_sort(nullptr, G_CALLBACK(vd_pop_menu_sort_cb), vd, FALSE, FALSE, TRUE, vd->layout->options.dir_view_list_sort.method);
menu_item_add_check(submenu, _("Ascending"), vd->layout->options.dir_view_list_sort.ascend, G_CALLBACK(vd_pop_menu_sort_ascend_cb), (vd));
- item = menu_item_add(menu, _("_Sort"), NULL, NULL);
+ item = menu_item_add(menu, _("_Sort"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
}
{
case TARGET_URI_LIST:
case TARGET_TEXT_PLAIN:
- list = g_list_prepend(NULL, vd->click_fd);
+ list = g_list_prepend(nullptr, vd->click_fd);
uri_selection_data_set_uris_from_filelist(selection_data, list);
g_list_free(list);
break;
{
auto vd = static_cast<ViewDir *>(data);
GtkTreePath *tpath;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
GdkDragAction action = GDK_ACTION_ASK;
- vd->click_fd = NULL;
+ vd->click_fd = nullptr;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), x, y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(widget), tpath);
gtk_tree_path_free(tpath);
*/
GdkModifierType mask;
- gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, &mask);
+ gdk_window_get_pointer(gtk_widget_get_window(widget), nullptr, nullptr, &mask);
if (mask & GDK_CONTROL_MASK)
{
action = GDK_ACTION_COPY;
{
file_util_copy_simple(list, fd->path, vd->widget);
done = TRUE;
- list = NULL;
+ list = nullptr;
}
else if (action == GDK_ACTION_MOVE)
{
file_util_move_simple(list, fd->path, vd->widget);
done = TRUE;
- list = NULL;
+ list = nullptr;
}
}
if (done == FALSE)
{
vd->popup = vd_drop_menu(vd, active);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
}
vd->drop_fd = fd;
static void vd_dnd_drop_update(ViewDir *vd, gint x, gint y)
{
GtkTreePath *tpath;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vd->view), x, y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(vd->view), tpath);
gtk_tree_path_free(tpath);
window = gtk_widget_get_window(vd->view);
seat = gdk_display_get_default_seat(gdk_window_get_display(window));
device = gdk_seat_get_pointer(seat);
- gdk_window_get_device_position(window, device, &x, &y, NULL);
+ gdk_window_get_device_position(window, device, &x, &y, nullptr);
w = gdk_window_get_width(window);
h = gdk_window_get_height(window);
{
auto vd = static_cast<ViewDir *>(data);
- vd->click_fd = NULL;
+ vd->click_fd = nullptr;
if (gtk_drag_get_source_widget(context) == vd->view)
{
if (vd->drop_fd != vd->click_fd) vd_color_set(vd, vd->drop_fd, FALSE);
- vd->drop_fd = NULL;
+ vd->drop_fd = nullptr;
if (vd->dnd_drop_leave_func) vd->dnd_drop_leave_func(vd);
}
static GdkColor *vd_color_shifted(GtkWidget *widget)
{
static GdkColor color;
- static GtkWidget *done = NULL;
+ static GtkWidget *done = nullptr;
if (done != widget)
{
{
auto vd = static_cast<ViewDir *>(data);
GtkTreePath *tpath;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (defined_mouse_buttons(widget, bevent, vd->layout))
{
if ((bevent->x != 0 || bevent->y != 0) &&
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(widget), tpath);
gtk_tree_path_free(tpath);
FileData *fd;
GtkTreePath *tpath;
GtkTreeIter iter;
- NodeData *nd = NULL;
+ NodeData *nd = nullptr;
GtkTreeModel *store;
if (bevent->button == MOUSE_BUTTON_RIGHT)
{
- if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y, &tpath, NULL, NULL, NULL))
+ if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y, &tpath, nullptr, nullptr, nullptr))
{
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
break;
case DIRVIEW_TREE:
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
- vd->click_fd = (nd) ? nd->fd : NULL;
+ vd->click_fd = (nd) ? nd->fd : nullptr;
}
if (vd->click_fd)
}
vd->popup = vd_pop_menu(vd, vd->click_fd);
- gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vd->popup), nullptr);
return TRUE;
}
GList *vficon_pop_menu_file_list(ViewFile *vf)
{
- if (!VFICON(vf)->click_fd) return NULL;
+ if (!VFICON(vf)->click_fd) return nullptr;
if (VFICON(vf)->click_fd->selected & SELECTION_SELECTED)
{
{
auto vf = static_cast<ViewFile *>(data);
- file_util_rename(NULL, vf_pop_menu_file_list(vf), vf->listview);
+ file_util_rename(nullptr, vf_pop_menu_file_list(vf), vf->listview);
}
void vficon_pop_menu_show_names_cb(GtkWidget *UNUSED(widget), gpointer data)
void vficon_popup_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto vf = static_cast<ViewFile *>(data);
- vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
- VFICON(vf)->click_fd = NULL;
- vf->popup = NULL;
+ vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, nullptr);
+ VFICON(vf)->click_fd = nullptr;
+ vf->popup = nullptr;
}
/*
static void vficon_send_layout_select(ViewFile *vf, FileData *fd)
{
- FileData *read_ahead_fd = NULL;
+ FileData *read_ahead_fd = nullptr;
FileData *sel_fd;
FileData *cur_fd;
row = g_list_index(vf->list, fd);
if (row > vficon_index_by_fd(vf, cur_fd) &&
- static_cast<guint>(row + 1) < vf_count(vf, NULL))
+ static_cast<guint>(row + 1) < vf_count(vf, nullptr))
{
read_ahead_fd = vf_index_get_data(vf, row + 1);
}
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
if (!vficon_find_position(vf, fd, &row, &col)) return FALSE;
- if (!gtk_tree_model_iter_nth_child(store, iter, NULL, row)) return FALSE;
+ if (!gtk_tree_model_iter_nth_child(store, iter, nullptr, row)) return FALSE;
if (column) *column = col;
return TRUE;
GtkTreeModel *store;
GtkTreeIter p;
- if (row < 0 || col < 0) return NULL;
+ if (row < 0 || col < 0) return nullptr;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
- if (gtk_tree_model_iter_nth_child(store, &p, NULL, row))
+ if (gtk_tree_model_iter_nth_child(store, &p, nullptr, row))
{
GList *list;
gtk_tree_model_get(store, &p, FILE_COLUMN_POINTER, &list, -1);
- if (!list) return NULL;
+ if (!list) return nullptr;
if (iter) *iter = p;
return static_cast<FileData *>(g_list_nth_data(list, col));
}
- return NULL;
+ return nullptr;
}
static FileData *vficon_find_data_by_coord(ViewFile *vf, gint x, gint y, GtkTreeIter *iter)
GtkTreeViewColumn *column;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), x, y,
- &tpath, &column, NULL, NULL))
+ &tpath, &column, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter row;
}
}
- return NULL;
+ return nullptr;
}
static void vficon_mark_toggled_cb(GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
seat = gdk_display_get_default_seat(gdk_window_get_display(gtk_tree_view_get_bin_window(GTK_TREE_VIEW(vf->listview))));
device = gdk_seat_get_pointer(seat);
gdk_window_get_device_position(gtk_tree_view_get_bin_window(GTK_TREE_VIEW(vf->listview)),
- device, &x, &y, NULL);
+ device, &x, &y, nullptr);
- VFICON(vf)->tip_fd = vficon_find_data_by_coord(vf, x, y, NULL);
+ VFICON(vf)->tip_fd = vficon_find_data_by_coord(vf, x, y, nullptr);
if (!VFICON(vf)->tip_fd) return;
VFICON(vf)->tip_window = gtk_window_new(GTK_WINDOW_POPUP);
display = gdk_display_get_default();
seat = gdk_display_get_default_seat(display);
device = gdk_seat_get_pointer(seat);
- gdk_device_get_position(device, NULL, &x, &y);
+ gdk_device_get_position(device, nullptr, &x, &y);
if (!gtk_widget_get_realized(VFICON(vf)->tip_window)) gtk_widget_realize(VFICON(vf)->tip_window);
gtk_window_move(GTK_WINDOW(VFICON(vf)->tip_window), x + 16, y + 16);
static void tip_hide(ViewFile *vf)
{
if (VFICON(vf)->tip_window) gtk_widget_destroy(VFICON(vf)->tip_window);
- VFICON(vf)->tip_window = NULL;
+ VFICON(vf)->tip_window = nullptr;
}
static gboolean tip_schedule_cb(gpointer data)
{
gint x, y;
- gdk_device_get_position(device, NULL, &x, &y);
+ gdk_device_get_position(device, nullptr, &x, &y);
gtk_window_move(GTK_WINDOW(VFICON(vf)->tip_window), x + 16, y + 16);
guint UNUSED(time), gpointer data)
{
auto vf = static_cast<ViewFile *>(data);
- GList *list = NULL;
+ GList *list = nullptr;
if (!VFICON(vf)->click_fd) return;
}
else
{
- list = g_list_append(NULL, file_data_ref(VFICON(vf)->click_fd));
+ list = g_list_append(nullptr, file_data_ref(VFICON(vf)->click_fd));
}
if (!list) return;
auto vf = static_cast<ViewFile *>(data);
if (info == TARGET_TEXT_PLAIN) {
- FileData *fd = vficon_find_data_by_coord(vf, x, y, NULL);
+ FileData *fd = vficon_find_data_by_coord(vf, x, y, nullptr);
if (fd) {
/* Add keywords to file */
{
auto vf = static_cast<ViewFile *>(data);
- vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
+ vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, nullptr);
if (gdk_drag_context_get_selected_action(context) == GDK_ACTION_MOVE)
{
{
GtkTreeIter row;
- if (vficon_find_iter(vf, fd, &row, NULL))
+ if (vficon_find_iter(vf, fd, &row, nullptr))
{
gtk_tree_model_get(store, &row, FILE_COLUMN_POINTER, &list, -1);
if (list) gtk_list_store_set(GTK_LIST_STORE(store), &row, FILE_COLUMN_POINTER, list, -1);
GList *work;
g_list_free(VFICON(vf)->selection);
- VFICON(vf)->selection = NULL;
+ VFICON(vf)->selection = nullptr;
work = vf->list;
while (work)
work = work->next;
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
- vficon_selection_add(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_add(vf, fd, SELECTION_SELECTED, nullptr);
}
vf_send_update(vf);
auto fd = static_cast<FileData *>(work->data);
work = work->next;
- vficon_selection_remove(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_remove(vf, fd, SELECTION_SELECTED, nullptr);
}
g_list_free(VFICON(vf)->selection);
- VFICON(vf)->selection = NULL;
+ VFICON(vf)->selection = nullptr;
vf_send_update(vf);
}
if (fd->selected & SELECTION_SELECTED)
{
VFICON(vf)->selection = g_list_remove(VFICON(vf)->selection, fd);
- vficon_selection_remove(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_remove(vf, fd, SELECTION_SELECTED, nullptr);
}
else
{
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
- vficon_selection_add(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_add(vf, fd, SELECTION_SELECTED, nullptr);
}
}
if (!fd || fd->selected & SELECTION_SELECTED) return;
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
- vficon_selection_add(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_add(vf, fd, SELECTION_SELECTED, nullptr);
vf_send_update(vf);
}
if (!fd || !(fd->selected & SELECTION_SELECTED) ) return;
VFICON(vf)->selection = g_list_remove(VFICON(vf)->selection, fd);
- vficon_selection_remove(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_remove(vf, fd, SELECTION_SELECTED, nullptr);
vf_send_update(vf);
}
if (work->data != end)
work = work->next;
else
- work = NULL;
+ work = nullptr;
}
return;
}
{
for (j = col1; j <= col2; j++)
{
- FileData *fd = vficon_find_data(vf, i, j, NULL);
+ FileData *fd = vficon_find_data(vf, i, j, nullptr);
if (fd) vficon_select_util(vf, fd, select);
}
}
GList *vficon_selection_get_list(ViewFile *vf)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work, *work2;
work = VFICON(vf)->selection;
GList *vficon_selection_get_list_by_index(ViewFile *vf)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
work = VFICON(vf)->selection;
if (g_list_find(vf->list, fd))
{
VFICON(vf)->selection = g_list_append(VFICON(vf)->selection, fd);
- vficon_selection_add(vf, fd, SELECTION_SELECTED, NULL);
+ vficon_selection_add(vf, fd, SELECTION_SELECTED, nullptr);
}
work = work->next;
}
static void vficon_select_closest(ViewFile *vf, FileData *sel_fd)
{
GList *work;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (sel_fd->parent) sel_fd = sel_fd->parent;
work = vf->list;
if (new_col >= l) new_col = l - 1;
}
- vficon_set_focus(vf, vficon_find_data(vf, new_row, new_col, NULL));
+ vficon_set_focus(vf, vficon_find_data(vf, new_row, new_col, nullptr));
}
static void vficon_set_focus(ViewFile *vf, FileData *fd)
* preserved when the icon view is refreshed. Caused by an unknown call from
* the idle loop. This patch hides the problem.
*/
- if (vficon_find_iter(vf, VFICON(vf)->focus_fd, &iter, NULL))
+ if (vficon_find_iter(vf, VFICON(vf)->focus_fd, &iter, nullptr))
{
tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
}
return;
}
- vficon_selection_remove(vf, VFICON(vf)->focus_fd, SELECTION_FOCUS, NULL);
+ vficon_selection_remove(vf, VFICON(vf)->focus_fd, SELECTION_FOCUS, nullptr);
}
if (!vficon_find_position(vf, fd, &row, &col))
{
- VFICON(vf)->focus_fd = NULL;
+ VFICON(vf)->focus_fd = nullptr;
VFICON(vf)->focus_row = -1;
VFICON(vf)->focus_column = -1;
return;
VFICON(vf)->focus_fd = fd;
VFICON(vf)->focus_row = row;
VFICON(vf)->focus_column = col;
- vficon_selection_add(vf, VFICON(vf)->focus_fd, SELECTION_FOCUS, NULL);
+ vficon_selection_add(vf, VFICON(vf)->focus_fd, SELECTION_FOCUS, nullptr);
- if (vficon_find_iter(vf, VFICON(vf)->focus_fd, &iter, NULL))
+ if (vficon_find_iter(vf, VFICON(vf)->focus_fd, &iter, nullptr))
{
GtkTreePath *tpath;
GtkTreeViewColumn *column;
focus_col = VFICON(vf)->columns - 1 - VFICON(vf)->focus_column;
break;
case GDK_KEY_space:
- fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, NULL);
+ fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, nullptr);
if (fd)
{
VFICON(vf)->click_fd = fd;
}
break;
case GDK_KEY_Menu:
- fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, NULL);
+ fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, nullptr);
VFICON(vf)->click_fd = fd;
- vficon_selection_add(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
+ vficon_selection_add(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, nullptr);
tip_unschedule(vf);
vf->popup = vf_pop_menu(vf);
- gtk_menu_popup_at_widget(GTK_MENU(vf->popup), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(vf->popup), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, nullptr);
break;
default:
stop_signal = FALSE;
FileData *new_fd;
FileData *old_fd;
- old_fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, NULL);
+ old_fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, nullptr);
vficon_move_focus(vf, focus_row, focus_col, TRUE);
- new_fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, NULL);
+ new_fd = vficon_find_data(vf, VFICON(vf)->focus_row, VFICON(vf)->focus_column, nullptr);
if (new_fd != old_fd)
{
auto vf = static_cast<ViewFile *>(data);
FileData *fd;
- fd = vficon_find_data_by_coord(vf, static_cast<gint>(event->x), static_cast<gint>(event->y), NULL);
+ fd = vficon_find_data_by_coord(vf, static_cast<gint>(event->x), static_cast<gint>(event->y), nullptr);
tip_update(vf, fd);
return FALSE;
break;
case MOUSE_BUTTON_RIGHT:
vf->popup = vf_pop_menu(vf);
- gtk_menu_popup_at_pointer(GTK_MENU(vf->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vf->popup), nullptr);
break;
default:
break;
{
auto vf = static_cast<ViewFile *>(data);
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
gboolean was_selected;
tip_schedule(vf);
if (VFICON(vf)->click_fd)
{
- vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, NULL);
+ vficon_selection_remove(vf, VFICON(vf)->click_fd, SELECTION_PRELIGHT, nullptr);
}
if (!fd || VFICON(vf)->click_fd != fd) return TRUE;
GtkTreeModel *store;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
- gtk_tree_model_foreach(store, vficon_destroy_node_cb, NULL);
+ gtk_tree_model_foreach(store, vficon_destroy_node_cb, nullptr);
gtk_list_store_clear(GTK_LIST_STORE(store));
}
static GList *vficon_add_row(ViewFile *vf, GtkTreeIter *iter)
{
GtkListStore *store;
- GList *list = NULL;
+ GList *list = nullptr;
gint i;
- for (i = 0; i < VFICON(vf)->columns; i++) list = g_list_prepend(list, NULL);
+ for (i = 0; i < VFICON(vf)->columns; i++) list = g_list_prepend(list, nullptr);
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview)));
gtk_list_store_append(store, iter);
GtkTreeModel *store;
GtkTreePath *tpath;
GList *work;
- FileData *visible_fd = NULL;
+ FileData *visible_fd = nullptr;
gint r, c;
gboolean valid;
GtkTreeIter iter;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
if (keep_position && gtk_widget_get_realized(vf->listview) &&
- gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeIter iter;
GList *list;
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 = static_cast<GtkCellRenderer *>((list) ? list->data : NULL);
+ cell = static_cast<GtkCellRenderer *>((list) ? list->data : nullptr);
g_list_free(list);
if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
r = -1;
c = 0;
- valid = gtk_tree_model_iter_children(store, &iter, NULL);
+ valid = gtk_tree_model_iter_children(store, &iter, nullptr);
work = vf->list;
while (work)
}
else
{
- fd = NULL;
+ fd = nullptr;
}
list->data = fd;
VFICON(vf)->rows = r;
if (visible_fd &&
- gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeIter iter;
GList *list;
gtk_tree_path_free(tpath);
gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
- if (g_list_find(list, visible_fd) == NULL &&
- vficon_find_iter(vf, visible_fd, &iter, NULL))
+ if (g_list_find(list, visible_fd) == nullptr &&
+ vficon_find_iter(vf, visible_fd, &iter, nullptr))
{
tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
}
GList *list;
if (!g_list_find(vf->list, fd)) return;
- if (!vficon_find_iter(vf, fd, &iter, NULL)) return;
+ if (!vficon_find_iter(vf, fd, &iter, nullptr)) return;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
GtkTreePath *tpath;
/* First see if there are visible files that don't have a loaded thumb... */
- if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter iter;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_path_free(tpath);
- tpath = NULL;
+ tpath = nullptr;
while (valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
{
if (!fd->thumb_pixbuf) return fd;
}
- return NULL;
+ return nullptr;
}
void vficon_set_star_fd(ViewFile *vf, FileData *fd)
GList *list;
if (!g_list_find(vf->list, fd)) return;
- if (!vficon_find_iter(vf, fd, &iter, NULL)) return;
+ if (!vficon_find_iter(vf, fd, &iter, nullptr)) return;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
/* first check the visible files */
- if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter iter;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_path_free(tpath);
- tpath = NULL;
+ tpath = nullptr;
while (valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
{
if (vf->stars_id == 0)
{
- vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, NULL);
+ vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, nullptr);
}
return fd;
if (vf->stars_id == 0)
{
- vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, NULL);
+ vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, nullptr);
}
return fd;
}
}
- return NULL;
+ return nullptr;
}
/*
{
gboolean ret = TRUE;
GList *work, *new_work;
- FileData *first_selected = NULL;
- GList *new_filelist = NULL;
- GList *new_fd_list = NULL;
- GList *old_selected = NULL;
- GtkTreePath *end_path = NULL;
- GtkTreePath *start_path = NULL;
+ FileData *first_selected = nullptr;
+ GList *new_filelist = nullptr;
+ GList *new_fd_list = nullptr;
+ GList *old_selected = nullptr;
+ GtkTreePath *end_path = nullptr;
+ GtkTreePath *start_path = nullptr;
gtk_tree_view_get_visible_range(GTK_TREE_VIEW(vf->listview), &start_path, &end_path);
if (vf->dir_fd)
{
- ret = filelist_read(vf->dir_fd, &new_filelist, NULL);
+ ret = filelist_read(vf->dir_fd, &new_filelist, nullptr);
new_filelist = file_data_filter_marks_list(new_filelist, vf_marks_get_filter(vf));
new_filelist = g_list_first(new_filelist);
new_filelist = file_data_filter_file_filter_list(new_filelist, vf_file_filter_get_filter(vf));
first_selected = static_cast<FileData *>(VFICON(vf)->selection->data);
file_data_ref(first_selected);
g_list_free(VFICON(vf)->selection);
- VFICON(vf)->selection = NULL;
+ VFICON(vf)->selection = nullptr;
}
/* iterate old list and new list, looking for differences */
new_work = new_filelist;
while (work || new_work)
{
- FileData *fd = NULL;
- FileData *new_fd = NULL;
+ FileData *fd = nullptr;
+ FileData *new_fd = nullptr;
gint match;
if (work && new_work)
/* file no longer exists, delete from vf->list */
GList *to_delete = work;
work = work->next;
- if (fd == VFICON(vf)->prev_selection) VFICON(vf)->prev_selection = NULL;
- if (fd == VFICON(vf)->click_fd) VFICON(vf)->click_fd = NULL;
+ if (fd == VFICON(vf)->prev_selection) VFICON(vf)->prev_selection = nullptr;
+ if (fd == VFICON(vf)->click_fd) VFICON(vf)->click_fd = nullptr;
file_data_unref(fd);
vf->list = g_list_delete_link(vf->list, to_delete);
}
if (start_path)
{
- gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vf->listview), start_path, NULL, FALSE, 0.0, 0.0);
+ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(vf->listview), start_path, nullptr, FALSE, 0.0, 0.0);
}
gtk_tree_path_free(start_path);
GdkColor color_fg;
GdkColor color_bg;
GtkStyle *style;
- gchar *name_sidecars = NULL;
+ gchar *name_sidecars = nullptr;
const gchar *link;
GtkStateType state = GTK_STATE_NORMAL;
}
else
{
- star_rating = NULL;
+ star_rating = nullptr;
}
link = islink(fd->path) ? GQ_LINK_STR : "";
vf->dir_fd = file_data_ref(dir_fd);
g_list_free(VFICON(vf)->selection);
- VFICON(vf)->selection = NULL;
+ VFICON(vf)->selection = nullptr;
g_list_free(vf->list);
- vf->list = NULL;
+ vf->list = nullptr;
/* NOTE: populate will clear the store for us */
ret = vficon_refresh_real(vf, FALSE);
- VFICON(vf)->focus_fd = NULL;
+ VFICON(vf)->focus_fd = nullptr;
vficon_move_focus(vf, 0, 0, FALSE);
return ret;
GtkTreeViewColumn *column;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), x, y,
- &tpath, &column, NULL, NULL))
+ &tpath, &column, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter row;
return fd;
}
- return NULL;
+ return nullptr;
}
static gboolean vflist_store_clear_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer UNUSED(data))
static void vflist_store_clear(ViewFile *vf, gboolean unlock_files)
{
GtkTreeModel *store;
- GList *files = NULL;
+ GList *files = nullptr;
if (unlock_files && vf->marks_enabled)
{
// unlock locked files in this directory
- filelist_read(vf->dir_fd, &files, NULL);
+ filelist_read(vf->dir_fd, &files, nullptr);
while (files)
{
auto fd = static_cast<FileData *>(files->data);
g_list_free(files);
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
- gtk_tree_model_foreach(store, vflist_store_clear_cb, NULL);
+ gtk_tree_model_foreach(store, vflist_store_clear_cb, nullptr);
gtk_tree_store_clear(GTK_TREE_STORE(store));
}
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
tpath = gtk_tree_model_get_path(store, iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
guint UNUSED(time), gpointer data)
{
auto vf = static_cast<ViewFile *>(data);
- GList *list = NULL;
+ GList *list = nullptr;
if (!VFLIST(vf)->click_fd) return;
}
else
{
- list = g_list_append(NULL, file_data_ref(VFLIST(vf)->click_fd));
+ list = g_list_append(nullptr, file_data_ref(VFLIST(vf)->click_fd));
}
if (!list) return;
guint items;
if (vflist_row_is_selected(vf, VFLIST(vf)->click_fd))
- items = vf_selection_count(vf, NULL);
+ items = vf_selection_count(vf, nullptr);
else
items = 1;
auto vf = static_cast<ViewFile *>(data);
if (info == TARGET_TEXT_PLAIN) {
- FileData *fd = vflist_find_data_by_coord(vf, x, y, NULL);
+ FileData *fd = vflist_find_data_by_coord(vf, x, y, nullptr);
if (fd) {
/* Add keywords to file */
GList *vflist_selection_get_one(ViewFile *vf, FileData *fd)
{
- GList *list = g_list_append(NULL, file_data_ref(fd));
+ GList *list = g_list_append(nullptr, file_data_ref(fd));
if (fd->sidecar_files)
{
GList *vflist_pop_menu_file_list(ViewFile *vf)
{
- if (!VFLIST(vf)->click_fd) return NULL;
+ if (!VFLIST(vf)->click_fd) return nullptr;
if (vflist_row_is_selected(vf, VFLIST(vf)->click_fd))
{
return;
}
- file_util_rename(NULL, list, vf->listview);
+ file_util_rename(nullptr, list, vf->listview);
}
void vflist_pop_menu_thumbs_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto vf = static_cast<ViewFile *>(data);
vflist_color_set(vf, VFLIST(vf)->click_fd, FALSE);
- VFLIST(vf)->click_fd = NULL;
- vf->popup = NULL;
+ VFLIST(vf)->click_fd = nullptr;
+ vf->popup = nullptr;
}
new_path = g_build_filename(vf->dir_fd->path, new_name, NULL);
- if (strchr(new_name, G_DIR_SEPARATOR) != NULL)
+ if (strchr(new_name, G_DIR_SEPARATOR) != nullptr)
{
gchar *text = g_strdup_printf(_("Invalid file name:\n%s"), new_name);
file_util_warning_dialog(_("Error renaming file"), text, GTK_STOCK_DIALOG_ERROR, vf->listview);
if (event->keyval != GDK_KEY_Menu) return FALSE;
- gtk_tree_view_get_cursor(GTK_TREE_VIEW(vf->listview), &tpath, NULL);
+ gtk_tree_view_get_cursor(GTK_TREE_VIEW(vf->listview), &tpath, nullptr);
if (tpath)
{
GtkTreeModel *store;
}
else
{
- VFLIST(vf)->click_fd = NULL;
+ VFLIST(vf)->click_fd = nullptr;
}
vf->popup = vf_pop_menu(vf);
- gtk_menu_popup_at_widget(GTK_MENU(vf->popup), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, NULL);
+ gtk_menu_popup_at_widget(GTK_MENU(vf->popup), widget, GDK_GRAVITY_EAST, GDK_GRAVITY_CENTER, nullptr);
return TRUE;
}
auto vf = static_cast<ViewFile *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
GtkTreeViewColumn *column;
vf->clicked_mark = 0;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, &column, NULL, NULL))
+ &tpath, &column, nullptr, nullptr))
{
GtkTreeModel *store;
gint col_idx = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_store_idx"));
if (bevent->button == MOUSE_BUTTON_RIGHT)
{
vf->popup = vf_pop_menu(vf);
- gtk_menu_popup_at_pointer(GTK_MENU(vf->popup), NULL);
+ gtk_menu_popup_at_pointer(GTK_MENU(vf->popup), nullptr);
return TRUE;
}
auto vf = static_cast<ViewFile *>(data);
GtkTreePath *tpath;
GtkTreeIter iter;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (defined_mouse_buttons(widget, bevent, vf->layout))
{
if ((bevent->x != 0 || bevent->y != 0) &&
gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
- &tpath, NULL, NULL, NULL))
+ &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
static void vflist_select_image(ViewFile *vf, FileData *sel_fd)
{
- FileData *read_ahead_fd = NULL;
+ FileData *read_ahead_fd = nullptr;
gint row;
FileData *cur_fd;
if (sel_fd && options->image.enable_read_ahead && row >= 0)
{
if (row > g_list_index(vf->list, cur_fd) &&
- static_cast<guint>(row + 1) < vf_count(vf, NULL))
+ static_cast<guint>(row + 1) < vf_count(vf, nullptr))
{
read_ahead_fd = vf_index_get_data(vf, row + 1);
}
if (VFLIST(vf)->select_fd)
{
vflist_select_image(vf, VFLIST(vf)->select_fd);
- VFLIST(vf)->select_fd = NULL;
+ VFLIST(vf)->select_fd = nullptr;
}
VFLIST(vf)->select_idle_id = 0;
GtkTreeIter iter;
GtkTreePath *cursor_path;
- VFLIST(vf)->select_fd = NULL;
+ VFLIST(vf)->select_fd = nullptr;
if (!path_currently_selected && gtk_tree_model_get_iter(store, &iter, tpath))
{
- gtk_tree_view_get_cursor(GTK_TREE_VIEW(vf->listview), &cursor_path, NULL);
+ gtk_tree_view_get_cursor(GTK_TREE_VIEW(vf->listview), &cursor_path, nullptr);
if (cursor_path)
{
gtk_tree_model_get_iter(store, &iter, cursor_path);
FILE_COLUMN_STAR_RATING, &star_rating,
-1);
- formatted = vflist_get_formatted(vf, name, sidecars, size, time, expanded, FALSE, NULL);
+ formatted = vflist_get_formatted(vf, name, sidecars, size, time, expanded, FALSE, nullptr);
formatted_with_stars = vflist_get_formatted(vf, name, sidecars, size, time, expanded, TRUE, star_rating);
gtk_tree_store_set(store, iter, FILE_COLUMN_FORMATTED, formatted,
static void vflist_setup_iter(ViewFile *vf, GtkTreeStore *store, GtkTreeIter *iter, FileData *fd)
{
gchar *size;
- gchar *sidecars = NULL;
+ gchar *sidecars = nullptr;
gchar *name;
const gchar *time = text_from_time(fd->date);
const gchar *link = islink(fd->path) ? GQ_LINK_STR : "";
}
else
{
- star_rating = NULL;
+ star_rating = nullptr;
}
if (fd->sidecar_files) /* expanded has no effect on files without sidecars */
name = g_strdup_printf("%s%s%s", link, fd->name, disabled_grouping);
size = text_from_size(fd->size);
- formatted = vflist_get_formatted(vf, name, sidecars, size, time, expanded, FALSE, NULL);
+ formatted = vflist_get_formatted(vf, name, sidecars, size, time, expanded, FALSE, nullptr);
formatted_with_stars = vflist_get_formatted(vf, name, sidecars, size, time, expanded, TRUE, star_rating);
gtk_tree_store_set(store, iter, FILE_COLUMN_POINTER, fd,
while (!done)
{
- FileData *old_fd = NULL;
+ FileData *old_fd = nullptr;
gint old_version = 0;
if (valid)
void vflist_sort_set(ViewFile *vf, SortType type, gboolean ascend)
{
gint i;
- GHashTable *fd_idx_hash = g_hash_table_new(NULL, NULL);
+ GHashTable *fd_idx_hash = g_hash_table_new(nullptr, nullptr);
gint *new_order;
GtkTreeStore *store;
GList *work;
}
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview)));
- gtk_tree_store_reorder(store, NULL, new_order);
+ gtk_tree_store_reorder(store, nullptr, new_order);
g_free(new_order);
g_hash_table_destroy(fd_idx_hash);
FileData *vflist_thumb_next_fd(ViewFile *vf)
{
GtkTreePath *tpath;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
/* first check the visible files */
- if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter iter;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_path_free(tpath);
- tpath = NULL;
+ tpath = nullptr;
while (!fd && valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
{
FileData *vflist_star_next_fd(ViewFile *vf)
{
GtkTreePath *tpath;
- FileData *fd = NULL;
- FileData *nfd = NULL;
+ FileData *fd = nullptr;
+ FileData *nfd = nullptr;
/* first check the visible files */
- if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
+ if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, nullptr, nullptr, nullptr))
{
GtkTreeModel *store;
GtkTreeIter iter;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_path_free(tpath);
- tpath = NULL;
+ tpath = nullptr;
while (!fd && valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
{
if (vf->stars_id == 0)
{
- vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, NULL);
+ vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, nullptr);
}
}
}
}
else
{
- fd = NULL;
+ fd = nullptr;
}
work = work->next;
if (vf->stars_id == 0)
{
- vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, NULL);
+ vf->stars_id = g_idle_add_full(G_PRIORITY_LOW, vf_stars_cb, vf, nullptr);
}
}
}
if (fd_n == fd) found = TRUE;
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return found;
}
count = g_list_length(slist);
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return count;
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return g_list_reverse(list);
GtkTreeModel *store;
GtkTreeSelection *selection;
GList *slist;
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
return g_list_reverse(list);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
gtk_tree_selection_select_all(selection);
- VFLIST(vf)->select_fd = NULL;
+ VFLIST(vf)->select_fd = nullptr;
}
void vflist_select_none(ViewFile *vf)
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
tpath = gtk_tree_model_get_path(store, &iter);
- gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, NULL, FALSE);
+ gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, nullptr, FALSE);
gtk_tree_path_free(tpath);
}
}
static void vflist_select_closest(ViewFile *vf, FileData *sel_fd)
{
GList *work;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (sel_fd->parent) sel_fd = sel_fd->parent;
work = vf->list;
/* mark functions can have various side effects - update all columns to be sure */
vflist_setup_iter(vf, GTK_TREE_STORE(store), &iter, fd);
/* mark functions can change sidecars too */
- vflist_setup_iter_recursive(vf, GTK_TREE_STORE(store), &iter, fd->sidecar_files, NULL, FALSE);
+ vflist_setup_iter_recursive(vf, GTK_TREE_STORE(store), &iter, fd->sidecar_files, nullptr, FALSE);
}
work = work->next;
}
- g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), NULL);
+ g_list_foreach(slist, static_cast<GFunc>(tree_path_free_wrapper), nullptr);
g_list_free(slist);
}
selected = vflist_selection_get_list(vf);
- vflist_setup_iter_recursive(vf, store, NULL, vf->list, selected, force);
+ vflist_setup_iter_recursive(vf, store, nullptr, vf->list, selected, force);
- if (selected && vflist_selection_count(vf, NULL) == 0)
+ if (selected && vflist_selection_count(vf, nullptr) == 0)
{
/* all selected files disappeared */
vflist_select_closest(vf, static_cast<FileData *>(selected->data));
gboolean ret = TRUE;
old_list = vf->list;
- vf->list = NULL;
+ vf->list = nullptr;
DEBUG_1("%s vflist_refresh: read dir", get_exec_time());
if (vf->dir_fd)
{
file_data_unregister_notify_func(vf_notify_cb, vf); /* we don't need the notification of changes detected by filelist_read */
- ret = filelist_read(vf->dir_fd, &vf->list, NULL);
+ ret = filelist_read(vf->dir_fd, &vf->list, nullptr);
if (vf->marks_enabled)
{
static GdkColor *vflist_listview_color_shifted(GtkWidget *widget)
{
static GdkColor color;
- static GtkWidget *done = NULL;
+ static GtkWidget *done = nullptr;
if (done != widget)
{
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", n);
}
- gtk_tree_view_column_set_cell_data_func(column, renderer, vflist_listview_color_cb, vf, NULL);
+ gtk_tree_view_column_set_cell_data_func(column, renderer, vflist_listview_color_cb, vf, nullptr);
g_object_set_data(G_OBJECT(column), "column_store_idx", GUINT_TO_POINTER(n));
g_object_set_data(G_OBJECT(renderer), "column_store_idx", GUINT_TO_POINTER(n));
/* mark functions can have various side effects - update all columns to be sure */
vflist_setup_iter(vf, GTK_TREE_STORE(store), &iter, fd);
/* mark functions can change sidecars too */
- vflist_setup_iter_recursive(vf, GTK_TREE_STORE(store), &iter, fd->sidecar_files, NULL, FALSE);
+ vflist_setup_iter_recursive(vf, GTK_TREE_STORE(store), &iter, fd->sidecar_files, nullptr, FALSE);
}
file_data_register_notify_func(vf_notify_cb, vf, NOTIFY_PRIORITY_MEDIUM);
vflist_store_clear(vf, TRUE);
filelist_free(vf->list);
- vf->list = NULL;
+ vf->list = nullptr;
ret = vf_refresh(vf);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(vf->listview));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
- gtk_tree_selection_set_select_function(selection, vflist_select_cb, vf, NULL);
+ gtk_tree_selection_set_select_function(selection, vflist_select_cb, vf, nullptr);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vf->listview), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vf->listview), FALSE);
GList *vf_get_list(ViewFile *vf)
{
- GList *list = NULL;
+ GList *list = nullptr;
GList *work;
for (work = vf->list; work; work = work->next)
{
{
case FILEVIEW_LIST: ret = vflist_selection_get_list(vf); break;
case FILEVIEW_ICON: ret = vficon_selection_get_list(vf); break;
- default: ret = NULL;
+ default: ret = nullptr;
}
return ret;
{
case FILEVIEW_LIST: ret = vflist_selection_get_list_by_index(vf); break;
case FILEVIEW_ICON: ret = vficon_selection_get_list_by_index(vf); break;
- default: ret = NULL;
+ default: ret = nullptr;
}
return ret;
{
case FILEVIEW_LIST: ret = vflist_pop_menu_file_list(vf); break;
case FILEVIEW_ICON: ret = vficon_pop_menu_file_list(vf); break;
- default: ret = NULL;
+ default: ret = nullptr;
}
return ret;
{
case FILEVIEW_LIST: ret = vflist_selection_get_one(vf, fd); break;
case FILEVIEW_ICON: ret = vficon_selection_get_one(vf, fd); break;
- default: ret = NULL;
+ default: ret = nullptr;
}
return ret;
{
auto vf = static_cast<ViewFile *>(data);
LayoutWindow *lw_new;
- FileData *fd = NULL;
+ FileData *fd = nullptr;
gchar *dest_dir;
switch (vf->type)
}
else
{
- warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
+ warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, nullptr);
}
}
{
auto vf = static_cast<ViewFile *>(data);
- file_util_copy(NULL, vf_pop_menu_file_list(vf), NULL, vf->listview);
+ file_util_copy(nullptr, vf_pop_menu_file_list(vf), nullptr, vf->listview);
}
static void vf_pop_menu_move_cb(GtkWidget *UNUSED(widget), gpointer data)
{
auto vf = static_cast<ViewFile *>(data);
- file_util_move(NULL, vf_pop_menu_file_list(vf), NULL, vf->listview);
+ file_util_move(nullptr, vf_pop_menu_file_list(vf), nullptr, vf->listview);
}
static void vf_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
auto vf = static_cast<ViewFile *>(data);
options->file_ops.safe_delete_enable = FALSE;
- file_util_delete(NULL, vf_pop_menu_file_list(vf), vf->listview);
+ file_util_delete(nullptr, vf_pop_menu_file_list(vf), vf->listview);
}
static void vf_pop_menu_move_to_trash_cb(GtkWidget *UNUSED(widget), gpointer data)
auto vf = static_cast<ViewFile *>(data);
options->file_ops.safe_delete_enable = TRUE;
- file_util_delete(NULL, vf_pop_menu_file_list(vf), vf->listview);
+ file_util_delete(nullptr, vf_pop_menu_file_list(vf), vf->listview);
}
static void vf_pop_menu_copy_path_cb(GtkWidget *UNUSED(widget), gpointer data)
}
filelist_free(vf->editmenu_fd_list);
- vf->editmenu_fd_list = NULL;
+ vf->editmenu_fd_list = nullptr;
}
/**
{
case FILEVIEW_LIST:
vflist_color_set(vf, VFLIST(vf)->click_fd, TRUE);
- active = (VFLIST(vf)->click_fd != NULL);
- class_archive = (VFLIST(vf)->click_fd != NULL && VFLIST(vf)->click_fd->format_class == FORMAT_CLASS_ARCHIVE);
+ active = (VFLIST(vf)->click_fd != nullptr);
+ class_archive = (VFLIST(vf)->click_fd != nullptr && VFLIST(vf)->click_fd->format_class == FORMAT_CLASS_ARCHIVE);
break;
case FILEVIEW_ICON:
- active = (VFICON(vf)->click_fd != NULL);
- class_archive = (VFICON(vf)->click_fd != NULL && VFICON(vf)->click_fd->format_class == FORMAT_CLASS_ARCHIVE);
+ active = (VFICON(vf)->click_fd != nullptr);
+ class_archive = (VFICON(vf)->click_fd != nullptr && VFICON(vf)->click_fd->format_class == FORMAT_CLASS_ARCHIVE);
break;
}
accel_group = gtk_accel_group_new();
gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
- g_object_set_data(G_OBJECT(menu), "window_keys", NULL);
+ g_object_set_data(G_OBJECT(menu), "window_keys", nullptr);
g_object_set_data(G_OBJECT(menu), "accel_group", accel_group);
g_signal_connect(G_OBJECT(menu), "destroy",
gtk_widget_set_sensitive(item, active);
menu_item_add_divider(menu);
- submenu = submenu_add_sort(NULL, G_CALLBACK(vf_pop_menu_sort_cb), vf,
+ submenu = submenu_add_sort(nullptr, G_CALLBACK(vf_pop_menu_sort_cb), vf,
FALSE, FALSE, TRUE, vf->sort_method);
menu_item_add_divider(submenu);
menu_item_add_check(submenu, _("Ascending"), vf->sort_ascend,
G_CALLBACK(vf_pop_menu_sort_ascend_cb), vf);
- item = menu_item_add(menu, _("_Sort"), NULL, NULL);
+ item = menu_item_add(menu, _("_Sort"), nullptr, nullptr);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
item = menu_item_add_radio(menu, _("Images as List"), GINT_TO_POINTER(FILEVIEW_LIST), vf->type == FILEVIEW_LIST,
if (vf->popup)
{
g_signal_handlers_disconnect_matched(G_OBJECT(vf->popup), G_SIGNAL_MATCH_DATA,
- 0, 0, 0, NULL, vf);
+ 0, 0, nullptr, nullptr, vf);
gtk_widget_destroy(vf->popup);
}
vf_marks_tooltip_cancel_cb, mte);
generic_dialog_add_message(mte->gd, GTK_STOCK_DIALOG_QUESTION, _("Set mark text"),
_("This will set or clear the mark text."), FALSE);
- generic_dialog_add_button(mte->gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(mte->gd, GTK_STOCK_OK, nullptr,
vf_marks_tooltip_ok_cb, TRUE);
- generic_dialog_add_button(mte->gd, GTK_STOCK_HELP, NULL,
+ generic_dialog_add_button(mte->gd, GTK_STOCK_HELP, nullptr,
vf_marks_tooltip_help_cb, FALSE);
table = pref_table_new(mte->gd->vbox, 3, 1, FALSE, TRUE);
{
auto vf = static_cast<ViewFile *>(data);
gchar *entry_text;
- gchar *remove_text = NULL;
- gchar *index_text = NULL;
+ gchar *remove_text = nullptr;
+ gchar *index_text = nullptr;
gboolean text_found = FALSE;
gint i;
static GtkWidget *vf_marks_filter_init(ViewFile *vf)
{
- GtkWidget *frame = gtk_frame_new(NULL);
+ GtkWidget *frame = gtk_frame_new(nullptr);
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gint i;
static GtkWidget *vf_file_filter_init(ViewFile *vf)
{
- GtkWidget *frame = gtk_frame_new(NULL);
+ GtkWidget *frame = gtk_frame_new(nullptr);
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GList *work;
gint n = 0;
vf->sort_ascend = TRUE;
vf->read_metadata_in_idle_id = 0;
- vf->scrolled = gtk_scrolled_window_new(NULL, NULL);
+ vf->scrolled = gtk_scrolled_window_new(nullptr, nullptr);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(vf->scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vf->scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
void vf_thumb_cleanup(ViewFile *vf)
{
- vf_thumb_status(vf, 0.0, NULL);
+ vf_thumb_status(vf, 0.0, nullptr);
vf->thumbs_running = FALSE;
thumb_loader_free(vf->thumbs_loader);
- vf->thumbs_loader = NULL;
+ vf->thumbs_loader = nullptr;
- vf->thumbs_filedata = NULL;
+ vf->thumbs_filedata = nullptr;
}
void vf_thumb_stop(ViewFile *vf)
static gboolean vf_thumb_next(ViewFile *vf)
{
- FileData *fd = NULL;
+ FileData *fd = nullptr;
if (!gtk_widget_get_realized(vf->listview))
{
- vf_thumb_status(vf, 0.0, NULL);
+ vf_thumb_status(vf, 0.0, nullptr);
return FALSE;
}
thumb_loader_set_callbacks(vf->thumbs_loader,
vf_thumb_done_cb,
vf_thumb_error_cb,
- NULL,
+ nullptr,
vf);
if (!thumb_loader_start(vf->thumbs_loader, fd))
if (fd->thumb_pixbuf)
{
g_object_unref(fd->thumb_pixbuf);
- fd->thumb_pixbuf = NULL;
+ fd->thumb_pixbuf = nullptr;
}
}
}
}
vf->stars_id = 0;
- vf->stars_filedata = NULL;
+ vf->stars_filedata = nullptr;
}
void vf_star_stop(ViewFile *vf)
static gboolean vf_star_next(ViewFile *vf)
{
- FileData *fd = NULL;
+ FileData *fd = nullptr;
switch (vf->type)
{
}
else
{
- vf->stars_filedata = NULL;
+ vf->stars_filedata = nullptr;
vf->stars_id = 0;
return G_SOURCE_REMOVE;
}
GRegex *vf_file_filter_get_filter(ViewFile *vf)
{
- GRegex *ret = NULL;
- GError *error = NULL;
- gchar *file_filter_text = NULL;
+ GRegex *ret = nullptr;
+ GError *error = nullptr;
+ gchar *file_filter_text = nullptr;
if (!gtk_widget_get_visible(vf->file_filter.combo))
{
- return g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ return g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
file_filter_text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(vf->file_filter.combo));
{
log_printf("Error: could not compile regular expression %s\n%s\n", file_filter_text, error->message);
g_error_free(error);
- error = NULL;
- ret = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ error = nullptr;
+ ret = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
g_free(file_filter_text);
}
else
{
- ret = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), NULL);
+ ret = g_regex_new("", GRegexCompileFlags(0), GRegexMatchFlags(0), nullptr);
}
return ret;
{
if (!vf->refresh_idle_id)
{
- vf->time_refresh_set = time(NULL);
+ vf->time_refresh_set = time(nullptr);
/* file operations run with G_PRIORITY_DEFAULT_IDLE */
- vf->refresh_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE + 50, vf_refresh_idle_cb, vf, NULL);
+ vf->refresh_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE + 50, vf_refresh_idle_cb, vf, nullptr);
}
- else if (time(NULL) - vf->time_refresh_set > 1)
+ else if (time(nullptr) - vf->time_refresh_set > 1)
{
/* more than 1 sec since last update - increase priority */
vf_refresh_idle_cancel(vf);
- vf->time_refresh_set = time(NULL);
- vf->refresh_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE - 50, vf_refresh_idle_cb, vf, NULL);
+ vf->time_refresh_set = time(nullptr);
+ vf->refresh_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE - 50, vf_refresh_idle_cb, vf, nullptr);
}
}
work = work->next;
}
- vf_thumb_status(vf, 0.0, NULL);
+ vf_thumb_status(vf, 0.0, nullptr);
vf->read_metadata_in_idle_id = 0;
vf_refresh(vf);
return G_SOURCE_REMOVE;
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
char buffer[PATH_MAX];
- char* resolved = NULL;
+ char* resolved = nullptr;
int length = -1;
for (;;)
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
int length = -1;
- FILE* maps = NULL;
+ FILE* maps = nullptr;
for (int r = 0; r < WAI_PROC_SELF_MAPS_RETRY; ++r)
{
}
fclose(maps);
- maps = NULL;
+ maps = nullptr;
if (length != -1)
break;
GtkWidget *window;
window = gtk_window_new(type);
- if (!window) return NULL;
+ if (!window) return nullptr;
if (subtitle)
{
}
else
{
- gtk_window_set_icon_from_file(GTK_WINDOW(window), file, NULL);
+ gtk_window_set_icon_from_file(GTK_WINDOW(window), file, nullptr);
}
}
static gchar *command_result(const gchar *binary, const gchar *command)
{
- gchar *result = NULL;
+ gchar *result = nullptr;
FILE *f;
gchar buf[2048];
gint l;
- if (!binary || binary[0] == '\0') return NULL;
- if (!file_in_path(binary)) return NULL;
+ if (!binary || binary[0] == '\0') return nullptr;
+ if (!file_in_path(binary)) return nullptr;
if (!command || command[0] == '\0') return g_strdup(binary);
if (command[0] == '!') return g_strdup(command + 1);
f = popen(command, "r");
- if (!f) return NULL;
+ if (!f) return nullptr;
while ((l = fread(buf, sizeof(gchar), sizeof(buf), f)) > 0)
{
static const gchar *html_browsers[] =
{
/* Our specific script */
- GQ_APPNAME_LC "_html_browser", NULL,
+ GQ_APPNAME_LC "_html_browser", nullptr,
/* Redhat has a nifty htmlview script to start the user's preferred browser */
- "htmlview", NULL,
+ "htmlview", nullptr,
/* Debian has even better approach with alternatives */
- "sensible-browser", NULL,
+ "sensible-browser", nullptr,
/* GNOME 2 */
"gconftool-2", "gconftool-2 -g /desktop/gnome/url-handlers/http/command",
/* KDE */
"kfmclient", "!kfmclient exec \"%s\"",
/* use fallbacks */
- "firefox", NULL,
- "mozilla", NULL,
- "konqueror", NULL,
- "netscape", NULL,
+ "firefox", nullptr,
+ "mozilla", nullptr,
+ "konqueror", nullptr,
+ "netscape", nullptr,
"opera", "!opera --remote 'openURL(%s,new-page)'",
- NULL, NULL
+ nullptr, nullptr
};
static void help_browser_run(const gchar *path)
{
const gchar *name = options->helpers.html_browser.command_name;
const gchar *cmd = options->helpers.html_browser.command_line;
- gchar *result = NULL;
+ gchar *result = nullptr;
gint i;
i = 0;
if (ret == 0) break;
g_free(result);
- result = NULL;
+ result = nullptr;
}
}
if (!html_browsers[i]) break;
*-----------------------------------------------------------------------------
*/
-static GtkWidget *help_window = NULL;
+static GtkWidget *help_window = nullptr;
static void help_window_destroy_cb(GtkWidget *UNUSED(window), gpointer UNUSED(data))
{
- help_window = NULL;
+ help_window = nullptr;
}
void help_window_show(const gchar *key)
{
gchar *path;
- if (key && strstr(key, ".html") != 0)
+ if (key && strstr(key, ".html") != nullptr)
{
path = g_build_filename(gq_htmldir, key, NULL);
if (!isfile(path))
hsd = g_new0(HelpSearchData, 1);
hsd->gd = gd = generic_dialog_new(_("On-line help search"), "help_search",
- NULL, TRUE,
+ nullptr, TRUE,
help_search_window_cancel_cb, hsd);
- generic_dialog_add_message(gd, NULL, _("Search the on-line help files.\n"), NULL, FALSE);
+ generic_dialog_add_message(gd, nullptr, _("Search the on-line help files.\n"), nullptr, FALSE);
- generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
+ generic_dialog_add_button(gd, GTK_STOCK_OK, nullptr,
help_search_window_ok_cb, TRUE);
label1 = pref_label_new(GENERIC_DIALOG(gd)->vbox, _("Search engine:"));
{
uint64_t strLength;
if(!ZDDecodeVariableLengthUnsigned(library, index, &strLength)) {
- return NULL;
+ return nullptr;
}
uint32_t strOffset = *index;
remoteStr = 1;
if(!ZDDecodeVariableLengthUnsigned(library, &strOffset, &strLength)) {
- return NULL;
+ return nullptr;
}
if(strLength > 256) {
- return NULL;
+ return nullptr;
}
}
if(list) {
free(list);
}
- return NULL;
+ return nullptr;
}
float* ZDPolygonToList(const ZoneDetect *library, uint32_t polygonId, size_t* lengthPtr)
{
uint32_t polygonIndex;
- int32_t* data = NULL;
- float* flData = NULL;
+ int32_t* data = nullptr;
+ float* flData = nullptr;
size_t length = 0;
- if(!ZDFindPolygon(library, polygonId, NULL, &polygonIndex)) {
+ if(!ZDFindPolygon(library, polygonId, nullptr, &polygonIndex)) {
goto fail;
}
if(flData) {
free(flData);
}
- return NULL;
+ return nullptr;
}
static ZDLookupResult ZDPointInPolygon(const ZoneDetect *library, uint32_t polygonIndex, int32_t latFixedPoint, int32_t lonFixedPoint, uint64_t *distanceSqrMin)
fail:
ZDCloseDatabase(library);
- return NULL;
+ return nullptr;
}
ZoneDetect *ZDOpenDatabase(const char *path)
}
lseek(library->fd, 0, SEEK_SET);
- library->mapping = static_cast<uint8_t *>(mmap(NULL, static_cast<size_t>(library->length), PROT_READ, MAP_PRIVATE | MAP_FILE, library->fd, 0));
+ library->mapping = static_cast<uint8_t *>(mmap(nullptr, static_cast<size_t>(library->length), PROT_READ, MAP_PRIVATE | MAP_FILE, library->fd, 0));
if(library->mapping == MAP_FAILED) {
zdError(ZD_E_DB_MMAP, errno);
goto fail;
fail:
ZDCloseDatabase(library);
- return NULL;
+ return nullptr;
}
ZoneDetectResult *ZDLookup(const ZoneDetect *library, float lat, float lon, float *safezone)
auto results = static_cast<ZoneDetectResult *>(malloc(sizeof(ZoneDetectResult)));
if(!results) {
- return NULL;
+ return nullptr;
}
uint32_t polygonId = 0;
lonFixedPoint >= minLon &&
lonFixedPoint <= maxLon) {
- const ZDLookupResult lookupResult = ZDPointInPolygon(library, library->dataOffset + polygonIndex, latFixedPoint, lonFixedPoint, (safezone) ? &distanceSqrMin : NULL);
+ const ZDLookupResult lookupResult = ZDPointInPolygon(library, library->dataOffset + polygonIndex, latFixedPoint, lonFixedPoint, (safezone) ? &distanceSqrMin : nullptr);
if(lookupResult == ZD_LOOKUP_PARSE_ERROR) {
break;
} else if(lookupResult != ZD_LOOKUP_NOT_IN_ZONE) {
}
}
free(results);
- return NULL;
+ return nullptr;
}
}
}
}
}
free(results);
- return NULL;
+ return nullptr;
}
}
/* Write end marker */
results[numResults].lookupResult = ZD_LOOKUP_END;
results[numResults].numFields = 0;
- results[numResults].fieldNames = NULL;
- results[numResults].data = NULL;
+ results[numResults].fieldNames = nullptr;
+ results[numResults].data = nullptr;
if(safezone) {
*safezone = sqrtf(static_cast<float>(distanceSqrMin)) * 90 / static_cast<float>(1 << (library->precision - 1));
char* ZDHelperSimpleLookupString(const ZoneDetect* library, float lat, float lon)
{
- ZoneDetectResult *result = ZDLookup(library, lat, lon, NULL);
+ ZoneDetectResult *result = ZDLookup(library, lat, lon, nullptr);
if(!result) {
- return NULL;
+ return nullptr;
}
- char* output = NULL;
+ char* output = nullptr;
size_t length = 0;
- char* strings[2] = {NULL};
+ char* strings[2] = {nullptr};
if(result[0].lookupResult == ZD_LOOKUP_END) {
goto done;
projects / geeqie.git / commitdiff