static void
cancel (DialogData *data,
	DataFunc    done_func)
{
	if (data->cancelling)
		return;

	data->done_func = done_func;
	data->cancelling = TRUE;
	if (data->loading_list)
		g_cancellable_cancel (data->cancellable);
	else
		gth_file_list_cancel (GTH_FILE_LIST (data->file_list), cancel_done, data);
}
Beispiel #2
0
static gboolean
do_cancel_in_timeout (gpointer user_data)
{
  g_autoptr(GCancellable) cancellable = user_data;

  IDE_ENTRY;

  g_assert (G_IS_CANCELLABLE (cancellable));

  if (!g_cancellable_is_cancelled (cancellable))
    g_cancellable_cancel (cancellable);

  IDE_RETURN (G_SOURCE_REMOVE);
}
Beispiel #3
0
/**
 * pk_backend_cancel:
 */
void
pk_backend_cancel (PkBackend *backend, PkBackendJob *job)
{
	GCancellable *cancellable;
	g_return_if_fail (PK_IS_BACKEND (backend));
	g_return_if_fail (PK_IS_BACKEND_JOB (job));

	/* cancel */
	cancellable = pk_backend_job_get_cancellable (job);
	g_cancellable_cancel (cancellable);

	/* call into the backend */
	backend->priv->desc->cancel (backend, job);
}
static void
cc_date_time_panel_dispose (GObject *object)
{
  CcDateTimePanelPrivate *priv = CC_DATE_TIME_PANEL (object)->priv;

  if (priv->clock_tracker != NULL)
    {
      g_object_unref (priv->clock_tracker);
      priv->clock_tracker = NULL;
    }

  if (priv->builder)
    {
      g_object_unref (priv->builder);
      priv->builder = NULL;
    }

  if (priv->settings)
    {
      g_object_unref (priv->settings);
      priv->settings = NULL;
    }

  if (priv->date)
    {
      g_date_time_unref (priv->date);
      priv->date = NULL;
    }

  if (priv->cancellable)
    {
      g_cancellable_cancel (priv->cancellable);
      g_object_unref (priv->cancellable);
      priv->cancellable = NULL;
    }

  if (priv->dtm)
    {
      g_object_unref (priv->dtm);
      priv->dtm = NULL;
    }

  if (priv->permission)
    {
      g_object_unref (priv->permission);
      priv->permission = NULL;
    }

  G_OBJECT_CLASS (cc_date_time_panel_parent_class)->dispose (object);
}
Beispiel #5
0
void ofono_network_list_query_cancel(struct telephony_service *service, telephony_result_cb cb, void *data)
{
	struct ofono_data *od = telephony_service_get_data(service);
	struct telephony_error error;

	if (od->network_scan_cancellable) {
		g_cancellable_cancel(od->network_scan_cancellable);
		cb(NULL, data);
	}
	else {
		error.code = TELEPHONY_ERROR_INVALID_ARGUMENT;
		cb(&error, data);
	}
}
static void
name_vanished_cb (GDBusConnection            *connection,
		  const gchar                *name,
		  TotemMediaPlayerKeysPlugin *pi)
{
	if (pi->priv->proxy != NULL) {
		g_object_unref (pi->priv->proxy);
		pi->priv->proxy = NULL;
	}

	if (pi->priv->cancellable) {
		g_cancellable_cancel (pi->priv->cancellable);
	}
}
static void
impl_deactivate (PeasActivatable *plugin)
{
	TotemMediaPlayerKeysPlugin *pi = TOTEM_MEDIA_PLAYER_KEYS_PLUGIN (plugin);
	GtkWindow *window;

	if (pi->priv->cancellable_init) {
		g_cancellable_cancel (pi->priv->cancellable_init);
	}

	if (pi->priv->cancellable) {
		g_cancellable_cancel (pi->priv->cancellable);
	}

	if (pi->priv->proxy != NULL) {
		g_object_unref (pi->priv->proxy);
		pi->priv->proxy = NULL;
	}

	if (pi->priv->handler_id != 0) {
		TotemObject *totem;

		totem = g_object_get_data (G_OBJECT (plugin), "object");
		window = totem_get_main_window (totem);
		if (window == NULL)
			return;

		g_signal_handler_disconnect (G_OBJECT (window), pi->priv->handler_id);

		g_object_unref (window);
		pi->priv->handler_id = 0;
	}
	if (pi->priv->watch_id != 0) {
		g_bus_unwatch_name (pi->priv->watch_id);
		pi->priv->watch_id = 0;
	}
}
Beispiel #8
0
static void
shell_done (GitgShell *shell,
            GError    *error)
{
	if (shell->priv->error)
	{
		g_error_free (shell->priv->error);
		shell->priv->error = NULL;
	}

	if (error)
	{
		shell->priv->error = g_error_copy (error);
		gitg_io_set_exit_status (GITG_IO (shell), EXIT_FAILURE);
	}

	if (shell->priv->main_loop)
	{
		g_main_loop_quit (shell->priv->main_loop);
		g_main_loop_unref (shell->priv->main_loop);

		shell->priv->main_loop = NULL;
	}

	if (shell->priv->runners == NULL)
	{
		return;
	}

	if (shell->priv->cancellable)
	{
		g_cancellable_cancel (shell->priv->cancellable);
		g_object_unref (shell->priv->cancellable);

		shell->priv->cancellable = NULL;
	}

	/* Take over the exit code of the last runner */
	if (!error)
	{
		gitg_io_set_exit_status (GITG_IO (shell),
		                         gitg_io_get_exit_status (GITG_IO (shell->priv->last_runner)));
	}

	close_runners (shell);
	gitg_io_close (GITG_IO (shell));

	gitg_io_end (GITG_IO (shell), error);
}
/**
 * pk_cnf_sigint_handler:
 **/
static void
pk_cnf_sigint_handler (int sig)
{
	g_debug ("Handling SIGINT");

	/* restore default ASAP, as the cancel might hang */
	signal (SIGINT, SIG_DFL);

	/* hopefully, cancel client */
	g_cancellable_cancel (cancellable);

	/* kill ourselves */
	g_debug ("Retrying SIGINT");
	kill (getpid (), SIGINT);
}
Beispiel #10
0
static void
set_current_operation (TotemYouTubePlugin *self, guint tree_view, GCancellable *cancellable)
{
	/* Cancel previous searches on this tree view */
	if (self->cancellable[tree_view] != NULL)
		g_cancellable_cancel (self->cancellable[tree_view]);

	/* Make this the current cancellable action for the given tab */
	g_object_weak_ref (G_OBJECT (cancellable), (GWeakNotify) cancellable_notify_cb, self);
	self->cancellable[tree_view] = cancellable;

	/* Enable the "Cancel" button if it applies to the current tree view */
	if (self->current_tree_view == tree_view)
		gtk_widget_set_sensitive (self->cancel_button, TRUE);
}
Beispiel #11
0
gboolean
mm_port_probe_run_cancel (MMPortProbe *self)
{
    g_return_val_if_fail (MM_IS_PORT_PROBE (self), FALSE);

    if (self->priv->task) {
        mm_dbg ("(%s/%s) requested to cancel the probing",
                g_udev_device_get_subsystem (self->priv->port),
                g_udev_device_get_name (self->priv->port));
        g_cancellable_cancel (self->priv->task->cancellable);
        return TRUE;
    }

    return FALSE;
}
Beispiel #12
0
static void
gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
{
  GtkSearchEngineTracker *tracker;

  tracker = GTK_SEARCH_ENGINE_TRACKER (engine);

  g_debug ("Query stopping");

  if (tracker->priv->query && tracker->priv->query_pending)
    {
	    g_cancellable_cancel (tracker->priv->cancellable);
      tracker->priv->query_pending = FALSE;
    }
}
Beispiel #13
0
static void
decorator_cancel_active_tasks (TrackerDecorator *decorator)
{
	TrackerDecoratorPrivate *priv = decorator->priv;
	GHashTableIter iter;
	GTask *task;

	g_hash_table_iter_init (&iter, priv->tasks);

	while (g_hash_table_iter_next (&iter, NULL, (gpointer*) &task)) {
		g_cancellable_cancel (g_task_get_cancellable (task));
	}

	g_hash_table_remove_all (priv->tasks);
}
static void
photos_application_stop_miners (PhotosApplication *self)
{
  PhotosApplicationPrivate *priv = self->priv;
  GList *l;

  for (l = priv->miners_running; l != NULL; l = l->next)
    {
      GomMiner *miner = GOM_MINER (l->data);
      GCancellable *cancellable;

      cancellable = g_object_get_data (G_OBJECT (miner), "cancellable");
      g_cancellable_cancel (cancellable);
    }
}
Beispiel #15
0
static void
receive_cancel (GtkButton *button,
                struct _send_info *info)
{
	if (info->state == SEND_ACTIVE) {
		g_cancellable_cancel (info->cancellable);
		if (info->progress_bar != NULL)
			gtk_progress_bar_set_text (
				GTK_PROGRESS_BAR (info->progress_bar),
				_("Canceling..."));
		info->state = SEND_CANCELLED;
	}
	if (info->cancel_button)
		gtk_widget_set_sensitive (info->cancel_button, FALSE);
}
Beispiel #16
0
/**
 * pk_generate_pack_sigint_cb:
 **/
static void
pk_generate_pack_sigint_cb (int sig)
{
	g_debug ("Handling SIGINT");

	/* restore default */
	signal (SIGINT, SIG_DFL);

	/* cancel any tasks still running */
	g_cancellable_cancel (cancellable);

	/* kill ourselves */
	g_debug ("Retrying SIGINT");
	kill (getpid (), SIGINT);
}
/**
 * g_socket_service_stop:
 * @service: a #GSocketService
 *
 * Stops the service, i.e. stops accepting connections
 * from the added sockets when the mainloop runs.
 *
 * This call is thread-safe, so it may be called from a thread
 * handling an incoming client request.
 *
 * Since: 2.22
 */
void
g_socket_service_stop (GSocketService *service)
{
  G_LOCK (active);

  if (service->priv->active)
    {
      service->priv->active = FALSE;

      if (service->priv->outstanding_accept)
	g_cancellable_cancel (service->priv->cancellable);
    }

  G_UNLOCK (active);
}
static void
_set_current_folder (FrFileSelectorDialog *self,
		     GFile                *folder,
		     GList                *files)
{
	if (self->priv->current_operation != NULL)
		g_cancellable_cancel (self->priv->current_operation->cancellable);

	gtk_list_store_clear (GTK_LIST_STORE (GET_WIDGET ("files_liststore")));
	_update_sensitivity (self);

	self->priv->current_operation = load_data_new (self, folder);
	self->priv->current_operation->files_to_select = _g_object_list_ref (files);
	_get_folder_list (self->priv->current_operation);
}
void GThreadSafeMainLoopSource::cancel()
{
    GMutexLocker<GRecMutex> locker(m_mutex);

    // The general cancellable object should only be present if we're currently dispatching this GMainLoopSource.
    ASSERT(!m_cancellable || m_status == Dispatching);

    // The source is perhaps being cancelled in the middle of a callback dispatch.
    // Cancelling this GCancellable object will convey this information to the
    // current execution context when the callback dispatch is finished.
    g_cancellable_cancel(m_cancellable.get());
    m_cancellable = nullptr;

    GMainLoopSource::cancel();
}
static void
channel_closed_cb (TpChannel *proxy,
    const GError *error,
    gpointer user_data,
    GObject *weak_object)
{
  EmpathyTpFile *self = EMPATHY_TP_FILE (weak_object);
  gboolean cancel = GPOINTER_TO_INT (user_data);

  DEBUG ("Channel is closed, should cancel %s", cancel ? "True" : "False");

  if (self->priv->cancellable != NULL &&
      !g_cancellable_is_cancelled (self->priv->cancellable) && cancel)
    g_cancellable_cancel (self->priv->cancellable);
}
Beispiel #21
0
static void
cancel_load_basenames (GFilenameCompleter *completer)
{
  LoadBasenamesData *loader;
  
  if (completer->basename_loader)
    {
      loader = completer->basename_loader; 
      loader->completer = NULL;
      
      g_cancellable_cancel (loader->cancellable);
      
      completer->basename_loader = NULL;
    }
}
static void
nautilus_image_properties_page_finalize (GObject *object)
{
	NautilusImagePropertiesPage *page;

	page = NAUTILUS_IMAGE_PROPERTIES_PAGE (object);

	if (page->details->cancellable) {
		g_cancellable_cancel (page->details->cancellable);
		g_object_unref (page->details->cancellable);
		page->details->cancellable = NULL;
	}

	G_OBJECT_CLASS (nautilus_image_properties_page_parent_class)->finalize (object);
}
static void
place_free (Place * p)
{
  if (p->cancellable != NULL)
    {
      g_cancellable_cancel (p->cancellable);
      g_object_unref (p->cancellable);
    }

  g_clear_object (&p->icon);
  g_object_unref (p->location);
  g_free (p->display_name);

  g_slice_free (Place, p);
}
Beispiel #24
0
static int
on_window_delete_event (GtkWidget *widget,
                        GdkEvent *event,
                        gpointer user_data)
{
	TrackedTask *task = NULL;

	/* Guard against going away before we display */
	if (tracked_tasks)
		task = g_hash_table_lookup (tracked_tasks, user_data);
	if (task != NULL)
		g_cancellable_cancel (task->cancellable);

	return TRUE; /* allow window to close */
}
gboolean
rejilla_async_task_manager_foreach_active_remove (RejillaAsyncTaskManager *self,
						  RejillaAsyncFindTask func,
						  gpointer user_data)
{
	GSList *iter, *tasks = NULL;
	RejillaAsyncTaskCtx *ctx;

	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (func != NULL, FALSE);

	g_mutex_lock (self->priv->lock);

	for (iter = self->priv->active_tasks; iter; iter = iter->next) {
		ctx = iter->data;
		if (func (self, ctx->data, user_data)) {
			g_cancellable_cancel (ctx->cancel);
			tasks = g_slist_prepend (tasks, ctx);
		}
	}

	while (tasks && self->priv->active_tasks) {
		GSList *next;

		/* Now we wait for all these active tasks to be finished */
		g_cond_wait (self->priv->task_finished, self->priv->lock);

		for (iter = tasks; iter; iter = next) {
			ctx = iter->data;
			next = iter->next;

			if (g_slist_find (self->priv->active_tasks, ctx))
				continue;

			tasks = g_slist_remove (tasks, ctx);

			/* destroy it */
			if (ctx->type->destroy)
				ctx->type->destroy (self, TRUE, ctx->data);

			g_free (ctx);
		}
	}

	g_mutex_unlock (self->priv->lock);

	return TRUE;
}
void
e_mail_shell_view_private_dispose (EMailShellView *mail_shell_view)
{
	EMailShellViewPrivate *priv = mail_shell_view->priv;
	gint ii;

	/* XXX It's a little awkward to have to dig up the
	 *     shell this late in the game.  Should we just
	 *     keep a direct reference to it?  Not sure. */
	if (priv->prepare_for_quit_handler_id > 0) {
		EShellBackend *shell_backend;
		EShell *shell;

		shell_backend = E_SHELL_BACKEND (priv->mail_shell_backend);
		shell = e_shell_backend_get_shell (shell_backend);

		g_signal_handler_disconnect (
			shell, priv->prepare_for_quit_handler_id);
		priv->prepare_for_quit_handler_id = 0;
	}

	g_clear_object (&priv->mail_shell_backend);
	g_clear_object (&priv->mail_shell_content);
	g_clear_object (&priv->mail_shell_sidebar);

	for (ii = 0; ii < MAIL_NUM_SEARCH_RULES; ii++)
		g_clear_object (&priv->search_rules[ii]);

	if (priv->opening_folder != NULL) {
		g_cancellable_cancel (priv->opening_folder);
		g_clear_object (&priv->opening_folder);
	}

	if (priv->search_account_all != NULL) {
		g_object_unref (priv->search_account_all);
		priv->search_account_all = NULL;
	}

	if (priv->search_account_current != NULL) {
		g_object_unref (priv->search_account_current);
		priv->search_account_current = NULL;
	}

	if (priv->search_account_cancel != NULL) {
		g_object_unref (priv->search_account_cancel);
		priv->search_account_cancel = NULL;
	}
}
static void
caja_image_properties_page_finalize (GObject *object)
{
    CajaImagePropertiesPage *page;

    page = CAJA_IMAGE_PROPERTIES_PAGE (object);

    if (page->details->cancellable)
    {
        g_cancellable_cancel (page->details->cancellable);
        g_object_unref (page->details->cancellable);
        page->details->cancellable = NULL;
    }

    G_OBJECT_CLASS (caja_image_properties_page_parent_class)->finalize (object);
}
Beispiel #28
0
static void
streams_removed_cb (NiceAgent *agent, guint *stream_ids, gpointer user_data)
{
  NiceOutputStream *self = NICE_OUTPUT_STREAM (user_data);
  guint i;

  for (i = 0; stream_ids[i] != 0; i++) {
    if (stream_ids[i] == self->priv->stream_id) {
      /* The socket has been closed. */
      g_cancellable_cancel (self->priv->closed_cancellable);

      g_output_stream_close (G_OUTPUT_STREAM (self), NULL, NULL);
      break;
    }
  }
}
static void
bg_pictures_source_dispose (GObject *object)
{
  BgPicturesSourcePrivate *priv = BG_PICTURES_SOURCE (object)->priv;

  if (priv->cancellable)
    {
      g_cancellable_cancel (priv->cancellable);
      g_clear_object (&priv->cancellable);
    }

  g_clear_object (&priv->grl_miner);
  g_clear_object (&priv->thumb_factory);

  G_OBJECT_CLASS (bg_pictures_source_parent_class)->dispose (object);
}
Beispiel #30
0
void
mm_manager_shutdown (MMManager *self)
{
    g_return_if_fail (self != NULL);
    g_return_if_fail (MM_IS_MANAGER (self));

    /* Cancel all ongoing auth requests */
    g_cancellable_cancel (self->priv->authp_cancellable);

    g_hash_table_foreach (self->priv->devices, (GHFunc)foreach_disable, self);

    /* Disabling may take a few iterations of the mainloop, so the caller
     * has to iterate the mainloop until all devices have been disabled and
     * removed.
     */
}