void
mpid_read_device_file (MPIDDevice *device, const char *device_info_path)
{
GError *error = NULL;
GKeyFile *keyfile;
GBytes *bytes;
gsize len;
const void *data;
keyfile = g_key_file_new ();
bytes = g_resources_lookup_data (device_info_path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (bytes != NULL) {
data = g_bytes_get_data (bytes, &len);
if (g_key_file_load_from_data (keyfile, data, len, G_KEY_FILE_NONE, &error) == FALSE) {
mpid_debug ("unable to read device info resource %s: %s\n", device_info_path, error->message);
g_clear_error (&error);
device->error = MPID_ERROR_DEVICE_INFO_MISSING;
g_bytes_unref (bytes);
return;
}
} else if (g_key_file_load_from_file (keyfile, device_info_path, G_KEY_FILE_NONE, &error) == FALSE) {
mpid_debug ("unable to read device info file %s: %s\n", device_info_path, error->message);
g_clear_error (&error);
device->error = MPID_ERROR_DEVICE_INFO_MISSING;
return;
}
mpid_read_keyfile (device, keyfile);
g_key_file_free (keyfile);
}
gboolean
tpaw_xml_validate_from_resource (xmlDoc *doc,
const gchar *dtd_resourcename)
{
GBytes *resourcecontents;
gconstpointer resourcedata;
gsize resourcesize;
xmlParserInputBufferPtr buffer;
xmlValidCtxt cvp;
xmlDtd *dtd;
GError *error = NULL;
gboolean ret;
DEBUG ("Loading dtd resource %s", dtd_resourcename);
resourcecontents = g_resources_lookup_data (dtd_resourcename, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (error != NULL)
{
g_warning ("Unable to load dtd resource '%s': %s", dtd_resourcename, error->message);
g_error_free (error);
return FALSE;
}
resourcedata = g_bytes_get_data (resourcecontents, &resourcesize);
buffer = xmlParserInputBufferCreateStatic (resourcedata, resourcesize, XML_CHAR_ENCODING_UTF8);
memset (&cvp, 0, sizeof (cvp));
dtd = xmlIOParseDTD (NULL, buffer, XML_CHAR_ENCODING_UTF8);
ret = xmlValidateDtd (&cvp, doc, dtd);
xmlFreeDtd (dtd);
g_bytes_unref (resourcecontents);
return ret;
}
static void
_gth_window_add_css_provider (GtkWidget *widget,
const char *path)
{
GBytes *bytes;
gconstpointer css_data;
gsize css_data_size;
GtkCssProvider *css_provider;
GError *error = NULL;
bytes = g_resources_lookup_data (path, 0, &error);
if (bytes == NULL) {
g_warning ("%s", error->message);
g_error_free (error);
return;
}
css_data = g_bytes_get_data (bytes, &css_data_size);
css_provider = gtk_css_provider_new ();
if (! gtk_css_provider_load_from_data (css_provider, css_data, css_data_size, &error)) {
g_warning ("%s", error->message);
g_error_free (error);
}
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (widget),
GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
g_bytes_unref (bytes);
}
GBytes *
gtk_file_load_bytes (GFile *file,
GCancellable *cancellable,
GError **error)
{
gchar *contents;
gsize len;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
if (g_file_has_uri_scheme (file, "resource"))
{
gchar *uri, *unescaped;
GBytes *bytes;
uri = g_file_get_uri (file);
unescaped = g_uri_unescape_string (uri + strlen ("resource://"), NULL);
g_free (uri);
bytes = g_resources_lookup_data (unescaped, 0, error);
g_free (unescaped);
return bytes;
}
/* contents is always \0 terminated, but we don't include that in the bytes */
if (g_file_load_contents (file, cancellable, &contents, &len, NULL, error))
return g_bytes_new_take (contents, len);
return NULL;
}
static GtkBuilder *gtkhash_properties_init_builder(void)
{
#if (GTK_MAJOR_VERSION > 2)
return gtk_builder_new_from_resource(PROPERTIES_XML_RESOURCE);
#else
GError *error = NULL;
GBytes *bytes = g_resources_lookup_data(PROPERTIES_XML_RESOURCE,
G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (G_UNLIKELY(error)) {
g_warning("%s", error->message);
g_error_free(error);
return NULL;
}
gsize xml_len = 0;
char *xml = g_bytes_unref_to_data(bytes, &xml_len);
GtkBuilder *builder = gtk_builder_new();
gtk_builder_add_from_string(builder, xml, xml_len, &error);
g_free(xml);
if (G_UNLIKELY(error)) {
g_warning("%s", error->message);
g_error_free(error);
g_object_unref(builder);
return NULL;
}
return builder;
#endif
}
GtkWidget *
do_css_accordion (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GBytes *bytes;
gsize data_size;
const guint8 *data;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 600, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
gtk_widget_set_valign (container, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_button_new_with_label ("This");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Is");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("A");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("CSS");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Accordion");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label (":-)");
gtk_container_add (GTK_CONTAINER (container), child);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
bytes = g_resources_lookup_data ("/css_accordion/css_accordion.css", 0, NULL);
data = g_bytes_get_data (bytes, &data_size);
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), (gchar *)data, data_size, NULL);
g_bytes_unref (bytes);
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static void
begin_print (GtkPrintOperation *operation,
GtkPrintContext *context,
gpointer user_data)
{
PrintData *data = (PrintData *)user_data;
GBytes *bytes;
int i;
double height;
height = gtk_print_context_get_height (context) - HEADER_HEIGHT - HEADER_GAP;
data->lines_per_page = floor (height / data->font_size);
bytes = g_resources_lookup_data (data->resourcename, 0, NULL);
data->lines = g_strsplit (g_bytes_get_data (bytes, NULL), "\n", 0);
g_bytes_unref (bytes);
i = 0;
while (data->lines[i] != NULL)
i++;
data->num_lines = i;
data->num_pages = (data->num_lines - 1) / data->lines_per_page + 1;
gtk_print_operation_set_n_pages (operation, data->num_pages);
}
static void
ide_keybindings_load_plugin (IdeKeybindings *self,
PeasPluginInfo *plugin_info,
PeasEngine *engine)
{
g_autofree gchar *path = NULL;
const gchar *module_name;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GtkCssProvider) provider = NULL;
g_assert (IDE_IS_KEYBINDINGS (self));
g_assert (plugin_info != NULL);
g_assert (PEAS_IS_ENGINE (engine));
if (!self->mode || !self->plugin_providers)
return;
module_name = peas_plugin_info_get_module_name (plugin_info);
path = g_strdup_printf ("/org/gnome/builder/plugins/%s/keybindings/%s.css",
module_name, self->mode);
bytes = g_resources_lookup_data (path, 0, NULL);
if (bytes == NULL)
return;
IDE_TRACE_MSG ("Loading %s keybindings for \"%s\" plugin", self->mode, module_name);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (provider, path);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
g_hash_table_insert (self->plugin_providers,
g_strdup (module_name),
g_steal_pointer (&provider));
}
/**
* locate and setup a direct resource
*
* Direct resources have general type of NSGTK_RESOURCE_GLIB but have
* g_resources_lookup_data() applied and the result stored so the data
* can be directly accessed without additional processing.
*
* \param respath A string vector containing the valid resource search paths
* \param resource A resource entry to initialise
*/
static nserror
init_direct_resource(char **respath, struct nsgtk_resource_s *resource)
{
nserror res;
res = init_resource(respath, resource);
#ifdef WITH_GRESOURCE
if ((res == NSERROR_OK) &&
(resource->type == NSGTK_RESOURCE_GLIB)) {
/* found gresource we can convert */
GBytes *data;
data = g_resources_lookup_data(resource->path,
G_RESOURCE_LOOKUP_FLAGS_NONE,
NULL);
if (data != NULL) {
resource->type = NSGTK_RESOURCE_DIRECT;
resource->path = (char *)data;
}
}
#endif
return res;
}
static void
gb_keybindings_reload (GbKeybindings *self)
{
const gchar *mode;
g_autofree gchar *path = NULL;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (GB_IS_KEYBINDINGS (self));
mode = self->mode ? self->mode : "default";
IDE_TRACE_MSG ("Loading %s keybindings", mode);
path = g_strdup_printf ("/org/gnome/builder/keybindings/%s.css", mode);
bytes = g_resources_lookup_data (path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (error == NULL)
gtk_css_provider_load_from_data (self->css_provider,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
&error);
if (error)
g_warning ("%s", error->message);
IDE_EXIT;
}
GtkWidget *
do_css_basics (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "CSS Basics");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_basics/css_basics.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static void
walk_resource_path (const char *path, int level, int size)
{
char **children = g_resources_enumerate_children (path, 0, NULL);
int i;
if (!children)
return;
for (i = 0; children[i]; i++) {
const char *child = children[i];
char *subpath;
GBytes *data;
if (level == 0) {
size = atol (child);
if (size <= 0)
continue;
}
subpath = g_build_path ("/", path, child, NULL);
data = g_resources_lookup_data (subpath, 0, NULL);
if (data) {
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_resource (subpath, NULL);
if (pixbuf && size > 0 && strchr (child, '.')) {
char *iconname = g_strdup (child);
strchr(iconname, '.')[0] = 0;
if (gnm_debug_flag ("icons"))
g_printerr ("Defining icon %s at size %d\n", iconname, size);
gtk_icon_theme_add_builtin_icon (iconname,
size,
pixbuf);
g_object_unref (pixbuf);
g_free (iconname);
}
g_bytes_unref (data);
} else
walk_resource_path (subpath, level + 1, size);
g_free (subpath);
}
g_strfreev (children);
}
static void
update_css_for_blend_mode (GtkCssProvider *provider,
const gchar *blend_mode)
{
GBytes *bytes;
gchar *css;
bytes = g_resources_lookup_data ("/css_blendmodes/css_blendmodes.css", 0, NULL);
css = g_strdup_printf ((gchar*) g_bytes_get_data (bytes, NULL),
blend_mode,
blend_mode,
blend_mode);
gtk_css_provider_load_from_data (provider, css, -1, NULL);
g_bytes_unref (bytes);
g_free (css);
}
/**
* gda_server_provider_load_resource_contents:
* @prov_name: the provider's name
* @resource: the name of the resource to load
*
* Loads and returns the contents of the specified resource.
* This function should only be used by database provider's implementations
*
* Returns: (transfer full): a new string containing the resource's contents, or %NULL if not found or if an error occurred
*
* Since: 6.0
*/
gchar *
gda_server_provider_load_resource_contents (const gchar *prov_name, const gchar *resource)
{
g_return_val_if_fail (prov_name, NULL);
g_return_val_if_fail (resource, NULL);
gchar *rname;
rname = g_strdup_printf ("/spec/%s/%s", prov_name, resource);
GBytes *bytes;
bytes = g_resources_lookup_data (rname, G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
g_free (rname);
if (!bytes)
return NULL;
gchar *retval;
retval = g_strdup ((const gchar*) g_bytes_get_data (bytes, NULL));
g_bytes_unref (bytes);
return retval;
}
static gboolean
css_provider_load_from_resource (GtkCssProvider *provider,
const char *resource_path,
GError **error)
{
GBytes *data;
gboolean retval;
data = g_resources_lookup_data (resource_path, 0, error);
if (!data)
return FALSE;
retval = gtk_css_provider_load_from_data (provider,
g_bytes_get_data (data, NULL),
g_bytes_get_size (data),
error);
g_bytes_unref (data);
return retval;
}
/**
* panel_applet_setup_menu_from_resource:
* @applet: a #PanelApplet.
* @resource_path: a resource path
*
* Sets up the context menu of @applet. @filename is a resource path to a menu
* XML file, containing a #GtkUIManager UI definition that describes how to
* display the menu items. @action_group contains the various #GtkAction that
* are referenced in @xml.
*
* See also the <link linkend="getting-started.context-menu">Context
* Menu</link> section.
*
* Since: 3.4
**/
void
panel_applet_setup_menu_from_resource (PanelApplet *applet,
const gchar *resource_path)
{
GBytes *bytes;
GError *error = NULL;
bytes = g_resources_lookup_data (resource_path,
G_RESOURCE_LOOKUP_FLAGS_NONE,
&error);
if (bytes) {
panel_applet_setup_menu (applet, g_bytes_get_data (bytes, NULL));
} else {
g_warning ("%s", error->message);
g_error_free (error);
}
g_bytes_unref (bytes);
}
void gui_about(void)
{
GBytes* authors_bytes;
gsize size;
const char *authors[2];
authors_bytes = g_resources_lookup_data("/com/pannetrat/cardpeek/AUTHORS",G_RESOURCE_LOOKUP_FLAGS_NONE,NULL);
authors[0] = (const char *)g_bytes_get_data(authors_bytes,&size);
authors[1] = NULL;
gtk_show_about_dialog(GTK_WINDOW(MAIN_WINDOW),
"program-name", "cardpeek",
"version", VERSION,
"license", LICENSE,
"wrap-license", TRUE,
"authors", authors,
"comments", "Cardpeek is a tool to read the contents of smart cards.",
"copyright", "Copyright Alain Pannetrat <*****@*****.**>",
"website", "http://pannetrat.com/Cardpeek/",
"website-label", "http://pannetrat.com/Cardpeek/",
NULL);
}
static gboolean
setup_dbus (ControlData *data)
{
GBytes *bytes;
bytes = g_resources_lookup_data ("/net/hadess/SwitcherooControl/net.hadess.SwitcherooControl.xml",
G_RESOURCE_LOOKUP_FLAGS_NONE,
NULL);
data->introspection_data = g_dbus_node_info_new_for_xml (g_bytes_get_data (bytes, NULL), NULL);
g_bytes_unref (bytes);
g_assert (data->introspection_data != NULL);
data->name_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
CONTROL_PROXY_DBUS_NAME,
G_BUS_NAME_OWNER_FLAGS_NONE,
bus_acquired_handler,
name_acquired_handler,
name_lost_handler,
data,
NULL);
return TRUE;
}
int
main (int argc,
char **argv)
{
guint owner_id;
GBytes *introspection_bytes;
g_autoptr(GError) error = NULL;
g_autofree char *path = NULL;
GDBusConnection *session_bus;
GOptionContext *context;
setlocale (LC_ALL, "");
/* Avoid even loading gvfs to avoid accidental confusion */
g_setenv ("GIO_USE_VFS", "local", TRUE);
context = g_option_context_new ("- document portal");
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("option parsing failed: %s\n", error->message);
return 1;
}
if (opt_daemon)
{
pid_t pid;
ssize_t read_res;
daemon_event_fd = eventfd (0, EFD_CLOEXEC);
pid = fork ();
if (pid != 0)
{
guint64 counter;
read_res = read (daemon_event_fd, &counter, sizeof (counter));
if (read_res != 8)
exit (1);
exit (counter - 1);
}
}
if (opt_verbose)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, message_handler, NULL);
g_set_prgname (argv[0]);
loop = g_main_loop_new (NULL, FALSE);
path = g_build_filename (g_get_user_data_dir (), "xdg-app/db", TABLE_NAME, NULL);
db = xdg_app_db_new (path, FALSE, &error);
if (db == NULL)
{
g_printerr ("Failed to load db: %s\n", error->message);
do_exit (2);
}
session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (session_bus == NULL)
{
g_printerr ("No session bus: %s\n", error->message);
do_exit (3);
}
permission_store = xdg_app_permission_store_proxy_new_sync (session_bus,G_DBUS_PROXY_FLAGS_NONE,
"org.freedesktop.XdgApp",
"/org/freedesktop/XdgApp/PermissionStore",
NULL, &error);
if (permission_store == NULL)
{
g_print ("No permission store: %s\n", error->message);
do_exit (4);
}
/* We want do do our custom post-mainloop exit */
g_dbus_connection_set_exit_on_close (session_bus, FALSE);
g_signal_connect (session_bus, "closed", G_CALLBACK (session_bus_closed), NULL);
if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
set_one_signal_handler(SIGPIPE, SIG_IGN, 0) == -1)
{
do_exit (5);
}
introspection_bytes = g_resources_lookup_data ("/org/freedesktop/portal/Documents/org.freedesktop.portal.Documents.xml", 0, NULL);
g_assert (introspection_bytes != NULL);
introspection_data = g_dbus_node_info_new_for_xml (g_bytes_get_data (introspection_bytes, NULL), NULL);
owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.freedesktop.portal.Documents",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
g_main_loop_run (loop);
xdp_fuse_exit ();
g_bus_unown_name (owner_id);
g_dbus_node_info_unref (introspection_data);
do_exit (final_exit_status);
return 0;
}
void
load_file (const gchar *demoname,
const gchar *filename)
{
GtkTextBuffer *info_buffer, *source_buffer;
GtkTextIter start, end;
char *resource_filename;
GError *err = NULL;
int state = 0;
gboolean in_para = 0;
gchar **lines;
GBytes *bytes;
gint i;
if (!g_strcmp0 (current_file, filename))
return;
remove_data_tabs ();
add_data_tab (demoname);
g_free (current_file);
current_file = g_strdup (filename);
info_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (info_buffer, "title",
"font", "Sans 18",
"pixels-below-lines", 10,
NULL);
source_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (source_buffer, "comment",
"foreground", "DodgerBlue",
NULL);
gtk_text_buffer_create_tag (source_buffer, "type",
"foreground", "ForestGreen",
NULL);
gtk_text_buffer_create_tag (source_buffer, "string",
"foreground", "RosyBrown",
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_buffer_create_tag (source_buffer, "control",
"foreground", "purple",
NULL);
gtk_text_buffer_create_tag (source_buffer, "preprocessor",
"style", PANGO_STYLE_OBLIQUE,
"foreground", "burlywood4",
NULL);
gtk_text_buffer_create_tag (source_buffer, "function",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "DarkGoldenrod4",
NULL);
resource_filename = g_strconcat ("/sources/", filename, NULL);
bytes = g_resources_lookup_data (resource_filename, 0, &err);
g_free (resource_filename);
if (bytes == NULL)
{
g_warning ("Cannot open source for %s: %s\n", filename, err->message);
g_error_free (err);
return;
}
lines = g_strsplit (g_bytes_get_data (bytes, NULL), "\n", -1);
g_bytes_unref (bytes);
gtk_text_buffer_get_iter_at_offset (info_buffer, &start, 0);
for (i = 0; lines[i] != NULL; i++)
{
gchar *p;
gchar *q;
gchar *r;
/* Make sure \r is stripped at the end for the poor windows people */
lines[i] = g_strchomp (lines[i]);
p = lines[i];
switch (state)
{
case 0:
/* Reading title */
while (*p == '/' || *p == '*' || g_ascii_isspace (*p))
p++;
r = p;
while (*r != '\0')
{
while (*r != '/' && *r != ':' && *r != '\0')
r++;
if (*r == '/')
{
r++;
p = r;
}
if (r[0] == ':' && r[1] == ':')
*r = '\0';
}
q = p + strlen (p);
while (q > p && g_ascii_isspace (*(q - 1)))
q--;
if (q > p)
{
int len_chars = g_utf8_pointer_to_offset (p, q);
end = start;
g_assert (strlen (p) >= q - p);
gtk_text_buffer_insert (info_buffer, &end, p, q - p);
start = end;
gtk_text_iter_backward_chars (&start, len_chars);
gtk_text_buffer_apply_tag_by_name (info_buffer, "title", &start, &end);
start = end;
while (*p && *p != '\n') p++;
state++;
}
break;
case 1:
/* Reading body of info section */
while (g_ascii_isspace (*p))
p++;
if (*p == '*' && *(p + 1) == '/')
{
gtk_text_buffer_get_iter_at_offset (source_buffer, &start, 0);
state++;
}
else
{
int len;
while (*p == '*' || g_ascii_isspace (*p))
p++;
len = strlen (p);
while (g_ascii_isspace (*(p + len - 1)))
len--;
if (len > 0)
{
if (in_para)
gtk_text_buffer_insert (info_buffer, &start, " ", 1);
g_assert (strlen (p) >= len);
gtk_text_buffer_insert (info_buffer, &start, p, len);
in_para = 1;
}
else
{
gtk_text_buffer_insert (info_buffer, &start, "\n", 1);
in_para = 0;
}
}
break;
case 2:
/* Skipping blank lines */
while (g_ascii_isspace (*p))
p++;
if (*p)
{
p = lines[i];
state++;
/* Fall through */
}
else
break;
case 3:
/* Reading program body */
gtk_text_buffer_insert (source_buffer, &start, p, -1);
gtk_text_buffer_insert (source_buffer, &start, "\n", 1);
break;
}
}
fontify (source_buffer);
g_strfreev (lines);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (info_view), info_buffer);
g_object_unref (info_buffer);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), source_buffer);
g_object_unref (source_buffer);
}
static void
add_data_tab (const gchar *demoname)
{
gchar *resource_dir, *resource_name, *content_type, *content_mime;
gchar **resources;
GBytes *bytes;
GtkWidget *widget, *label;
guint i;
resource_dir = g_strconcat ("/", demoname, NULL);
resources = g_resources_enumerate_children (resource_dir, 0, NULL);
if (resources == NULL)
{
g_free (resource_dir);
return;
}
for (i = 0; resources[i]; i++)
{
resource_name = g_strconcat (resource_dir, "/", resources[i], NULL);
bytes = g_resources_lookup_data (resource_name, 0, NULL);
g_assert (bytes);
content_type = g_content_type_guess (resource_name,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
NULL);
content_mime = g_content_type_get_mime_type (content_type);
/* In theory we should look at all the mime types gdk-pixbuf supports
* and go from there, but we know what file types we've added.
*/
if (g_content_type_is_a (content_mime, "image/png") ||
g_content_type_is_a (content_mime, "image/gif") ||
g_content_type_is_a (content_mime, "image/jpeg"))
{
widget = gtk_image_new_from_resource (resource_name);
}
else if (g_content_type_is_a (content_mime, "text/plain") ||
g_content_type_is_a (content_mime, "application/x-ext-ui") ||
g_content_type_is_a (content_mime, "text/css"))
{
GtkTextBuffer *buffer;
GtkWidget *textview;
widget = create_text (&textview, FALSE);
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (buffer, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
gtk_text_view_set_buffer (GTK_TEXT_VIEW (textview), buffer);
}
else
{
g_warning ("Don't know how to display resource '%s' of type '%s'\n", resource_name, content_mime);
widget = NULL;
}
gtk_widget_show_all (widget);
label = gtk_label_new (resources[i]);
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, label);
gtk_container_child_set (GTK_CONTAINER (notebook),
GTK_WIDGET (widget),
"tab-expand", TRUE,
NULL);
g_free (content_mime);
g_free (content_type);
g_free (resource_name);
g_bytes_unref (bytes);
}
g_strfreev (resources);
g_free (resource_dir);
}
GtkWidget *
do_listbox (GtkWidget *do_widget)
{
GtkWidget *scrolled, *listbox, *vbox, *label;
GtkMessage *message;
GtkMessageRow *row;
GBytes *data;
char **lines;
int i;
if (!window)
{
avatar_pixbuf_other = gdk_pixbuf_new_from_resource_at_scale ("/listbox/apple-red.png", 32, 32, FALSE, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "List Box");
gtk_window_set_default_size (GTK_WINDOW (window),
400, 600);
/* NULL window variable when window is closed */
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("Messages from Gtk+ and friends");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
listbox = gtk_list_box_new ();
gtk_container_add (GTK_CONTAINER (scrolled), listbox);
gtk_list_box_set_sort_func (GTK_LIST_BOX (listbox), (GtkListBoxSortFunc)gtk_message_row_sort, listbox, NULL);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (listbox), FALSE);
g_signal_connect (listbox, "row-activated", G_CALLBACK (row_activated), NULL);
gtk_widget_show_all (vbox);
data = g_resources_lookup_data ("/listbox/messages.txt", 0, NULL);
lines = g_strsplit (g_bytes_get_data (data, NULL), "\n", 0);
for (i = 0; lines[i] != NULL && *lines[i]; i++)
{
message = gtk_message_new (lines[i]);
row = gtk_message_row_new (message);
gtk_widget_show (GTK_WIDGET (row));
gtk_container_add (GTK_CONTAINER (listbox), GTK_WIDGET (row));
}
g_strfreev (lines);
g_bytes_unref (data);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
static GBytes *
ide_language_defaults_get_defaults (GError **error)
{
return g_resources_lookup_data ("/org/gnome/builder/file-settings/defaults.ini",
G_RESOURCE_LOOKUP_FLAGS_NONE, error);
}
static gboolean
create_window(void)
{
GError *error = NULL;
builder = gtk_builder_new_from_resource("/org/chimara-if/player/chimara.ui");
window = GTK_WIDGET(load_object("chimara"));
aboutwindow = GTK_WIDGET(load_object("aboutwindow"));
prefswindow = GTK_WIDGET(load_object("prefswindow"));
recentwindow = GTK_WIDGET(load_object("recentwindow"));
glk = chimara_if_new();
g_object_set(glk,
"ignore-errors", TRUE,
/*"interpreter-number", CHIMARA_IF_ZMACHINE_TANDY_COLOR,*/
NULL);
GBytes *css_bytes = g_resources_lookup_data("/org/chimara-if/player/style.css",
G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (!css_bytes)
return FALSE;
size_t len;
char *css = g_bytes_unref_to_data(css_bytes, &len);
chimara_glk_set_css_from_string(CHIMARA_GLK(glk), css);
g_free(css);
/* DON'T UNCOMMENT THIS your eyes will burn
but it is a good test of programmatically altering just one style
chimara_glk_set_css_from_string(CHIMARA_GLK(glk),
"buffer { font-family: 'Comic Sans MS'; }");*/
GtkBox *vbox = GTK_BOX( gtk_builder_get_object(builder, "vbox") );
if(vbox == NULL)
return FALSE;
create_app_actions(G_ACTION_MAP(app), glk);
create_window_actions(G_ACTION_MAP(window), glk);
GtkWidget *toolbar = GTK_WIDGET(gtk_builder_get_object(builder, "toolbar"));
/* Set the default value of the "View/Toolbar" menu item upon creation of a
new window to the "show-toolbar-default" setting, but bind the setting
one-way only - we don't want toolbars to disappear suddenly */
GPropertyAction *toolbar_action = g_property_action_new("toolbar", toolbar, "visible");
g_action_map_add_action(G_ACTION_MAP(window), G_ACTION(toolbar_action));
if (g_settings_get_boolean(state_settings, "show-toolbar-default"))
gtk_widget_show(toolbar);
else
gtk_widget_hide(toolbar);
g_settings_bind(state_settings, "show-toolbar-default",
toolbar, "visible", G_SETTINGS_BIND_SET);
gtk_box_pack_end(vbox, glk, TRUE, TRUE, 0);
gtk_box_pack_start(vbox, toolbar, FALSE, FALSE, 0);
gtk_builder_connect_signals(builder, glk);
g_signal_connect(glk, "notify::program-name", G_CALLBACK(change_window_title), window);
g_signal_connect(glk, "notify::story-name", G_CALLBACK(change_window_title), window);
/* Create preferences window */
preferences_create(CHIMARA_GLK(glk));
return TRUE;
}
GtkWidget *
do_css_pixbufs (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *paned, *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Animated Backgrounds");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (window), paned);
/* Need a filler so we get a handle */
child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (paned), child);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (paned), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_pixbufs/gtk.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
/**
* cockpit_web_response_error:
* @self: the response
* @status: the HTTP status code
* @headers: headers to include or NULL
* @format: printf format of error message
*
* Send an error message with a basic HTML page containing
* the error.
*/
void
cockpit_web_response_error (CockpitWebResponse *self,
guint code,
GHashTable *headers,
const gchar *format,
...)
{
va_list var_args;
gchar *reason = NULL;
const gchar *message;
GBytes *input = NULL;
GList *output, *l;
GError *error = NULL;
g_return_if_fail (COCKPIT_IS_WEB_RESPONSE (self));
if (format)
{
va_start (var_args, format);
reason = g_strdup_vprintf (format, var_args);
va_end (var_args);
message = reason;
}
else
{
switch (code)
{
case 400:
message = "Bad request";
break;
case 401:
message = "Not Authorized";
break;
case 403:
message = "Forbidden";
break;
case 404:
message = "Not Found";
break;
case 405:
message = "Method Not Allowed";
break;
case 413:
message = "Request Entity Too Large";
break;
case 502:
message = "Remote Page is Unavailable";
break;
case 500:
message = "Internal Server Error";
break;
default:
if (code < 100)
reason = g_strdup_printf ("%u Continue", code);
else if (code < 200)
reason = g_strdup_printf ("%u OK", code);
else if (code < 300)
reason = g_strdup_printf ("%u Moved", code);
else
reason = g_strdup_printf ("%u Failed", code);
message = reason;
break;
}
}
g_debug ("%s: returning error: %u %s", self->logname, code, message);
if (cockpit_web_failure_resource)
{
input = g_resources_lookup_data (cockpit_web_failure_resource, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (input == NULL)
{
g_critical ("couldn't load: %s: %s", cockpit_web_failure_resource, error->message);
g_error_free (error);
}
}
if (!input)
input = g_bytes_new_static (default_failure_template, strlen (default_failure_template));
if (headers)
{
if (!g_hash_table_lookup (headers, "Content-Type"))
g_hash_table_replace (headers, g_strdup ("Content-Type"), g_strdup ("text/html; charset=utf8"));
cockpit_web_response_headers_full (self, code, message, -1, headers);
}
else
{
cockpit_web_response_headers (self, code, message, -1, "Content-Type", "text/html; charset=utf8", NULL);
}
output = cockpit_template_expand (input, substitute_message, (gpointer)message);
g_bytes_unref (input);
for (l = output; l != NULL; l = g_list_next (l))
{
if (!cockpit_web_response_queue (self, l->data))
break;
}
if (l == NULL)
cockpit_web_response_complete (self);
g_list_free_full (output, (GDestroyNotify)g_bytes_unref);
g_free (reason);
}
static GFileInfo *
g_resource_file_query_info (GFile *file,
const char *attributes,
GFileQueryInfoFlags flags,
GCancellable *cancellable,
GError **error)
{
GResourceFile *resource = G_RESOURCE_FILE (file);
GError *my_error = NULL;
GFileInfo *info;
GFileAttributeMatcher *matcher;
gboolean res;
gsize size;
guint32 resource_flags;
char **children;
gboolean is_dir;
char *base;
is_dir = FALSE;
children = g_resources_enumerate_children (resource->path, 0, NULL);
if (children != NULL)
{
g_strfreev (children);
is_dir = TRUE;
}
/* root is always there */
if (strcmp ("/", resource->path) == 0)
is_dir = TRUE;
if (!is_dir)
{
res = g_resources_get_info (resource->path, 0, &size, &resource_flags, &my_error);
if (!res)
{
if (g_error_matches (my_error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("The resource at '%s' does not exist"),
resource->path);
}
else
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
my_error->message);
g_clear_error (&my_error);
return FALSE;
}
}
matcher = g_file_attribute_matcher_new (attributes);
info = g_file_info_new ();
base = g_resource_file_get_basename (file);
g_file_info_set_name (info, base);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_READ, TRUE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_WRITE, FALSE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_EXECUTE, FALSE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_RENAME, FALSE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_DELETE, FALSE);
_g_file_info_set_attribute_boolean_by_id (info, G_FILE_ATTRIBUTE_ID_ACCESS_CAN_TRASH, FALSE);
if (is_dir)
{
g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
}
else
{
GBytes *bytes;
char *content_type;
g_file_info_set_file_type (info, G_FILE_TYPE_REGULAR);
g_file_info_set_size (info, size);
if ((_g_file_attribute_matcher_matches_id (matcher, G_FILE_ATTRIBUTE_ID_STANDARD_CONTENT_TYPE) ||
((~resource_flags & G_RESOURCE_FLAGS_COMPRESSED) &&
_g_file_attribute_matcher_matches_id (matcher, G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE))) &&
(bytes = g_resources_lookup_data (resource->path, 0, NULL)))
{
const guchar *data;
gsize data_size;
data = g_bytes_get_data (bytes, &data_size);
content_type = g_content_type_guess (base, data, data_size, NULL);
g_bytes_unref (bytes);
}
else
content_type = NULL;
if (content_type)
{
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_CONTENT_TYPE, content_type);
_g_file_info_set_attribute_string_by_id (info, G_FILE_ATTRIBUTE_ID_STANDARD_FAST_CONTENT_TYPE, content_type);
g_free (content_type);
}
}
g_free (base);
g_file_attribute_matcher_unref (matcher);
return info;
}
static void
add_data_tab (const gchar *demoname)
{
gchar *resource_dir, *resource_name;
gchar **resources;
GtkWidget *widget, *label;
guint i;
resource_dir = g_strconcat ("/", demoname, NULL);
resources = g_resources_enumerate_children (resource_dir, 0, NULL);
if (resources == NULL)
{
g_free (resource_dir);
return;
}
for (i = 0; resources[i]; i++)
{
resource_name = g_strconcat (resource_dir, "/", resources[i], NULL);
widget = gtk_image_new_from_resource (resource_name);
if (gtk_image_get_pixbuf (GTK_IMAGE (widget)) == NULL &&
gtk_image_get_animation (GTK_IMAGE (widget)) == NULL)
{
GBytes *bytes;
/* So we've used the best API available to figure out it's
* not an image. Let's try something else then.
*/
g_object_ref_sink (widget);
g_object_unref (widget);
bytes = g_resources_lookup_data (resource_name, 0, NULL);
g_assert (bytes);
if (g_utf8_validate (g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes), NULL))
{
/* Looks like it parses as text. Dump it into a textview then! */
GtkTextBuffer *buffer;
GtkWidget *textview;
widget = create_text (&textview, FALSE);
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (buffer, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
gtk_text_view_set_buffer (GTK_TEXT_VIEW (textview), buffer);
}
else
{
g_warning ("Don't know how to display resource '%s'\n", resource_name);
widget = NULL;
}
g_bytes_unref (bytes);
}
gtk_widget_show_all (widget);
label = gtk_label_new (resources[i]);
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, label);
gtk_container_child_set (GTK_CONTAINER (notebook),
GTK_WIDGET (widget),
"tab-expand", TRUE,
NULL);
g_free (resource_name);
}
g_strfreev (resources);
g_free (resource_dir);
}
GtkWidget *
do_css_multiplebgs (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *paned, *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
container = gtk_overlay_new ();
gtk_widget_add_events (container,
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_drawing_area_new ();
gtk_widget_set_name (child, "canvas");
g_signal_connect (child, "draw",
G_CALLBACK (drawing_area_draw), NULL);
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new ();
gtk_widget_add_events (child,
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK);
gtk_overlay_add_overlay (GTK_OVERLAY (container), child);
gtk_widget_set_name (child, "bricks-button");
gtk_widget_set_halign (child, GTK_ALIGN_CENTER);
gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
gtk_widget_set_size_request (child, 200, 80);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_overlay_add_overlay (GTK_OVERLAY (container), paned);
/* Need a filler so we get a handle */
child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (paned), child);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (paned), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text,
"changed",
G_CALLBACK (css_text_changed),
provider);
bytes = g_resources_lookup_data ("/css_multiplebgs/gtk.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
gboolean
peas_lua_utils_load_resource (lua_State *L,
const gchar *name,
guint n_args,
guint n_results)
{
gchar *resource_path;
GBytes *lua_resource;
const gchar *code;
gsize code_len;
gchar *lua_filename;
/* We don't use the byte-compiled Lua source
* because glib-compile-resources cannot output
* depends for generated files.
*
* There are also concerns that the bytecode is
* not stable enough between different Lua versions.
*
* https://bugzilla.gnome.org/show_bug.cgi?id=673101
*/
resource_path = g_strconcat ("/org/gnome/libpeas/loaders/lua5.1/",
name, NULL);
lua_resource = g_resources_lookup_data (resource_path,
G_RESOURCE_LOOKUP_FLAGS_NONE,
NULL);
g_free (resource_path);
if (lua_resource == NULL)
{
g_warning ("Failed to find '%s' resource", name);
return FALSE;
}
code = g_bytes_get_data (lua_resource, &code_len);
/* Filenames are prefixed with '@' */
lua_filename = g_strconcat ("@peas-lua-", name, NULL);
if (luaL_loadbuffer (L, code, code_len, lua_filename) != 0)
{
g_warning ("Failed to load '%s' resource: %s",
name, lua_tostring (L, -1));
/* Pop error */
lua_pop (L, 1);
g_free (lua_filename);
g_bytes_unref (lua_resource);
return FALSE;
}
g_free (lua_filename);
g_bytes_unref (lua_resource);
if (!peas_lua_utils_call (L, n_args, n_results))
{
g_warning ("Failed to run '%s' resource: %s",
name, lua_tostring (L, -1));
/* Pop error */
lua_pop (L, 1);
return FALSE;
}
return TRUE;
}
