static void
inf_text_gtk_viewport_set_user_table(InfTextGtkViewport* viewport,
InfUserTable* user_table)
{
InfTextGtkViewportPrivate* priv;
priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(viewport);
if(priv->user_table != NULL)
{
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->user_table),
G_CALLBACK(inf_text_gtk_viewport_add_user_cb),
viewport
);
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->user_table),
G_CALLBACK(inf_text_gtk_viewport_remove_user_cb),
viewport
);
inf_user_table_foreach_user(
priv->user_table,
inf_text_gtk_viewport_set_user_table_foreach_old_user_func,
viewport
);
g_object_unref(priv->user_table);
}
priv->user_table = user_table;
if(user_table != NULL)
{
g_object_ref(user_table);
g_signal_connect(
G_OBJECT(user_table),
"add-user",
G_CALLBACK(inf_text_gtk_viewport_add_user_cb),
viewport
);
g_signal_connect(
G_OBJECT(user_table),
"remove-user",
G_CALLBACK(inf_text_gtk_viewport_remove_user_cb),
viewport
);
inf_user_table_foreach_user(
user_table,
inf_text_gtk_viewport_set_user_table_foreach_new_user_func,
viewport
);
}
g_object_notify(G_OBJECT(viewport), "user-table");
}
static void
inf_adopted_session_synchronization_complete(InfSession* session,
InfXmlConnection* connection)
{
InfAdoptedSessionPrivate* priv;
InfSessionStatus status;
priv = INF_ADOPTED_SESSION_PRIVATE(session);
g_object_get(G_OBJECT(session), "status", &status, NULL);
INF_SESSION_CLASS(parent_class)->synchronization_complete(
session,
connection
);
if(status == INF_SESSION_SYNCHRONIZING)
{
inf_user_table_foreach_user(
inf_session_get_user_table(session),
inf_adopted_session_synchronization_complete_foreach_user_func,
NULL
);
/* Create adOPTed algorithm upon successful synchronization */
g_assert(priv->algorithm == NULL);
inf_adopted_session_create_algorithm(INF_ADOPTED_SESSION(session));
}
}
static void
inf_adopted_session_to_xml_sync(InfSession* session,
xmlNodePtr parent)
{
InfAdoptedSessionPrivate* priv;
InfAdoptedSessionToXmlSyncForeachData foreach_data;
priv = INF_ADOPTED_SESSION_PRIVATE(session);
g_assert(priv->algorithm != NULL);
INF_SESSION_CLASS(parent_class)->to_xml_sync(session, parent);
foreach_data.session = INF_ADOPTED_SESSION(session);
foreach_data.parent_xml = parent;
inf_user_table_foreach_user(
inf_session_get_user_table(session),
inf_adopted_session_to_xml_sync_foreach_user_func,
&foreach_data
);
}
static gboolean
infinoted_plugin_linekeeper_has_available_users(
InfinotedPluginLinekeeperSessionInfo* info)
{
InfinotedPluginLinekeeperHasAvailableUsersData data;
InfSession* session;
InfUserTable* user_table;
g_object_get(G_OBJECT(info->proxy), "session", &session, NULL);
user_table = inf_session_get_user_table(session);
data.has_available_user = FALSE;
data.own_user = info->user;
inf_user_table_foreach_user(
user_table,
infinoted_plugin_linekeeper_has_available_users_foreach_func,
&data
);
g_object_unref(session);
return data.has_available_user;
}
static void
infc_session_proxy_release_connection(InfcSessionProxy* proxy)
{
InfcSessionProxyPrivate* priv;
priv = INFC_SESSION_PROXY_PRIVATE(proxy);
g_assert(priv->connection != NULL);
g_assert(priv->subscription_group != NULL);
/* TODO: Emit failed signal with some "cancelled" error? */
infc_request_manager_clear(priv->request_manager);
/* Set status of all users to unavailable */
/* TODO: Keep local users available */
inf_user_table_foreach_user(
inf_session_get_user_table(priv->session),
infc_session_proxy_release_connection_foreach_user_func,
NULL
);
g_signal_handlers_disconnect_by_func(
G_OBJECT(priv->connection),
G_CALLBACK(infc_session_proxy_connection_notify_status_cb),
proxy
);
inf_session_set_subscription_group(priv->session, NULL);
inf_connection_manager_group_unref(priv->subscription_group);
priv->subscription_group = NULL;
g_object_unref(G_OBJECT(priv->connection));
priv->connection = NULL;
g_object_notify(G_OBJECT(proxy), "connection");
g_object_notify(G_OBJECT(proxy), "subscription-group");
}
static gboolean
infd_note_plugin_text_session_write(InfdStorage* storage,
InfSession* session,
const gchar* path,
gpointer user_data,
GError** error)
{
InfUserTable* table;
InfTextBuffer* buffer;
InfTextBufferIter* iter;
xmlNodePtr root;
xmlNodePtr buffer_node;
xmlNodePtr segment_node;
guint author;
gchar* content;
gsize bytes;
FILE* stream;
xmlDocPtr doc;
xmlErrorPtr xmlerror;
g_assert(INFD_IS_FILESYSTEM_STORAGE(storage));
g_assert(INF_TEXT_IS_SESSION(session));
/* Open stream before exporting buffer to XML so possible errors are
* catched earlier. */
stream = infd_filesystem_storage_open(
INFD_FILESYSTEM_STORAGE(storage),
"InfText",
path,
"w",
error
);
if(stream == NULL)
return FALSE;
root = xmlNewNode(NULL, (const xmlChar*)"inf-text-session");
buffer = INF_TEXT_BUFFER(inf_session_get_buffer(session));
table = inf_session_get_user_table(session);
inf_user_table_foreach_user(
table,
infd_note_plugin_text_session_write_foreach_user_func,
root
);
buffer_node = xmlNewChild(root, NULL, (const xmlChar*)"buffer", NULL);
iter = inf_text_buffer_create_iter(buffer);
if(iter != NULL)
{
do
{
author = inf_text_buffer_iter_get_author(buffer, iter);
content = inf_text_buffer_iter_get_text(buffer, iter);
bytes = inf_text_buffer_iter_get_bytes(buffer, iter);
segment_node = xmlNewChild(
buffer_node,
NULL,
(const xmlChar*)"segment",
NULL
);
inf_xml_util_set_attribute_uint(segment_node, "author", author);
inf_xml_util_add_child_text(segment_node, content, bytes);
g_free(content);
} while(inf_text_buffer_iter_next(buffer, iter));
inf_text_buffer_destroy_iter(buffer, iter);
}
doc = xmlNewDoc((const xmlChar*)"1.0");
xmlDocSetRootElement(doc, root);
if(xmlDocFormatDump(stream, doc, 1) == -1)
{
xmlerror = xmlGetLastError();
fclose(stream);
xmlFreeDoc(doc);
g_set_error(
error,
g_quark_from_static_string("LIBXML2_OUTPUT_ERROR"),
xmlerror->code,
"%s",
xmlerror->message
);
return FALSE;
}
fclose(stream);
xmlFreeDoc(doc);
return TRUE;
}
