585 lines
19 KiB
C
585 lines
19 KiB
C
|
/* PIKA - Photo and Image Kooker Application
|
||
|
|
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
|
||
|
|
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
|
||
|
|
*
|
||
|
|
* Original copyright, applying to most contents (license remains unchanged):
|
||
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
||
|
|
*
|
||
|
|
* pikadataloaderfactory.c
|
||
|
|
* Copyright (C) 2001-2018 Michael Natterer <mitch@gimp.org>
|
||
|
|
*
|
||
|
|
* This program is free software: you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU General Public License as published by
|
||
|
|
* the Free Software Foundation; either version 3 of the License, or
|
||
|
|
* (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This program is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License
|
||
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "config.h"
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include <gdk-pixbuf/gdk-pixbuf.h>
|
||
|
|
#include <gegl.h>
|
||
|
|
|
||
|
|
#include "libpikabase/pikabase.h"
|
||
|
|
|
||
|
|
#include "core-types.h"
|
||
|
|
|
||
|
|
#include "pika.h"
|
||
|
|
#include "pika-utils.h"
|
||
|
|
#include "pikacontainer.h"
|
||
|
|
#include "pikadata.h"
|
||
|
|
#include "pikadataloaderfactory.h"
|
||
|
|
|
||
|
|
#include "pika-intl.h"
|
||
|
|
|
||
|
|
|
||
|
|
/* Data files that have this string in their path are considered
|
||
|
|
* obsolete and are only kept around for backwards compatibility
|
||
|
|
*/
|
||
|
|
#define PIKA_OBSOLETE_DATA_DIR_NAME "pika-obsolete-files"
|
||
|
|
|
||
|
|
|
||
|
|
typedef struct _PikaDataLoader PikaDataLoader;
|
||
|
|
|
||
|
|
struct _PikaDataLoader
|
||
|
|
{
|
||
|
|
gchar *name;
|
||
|
|
PikaDataLoadFunc load_func;
|
||
|
|
gchar *extension;
|
||
|
|
gboolean writable;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
struct _PikaDataLoaderFactoryPrivate
|
||
|
|
{
|
||
|
|
GList *loaders;
|
||
|
|
PikaDataLoader *fallback;
|
||
|
|
};
|
||
|
|
|
||
|
|
#define GET_PRIVATE(obj) (((PikaDataLoaderFactory *) (obj))->priv)
|
||
|
|
|
||
|
|
|
||
|
|
static void pika_data_loader_factory_finalize (GObject *object);
|
||
|
|
|
||
|
|
static void pika_data_loader_factory_data_init (PikaDataFactory *factory,
|
||
|
|
PikaContext *context);
|
||
|
|
static void pika_data_loader_factory_data_refresh (PikaDataFactory *factory,
|
||
|
|
PikaContext *context);
|
||
|
|
|
||
|
|
static PikaDataLoader *
|
||
|
|
pika_data_loader_factory_get_loader (PikaDataFactory *factory,
|
||
|
|
GFile *file);
|
||
|
|
|
||
|
|
static void pika_data_loader_factory_load (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache);
|
||
|
|
static void pika_data_loader_factory_load_directory (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache,
|
||
|
|
gboolean dir_writable,
|
||
|
|
GFile *directory,
|
||
|
|
GFile *top_directory);
|
||
|
|
static void pika_data_loader_factory_load_data (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache,
|
||
|
|
gboolean dir_writable,
|
||
|
|
GFile *file,
|
||
|
|
GFileInfo *info,
|
||
|
|
GFile *top_directory);
|
||
|
|
|
||
|
|
static PikaDataLoader * pika_data_loader_new (const gchar *name,
|
||
|
|
PikaDataLoadFunc load_func,
|
||
|
|
const gchar *extension,
|
||
|
|
gboolean writable);
|
||
|
|
static void pika_data_loader_free (PikaDataLoader *loader);
|
||
|
|
|
||
|
|
|
||
|
|
G_DEFINE_TYPE_WITH_PRIVATE (PikaDataLoaderFactory, pika_data_loader_factory,
|
||
|
|
PIKA_TYPE_DATA_FACTORY)
|
||
|
|
|
||
|
|
#define parent_class pika_data_loader_factory_parent_class
|
||
|
|
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_class_init (PikaDataLoaderFactoryClass *klass)
|
||
|
|
{
|
||
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
||
|
|
PikaDataFactoryClass *factory_class = PIKA_DATA_FACTORY_CLASS (klass);
|
||
|
|
|
||
|
|
object_class->finalize = pika_data_loader_factory_finalize;
|
||
|
|
|
||
|
|
factory_class->data_init = pika_data_loader_factory_data_init;
|
||
|
|
factory_class->data_refresh = pika_data_loader_factory_data_refresh;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_init (PikaDataLoaderFactory *factory)
|
||
|
|
{
|
||
|
|
factory->priv = pika_data_loader_factory_get_instance_private (factory);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_finalize (GObject *object)
|
||
|
|
{
|
||
|
|
PikaDataLoaderFactoryPrivate *priv = GET_PRIVATE (object);
|
||
|
|
|
||
|
|
g_list_free_full (priv->loaders, (GDestroyNotify) pika_data_loader_free);
|
||
|
|
priv->loaders = NULL;
|
||
|
|
|
||
|
|
g_clear_pointer (&priv->fallback, pika_data_loader_free);
|
||
|
|
|
||
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_data_init (PikaDataFactory *factory,
|
||
|
|
PikaContext *context)
|
||
|
|
{
|
||
|
|
pika_data_loader_factory_load (factory, context, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_refresh_cache_add (PikaDataFactory *factory,
|
||
|
|
PikaData *data,
|
||
|
|
gpointer user_data)
|
||
|
|
{
|
||
|
|
GFile *file = pika_data_get_file (data);
|
||
|
|
|
||
|
|
if (file)
|
||
|
|
{
|
||
|
|
PikaContainer *container = pika_data_factory_get_container (factory);
|
||
|
|
GHashTable *cache = user_data;
|
||
|
|
GList *list;
|
||
|
|
|
||
|
|
g_object_ref (data);
|
||
|
|
|
||
|
|
pika_container_remove (container, PIKA_OBJECT (data));
|
||
|
|
|
||
|
|
list = g_hash_table_lookup (cache, file);
|
||
|
|
list = g_list_prepend (list, data);
|
||
|
|
|
||
|
|
g_hash_table_insert (cache, file, list);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static gboolean
|
||
|
|
pika_data_loader_factory_refresh_cache_remove (gpointer key,
|
||
|
|
gpointer value,
|
||
|
|
gpointer user_data)
|
||
|
|
{
|
||
|
|
GList *list;
|
||
|
|
|
||
|
|
for (list = value; list; list = list->next)
|
||
|
|
g_object_unref (list->data);
|
||
|
|
|
||
|
|
g_list_free (value);
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_data_refresh (PikaDataFactory *factory,
|
||
|
|
PikaContext *context)
|
||
|
|
{
|
||
|
|
PikaContainer *container = pika_data_factory_get_container (factory);
|
||
|
|
GHashTable *cache;
|
||
|
|
|
||
|
|
pika_container_freeze (container);
|
||
|
|
|
||
|
|
/* First, save all dirty data objects */
|
||
|
|
pika_data_factory_data_save (factory);
|
||
|
|
|
||
|
|
cache = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
|
||
|
|
|
||
|
|
pika_data_factory_data_foreach (factory, TRUE,
|
||
|
|
pika_data_loader_factory_refresh_cache_add,
|
||
|
|
cache);
|
||
|
|
|
||
|
|
/* Now the cache contains a GFile => list-of-objects mapping of
|
||
|
|
* the old objects. So we should now traverse the directory and for
|
||
|
|
* each file load it only if its mtime is newer.
|
||
|
|
*
|
||
|
|
* Once a file was added, it is removed from the cache, so the only
|
||
|
|
* objects remaining there will be those that are not present on
|
||
|
|
* the disk (that have to be destroyed)
|
||
|
|
*/
|
||
|
|
pika_data_loader_factory_load (factory, context, cache);
|
||
|
|
|
||
|
|
/* Now all the data is loaded. Free what remains in the cache */
|
||
|
|
g_hash_table_foreach_remove (cache,
|
||
|
|
pika_data_loader_factory_refresh_cache_remove,
|
||
|
|
NULL);
|
||
|
|
|
||
|
|
g_hash_table_destroy (cache);
|
||
|
|
|
||
|
|
pika_container_thaw (container);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* public functions */
|
||
|
|
|
||
|
|
PikaDataFactory *
|
||
|
|
pika_data_loader_factory_new (Pika *pika,
|
||
|
|
GType data_type,
|
||
|
|
const gchar *path_property_name,
|
||
|
|
const gchar *writable_property_name,
|
||
|
|
const gchar *ext_property_name,
|
||
|
|
PikaDataNewFunc new_func,
|
||
|
|
PikaDataGetStandardFunc get_standard_func)
|
||
|
|
{
|
||
|
|
g_return_val_if_fail (PIKA_IS_PIKA (pika), NULL);
|
||
|
|
g_return_val_if_fail (g_type_is_a (data_type, PIKA_TYPE_DATA), NULL);
|
||
|
|
g_return_val_if_fail (path_property_name != NULL, NULL);
|
||
|
|
g_return_val_if_fail (writable_property_name != NULL, NULL);
|
||
|
|
g_return_val_if_fail (ext_property_name != NULL, NULL);
|
||
|
|
|
||
|
|
return g_object_new (PIKA_TYPE_DATA_LOADER_FACTORY,
|
||
|
|
"pika", pika,
|
||
|
|
"data-type", data_type,
|
||
|
|
"path-property-name", path_property_name,
|
||
|
|
"writable-property-name", writable_property_name,
|
||
|
|
"ext-property-name", ext_property_name,
|
||
|
|
"new-func", new_func,
|
||
|
|
"get-standard-func", get_standard_func,
|
||
|
|
NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
pika_data_loader_factory_add_loader (PikaDataFactory *factory,
|
||
|
|
const gchar *name,
|
||
|
|
PikaDataLoadFunc load_func,
|
||
|
|
const gchar *extension,
|
||
|
|
gboolean writable)
|
||
|
|
{
|
||
|
|
PikaDataLoaderFactoryPrivate *priv;
|
||
|
|
PikaDataLoader *loader;
|
||
|
|
|
||
|
|
g_return_if_fail (PIKA_IS_DATA_LOADER_FACTORY (factory));
|
||
|
|
g_return_if_fail (name != NULL);
|
||
|
|
g_return_if_fail (load_func != NULL);
|
||
|
|
g_return_if_fail (extension != NULL);
|
||
|
|
|
||
|
|
priv = GET_PRIVATE (factory);
|
||
|
|
|
||
|
|
loader = pika_data_loader_new (name, load_func, extension, writable);
|
||
|
|
|
||
|
|
priv->loaders = g_list_append (priv->loaders, loader);
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
pika_data_loader_factory_add_fallback (PikaDataFactory *factory,
|
||
|
|
const gchar *name,
|
||
|
|
PikaDataLoadFunc load_func)
|
||
|
|
{
|
||
|
|
PikaDataLoaderFactoryPrivate *priv;
|
||
|
|
|
||
|
|
g_return_if_fail (PIKA_IS_DATA_LOADER_FACTORY (factory));
|
||
|
|
g_return_if_fail (name != NULL);
|
||
|
|
g_return_if_fail (load_func != NULL);
|
||
|
|
|
||
|
|
priv = GET_PRIVATE (factory);
|
||
|
|
|
||
|
|
g_clear_pointer (&priv->fallback, pika_data_loader_free);
|
||
|
|
|
||
|
|
priv->fallback = pika_data_loader_new (name, load_func, NULL, FALSE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* private functions */
|
||
|
|
|
||
|
|
static PikaDataLoader *
|
||
|
|
pika_data_loader_factory_get_loader (PikaDataFactory *factory,
|
||
|
|
GFile *file)
|
||
|
|
{
|
||
|
|
PikaDataLoaderFactoryPrivate *priv = GET_PRIVATE (factory);
|
||
|
|
GList *list;
|
||
|
|
|
||
|
|
for (list = priv->loaders; list; list = g_list_next (list))
|
||
|
|
{
|
||
|
|
PikaDataLoader *loader = list->data;
|
||
|
|
|
||
|
|
if (pika_file_has_extension (file, loader->extension))
|
||
|
|
return loader;
|
||
|
|
}
|
||
|
|
|
||
|
|
return priv->fallback;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_load (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache)
|
||
|
|
{
|
||
|
|
const GList *ext_path;
|
||
|
|
GList *path;
|
||
|
|
GList *writable_path;
|
||
|
|
GList *list;
|
||
|
|
|
||
|
|
path = pika_data_factory_get_data_path (factory);
|
||
|
|
writable_path = pika_data_factory_get_data_path_writable (factory);
|
||
|
|
ext_path = pika_data_factory_get_data_path_ext (factory);
|
||
|
|
|
||
|
|
for (list = (GList *) ext_path; list; list = g_list_next (list))
|
||
|
|
{
|
||
|
|
/* Adding data from extensions.
|
||
|
|
* Consider these always non-writable (even when the directory is
|
||
|
|
* writable, since writability of extension is only taken into
|
||
|
|
* account for extension update).
|
||
|
|
*/
|
||
|
|
pika_data_loader_factory_load_directory (factory, context, cache,
|
||
|
|
FALSE,
|
||
|
|
list->data,
|
||
|
|
list->data);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (list = path; list; list = g_list_next (list))
|
||
|
|
{
|
||
|
|
gboolean dir_writable = FALSE;
|
||
|
|
|
||
|
|
if (g_list_find_custom (writable_path, list->data,
|
||
|
|
(GCompareFunc) pika_file_compare))
|
||
|
|
dir_writable = TRUE;
|
||
|
|
|
||
|
|
pika_data_loader_factory_load_directory (factory, context, cache,
|
||
|
|
dir_writable,
|
||
|
|
list->data,
|
||
|
|
list->data);
|
||
|
|
}
|
||
|
|
|
||
|
|
g_list_free_full (path, (GDestroyNotify) g_object_unref);
|
||
|
|
g_list_free_full (writable_path, (GDestroyNotify) g_object_unref);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_load_directory (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache,
|
||
|
|
gboolean dir_writable,
|
||
|
|
GFile *directory,
|
||
|
|
GFile *top_directory)
|
||
|
|
{
|
||
|
|
GFileEnumerator *enumerator;
|
||
|
|
|
||
|
|
enumerator = g_file_enumerate_children (directory,
|
||
|
|
G_FILE_ATTRIBUTE_STANDARD_NAME ","
|
||
|
|
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
|
||
|
|
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
|
||
|
|
G_FILE_ATTRIBUTE_TIME_MODIFIED,
|
||
|
|
G_FILE_QUERY_INFO_NONE,
|
||
|
|
NULL, NULL);
|
||
|
|
|
||
|
|
if (enumerator)
|
||
|
|
{
|
||
|
|
GFileInfo *info;
|
||
|
|
|
||
|
|
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)))
|
||
|
|
{
|
||
|
|
GFileType file_type;
|
||
|
|
GFile *child;
|
||
|
|
|
||
|
|
if (g_file_info_get_is_hidden (info))
|
||
|
|
{
|
||
|
|
g_object_unref (info);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
file_type = g_file_info_get_file_type (info);
|
||
|
|
child = g_file_enumerator_get_child (enumerator, info);
|
||
|
|
|
||
|
|
if (file_type == G_FILE_TYPE_DIRECTORY)
|
||
|
|
{
|
||
|
|
pika_data_loader_factory_load_directory (factory, context, cache,
|
||
|
|
dir_writable,
|
||
|
|
child,
|
||
|
|
top_directory);
|
||
|
|
}
|
||
|
|
else if (file_type == G_FILE_TYPE_REGULAR)
|
||
|
|
{
|
||
|
|
pika_data_loader_factory_load_data (factory, context, cache,
|
||
|
|
dir_writable,
|
||
|
|
child, info,
|
||
|
|
top_directory);
|
||
|
|
}
|
||
|
|
|
||
|
|
g_object_unref (child);
|
||
|
|
g_object_unref (info);
|
||
|
|
}
|
||
|
|
|
||
|
|
g_object_unref (enumerator);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_factory_load_data (PikaDataFactory *factory,
|
||
|
|
PikaContext *context,
|
||
|
|
GHashTable *cache,
|
||
|
|
gboolean dir_writable,
|
||
|
|
GFile *file,
|
||
|
|
GFileInfo *info,
|
||
|
|
GFile *top_directory)
|
||
|
|
{
|
||
|
|
PikaDataLoader *loader;
|
||
|
|
PikaContainer *container;
|
||
|
|
PikaContainer *container_obsolete;
|
||
|
|
GList *data_list = NULL;
|
||
|
|
GInputStream *input;
|
||
|
|
guint64 mtime;
|
||
|
|
GError *error = NULL;
|
||
|
|
|
||
|
|
loader = pika_data_loader_factory_get_loader (factory, file);
|
||
|
|
|
||
|
|
if (! loader)
|
||
|
|
return;
|
||
|
|
|
||
|
|
container = pika_data_factory_get_container (factory);
|
||
|
|
container_obsolete = pika_data_factory_get_container_obsolete (factory);
|
||
|
|
|
||
|
|
if (pika_data_factory_get_pika (factory)->be_verbose)
|
||
|
|
g_print (" Loading %s\n", pika_file_get_utf8_name (file));
|
||
|
|
|
||
|
|
mtime = g_file_info_get_attribute_uint64 (info,
|
||
|
|
G_FILE_ATTRIBUTE_TIME_MODIFIED);
|
||
|
|
|
||
|
|
if (cache)
|
||
|
|
{
|
||
|
|
GList *cached_data = g_hash_table_lookup (cache, file);
|
||
|
|
|
||
|
|
if (cached_data &&
|
||
|
|
pika_data_get_mtime (cached_data->data) != 0 &&
|
||
|
|
pika_data_get_mtime (cached_data->data) == mtime)
|
||
|
|
{
|
||
|
|
GList *list;
|
||
|
|
|
||
|
|
for (list = cached_data; list; list = g_list_next (list))
|
||
|
|
pika_container_add (container, list->data);
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
input = G_INPUT_STREAM (g_file_read (file, NULL, &error));
|
||
|
|
|
||
|
|
if (input)
|
||
|
|
{
|
||
|
|
GInputStream *buffered = g_buffered_input_stream_new (input);
|
||
|
|
|
||
|
|
data_list = loader->load_func (context, file, buffered, &error);
|
||
|
|
|
||
|
|
if (error)
|
||
|
|
{
|
||
|
|
g_prefix_error (&error,
|
||
|
|
_("Error loading '%s': "),
|
||
|
|
pika_file_get_utf8_name (file));
|
||
|
|
}
|
||
|
|
else if (! data_list)
|
||
|
|
{
|
||
|
|
g_set_error (&error, PIKA_DATA_ERROR, PIKA_DATA_ERROR_READ,
|
||
|
|
_("Error loading '%s'"),
|
||
|
|
pika_file_get_utf8_name (file));
|
||
|
|
}
|
||
|
|
|
||
|
|
g_object_unref (buffered);
|
||
|
|
g_object_unref (input);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
g_prefix_error (&error,
|
||
|
|
_("Could not open '%s' for reading: "),
|
||
|
|
pika_file_get_utf8_name (file));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (G_LIKELY (data_list))
|
||
|
|
{
|
||
|
|
GList *list;
|
||
|
|
gchar *uri;
|
||
|
|
gboolean obsolete;
|
||
|
|
gboolean writable = FALSE;
|
||
|
|
gboolean deletable = FALSE;
|
||
|
|
|
||
|
|
uri = g_file_get_uri (file);
|
||
|
|
|
||
|
|
obsolete = (strstr (uri, PIKA_OBSOLETE_DATA_DIR_NAME) != 0);
|
||
|
|
|
||
|
|
g_free (uri);
|
||
|
|
|
||
|
|
/* obsolete files are immutable, don't check their writability */
|
||
|
|
if (! obsolete)
|
||
|
|
{
|
||
|
|
deletable = (g_list_length (data_list) == 1 && dir_writable);
|
||
|
|
writable = (deletable && loader->writable);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (list = data_list; list; list = g_list_next (list))
|
||
|
|
{
|
||
|
|
PikaData *data = list->data;
|
||
|
|
|
||
|
|
pika_data_set_file (data, file, writable, deletable);
|
||
|
|
pika_data_set_mtime (data, mtime);
|
||
|
|
pika_data_clean (data);
|
||
|
|
|
||
|
|
if (obsolete)
|
||
|
|
{
|
||
|
|
pika_container_add (container_obsolete,
|
||
|
|
PIKA_OBJECT (data));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pika_data_set_folder_tags (data, top_directory);
|
||
|
|
|
||
|
|
pika_container_add (container,
|
||
|
|
PIKA_OBJECT (data));
|
||
|
|
}
|
||
|
|
|
||
|
|
g_object_unref (data);
|
||
|
|
}
|
||
|
|
|
||
|
|
g_list_free (data_list);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* not else { ... } because loader->load_func() can return a list
|
||
|
|
* of data objects *and* an error message if loading failed after
|
||
|
|
* something was already loaded
|
||
|
|
*/
|
||
|
|
if (G_UNLIKELY (error))
|
||
|
|
{
|
||
|
|
pika_message (pika_data_factory_get_pika (factory), NULL,
|
||
|
|
PIKA_MESSAGE_ERROR,
|
||
|
|
_("Failed to load data:\n\n%s"), error->message);
|
||
|
|
g_clear_error (&error);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static PikaDataLoader *
|
||
|
|
pika_data_loader_new (const gchar *name,
|
||
|
|
PikaDataLoadFunc load_func,
|
||
|
|
const gchar *extension,
|
||
|
|
gboolean writable)
|
||
|
|
{
|
||
|
|
PikaDataLoader *loader = g_slice_new (PikaDataLoader);
|
||
|
|
|
||
|
|
loader->name = g_strdup (name);
|
||
|
|
loader->load_func = load_func;
|
||
|
|
loader->extension = g_strdup (extension);
|
||
|
|
loader->writable = writable ? TRUE : FALSE;
|
||
|
|
|
||
|
|
return loader;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
pika_data_loader_free (PikaDataLoader *loader)
|
||
|
|
{
|
||
|
|
g_free (loader->name);
|
||
|
|
g_free (loader->extension);
|
||
|
|
|
||
|
|
g_slice_free (PikaDataLoader, loader);
|
||
|
|
}
|
