/**
* seahorse_context_search_remote:
* @sctx: A #SeahorseContext (can be NULL)
* @search: a keyword (name, email address...) to search for
*
* Searches for the key matching @search o the remote servers
*
* Returns: The created search operation
*/
SeahorseOperation*
seahorse_context_search_remote (SeahorseContext *sctx, const gchar *search)
{
SeahorseSource *ks;
SeahorseMultiOperation *mop = NULL;
SeahorseOperation *op = NULL;
GSList *l, *names;
GHashTable *servers = NULL;
gchar *uri;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
/* Get a list of all selected key servers */
names = seahorse_gconf_get_string_list (LASTSERVERS_KEY);
if (names) {
servers = g_hash_table_new (g_str_hash, g_str_equal);
for (l = names; l; l = g_slist_next (l))
g_hash_table_insert (servers, l->data, GINT_TO_POINTER (TRUE));
}
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (seahorse_source_get_location (ks) != SEAHORSE_LOCATION_REMOTE)
continue;
if (servers) {
g_object_get (ks, "uri", &uri, NULL);
if (!g_hash_table_lookup (servers, uri)) {
g_free (uri);
continue;
}
g_free (uri);
}
if (mop == NULL && op != NULL) {
mop = seahorse_multi_operation_new ();
seahorse_multi_operation_take (mop, op);
}
op = seahorse_source_search (ks, search);
if (mop != NULL)
seahorse_multi_operation_take (mop, op);
}
seahorse_util_string_slist_free (names);
return mop ? SEAHORSE_OPERATION (mop) : op;
}
/**
* seahorse_context_refresh_auto:
* @sctx: A #SeahorseContext (can be NULL)
*
* Starts a new refresh operation and emits the "refreshing" signal
*
*/
void
seahorse_context_refresh_auto (SeahorseContext *sctx)
{
SeahorseSource *ks;
SeahorseOperation *op = NULL;
GSList *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_if_fail (SEAHORSE_IS_CONTEXT (sctx));
if (!sctx->pv->refresh_ops)
sctx->pv->refresh_ops = seahorse_multi_operation_new ();
for (l = sctx->pv->sources; l; l = g_slist_next (l)) {
ks = SEAHORSE_SOURCE (l->data);
if (seahorse_source_get_location (ks) == SEAHORSE_LOCATION_LOCAL) {
op = seahorse_source_load (ks);
g_return_if_fail (op);
seahorse_multi_operation_take (sctx->pv->refresh_ops, op);
}
}
g_signal_emit (sctx, signals[REFRESHING], 0, sctx->pv->refresh_ops);
}
void
seahorse_server_source_take_operation (SeahorseServerSource *ssrc, SeahorseOperation *op)
{
g_return_if_fail (SEAHORSE_IS_SERVER_SOURCE (ssrc));
g_return_if_fail (SEAHORSE_IS_OPERATION (op));
seahorse_multi_operation_take (ssrc->priv->mop, op);
}
/**
* seahorse_progress_status_set_operation:
* @swidget: The SeahorseWidget to add the operation to
* @operation: The operation to add
*
* Adds the operation to the widget.
*
*/
void
seahorse_progress_status_set_operation (SeahorseWidget *swidget,
SeahorseOperation *operation)
{
SeahorseOperation *prev;
/*
* Note that this is not one off, the operation is monitored until it is
* replaced, so if the operation starts up again the progress will be
* displayed
*/
g_return_if_fail (SEAHORSE_IS_WIDGET (swidget));
g_return_if_fail (SEAHORSE_IS_OPERATION (operation));
prev = SEAHORSE_OPERATION (g_object_get_data (G_OBJECT (swidget), "operation"));
if (prev) {
/* If it's the same operation, just ignore */
if (prev == operation)
return;
/* If the previous one was a multi operation, just piggy back this one in */
if (SEAHORSE_IS_MULTI_OPERATION (prev)) {
g_object_ref (operation);
seahorse_multi_operation_take (SEAHORSE_MULTI_OPERATION (prev), operation);
return;
}
/* Otherwise disconnect old progress, replace with new */
disconnect_progress (swidget, prev);
}
g_object_ref (operation);
g_object_set_data_full (G_OBJECT (swidget), "operation", operation,
(GDestroyNotify)g_object_unref);
g_signal_connect (swidget, "destroy",
G_CALLBACK (disconnect_progress), operation);
if (!seahorse_operation_is_running (operation))
operation_done (operation, swidget);
operation_progress (operation, seahorse_operation_get_message (operation),
seahorse_operation_get_progress (operation), swidget);
g_signal_connect (operation, "done", G_CALLBACK (operation_done), swidget);
g_signal_connect (operation, "progress", G_CALLBACK (operation_progress), swidget);
}
/**
* seahorse_context_retrieve_objects:
* @sctx: A #SeahorsecContext
* @ktype: The type of the keys to transfer
* @ids: The key ids to transfer
* @to: A #SeahorseSource. If NULL, it will use @ktype to find a source
*
* Copies remote objects to a local source
*
* Returns: A #SeahorseOperation
*/
SeahorseOperation*
seahorse_context_retrieve_objects (SeahorseContext *sctx, GQuark ktype,
GSList *ids, SeahorseSource *to)
{
SeahorseMultiOperation *mop = NULL;
SeahorseOperation *op = NULL;
SeahorseSource *sksrc;
GSList *sources, *l;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
if (!to) {
to = seahorse_context_find_source (sctx, ktype, SEAHORSE_LOCATION_LOCAL);
if (!to) {
/* TODO: How can we warn caller about this. Do we need to? */
g_warning ("couldn't find a local source for: %s",
g_quark_to_string (ktype));
return seahorse_operation_new_complete (NULL);
}
}
sources = seahorse_context_find_sources (sctx, ktype, SEAHORSE_LOCATION_REMOTE);
if (!sources) {
g_warning ("no sources found for type: %s", g_quark_to_string (ktype));
return seahorse_operation_new_complete (NULL);
}
for (l = sources; l; l = g_slist_next (l)) {
sksrc = SEAHORSE_SOURCE (l->data);
g_return_val_if_fail (SEAHORSE_IS_SOURCE (sksrc), NULL);
if (op != NULL) {
if (mop == NULL)
mop = seahorse_multi_operation_new ();
seahorse_multi_operation_take (mop, op);
}
/* Start a new transfer operation between the two key sources */
op = seahorse_transfer_operation_new (NULL, sksrc, to, ids);
g_return_val_if_fail (op != NULL, FALSE);
}
return mop ? SEAHORSE_OPERATION (mop) : op;
}
/**
* seahorse_context_transfer_objects:
* @sctx: The #SeahorseContext (can be NULL)
* @objects: the objects to import
* @to: a source to import to (can be NULL)
*
*
*
* Returns: A transfer operation
*/
SeahorseOperation*
seahorse_context_transfer_objects (SeahorseContext *sctx, GList *objects,
SeahorseSource *to)
{
SeahorseSource *from;
SeahorseOperation *op = NULL;
SeahorseMultiOperation *mop = NULL;
SeahorseObject *sobj;
GSList *ids = NULL;
GList *next, *l;
GQuark ktype;
if (!sctx)
sctx = seahorse_context_for_app ();
g_return_val_if_fail (SEAHORSE_IS_CONTEXT (sctx), NULL);
objects = g_list_copy (objects);
/* Sort by key source */
objects = seahorse_util_objects_sort (objects);
while (objects) {
/* break off one set (same keysource) */
next = seahorse_util_objects_splice (objects);
g_assert (SEAHORSE_IS_OBJECT (objects->data));
sobj = SEAHORSE_OBJECT (objects->data);
/* Export from this key source */
from = seahorse_object_get_source (sobj);
g_return_val_if_fail (from != NULL, FALSE);
ktype = seahorse_source_get_tag (from);
/* Find a local keysource to import to */
if (!to) {
to = seahorse_context_find_source (sctx, ktype, SEAHORSE_LOCATION_LOCAL);
if (!to) {
/* TODO: How can we warn caller about this. Do we need to? */
g_warning ("couldn't find a local source for: %s",
g_quark_to_string (ktype));
}
}
/* Make sure it's the same type */
if (ktype != seahorse_source_get_tag (to)) {
/* TODO: How can we warn caller about this. Do we need to? */
g_warning ("destination is not of type: %s",
g_quark_to_string (ktype));
}
if (to != NULL && from != to) {
if (op != NULL) {
if (mop == NULL)
mop = seahorse_multi_operation_new ();
seahorse_multi_operation_take (mop, op);
}
/* Build id list */
for (l = objects; l; l = g_list_next (l))
ids = g_slist_prepend (ids, GUINT_TO_POINTER (seahorse_object_get_id (l->data)));
ids = g_slist_reverse (ids);
/* Start a new transfer operation between the two sources */
op = seahorse_transfer_operation_new (NULL, from, to, ids);
g_return_val_if_fail (op != NULL, FALSE);
g_slist_free (ids);
ids = NULL;
}
g_list_free (objects);
objects = next;
}
/* No objects done, just return success */
if (!mop && !op) {
g_warning ("no valid objects to transfer found");
return seahorse_operation_new_complete (NULL);
}
return mop ? SEAHORSE_OPERATION (mop) : op;
}
