AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
9c84fa127a
gtk2/gtk/gtkbuilderlistitemfactory.c

402 lines
12 KiB
C
Raw Normal View History

listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
/*
* Copyright © 2019 Benjamin Otte
*
* 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 2.1 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
* Lesser 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 <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#include "config.h"
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
#include "gtkbuilderlistitemfactory.h"
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
#include "gtkbuilder.h"
builderlistitemfactory: Precompile the xml This is the one place where we can really take advantage of precompiling, since we instantiate this template over and over.
2019-12-23 23:23:59 +00:00
#include "gtkbuilderprivate.h"
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
#include "gtkintl.h"
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
#include "gtklistitemfactoryprivate.h"
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
#include "gtklistitemprivate.h"
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
* SECTION:gtkbuilderlistitemfactory
builderlistitemfactory: Documentation fixes
2020-06-30 02:08:21 +00:00
* @Title: GtkBuilderListItemFactory
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
* @Short_description: A listitem factory using ui files
*
* #GtkBuilderListItemFactory is a #GtkListItemFactory that creates
* widgets by instantiating #GtkBuilder UI templates. The templates
* must be extending #GtkListItem, and typically use #GtkExpressions
* to obtain data from the items in the model.
*
* Example:
* |[
* <interface>
* <template class="GtkListItem">
* <property name="child">
* <object class="GtkLabel">
* <property name="xalign">0</property>
* <binding name="label">
* <lookup name="name" type="SettingsKey">
* <lookup name="item">GtkListItem</lookup>
* </lookup>
* </binding>
* </object>
* </property>
* </template>
* </interface>
* ]|
*/
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
struct _GtkBuilderListItemFactory
{
GtkListItemFactory parent_instance;
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
GtkBuilderScope *scope;
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
GBytes *bytes;
builderlistitemfactory: Precompile the xml This is the one place where we can really take advantage of precompiling, since we instantiate this template over and over.
2019-12-23 23:23:59 +00:00
GBytes *data;
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
char *resource;
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
};
struct _GtkBuilderListItemFactoryClass
{
GtkListItemFactoryClass parent_class;
};
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
enum {
PROP_0,
PROP_BYTES,
PROP_RESOURCE,
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
PROP_SCOPE,
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
N_PROPS
};
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
G_DEFINE_TYPE (GtkBuilderListItemFactory, gtk_builder_list_item_factory, GTK_TYPE_LIST_ITEM_FACTORY)
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
static GParamSpec *properties[N_PROPS] = { NULL, };
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
static void
gtk_builder_list_item_factory_setup (GtkListItemFactory *factory,
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
GtkListItemWidget *widget,
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
GtkListItem *list_item)
{
GtkBuilderListItemFactory *self = GTK_BUILDER_LIST_ITEM_FACTORY (factory);
GtkBuilder *builder;
GError *error = NULL;
listitemfactory: Simplify Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track of what it needs to do. We're doing lots of dancing from one object to another here, but this will hopefully get simpler with further commits.
2019-11-03 01:23:46 +00:00
GTK_LIST_ITEM_FACTORY_CLASS (gtk_builder_list_item_factory_parent_class)->setup (factory, widget, list_item);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
builder = gtk_builder_new ();
gtk_builder_set_current_object (builder, G_OBJECT (list_item));
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
if (self->scope)
gtk_builder_set_scope (builder, self->scope);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
builderlistitemfactory: Precompile the xml This is the one place where we can really take advantage of precompiling, since we instantiate this template over and over.
2019-12-23 23:23:59 +00:00
if (!gtk_builder_extend_with_template (builder, G_OBJECT (list_item), G_OBJECT_TYPE (list_item),
(const char *)g_bytes_get_data (self->data, NULL),
g_bytes_get_size (self->data),
&error))
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
{
g_critical ("Error building template for list item: %s", error->message);
g_error_free (error);
/* This should never happen, if the template XML cannot be built
* then it is a critical programming error.
*/
g_object_unref (builder);
return;
}
g_object_unref (builder);
}
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
static void
gtk_builder_list_item_factory_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkBuilderListItemFactory *self = GTK_BUILDER_LIST_ITEM_FACTORY (object);
switch (property_id)
{
case PROP_BYTES:
g_value_set_boxed (value, self->bytes);
break;
case PROP_RESOURCE:
g_value_set_string (value, self->resource);
break;
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
case PROP_SCOPE:
g_value_set_object (value, self->scope);
break;
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
gtk_builder_list_item_factory_set_bytes (GtkBuilderListItemFactory *self,
GBytes *bytes)
{
if (bytes == NULL)
return FALSE;
if (self->bytes)
{
g_critical ("Data for GtkBuilderListItemFactory has already been set.");
return FALSE;
}
self->bytes = g_bytes_ref (bytes);
builderlistitemfactory: Precompile the xml This is the one place where we can really take advantage of precompiling, since we instantiate this template over and over.
2019-12-23 23:23:59 +00:00
if (!_gtk_buildable_parser_is_precompiled (g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes)))
{
GError *error = NULL;
GBytes *data;
data = _gtk_buildable_parser_precompile (g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
&error);
if (data == NULL)
{
g_warning ("Failed to precompile template for GtkBuilderListItemFactory: %s", error->message);
g_error_free (error);
self->data = g_bytes_ref (bytes);
}
else
{
self->data = data;
}
}
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
return TRUE;
}
static void
gtk_builder_list_item_factory_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkBuilderListItemFactory *self = GTK_BUILDER_LIST_ITEM_FACTORY (object);
switch (property_id)
{
case PROP_BYTES:
gtk_builder_list_item_factory_set_bytes (self, g_value_get_boxed (value));
break;
case PROP_RESOURCE:
{
GError *error = NULL;
GBytes *bytes;
const char *resource;
resource = g_value_get_string (value);
if (resource == NULL)
break;
bytes = g_resources_lookup_data (resource, 0, &error);
if (bytes)
{
if (gtk_builder_list_item_factory_set_bytes (self, bytes))
self->resource = g_strdup (resource);
g_bytes_unref (bytes);
}
else
{
g_critical ("Unable to load resource for list item template: %s", error->message);
g_error_free (error);
}
}
break;
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
case PROP_SCOPE:
self->scope = g_value_dup_object (value);
break;
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
static void
gtk_builder_list_item_factory_finalize (GObject *object)
{
GtkBuilderListItemFactory *self = GTK_BUILDER_LIST_ITEM_FACTORY (object);
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
g_clear_object (&self->scope);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
g_bytes_unref (self->bytes);
builderlistitemfactory: Precompile the xml This is the one place where we can really take advantage of precompiling, since we instantiate this template over and over.
2019-12-23 23:23:59 +00:00
g_bytes_unref (self->data);
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
g_free (self->resource);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
G_OBJECT_CLASS (gtk_builder_list_item_factory_parent_class)->finalize (object);
}
static void
gtk_builder_list_item_factory_class_init (GtkBuilderListItemFactoryClass *klass)
{
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
GtkListItemFactoryClass *factory_class = GTK_LIST_ITEM_FACTORY_CLASS (klass);
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
gobject_class->finalize = gtk_builder_list_item_factory_finalize;
gobject_class->get_property = gtk_builder_list_item_factory_get_property;
gobject_class->set_property = gtk_builder_list_item_factory_set_property;
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
factory_class->setup = gtk_builder_list_item_factory_setup;
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
/**
* GtkBuilderListItemFactory:bytes:
*
* bytes containing the UI definition
*/
properties[PROP_BYTES] =
g_param_spec_boxed ("bytes",
P_("Bytes"),
P_("bytes containing the UI definition"),
G_TYPE_BYTES,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
/**
* GtkBuilderListItemFactory:resource:
*
* resource containing the UI definition
*/
properties[PROP_RESOURCE] =
g_param_spec_string ("resource",
P_("Resource"),
P_("resource containing the UI definition"),
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
/**
* GtkBuilderListItemFactory:scope:
*
* scope to use when instantiating listitems
*/
properties[PROP_SCOPE] =
g_param_spec_object ("scope",
P_("Scope"),
P_("scope to use when instantiating listitems"),
GTK_TYPE_BUILDER_SCOPE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
g_object_class_install_properties (gobject_class, N_PROPS, properties);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
}
static void
gtk_builder_list_item_factory_init (GtkBuilderListItemFactory *self)
{
}
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
* gtk_builder_list_item_factory_new_from_bytes:
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
* @scope: (nullable) (transfer none): A scope to use when instantiating
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
* @bytes: the bytes containing the ui file to instantiate
*
* Creates s new #GtkBuilderListItemFactory that instantiates widgets
* using @bytes as the data to pass to #GtkBuilder.
*
* Returns: a new #GtkBuilderListItemFactory
**/
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
GtkListItemFactory *
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
gtk_builder_list_item_factory_new_from_bytes (GtkBuilderScope *scope,
GBytes *bytes)
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
{
g_return_val_if_fail (bytes != NULL, NULL);
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
return g_object_new (GTK_TYPE_BUILDER_LIST_ITEM_FACTORY,
"bytes", bytes,
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
"scope", scope,
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
NULL);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
}
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
/**
* gtk_builder_list_item_factory_new_from_resource:
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
* @scope: (nullable) (transfer none): A scope to use when instantiating
listview: Expose GtkListItemFactory APIs Due to the many different ways to set factories, it makes sense to expose them as custom objects. This makes the actual APIs for the list widgets simpler, because they can just have a regular "factory" property. As a convenience function, gtk_list_view_new_with_factory() was added to make this whole approach easy to use from C.
2019-10-08 22:07:07 +00:00
* @resource_path: valid path to a resource that contains the data
*
* Creates s new #GtkBuilderListItemFactory that instantiates widgets
* using data read from the given @resource_path to pass to #GtkBuilder.
*
* Returns: a new #GtkBuilderListItemFactory
**/
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
GtkListItemFactory *
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
gtk_builder_list_item_factory_new_from_resource (GtkBuilderScope *scope,
const char *resource_path)
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
{
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
g_return_val_if_fail (scope == NULL || GTK_IS_BUILDER_SCOPE (scope), NULL);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
g_return_val_if_fail (resource_path != NULL, NULL);
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
return g_object_new (GTK_TYPE_BUILDER_LIST_ITEM_FACTORY,
"resource", resource_path,
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
"scope", scope,
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
NULL);
}
/**
* gtk_builder_list_item_factory_get_bytes:
* @self: a #GtkBuilderListItemFactory
*
* Gets the data used as the #GtkBuilder UI template for constructing
* listitems.
*
* Returns: (transfer none): The GtkBuilder data
*
**/
GBytes *
gtk_builder_list_item_factory_get_bytes (GtkBuilderListItemFactory *self)
{
g_return_val_if_fail (GTK_IS_BUILDER_LIST_ITEM_FACTORY (self), NULL);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
return self->bytes;
}
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
/**
* gtk_builder_list_item_factory_get_resource:
* @self: a #GtkBuilderListItemFactory
*
* If the data references a resource, gets the path of that resource.
*
* Returns: (transfer none) (nullable): The path to the resource or %NULL
* if none
**/
const char *
gtk_builder_list_item_factory_get_resource (GtkBuilderListItemFactory *self)
{
g_return_val_if_fail (GTK_IS_BUILDER_LIST_ITEM_FACTORY (self), NULL);
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
listitemfactory: Make the builder factory properly buildable Turn the construct arguments into construct properties so that they can be set from ui files.
2019-10-18 02:07:04 +00:00
return self->resource;
listitemfactory: Add a factory for ui files Reuse <template> magic to initialize GtkListItems. This feels amazingly hacky, but it also amazingly worked on the first try.
2019-06-10 02:58:45 +00:00
}
builderlistitemfactory: Add scope argument This way, the scope used when creating builder instances can be influenced. This way, callbacks can be passed into the factory.
2019-12-03 06:03:10 +00:00
/**
* gtk_builder_list_item_factory_get_scope:
* @self: a #GtkBuilderListItemFactory
*
* Gets the scope used when constructing listitems.
*
* Returns: (transfer none) (nullable): The scope used when constructing listitems
**/
GtkBuilderScope *
gtk_builder_list_item_factory_get_scope (GtkBuilderListItemFactory *self)
{
g_return_val_if_fail (GTK_IS_BUILDER_LIST_ITEM_FACTORY (self), NULL);
return self->scope;
}
Reference in New Issue Copy Permalink