static GtkWidget * cc_sharing_panel_new_media_sharing_row (const char *uri_or_path, CcSharingPanel *self) { GtkWidget *row, *box, *w; GUserDirectory dir = G_USER_N_DIRECTORIES; GIcon *icon; guint i; char *basename, *path; GFile *file; file = g_file_new_for_commandline_arg (uri_or_path); path = g_file_get_path (file); g_object_unref (file); row = gtk_list_box_row_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 12); gtk_container_add (GTK_CONTAINER (row), box); /* Find the icon and create it */ for (i = 0; i < G_USER_N_DIRECTORIES; i++) { if (g_strcmp0 (path, g_get_user_special_dir (i)) == 0) { dir = i; break; } } icon = special_directory_get_gicon (dir); w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU); gtk_widget_set_margin_end (w, 12); gtk_container_add (GTK_CONTAINER (box), w); g_object_unref (icon); /* Label */ basename = g_filename_display_basename (path); w = gtk_label_new (basename); g_free (basename); gtk_container_add (GTK_CONTAINER (box), w); /* Remove button */ w = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE); gtk_widget_set_margin_top (w, 3); gtk_widget_set_margin_bottom (w, 3); gtk_widget_set_margin_end (w, 12); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (cc_sharing_panel_remove_folder), self); g_object_set_data (G_OBJECT (w), "row", row); g_object_set_data_full (G_OBJECT (row), "path", g_strdup (path), g_free); gtk_widget_show_all (row); return row; }
gboolean filebrowser_backend_process_drag_drop(FilebrowserBackend *filebackend, gchar *stringdata) { FilebrowserBackendDetails *directory; directory = FILEBROWSER_BACKEND_GET_PRIVATE(filebackend); GFile *destdir = g_file_new_for_commandline_arg (directory->current_folder); g_object_ref(destdir); if (destdir) { if (strchr(stringdata, '\n') == NULL) { /* no newlines, probably a single file */ GSList *list = NULL; GFile *uri; uri = g_file_new_for_commandline_arg(stringdata); list = g_slist_append(list, uri); filebrowser_backend_copy_uris_async(filebackend, destdir, list); g_slist_free(list); g_object_unref(uri); } else { /* there are newlines, probably this is a list of uri's */ filebrowser_backend_copy_files_async(filebackend,destdir, stringdata); } g_object_unref(destdir); return TRUE; } else { return FALSE; } }
/** * rb_async_copy_start: * @copy: a #RBAsyncCopy * @src: source URI * @dest: destination URI * @callback: completion callback * @user_data: data for completion callback * @destroy_data: destroy function for user_data * * Starts copying @src to @dest, calling @callback on completion or error. */ void rb_async_copy_start (RBAsyncCopy *copy, const char *src, const char *dest, RBAsyncCopyCallback callback, gpointer user_data, GDestroyNotify destroy_data) { g_assert (copy->priv->src == NULL); copy->priv->cancel = g_cancellable_new (); copy->priv->callback = callback; copy->priv->callback_data = user_data; copy->priv->destroy_data = destroy_data; copy->priv->src = g_file_new_for_commandline_arg (src); copy->priv->dest = g_file_new_for_commandline_arg (dest); g_file_copy_async (copy->priv->src, copy->priv->dest, G_FILE_COPY_NONE, G_PRIORITY_DEFAULT, copy->priv->cancel, progress_cb, copy, copy_cb, copy); }
void filebrowser_backend_create_dir(FilebrowserBackend *filebackend, gchar *filename, gchar *name, gboolean isdir){ FilebrowserBackendDetails *directory = FILEBROWSER_BACKEND_GET_PRIVATE(filebackend); GFile *config; GError *error=NULL; gchar *filename_int; if (isdir){ gchar *parent=filename_parent_uri(filename); filename_int= g_strdup_printf("%s/%s",parent,name); g_free(parent); config= g_file_new_for_commandline_arg(filename_int); } else { gchar *parent; if (filename) { parent=filename_parent_uri(filename); } else { parent=g_strdup(directory->current_folder); } filename_int= g_build_path (G_DIR_SEPARATOR_S, parent, name, NULL); g_free(parent); config=g_file_new_for_commandline_arg(filename_int); } gphpedit_debug_message(DEBUG_FILEBROWSER, "New directory:%s",filename_int); g_free(filename_int); if (!g_file_make_directory (config, directory->cancellable, &error)){ g_print(_("Error creating folder. GIO error:%s\n"), error->message); g_error_free (error); } g_object_unref(config); filebrowser_backend_refresh_folder (filebackend); }
int main (int argc, char* argv[]) { GtkWidget *window; GList *sources; GFile *dest; GFile *source; int i; GList *infos; NautilusProgressInfoManager *manager; NautilusProgressInfo *progress_info; test_init (&argc, &argv); if (argc < 3) { g_print ("Usage test-copy <sources...> <dest dir>\n"); return 1; } sources = NULL; for (i = 1; i < argc - 1; i++) { source = g_file_new_for_commandline_arg (argv[i]); sources = g_list_prepend (sources, source); } sources = g_list_reverse (sources); dest = g_file_new_for_commandline_arg (argv[i]); window = test_window_new ("copy test", 5); gtk_widget_show (window); manager = nautilus_progress_info_manager_new (); nautilus_file_operations_copy (sources, NULL /* GArray *relative_item_points */, dest, GTK_WINDOW (window), copy_done, NULL); infos = nautilus_progress_info_manager_get_all_infos (manager); if (infos == NULL) { g_object_unref (manager); return 0; } progress_info = NAUTILUS_PROGRESS_INFO (infos->data); g_signal_connect (progress_info, "changed", (GCallback)changed_cb, NULL); g_signal_connect (progress_info, "progress-changed", (GCallback)progress_changed_cb, NULL); g_signal_connect (progress_info, "finished", (GCallback)finished_cb, NULL); gtk_main (); g_object_unref (manager); return 0; }
static void fm_path_entry_changed(GtkEditable *editable, gpointer user_data) { FmPathEntry *entry = FM_PATH_ENTRY(editable); FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry); GtkWidget* widget = GTK_WIDGET(entry); const gchar *path_str, *sep; /* find parent dir of current path */ path_str = gtk_entry_get_text( GTK_ENTRY(entry) ); sep = g_utf8_strrchr(path_str, -1, G_DIR_SEPARATOR); if(sep) /* we found a parent dir */ { int parent_len = (sep - path_str) + 1; /* includes the dir separator / */ if(!priv->parent_dir || priv->parent_len != parent_len || strncmp(priv->parent_dir, path_str, parent_len )) { /* parent dir has been changed, reload dir list */ ListSubDirNames* data = g_slice_new0(ListSubDirNames); g_free(priv->parent_dir); priv->parent_dir = g_strndup(path_str, parent_len); priv->parent_len = parent_len; /* g_debug("parent dir is changed to %s", priv->parent_dir); */ /* FIXME: convert utf-8 encoded path to on-disk encoding. */ data->entry = entry; if(priv->parent_dir[0] == '~') /* special case for home dir */ { char* expand = g_strconcat(g_get_home_dir(), priv->parent_dir + 1, NULL); data->dir = g_file_new_for_commandline_arg(expand); g_free(expand); } else data->dir = g_file_new_for_commandline_arg(priv->parent_dir); /* clear current model */ gtk_list_store_clear(GTK_LIST_STORE(priv->model)); /* cancel running dir-listing jobs */ if(priv->cancellable) { g_cancellable_cancel(priv->cancellable); g_object_unref(priv->cancellable); } /* launch a new job to do dir listing */ data->cancellable = g_cancellable_new(); priv->cancellable = (GCancellable*)g_object_ref(data->cancellable); g_io_scheduler_push_job(list_sub_dirs, data, (GDestroyNotify)list_sub_dir_names_free, G_PRIORITY_LOW, data->cancellable); } /* calculate the length of remaining part after / */ priv->typed_basename_len = strlen(sep + 1); } else /* clear all autocompletion thing. */ clear_completion(priv); }
/** * dax_dom_document_new_from_file: * * Creates a new #DaxDomDocument. FIXME * * Return value: the newly created #DaxDomDocument instance */ DaxDomDocument * dax_dom_document_new_from_file (const gchar *filename, GError **error) { DaxDomDocument *document; GFile *file, *directory; ParserContext ctx; gchar *base_uri; ctx.reader = xmlNewTextReaderFilename(filename); if (ctx.reader == NULL) return NULL; document = dax_document_new(); ctx.current_node = DAX_DOM_NODE (document); /* Set up the base uri */ file = g_file_new_for_commandline_arg (filename); directory = g_file_get_parent (file); base_uri = g_file_get_uri (directory); dax_dom_document_set_base_iri (document, base_uri); g_free (base_uri); g_object_unref (file); g_object_unref (directory); dax_dom_document_parse_and_setup (document, &ctx); return document; }
gboolean timeout_func (gpointer user_data) { char ** argv = (char **)user_data; g_usleep(500000); g_debug("Initing"); gchar * command = g_strdup_printf("%s --dbus-name=org.dbusmenu.test --dbus-object=/org/test", argv[1]); g_debug("Executing: %s", command); gchar * output; g_spawn_command_line_sync(command, &output, NULL, NULL, NULL); GFile * ofile = g_file_new_for_commandline_arg(argv[2]); if (ofile != NULL) { g_file_replace_contents(ofile, output, g_utf8_strlen(output, -1), NULL, FALSE, 0, NULL, NULL, NULL); } g_spawn_command_line_sync("gdbus call --session --dest org.dbusmenu.test --object-path /org/test --method com.canonical.dbusmenu.Event 0 clicked \"<0>\" 0", NULL, NULL, NULL, NULL); g_main_loop_quit(mainloop); return TRUE; }
static void ag_app_import_cb(GSimpleAction *action, GVariant *parameter, gpointer user_data) { gint response; GtkWidget *fs; GtkFileFilter *filter; GSList *filenames = NULL; const gchar *target_type = g_variant_get_string(parameter, NULL); AgAppImportType type = AG_APP_IMPORT_NONE; AgApp *app = AG_APP(user_data); if (strncmp("agc", target_type, 3) == 0) { type = AG_APP_IMPORT_AGC; filter = filter_chart; } else if (strncmp("hor", target_type, 3) == 0) { type = AG_APP_IMPORT_HOR; filter = filter_hor; } else { g_error("Unknown import type!"); } fs = gtk_file_chooser_dialog_new( _("Select charts"), gtk_application_get_active_window(GTK_APPLICATION(app)), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Import"), GTK_RESPONSE_ACCEPT, NULL ); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter_all); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fs), filter); gtk_dialog_set_default_response(GTK_DIALOG(fs), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fs), TRUE); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fs), FALSE); response = gtk_dialog_run(GTK_DIALOG(fs)); if (response == GTK_RESPONSE_ACCEPT) { filenames = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(fs)); } if (filenames != NULL) { GSList *l; for (l = filenames; l; l = g_slist_next(l)) { GFile *file; char *data = l->data; if (data == NULL) { continue; } file = g_file_new_for_commandline_arg(data); ag_app_import_file(AG_APP(user_data), file, type); } } gtk_widget_destroy(fs); }
void foreach_gxps_page (const gchar *xps_filename, GXPSPageFunc page_func, gpointer data) { GError *error = NULL; GFile *gfile = g_file_new_for_commandline_arg (xps_filename); GXPSFile *file = gxps_file_new (gfile, &error); if (file == NULL) rerror ("Unable to open %s: %s", xps_filename, error->message); GXPSDocument *doc = gxps_file_get_document (file, 0, &error); if (doc == NULL) rerror ("Unable to open %s: %s", xps_filename, error->message); gint page_count = gxps_document_get_n_pages (doc); xps_range_set_min (range, 1); xps_range_set_max (range, page_count); if (xps_range_is_empty (range)) xps_range_append (range, 1, page_count, 1); gint pi; XpsRangeIter iter; xps_range_iter_init (&iter, range); while (xps_range_iter_next (&iter, &pi)) { GXPSPage *page = gxps_document_get_page (doc, pi-1, &error); gdouble width, height; gxps_page_get_size (page, &width, &height); page_func (page, width, height, data); g_object_unref (page); } }
GSList* vnr_tools_get_list_from_array (gchar **files) { GSList *uri_list = NULL; gint i; if (files == NULL) return NULL; for (i = 0; files[i]; i++) { char *uri_string; GFile *file; file = g_file_new_for_commandline_arg (files[i]); uri_string = g_file_get_path (file); g_object_unref (file); if (uri_string) { uri_list = g_slist_prepend (uri_list, g_strdup (uri_string)); g_free (uri_string); } } return g_slist_reverse (uri_list); }
gchar * clean_uri (gchar * input_arg) { GFile *gfile; gchar *fileuri; if (gst_uri_is_valid (input_arg)) fileuri = g_strdup (input_arg); else { gfile = g_file_new_for_commandline_arg (input_arg); if (g_file_has_uri_scheme (gfile, "archive") != FALSE) { g_print ("ERROR: %s isn't a file\n", input_arg); } fileuri = g_file_get_path (gfile); if (g_str_has_suffix (fileuri, ".iso")) { fileuri = g_strdup_printf ("dvd://%s", fileuri); } else { fileuri = g_strdup_printf ("file://%s", fileuri); } } return fileuri; }
static char * copy_db (void) { GFile *src, *dest; char *url, *path; GError *error = NULL; gboolean ret; db_dir_path = g_dir_make_tmp("test-gom-find-XXXXXXX", &error); g_assert(db_dir_path); g_assert_no_error(error); src = g_file_new_for_commandline_arg (DB); path = g_build_filename(db_dir_path, "gom-db-test.db", NULL); dest = g_file_new_for_path (path); g_free (path); ret = g_file_copy (src, dest, G_FILE_COPY_TARGET_DEFAULT_PERMS, NULL, NULL, NULL, &error); g_assert_no_error(error); g_assert (ret); g_object_unref (src); url = g_file_get_uri(dest); g_object_unref (dest); return url; }
GSList* eog_util_string_array_to_list (const gchar **files, gboolean create_uri) { gint i; GSList *list = NULL; if (files == NULL) return list; for (i = 0; files[i]; i++) { char *str; if (create_uri) { GFile *file; file = g_file_new_for_commandline_arg (files[i]); str = g_file_get_uri (file); g_object_unref (file); } else { str = g_strdup (files[i]); } if (str) { list = g_slist_prepend (list, g_strdup (str)); g_free (str); } } return g_slist_reverse (list); }
static void destroy_and_quit(VteTerminal *terminal, GtkWidget *window) { const char *output_file = g_object_get_data (G_OBJECT (terminal), "output_file"); if (output_file) { GFile *file; GOutputStream *stream; GError *error = NULL; file = g_file_new_for_commandline_arg (output_file); stream = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error)); if (stream) { vte_terminal_write_contents (terminal, stream, VTE_TERMINAL_WRITE_DEFAULT, NULL, &error); g_object_unref (stream); } if (error) { g_printerr ("%s\n", error->message); g_error_free (error); } g_object_unref (file); } gtk_widget_destroy (window); gtk_main_quit (); }
static void create_file_with_data (MMSms *sms, const gchar *input_path_str) { GError *error = NULL; gchar *path; GFile *file; const guint8 *data; gsize data_size; file = g_file_new_for_commandline_arg (input_path_str); path = g_file_get_path (file); data = mm_sms_get_data (sms, &data_size); if (!data) { g_printerr ("error: couldn't create file: SMS has no data\n"); exit (EXIT_FAILURE); } if (!g_file_set_contents (path, (const gchar *)data, data_size, &error)) { g_printerr ("error: cannot write to file '%s': '%s'\n", input_path_str, error->message); exit (EXIT_FAILURE); } g_free (path); g_object_unref (file); }
VinagreConnection * vinagre_connection_new_from_file (const gchar *uri, gchar **error_msg, gboolean use_bookmarks) { VinagreConnection *conn; gchar *data; GFile *file_a; GError *error; GHashTable *extensions; GHashTableIter iter; gpointer ext; *error_msg = NULL; data = NULL; conn = NULL; error = NULL; file_a = g_file_new_for_commandline_arg (uri); if (!g_file_load_contents (file_a, NULL, &data, NULL, NULL, &error)) { if (error) { *error_msg = g_strdup (error->message); g_error_free (error); } else *error_msg = g_strdup (_("Could not open the file.")); goto the_end; } extensions = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ()); g_hash_table_iter_init (&iter, extensions); while (g_hash_table_iter_next (&iter, NULL, &ext)) { VinagreProtocol *protocol = VINAGRE_PROTOCOL (ext); if (vinagre_protocol_recognize_file (protocol, file_a)) { conn = vinagre_protocol_new_connection_from_file (protocol, data, use_bookmarks, error_msg); break; } } the_end: g_free (data); g_object_unref (file_a); if (!conn && !*error_msg) *error_msg = g_strdup (_("The file was not recognized by any of the plugins.")); return conn; }
static void iterate_contacts (TpChannel *channel, GArray *handles, char **argv) { GError *error = NULL; int i; for (i = 0; i < handles->len; i++) { int handle = g_array_index (handles, int, i); /* FIXME: we should check that our client has the * FT capability */ /* begin ex.filetransfer.sending.gfileinfo */ GFile *file = g_file_new_for_commandline_arg (argv[3]); GFileInfo *info = g_file_query_info (file, "standard::*", G_FILE_QUERY_INFO_NONE, NULL, &error); handle_error (error); GHashTable *props = tp_asv_new ( TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT, TP_PROP_CHANNEL_TARGET_HANDLE, G_TYPE_UINT, handle, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_FILENAME, G_TYPE_STRING, g_file_info_get_display_name (info), TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_TYPE, G_TYPE_STRING, g_file_info_get_content_type (info), TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_SIZE, G_TYPE_UINT64, g_file_info_get_size (info), NULL); tp_cli_connection_interface_requests_call_create_channel ( conn, -1, props, create_ft_channel_cb, NULL, NULL, NULL); g_hash_table_destroy (props); g_object_unref (info); g_object_unref (file); /* end ex.filetransfer.sending.gfileinfo */ } }
int main (int argc, char *argv[]) { GError *error; GOptionContext *context; GFile *file; int retval = 0; gchar *param; gchar *summary; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, GVFS_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); error = NULL; param = g_strdup_printf ("[%s...]", _("FILE")); summary = _("Delete the given files."); context = g_option_context_new (param); g_option_context_set_summary (context, summary); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_parse (context, &argc, &argv, &error); g_option_context_free (context); g_free (param); if (error != NULL) { g_printerr (_("Error parsing commandline options: %s\n"), error->message); g_printerr ("\n"); g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ()); g_printerr ("\n"); g_error_free (error); return 1; } if (argc > 1) { int i; for (i = 1; i < argc; i++) { file = g_file_new_for_commandline_arg (argv[i]); error = NULL; if (!g_file_delete (file, NULL, &error)) { if (!force || !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_printerr ("Error deleting file: %s\n", error->message); retval = 1; } g_error_free (error); } g_object_unref (file); } } return retval; }
int main (int argc, char **argv) { GFile *file; char *url; bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gst_init (&argc, &argv); gtk_init (&argc, &argv); if (argc != 2) { g_print ("Usage: %s [URI]\n", argv[0]); return 1; } file = g_file_new_for_commandline_arg (argv[1]); url = g_file_get_uri (file); g_object_unref (file); create_props (url); g_free (url); gtk_main (); destroy_props (); return 0; }
String Util::canonical_external_path( const char * path , bool abort_on_error ) { String result; if ( path ) { GFile * file = g_file_new_for_commandline_arg( path ); gchar * p = g_file_get_path( file ); g_object_unref( file ); if ( p ) { result = p; g_free( p ); } } if ( abort_on_error && result.empty() ) { g_error( "INVALID PATH '%s'" , path ? path : "<null>" ); } return result; }
int main(int argc, char *argv[]) { GError *error = NULL; gtk_init(&argc, &argv); create_window(); gtk_widget_show_all(window); if(argc < 2) g_error("Must provide a plugin\n"); GFile *plugin_file; if( g_str_has_suffix(argv[1], ".la") ) plugin_file = libname_from_la_file(argv[1]); else plugin_file = g_file_new_for_commandline_arg(argv[1]); chimara_glk_set_resource_load_callback(CHIMARA_GLK(glk), (ChimaraResourceLoadFunc)resource_load, NULL, NULL); if( !chimara_glk_run_file(CHIMARA_GLK(glk), plugin_file, argc - 1, argv + 1, &error) ) g_error("Error starting Glk library: %s\n", error->message); g_object_unref(plugin_file); gtk_main(); chimara_glk_stop(CHIMARA_GLK(glk)); chimara_glk_wait(CHIMARA_GLK(glk)); g_object_unref(glk); return 0; }
static gboolean load_uri_args (const char **args, GFunc handler, gpointer user_data) { gboolean handled; guint i; handled = FALSE; for (i = 0; args && args[i]; i++) { GFile *file; char *uri; rb_debug ("examining argument %s", args[i]); file = g_file_new_for_commandline_arg (args[i]); uri = g_file_get_uri (file); /* * rb_uri_exists won't work if the location isn't mounted. * however, things that are interesting to mount are generally * non-local, so we'll process them anyway. */ if (rb_uri_is_local (uri) == FALSE || rb_uri_exists (uri)) { handler (uri, user_data); } g_free (uri); g_object_unref (file); handled = TRUE; } return handled; }
int main (int argc, char *argv[]) { GFile *base, *crash; int result; RSVG_G_TYPE_INIT; g_test_init (&argc, &argv, NULL); if (argc < 2) { base = g_file_new_for_path (test_utils_get_test_data_path ()); crash = g_file_get_child (base, "render-crash"); test_utils_add_test_for_all_files ("/render-crash", crash, crash, test_render_crash, NULL); g_object_unref (base); g_object_unref (crash); } else { guint i; for (i = 1; i < argc; i++) { GFile *file = g_file_new_for_commandline_arg (argv[i]); test_utils_add_test_for_all_files ("/render-crash", NULL, file, test_render_crash, NULL); g_object_unref (file); } } result = g_test_run (); rsvg_cleanup (); return result; }
static cairo_font_face_t * font_face_create(gchar *fontfile){ FT_Error error; FT_Library library; FT_Face face; GFile *file; gchar *font_file; error = FT_Init_FreeType (&library); if (error) { g_printerr("Could not initialise freetype\n"); exit(1); } file = g_file_new_for_commandline_arg (fontfile); font_file = g_file_get_uri (file); g_object_unref (file); if (!font_file) { g_printerr("Could not parse argument into a URI\n"); exit(1); } error = FT_New_Face_From_URI (library, font_file, 0, &face); if (error) { g_printerr("Could not load face '%s'\n", font_file); exit(1); } return cairo_ft_font_face_create_for_ft_face (face, 0); }
static int app_launch (gchar **args) { GVariantBuilder files; gint i; if (!app_check_name (args, "launch")) return 1; if (args[1] == NULL) return app_activate (args[0]); g_variant_builder_init (&files, G_VARIANT_TYPE_STRING_ARRAY); for (i = 1; args[i]; i++) { GFile *file; /* "This operation never fails" */ file = g_file_new_for_commandline_arg (args[i]); g_variant_builder_add_value (&files, g_variant_new_take_string (g_file_get_uri (file))); g_object_unref (file); } return app_call (args[0], "Open", g_variant_new ("(as@a{sv})", &files, app_get_platform_data ())); }
static const char * get_output_dir (void) { static const char *output_dir = NULL; GError *error = NULL; if (output_dir) return output_dir; if (arg_output_dir) { GFile *file = g_file_new_for_commandline_arg (arg_output_dir); output_dir = g_file_get_path (file); g_object_unref (file); } else { output_dir = g_get_tmp_dir (); } if (!g_file_test (output_dir, G_FILE_TEST_EXISTS)) { GFile *file; file = g_file_new_for_path (output_dir); g_assert (g_file_make_directory_with_parents (file, NULL, &error)); g_assert_no_error (error); g_object_unref (file); } return output_dir; }
void install_monitor() { if (_inotify_fd == -1) { _inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC); _monitor_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)g_object_unref); g_timeout_add(50, (GSourceFunc)_inotify_poll, NULL); _desktop_file = g_file_new_for_commandline_arg(DESKTOP_DIR()); _trash_can = g_file_new_for_uri("trash:///"); GFileMonitor* m = g_file_monitor(_trash_can, G_FILE_MONITOR_NONE, NULL, NULL); g_signal_connect(m, "changed", G_CALLBACK(trash_changed), NULL); _add_monitor_directory(_desktop_file); GDir *dir = g_dir_open(DESKTOP_DIR(), 0, NULL); if (dir != NULL) { const char* filename = NULL; while ((filename = g_dir_read_name(dir)) != NULL) { GFile* f = g_file_get_child(_desktop_file, filename); _add_monitor_directory(f); g_object_unref(f); } g_dir_close(dir); } } }
gboolean xdg_app_builtin_build_export (int argc, char **argv, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; g_autoptr(GOptionContext) context = NULL; g_autoptr(GFile) base = NULL; g_autoptr(GFile) files = NULL; g_autoptr(GFile) metadata = NULL; g_autoptr(GFile) export = NULL; g_autoptr(GFile) repofile = NULL; g_autoptr(GFile) arg = NULL; g_autoptr(GFile) root = NULL; g_autoptr(OstreeRepo) repo = NULL; const char *location; const char *directory; const char *branch; g_autofree char *arch = NULL; g_autofree char *full_branch = NULL; g_autofree char *app_id = NULL; g_autofree char *parent = NULL; g_autofree char *commit_checksum = NULL; g_autofree char *metadata_contents = NULL; g_autofree char *format_size = NULL; g_autoptr(OstreeMutableTree) mtree = NULL; g_autoptr(GKeyFile) metakey = NULL; gsize metadata_size; g_autofree char *subject = NULL; g_autofree char *body = NULL; OstreeRepoTransactionStats stats; OstreeRepoCommitModifier *modifier = NULL; context = g_option_context_new ("LOCATION DIRECTORY [BRANCH] - Create a repository from a build directory"); if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error)) goto out; if (argc < 3) { usage_error (context, "LOCATION and DIRECTORY must be specified", error); goto out; } location = argv[1]; directory = argv[2]; if (argc >= 4) branch = argv[3]; else branch = "master"; if (!xdg_app_is_valid_branch (branch)) { xdg_app_fail (error, "'%s' is not a valid branch name", branch); goto out; } base = g_file_new_for_commandline_arg (directory); files = g_file_get_child (base, "files"); metadata = g_file_get_child (base, "metadata"); export = g_file_get_child (base, "export");
static GList * get_tracker_locations (void) { gchar **locations; GList *list; gint idx; Place *location; const gchar *path; locations = g_settings_get_strv (tracker_preferences, TRACKER_KEY_RECURSIVE_DIRECTORIES); list = NULL; for (idx = 0; locations[idx] != NULL; idx++) { path = path_from_tracker_dir (locations[idx]); location = g_slice_new0 (Place); location->location = g_file_new_for_commandline_arg (path); location->display_name = g_file_get_basename (location->location); location->place_type = PLACE_OTHER; list = g_list_prepend (list, location); } g_strfreev (locations); return g_list_reverse (list); }