/** * gimp_config_writer_new_gfile: * @file: a #GFile * @atomic: if %TRUE the file is written atomically * @header: text to include as comment at the top of the file * @error: return location for errors * * Creates a new #GimpConfigWriter and sets it up to write to * @file. If @atomic is %TRUE, a temporary file is used to avoid * possible race conditions. The temporary file is then moved to @file * when the writer is closed. * * Return value: a new #GimpConfigWriter or %NULL in case of an error * * Since: GIMP 2.10 **/ GimpConfigWriter * gimp_config_writer_new_gfile (GFile *file, gboolean atomic, const gchar *header, GError **error) { GimpConfigWriter *writer; GOutputStream *output; GError *my_error = NULL; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); if (atomic) { output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &my_error)); if (! output) g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE, _("Could not create temporary file for '%s': %s"), gimp_file_get_utf8_name (file), my_error->message); } else { output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, &my_error)); if (! output) g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE, _("Could not open '%s' for writing: %s"), gimp_file_get_utf8_name (file), my_error->message); } if (! output) { g_clear_error (&my_error); return NULL; } writer = g_slice_new0 (GimpConfigWriter); writer->output = output; writer->file = g_object_ref (file); writer->buffer = g_string_new (NULL); if (header) { gimp_config_writer_comment (writer, header); gimp_config_writer_linefeed (writer); } return writer; }
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = response; m_download->didReceiveResponse(response); if (response.httpStatusCode() >= 400) { downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url(), response.httpStatusText())); return; } String suggestedFilename = response.suggestedFilename(); if (suggestedFilename.isEmpty()) { URL url = response.url(); url.setQuery(String()); url.removeFragmentIdentifier(); suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent()); } String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename, m_allowOverwrite); if (destinationURI.isEmpty()) { #if PLATFORM(GTK) GUniquePtr<char> buffer(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data())); String errorMessage = String::fromUTF8(buffer.get()); #else String errorMessage = makeString("Cannot determine destination URI for download with suggested filename ", suggestedFilename); #endif downloadFailed(platformDownloadDestinationError(response, errorMessage)); return; } m_destinationFile = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data())); GRefPtr<GFileOutputStream> outputStream; GUniqueOutPtr<GError> error; if (m_allowOverwrite) outputStream = adoptGRef(g_file_replace(m_destinationFile.get(), nullptr, FALSE, G_FILE_CREATE_NONE, nullptr, &error.outPtr())); else outputStream = adoptGRef(g_file_create(m_destinationFile.get(), G_FILE_CREATE_NONE, nullptr, &error.outPtr())); if (!outputStream) { m_destinationFile.clear(); downloadFailed(platformDownloadDestinationError(response, error->message)); return; } String intermediateURI = destinationURI + ".wkdownload"; m_intermediateFile = adoptGRef(g_file_new_for_uri(intermediateURI.utf8().data())); m_outputStream = adoptGRef(g_file_replace(m_intermediateFile.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr())); if (!m_outputStream) { downloadFailed(platformDownloadDestinationError(response, error->message)); return; } m_download->didCreateDestination(destinationURI); }
/** * camel_stream_vfs_new_with_uri: * @uri: a file uri * @mode: opening mode for the uri file * * Creates a new #CamelStreamVFS corresponding to the named file and mode. * * Returns the new stream, or %NULL on error. **/ CamelStream * camel_stream_vfs_new_with_uri (const char *uri, CamelStreamVFSOpenMethod mode) { GFile *file; GObject *stream; GError *error = NULL; file = g_file_new_for_uri (uri); switch (mode) { case CAMEL_STREAM_VFS_CREATE: stream = G_OBJECT (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error)); break; case CAMEL_STREAM_VFS_APPEND: stream = G_OBJECT (g_file_append_to (file, G_FILE_CREATE_NONE, NULL, &error)); break; case CAMEL_STREAM_VFS_READ: stream = G_OBJECT (g_file_read (file, NULL, &error)); break; default: errno = EINVAL; g_return_val_if_reached (NULL); } g_object_unref (file); if (error) { errno = error->code; g_warning ("%s", error->message); g_error_free (error); return NULL; } return camel_stream_vfs_new_with_stream (stream); }
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 do_replace (GVfsBackend *backend, GVfsJobOpenForWrite *job, const char *filename, const char *etag, gboolean make_backup, GFileCreateFlags flags) { GFile *file; GFileOutputStream *out; GError *error; file = g_vfs_get_file_for_path (g_vfs_get_local (), filename); error = NULL; out = g_file_replace (file, etag, make_backup, flags, G_VFS_JOB (job)->cancellable, &error); g_object_unref (file); if (out) { g_vfs_job_open_for_write_set_can_seek (job, FALSE); g_vfs_job_open_for_write_set_handle (job, out); g_vfs_job_succeeded (G_VFS_JOB (job)); } else { g_vfs_job_failed_from_error (G_VFS_JOB (job), error); g_error_free (error); } }
void lllp_connected_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) { GtkListStore *store_library = GTK_LIST_STORE(pstore_library); GSocketConnection *connection; GSocketAddress *address; gchar *address_char; GInputStream *stream; GFile *output_file; GOutputStream *file_stream; gsize count; gboolean valid = FALSE; connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL); address = g_socket_connection_get_remote_address(connection, NULL); address_char = g_inet_address_to_string(g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address))); printf("%s\n", address_char); output_file = g_file_new_for_path(address_char); g_file_delete(output_file, NULL, NULL); file_stream = (GOutputStream*)g_file_replace(output_file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL); stream = g_io_stream_get_input_stream(G_IO_STREAM(connection)); g_output_stream_splice(file_stream, stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE & G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, NULL); g_output_stream_close(file_stream, NULL, NULL); convert_library_to_list_store(store_library, address_char); printf("%s CONNECTED\n", address_char); g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_connected_cb, store_library); }
gboolean ot_util_variant_save (GFile *dest, GVariant *variant, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gs_unref_object GOutputStream *out = NULL; gsize bytes_written; out = (GOutputStream*)g_file_replace (dest, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, cancellable, error); if (!out) goto out; if (!g_output_stream_write_all (out, g_variant_get_data (variant), g_variant_get_size (variant), &bytes_written, cancellable, error)) goto out; if (!g_output_stream_close (out, cancellable, error)) goto out; ret = TRUE; out: return ret; }
static void export_png (GtkButton *button, ChamplainView *view) { cairo_surface_t *surface; GdkPixbuf *pixbuf; GFileOutputStream *os; GFile *file; gint width, height; if (champlain_view_get_state (view) != CHAMPLAIN_STATE_DONE) return; surface = champlain_view_to_surface (view, TRUE); if (!surface) return; width = cairo_image_surface_get_width (surface); height = cairo_image_surface_get_height (surface); pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height); if (!pixbuf) return; file = g_file_new_for_path ("champlain-map.png"); os = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL); if (!os) { g_object_unref (pixbuf); return; } gdk_pixbuf_save_to_stream (pixbuf, G_OUTPUT_STREAM (os), "png", NULL, NULL, NULL); g_output_stream_close (G_OUTPUT_STREAM (os), NULL, NULL); }
static void byzanz_session_constructed (GObject *object) { ByzanzSession *session = BYZANZ_SESSION (object); GOutputStream *stream; session->recorder = byzanz_recorder_new (session->window, &session->area); g_signal_connect (session->recorder, "notify::recording", G_CALLBACK (byzanz_session_recorder_notify_cb), session); g_signal_connect (session->recorder, "image", G_CALLBACK (byzanz_session_recorder_image_cb), session); /* FIXME: make async */ stream = G_OUTPUT_STREAM (g_file_replace (session->file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, session->cancellable, &session->error)); if (stream != NULL) { session->encoder = byzanz_encoder_new (session->encoder_type, byzanz_queue_get_input_stream (session->queue), stream, session->record_audio, session->cancellable); g_signal_connect (session->encoder, "notify", G_CALLBACK (byzanz_session_encoder_notify_cb), session); g_object_unref (stream); if (byzanz_encoder_get_error (session->encoder)) byzanz_session_set_error (session, byzanz_encoder_get_error (session->encoder)); } byzanz_serialize_header (byzanz_queue_get_output_stream (session->queue), session->area.width, session->area.height, session->cancellable, &session->error); if (G_OBJECT_CLASS (byzanz_session_parent_class)->constructed) G_OBJECT_CLASS (byzanz_session_parent_class)->constructed (object); }
gboolean ev_attachment_save (EvAttachment *attachment, GFile *file, GError **error) { GFileOutputStream *output_stream; GError *ioerror = NULL; gssize written_bytes; g_return_val_if_fail (EV_IS_ATTACHMENT (attachment), FALSE); g_return_val_if_fail (G_IS_FILE (file), FALSE); output_stream = g_file_replace (file, NULL, FALSE, 0, NULL, &ioerror); if (output_stream == NULL) { char *uri; uri = g_file_get_uri (file); g_set_error (error, EV_ATTACHMENT_ERROR, ioerror->code, _("Couldn't save attachment “%s”: %s"), uri, ioerror->message); g_error_free (ioerror); g_free (uri); return FALSE; } written_bytes = g_output_stream_write (G_OUTPUT_STREAM (output_stream), attachment->priv->data, attachment->priv->size, NULL, &ioerror); if (written_bytes == -1) { char *uri; uri = g_file_get_uri (file); g_set_error (error, EV_ATTACHMENT_ERROR, ioerror->code, _("Couldn't save attachment “%s”: %s"), uri, ioerror->message); g_output_stream_close (G_OUTPUT_STREAM (output_stream), NULL, NULL); g_error_free (ioerror); g_free (uri); return FALSE; } g_output_stream_close (G_OUTPUT_STREAM (output_stream), NULL, NULL); return TRUE; }
/** * ly_log_logger_clear: * @logger: the logger * * Clear all the logs written before. This function always attempts to * create a temp file whose filename is ended up with "~" and store all * the old logs into it. */ void ly_log_logger_clear (LyLogLogger *logger) { LyLogLoggerPrivate *priv=LY_LOG_LOGGER_GET_PRIVATE(LY_LOG_LOGGER(logger)); GFileOutputStream *ostream; gchar str[64]="LOG BEGIN >>\n"; ostream=g_file_replace(G_FILE(priv->file), NULL, TRUE, \ G_FILE_CREATE_NONE, NULL, NULL); g_output_stream_write(G_OUTPUT_STREAM(ostream), str, strlen(str), \ NULL, NULL); g_output_stream_close(G_OUTPUT_STREAM(ostream), NULL, NULL); g_object_unref(ostream); }
static gboolean ori_save (gchar * fn, gboolean replace) { gchar *text; GFile *fp; GFileOutputStream *file_out; GError *error = NULL; char *nullstr = "NULLSTRING"; gssize bytes; if (!fn) fn = nullstr; fp = g_file_new_for_uri (fn); file_out = g_file_create (fp, G_FILE_CREATE_NONE, NULL, &error); if ((file_out == NULL) && (error->code == G_IO_ERROR_EXISTS)) { if (replace) { g_error_free (error); /* replace file */ file_out = g_file_replace (fp, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &error); } } text = gui_editor_get_text (app->editor); if (file_out == NULL) { gchar errmsg[MAX_ERR_MSG_SIZE + 1]; g_snprintf (errmsg, MAX_ERR_MSG_SIZE, _("Failed to save <%s>"), fn); gui_app_show_msg (GTK_MESSAGE_ERROR, errmsg); return TRUE; } bytes = g_output_stream_write (G_OUTPUT_STREAM (file_out), text, strlen (text), NULL, NULL); gtk_text_buffer_set_modified ((GtkTextBuffer *)app->editor->buffer, FALSE); /* debug */ g_output_stream_close (G_OUTPUT_STREAM (file_out), NULL, NULL); g_free (text); if (replace) _set_file_name (fn); /*g_error_free (error);*/ return TRUE; }
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = adoptGRef(response.toSoupMessage()); m_download->didReceiveResponse(response); if (response.httpStatusCode() >= 400) { downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url().string(), response.httpStatusText())); return; } String suggestedFilename = response.suggestedFilename(); if (suggestedFilename.isEmpty()) { URL url = response.url(); url.setQuery(String()); url.removeFragmentIdentifier(); suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent()); } bool overwrite; String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename, overwrite); if (destinationURI.isEmpty()) { #if PLATFORM(GTK) GOwnPtr<char> buffer(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data())); String errorMessage = String::fromUTF8(buffer.get()); #else String errorMessage = makeString("Cannot determine destination URI for download with suggested filename ", suggestedFilename); #endif downloadFailed(platformDownloadDestinationError(response, errorMessage)); return; } GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data())); GOwnPtr<GError> error; m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr())); if (!m_outputStream) { downloadFailed(platformDownloadDestinationError(response, error->message)); return; } GRefPtr<GFileInfo> info = adoptGRef(g_file_info_new()); g_file_info_set_attribute_string(info.get(), "metadata::download-uri", response.url().string().utf8().data()); g_file_set_attributes_async(file.get(), info.get(), G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, 0, 0, 0); m_download->didCreateDestination(destinationURI); }
static GFile * create_file (GFile *base_dir) { GFile *scratch_file; gchar *scratch_name; GOutputStream *output_stream; gint pid; GError *error = NULL; gchar buffer [BUFFER_SIZE]; gint i; pid = getpid (); scratch_name = g_strdup_printf ("gvfs-benchmark-scratch-%d", pid); scratch_file = g_file_resolve_relative_path (base_dir, scratch_name); g_free (scratch_name); if (!scratch_file) return NULL; output_stream = G_OUTPUT_STREAM (g_file_replace (scratch_file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error)); if (!output_stream) { g_printerr ("Failed to create scratch file: %s\n", error->message); g_object_unref (scratch_file); return NULL; } memset (buffer, 0xaa, BUFFER_SIZE); for (i = 0; i < FILE_SIZE; i += BUFFER_SIZE) { if (g_output_stream_write (output_stream, buffer, BUFFER_SIZE, NULL, &error) < BUFFER_SIZE) { g_printerr ("Failed to populate scratch file: %s\n", error->message); g_output_stream_close (output_stream, NULL, NULL); g_object_unref (output_stream); g_object_unref (scratch_file); return NULL; } } g_output_stream_close (output_stream, NULL, NULL); g_object_unref (output_stream); return scratch_file; }
static void debug_dialog_save_file_chooser_response_cb (GtkDialog *dialog, gint response_id, EmpathyDebugDialog *debug_dialog) { EmpathyDebugDialogPriv *priv = GET_PRIV (debug_dialog); gchar *filename = NULL; GFile *gfile = NULL; GFileOutputStream *output_stream = NULL; GError *error = NULL; if (response_id != GTK_RESPONSE_ACCEPT) goto OUT; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); DEBUG ("Saving log as %s", filename); gfile = g_file_new_for_path (filename); output_stream = g_file_replace (gfile, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error); if (error != NULL) { DEBUG ("Failed to open file for writing: %s", error->message); g_error_free (error); goto OUT; } gtk_tree_model_foreach (priv->store_filter, debug_dialog_store_filter_foreach, output_stream); OUT: if (gfile != NULL) g_object_unref (gfile); if (output_stream != NULL) g_object_unref (output_stream); if (filename != NULL) g_free (filename); gtk_widget_destroy (GTK_WIDGET (dialog)); }
static GOutputStream * prepare_write_stream (const gchar *filename, gchar **filename_used) { GOutputStream *stream; GFile *file; if (g_path_is_absolute (filename)) { file = g_file_new_for_path (filename); *filename_used = g_strdup (filename); stream = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL)); g_object_unref (file); } else { stream = get_stream_for_filename (filename, filename_used); } return stream; }
bool QuiddityManager::save_command_history(const char* file_path) const { GFile* file = g_file_new_for_commandline_arg(file_path); On_scope_exit { g_object_unref(file); }; GError* error = nullptr; GFileOutputStream* file_stream = g_file_replace(file, nullptr, TRUE, // make backup G_FILE_CREATE_NONE, nullptr, &error); On_scope_exit { g_object_unref(file_stream); }; if (error != nullptr) { g_warning("%s", error->message); g_error_free(error); return false; } auto histo = get_serialized_command_history(); if (histo.empty()) return false; // saving the save tree to the file gchar* history = g_strdup(histo.c_str()); g_output_stream_write( (GOutputStream*)file_stream, history, sizeof(gchar) * strlen(history), nullptr, &error); g_free(history); if (error != nullptr) { g_warning("%s", error->message); g_error_free(error); return false; } g_output_stream_close((GOutputStream*)file_stream, nullptr, &error); if (error != nullptr) { g_warning("%s", error->message); g_error_free(error); return false; } return true; }
/* * et_picture_save_file_data: * @pic: the #Picture from which to take an image * @file: the #GFile for which to save an image * @error: a #GError to provide information on errors, or %NULL to ignore * * Saves an image from @pic to the supplied @file. * * Returns: %TRUE on success, %FALSE otherwise */ static gboolean et_picture_save_file_data (const Picture *pic, GFile *file, GError **error) { GFileOutputStream *file_ostream; gsize bytes_written; g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file_ostream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error); if (!file_ostream) { g_assert (error == NULL || *error != NULL); return FALSE; } if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream), pic->data, pic->size, &bytes_written, NULL, error)) { g_debug ("Only %" G_GSIZE_FORMAT " bytes out of %" G_GSIZE_FORMAT " bytes of picture data were written", bytes_written, pic->size); g_object_unref (file_ostream); g_assert (error == NULL || *error != NULL); return FALSE; } if (!g_output_stream_close (G_OUTPUT_STREAM (file_ostream), NULL, error)) { g_object_unref (file_ostream); g_assert (error == NULL || *error != NULL); return FALSE; } g_assert (error == NULL || *error == NULL); g_object_unref (file_ostream); return TRUE; }
static void disabled_repos_free (GHashTable *disabled) { GHashTableIter iter; GFile *file; GFileOutputStream *file_stream; GDataOutputStream *data_stream; const gchar *line = PACMAN_REPO_LIST_HEADER "\n"; g_return_if_fail (disabled != NULL); g_debug ("pacman: storing disabled repos in %s", PACMAN_REPO_LIST); file = g_file_new_for_path (PACMAN_REPO_LIST); file_stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL); if (file_stream == NULL) { g_object_unref (file); g_hash_table_unref (disabled); return; } g_hash_table_iter_init (&iter, disabled); data_stream = g_data_output_stream_new (G_OUTPUT_STREAM (file_stream)); /* write header, then all disabled repos line by line */ if (g_data_output_stream_put_string (data_stream, line, NULL, NULL)) { while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) && g_data_output_stream_put_string (data_stream, line, NULL, NULL) && g_data_output_stream_put_string (data_stream, "\n", NULL, NULL)); } g_object_unref (data_stream); g_object_unref (file_stream); g_object_unref (file); g_hash_table_unref (disabled); }
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = adoptGRef(response.toSoupMessage()); m_download->didReceiveResponse(response); if (response.httpStatusCode() >= 400) { downloadFailed(downloadNetworkError(ResourceError(errorDomainDownload, response.httpStatusCode(), response.url().string(), response.httpStatusText()))); return; } String suggestedFilename = response.suggestedFilename(); if (suggestedFilename.isEmpty()) { KURL url = response.url(); url.setQuery(String()); url.removeFragmentIdentifier(); suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent()); } bool overwrite; String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename.utf8().data(), overwrite); if (destinationURI.isEmpty()) { GOwnPtr<char> errorMessage(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data())); downloadFailed(downloadDestinationError(response, errorMessage.get())); return; } GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data())); GOwnPtr<GError> error; m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr())); if (!m_outputStream) { downloadFailed(downloadDestinationError(response, error->message)); return; } m_download->didCreateDestination(destinationURI); }
static void disabled_repos_free (GHashTable *table) { GHashTableIter iter; GFile *file; GFileOutputStream *os; GDataOutputStream *output; const gchar *line; g_return_if_fail (table != NULL); g_debug ("storing disabled repos in %s", PK_BACKEND_REPO_FILE); file = g_file_new_for_path (PK_BACKEND_REPO_FILE); os = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL); if (os == NULL) { g_object_unref (file); g_hash_table_unref (table); return; } g_hash_table_iter_init (&iter, table); output = g_data_output_stream_new (G_OUTPUT_STREAM (os)); /* write all disabled repos line by line */ while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) && g_data_output_stream_put_string (output, line, NULL, NULL) && g_data_output_stream_put_byte (output, '\n', NULL, NULL)); g_object_unref (output); g_object_unref (os); g_object_unref (file); g_hash_table_unref (table); }
bool gunzip_file(const char *path) { GFile *in = NULL, *out = NULL; autofree(gchar) *newpath = NULL; autofree(GFileInputStream) *fis = NULL; autofree(GFileOutputStream) *fos = NULL; autofree(GOutputStream) *cos = NULL; autofree(GZlibDecompressor) *conv = NULL; gsize ret; newpath = g_strdup(path); if (g_str_has_suffix(newpath, ".gz")) { newpath = str_replace(newpath, ".gz", ""); } in = g_file_new_for_path(path); out = g_file_new_for_path(newpath); fis = g_file_read(in, NULL, NULL); if (!fis) { return NULL; } fos = g_file_replace(out, NULL, FALSE, 0, NULL, NULL); if (!fos) { return NULL; } conv = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_GZIP); cos = g_converter_output_stream_new(G_OUTPUT_STREAM(fos), G_CONVERTER(conv)); if (!cos) { return NULL; } ret = g_output_stream_splice(cos, G_INPUT_STREAM(fis), G_OUTPUT_STREAM_SPLICE_NONE, NULL, NULL); return (ret > 0 ? true : false ); }
static gboolean write_theme_to_disk (MateThemeMetaInfo *theme_info, const gchar *theme_name, const gchar *theme_description, gboolean save_background, GError **error) { gchar* dir; gchar* theme_name_dir; GFile* tmp_file; GFile* target_file; GOutputStream* output; gchar* str; gchar* current_background; GSettings* settings; const gchar* theme_header = "" "[Desktop Entry]\n" "Name=%s\n" "Type=X-GNOME-Metatheme\n" "Comment=%s\n" "\n" "[X-GNOME-Metatheme]\n" "GtkTheme=%s\n" "MetacityTheme=%s\n" "IconTheme=%s\n"; theme_name_dir = str_remove_slash (theme_name); dir = g_build_filename (g_get_home_dir (), ".themes", theme_name_dir, "index.theme~", NULL); g_free (theme_name_dir); tmp_file = g_file_new_for_path (dir); dir [strlen (dir) - 1] = '\000'; target_file = g_file_new_for_path (dir); g_free (dir); /* start making the theme file */ str = g_strdup_printf(theme_header, theme_name, theme_description, theme_info->gtk_theme_name, theme_info->marco_theme_name, theme_info->icon_theme_name); output = G_OUTPUT_STREAM (g_file_replace (tmp_file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL)); g_output_stream_write (output, str, strlen (str), NULL, NULL); g_free (str); if (theme_info->gtk_color_scheme) { gchar *a, *tmp; tmp = g_strdup (theme_info->gtk_color_scheme); for (a = tmp; *a != '\0'; a++) if (*a == '\n') *a = ','; str = g_strdup_printf ("GtkColorScheme=%s\n", tmp); g_output_stream_write (output, str, strlen (str), NULL, NULL); g_free (str); g_free (tmp); } if (theme_info->cursor_theme_name) { #ifdef HAVE_XCURSOR str = g_strdup_printf ("CursorTheme=%s\n" "CursorSize=%i\n", theme_info->cursor_theme_name, theme_info->cursor_size); #else str = g_strdup_printf ("CursorFont=%s\n", theme_info->cursor_theme_name); #endif g_output_stream_write (output, str, strlen (str), NULL, NULL); g_free (str); } if (theme_info->notification_theme_name) { str = g_strdup_printf ("NotificationTheme=%s\n", theme_info->notification_theme_name); g_output_stream_write (output, str, strlen (str), NULL, NULL); g_free (str); } if (save_background) { settings = g_settings_new (WP_SCHEMA); current_background = g_settings_get_string (settings, WP_FILE_KEY); if (current_background != NULL) { str = g_strdup_printf ("BackgroundImage=%s\n", current_background); g_output_stream_write (output, str, strlen (str), NULL, NULL); g_free (current_background); g_free (str); } g_object_unref (settings); } g_file_move (tmp_file, target_file, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, NULL); g_output_stream_close (output, NULL, NULL); g_object_unref (tmp_file); g_object_unref (target_file); return TRUE; }
static GimpValueArray * xcf_save_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { XcfInfo info = { 0, }; GimpValueArray *return_vals; GimpImage *image; const gchar *uri; gchar *filename; GFile *file; gboolean success = FALSE; GError *my_error = NULL; gimp_set_busy (gimp); image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp); uri = g_value_get_string (gimp_value_array_index (args, 3)); #ifdef GIO_IS_FIXED file = g_file_new_for_uri (uri); #else file = g_file_new_for_path (uri); #endif filename = g_file_get_parse_name (file); info.output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, 0, NULL, &my_error)); if (info.output) { info.gimp = gimp; info.seekable = G_SEEKABLE (info.output); info.progress = progress; info.filename = filename; info.compression = COMPRESS_RLE; if (progress) { gchar *name = g_filename_display_name (filename); gchar *msg = g_strdup_printf (_("Saving '%s'"), name); gimp_progress_start (progress, msg, FALSE); g_free (msg); g_free (name); } xcf_save_choose_format (&info, image); success = xcf_save_image (&info, image, error); g_object_unref (info.output); if (progress) gimp_progress_end (progress); } else { g_propagate_prefixed_error (error, my_error, _("Could not open '%s' for writing: "), filename); } g_free (filename); g_object_unref (file); return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); gimp_unset_busy (gimp); return return_vals; }
/* Save app data lists to file */ static gboolean idle_save_application_usage (gpointer data) { ShellAppUsage *self = SHELL_APP_USAGE (data); UsageIterator iter; const char *current_context; const char *context; const char *id; UsageData *usage; GFileOutputStream *output; GOutputStream *buffered_output; GDataOutputStream *data_output; GError *error = NULL; self->save_id = 0; /* Parent directory is already created by shell-global */ output = g_file_replace (self->configfile, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error); if (!output) { g_debug ("Could not save applications usage data: %s", error->message); g_error_free (error); return FALSE; } buffered_output = g_buffered_output_stream_new (G_OUTPUT_STREAM (output)); g_object_unref (output); data_output = g_data_output_stream_new (G_OUTPUT_STREAM (buffered_output)); g_object_unref (buffered_output); if (!g_data_output_stream_put_string (data_output, "<?xml version=\"1.0\"?>\n<application-state>\n", NULL, &error)) goto out; usage_iterator_init (self, &iter); current_context = NULL; while (usage_iterator_next (self, &iter, &context, &id, &usage)) { ShellApp *app; app = shell_app_system_lookup_app (shell_app_system_get_default(), id); if (!app) continue; if (context != current_context) { if (current_context != NULL) { if (!g_data_output_stream_put_string (data_output, " </context>", NULL, &error)) goto out; } current_context = context; if (!g_data_output_stream_put_string (data_output, " <context", NULL, &error)) goto out; if (!write_attribute_string (data_output, "id", context, &error)) goto out; if (!g_data_output_stream_put_string (data_output, ">\n", NULL, &error)) goto out; } if (!g_data_output_stream_put_string (data_output, " <application", NULL, &error)) goto out; if (!write_attribute_string (data_output, "id", id, &error)) goto out; if (!write_attribute_uint (data_output, "open-window-count", shell_app_get_n_windows (app), &error)) goto out; if (!write_attribute_double (data_output, "score", usage->score, &error)) goto out; if (!write_attribute_uint (data_output, "last-seen", usage->last_seen, &error)) goto out; if (!g_data_output_stream_put_string (data_output, "/>\n", NULL, &error)) goto out; } if (current_context != NULL) { if (!g_data_output_stream_put_string (data_output, " </context>\n", NULL, &error)) goto out; } if (!g_data_output_stream_put_string (data_output, "</application-state>\n", NULL, &error)) goto out; out: if (!error) g_output_stream_close_async (G_OUTPUT_STREAM (data_output), 0, NULL, NULL, NULL); g_object_unref (data_output); if (error) { g_debug ("Could not save applications usage data: %s", error->message); g_error_free (error); } return FALSE; }
void Tetris::dragDrop(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, Tetris * t) { const char *fileuri; GError *error = NULL; GFile *file; GFile *outfile; GFileInfo *fileinfo; GFileInputStream *istream; GFileOutputStream *outstream; goffset filesize; gssize bytesread, byteswrote; GdkPixbufLoader *loader; GdkPixbuf *pixbuf; guchar *buffer; /* Accept a dropped filename and try and load it as the background image. In the event of any kind of failure we silently ignore it. */ /* FIXME: We don't handle colour gradients (e.g. from the gimp) */ /* FIXME: Dropped URLs from mozilla don't work (see below). */ if (data->length < 0) { gtk_drag_finish (context, FALSE, FALSE, time); return; } gtk_drag_finish (context, TRUE, FALSE, time); if (info == COLOUR) { if (data->length == 8) decodeColour ((guint16 *)data->data, t); return; } if (info == RESET) { resetColour (t); return; } fileuri = decodeDropData ((char *)data->data, info); /* Silently ignore bad data. */ if (fileuri == NULL) goto error_exit; /* Now that we have a URI we load it and test it to see if it is * an image file. */ file = g_file_new_for_uri (fileuri); istream = g_file_read (file, NULL, &error); if (error) goto error_exit; fileinfo = g_file_input_stream_query_info (istream, (char *)G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &error); if (error) goto error_exit_handle; filesize = g_file_info_get_size (fileinfo); buffer = (guchar *)g_malloc (filesize); if (buffer == NULL) goto error_exit_handle; bytesread = g_input_stream_read (G_INPUT_STREAM (istream), buffer, filesize, NULL, &error); /* FIXME: We should reread if not enough was read. */ if (error || (bytesread != filesize)) goto error_exit_buffer; loader = gdk_pixbuf_loader_new (); if (!gdk_pixbuf_loader_write (loader, buffer, filesize, NULL)) goto error_exit_loader; gdk_pixbuf_loader_close (loader, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf == NULL) goto error_exit_loader; g_object_ref (pixbuf); /* We now have an image file, in memory, that we know gdk-pixbuf * can handle. Now we save it to disk. This is necessary so that * "slow" URIs (e.g. http) behave well in the long run. */ outfile = g_file_new_for_path (t->bgPixmap); outstream = g_file_replace (outfile, NULL, FALSE, G_FILE_CREATE_PRIVATE, NULL, &error); if (error) goto error_exit_loader; byteswrote = g_output_stream_write (G_OUTPUT_STREAM (outstream), buffer, bytesread, NULL, &error); if (byteswrote != filesize) goto error_exit_saver; t->usebg = TRUE; t->saveBgOptions (); error_exit_saver: g_object_unref(outstream); error_exit_loader: g_object_unref (loader); error_exit_buffer: g_free (buffer); error_exit_handle: g_object_unref(istream); error_exit: if(error) g_error_free(error); return; }
static void * gio_fopen (const char * filename, const char * mode) { GError * error = 0; FileData * data = g_new0 (FileData, 1); data->file = g_file_new_for_uri (filename); switch (mode[0]) { case 'r': if (strchr (mode, '+')) { data->iostream = (GIOStream *) g_file_open_readwrite (data->file, 0, & error); CHECK_ERROR ("open", filename); data->istream = g_io_stream_get_input_stream (data->iostream); data->ostream = g_io_stream_get_output_stream (data->iostream); data->seekable = (GSeekable *) data->iostream; } else { data->istream = (GInputStream *) g_file_read (data->file, 0, & error); CHECK_ERROR ("open", filename); data->seekable = (GSeekable *) data->istream; } break; case 'w': if (strchr (mode, '+')) { data->iostream = (GIOStream *) g_file_replace_readwrite (data->file, 0, 0, 0, 0, & error); CHECK_ERROR ("open", filename); data->istream = g_io_stream_get_input_stream (data->iostream); data->ostream = g_io_stream_get_output_stream (data->iostream); data->seekable = (GSeekable *) data->iostream; } else { data->ostream = (GOutputStream *) g_file_replace (data->file, 0, 0, 0, 0, & error); CHECK_ERROR ("open", filename); data->seekable = (GSeekable *) data->ostream; } break; case 'a': if (strchr (mode, '+')) { gio_error ("Cannot open %s: GIO does not support read-and-append mode.", filename); goto FAILED; } else { data->ostream = (GOutputStream *) g_file_append_to (data->file, 0, 0, & error); CHECK_ERROR ("open", filename); data->seekable = (GSeekable *) data->ostream; } break; default: gio_error ("Cannot open %s: invalid mode.", filename); goto FAILED; } return data; FAILED: g_free (data); return 0; }
bool TextFileSaver::step() { GOutputStream *stream = NULL; // Open the file. GFile *file = g_file_new_for_uri(uri()); GFileOutputStream *fileStream = g_file_replace(file, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &m_error); if (!fileStream) { g_object_unref(file); return true; } // Open the encoding converter and setup the input stream. if (m_encoding == "UTF-8") stream = G_OUTPUT_STREAM(fileStream); else { GCharsetConverter *encodingConverter = g_charset_converter_new(m_encoding.c_str(), "UTF-8", &m_error); if (!encodingConverter) { g_object_unref(file); g_object_unref(fileStream); return true; } stream = g_converter_output_stream_new(G_OUTPUT_STREAM(fileStream), G_CONVERTER(encodingConverter)); g_object_unref(fileStream); g_object_unref(encodingConverter); } // Convert and write. int size = g_output_stream_write(stream, m_text.get(), m_length == -1 ? strlen(m_text.get()) : m_length, NULL, &m_error); if (size == -1) { g_object_unref(file); g_object_unref(stream); return true; } if (!g_output_stream_close(stream, NULL, &m_error)) { g_object_unref(file); g_object_unref(stream); return true; } g_object_unref(stream); // Get the time when the file was last modified. GFileInfo *fileInfo; fileInfo = g_file_query_info(file, G_FILE_ATTRIBUTE_TIME_MODIFIED, G_FILE_QUERY_INFO_NONE, NULL, &m_error); if (!fileInfo) { g_object_unref(file); return true; } m_modifiedTime.seconds = g_file_info_get_attribute_uint64( fileInfo, G_FILE_ATTRIBUTE_TIME_MODIFIED); g_object_unref(fileInfo); fileInfo = g_file_query_info(file, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC, G_FILE_QUERY_INFO_NONE, NULL, &m_error); if (!fileInfo) { g_object_unref(file); return true; } m_modifiedTime.microSeconds = g_file_info_get_attribute_uint32( fileInfo, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC); g_object_unref(fileInfo); g_object_unref(file); return true; }
gboolean idol_pl_parser_save_m3u (IdolPlParser *parser, IdolPlPlaylist *playlist, GFile *output, gboolean dos_compatible, GError **error) { IdolPlPlaylistIter iter; GFileOutputStream *stream; gboolean valid, success; char *buf; char *cr; stream = g_file_replace (output, NULL, FALSE, G_FILE_CREATE_NONE, NULL, error); if (stream == NULL) return FALSE; cr = dos_compatible ? "\r\n" : "\n"; buf = g_strdup_printf ("#EXTM3U%s", cr); success = idol_pl_parser_write_string (G_OUTPUT_STREAM (stream), buf, error); g_free (buf); if (success == FALSE) return FALSE; valid = idol_pl_playlist_iter_first (playlist, &iter); while (valid) { char *uri, *title, *path2; GFile *file; idol_pl_playlist_get (playlist, &iter, IDOL_PL_PARSER_FIELD_URI, &uri, IDOL_PL_PARSER_FIELD_TITLE, &title, NULL); valid = idol_pl_playlist_iter_next (playlist, &iter); if (!uri) { g_free (title); continue; } file = g_file_new_for_uri (uri); if (idol_pl_parser_scheme_is_ignored (parser, file) != FALSE) { g_object_unref (file); g_free (uri); g_free (title); continue; } g_object_unref (file); if (title) { buf = g_strdup_printf (EXTINF",%s%s", title, cr); success = idol_pl_parser_write_string (G_OUTPUT_STREAM (stream), buf, error); g_free (buf); if (success == FALSE) { g_free (title); g_free (uri); return FALSE; } } g_free (title); if (dos_compatible == FALSE) { char *tmp; tmp = idol_pl_parser_relative (output, uri); if (tmp == NULL && g_str_has_prefix (uri, "file:")) { path2 = g_filename_from_uri (uri, NULL, NULL); } else { path2 = tmp; } } else { path2 = idol_pl_parser_uri_to_dos (uri, output); } buf = g_strdup_printf ("%s%s", path2 ? path2 : uri, cr); g_free (path2); g_free (uri); success = idol_pl_parser_write_string (G_OUTPUT_STREAM (stream), buf, error); g_free (buf); if (success == FALSE) return FALSE; } g_object_unref (stream); return TRUE; }
static gboolean _save_to_uri (GESFormatter * formatter, GESTimeline * timeline, const gchar * uri, gboolean overwrite, GError ** error) { GFile *file; gboolean ret; GString *str; GOutputStream *stream; GError *lerror = NULL; g_return_val_if_fail (formatter->project, FALSE); file = g_file_new_for_uri (uri); stream = G_OUTPUT_STREAM (g_file_create (file, G_FILE_CREATE_NONE, NULL, &lerror)); if (stream == NULL) { if (overwrite && lerror->code == G_IO_ERROR_EXISTS) { g_clear_error (&lerror); stream = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &lerror)); } if (stream == NULL) goto failed_opening_file; } str = GES_BASE_XML_FORMATTER_GET_CLASS (formatter)->save (formatter, timeline, error); if (str == NULL) goto serialization_failed; ret = g_output_stream_write_all (stream, str->str, str->len, NULL, NULL, &lerror); ret = g_output_stream_close (stream, NULL, &lerror); if (ret == FALSE) GST_WARNING_OBJECT (formatter, "Could not save %s because: %s", uri, lerror->message); g_string_free (str, TRUE); gst_object_unref (file); gst_object_unref (stream); if (lerror) g_propagate_error (error, lerror); return ret; serialization_failed: gst_object_unref (file); g_output_stream_close (stream, NULL, NULL); gst_object_unref (stream); if (lerror) g_propagate_error (error, lerror); return FALSE; failed_opening_file: gst_object_unref (file); GST_WARNING_OBJECT (formatter, "Could not open %s because: %s", uri, lerror->message); if (lerror) g_propagate_error (error, lerror); return FALSE; }