static void
remove_chat (InfcBrowser *browser,
GeditCollaborationWindowHelper *helper)
{
GtkWidget *chat;
GeditPanel *panel;
InfXmlConnection *connection;
InfcSessionProxy *proxy;
proxy = infc_browser_get_chat_session (browser);
if (proxy != NULL)
{
InfSession *session;
session = infc_session_proxy_get_session (proxy);
inf_session_close (session);
}
connection = infc_browser_get_connection (browser);
chat = GTK_WIDGET (g_object_get_data (G_OBJECT (connection),
CHAT_DATA_KEY));
if (chat != NULL)
{
panel = gedit_window_get_bottom_panel (helper->priv->window);
gedit_panel_remove_item (panel, chat);
g_object_set_data (G_OBJECT (connection), CHAT_DATA_KEY, NULL);
}
}
static void
on_synchronization_complete(InfSession* session,
InfXmlConnection* connection,
gpointer user_data)
{
InfTestGtkBrowserWindow* test;
InfAdoptedAlgorithm* algorithm;
test = (InfTestGtkBrowserWindow*)user_data;
session = infc_session_proxy_get_session(test->proxy);
algorithm = inf_adopted_session_get_algorithm(INF_ADOPTED_SESSION(session));
g_signal_connect(
G_OBJECT(algorithm),
"can-undo-changed",
G_CALLBACK(on_can_undo_changed),
test
);
g_signal_connect(
G_OBJECT(algorithm),
"can-redo-changed",
G_CALLBACK(on_can_redo_changed),
test
);
request_join(test, g_get_user_name());
}
static void
on_join_finished(InfcUserRequest* request,
InfUser* user,
gpointer user_data)
{
InfTestGtkBrowserWindow* test;
InfAdoptedSession* session;
InfAdoptedAlgorithm* algorithm;
gboolean undo;
gboolean redo;
test = (InfTestGtkBrowserWindow*)user_data;
inf_text_gtk_buffer_set_active_user(test->buffer, INF_TEXT_USER(user));
gtk_text_view_set_editable(GTK_TEXT_VIEW(test->textview), TRUE);
test->user = user;
session = INF_ADOPTED_SESSION(infc_session_proxy_get_session(test->proxy));
algorithm = inf_adopted_session_get_algorithm(session);
undo = inf_adopted_algorithm_can_undo(algorithm, INF_ADOPTED_USER(user));
redo = inf_adopted_algorithm_can_redo(algorithm, INF_ADOPTED_USER(user));
gtk_widget_set_sensitive(test->undo_button, undo);
gtk_widget_set_sensitive(test->redo_button, redo);
}
static void
on_redo_button_clicked(GtkButton* button,
gpointer user_data)
{
InfTestGtkBrowserWindow* test;
InfAdoptedSession* session;
test = (InfTestGtkBrowserWindow*)user_data;
session = INF_ADOPTED_SESSION(infc_session_proxy_get_session(test->proxy));
inf_adopted_session_redo(session, INF_ADOPTED_USER(test->user));
}
static void
inf_chat_test_subscribe_finished_cb(InfcNodeRequest* request,
const InfcBrowserIter* iter,
gpointer user_data)
{
InfTestChat* test;
InfSession* session;
test = (InfTestChat*)user_data;
printf("Subscription successful, waiting for synchronization...\n");
session = infc_session_proxy_get_session(
infc_browser_get_chat_session(test->browser));
test->buffer = INF_CHAT_BUFFER(inf_session_get_buffer(session));
/* TODO: Show backlog after during/after synchronization */
g_signal_connect_after(
G_OBJECT(session),
"receive-message",
G_CALLBACK(inf_chat_test_buffer_receive_message_cb),
test
);
g_signal_connect_after(
G_OBJECT(session),
"synchronization-complete",
G_CALLBACK(inf_chat_test_session_synchronization_complete_cb),
test
);
g_signal_connect_after(
G_OBJECT(session),
"synchronization-failed",
G_CALLBACK(inf_chat_test_session_synchronization_failed_cb),
test
);
/* This can happen when the server disables the chat without being
* shutdown. */
g_signal_connect_after(
G_OBJECT(session),
"close",
G_CALLBACK(inf_chat_test_session_close_cb),
test
);
}
static void
subscribe_chat_cb (InfcNodeRequest *infcnoderequest,
InfcBrowserIter *iter,
gpointer data)
{
InfcSessionProxy *proxy;
InfSession *session;
ChatData *cdata = (ChatData *) data;
GtkWidget *chat;
proxy = infc_browser_get_chat_session (cdata->browser);
if (proxy == NULL)
{
free_chat_data (data);
return;
}
session = infc_session_proxy_get_session (proxy);
cdata->proxy = proxy;
chat = inf_gtk_chat_new ();
cdata->chat = chat;
inf_gtk_chat_set_session (INF_GTK_CHAT (chat),
INF_CHAT_SESSION (session));
g_signal_connect_after (session,
"synchronization-failed",
G_CALLBACK (sync_failed),
data);
g_signal_connect_after (session,
"synchronization-complete",
G_CALLBACK (sync_completed),
data);
}
static void
on_subscribe_session(InfcBrowser* browser,
InfcBrowserIter* iter,
InfcSessionProxy* proxy,
gpointer user_data)
{
GtkWidget* window;
GtkWidget* scroll;
GtkWidget* textview;
GtkWidget* vbox;
GtkWidget* hbox;
GtkWidget* undo_button;
GtkWidget* redo_button;
InfSession* session;
InfTextGtkBuffer* buffer;
GtkTextBuffer* textbuffer;
InfTestGtkBrowserWindow* test;
session = infc_session_proxy_get_session(proxy);
buffer = INF_TEXT_GTK_BUFFER(inf_session_get_buffer(session));
textbuffer = inf_text_gtk_buffer_get_text_buffer(buffer);
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_widget_show(textview);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(
GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_IN
);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC
);
gtk_container_add(GTK_CONTAINER(scroll), textview);
gtk_widget_show(scroll);
undo_button = gtk_button_new_from_stock(GTK_STOCK_UNDO);
redo_button = gtk_button_new_from_stock(GTK_STOCK_REDO);
gtk_widget_set_sensitive(undo_button, FALSE);
gtk_widget_set_sensitive(redo_button, FALSE);
gtk_widget_show(undo_button);
gtk_widget_show(redo_button);
hbox = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(hbox), undo_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), redo_button, FALSE, FALSE, 0);
gtk_widget_show(hbox);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(vbox);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(
GTK_WINDOW(window),
infc_browser_iter_get_name(browser, iter)
);
gtk_window_set_default_size(GTK_WINDOW(window), 400, 400);
gtk_window_set_icon_name(GTK_WINDOW(window), "infinote");
gtk_container_set_border_width(GTK_CONTAINER(window), 6);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(window);
test = g_slice_new(InfTestGtkBrowserWindow);
test->textview = textview;
test->undo_button = undo_button;
test->redo_button = redo_button;
test->buffer = buffer;
test->proxy = proxy;
test->user = NULL;
g_signal_connect_after(
G_OBJECT(session),
"synchronization-failed",
G_CALLBACK(on_synchronization_failed),
test
);
g_signal_connect_after(
G_OBJECT(session),
"synchronization-complete",
G_CALLBACK(on_synchronization_complete),
test
);
g_signal_connect(
G_OBJECT(window),
"destroy",
G_CALLBACK(on_text_window_destroy),
test
);
g_signal_connect(
G_OBJECT(undo_button),
"clicked",
G_CALLBACK(on_undo_button_clicked),
test
);
g_signal_connect(
G_OBJECT(redo_button),
"clicked",
G_CALLBACK(on_redo_button_clicked),
test
);
}
static void
request_join(InfTestGtkBrowserWindow* test,
const gchar* user_name)
{
InfcUserRequest* request;
InfAdoptedStateVector* v;
GError* error;
GtkTextBuffer* buffer;
GtkTextMark* mark;
GtkTextIter iter;
GParameter params[3] = {
{ "name", { 0 } },
{ "vector", { 0 } },
{ "caret-position", { 0 } }
};
g_value_init(¶ms[0].value, G_TYPE_STRING);
g_value_init(¶ms[1].value, INF_ADOPTED_TYPE_STATE_VECTOR);
g_value_init(¶ms[2].value, G_TYPE_UINT);
g_value_set_static_string(¶ms[0].value, user_name);
/* Use current state vector. Infinote should already do this. */
v = inf_adopted_state_vector_copy(
inf_adopted_algorithm_get_current(
inf_adopted_session_get_algorithm(
INF_ADOPTED_SESSION(infc_session_proxy_get_session(test->proxy))
)
)
);
g_value_take_boxed(¶ms[1].value, v);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(test->textview));
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
g_value_set_uint(¶ms[2].value, gtk_text_iter_get_offset(&iter));
error = NULL;
request = infc_session_proxy_join_user(test->proxy, params, 3, &error);
/* TODO: Free GValues? */
if(request == NULL)
{
set_error(test, "Failed to request user join", error->message);
}
else
{
g_signal_connect_after(
G_OBJECT(request),
"failed",
G_CALLBACK(on_join_failed),
test
);
g_signal_connect_after(
G_OBJECT(request),
"finished",
G_CALLBACK(on_join_finished),
test
);
}
}
