AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/libpika/pikaresource.c

516 lines
15 KiB
C
Raw Blame History

/* LIBPIKA - The PIKA Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "pika.h"
#include "libpikabase/pikawire.h" /* FIXME kill this include */
#include "pikaplugin-private.h"
#include "pikaprocedure-private.h"
/* PikaResource: base class for resources.
*
* Known subclasses are Font, Brush, Pattern, Palette, Gradient.
* FUTURE: ? Dynamics, ToolPreset, ColorProfile, Color, ColorScale
* (PikaParasite is NOT.)
*
* A *resource* is data that PIKA loads at runtime startup,
* where the data is used by drawing tools.
* The PikaContext holds a user's current choice of resources.
* The PIKA core has the *resource* data.
*
* A resource has-a identifier.
* Currently the identifier is a string, sometimes called a name.
* The identifier is unique among instances(resource datas) loaded into PIKA.
*
* A user can change the set of resources installed with PIKA,
* and edit or create new resources meaning datasets.
* A user may attempt to install two different resources having the same name.
* A user may uninstall a resource while there are still references to it in settings.
*
* FUTURE: the identifier is world unique, a UUID or an integer incremented by core.
* Uniqueness is enforced by core.
*
* A PikaResource's identifier is serialized as a setting, i.e. a user's choice,
* A serialization of a PikaResource is *not* the serialization of the
* resource's underlying data e.g. not the pixels of a brush.
*
* The PikaResource identifier is opaque: you should only pass it around.
* You should not assume it has any human readable meaning (although it does now.)
* You should not assume that the "id" is a string.
* The Resource class encapsulates the ID so in the future, the type may change.
* PDB procedures that pass a string ID for a resource are obsolete.
*
* Usually a plugin lets a user choose a resource interactively
* then sets it into a temporary context to affect subsequent operations.
*
* The Pika architecture for plugins uses remote procedures,
* and identically named classes on each side of the wire.
* A PikaBrush class in core is not the same class as PikaBrush in libpika.
* a PikaResource on the libpika side is a proxy.
* There is no PikaResource class in core.
*
* One use of PikaResource and its subclasses is as a held type of
* GParamSpecObject, used to declare the parameters of a PDB
* procedure. A PikaResource just holds the id as a way to identify a
* *resource* in calls to PDB procedures that ultimately access the
* core instance of the resource.
*
* A PikaResource that has been serialized in a PikaConfig refers to a *resource*
* that might not still exist in core in the set of loaded resources (files.)
*
* A PikaResource:
* - furnishes its ID as a property
* - serializes/deserializes itself (implements PikaConfigInterface)
*
* Some subclasses e.g. PikaFont are pure types.
* That is, inheriting all its properties and methods from PikaResource.
* Such a pure type exists just to distinguish (by the name of its type)
* from other subclasses of PikaResource.
*
* Some subclasses have methods for getting/setting attributes of a resource.
* Some subclasses have methods for creating, duplicating, and deleting resources.
* Most methods are defined in the PDB (in .pdb files.)
*
* Internally, you may need to create a proxy object. Use:
* brush = g_object_new (PIKA_TYPE_BRUSH, NULL);
* g_object_set (PIKA_RESOURCE(brush), "id", "foo name", NULL);
* This does NOT create the resource's data in core, only a reference to it.
* When there is no underlying resource of that id (name) in core,
* the brush is invalid.
*/
enum
{
PROP_0,
PROP_ID,
N_PROPS
};
typedef struct _PikaResourcePrivate
{
gint id;
} PikaResourcePrivate;
static void pika_resource_config_iface_init (PikaConfigInterface *iface);
static void pika_resource_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void pika_resource_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean pika_resource_serialize (PikaConfig *config,
PikaConfigWriter *writer,
gpointer data);
static PikaConfig *
pika_resource_deserialize_create (GType type,
GScanner *scanner,
gint nest_level,
gpointer data);
G_DEFINE_TYPE_EXTENDED (PikaResource, pika_resource, G_TYPE_OBJECT,
G_TYPE_FLAG_ABSTRACT,
G_ADD_PRIVATE (PikaResource)
G_IMPLEMENT_INTERFACE (PIKA_TYPE_CONFIG,
pika_resource_config_iface_init))
#define parent_class pika_resource_parent_class
static GParamSpec *props[N_PROPS] = { NULL, };
static void
pika_resource_class_init (PikaResourceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->set_property = pika_resource_set_property;
object_class->get_property = pika_resource_get_property;
props[PROP_ID] =
g_param_spec_int ("id",
"The id",
"The id for internal use",
0, G_MAXINT32, 0,
PIKA_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties (object_class, N_PROPS, props);
}
static void
pika_resource_config_iface_init (PikaConfigInterface *iface)
{
iface->serialize = pika_resource_serialize;
iface->deserialize_create = pika_resource_deserialize_create;
}
static void
pika_resource_init (PikaResource *resource)
{
}
static void
pika_resource_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaResource *resource = PIKA_RESOURCE (object);
PikaResourcePrivate *priv = pika_resource_get_instance_private (resource);
switch (property_id)
{
case PROP_ID:
priv->id = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_resource_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaResource *resource = PIKA_RESOURCE (object);
PikaResourcePrivate *priv = pika_resource_get_instance_private (resource);
switch (property_id)
{
case PROP_ID:
g_value_set_int (value, priv->id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
pika_resource_serialize (PikaConfig *config,
PikaConfigWriter *writer,
gpointer data)
{
PikaResource *resource;
gchar *name;
gchar *collection;
gboolean is_internal;
g_return_val_if_fail (PIKA_IS_RESOURCE (config), FALSE);
resource = PIKA_RESOURCE (config);
is_internal = _pika_resource_get_identifiers (resource, &name, &collection);
if (is_internal)
pika_config_writer_identifier (writer, "internal");
pika_config_writer_string (writer, name);
pika_config_writer_string (writer, collection);
g_free (name);
g_free (collection);
return TRUE;
}
static PikaConfig *
pika_resource_deserialize_create (GType type,
GScanner *scanner,
gint nest_level,
gpointer data)
{
PikaResource *resource = NULL;
gchar *name = NULL;
gchar *collection = NULL;
gboolean is_internal = FALSE;
if (pika_scanner_parse_identifier (scanner, "internal"))
is_internal = TRUE;
if (pika_scanner_parse_string (scanner, &name) &&
pika_scanner_parse_string (scanner, &collection))
resource = _pika_resource_get_by_identifiers (g_type_name (type), name, collection, is_internal);
if (resource == NULL)
/* Default to context resource. */
resource = _pika_context_get_resource (g_type_name (type));
if (resource)
g_object_ref (resource);
g_free (collection);
g_free (name);;
return PIKA_CONFIG (resource);;
}
/**
* pika_resource_get_id:
* @resource: The resource.
*
* Returns: the resource ID.
*
* Since: 3.0
**/
gint32
pika_resource_get_id (PikaResource *resource)
{
if (resource)
{
PikaResourcePrivate *priv = pika_resource_get_instance_private (resource);
return priv->id;
}
else
{
return -1;
}
}
/**
* pika_resource_get_by_id:
* @resource_id: The resource id.
*
* Returns a #PikaResource representing @resource_id. Since #PikaResource is an
* abstract class, the real object type will actually be the proper
* subclass.
*
* Returns: (nullable) (transfer none): a #PikaResource for @resource_id or
* %NULL if @resource_id does not represent a valid resource.
* The object belongs to libpika and you must not modify
* or unref it.
*
* Since: 3.0
**/
PikaResource *
pika_resource_get_by_id (gint32 resource_id)
{
if (resource_id > 0)
{
PikaPlugIn *plug_in = pika_get_plug_in ();
PikaProcedure *procedure = _pika_plug_in_get_procedure (plug_in);
return _pika_procedure_get_resource (procedure, resource_id);
}
return NULL;
}
/**
* pika_resource_get_by_name:
* @resource_type: The #GType of the resource.
* @resource_name: The name of the resource.
*
* Returns the resource with the given @resource_type and
* @resource_name.
*
* Returns: (transfer full): The resource.
*
* Since: 3.0
**/
PikaResource *
pika_resource_get_by_name (GType resource_type,
const gchar *resource_name)
{
g_return_val_if_fail (g_type_is_a (resource_type, PIKA_TYPE_RESOURCE), NULL);
if (resource_name == NULL)
return NULL;
return _pika_resource_get_by_name (g_type_name (resource_type), resource_name);
}
/**
* pika_resource_is_valid:
* @resource: The resource to check.
*
* Returns TRUE if the resource is valid.
*
* This procedure checks if the given resource is valid and refers to an
* existing resource.
*
* Returns: Whether the resource is valid.
*
* Since: 3.0
**/
gboolean
pika_resource_is_valid (PikaResource *resource)
{
return pika_resource_id_is_valid (pika_resource_get_id (resource));
}
/**
* pika_resource_is_brush:
* @resource: The resource.
*
* Returns whether the resource is a brush.
*
* This procedure returns TRUE if the specified resource is a brush.
*
* Returns: TRUE if the resource is a brush, FALSE otherwise.
*
* Since: 3.0
**/
gboolean
pika_resource_is_brush (PikaResource *resource)
{
return pika_resource_id_is_brush (pika_resource_get_id (resource));
}
/**
* pika_resource_is_pattern:
* @resource: The resource.
*
* Returns whether the resource is a pattern.
*
* This procedure returns TRUE if the specified resource is a pattern.
*
* Returns: TRUE if the resource is a pattern, FALSE otherwise.
*
* Since: 3.0
**/
gboolean
pika_resource_is_pattern (PikaResource *resource)
{
return pika_resource_id_is_pattern (pika_resource_get_id (resource));
}
/**
* pika_resource_is_gradient:
* @resource: The resource.
*
* Returns whether the resource is a gradient.
*
* This procedure returns TRUE if the specified resource is a gradient.
*
* Returns: TRUE if the resource is a gradient, FALSE otherwise.
*
* Since: 3.0
**/
gboolean
pika_resource_is_gradient (PikaResource *resource)
{
return pika_resource_id_is_gradient (pika_resource_get_id (resource));
}
/**
* pika_resource_is_palette:
* @resource: The resource.
*
* Returns whether the resource is a palette.
*
* This procedure returns TRUE if the specified resource is a palette.
*
* Returns: TRUE if the resource is a palette, FALSE otherwise.
*
* Since: 3.0
**/
gboolean
pika_resource_is_palette (PikaResource *resource)
{
return pika_resource_id_is_palette (pika_resource_get_id (resource));
}
/**
* pika_resource_is_font:
* @resource: The resource.
*
* Returns whether the resource is a font.
*
* This procedure returns TRUE if the specified resource is a font.
*
* Returns: TRUE if the resource is a font, FALSE otherwise.
*
* Since: 3.0
**/
gboolean
pika_resource_is_font (PikaResource *resource)
{
return pika_resource_id_is_font (pika_resource_get_id (resource));
}
struct _PikaBrush
{
PikaResource parent_instance;
};
G_DEFINE_TYPE (PikaBrush, pika_brush, PIKA_TYPE_RESOURCE);
static void pika_brush_class_init (PikaBrushClass *klass) {}
static void pika_brush_init (PikaBrush *self) {}
struct _PikaPattern
{
PikaResource parent_instance;
};
G_DEFINE_TYPE (PikaPattern, pika_pattern, PIKA_TYPE_RESOURCE);
static void pika_pattern_class_init (PikaPatternClass *klass) {}
static void pika_pattern_init (PikaPattern *self) {}
struct _PikaGradient
{
PikaResource parent_instance;
};
G_DEFINE_TYPE (PikaGradient, pika_gradient, PIKA_TYPE_RESOURCE);
static void pika_gradient_class_init (PikaGradientClass *klass) {}
static void pika_gradient_init (PikaGradient *self) {}
struct _PikaPalette
{
PikaResource parent_instance;
};
G_DEFINE_TYPE (PikaPalette, pika_palette, PIKA_TYPE_RESOURCE);
static void pika_palette_class_init (PikaPaletteClass *klass) {}
static void pika_palette_init (PikaPalette *self) {}
struct _PikaFont
{
PikaResource parent_instance;
};
G_DEFINE_TYPE (PikaFont, pika_font, PIKA_TYPE_RESOURCE);
static void pika_font_class_init (PikaFontClass *klass) {}
static void pika_font_init (PikaFont *self) {}
Reference in New Issue View Git Blame Copy Permalink