static void pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { gchar *tmp_dir_name, *db_err, *path = NULL; gint ret; gboolean force; GSList *file_list = NULL, *l; GFile *db_file = NULL; GFileInfo *file_info = NULL; GError *err = NULL; sqlite3_stmt *stmt = NULL; PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job); pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG); /* Create temporary directory */ tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err); if (!tmp_dir_name) { pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", err->message); g_error_free(err); return; } g_variant_get(params, "(b)", &force); /* Force the complete cache refresh if the read configuration file is newer than the metadata cache */ if (!force) { path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL); db_file = g_file_new_for_path(path); file_info = g_file_query_info(db_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &err); if (err) { pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, err->message); g_error_free(err); goto out; } ret = sqlite3_prepare_v2(job_data->db, "SELECT value FROM cache_info WHERE key LIKE 'last_modification'", -1, &stmt, NULL); if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW)) { pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, sqlite3_errstr(ret)); goto out; } if ((guint32) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec")) force = TRUE; } if (force) { /* It should empty all tables */ if (sqlite3_exec(job_data->db, "DELETE FROM repos", NULL, 0, &db_err) != SQLITE_OK) { pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", db_err); sqlite3_free(db_err); goto out; } } for (l = repos; l; l = g_slist_next(l)) /* Get list of files that should be downloaded */ file_list = g_slist_concat(file_list, katja_pkgtools_collect_cache_info(l->data, tmp_dir_name)); /* Download repository */ pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_REPOSITORY); for (l = file_list; l; l = g_slist_next(l)) katja_get_file(&job_data->curl, ((gchar **)l->data)[0], ((gchar **)l->data)[1]); g_slist_free_full(file_list, (GDestroyNotify)g_strfreev); /* Refresh cache */ pk_backend_job_set_status(job, PK_STATUS_ENUM_REFRESH_CACHE); for (l = repos; l; l = g_slist_next(l)) katja_pkgtools_generate_cache(l->data, job, tmp_dir_name); out: sqlite3_finalize(stmt); if (file_info) g_object_unref(file_info); if (db_file) g_object_unref(db_file); g_free(path); pk_directory_remove_contents(tmp_dir_name); g_rmdir(tmp_dir_name); g_free(tmp_dir_name); }
static void download_track (RBMtpThread *thread, RBMtpThreadTask *task) { LIBMTP_file_t *fileinfo; LIBMTP_error_t *stack; GError *error = NULL; GFile *dir; RBMtpDownloadCallback cb = (RBMtpDownloadCallback) task->callback; /* first, check there's enough space to copy it */ fileinfo = LIBMTP_Get_Filemetadata (thread->device, task->track_id); if (fileinfo == NULL) { stack = LIBMTP_Get_Errorstack (thread->device); rb_debug ("unable to get track metadata for %u: %s", task->track_id, stack->error_text); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } if (task->filename[0] == '\0') { dir = g_file_new_for_path (g_get_tmp_dir ()); } else { GFile *file = g_file_new_for_path (task->filename); dir = g_file_get_parent (file); g_object_unref (file); } rb_debug ("checking for %" G_GINT64_FORMAT " bytes available", fileinfo->filesize); if (rb_check_dir_has_space (dir, fileinfo->filesize) == FALSE) { char *dpath = g_file_get_path (dir); rb_debug ("not enough space in %s", dpath); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_NO_SPACE, _("Not enough space in %s"), dpath); g_free (dpath); } LIBMTP_destroy_file_t (fileinfo); g_object_unref (dir); if (error != NULL) { rb_debug ("bailing out due to error: %s", error->message); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } if (task->filename[0] == '\0') { /* download to a temporary file */ int fd; GError *tmperror = NULL; g_free (task->filename); fd = g_file_open_tmp ("rb-mtp-temp-XXXXXX", &task->filename, &tmperror); if (fd == -1) { rb_debug ("unable to open temporary file: %s", tmperror->message); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_TEMPFILE, _("Unable to open temporary file: %s"), tmperror->message); g_error_free (tmperror); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } else { rb_debug ("downloading track %u to file descriptor %d", task->track_id, fd); if (LIBMTP_Get_Track_To_File_Descriptor (thread->device, task->track_id, fd, NULL, NULL)) { stack = LIBMTP_Get_Errorstack (thread->device); rb_debug ("unable to retrieve track %u: %s", task->track_id, stack->error_text); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); close (fd); remove (task->filename); return; } rb_debug ("done downloading track"); close (fd); } } else { if (LIBMTP_Get_Track_To_File (thread->device, task->track_id, task->filename, NULL, NULL)) { stack = LIBMTP_Get_Errorstack (thread->device); error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK, _("Unable to copy file from MTP device: %s"), stack->error_text); LIBMTP_Clear_Errorstack (thread->device); cb (task->track_id, NULL, error, task->user_data); g_error_free (error); return; } } cb (task->track_id, task->filename, NULL, task->user_data); }
/** * main: **/ int main (int argc, char *argv[]) { CdUtilPrivate *priv; gboolean ret = TRUE; gboolean verbose = FALSE; guint retval = 1; g_autoptr(GError) error = NULL; g_autofree gchar *cmd_descriptions = NULL; g_autofree gchar *locale = NULL; g_autoptr(GFile) file = NULL; const GOptionEntry options[] = { { "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, /* TRANSLATORS: command line option */ _("Show extra debugging information"), NULL }, { "locale", '\0', 0, G_OPTION_ARG_STRING, &locale, /* TRANSLATORS: command line option */ _("The locale to use when setting localized text"), NULL }, { NULL} }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); cmsSetLogErrorHandler (cd_util_lcms_error_cb); /* create helper object */ priv = g_new0 (CdUtilPrivate, 1); priv->rewrite_file = TRUE; priv->client = cd_client_new (); /* add commands */ priv->cmd_array = g_ptr_array_new_with_free_func ((GDestroyNotify) cd_util_item_free); cd_util_add (priv->cmd_array, "extract-vcgt", /* TRANSLATORS: command description */ _("Generate the VCGT calibration of a given size"), cd_util_extract_vcgt); cd_util_add (priv->cmd_array, "md-clear", /* TRANSLATORS: command description */ _("Clear any metadata in the profile"), cd_util_clear_metadata); cd_util_add (priv->cmd_array, "md-init", /* TRANSLATORS: command description */ _("Initialize any metadata for the profile"), cd_util_init_metadata); cd_util_add (priv->cmd_array, "md-add", /* TRANSLATORS: command description */ _("Add a metadata item to the profile"), cd_util_add_metadata); cd_util_add (priv->cmd_array, "md-remove", /* TRANSLATORS: command description */ _("Remove a metadata item from the profile"), cd_util_remove_metadata); cd_util_add (priv->cmd_array, "set-copyright", /* TRANSLATORS: command description */ _("Sets the copyright string"), cd_util_set_copyright); cd_util_add (priv->cmd_array, "set-description", /* TRANSLATORS: command description */ _("Sets the description string"), cd_util_set_description); cd_util_add (priv->cmd_array, "set-manufacturer", /* TRANSLATORS: command description */ _("Sets the manufacturer string"), cd_util_set_manufacturer); cd_util_add (priv->cmd_array, "set-model", /* TRANSLATORS: command description */ _("Sets the model string"), cd_util_set_model); cd_util_add (priv->cmd_array, "md-fix", /* TRANSLATORS: command description */ _("Automatically fix metadata in the profile"), cd_util_set_fix_metadata); cd_util_add (priv->cmd_array, "set-version", /* TRANSLATORS: command description */ _("Set the ICC profile version"), cd_util_set_version); cd_util_add (priv->cmd_array, "export-tag-data", /* TRANSLATORS: command description */ _("Export the tag data"), cd_util_export_tag_data); /* sort by command name */ g_ptr_array_sort (priv->cmd_array, (GCompareFunc) cd_sort_command_name_cb); /* get a list of the commands */ priv->context = g_option_context_new (NULL); cmd_descriptions = cd_util_get_descriptions (priv->cmd_array); g_option_context_set_summary (priv->context, cmd_descriptions); /* TRANSLATORS: program name */ g_set_application_name (_("Color Management")); g_option_context_add_main_entries (priv->context, options, NULL); ret = g_option_context_parse (priv->context, &argc, &argv, &error); if (!ret) { /* TRANSLATORS: the user didn't read the man page */ g_print ("%s: %s\n", _("Failed to parse arguments"), error->message); goto out; } /* use explicit locale */ priv->locale = g_strdup (locale); /* set verbose? */ if (verbose) { g_setenv ("COLORD_VERBOSE", "1", FALSE); } else { g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, cd_util_ignore_cb, NULL); } /* the first option is always the filename */ if (argc < 2) { g_print ("%s\n", "Filename must be the first argument"); goto out; } /* open file */ file = g_file_new_for_path (argv[1]); priv->icc = cd_icc_new (); ret = cd_icc_load_file (priv->icc, file, CD_ICC_LOAD_FLAGS_ALL, NULL, &error); if (!ret) { g_print ("%s\n", error->message); goto out; } /* run the specified command */ ret = cd_util_run (priv, argv[2], (gchar**) &argv[2], &error); if (!ret) { g_print ("%s\n", error->message); goto out; } /* save file */ if (priv->rewrite_file) { ret = cd_icc_save_file (priv->icc, file, CD_ICC_SAVE_FLAGS_NONE, NULL, &error); if (!ret) { g_print ("%s\n", error->message); goto out; } } /* success */ retval = 0; out: if (priv != NULL) { if (priv->cmd_array != NULL) g_ptr_array_unref (priv->cmd_array); g_option_context_free (priv->context); if (priv->icc != NULL) g_object_unref (priv->icc); g_object_unref (priv->client); g_free (priv->locale); g_free (priv); } return retval; }
static GtkWidget * panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item) { GtkWidget *places_menu; GtkWidget *item; char *gsettings_name = NULL; char *name; char *uri; GFile *file; places_menu = panel_create_menu (); file = g_file_new_for_path (g_get_home_dir ()); uri = g_file_get_uri (file); name = panel_util_get_label_for_uri (uri); g_object_unref (file); panel_menu_items_append_place_item (PANEL_ICON_HOME, NULL, name, _("Open your personal folder"), places_menu, G_CALLBACK (activate_home_uri), uri); g_free (name); g_free (uri); if (!place_item->priv->caja_prefs_settings || !g_settings_get_boolean (place_item->priv->caja_prefs_settings, CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY)) { file = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP)); uri = g_file_get_uri (file); g_object_unref (file); panel_menu_items_append_place_item ( PANEL_ICON_DESKTOP, NULL, /* Translators: Desktop is used here as in * "Desktop Folder" (this is not the Desktop * environment). */ C_("Desktop Folder", "Desktop"), _("Open the contents of your desktop in a folder"), places_menu, G_CALLBACK (activate_desktop_uri), /* FIXME: if the dir changes, we'd need to update the drag data since the uri is not the same */ uri); g_free (uri); } panel_place_menu_item_append_gtk_bookmarks (places_menu, g_settings_get_uint (place_item->priv->menubar_settings, PANEL_MENU_BAR_MAX_ITEMS_OR_SUBMENU)); add_menu_separator (places_menu); if (place_item->priv->caja_desktop_settings != NULL) gsettings_name = g_settings_get_string (place_item->priv->caja_desktop_settings, CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY); if (PANEL_GLIB_STR_EMPTY (gsettings_name)) gsettings_name = g_strdup (_("Computer")); panel_menu_items_append_place_item ( PANEL_ICON_COMPUTER, NULL, gsettings_name, _("Browse all local and remote disks and folders accessible from this computer"), places_menu, G_CALLBACK (activate_uri), "computer://"); if (gsettings_name) g_free (gsettings_name); panel_place_menu_item_append_local_gio (place_item, places_menu); add_menu_separator (places_menu); panel_menu_items_append_place_item ( PANEL_ICON_NETWORK, NULL, _("Network"), _("Browse bookmarked and local network locations"), places_menu, G_CALLBACK (activate_uri), "network://"); panel_place_menu_item_append_remote_gio (place_item, places_menu); if (panel_is_program_in_path ("caja-connect-server") || panel_is_program_in_path ("nautilus-connect-server") || panel_is_program_in_path ("nemo-connect-server")) { item = panel_menu_items_create_action_item (PANEL_ACTION_CONNECT_SERVER); if (item != NULL) gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); } add_menu_separator (places_menu); if (panel_is_program_in_path ("mate-search-tool")) panel_menu_items_append_from_desktop (places_menu, "mate-search-tool.desktop", NULL, FALSE); else panel_menu_items_append_from_desktop (places_menu, "gnome-search-tool.desktop", NULL, FALSE); panel_recent_append_documents_menu (places_menu, place_item->priv->recent_manager); /* Fix any failures of compiz/other wm's to communicate with gtk for transparency */ GtkWidget *toplevel = gtk_widget_get_toplevel (places_menu); GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel)); GdkVisual *visual = gdk_screen_get_rgba_visual(screen); gtk_widget_set_visual(GTK_WIDGET(toplevel), visual); return places_menu; }
/* Setting '/theme' changed either at widget or at xfconf property */ static void _xfdashboard_settings_widget_changed_theme(XfdashboardSettings *self, GtkTreeSelection *inSelection) { XfdashboardSettingsPrivate *priv; GtkTreeModel *model; GtkTreeIter iter; gchar *themeDisplayName; gchar *themeComment; gchar *themeAuthor; gchar *themeVersion; gchar *themeScreenshot; gchar *themeFilename; gchar *themeName; g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self)); g_return_if_fail(GTK_IS_TREE_SELECTION(inSelection)); priv=self->priv; themeDisplayName=NULL; themeComment=NULL; themeAuthor=NULL; themeVersion=NULL; themeScreenshot=NULL; themeFilename=NULL; themeName=NULL; /* Get selected entry from widget */ if(gtk_tree_selection_get_selected(inSelection, &model, &iter)) { /* Get data from model */ gtk_tree_model_get(model, &iter, COLUMN_THEME_NAME, &themeName, COLUMN_THEME_FILE, &themeFilename, COLUMN_THEME_DISPLAY_NAME, &themeDisplayName, COLUMN_THEME_DESCRIPTION, &themeComment, COLUMN_THEME_AUTHORS, &themeAuthor, COLUMN_THEME_VERSION, &themeVersion, COLUMN_THEME_SCREENSHOTS, &themeScreenshot, -1); } /* Set text in labels */ if(themeDisplayName) { gtk_label_set_text(GTK_LABEL(priv->widgetThemeName), themeDisplayName); gtk_widget_show(priv->widgetThemeName); gtk_widget_show(priv->widgetThemeNameLabel); } else { gtk_widget_hide(priv->widgetThemeName); gtk_widget_hide(priv->widgetThemeNameLabel); } if(themeComment) { gtk_label_set_text(GTK_LABEL(priv->widgetThemeDescription), themeComment); gtk_widget_show(priv->widgetThemeDescription); gtk_widget_show(priv->widgetThemeDescriptionLabel); } else { gtk_widget_hide(priv->widgetThemeDescription); gtk_widget_hide(priv->widgetThemeDescriptionLabel); } if(themeAuthor) { gtk_label_set_text(GTK_LABEL(priv->widgetThemeAuthor), themeAuthor); gtk_widget_show(priv->widgetThemeAuthor); gtk_widget_show(priv->widgetThemeAuthorLabel); } else { gtk_widget_hide(priv->widgetThemeAuthor); gtk_widget_hide(priv->widgetThemeAuthorLabel); } if(themeVersion) { gtk_label_set_text(GTK_LABEL(priv->widgetThemeVersion), themeVersion); gtk_widget_show(priv->widgetThemeVersion); gtk_widget_show(priv->widgetThemeVersionLabel); } else { gtk_widget_hide(priv->widgetThemeVersion); gtk_widget_hide(priv->widgetThemeVersionLabel); } /* Set screenshot */ if(themeScreenshot) { gchar *screenshotFile; GdkPixbuf *screenshotImage; screenshotFile=NULL; screenshotImage=NULL; /* Get screenshot file but resolve relative path if needed */ if(!g_path_is_absolute(themeScreenshot)) { GFile *file; GFile *parentPath; gchar *themePath; file=NULL; parentPath=NULL; themePath=NULL; /* Resolve relative path relative to theme path */ file=g_file_new_for_path(themeFilename); if(file) parentPath=g_file_get_parent(file); if(parentPath) themePath=g_file_get_path(parentPath); if(themePath) screenshotFile=g_build_filename(themePath, themeScreenshot, NULL); /* Release allocated resources */ if(themePath) g_free(themePath); if(parentPath) g_object_unref(parentPath); if(file) g_object_unref(file); } else { /* Path is absolute so just create a copy */ screenshotFile=g_strdup(themeScreenshot); } /* If screenshot file exists set up and show image * otherwise hide image. */ if(screenshotFile && g_file_test(screenshotFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) { GError *error; gint width; gint height; error=NULL; /* Check if screenshot fits into widget without scaling or * scale it to maximum size but preserve aspect ratio. */ if(gdk_pixbuf_get_file_info(screenshotFile, &width, &height)) { if(width<MAX_SCREENSHOT_WIDTH) { screenshotImage=gdk_pixbuf_new_from_file(screenshotFile, &error); } else { screenshotImage=gdk_pixbuf_new_from_file_at_scale(screenshotFile, MAX_SCREENSHOT_WIDTH, -1, TRUE, &error); } if(error) { g_warning("Could not load screenshot: %s", error ? error->message : _("Unknown error")); /* Release allocated resources */ if(error) g_error_free(error); if(screenshotImage) { g_object_unref(screenshotImage); screenshotImage=NULL; } } } } if(screenshotImage) { gtk_image_set_from_pixbuf(GTK_IMAGE(priv->widgetThemeScreenshot), screenshotImage); gtk_widget_show(priv->widgetThemeScreenshot); } else { gtk_widget_hide(priv->widgetThemeScreenshot); } /* Release allocated resources */ if(screenshotImage) g_object_unref(screenshotImage); if(screenshotFile) g_free(screenshotFile); } else { gtk_widget_hide(priv->widgetThemeScreenshot); } /* Set value at xfconf property if it must be changed */ if(themeName) { gchar *currentTheme; currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME); if(g_strcmp0(currentTheme, themeName)) { xfconf_channel_set_string(priv->xfconfChannel, "/theme", themeName); } g_free(currentTheme); } /* Release allocated resources */ if(themeDisplayName) g_free(themeDisplayName); if(themeComment) g_free(themeComment); if(themeAuthor) g_free(themeAuthor); if(themeVersion) g_free(themeVersion); if(themeScreenshot) g_free(themeScreenshot); if(themeFilename) g_free(themeFilename); if(themeName) g_free(themeName); }
gboolean ostree_option_context_parse (GOptionContext *context, const GOptionEntry *main_entries, int *argc, char ***argv, OstreeBuiltinFlags flags, OstreeRepo **out_repo, GCancellable *cancellable, GError **error) { glnx_unref_object OstreeRepo *repo = NULL; gboolean success = FALSE; /* Entries are listed in --help output in the order added. We add the * main entries ourselves so that we can add the --repo entry first. */ if (!(flags & OSTREE_BUILTIN_FLAG_NO_REPO)) g_option_context_add_main_entries (context, repo_entry, NULL); if (main_entries != NULL) g_option_context_add_main_entries (context, main_entries, NULL); g_option_context_add_main_entries (context, global_entries, NULL); if (!g_option_context_parse (context, argc, argv, error)) return FALSE; if (opt_version) { g_print ("%s\n %s\n", PACKAGE_STRING, OSTREE_FEATURES); exit (EXIT_SUCCESS); } if (opt_verbose) g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL); if (opt_repo == NULL && !(flags & OSTREE_BUILTIN_FLAG_NO_REPO)) { GError *local_error = NULL; repo = ostree_repo_new_default (); if (!ostree_repo_open (repo, cancellable, &local_error)) { if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_autofree char *help = NULL; g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Command requires a --repo argument"); g_error_free (local_error); help = g_option_context_get_help (context, FALSE, NULL); g_printerr ("%s", help); } else { g_propagate_error (error, local_error); } goto out; } } else if (opt_repo != NULL) { g_autoptr(GFile) repo_file = g_file_new_for_path (opt_repo); repo = ostree_repo_new (repo_file); if (!(flags & OSTREE_BUILTIN_FLAG_NO_CHECK)) { if (!ostree_repo_open (repo, cancellable, error)) goto out; } } if (out_repo) *out_repo = g_steal_pointer (&repo); success = TRUE; out: return success; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GError *error = NULL; INIT_I18N (); gegl_init (NULL, NULL); run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (strcmp (name, LOAD_PROC) == 0) { const gchar *filename = param[1].data.d_string; TIFF *tif; tif = tiff_open (filename, "r", &error); if (tif) { TiffSelectedPages pages; pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; gimp_get_data (LOAD_PROC, &pages.target); pages.n_pages = pages.o_pages = TIFFNumberOfDirectories (tif); if (pages.n_pages == 0) { g_set_error (&error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("TIFF '%s' does not contain any directories"), gimp_filename_to_utf8 (filename)); status = GIMP_PDB_EXECUTION_ERROR; } else { gboolean run_it = FALSE; gint i; if (run_mode != GIMP_RUN_INTERACTIVE) { pages.pages = g_new (gint, pages.n_pages); for (i = 0; i < pages.n_pages; i++) pages.pages[i] = i; run_it = TRUE; } else { gimp_ui_init (PLUG_IN_BINARY, FALSE); } if (pages.n_pages == 1) { pages.pages = g_new0 (gint, pages.n_pages); pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS; run_it = TRUE; } if ((! run_it) && (run_mode == GIMP_RUN_INTERACTIVE)) run_it = load_dialog (tif, LOAD_PROC, &pages); if (run_it) { gint32 image; gboolean resolution_loaded = FALSE; gimp_set_data (LOAD_PROC, &pages.target, sizeof (pages.target)); image = load_image (param[1].data.d_string, tif, &pages, &resolution_loaded, &error); g_free (pages.pages); if (image > 0) { GFile *file; GimpMetadata *metadata; file = g_file_new_for_path (param[1].data.d_string); metadata = gimp_image_metadata_load_prepare (image, "image/tiff", file, NULL); if (metadata) { GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL; if (resolution_loaded) flags &= ~GIMP_METADATA_LOAD_RESOLUTION; gimp_image_metadata_load_finish (image, "image/tiff", metadata, flags, run_mode == GIMP_RUN_INTERACTIVE); g_object_unref (metadata); } g_object_unref (file); *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image; } else { status = GIMP_PDB_EXECUTION_ERROR; } } else { status = GIMP_PDB_CANCEL; } } TIFFClose (tif); } else { status = GIMP_PDB_EXECUTION_ERROR; } } else if ((strcmp (name, SAVE_PROC) == 0) || (strcmp (name, SAVE2_PROC) == 0)) { /* Plug-in is either file_tiff_save or file_tiff_save2 */ GimpMetadata *metadata; GimpMetadataSaveFlags metadata_flags; GimpParasite *parasite; gint32 image = param[1].data.d_int32; gint32 drawable = param[2].data.d_int32; gint32 orig_image = image; GimpExportReturn export = GIMP_EXPORT_CANCEL; switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image, &drawable, "TIFF", GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED | GIMP_EXPORT_CAN_HANDLE_ALPHA); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }
int rpmostree_compose_builtin_tree (int argc, char **argv, GCancellable *cancellable, GError **error) { int exit_status = EXIT_FAILURE; GError *temp_error = NULL; GOptionContext *context = g_option_context_new ("TREEFILE - Run yum and commit the result to an OSTree repository"); RpmOstreeTreeComposeContext selfdata = { NULL, }; RpmOstreeTreeComposeContext *self = &selfdata; JsonNode *treefile_rootval = NULL; JsonObject *treefile = NULL; gs_free char *cachekey = NULL; gs_free char *new_inputhash = NULL; gs_unref_object GFile *previous_root = NULL; gs_free char *previous_checksum = NULL; gs_unref_object GFile *yumroot = NULL; gs_unref_object GFile *yumroot_varcache = NULL; gs_unref_object OstreeRepo *repo = NULL; gs_unref_ptrarray GPtrArray *bootstrap_packages = NULL; gs_unref_ptrarray GPtrArray *packages = NULL; gs_unref_object GFile *treefile_path = NULL; gs_unref_object GFile *treefile_dirpath = NULL; gs_unref_object GFile *repo_path = NULL; gs_unref_object JsonParser *treefile_parser = NULL; gs_unref_variant_builder GVariantBuilder *metadata_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); g_autoptr(RpmOstreeContext) corectx = NULL; g_autoptr(GHashTable) varsubsts = NULL; gboolean workdir_is_tmp = FALSE; self->treefile_context_dirs = g_ptr_array_new_with_free_func ((GDestroyNotify)g_object_unref); if (!rpmostree_option_context_parse (context, option_entries, &argc, &argv, RPM_OSTREE_BUILTIN_FLAG_LOCAL_CMD, cancellable, NULL, error)) goto out; if (argc < 2) { rpmostree_usage_error (context, "TREEFILE must be specified", error); goto out; } if (!opt_repo) { rpmostree_usage_error (context, "--repo must be specified", error); goto out; } if (getuid () != 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "compose tree must presently be run as uid 0 (root)"); goto out; } repo_path = g_file_new_for_path (opt_repo); repo = self->repo = ostree_repo_new (repo_path); if (!ostree_repo_open (repo, cancellable, error)) goto out; treefile_path = g_file_new_for_path (argv[1]); if (opt_workdir) { self->workdir = g_file_new_for_path (opt_workdir); } else { gs_free char *tmpd = NULL; if (!rpmostree_mkdtemp ("/var/tmp/rpm-ostree.XXXXXX", &tmpd, NULL, error)) goto out; self->workdir = g_file_new_for_path (tmpd); workdir_is_tmp = TRUE; if (opt_workdir_tmpfs) { if (mount ("tmpfs", tmpd, "tmpfs", 0, (const void*)"mode=755") != 0) { _rpmostree_set_prefix_error_from_errno (error, errno, "mount(tmpfs): "); goto out; } } } if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (self->workdir), FALSE, &self->workdir_dfd, error)) goto out; if (opt_cachedir) { if (!glnx_opendirat (AT_FDCWD, opt_cachedir, TRUE, &self->cachedir_dfd, error)) { g_prefix_error (error, "Opening cachedir '%s': ", opt_cachedir); goto out; } } else { self->cachedir_dfd = fcntl (self->workdir_dfd, F_DUPFD_CLOEXEC, 3); if (self->cachedir_dfd < 0) { glnx_set_error_from_errno (error); goto out; } } if (opt_metadata_strings) { if (!parse_keyvalue_strings (opt_metadata_strings, metadata_builder, error)) goto out; } if (fchdir (self->workdir_dfd) != 0) { glnx_set_error_from_errno (error); goto out; } corectx = rpmostree_context_new_unprivileged (self->cachedir_dfd, cancellable, error); if (!corectx) goto out; varsubsts = rpmostree_context_get_varsubsts (corectx); treefile_parser = json_parser_new (); if (!json_parser_load_from_file (treefile_parser, gs_file_get_path_cached (treefile_path), error)) goto out; treefile_rootval = json_parser_get_root (treefile_parser); if (!JSON_NODE_HOLDS_OBJECT (treefile_rootval)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Treefile root is not an object"); goto out; } treefile = json_node_get_object (treefile_rootval); if (!process_includes (self, treefile_path, 0, treefile, cancellable, error)) goto out; if (opt_print_only) { gs_unref_object JsonGenerator *generator = json_generator_new (); gs_unref_object GOutputStream *stdout = g_unix_output_stream_new (1, FALSE); json_generator_set_pretty (generator, TRUE); json_generator_set_root (generator, treefile_rootval); (void) json_generator_to_stream (generator, stdout, NULL, NULL); exit_status = EXIT_SUCCESS; goto out; } { const char *input_ref = _rpmostree_jsonutil_object_require_string_member (treefile, "ref", error); if (!input_ref) goto out; self->ref = _rpmostree_varsubst_string (input_ref, varsubsts, error); if (!self->ref) goto out; } if (!ostree_repo_read_commit (repo, self->ref, &previous_root, &previous_checksum, cancellable, &temp_error)) { if (g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) { g_clear_error (&temp_error); g_print ("No previous commit for %s\n", self->ref); } else { g_propagate_error (error, temp_error); goto out; } } else g_print ("Previous commit: %s\n", previous_checksum); self->previous_checksum = previous_checksum; yumroot = g_file_get_child (self->workdir, "rootfs.tmp"); if (!glnx_shutil_rm_rf_at (self->workdir_dfd, "rootfs.tmp", cancellable, error)) goto out; if (json_object_has_member (treefile, "automatic_version_prefix") && !compose_strv_contains_prefix (opt_metadata_strings, "version=")) { gs_unref_variant GVariant *variant = NULL; gs_free char *last_version = NULL; gs_free char *next_version = NULL; const char *ver_prefix; ver_prefix = _rpmostree_jsonutil_object_require_string_member (treefile, "automatic_version_prefix", error); if (!ver_prefix) goto out; if (previous_checksum) { if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, previous_checksum, &variant, error)) goto out; last_version = checksum_version (variant); } next_version = _rpmostree_util_next_version (ver_prefix, last_version); g_variant_builder_add (metadata_builder, "{sv}", "version", g_variant_new_string (next_version)); } bootstrap_packages = g_ptr_array_new (); packages = g_ptr_array_new (); if (json_object_has_member (treefile, "bootstrap_packages")) { if (!_rpmostree_jsonutil_append_string_array_to (treefile, "bootstrap_packages", packages, error)) goto out; } if (!_rpmostree_jsonutil_append_string_array_to (treefile, "packages", packages, error)) goto out; g_ptr_array_add (packages, NULL); { gs_unref_object JsonGenerator *generator = json_generator_new (); char *treefile_buf = NULL; gsize len; json_generator_set_root (generator, treefile_rootval); json_generator_set_pretty (generator, TRUE); treefile_buf = json_generator_to_data (generator, &len); self->serialized_treefile = g_bytes_new_take (treefile_buf, len); } treefile_dirpath = g_file_get_parent (treefile_path); if (TRUE) { gboolean generate_from_previous = TRUE; if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile, "preserve-passwd", &generate_from_previous, error)) goto out; if (generate_from_previous) { if (!rpmostree_generate_passwd_from_previous (repo, yumroot, treefile_dirpath, previous_root, treefile, cancellable, error)) goto out; } } { gboolean unmodified = FALSE; if (!install_packages_in_root (self, corectx, treefile, yumroot, (char**)packages->pdata, opt_force_nocache ? NULL : &unmodified, &new_inputhash, cancellable, error)) goto out; if (unmodified) { g_print ("No apparent changes since previous commit; use --force-nocache to override\n"); exit_status = EXIT_SUCCESS; goto out; } else if (opt_dry_run) { g_print ("--dry-run complete, exiting\n"); exit_status = EXIT_SUCCESS; goto out; } } if (g_strcmp0 (g_getenv ("RPM_OSTREE_BREAK"), "post-yum") == 0) goto out; if (!rpmostree_treefile_postprocessing (yumroot, self->treefile_context_dirs->pdata[0], self->serialized_treefile, treefile, cancellable, error)) goto out; if (!rpmostree_prepare_rootfs_for_commit (yumroot, treefile, cancellable, error)) goto out; if (!rpmostree_copy_additional_files (yumroot, self->treefile_context_dirs->pdata[0], treefile, cancellable, error)) goto out; if (!rpmostree_check_passwd (repo, yumroot, treefile_dirpath, treefile, previous_checksum, cancellable, error)) goto out; if (!rpmostree_check_groups (repo, yumroot, treefile_dirpath, treefile, previous_checksum, cancellable, error)) goto out; { const char *gpgkey; gboolean selinux = TRUE; gs_unref_variant GVariant *metadata = NULL; g_variant_builder_add (metadata_builder, "{sv}", "rpmostree.inputhash", g_variant_new_string (new_inputhash)); metadata = g_variant_ref_sink (g_variant_builder_end (metadata_builder)); if (!_rpmostree_jsonutil_object_get_optional_string_member (treefile, "gpg_key", &gpgkey, error)) goto out; if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile, "selinux", &selinux, error)) goto out; { g_autofree char *new_revision = NULL; glnx_fd_close int rootfs_fd = -1; if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (yumroot), TRUE, &rootfs_fd, error)) goto out; g_print ("Committing...\n"); if (!rpmostree_commit (rootfs_fd, repo, self->ref, metadata, gpgkey, selinux, NULL, &new_revision, cancellable, error)) goto out; g_print ("%s => %s\n", self->ref, new_revision); } } if (opt_touch_if_changed) { gs_fd_close int fd = open (opt_touch_if_changed, O_CREAT|O_WRONLY|O_NOCTTY, 0644); if (fd == -1) { gs_set_error_from_errno (error, errno); g_prefix_error (error, "Updating '%s': ", opt_touch_if_changed); goto out; } if (futimens (fd, NULL) == -1) { gs_set_error_from_errno (error, errno); goto out; } } exit_status = EXIT_SUCCESS; out: /* Explicitly close this one now as it may have references to files * we delete below. */ g_clear_object (&corectx); /* Move back out of the workding directory to ensure unmount works */ (void )chdir ("/"); if (self->workdir_dfd != -1) (void) close (self->workdir_dfd); if (workdir_is_tmp) { if (opt_workdir_tmpfs) if (umount (gs_file_get_path_cached (self->workdir)) != 0) { fprintf (stderr, "warning: umount failed: %m\n"); } (void) gs_shutil_rm_rf (self->workdir, NULL, NULL); } if (self) { g_clear_object (&self->workdir); g_clear_pointer (&self->serialized_treefile, g_bytes_unref); g_ptr_array_unref (self->treefile_context_dirs); } return exit_status; }
static char * get_prefix_for_entry (GMenuTreeEntry *entry) { char *prefix = NULL, *file_prefix = NULL; const char *id; GFile *file; char *name; int i = 0; id = gmenu_tree_entry_get_desktop_file_id (entry); file = g_file_new_for_path (gmenu_tree_entry_get_desktop_file_path (entry)); name = g_file_get_basename (file); if (!name) { g_object_unref (file); return NULL; } for (i = 0; vendor_prefixes[i]; i++) { if (g_str_has_prefix (name, vendor_prefixes[i])) { file_prefix = g_strdup (vendor_prefixes[i]); break; } } while (strcmp (name, id) != 0) { char *t; char *pname; GFile *parent = g_file_get_parent (file); if (!parent) { g_warn_if_reached (); break; } pname = g_file_get_basename (parent); if (!pname) { g_object_unref (parent); break; } if (!g_strstr_len (id, -1, pname)) { /* handle <LegacyDir prefix="..."> */ char *t; size_t name_len = strlen (name); size_t id_len = strlen (id); char *t_id = g_strdup (id); t_id[id_len - name_len] = '\0'; t = g_strdup(t_id); g_free (prefix); g_free (t_id); g_free (name); name = g_strdup (id); prefix = t; g_object_unref (file); file = parent; g_free (pname); g_free (file_prefix); file_prefix = NULL; break; } t = g_strconcat (pname, "-", name, NULL); g_free (name); name = t; t = g_strconcat (pname, "-", prefix, NULL); g_free (prefix); prefix = t; g_object_unref (file); file = parent; g_free (pname); } if (file) g_object_unref (file); if (strcmp (name, id) == 0) { g_free (name); if (file_prefix && !prefix) return file_prefix; if (file_prefix) { char *t = g_strconcat (prefix, "-", file_prefix, NULL); g_free (prefix); g_free (file_prefix); prefix = t; } return prefix; } g_free (name); g_free (prefix); g_free (file_prefix); g_return_val_if_reached (NULL); }
XfdesktopSpecialFileIcon * xfdesktop_special_file_icon_new(XfdesktopSpecialFileIconType type, GdkScreen *screen) { XfdesktopSpecialFileIcon *special_file_icon; GFile *file = NULL; switch(type) { case XFDESKTOP_SPECIAL_FILE_ICON_FILESYSTEM: file = g_file_new_for_uri("file:///"); break; case XFDESKTOP_SPECIAL_FILE_ICON_HOME: file = g_file_new_for_path(xfce_get_homedir()); break; case XFDESKTOP_SPECIAL_FILE_ICON_TRASH: file = g_file_new_for_uri("trash:///"); break; default: g_return_val_if_reached(NULL); } special_file_icon = g_object_new(XFDESKTOP_TYPE_SPECIAL_FILE_ICON, NULL); special_file_icon->priv->type = type; special_file_icon->priv->gscreen = screen; special_file_icon->priv->file = file; special_file_icon->priv->file_info = g_file_query_info(file, XFDESKTOP_FILE_INFO_NAMESPACE, G_FILE_QUERY_INFO_NONE, NULL, NULL); if(!special_file_icon->priv->file_info) { g_object_unref(special_file_icon); return NULL; } /* query file system information from GIO */ special_file_icon->priv->filesystem_info = g_file_query_filesystem_info(special_file_icon->priv->file, XFDESKTOP_FILESYSTEM_INFO_NAMESPACE, NULL, NULL); /* update the trash full state */ if(type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH) xfdesktop_special_file_icon_update_trash_count(special_file_icon); g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)), "changed", G_CALLBACK(xfdesktop_icon_invalidate_pixbuf), special_file_icon); special_file_icon->priv->monitor = g_file_monitor(special_file_icon->priv->file, G_FILE_MONITOR_NONE, NULL, NULL); if(special_file_icon->priv->monitor) { g_signal_connect(special_file_icon->priv->monitor, "changed", G_CALLBACK(xfdesktop_special_file_icon_changed), special_file_icon); } return special_file_icon; }
static gboolean install_packages_in_root (RpmOstreeTreeComposeContext *self, RpmOstreeContext *ctx, JsonObject *treedata, GFile *yumroot, char **packages, gboolean *out_unmodified, char **out_new_inputhash, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; guint progress_sigid; GFile *contextdir = self->treefile_context_dirs->pdata[0]; g_autoptr(RpmOstreeInstall) hifinstall = { 0, }; HifContext *hifctx; gs_free char *ret_new_inputhash = NULL; g_autoptr(GKeyFile) treespec = g_key_file_new (); JsonArray *enable_repos = NULL; JsonArray *add_files = NULL; /* TODO - uncomment this once we have SELinux working */ #if 0 g_autofree char *cache_repo_pathstr = glnx_fdrel_abspath (self->cachedir_dfd, "repo"); g_autoptr(GFile) cache_repo_path = g_file_new_for_path (cache_repo_pathstr); glnx_unref_object OstreeRepo *ostreerepo = ostree_repo_new (cache_repo_path); if (!g_file_test (cache_repo_pathstr, G_FILE_TEST_EXISTS)) { if (!ostree_repo_create (ostreerepo, OSTREE_REPO_MODE_BARE_USER, cancellable, error)) goto out; } #endif hifctx = rpmostree_context_get_hif (ctx); if (opt_proxy) hif_context_set_http_proxy (hifctx, opt_proxy); hif_context_set_repo_dir (hifctx, gs_file_get_path_cached (contextdir)); g_key_file_set_string (treespec, "tree", "ref", self->ref); g_key_file_set_string_list (treespec, "tree", "packages", (const char *const*)packages, g_strv_length (packages)); /* Some awful code to translate between JSON and GKeyFile */ if (json_object_has_member (treedata, "install-langs")) { JsonArray *a = json_object_get_array_member (treedata, "install-langs"); if (!set_keyfile_string_array_from_json (treespec, "tree", "install-langs", a, error)) goto out; } /* Bind the json \"repos\" member to the hif state, which looks at the * enabled= member of the repos file. By default we forcibly enable * only repos which are specified, ignoring the enabled= flag. */ if (!json_object_has_member (treedata, "repos")) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Treefile is missing required \"repos\" member"); goto out; } enable_repos = json_object_get_array_member (treedata, "repos"); if (!set_keyfile_string_array_from_json (treespec, "tree", "repos", enable_repos, error)) goto out; { gboolean docs = TRUE; if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treedata, "documentation", &docs, error)) goto out; if (!docs) g_key_file_set_boolean (treespec, "tree", "documentation", FALSE); } { g_autoptr(GError) tmp_error = NULL; g_autoptr(RpmOstreeTreespec) treespec_value = rpmostree_treespec_new_from_keyfile (treespec, &tmp_error); g_assert_no_error (tmp_error); if (!rpmostree_context_setup (ctx, gs_file_get_path_cached (yumroot), "/", treespec_value, cancellable, error)) goto out; } /* --- Downloading metadata --- */ if (!rpmostree_context_download_metadata (ctx, cancellable, error)) goto out; if (!rpmostree_context_prepare_install (ctx, &hifinstall, cancellable, error)) goto out; if (json_object_has_member (treedata, "add-files")) add_files = json_object_get_array_member (treedata, "add-files"); /* FIXME - just do a depsolve here before we compute download requirements */ if (!compute_checksum_from_treefile_and_goal (self, hif_context_get_goal (hifctx), contextdir, add_files, &ret_new_inputhash, error)) goto out; /* Only look for previous checksum if caller has passed *out_unmodified */ if (self->previous_checksum && out_unmodified != NULL) { gs_unref_variant GVariant *commit_v = NULL; gs_unref_variant GVariant *commit_metadata = NULL; const char *previous_inputhash = NULL; if (!ostree_repo_load_variant (self->repo, OSTREE_OBJECT_TYPE_COMMIT, self->previous_checksum, &commit_v, error)) goto out; commit_metadata = g_variant_get_child_value (commit_v, 0); if (g_variant_lookup (commit_metadata, "rpmostree.inputhash", "&s", &previous_inputhash)) { if (strcmp (previous_inputhash, ret_new_inputhash) == 0) { *out_unmodified = TRUE; ret = TRUE; goto out; } } else g_print ("Previous commit found, but without rpmostree.inputhash metadata key\n"); } if (opt_dry_run) { ret = TRUE; goto out; } /* --- Downloading packages --- */ if (!rpmostree_context_download (ctx, hifinstall, cancellable, error)) goto out; { g_auto(GLnxConsoleRef) console = { 0, }; gs_unref_object HifState *hifstate = hif_state_new (); progress_sigid = g_signal_connect (hifstate, "percentage-changed", G_CALLBACK (on_hifstate_percentage_changed), "Installing packages:"); glnx_console_lock (&console); if (!hif_transaction_commit (hif_context_get_transaction (hifctx), hif_context_get_goal (hifctx), hifstate, error)) goto out; g_signal_handler_disconnect (hifstate, progress_sigid); } ret = TRUE; if (out_unmodified) *out_unmodified = FALSE; gs_transfer_out_value (out_new_inputhash, &ret_new_inputhash); out: return ret; }
static void migrate_history () { GFileInputStream *input; GMarkupParseContext *context; GError *error = NULL; GFile *file; char *filename; char buffer[1024]; HistoryParseData parse_data; gchar *temporary_file = g_build_filename (ephy_dot_dir (), "ephy-history.db", NULL); /* Do nothing if the history file already exists. Safer than wiping * it out. */ if (g_file_test (temporary_file, G_FILE_TEST_EXISTS)) { g_warning ("Did not migrate Epiphany's history, the ephy-history.db file already exists"); g_free (temporary_file); return; } history_service = ephy_history_service_new (temporary_file); g_free (temporary_file); memset (&parse_data, 0, sizeof (HistoryParseData)); parse_data.location = NULL; parse_data.title = NULL; parse_data.visits = NULL; filename = g_build_filename (ephy_dot_dir (), "ephy-history.xml", NULL); file = g_file_new_for_path (filename); g_free (filename); input = g_file_read (file, NULL, &error); g_object_unref (file); if (error) { if (error->code != G_IO_ERROR_NOT_FOUND) g_warning ("Could not load Epiphany history data, migration aborted: %s", error->message); g_error_free (error); return; } context = g_markup_parse_context_new (&history_parse_funcs, 0, &parse_data, NULL); while (TRUE) { gssize count = g_input_stream_read (G_INPUT_STREAM (input), buffer, sizeof (buffer), NULL, &error); if (count <= 0) break; if (!g_markup_parse_context_parse (context, buffer, count, &error)) break; } g_markup_parse_context_free (context); g_input_stream_close (G_INPUT_STREAM (input), NULL, NULL); g_object_unref (input); if (parse_data.visits) { ephy_history_service_add_visits (history_service, parse_data.visits, NULL, (EphyHistoryJobCallback)visit_cb, NULL); ephy_history_page_visit_list_free (parse_data.visits); while (!all_done) g_main_context_iteration (NULL, FALSE); } g_object_unref (history_service); }
/* * Function to use anywhere in the application to send a message to the LogList */ void Log_Print (Log_Error_Type error_type, gchar const *format, ...) { va_list args; gchar *string; GtkTreeIter iter; static gboolean first_time = TRUE; static gchar *file_path = NULL; GFile *file; GFileOutputStream *file_ostream; GError *error = NULL; va_start (args, format); string = g_strdup_vprintf(format, args); va_end (args); // If the log window is displayed then messages are displayed, else // the messages are stored in a temporary list. if (LogList && logListModel) { gint n_items; gchar *time = Log_Format_Date(); /* Remove lines that exceed the limit. */ n_items = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (logListModel), NULL); if (n_items > LOG_MAX_LINES - 1 && gtk_tree_model_get_iter_first(GTK_TREE_MODEL(logListModel), &iter)) { gtk_list_store_remove(GTK_LIST_STORE(logListModel), &iter); } gtk_list_store_insert_with_values (logListModel, &iter, G_MAXINT, LOG_PIXBUF, Log_Get_Stock_Id_From_Error_Type (error_type), LOG_TIME_TEXT, time, LOG_TEXT, string, LOG_ROW_BACKGROUND, NULL, LOG_ROW_FOREGROUND, NULL, -1); Log_List_Set_Row_Visible(GTK_TREE_MODEL(logListModel), &iter); g_free(time); }else { Log_Data *LogData = g_malloc0(sizeof(Log_Data)); LogData->time = Log_Format_Date(); LogData->error_type = error_type; LogData->string = g_strdup(string); LogPrintTmpList = g_list_append(LogPrintTmpList,LogData); //g_print("%s",string); } // Store also the messages in the log file. if (!file_path) { gchar *cache_path = g_build_filename (g_get_user_cache_dir (), PACKAGE_TARNAME, NULL); if (!g_file_test (cache_path, G_FILE_TEST_IS_DIR)) { gint result = g_mkdir_with_parents (cache_path, S_IRWXU); if (result == -1) { g_printerr ("%s", "Unable to create cache directory"); g_free (cache_path); g_free (string); return; } } file_path = g_build_filename (cache_path, LOG_FILE, NULL); g_free (cache_path); } file = g_file_new_for_path (file_path); /* On startup, the log is cleared. The log is then appended to for the * remainder of the application lifetime. */ if (first_time) { file_ostream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error); } else { file_ostream = g_file_append_to (file, G_FILE_CREATE_NONE, NULL, &error); } if (file_ostream) { gchar *time; GString *data; gsize bytes_written; time = Log_Format_Date (); data = g_string_new (time); g_free (time); data = g_string_append_c (data, ' '); data = g_string_append (data, string); g_free (string); data = g_string_append_c (data, '\n'); if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream), data->str, data->len, &bytes_written, NULL, &error)) { g_debug ("Only %" G_GSIZE_FORMAT " bytes out of %" G_GSIZE_FORMAT "bytes of data were written", bytes_written, data->len); /* To avoid recursion of Log_Print. */ g_warning ("Error writing to the log file '%s' ('%s')", file_path, error->message); g_error_free (error); g_string_free (data, TRUE); g_object_unref (file_ostream); g_object_unref (file); return; } first_time = FALSE; g_string_free (data, TRUE); } else { g_warning ("Error opening output stream of file '%s' ('%s')", file_path, error->message); g_error_free (error); } g_object_unref (file_ostream); g_object_unref (file); }
/** * seahorse_util_uris_package * @package: Package uri * @uris: null-terminated array of uris to package * * Package uris into an archive. The uris must be local. * * Returns: Success or failure */ gboolean seahorse_util_uris_package (const gchar* package, const char** uris) { GError* err = NULL; gchar *out = NULL; gint status; gboolean r; GString *str; gchar *cmd; gchar *t; gchar *x; GFile *file, *fpackage; fpackage = g_file_new_for_uri (package); t = g_file_get_path (fpackage); x = g_shell_quote (t); g_free (t); /* create execution */ str = g_string_new (""); g_string_printf (str, "file-roller --add-to=%s", x); g_free(x); while(*uris) { x = g_uri_parse_scheme (*uris); if (x) file = g_file_new_for_uri (*uris); else file = g_file_new_for_path (*uris); g_free (x); t = g_file_get_path (file); g_object_unref (file); g_return_val_if_fail (t != NULL, FALSE); x = g_shell_quote(t); g_free(t); g_string_append_printf (str, " %s", x); g_free(x); uris++; } /* Execute the command */ cmd = g_string_free (str, FALSE); r = g_spawn_command_line_sync (cmd, &out, NULL, &status, &err); g_free (cmd); if (out) { g_print (out, NULL); g_free (out); } if (!r) { seahorse_util_handle_error (err, _("Couldn't run file-roller")); return FALSE; } if(!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) { seahorse_util_show_error(NULL, _("Couldn't package files"), _("The file-roller process did not complete successfully")); return FALSE; } t = g_file_get_path (fpackage); if (t != NULL) { g_chmod (t, S_IRUSR | S_IWUSR); g_free (t); } return TRUE; }
int main (int argc, char **argv) { GtkWidget *w1; gchar *path; g_type_init (); gtk_init (&argc, &argv); toplevel = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width (GTK_CONTAINER (toplevel), 12); grid = gtk_grid_new (); w1 = gtk_label_new ("File:"); gtk_widget_set_halign (w1, GTK_ALIGN_START); gtk_grid_attach (GTK_GRID (grid), w1, 0, 0, 1, 1); file_l = gtk_button_new (); path = g_build_filename (g_get_current_dir (), "apple-red.png", NULL); file = g_file_new_for_path (path); gtk_button_set_label (GTK_BUTTON (file_l), path); g_free (path); gtk_widget_set_halign (file_l, GTK_ALIGN_START); gtk_grid_attach_next_to (GTK_GRID (grid), file_l, w1, GTK_POS_RIGHT, 3, 1); g_signal_connect (file_l, "clicked", G_CALLBACK (button_clicked), NULL); radio_file = gtk_radio_button_new_with_label (NULL, "Use GFile"); radio_content = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_file), "Use content type"); gtk_grid_attach (GTK_GRID (grid), radio_file, 0, 1, 1, 1); gtk_grid_attach_next_to (GTK_GRID (grid), radio_content, radio_file, GTK_POS_BOTTOM, 1, 1); open = gtk_button_new_with_label ("Trigger App Chooser dialog"); gtk_grid_attach_next_to (GTK_GRID (grid), open, radio_content, GTK_POS_BOTTOM, 1, 1); recommended = gtk_check_button_new_with_label ("Show recommended"); gtk_grid_attach_next_to (GTK_GRID (grid), recommended, open, GTK_POS_BOTTOM, 1, 1); g_object_set (recommended, "active", TRUE, NULL); fallback = gtk_check_button_new_with_label ("Show fallback"); gtk_grid_attach_next_to (GTK_GRID (grid), fallback, recommended, GTK_POS_RIGHT, 1, 1); other = gtk_check_button_new_with_label ("Show other"); gtk_grid_attach_next_to (GTK_GRID (grid), other, fallback, GTK_POS_RIGHT, 1, 1); all = gtk_check_button_new_with_label ("Show all"); gtk_grid_attach_next_to (GTK_GRID (grid), all, other, GTK_POS_RIGHT, 1, 1); def = gtk_check_button_new_with_label ("Show default"); gtk_grid_attach_next_to (GTK_GRID (grid), def, all, GTK_POS_RIGHT, 1, 1); g_object_set (recommended, "active", TRUE, NULL); prepare_dialog (); g_signal_connect (open, "clicked", G_CALLBACK (display_dialog), NULL); gtk_container_add (GTK_CONTAINER (toplevel), grid); gtk_widget_show_all (toplevel); g_signal_connect (toplevel, "delete-event", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return EXIT_SUCCESS; }
gboolean wavpack_tag_write_file_tag (const ET_File *ETFile, GError **error) { WavpackStreamReader writer = { wavpack_read_bytes, wavpack_get_pos, wavpack_set_pos_abs, wavpack_set_pos_rel, wavpack_push_back_byte, wavpack_get_length, wavpack_can_seek, wavpack_write_bytes }; GFile *file; EtWavpackWriteState state; const gchar *filename; const File_Tag *FileTag; WavpackContext *wpc; gchar message[80]; gchar *buffer; g_return_val_if_fail (ETFile != NULL && ETFile->FileTag != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); filename = ((File_Name *)((GList *)ETFile->FileNameCur)->data)->value; FileTag = (File_Tag *)ETFile->FileTag->data; file = g_file_new_for_path (filename); state.error = NULL; state.iostream = g_file_open_readwrite (file, NULL, &state.error); g_object_unref (file); if (!state.iostream) { g_propagate_error (error, state.error); return FALSE; } state.istream = G_FILE_INPUT_STREAM (g_io_stream_get_input_stream (G_IO_STREAM (state.iostream))); state.ostream = G_FILE_OUTPUT_STREAM (g_io_stream_get_output_stream (G_IO_STREAM (state.iostream))); state.seekable = G_SEEKABLE (state.iostream); /* NULL for the WavPack correction file. */ wpc = WavpackOpenFileInputEx (&writer, &state, NULL, message, OPEN_EDIT_TAGS, 0); if (wpc == NULL) { if (state.error) { g_propagate_error (error, state.error); } else { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", message); } g_object_unref (state.iostream); return FALSE; } /* Title. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "title", FileTag->title)) { goto err; } /* Artist. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "artist", FileTag->artist)) { goto err; } /* Album artist. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "album artist", FileTag->album_artist)) { goto err; } /* Album. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "album", FileTag->album)) { goto err; } /* Discnumber. */ if (FileTag->disc_number && FileTag->disc_total) { buffer = g_strdup_printf ("%s/%s", FileTag->disc_number, FileTag->disc_total); if (!et_wavpack_append_or_delete_tag_item (wpc, "part", buffer)) { g_free (buffer); goto err; } else { g_free (buffer); } } else { if (!et_wavpack_append_or_delete_tag_item (wpc, "part", FileTag->disc_number)) { goto err; } } /* Year. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "year", FileTag->year)) { goto err; } /* Tracknumber + tracktotal. */ if (FileTag->track_total) { buffer = g_strdup_printf ("%s/%s", FileTag->track, FileTag->track_total); if (!et_wavpack_append_or_delete_tag_item (wpc, "track", buffer)) { g_free (buffer); goto err; } else { g_free (buffer); } } else { if (!et_wavpack_append_or_delete_tag_item (wpc, "track", FileTag->track)) { goto err; } } /* Genre. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "genre", FileTag->genre)) { goto err; } /* Comment. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "comment", FileTag->comment)) { goto err; } /* Composer. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "composer", FileTag->composer)) { goto err; } /* Original artist. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "original artist", FileTag->orig_artist)) { goto err; } /* Copyright. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "copyright", FileTag->copyright)) { goto err; } /* URL. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "copyright url", FileTag->url)) { goto err; } /* Encoded by. */ if (!et_wavpack_append_or_delete_tag_item (wpc, "encoded by", FileTag->encoded_by)) { goto err; } if (WavpackWriteTag (wpc) == 0) { goto err; } WavpackCloseFile (wpc); g_object_unref (state.iostream); return TRUE; err: g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", WavpackGetErrorMessage (wpc)); WavpackCloseFile (wpc); return FALSE; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[4]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_ID; GError *error = NULL; run_mode = param[0].data.d_int32; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; if (strcmp (name, LOAD_PROC) == 0 || strcmp (name, LOAD_MERGED_PROC) == 0) { gboolean resolution_loaded = FALSE; gboolean interactive; switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); interactive = TRUE; break; default: interactive = FALSE; break; } image_ID = load_image (param[1].data.d_string, strcmp (name, LOAD_MERGED_PROC) == 0, &resolution_loaded, &error); if (image_ID != -1) { GFile *file = g_file_new_for_path (param[1].data.d_string); GimpMetadata *metadata; metadata = gimp_image_metadata_load_prepare (image_ID, "image/x-psd", file, NULL); if (metadata) { GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL; if (resolution_loaded) flags &= ~GIMP_METADATA_LOAD_RESOLUTION; gimp_image_metadata_load_finish (image_ID, "image/x-psd", metadata, flags, interactive); g_object_unref (metadata); } g_object_unref (file); *nreturn_vals = 2; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; } else { status = GIMP_PDB_EXECUTION_ERROR; } } else if (strcmp (name, LOAD_THUMB_PROC) == 0) { if (nparams < 2) { status = GIMP_PDB_CALLING_ERROR; } else { const gchar *filename = param[0].data.d_string; gint width = 0; gint height = 0; image_ID = load_thumbnail_image (filename, &width, &height, &error); if (image_ID != -1) { *nreturn_vals = 4; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = image_ID; values[2].type = GIMP_PDB_INT32; values[2].data.d_int32 = width; values[3].type = GIMP_PDB_INT32; values[3].data.d_int32 = height; } else { status = GIMP_PDB_EXECUTION_ERROR; } } } else if (strcmp (name, SAVE_PROC) == 0) { gint32 drawable_id; GimpMetadata *metadata; GimpMetadataSaveFlags metadata_flags; GimpExportReturn export = GIMP_EXPORT_IGNORE; IFDBG(2) g_debug ("\n---------------- %s ----------------\n", param[3].data.d_string); image_ID = param[1].data.d_int32; drawable_id = param[2].data.d_int32; switch (run_mode) { case GIMP_RUN_INTERACTIVE: case GIMP_RUN_WITH_LAST_VALS: gimp_ui_init (PLUG_IN_BINARY, FALSE); export = gimp_export_image (&image_ID, &drawable_id, "PSD", GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED | GIMP_EXPORT_CAN_HANDLE_ALPHA | GIMP_EXPORT_CAN_HANDLE_LAYERS | GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS); if (export == GIMP_EXPORT_CANCEL) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } break; default: break; }
static void cleaner_task_handler (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { HevFileboxCleaner *self = HEV_FILEBOX_CLEANER (source_object); HevFileboxCleanerPrivate *priv = HEV_FILEBOX_CLEANER_GET_PRIVATE (self); gchar *fp_path = NULL, *fm_path = NULL; GFile *file = NULL; GFileEnumerator *file_enumerator = NULL; GFileInfo *file_info = NULL; g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); fp_path = g_key_file_get_string (priv->config, "Module", "FilePoolPath", NULL); fm_path = g_key_file_get_string (priv->config, "Module", "FileMetaPath", NULL); /* enumerate file pool */ file = g_file_new_for_path (fp_path); file_enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME","G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); while (file_info = g_file_enumerator_next_file (file_enumerator, NULL, NULL)) { if (G_FILE_TYPE_REGULAR == g_file_info_get_file_type (file_info)) { gchar *meta_path = NULL; GKeyFile *meta = NULL; meta_path = g_build_filename (fm_path, g_file_info_get_name (file_info), NULL); meta = g_key_file_new (); if (g_key_file_load_from_file (meta, meta_path, G_KEY_FILE_NONE, NULL)) { gint64 exp = 0; GDateTime *now_date = NULL, *exp_date = NULL; exp = g_key_file_get_int64 (meta, "Meta", "ExpDate", NULL); now_date = g_date_time_new_now_utc (); exp_date = g_date_time_new_from_unix_utc (exp); /* compare date */ if (1 == g_date_time_compare (now_date, exp_date)) { gchar *file_path = NULL; file_path = g_build_filename (fp_path, g_file_info_get_name (file_info), NULL); /* delete file and it's meta */ g_unlink ((const gchar *) file_path); g_unlink ((const gchar *) meta_path); g_free (file_path); } g_date_time_unref (now_date); g_date_time_unref (exp_date); } g_key_file_unref (meta); g_free (meta_path); } g_object_unref (file_info); } g_object_unref (file_enumerator); g_object_unref (file); g_free (fp_path); g_free (fm_path); g_task_return_boolean (task, TRUE); }
gboolean ostree_admin_option_context_parse (GOptionContext *context, const GOptionEntry *main_entries, int *argc, char ***argv, OstreeAdminBuiltinFlags flags, OstreeSysroot **out_sysroot, GCancellable *cancellable, GError **error) { g_autoptr(GFile) sysroot_path = NULL; glnx_unref_object OstreeSysroot *sysroot = NULL; gboolean success = FALSE; /* Entries are listed in --help output in the order added. We add the * main entries ourselves so that we can add the --sysroot entry first. */ g_option_context_add_main_entries (context, global_admin_entries, NULL); if (!ostree_option_context_parse (context, main_entries, argc, argv, OSTREE_BUILTIN_FLAG_NO_REPO, NULL, cancellable, error)) goto out; if (opt_sysroot != NULL) sysroot_path = g_file_new_for_path (opt_sysroot); sysroot = ostree_sysroot_new (sysroot_path); if (flags & OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER) { GFile *path = ostree_sysroot_get_path (sysroot); /* If sysroot path is "/" then user must be root. */ if (!g_file_has_parent (path, NULL) && getuid () != 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED, "You must be root to perform this command"); goto out; } } if (opt_print_current_dir) { g_autoptr(GPtrArray) deployments = NULL; OstreeDeployment *first_deployment; g_autoptr(GFile) deployment_file = NULL; g_autofree char *deployment_path = NULL; if (!ostree_sysroot_load (sysroot, cancellable, error)) goto out; deployments = ostree_sysroot_get_deployments (sysroot); if (deployments->len == 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unable to find a deployment in sysroot"); goto out; } first_deployment = deployments->pdata[0]; deployment_file = ostree_sysroot_get_deployment_directory (sysroot, first_deployment); deployment_path = g_file_get_path (deployment_file); g_print ("%s\n", deployment_path); exit (EXIT_SUCCESS); } if ((flags & OSTREE_ADMIN_BUILTIN_FLAG_UNLOCKED) == 0) { /* Released when sysroot is finalized, or on process exit */ if (!ot_admin_sysroot_lock (sysroot, error)) goto out; } if (out_sysroot) *out_sysroot = g_steal_pointer (&sysroot); success = TRUE; out: return success; }
int main(int argc, char *argv[]) { EventdCoreContext *context; gchar *runtime_dir = NULL; gchar *control_socket = NULL; gchar **binds = NULL; gboolean take_over_socket = FALSE; gboolean enable_relay = TRUE; gboolean enable_sd_modules = TRUE; gchar *config_dir = NULL; gboolean daemonize = FALSE; gboolean print_paths = FALSE; gboolean print_version = FALSE; EventdReturnCode retval = EVENTD_RETURN_CODE_OK; GError *error = NULL; GOptionContext *option_context = NULL; #ifdef EVENTD_DEBUG g_setenv("G_MESSAGES_DEBUG", "all", FALSE); #endif /* EVENTD_DEBUG */ setlocale(LC_ALL, ""); #ifdef ENABLE_NLS bindtextdomain(GETTEXT_PACKAGE, EVENTD_LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); #endif /* ENABLE_NLS */ if ( ! g_get_filename_charsets(NULL) ) { g_warning(PACKAGE_NAME " does not support non-UTF-8 filename encoding"); return EVENTD_RETURN_CODE_FILESYSTEM_ENCODING_ERROR; } if ( G_UNLIKELY(! g_module_supported()) ) { g_warning("No loadable module support"); return EVENTD_RETURN_CODE_NO_MODULE_SUPPORT_ERROR; } #ifdef EVENTD_DEBUG setvbuf(stdout, NULL, _IOLBF, 0); const gchar *debug_log_filename = g_getenv("EVENTD_DEBUG_LOG_FILENAME"); GDataOutputStream *debug_stream = NULL; if ( debug_log_filename != NULL ) { GFile *debug_log; debug_log = g_file_new_for_path(debug_log_filename); GError *error = NULL; GFileOutputStream *debug_log_stream; debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error); if ( debug_log_stream == NULL ) { g_warning("Couldn't open debug log file: %s", error->message); g_clear_error(&error); } else { debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream)); g_object_unref(debug_log_stream); g_log_set_default_handler(_eventd_core_debug_log_handler, debug_stream); } g_object_unref(debug_log); } #endif /* EVENTD_DEBUG */ context = g_new0(EventdCoreContext, 1); context->interface.get_sockets = eventd_core_get_sockets; context->interface.push_event = eventd_core_push_event; #ifdef G_OS_UNIX context->system_mode = ( g_getenv("XDG_RUNTIME_DIR") == NULL ); if ( context->system_mode ) g_setenv("XDG_RUNTIME_DIR", "/run", TRUE); #endif /* G_OS_UNIX */ GOptionEntry entries[] = { { "private-socket", 'i', 0, G_OPTION_ARG_FILENAME, &control_socket, "Socket to listen for internal control", "<socket>" }, { "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &binds, "Add a socket to listen to", "<socket>" }, { "take-over", 't', GIO_UNIX_OPTION_FLAG, G_OPTION_ARG_NONE, &take_over_socket, "Take over socket", NULL }, { "no-relay", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_relay, "Disable the relay feature", NULL }, { "no-service-discovery", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_sd_modules, "Disable the service discovery feature", NULL }, { "config-dir", 'c', 0, G_OPTION_ARG_FILENAME, &config_dir, "Additionnal configuration directory", "<directory>" }, { "daemonize", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &daemonize, NULL, NULL }, { "paths", 'P', 0, G_OPTION_ARG_NONE, &print_paths, "Print search paths", NULL }, { "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL }, { .long_name = NULL } };
static void picture_scaled (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source = BG_PICTURES_SOURCE (user_data); CcBackgroundItem *item; GError *error = NULL; GdkPixbuf *pixbuf; const char *source_url; GtkTreeIter iter; GtkListStore *store; store = bg_source_get_liststore (BG_SOURCE (bg_source)); item = g_object_get_data (source_object, "item"); pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error); if (pixbuf == NULL) { g_warning ("Failed to load image: %s", error->message); g_error_free (error); g_object_unref (item); return; } /* insert the item into the liststore */ gtk_list_store_insert_with_values (store, &iter, 0, 0, pixbuf, 1, item, -1); source_url = cc_background_item_get_source_url (item); if (source_url != NULL) { g_hash_table_insert (bg_source->priv->known_items, bg_pictures_source_get_unique_filename (source_url), GINT_TO_POINTER (TRUE)); } else { char *cache_path; GFile *file, *parent, *dir; cache_path = bg_pictures_source_get_cache_path (); dir = g_file_new_for_path (cache_path); g_free (cache_path); file = g_file_new_for_uri (cc_background_item_get_uri (item)); parent = g_file_get_parent (file); if (g_file_equal (parent, dir)) { char *basename; basename = g_file_get_basename (file); g_hash_table_insert (bg_source->priv->known_items, basename, GINT_TO_POINTER (TRUE)); } g_object_unref (file); g_object_unref (parent); } g_object_unref (pixbuf); }
int main (int argc, char *argv[]) { GError *error; GOptionContext *context; GFile *file; setlocale (LC_ALL, ""); g_type_init (); error = NULL; context = g_option_context_new ("- list files at <location>"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_parse (context, &argc, &argv, &error); g_option_context_free (context); 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 (attributes != NULL) { /* asking for attributes implies -l; otherwise it won't get shown */ show_long = TRUE; } attributes = g_strconcat (G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_SIZE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN, attributes != NULL ? "," : "", attributes, NULL); if (show_completions != NULL) { print_completions (show_completions); return 0; } if (argc > 1) { int i; for (i = 1; i < argc; i++) { file = g_file_new_for_commandline_arg (argv[i]); list (file); g_object_unref (file); } } else { char *cwd; cwd = g_get_current_dir (); file = g_file_new_for_path (cwd); g_free (cwd); list (file); g_object_unref (file); } g_free (attributes); return 0; }
static void panel_place_menu_item_init (PanelPlaceMenuItem *menuitem) { GFile *bookmark; char *bookmarks_filename; GError *error; menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem); if (mate_gsettings_schema_exists (CAJA_DESKTOP_SCHEMA)) { menuitem->priv->caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA); g_signal_connect (menuitem->priv->caja_desktop_settings, "changed::" CAJA_DESKTOP_HOME_ICON_NAME_KEY, G_CALLBACK (panel_place_menu_item_key_changed), G_OBJECT (menuitem)); g_signal_connect (menuitem->priv->caja_desktop_settings, "changed::" CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY, G_CALLBACK (panel_place_menu_item_key_changed), G_OBJECT (menuitem)); } else menuitem->priv->caja_desktop_settings = NULL; if (mate_gsettings_schema_exists (CAJA_PREFS_SCHEMA)) { menuitem->priv->caja_prefs_settings = g_settings_new (CAJA_PREFS_SCHEMA); g_signal_connect (menuitem->priv->caja_prefs_settings, "changed::" CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY, G_CALLBACK (panel_place_menu_item_key_changed), G_OBJECT (menuitem)); } else menuitem->priv->caja_prefs_settings = NULL; menuitem->priv->menubar_settings = g_settings_new (PANEL_MENU_BAR_SCHEMA); g_signal_connect (menuitem->priv->menubar_settings, "changed::" PANEL_MENU_BAR_MAX_ITEMS_OR_SUBMENU, G_CALLBACK (panel_place_menu_item_key_changed), G_OBJECT (menuitem)); menuitem->priv->recent_manager = gtk_recent_manager_get_default (); bookmarks_filename = g_build_filename (g_get_home_dir (), BOOKMARKS_FILENAME, NULL); bookmark = g_file_new_for_path (bookmarks_filename); error = NULL; menuitem->priv->bookmarks_monitor = g_file_monitor_file (bookmark, G_FILE_MONITOR_NONE, NULL, &error); if (error) { g_warning ("Failed to add file monitor for %s: %s\n", bookmarks_filename, error->message); g_error_free (error); } else { g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor), "changed", (GCallback) panel_place_menu_item_gtk_bookmarks_changed, menuitem); } g_object_unref (bookmark); g_free (bookmarks_filename); menuitem->priv->volume_monitor = g_volume_monitor_get (); menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-changed", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-connected", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-disconnected", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-added", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-changed", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-removed", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-added", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-changed", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-removed", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); }
int main (int argc, char** argv) { GFile *db_dir, *db_file; notmuch_status_t status; notmuch_database_t *db = NULL; notmuch_query_t *query = NULL; notmuch_messages_t *messages = NULL; notmuch_message_t *message = NULL; GMainLoop *loop = NULL; const char *query_string = "date:2014-02-01.."; if (argc != 2) { g_warning ("Usage: %s EVOLUTION_MAILDIR", argv[0]); return 1; } db_dir = g_file_new_for_path (argv[1]); db_file = g_file_get_child (db_dir, ".notmuch"); if (!g_file_query_exists (db_dir, NULL)) { g_object_unref (db_dir); g_object_unref (db_file); g_error ("directory %s does not exists"); return 2; } if (!g_file_query_exists (db_file, NULL)) status = notmuch_database_create (argv[1], &db); else status = notmuch_database_open (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db); if (status) { g_error ("Could not open database: %d", status); g_object_unref (db_dir); g_object_unref (db_file); notmuch_database_destroy (db); return 3; } scan_directory (db, db_dir); //loop = g_main_loop_new (NULL, FALSE); //g_main_loop_run (loop); query = notmuch_query_create (db, query_string); if (!query) { g_error ("Could not create query from string = \"%s\"", query_string); notmuch_database_destroy (db); g_object_unref (db_file); g_object_unref (db_dir); return 4; } g_message ("Query results -\n\n"); for (messages = notmuch_query_search_messages (query); notmuch_messages_valid (messages); notmuch_messages_move_to_next (messages)) { message = notmuch_messages_get (messages); g_message ("Message file: %s", notmuch_message_get_filename (message)); g_message ("Message ID: %s", notmuch_message_get_message_id (message)); g_message ("Message Sender: %s", notmuch_message_get_header (message, "from")); g_message ("Message Recipients: %s", notmuch_message_get_header (message, "to")); g_message ("Message Subject: %s", notmuch_message_get_header (message, "subject")); g_message ("Message date: %s\n", notmuch_message_get_header (message, "date")); notmuch_message_destroy (message); } notmuch_query_destroy (query); notmuch_database_destroy (db); g_object_unref (db_file); g_object_unref (db_dir); return 0; }
static void fr_command_jar_add (FrCommand *comm, const char *from_file, GList *file_list, const char *base_dir, gboolean update, gboolean follow_links) { FrProcess *proc = comm->process; GList *zip_list = NULL, *jardata_list = NULL, *jar_list = NULL; GList *scan; char *tmp_dir; for (scan = file_list; scan; scan = scan->next) { char *filename = scan->data; char *path = g_build_filename (base_dir, filename, NULL); char *package = NULL; if (_g_filename_has_extension (filename, ".java")) package = get_package_name_from_java_file (path); else if (_g_filename_has_extension (filename, ".class")) package = get_package_name_from_class_file (path); if ((package == NULL) || (strlen (package) == 0)) zip_list = g_list_append (zip_list, g_strdup (filename)); else { JarData *newdata = g_new0 (JarData, 1); newdata->package_minus_one_level = _g_path_remove_level (package); newdata->link_name = g_strdup (_g_path_get_basename (package)); newdata->rel_path = _g_path_remove_level (filename); newdata->filename = g_strdup (_g_path_get_basename (filename)); jardata_list = g_list_append (jardata_list, newdata); } g_free (package); g_free (path); } tmp_dir = _g_path_get_temp_work_dir (NULL); for (scan = jardata_list; scan ; scan = scan->next) { JarData *jdata = scan->data; char *pack_path; GFile *directory; char *old_link; char *link_name; int retval; pack_path = g_build_filename (tmp_dir, jdata->package_minus_one_level, NULL); directory = g_file_new_for_path (pack_path); if (! _g_file_make_directory_tree (directory, 0755, NULL)) { g_object_unref (directory); g_free (pack_path); continue; } old_link = g_build_filename (base_dir, jdata->rel_path, NULL); link_name = g_build_filename (pack_path, jdata->link_name, NULL); retval = symlink (old_link, link_name); if ((retval != -1) || (errno == EEXIST)) jar_list = g_list_append (jar_list, g_build_filename (jdata->package_minus_one_level, jdata->link_name, jdata->filename, NULL)); g_free (link_name); g_free (old_link); g_object_unref (directory); g_free (pack_path); } if (zip_list != NULL) FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, zip_list, base_dir, update, follow_links); if (jar_list != NULL) FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, jar_list, tmp_dir, update, follow_links); fr_process_begin_command (proc, "rm"); fr_process_set_working_dir (proc, "/"); fr_process_add_arg (proc, "-r"); fr_process_add_arg (proc, "-f"); fr_process_add_arg (proc, tmp_dir); fr_process_end_command (proc); fr_process_set_sticky (proc, TRUE); for (scan = jardata_list; scan ; scan = scan->next) { JarData *jdata = scan->data; g_free (jdata->filename); g_free (jdata->package_minus_one_level); g_free (jdata->link_name); g_free (jdata->rel_path); } _g_string_list_free (jardata_list); _g_string_list_free (jar_list); _g_string_list_free (zip_list); g_free (tmp_dir); }
static GtkWidget * panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item) { GtkWidget *places_menu; GtkWidget *item; char *gconf_name; char *name; char *uri; GFile *file; places_menu = panel_create_menu (); file = g_file_new_for_path (g_get_home_dir ()); uri = g_file_get_uri (file); name = panel_util_get_label_for_uri (uri); g_object_unref (file); item = panel_menu_item_uri_new (uri, PANEL_ICON_HOME, NULL, name, _("Open your personal folder"), G_CALLBACK (activate_home_uri)); gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); g_free (name); g_free (uri); if (!gconf_client_get_bool (panel_gconf_get_client (), DESKTOP_IS_HOME_DIR_KEY, NULL)) { file = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP)); uri = g_file_get_uri (file); g_object_unref (file); item = panel_menu_item_uri_new ( /* FIXME: if the dir changes, we'd need to update the drag data since the uri is not the same */ uri, PANEL_ICON_DESKTOP, NULL, /* Translators: Desktop is used here as in * "Desktop Folder" (this is not the Desktop * environment). */ C_("Desktop Folder", "Desktop"), _("Open the contents of your desktop in a folder"), G_CALLBACK (activate_desktop_uri)); gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); g_free (uri); } panel_place_menu_item_append_gtk_bookmarks (places_menu); add_menu_separator (places_menu); gconf_name = gconf_client_get_string (panel_gconf_get_client (), COMPUTER_NAME_KEY, NULL); if (gconf_name == NULL) { gconf_name = g_strdup (_("Computer")); } item = panel_menu_item_uri_new ("computer://", PANEL_ICON_COMPUTER, NULL, gconf_name, _("Browse all local and remote disks and folders accessible from this computer"), G_CALLBACK (activate_uri)); gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); g_free (gconf_name); panel_place_menu_item_append_local_gio (place_item, places_menu); add_menu_separator (places_menu); item = panel_menu_item_uri_new ("network://", PANEL_ICON_NETWORK, NULL, _("Network"), _("Browse bookmarked and local network locations"), G_CALLBACK (activate_uri)); gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); panel_place_menu_item_append_remote_gio (place_item, places_menu); if (panel_is_program_in_path ("nautilus-connect-server")) { item = panel_menu_items_create_action_item (PANEL_ACTION_CONNECT_SERVER); if (item != NULL) gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); } add_menu_separator (places_menu); item = panel_menu_item_desktop_new ("gnome-search-tool.desktop", NULL, FALSE); if (item) gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item); panel_recent_append_documents_menu (places_menu, place_item->priv->recent_manager); return places_menu; }
static void picture_scaled (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source; CcBackgroundItem *item; GError *error = NULL; GdkPixbuf *pixbuf; const char *source_url; const char *software; GtkTreeIter iter; GtkListStore *store; pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error); if (pixbuf == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Failed to load image: %s", error->message); g_error_free (error); return; } /* since we were not cancelled, we can now cast user_data * back to BgPicturesSource. */ bg_source = BG_PICTURES_SOURCE (user_data); store = bg_source_get_liststore (BG_SOURCE (bg_source)); item = g_object_get_data (source_object, "item"); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), 1, (GtkTreeIterCompareFunc)sort_func, bg_source, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 1, GTK_SORT_ASCENDING); /* Ignore screenshots */ software = gdk_pixbuf_get_option (pixbuf, "tEXt::Software"); if (software != NULL && g_str_equal (software, "gnome-screenshot")) { g_debug ("Ignored URL '%s' as it's a screenshot from gnome-screenshot", cc_background_item_get_uri (item)); g_object_unref (pixbuf); g_object_unref (item); return; } cc_background_item_load (item, NULL); /* insert the item into the liststore */ gtk_list_store_insert_with_values (store, &iter, 0, 0, pixbuf, 1, item, -1); source_url = cc_background_item_get_source_url (item); if (source_url != NULL) { g_hash_table_insert (bg_source->priv->known_items, bg_pictures_source_get_unique_filename (source_url), GINT_TO_POINTER (TRUE)); } else { char *cache_path; GFile *file, *parent, *dir; cache_path = bg_pictures_source_get_cache_path (); dir = g_file_new_for_path (cache_path); g_free (cache_path); file = g_file_new_for_uri (cc_background_item_get_uri (item)); parent = g_file_get_parent (file); if (g_file_equal (parent, dir)) { char *basename; basename = g_file_get_basename (file); g_hash_table_insert (bg_source->priv->known_items, basename, GINT_TO_POINTER (TRUE)); } g_object_unref (file); g_object_unref (parent); } g_object_unref (pixbuf); }
static void panel_place_menu_item_init (PanelPlaceMenuItem *menuitem) { GFile *bookmark; char *bookmarks_filename; GError *error; menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem); gconf_client_add_dir (panel_gconf_get_client (), DESKTOP_IS_HOME_DIR_DIR, GCONF_CLIENT_PRELOAD_NONE, NULL); gconf_client_add_dir (panel_gconf_get_client (), NAMES_DIR, GCONF_CLIENT_PRELOAD_NONE, NULL); panel_gconf_notify_add_while_alive (HOME_NAME_KEY, (GConfClientNotifyFunc) panel_place_menu_item_key_changed, G_OBJECT (menuitem)); panel_gconf_notify_add_while_alive (DESKTOP_IS_HOME_DIR_KEY, (GConfClientNotifyFunc) panel_place_menu_item_key_changed, G_OBJECT (menuitem)); panel_gconf_notify_add_while_alive (COMPUTER_NAME_KEY, (GConfClientNotifyFunc) panel_place_menu_item_key_changed, G_OBJECT (menuitem)); menuitem->priv->recent_manager = gtk_recent_manager_get_default (); bookmarks_filename = g_build_filename (g_get_home_dir (), BOOKMARKS_FILENAME, NULL); bookmark = g_file_new_for_path (bookmarks_filename); error = NULL; menuitem->priv->bookmarks_monitor = g_file_monitor_file (bookmark, G_FILE_MONITOR_NONE, NULL, &error); if (error) { g_warning ("Failed to add file monitor for %s: %s\n", bookmarks_filename, error->message); g_error_free (error); } else { g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor), "changed", (GCallback) panel_place_menu_item_gtk_bookmarks_changed, menuitem); } g_object_unref (bookmark); g_free (bookmarks_filename); menuitem->priv->volume_monitor = g_volume_monitor_get (); menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-changed", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-connected", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor, "drive-disconnected", G_CALLBACK (panel_place_menu_item_drives_changed), menuitem); menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-added", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-changed", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor, "volume-removed", G_CALLBACK (panel_place_menu_item_volumes_changed), menuitem); menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-added", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-changed", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor, "mount-removed", G_CALLBACK (panel_place_menu_item_mounts_changed), menuitem); }
static void load_desktop_file (GFile *file, GAsyncResult *result, GAsyncResult *init_result) { HDImagesetBackground *background = HD_IMAGESET_BACKGROUND (g_async_result_get_source_object (init_result)); HDImagesetBackgroundPrivate *priv = background->priv; char *file_contents = NULL; gsize file_size; char *etag; GKeyFile *key_file = NULL; guint i; GError *error = NULL; char *type = NULL; g_file_load_contents_finish (file, result, &file_contents, &file_size, &etag, &error); if (error) { g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result), error); g_error_free (error); goto complete; } key_file = g_key_file_new (); g_key_file_load_from_data (key_file, file_contents, file_size, G_KEY_FILE_NONE, &error); if (error) { g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result), error); g_error_free (error); goto complete; } type = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_TYPE, &error); if (error) { g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result), error); g_error_free (error); goto complete; } else if (g_strcmp0 (type, KEY_FILE_BACKGROUND_VALUE_TYPE) != 0) { g_simple_async_result_set_error (G_SIMPLE_ASYNC_RESULT (init_result), G_IO_ERROR, G_IO_ERROR_FAILED, "Not a valid imageset .desktop file. Type needs to be Background Image"); } priv->name = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, G_KEY_FILE_DESKTOP_KEY_NAME, &error); if (error) { g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result), error); g_error_free (error); goto complete; } int max_value = HD_DESKTOP_VIEWS; if(hd_backgrounds_is_portrait_wallpaper_enabled (hd_backgrounds_get ())) max_value += HD_DESKTOP_VIEWS; for (i = 0; i < max_value; i++) { gchar *key, *value; GFile *image_file; if (i >= HD_DESKTOP_VIEWS) key = g_strdup_printf ("X-Portrait-File%u", i + 1 - HD_DESKTOP_VIEWS); else key = g_strdup_printf ("X-File%u", i + 1); value = g_key_file_get_string (key_file, G_KEY_FILE_DESKTOP_GROUP, key, &error); g_free (key); if (error) { g_error_free (error); error = NULL; g_free (value); continue; } g_strstrip (value); if (g_path_is_absolute (value)) image_file = g_file_new_for_path (value); else { GFile *desktop_parent = g_file_get_parent (file); image_file = g_file_get_child (desktop_parent, value); g_object_unref (desktop_parent); } g_free (value); if (g_file_query_exists (image_file, NULL)) { hd_object_vector_push_back (priv->image_files, image_file); g_object_unref (image_file); } else { char *path = g_file_get_path (image_file); g_simple_async_result_set_error (G_SIMPLE_ASYNC_RESULT (init_result), G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "Could not find file %s", path); g_object_unref (image_file); g_free (path); goto complete; } } g_simple_async_result_set_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (init_result), TRUE); complete: g_free (file_contents); g_free (type); if (key_file) g_key_file_free (key_file); g_simple_async_result_complete (G_SIMPLE_ASYNC_RESULT (init_result)); }
static void pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { gchar *pkg_id, *full_name, *desc, **pkg_tokens; const gchar *pkg_metadata_filename; GFile *pkg_metadata_dir; GFileEnumerator *pkg_metadata_enumerator; GFileInfo *pkg_metadata_file_info; GError *err = NULL; sqlite3_stmt *stmt; PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job); pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); if ((sqlite3_prepare_v2(job_data->db, "SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext " "FROM pkglist AS p1 NATURAL JOIN repos AS r " "WHERE p1.name LIKE @name AND p1.repo_order = " "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", -1, &stmt, NULL) != SQLITE_OK)) { pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); goto out; } /* Read the package metadata directory and comprare all installed packages with ones in the cache */ pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name", G_FILE_QUERY_INFO_NONE, NULL, &err); g_object_unref(pkg_metadata_dir); if (err) { pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "/var/log/packages: %s", err->message); g_error_free(err); goto out; } while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) { pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info); pkg_tokens = katja_cut_pkg(pkg_metadata_filename); /* Select the package from the database */ sqlite3_bind_text(stmt, 1, pkg_tokens[0], -1, SQLITE_TRANSIENT); /* If there are more packages with the same name, remember the one from the repository with the lowest order */ if ((sqlite3_step(stmt) == SQLITE_ROW) || g_slist_find_custom(repos, ((gchar *) sqlite3_column_text(stmt, 4)), katja_cmp_repo)) { full_name = g_strdup((gchar *) sqlite3_column_text(stmt, 0)); if (!g_strcmp0((gchar *) sqlite3_column_text(stmt, 6), "obsolete")) { /* Remove if obsolete */ pkg_id = pk_package_id_build(pkg_tokens[PK_PACKAGE_ID_NAME], pkg_tokens[PK_PACKAGE_ID_VERSION], pkg_tokens[PK_PACKAGE_ID_ARCH], "obsolete"); /* TODO: * 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages() if the package is obsolete or not * 2: Get description from /var/log/packages, not from the database */ desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5)); pk_backend_job_package(job, PK_INFO_ENUM_REMOVING, pkg_id, desc); g_free(desc); g_free(pkg_id); } else if (g_strcmp0(pkg_metadata_filename, full_name)) { /* Update available */ pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1), (gchar *) sqlite3_column_text(stmt, 2), (gchar *) sqlite3_column_text(stmt, 3), (gchar *) sqlite3_column_text(stmt, 4)); desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5)); pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc); g_free(desc); g_free(pkg_id); } g_free(full_name); } sqlite3_clear_bindings(stmt); sqlite3_reset(stmt); g_strfreev(pkg_tokens); g_object_unref(pkg_metadata_file_info); } g_object_unref(pkg_metadata_enumerator); out: sqlite3_finalize(stmt); }