* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include <locale.h>
+#include <clocale>
#include "main.h"
#include "metadata.h"
#include "layout-util.h"
#include "rcfile.h"
-typedef enum {
+enum MetadataKey {
MK_NONE,
MK_KEYWORDS,
MK_COMMENT
-} MetadataKey;
+};
/* If contents change, keep GuideOptionsMetadata.xml up to date */
/**
"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);
work = fd->cached_metadata;
while (work)
{
- GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = static_cast<gchar *>(entry->data);
+ auto entry = static_cast<GList *>(work->data);
+ auto entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
/* key found - just replace values */
GList *old_values = entry->next;
- entry->next = NULL;
- old_values->prev = NULL;
- string_list_free(old_values);
+ entry->next = nullptr;
+ old_values->prev = nullptr;
+ g_list_free_full(old_values, g_free);
work->data = g_list_append(entry, string_list_copy(values));
DEBUG_1("updated %s %s\n", key, fd->path);
return;
work = fd->cached_metadata;
while (work)
{
- GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = static_cast<gchar *>(entry->data);
+ auto entry = static_cast<GList *>(work->data);
+ auto entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
}
work = work->next;
}
- return NULL;
+ return nullptr;
DEBUG_1("not found %s %s\n", key, fd->path);
}
work = fd->cached_metadata;
while (work)
{
- GList *entry = static_cast<GList *>(work->data);
- gchar *entry_key = static_cast<gchar *>(entry->data);
+ auto entry = static_cast<GList *>(work->data);
+ auto entry_key = static_cast<gchar *>(entry->data);
if (strcmp(entry_key, key) == 0)
{
/* key found */
- string_list_free(entry);
+ g_list_free_full(entry, g_free);
fd->cached_metadata = g_list_delete_link(fd->cached_metadata, work);
DEBUG_1("removed %s %s\n", key, fd->path);
return;
void metadata_cache_free(FileData *fd)
{
- GList *work;
if (fd->cached_metadata) DEBUG_1("freed %s\n", fd->path);
- work = fd->cached_metadata;
- while (work)
+ g_list_free_full(fd->cached_metadata, [](gpointer data)
{
- GList *entry = static_cast<GList *>(work->data);
- string_list_free(entry);
-
- work = work->next;
- }
- g_list_free(fd->cached_metadata);
- fd->cached_metadata = NULL;
+ auto entry = static_cast<GList *>(data);
+ g_list_free_full(entry, g_free);
+ });
+ 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);
return TRUE;
}
-//gboolean metadata_write_queue_remove_list(GList *list)
-//{
- //GList *work;
- //gboolean ret = TRUE;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+gboolean metadata_write_queue_remove_list_unused(GList *list)
+{
+ GList *work;
+ gboolean ret = TRUE;
- //work = list;
- //while (work)
- //{
- //FileData *fd = static_cast<//FileData *>(work->data);
- //work = work->next;
- //ret = ret && metadata_write_queue_remove(fd);
- //}
- //return ret;
-//}
+ work = list;
+ while (work)
+ {
+ FileData *fd = static_cast<FileData *>(work->data);
+ work = work->next;
+ ret = ret && metadata_write_queue_remove(fd);
+ }
+ return ret;
+}
+#pragma GCC diagnostic pop
-void metadata_notify_cb(FileData *fd, NotifyType type, gpointer UNUSED(data))
+void metadata_notify_cb(FileData *fd, NotifyType type, gpointer)
{
if (type & (NOTIFY_REREAD | NOTIFY_CHANGE))
{
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)
{
- FileData *fd = static_cast<FileData *>(work->data);
+ auto fd = static_cast<FileData *>(work->data);
work = work->next;
if (!isname(fd->path))
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))
+static gboolean metadata_write_queue_idle_cb(gpointer)
{
- metadata_write_queue_confirm(FALSE, NULL, NULL);
+ metadata_write_queue_confirm(FALSE, nullptr, nullptr);
metadata_write_idle_id = 0;
return FALSE;
}
return success;
}
-gint metadata_queue_length(void)
+gint metadata_queue_length()
{
return g_list_length(metadata_write_queue);
}
{
if (!fd->modified_xmp)
{
- fd->modified_xmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)string_list_free);
+ fd->modified_xmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, reinterpret_cast<GDestroyNotify>(string_list_free));
}
- g_hash_table_insert(fd->modified_xmp, g_strdup(key), string_list_copy((GList *)values));
+ g_hash_table_insert(fd->modified_xmp, g_strdup(key), string_list_copy(const_cast<GList *>(values)));
metadata_cache_remove(fd, key);
while (work)
{
- FileData *sfd = static_cast<FileData *>(work->data);
+ auto sfd = static_cast<FileData *>(work->data);
work = work->next;
if (sfd->format_class == FORMAT_CLASS_META) continue;
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);
+ g_list_free_full(list, g_free);
return ret;
}
{
gchar string[50];
- g_snprintf(string, sizeof(string), "%llu", (unsigned long long) value);
+ g_snprintf(string, sizeof(string), "%llu", static_cast<unsigned long long>(value));
return metadata_write_string(fd, key, string);
}
secure_fprintf(ssi, "[keywords]\n");
while (keywords && secsave_errno == SS_ERR_NONE)
{
- const gchar *word = static_cast<const gchar *>(keywords->data);
+ auto word = static_cast<const gchar *>(keywords->data);
keywords = keywords->next;
secure_fprintf(ssi, "%s\n", word);
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) ? ((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);
success = metadata_file_write(metadata_pathl,
- have_keywords ? (GList *)keywords : orig_keywords,
+ have_keywords ? static_cast<GList *>(keywords) : orig_keywords,
have_comment ? comment : orig_comment);
g_free(metadata_pathl);
g_free(orig_comment);
- string_list_free(orig_keywords);
+ g_list_free_full(orig_keywords, g_free);
return success;
}
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;
}
else
{
- string_list_free(list);
+ g_list_free_full(list, g_free);
}
if (comment_build)
{
GList *work = list;
GHashTable *hashtable = g_hash_table_new(g_str_hash, g_str_equal);
- GList *newlist = NULL;
+ GList *newlist = nullptr;
while (work)
{
- gchar *key = static_cast<gchar *>(work->data);
+ 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, (gpointer) key, GINT_TO_POINTER(1));
+ g_hash_table_insert(hashtable, key, GINT_TO_POINTER(1));
newlist = g_list_prepend(newlist, key);
}
work = work->next;
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)
{
- return g_list_append(NULL, metadata_lua_info(fd, key, format));
+ return g_list_append(nullptr, metadata_lua_info(fd, key, format));
}
#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);
GList *string_list = metadata_read_list(fd, key, format);
if (string_list)
{
- gchar *str = static_cast<gchar *>(string_list->data);
- string_list->data = NULL;
- string_list_free(string_list);
+ auto str = static_cast<gchar *>(string_list->data);
+ string_list->data = nullptr;
+ g_list_free_full(string_list, g_free);
return str;
}
- return NULL;
+ return nullptr;
}
guint64 metadata_read_int(FileData *fd, const gchar *key, guint64 fallback)
gdouble min;
gdouble param;
char *coordinate;
- char *ref;
+ const char *ref;
gboolean ok = TRUE;
char *old_locale, *saved_locale;
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;
}
list = remove_duplicate_strings_from_list(list);
ret = metadata_write_list(fd, key, list);
- string_list_free(list);
+ g_list_free_full(list, g_free);
return ret;
}
}
while (list)
{
- gchar *haystack = static_cast<gchar *>(list->data);
+ auto haystack = static_cast<gchar *>(list->data);
if (haystack)
{
}
g_free(string_casefold);
- return NULL;
+ return nullptr;
}
/**
{
while (list)
{
- gchar *haystack = static_cast<gchar *>(list->data);
+ auto haystack = static_cast<gchar *>(list->data);
if (haystack && strcmp(haystack, string) == 0)
return haystack;
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_get_keyword_mark(FileData *fd, gint UNUSED(n), gpointer data)
+gboolean meta_data_get_keyword_mark(FileData *fd, gint, gpointer data)
{
/** @FIXME do not use global keyword_tree */
- GList *path = static_cast<GList *>(data);
+ auto path = static_cast<GList *>(data);
GList *keywords;
gboolean found = FALSE;
keywords = metadata_read_list(fd, KEYWORD_KEY, METADATA_PLAIN);
return found;
}
-gboolean meta_data_set_keyword_mark(FileData *fd, gint UNUSED(n), gboolean value, gpointer data)
+gboolean meta_data_set_keyword_mark(FileData *fd, gint, gboolean value, gpointer data)
{
- GList *path = static_cast<GList *>(data);
- GList *keywords = NULL;
+ auto path = static_cast<GList *>(data);
+ GList *keywords = nullptr;
GtkTreeIter iter;
if (!keyword_tree_get_iter(GTK_TREE_MODEL(keyword_tree), &iter, path)) return FALSE;
metadata_write_list(fd, KEYWORD_KEY, keywords);
}
- string_list_free(keywords);
+ g_list_free_full(keywords, g_free);
return TRUE;
}
if (get_mark_func == meta_data_get_keyword_mark)
{
GtkTreeIter old_kw_iter;
- GList *old_path = static_cast<GList *>(mark_func_data);
+ auto old_path = static_cast<GList *>(mark_func_data);
if (keyword_tree_get_iter(keyword_tree, &old_kw_iter, old_path) &&
(i == mark || /* release any previous connection of given mark */
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);
}
}
GList *path;
gchar *mark_str;
path = keyword_tree_get_path(keyword_tree, kw_iter);
- file_data_register_mark_func(mark, meta_data_get_keyword_mark, meta_data_set_keyword_mark, path, (GDestroyNotify)string_list_free);
+ file_data_register_mark_func(mark, meta_data_get_keyword_mark, meta_data_set_keyword_mark, path, reinterpret_cast<GDestroyNotify>(string_list_free));
mark_str = g_strdup_printf("%d", (mark < 9 ? mark : -1) + 1);
gtk_tree_store_set(GTK_TREE_STORE(keyword_tree), kw_iter, KEYWORD_COLUMN_MARK, mark_str, -1);
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;
while (TRUE)
{
- if (!(exclude_sibling && sibling && keyword_compare(keyword_tree, &iter, sibling) == 0))
+ if (!exclude_sibling || !sibling || keyword_compare(keyword_tree, &iter, sibling) != 0)
{
if (options->metadata.keywords_case_sensitive)
{
GList *keyword_tree_get_path(GtkTreeModel *keyword_tree, GtkTreeIter *iter_ptr)
{
- GList *path = NULL;
+ GList *path = nullptr;
GtkTreeIter iter = *iter_ptr;
while (TRUE)
gchar *iter_casefold = keyword_get_casefold(keyword_tree, &iter);
while (work)
{
- const gchar *casefold = static_cast<const gchar *>(work->data);
+ auto casefold = static_cast<const gchar *>(work->data);
work = work->next;
if (strcmp(iter_casefold, casefold) == 0)
gchar *iter_name = keyword_get_name(keyword_tree, &iter);
while (work)
{
- const gchar *name = static_cast<const gchar *>(work->data);
+ auto name = static_cast<const gchar *>(work->data);
work = work->next;
if (strcmp(iter_name, name) == 0)
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)
work = kw_list;
while (work)
{
- const gchar *kw = static_cast<const gchar *>(work->data);
+ auto kw = static_cast<const gchar *>(work->data);
work = work->next;
casefold_list = g_list_prepend(casefold_list, g_utf8_casefold(kw, -1));
ret = keyword_tree_is_set_casefold(keyword_tree, *iter, casefold_list);
- string_list_free(casefold_list);
+ g_list_free_full(casefold_list, g_free);
}
return ret;
GList *keyword_tree_get(GtkTreeModel *keyword_tree, GtkTreeIter *iter_ptr)
{
GtkTreeIter iter = *iter_ptr;
- GList *kw_list = NULL;
+ GList *kw_list = nullptr;
while (TRUE)
{
return !!g_list_find(list, id);
}
-static gboolean keyword_show_all_in_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer data)
+static gboolean keyword_show_all_in_cb(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer data)
{
keyword_show_in(GTK_TREE_STORE(model), iter, data);
return FALSE;
gtk_tree_model_foreach(GTK_TREE_MODEL(keyword_tree), keyword_show_all_in_cb, id);
}
-static gboolean keyword_revert_hidden_in_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter, gpointer data)
+static gboolean keyword_revert_hidden_in_cb(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer data)
{
if (keyword_is_hidden_in(GTK_TREE_MODEL(keyword_tree), iter, data))
{
keyword_hide_unset_in_recursive(keyword_tree, &iter, id, keywords);
}
-static gboolean keyword_show_set_in_cb(GtkTreeModel *model, GtkTreePath *UNUSED(path), GtkTreeIter *iter_ptr, gpointer data)
+static gboolean keyword_show_set_in_cb(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter_ptr, gpointer data)
{
GtkTreeIter iter = *iter_ptr;
- GList *keywords = static_cast<GList *>(data);
+ auto keywords = static_cast<GList *>(data);
gpointer id = keywords->data;
keywords = keywords->next; /* hack */
if (keyword_tree_is_set(model, &iter, keywords))
}
-void keyword_tree_new(void)
+void keyword_tree_new()
{
if (keyword_tree) return;
return iter;
}
-void keyword_tree_new_default(void)
+void keyword_tree_new_default()
{
GtkTreeIter i1, i2;
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);
}
if (mark_str)
{
- gint i = (gint)atoi(mark_str);
+ gint i = static_cast<gint>(atoi(mark_str));
if (i == 0) i = 10;
meta_data_connect_mark_with_keyword(GTK_TREE_MODEL(keyword_tree),
return gtk_tree_iter_copy(&iter);
}
g_free(name);
- return NULL;
+ return nullptr;
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
projects / geeqie.git / blobdiff