static void
fetch_items(GTask* task, gpointer source, gpointer task_data, GCancellable* cancel)
{
g_assert(GT_IS_SEARCH_GAME_CONTAINER(source));
GtSearchGameContainer* self = GT_SEARCH_GAME_CONTAINER(source);
GtSearchGameContainerPrivate* priv = gt_search_game_container_get_instance_private(self);
g_assert(G_IS_CANCELLABLE(cancel));
g_assert(G_IS_TASK(task));
if (g_task_return_error_if_cancelled(task))
return;
if (utils_str_empty(priv->query))
{
g_task_return_pointer(task, NULL, NULL);
return;
}
g_assert_nonnull(task_data);
FetchItemsData* data = task_data;
g_mutex_lock(&priv->mutex);
gint64 end_time = g_get_monotonic_time() + SEARCH_DELAY;
g_cancellable_connect(cancel, G_CALLBACK(cancelled_cb), self, NULL);
while (!g_cancellable_is_cancelled(cancel))
{
if (!g_cond_wait_until(&priv->cond, &priv->mutex, end_time))
{
/* We weren't cancelled */
g_assert(!utils_str_empty(priv->query));
GError* err = NULL;
GList* items = data->offset == 0 ? gt_twitch_search_games(main_app->twitch,
priv->query, data->amount, data->offset, &err) : NULL;
if (err)
g_task_return_error(task, err);
else
g_task_return_pointer(task, items, (GDestroyNotify) gt_game_list_free);
g_mutex_unlock(&priv->mutex);
return;
}
}
/* We were cancelled */
g_assert(g_task_return_error_if_cancelled(task));
g_mutex_unlock(&priv->mutex);
}
static void taskThread(GTask * task, gpointer source,
gpointer taskData, GCancellable * cancellable)
{
TaskData *td = taskData;
gchar *q = g_uri_escape_string(td->src, NULL, TRUE);
gchar *target = g_strdup_printf(TARGET_URL,
wl_dict_lang_get_phrase(td->from),
wl_dict_lang_get_phrase(td->to), q);
g_free(q);
SoupMessage *msg = soup_message_new("GET", target);
if (msg == NULL) {
GError *error = g_error_new(G_IO_ERROR, 2,
"failed to parse URL %s", target);
g_free(target);
g_task_return_error(task, error);
return;
}
g_free(target);
static SoupSession *session = NULL;
if (session == NULL) {
session = soup_session_new();
}
if (g_task_return_error_if_cancelled(task)) {
g_object_unref(msg);
return;
}
guint status = soup_session_send_message(session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL(status)) {
g_object_unref(msg);
g_task_return_new_error(task, G_IO_ERROR, status,
"%s", soup_status_get_phrase(status));
return;
}
if (g_task_return_error_if_cancelled(task)) {
g_object_unref(msg);
return;
}
SoupMessageBody *body = NULL;
g_object_get(msg, "response-body", &body, NULL);
gchar *responseBody = g_strdup(body->data);
g_object_unref(msg);
g_task_return_pointer(task, responseBody, g_free);
}
static void
search_providers_discover_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GList *providers = NULL;
const gchar * const *system_data_dirs;
int idx;
system_data_dirs = g_get_system_data_dirs ();
for (idx = 0; system_data_dirs[idx] != NULL; idx++)
{
providers = g_list_concat (search_providers_discover_one_directory (system_data_dirs[idx], cancellable),
providers);
if (g_task_return_error_if_cancelled (task))
{
g_list_free_full (providers, g_object_unref);
return;
}
}
g_task_return_pointer (task, providers, NULL);
}
static void
get_libproxy_proxies (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GLibProxyResolver *resolver = source_object;
const gchar *uri = task_data;
GError *error = NULL;
gchar **proxies;
if (g_task_return_error_if_cancelled (task))
return;
proxies = px_proxy_factory_get_proxies (resolver->factory, uri);
if (proxies)
{
/* We always copy to be able to translate "socks" entry into
* three entries ("socks5", "socks4a", "socks4").
*/
g_task_return_pointer (task, copy_proxies (proxies), (GDestroyNotify) g_strfreev);
free_libproxy_proxies (proxies);
}
else
{
g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Proxy resolver internal error."));
g_task_return_error (task, error);
}
}
static void
create_tmp_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GbBeautifierWorkbenchAddin *self = (GbBeautifierWorkbenchAddin *)object;
g_autoptr (GTask) task = (GTask *)user_data;
g_autoptr(GError) error = NULL;
ProcessState *state;
GSubprocess *process;
GCancellable *cancellable;
g_assert (GB_IS_BEAUTIFIER_WORKBENCH_ADDIN (self));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
state = (ProcessState *)g_task_get_task_data (task);
if (NULL == (state->src_file = gb_beautifier_helper_create_tmp_file_finish (self, result, &error)))
goto fail;
if (state->command == GB_BEAUTIFIER_CONFIG_COMMAND_CLANG_FORMAT)
process = gb_beautifier_process_create_for_clang_format (self, state, error);
else
process = gb_beautifier_process_create_generic (self, state, error);
if (process != NULL)
{
if (g_task_return_error_if_cancelled (task))
g_object_unref (process);
else
{
cancellable = g_task_get_cancellable (task);
g_subprocess_communicate_utf8_async (process,
NULL,
cancellable,
process_communicate_utf8_cb,
g_steal_pointer (&task));
}
return;
}
fail:
g_task_return_error (task, g_steal_pointer (&error));
return;
}
static void
mail_printer_load_changed_cb (WebKitWebView *web_view,
WebKitLoadEvent load_event,
GTask *task)
{
AsyncContext *async_context;
/* Note: we disregard WEBKIT_LOAD_FAILED and print what we can. */
if (load_event != WEBKIT_LOAD_FINISHED)
return;
async_context = g_task_get_task_data (task);
g_return_if_fail (async_context != NULL);
/* WebKit reloads the page once more right before starting to print,
* so disconnect this handler after the first time to avoid starting
* another print operation. */
g_signal_handler_disconnect (
async_context->web_view,
async_context->load_status_handler_id);
async_context->load_status_handler_id = 0;
/* Check if we've been cancelled. */
if (g_task_return_error_if_cancelled (task)) {
return;
} else {
GSource *timeout_source;
/* Give WebKit some time to perform layouting and rendering before
* we start printing. 500ms should be enough in most cases. */
timeout_source = g_timeout_source_new (500);
g_task_attach_source (
task,
timeout_source,
(GSourceFunc) mail_printer_print_timeout_cb);
g_source_unref (timeout_source);
}
}
static void
watch_smartcards_from_driver (GTask *task,
GsdSmartcardManager *self,
WatchSmartcardsOperation *operation,
GCancellable *cancellable)
{
g_debug ("watching for smartcard events");
while (!g_cancellable_is_cancelled (cancellable)) {
gboolean watch_succeeded;
GError *error = NULL;
watch_succeeded = watch_one_event_from_driver (self, operation, cancellable, &error);
if (g_task_return_error_if_cancelled (task)) {
break;
}
if (!watch_succeeded) {
g_task_return_error (task, error);
break;
}
}
}
static void
process_communicate_utf8_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr (GSubprocess) process = (GSubprocess *)object;
g_autoptr (GTask) task = (GTask *)user_data;
g_autofree gchar *stdout_str = NULL;
g_autofree gchar *stderr_str = NULL;
g_autoptr(GError) error = NULL;
GtkSourceCompletion *completion;
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
ProcessState *state;
gboolean status;
g_assert (G_IS_SUBPROCESS (process));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
if (!g_subprocess_communicate_utf8_finish (process, result, &stdout_str, &stderr_str, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if (g_task_return_error_if_cancelled (task))
return;
state = (ProcessState *)g_task_get_task_data (task);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (state->source_view));
completion = gtk_source_view_get_completion (GTK_SOURCE_VIEW (state->source_view));
if (!ide_str_empty0 (stdout_str))
{
gtk_source_completion_block_interactive (completion);
gtk_text_buffer_begin_user_action (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark);
gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark);
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_insert (buffer, &begin, stdout_str, -1);
/* Get valid iters from marks */
gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark);
gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark);
gtk_text_buffer_select_range (buffer, &begin, &end);
g_signal_emit_by_name (state->source_view, "selection-theatric", IDE_SOURCE_VIEW_THEATRIC_EXPAND);
gtk_text_buffer_end_user_action (buffer);
gtk_source_completion_unblock_interactive (completion);
g_task_return_boolean (task, TRUE);
}
else
g_warning ("beautify plugin: output empty");
if (g_subprocess_get_if_exited (process))
{
status = g_subprocess_get_exit_status (process);
if (status != 0 &&
stderr_str != NULL &&
!ide_str_empty0 (stderr_str))
{
g_warning ("beautify plugin stderr:\n%s", stderr_str);
}
}
}
