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; }