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