From 60390ad2897bffcb47f3f9e2454dfd9cc7bd979e Mon Sep 17 00:00:00 2001 From: Mohammed Sadiq Date: Fri, 3 Jan 2020 20:03:08 +0530 Subject: [PATCH 1/3] Add chatty-settings-dialog class This has been extracted from chatty-dialogs.c and made into a separate class. --- src/chatty-settings-dialog.c | 810 +++++++++++++++++++++++++++++++ src/chatty-settings-dialog.h | 37 ++ src/chatty-window.c | 18 +- src/chatty.gresource.xml | 1 + src/meson.build | 1 + src/ui/chatty-settings-dialog.ui | 726 +++++++++++++++++++++++++++ 6 files changed, 1589 insertions(+), 4 deletions(-) create mode 100644 src/chatty-settings-dialog.c create mode 100644 src/chatty-settings-dialog.h create mode 100644 src/ui/chatty-settings-dialog.ui diff --git a/src/chatty-settings-dialog.c b/src/chatty-settings-dialog.c new file mode 100644 index 00000000..08dc629d --- /dev/null +++ b/src/chatty-settings-dialog.c @@ -0,0 +1,810 @@ +/* -*- mode: c; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* chatty-settings-dialog.c + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + * Author(s): + * Andrea Schäfer + * Mohammed Sadiq + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#define G_LOG_DOMAIN "chatty-settings-dialog" + +#include + +#include "chatty-config.h" +#include "chatty-window.h" +#include "chatty-purple-init.h" +#include "chatty-lurch.h" +#include "chatty-dialogs.h" +#include "chatty-account.h" +#include "chatty-icons.h" +#include "chatty-settings.h" +#include "chatty-settings-dialog.h" + +/** + * @short_description: Chatty settings Dialog + */ + +/* Several code has been copied from chatty-dialogs.c with modifications + * which was written by Andrea Schäfer. */ +struct _ChattySettingsDialog +{ + HdyDialog parent_instance; + + GtkWidget *add_button; + GtkWidget *save_button; + + GtkWidget *main_stack; + GtkWidget *accounts_list_box; + GtkWidget *add_account_row; + + GtkWidget *avatar_button; + GtkWidget *account_id_entry; + GtkWidget *account_protocol_label; + GtkWidget *status_label; + GtkWidget *password_entry; + GtkWidget *edit_password_button; + + GtkWidget *protocol_list; + GtkWidget *protocol_title_label; + GtkWidget *xmpp_radio_button; + GtkWidget *matrix_row; + GtkWidget *matrix_radio_button; + GtkWidget *telegram_row; + GtkWidget *telegram_radio_button; + GtkWidget *new_account_settings_list; + GtkWidget *new_account_id_entry; + GtkWidget *server_url_entry; + GtkWidget *new_password_entry; + + GtkWidget *fingerprint_list; + GtkWidget *fingerprint_device_list; + + GtkWidget *send_receipts_switch; + GtkWidget *message_carbons_row; + GtkWidget *message_carbons_switch; + GtkWidget *typing_notification_switch; + + GtkWidget *indicate_offline_switch; + GtkWidget *indicate_idle_switch; + GtkWidget *indicate_unknown_switch; + + GtkWidget *convert_smileys_switch; + GtkWidget *return_sends_switch; + + ChattySettings *settings; + PurpleAccount *selected_account; +}; + +G_DEFINE_TYPE (ChattySettingsDialog, chatty_settings_dialog, HDY_TYPE_DIALOG) + + +static void +chatty_settings_dialog_update_status (ChattySettingsDialog *self, + PurpleAccount *account) +{ + const gchar *status; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + if (purple_account_is_connected (account)) + status = _("connected"); + else if (purple_account_is_connecting (account)) + status = _("connecting…"); + else + status = _("disconnected"); + + gtk_label_set_text (GTK_LABEL (self->status_label), status); +} + +static void +chatty_account_list_clear (ChattySettingsDialog *self, + GtkListBox *list) +{ + g_autoptr(GList) children = NULL; + GList *iter; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + g_assert (GTK_IS_LIST_BOX (list)); + + children = gtk_container_get_children (GTK_CONTAINER (list)); + + for (iter = children; iter != NULL; iter = iter->next) + if ((GtkWidget *)iter->data != self->add_account_row) + gtk_container_remove (GTK_CONTAINER (list), GTK_WIDGET(iter->data)); +} + +static void +settings_update_account_details (ChattySettingsDialog *self) +{ + GdkPixbuf *pixbuf, *origin_pixbuf; + PurpleStoredImage *image; + PurpleAccount *account; + GtkWidget *avatar; + const char *account_name, *protocol_name; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + account = self->selected_account; + account_name = purple_account_get_username (account); + protocol_name = purple_account_get_protocol_name (account); + + image = purple_buddy_icons_find_account_icon (account); + avatar = gtk_image_new (); + + gtk_entry_set_text (GTK_ENTRY (self->account_id_entry), account_name); + gtk_label_set_text (GTK_LABEL (self->account_protocol_label), protocol_name); + + if (image != NULL) + { + pixbuf = chatty_icon_pixbuf_from_data (purple_imgstore_get_data (image), + purple_imgstore_get_size (image)); + + if (gdk_pixbuf_get_width (pixbuf) >= CHATTY_ICON_SIZE_LARGE || + gdk_pixbuf_get_height (pixbuf) >= CHATTY_ICON_SIZE_LARGE) + { + + origin_pixbuf = g_object_ref (pixbuf); + g_object_unref (pixbuf); + + pixbuf = gdk_pixbuf_scale_simple (origin_pixbuf, + CHATTY_ICON_SIZE_LARGE, + CHATTY_ICON_SIZE_LARGE, + GDK_INTERP_BILINEAR); + + g_object_unref (origin_pixbuf); + } + + gtk_image_set_from_pixbuf (GTK_IMAGE (avatar), chatty_icon_shape_pixbuf_circular (pixbuf)); + + g_object_unref (pixbuf); + purple_imgstore_unref (image); + } + else + { + gtk_image_set_from_icon_name (GTK_IMAGE (avatar), + "avatar-default-symbolic", + GTK_ICON_SIZE_DIALOG); + } + + gtk_button_set_image (GTK_BUTTON (self->avatar_button), + GTK_WIDGET (avatar)); +} + +static void +chatty_settings_add_clicked_cb (ChattySettingsDialog *self) +{ + PurpleAccount *account; + const char *user_id, *password, *server_url; + gboolean is_matrix, is_telegram; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + user_id = gtk_entry_get_text (GTK_ENTRY (self->new_account_id_entry)); + password = gtk_entry_get_text (GTK_ENTRY (self->new_password_entry)); + server_url = gtk_entry_get_text (GTK_ENTRY (self->server_url_entry)); + + is_matrix = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->matrix_radio_button)); + is_telegram = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->telegram_radio_button)); + + if (is_matrix) + { + account = purple_account_new (user_id, "prpl-matrix"); + purple_account_set_string (account, "home_server", server_url); + } + else if (is_telegram) + { + account = purple_account_new (user_id, "prpl-matrix"); + purple_account_set_string (account, "password-two-factor", password); + } + else /* XMPP */ + { + g_autofree char *name = NULL; + const gchar *url_prefix = NULL; + + if (server_url && *server_url) + url_prefix = "@"; + + name = g_strconcat (user_id, url_prefix, server_url, NULL); + account = purple_account_new (name, "prpl-matrix"); + } + + if (!is_telegram && password && *password) + { + purple_account_set_password (account, password); + purple_account_set_remember_password (account, TRUE); + } + + purple_account_set_enabled (account, CHATTY_UI, TRUE); + purple_accounts_add (account); + + gtk_widget_hide (self->add_button); + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), "main-settings"); +} + +static void +chatty_settings_save_clicked_cb (ChattySettingsDialog *self) +{ + GtkEntry *password_entry; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + purple_account_set_username (self->selected_account, + gtk_entry_get_text (GTK_ENTRY (self->account_id_entry))); + + password_entry = (GtkEntry *)self->password_entry; + purple_account_set_password (self->selected_account, + gtk_entry_get_text (password_entry)); + + purple_account_set_remember_password (self->selected_account, TRUE); + purple_account_set_enabled (self->selected_account, CHATTY_UI, TRUE); + + gtk_widget_hide (self->save_button); + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), "main-settings"); +} + +static void +settings_update_new_account_view (ChattySettingsDialog *self) +{ + PurplePlugin *protocol; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + gtk_entry_set_text (GTK_ENTRY (self->new_account_id_entry), ""); + gtk_entry_set_text (GTK_ENTRY (self->new_password_entry), ""); + gtk_entry_set_text (GTK_ENTRY (self->server_url_entry), ""); + + self->selected_account = NULL; + gtk_widget_grab_focus (self->new_account_id_entry); + gtk_widget_show (self->add_button); + + protocol = purple_find_prpl ("prpl-matrix"); + gtk_widget_set_visible (self->matrix_row, protocol != NULL); + + protocol = purple_find_prpl ("prpl-telegram"); + gtk_widget_set_visible (self->telegram_row, protocol != NULL); + + if (gtk_widget_get_visible (self->matrix_row) || + gtk_widget_get_visible (self->telegram_row)) + { + gtk_label_set_text (GTK_LABEL (self->protocol_title_label), _("Select Protocol")); + gtk_widget_show (self->protocol_list); + } + else + { + gtk_label_set_text (GTK_LABEL (self->protocol_title_label), _("Add XMPP account")); + gtk_widget_hide (self->protocol_list); + } + + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), "add-account-view"); +} + +static void +account_list_row_activated_cb (ChattySettingsDialog *self, + GtkListBoxRow *row, + GtkListBox *box) +{ + chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); + chatty_purple_data_t *chatty_purple = chatty_get_purple_data (); + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + g_assert (GTK_IS_LIST_BOX_ROW (row)); + g_assert (GTK_IS_LIST_BOX (box)); + + gtk_widget_set_sensitive (self->add_button, FALSE); + gtk_widget_set_sensitive (self->save_button, FALSE); + gtk_widget_set_sensitive (self->password_entry, FALSE); + + if (GTK_WIDGET (row) == self->add_account_row) + { + settings_update_new_account_view (self); + } + else + { + const gchar *protocol_id; + + gtk_widget_show (self->save_button); + self->selected_account = g_object_get_data (G_OBJECT (row), "row-account"); + g_assert (self->selected_account != NULL); + + chatty_settings_dialog_update_status (self, self->selected_account); + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), + "edit-account-view"); + + protocol_id = purple_account_get_protocol_id (self->selected_account); + + if (chatty_purple->plugin_lurch_loaded && + g_strcmp0 (protocol_id, "prpl-jabber") == 0) + { + gtk_widget_show (GTK_WIDGET (chatty_dialog->omemo.listbox_fp_own)); + gtk_widget_show (GTK_WIDGET (chatty_dialog->omemo.listbox_fp_own_dev)); + chatty_lurch_get_fp_list_own (self->selected_account); + } + + settings_update_account_details (self); + } +} + +static void +settings_message_carbons_changed_cb (ChattySettingsDialog *self) +{ + gboolean active; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + active = gtk_switch_get_active (GTK_SWITCH (self->message_carbons_switch)); + purple_prefs_set_bool (CHATTY_PREFS_ROOT "/plugins/message_carbons", active); + + if (active) + chatty_purple_load_plugin ("core-riba-carbons"); + else + chatty_purple_unload_plugin ("core-riba-carbons"); +} + +static void +chatty_settings_back_clicked_cb (ChattySettingsDialog *self) +{ + const gchar *visible_child; + + visible_child = gtk_stack_get_visible_child_name (GTK_STACK (self->main_stack)); + + if (g_str_equal (visible_child, "main-settings")) + { + gtk_widget_hide (GTK_WIDGET (self)); + } + else + { + gtk_widget_hide (self->add_button); + gtk_widget_hide (self->save_button); + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), "main-settings"); + } +} + +static char * +settings_show_dialog_load_avatar (void) +{ + GtkFileChooserNative *dialog; + GtkWindow *window; + char *file_name = NULL; + int response; + + window = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); + + dialog = gtk_file_chooser_native_new (_("Set Avatar"), + window, + GTK_FILE_CHOOSER_ACTION_OPEN, + _("Open"), + _("Cancel")); + + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog), getenv ("HOME")); + + // TODO: add preview widget when available in portrait mode + + response = gtk_native_dialog_run (GTK_NATIVE_DIALOG(dialog)); + + if (response == GTK_RESPONSE_ACCEPT) + file_name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog)); + + g_object_unref (dialog); + + return file_name; +} + +static void +settings_avatar_button_clicked_cb (ChattySettingsDialog *self) +{ + g_autofree char *file_name = NULL; + g_autoptr(GError) error = NULL; + + file_name = settings_show_dialog_load_avatar (); + + if (file_name) + { + PurplePluginProtocolInfo *prpl_info; + GdkPixbuf *pixbuf, *origin_pixbuf; + GtkWidget *avatar; + const char *protocol_id; + guchar *buffer; + size_t len; + + protocol_id = purple_account_get_protocol_id (self->selected_account); + prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO (purple_find_prpl (protocol_id)); + + buffer = chatty_icon_get_data_from_pixbuf (file_name, prpl_info, &len); + + purple_buddy_icons_set_account_icon (self->selected_account, buffer, len); + + pixbuf = gdk_pixbuf_new_from_file (file_name, &error); + + if (error != NULL) + { + g_error ("Could not create pixbuf from file: %s", error->message); + return; + } + + avatar = gtk_image_new (); + + if (gdk_pixbuf_get_width (pixbuf) >= CHATTY_ICON_SIZE_LARGE || + gdk_pixbuf_get_height (pixbuf) >= CHATTY_ICON_SIZE_LARGE) + { + + origin_pixbuf = g_object_ref (pixbuf); + + g_object_unref (pixbuf); + + pixbuf = gdk_pixbuf_scale_simple (origin_pixbuf, + CHATTY_ICON_SIZE_LARGE, + CHATTY_ICON_SIZE_LARGE, + GDK_INTERP_BILINEAR); + + g_object_unref (origin_pixbuf); + } + + gtk_image_set_from_pixbuf (GTK_IMAGE (avatar), chatty_icon_shape_pixbuf_circular (pixbuf)); + gtk_button_set_image (GTK_BUTTON (self->avatar_button), GTK_WIDGET (avatar)); + + g_object_unref (pixbuf); + } +} + +static void +settings_account_id_changed_cb (ChattySettingsDialog *self, + GtkEntry *account_id_entry) +{ + const gchar *id; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + g_assert (GTK_IS_ENTRY (account_id_entry)); + + id = gtk_entry_get_text (account_id_entry); + + gtk_widget_set_sensitive (self->add_button, id && *id); +} + +static void +settings_edit_password_clicked_cb (ChattySettingsDialog *self) +{ + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + gtk_widget_set_sensitive (self->save_button, TRUE); + gtk_widget_set_sensitive (self->password_entry, TRUE); + gtk_widget_grab_focus (self->password_entry); +} + +static void chatty_settings_dialog_popuplate_account_list (ChattySettingsDialog *self); + +static void +settings_delete_account_clicked_cb (ChattySettingsDialog *self) +{ + PurpleAccount *account; + GtkWidget *dialog; + int response; + + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + + account = self->selected_account; + dialog = gtk_message_dialog_new ((GtkWindow*)self, + GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK_CANCEL, + _("Delete Account")); + + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("Delete account %s?"), + purple_account_get_username (account)); + + gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL); + gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ON_PARENT); + + response = gtk_dialog_run (GTK_DIALOG(dialog)); + + if (response == GTK_RESPONSE_OK) + { + self->selected_account = NULL; + purple_accounts_delete (account); + + chatty_settings_dialog_popuplate_account_list (self); + gtk_widget_hide (self->save_button); + gtk_stack_set_visible_child_name (GTK_STACK (self->main_stack), "main-settings"); + } + + gtk_widget_destroy (dialog); +} + +static void +settings_protocol_changed_cb (ChattySettingsDialog *self, + GtkWidget *button) +{ + g_assert (CHATTY_IS_SETTINGS_DIALOG (self)); + g_assert (GTK_IS_TOGGLE_BUTTON (button)); + + /* Show URL entry for non-Telegram accounts */ + gtk_widget_set_visible (self->server_url_entry, button != self->telegram_radio_button); + + if (button == self->xmpp_radio_button) + gtk_entry_set_text (GTK_ENTRY (self->server_url_entry), ""); + else if (button == self->matrix_radio_button) + gtk_entry_set_text (GTK_ENTRY (self->server_url_entry), "https://chat.librem.one"); + + gtk_widget_grab_focus (self->account_id_entry); +} + +static void +account_enabled_changed_cb (GtkListBoxRow *row, + GParamSpec *pspec, + GtkSwitch *enabled_switch) +{ + PurpleAccount *account; + gboolean enabled; + + g_assert (GTK_IS_LIST_BOX_ROW (row)); + g_assert (GTK_IS_SWITCH (enabled_switch)); + + account = g_object_get_data (G_OBJECT (row), "row-account"); + enabled = gtk_switch_get_active (enabled_switch); + + purple_account_set_enabled (account, CHATTY_UI, enabled); +} + +static GtkWidget * +chatty_account_row_new (PurpleAccount *account) +{ + HdyActionRow *row; + GtkWidget *account_enabled_switch; + const gchar *protocol_id; + GtkWidget *spinner; + + row = hdy_action_row_new (); + gtk_widget_show (GTK_WIDGET (row)); + g_object_set_data (G_OBJECT(row), + "row-account", + (gpointer) account); + + protocol_id = purple_account_get_protocol_id (account); + + if ((g_strcmp0 (protocol_id, "prpl-jabber")) != 0 && + (g_strcmp0 (protocol_id, "prpl-matrix")) != 0 && + (g_strcmp0 (protocol_id, "prpl-telegram")) != 0 && + (g_strcmp0 (protocol_id, "prpl-delta")) != 0 && + (g_strcmp0 (protocol_id, "prpl-threepl")) != 0 && + (g_strcmp0 (protocol_id, "prpl-mm-sms")) != 0) + return NULL; + + spinner = gtk_spinner_new (); + gtk_widget_show (spinner); + hdy_action_row_add_prefix (row, spinner); + + g_object_set_data (G_OBJECT(row), + "row-prefix", + (gpointer)spinner); + + account_enabled_switch = gtk_switch_new (); + gtk_widget_show (account_enabled_switch); + + g_object_set (G_OBJECT(account_enabled_switch), + "valign", GTK_ALIGN_CENTER, + "halign", GTK_ALIGN_END, + NULL); + + gtk_switch_set_state (GTK_SWITCH(account_enabled_switch), + purple_account_get_enabled (account, CHATTY_UI)); + + g_signal_connect_object (account_enabled_switch, + "notify::active", + G_CALLBACK(account_enabled_changed_cb), + (gpointer) row, + G_CONNECT_SWAPPED); + + hdy_action_row_set_title (row, purple_account_get_username (account)); + hdy_action_row_set_subtitle (row, purple_account_get_protocol_name (account)); + hdy_action_row_add_action (row, account_enabled_switch); + hdy_action_row_set_activatable_widget (row, NULL); + + return GTK_WIDGET (row); +} + +static void +chatty_settings_dialog_popuplate_account_list (ChattySettingsDialog *self) +{ + gint index = 0; + + chatty_account_list_clear (self, GTK_LIST_BOX (self->accounts_list_box)); + + for (GList *l = purple_accounts_get_all (); l != NULL; l = l->next) { + GtkWidget *row; + const gchar *protocol_id; + + protocol_id = purple_account_get_protocol_id ((PurpleAccount *)l->data); + + if (g_strcmp0 (protocol_id, "prpl-mm-sms") == 0) + continue; + + row = chatty_account_row_new (l->data); + + if (!row) + continue; + + gtk_list_box_insert (GTK_LIST_BOX (self->accounts_list_box), row, index); + index++; + } +} + +static void +chatty_settings_dialog_constructed (GObject *object) +{ + ChattySettingsDialog *self = (ChattySettingsDialog *)object; + ChattySettings *settings; + chatty_data_t *chatty; + chatty_dialog_data_t *chatty_dialog; + + G_OBJECT_CLASS (chatty_settings_dialog_parent_class)->constructed (object); + + chatty = chatty_get_data (); + chatty_dialog = chatty_get_dialog_data (); + + settings = chatty_settings_get_default (); + self->settings = g_object_ref (settings); + chatty->list_manage_account = GTK_LIST_BOX (self->accounts_list_box); + + chatty_dialog->omemo.listbox_fp_own = GTK_LIST_BOX (self->fingerprint_list); + chatty_dialog->omemo.listbox_fp_own_dev = GTK_LIST_BOX (self->fingerprint_device_list); + + g_object_bind_property (settings, "send-receipts", + self->send_receipts_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + g_object_bind_property (settings, "send-typing", + self->typing_notification_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + + g_object_bind_property (settings, "greyout-offline-buddies", + self->indicate_offline_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + g_object_bind_property (settings, "blur-idle-buddies", + self->indicate_idle_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + g_object_bind_property (settings, "indicate-unknown-contacts", + self->indicate_unknown_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + + g_object_bind_property (settings, "convert-emoticons", + self->convert_smileys_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + g_object_bind_property (settings, "return-sends-message", + self->return_sends_switch, "active", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); + + chatty_settings_dialog_popuplate_account_list (self); +} + +static void +chatty_settings_dialog_finalize (GObject *object) +{ + ChattySettingsDialog *self = (ChattySettingsDialog *)object; + chatty_data_t *chatty; + + chatty = chatty_get_data (); + + g_clear_object (&self->settings); + chatty->list_manage_account = NULL; + + G_OBJECT_CLASS (chatty_settings_dialog_parent_class)->finalize (object); +} + +static void +chatty_settings_dialog_class_init (ChattySettingsDialogClass *klass) +{ + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->constructed = chatty_settings_dialog_constructed; + object_class->finalize = chatty_settings_dialog_finalize; + + gtk_widget_class_set_template_from_resource (widget_class, + "/sm/puri/chatty/" + "ui/chatty-settings-dialog.ui"); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, add_button); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, save_button); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, main_stack); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, accounts_list_box); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, add_account_row); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, avatar_button); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, account_id_entry); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, account_protocol_label); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, status_label); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, password_entry); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, edit_password_button); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, protocol_list); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, protocol_title_label); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, xmpp_radio_button); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, matrix_row); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, matrix_radio_button); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, telegram_row); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, telegram_radio_button); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, new_account_settings_list); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, new_account_id_entry); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, server_url_entry); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, new_password_entry); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, fingerprint_list); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, fingerprint_device_list); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, send_receipts_switch); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, message_carbons_row); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, message_carbons_switch); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, typing_notification_switch); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, indicate_offline_switch); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, indicate_idle_switch); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, indicate_unknown_switch); + + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, convert_smileys_switch); + gtk_widget_class_bind_template_child (widget_class, ChattySettingsDialog, return_sends_switch); + + gtk_widget_class_bind_template_callback (widget_class, chatty_settings_add_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, chatty_settings_save_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, account_list_row_activated_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_message_carbons_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, chatty_settings_back_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_avatar_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_account_id_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_edit_password_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_delete_account_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, settings_protocol_changed_cb); +} + +static void +chatty_settings_dialog_init (ChattySettingsDialog *self) +{ + chatty_purple_data_t *chatty_purple; + + gtk_widget_init_template (GTK_WIDGET (self)); + + gtk_list_box_set_header_func (GTK_LIST_BOX (self->accounts_list_box), + hdy_list_box_separator_header, NULL, NULL); + gtk_list_box_set_header_func (GTK_LIST_BOX (self->fingerprint_list), + hdy_list_box_separator_header, NULL, NULL); + gtk_list_box_set_header_func (GTK_LIST_BOX (self->fingerprint_device_list), + hdy_list_box_separator_header, NULL, NULL); + + gtk_list_box_set_header_func (GTK_LIST_BOX (self->protocol_list), + hdy_list_box_separator_header, NULL, NULL); + gtk_list_box_set_header_func (GTK_LIST_BOX (self->new_account_settings_list), + hdy_list_box_separator_header, NULL, NULL); + + chatty_purple = chatty_get_purple_data (); + gtk_widget_set_visible (self->message_carbons_row, + chatty_purple->plugin_carbons_available); + gtk_switch_set_state (GTK_SWITCH (self->message_carbons_switch), + chatty_purple->plugin_carbons_loaded); +} + +GtkWidget * +chatty_settings_dialog_new (GtkWindow *parent_window) +{ + g_return_val_if_fail (GTK_IS_WINDOW (parent_window), NULL); + + return g_object_new (CHATTY_TYPE_SETTINGS_DIALOG, + "transient-for", parent_window, + "use-header-bar", 1, + NULL); +} diff --git a/src/chatty-settings-dialog.h b/src/chatty-settings-dialog.h new file mode 100644 index 00000000..fedcd3b2 --- /dev/null +++ b/src/chatty-settings-dialog.h @@ -0,0 +1,37 @@ +/* -*- mode: c; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* chatty-settings-dialog.h + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + * Author(s): + * Mohammed Sadiq + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#pragma once + +#define HANDY_USE_UNSTABLE_API +#include + +G_BEGIN_DECLS + +#define CHATTY_TYPE_SETTINGS_DIALOG (chatty_settings_dialog_get_type()) +G_DECLARE_FINAL_TYPE (ChattySettingsDialog, chatty_settings_dialog, CHATTY, SETTINGS_DIALOG, HdyDialog) + +GtkWidget *chatty_settings_dialog_new (GtkWindow *parent_window); + +G_END_DECLS diff --git a/src/chatty-window.c b/src/chatty-window.c index c411fbf5..f5604120 100644 --- a/src/chatty-window.c +++ b/src/chatty-window.c @@ -10,6 +10,7 @@ #include "chatty-config.h" #include "chatty-dialogs.h" #include "chatty-window.h" +#include "chatty-settings-dialog.h" #include "chatty-message-list.h" #include "chatty-buddy-list.h" #include "chatty-conversation.h" @@ -153,6 +154,18 @@ chatty_window_show_chat_info (void) } } +static void +chatty_window_show_settings_dialog (void) +{ + GtkWindow *window; + GtkWidget *dialog; + + window = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); + dialog = chatty_settings_dialog_new (window); + gtk_dialog_run (GTK_DIALOG (dialog)); + + gtk_widget_destroy (dialog); +} void chatty_window_change_view (ChattyWindowState view) @@ -161,7 +174,7 @@ chatty_window_change_view (ChattyWindowState view) switch (view) { case CHATTY_VIEW_SETTINGS: - gtk_widget_show (GTK_WIDGET(chatty->dialog_settings)); + chatty_window_show_settings_dialog (); break; case CHATTY_VIEW_ABOUT_CHATTY: chatty_dialogs_show_dialog_about_chatty (); @@ -268,9 +281,6 @@ chatty_window_init_data (void) libpurple_init (); - // the settings dialog needs an initialized purple core - chatty->dialog_settings = chatty_dialogs_create_dialog_settings (); - // now the account-list widgets are instantiated and we can add // the SMS account if the plugin && ModemManager is present chatty_purple_check_sms_plugin (); diff --git a/src/chatty.gresource.xml b/src/chatty.gresource.xml index 27a239a2..5686a34d 100644 --- a/src/chatty.gresource.xml +++ b/src/chatty.gresource.xml @@ -5,6 +5,7 @@ ui/chatty-message-list.ui ui/chatty-message-list-popover.ui ui/chatty-dialog-settings.ui + ui/chatty-settings-dialog.ui ui/chatty-dialog-new-chat.ui ui/chatty-dialog-join-muc.ui ui/chatty-dialog-muc-info.ui diff --git a/src/meson.build b/src/meson.build index 90dad5d3..f45cc266 100644 --- a/src/meson.build +++ b/src/meson.build @@ -10,6 +10,7 @@ chatty_sources = [ 'chatty-application.c', 'chatty-window.c', 'chatty-dialogs.c', + 'chatty-settings-dialog.c', 'chatty-account.c', 'chatty-message-list.c', 'chatty-contact-row.c', diff --git a/src/ui/chatty-settings-dialog.ui b/src/ui/chatty-settings-dialog.ui new file mode 100644 index 00000000..97863ca4 --- /dev/null +++ b/src/ui/chatty-settings-dialog.ui @@ -0,0 +1,726 @@ + + + + -- GitLab From 49207deb4ed6c698eec6711474f0f53eb2e06b56 Mon Sep 17 00:00:00 2001 From: Mohammed Sadiq Date: Sat, 4 Jan 2020 11:23:06 +0530 Subject: [PATCH 2/3] remove obsolete code --- src/chatty-account.c | 29 +- src/chatty-connection.c | 12 +- src/chatty-dialogs.c | 765 ------------------------------ src/chatty-dialogs.h | 14 - src/chatty.gresource.xml | 1 - src/ui/chatty-dialog-settings.ui | 767 ------------------------------- 6 files changed, 2 insertions(+), 1586 deletions(-) delete mode 100644 src/ui/chatty-dialog-settings.ui diff --git a/src/chatty-account.c b/src/chatty-account.c index 7c26db68..42b8138f 100644 --- a/src/chatty-account.c +++ b/src/chatty-account.c @@ -42,12 +42,8 @@ static void cb_account_added (PurpleAccount *account, gpointer user_data) { - chatty_data_t *chatty = chatty_get_data (); - chatty_window_overlay_show (FALSE); - chatty_account_populate_account_list (chatty->list_manage_account, LIST_MANAGE_ACCOUNT); - if (purple_accounts_find ("SMS", "prpl-mm-sms")) { purple_account_set_enabled (account, CHATTY_UI, TRUE); } @@ -213,8 +209,6 @@ chatty_account_populate_account_list (GtkListBox *list, guint type) HdyActionRow *row; const gchar *protocol_id; - chatty_data_t *chatty = chatty_get_data (); - chatty_account_list_clear (list); for (l = purple_accounts_get_all (); l != NULL; l = l->next) { @@ -223,14 +217,6 @@ chatty_account_populate_account_list (GtkListBox *list, guint type) protocol_id = purple_account_get_protocol_id ((PurpleAccount *)l->data); switch (type) { - case LIST_MANAGE_ACCOUNT: - if (!(g_strcmp0 (protocol_id, "prpl-mm-sms") == 0)) { - chatty_account_add_to_accounts_list ((PurpleAccount *)l->data, - list, - LIST_MANAGE_ACCOUNT); - } - - break; case LIST_SELECT_MUC_ACCOUNT: if (!(g_strcmp0 (protocol_id, "prpl-mm-sms") == 0)) { chatty_account_add_to_accounts_list ((PurpleAccount *)l->data, @@ -258,20 +244,7 @@ chatty_account_populate_account_list (GtkListBox *list, guint type) } } - if (type == LIST_MANAGE_ACCOUNT) { - row = hdy_action_row_new (); - - g_object_set_data (G_OBJECT(row), - "row-new-account", - (gpointer)TRUE); - - hdy_action_row_set_title (row, _("Add new account…")); - - gtk_container_add (GTK_CONTAINER(chatty->list_manage_account), - GTK_WIDGET(row)); - - gtk_widget_show (GTK_WIDGET(row)); - } else if (type == LIST_SELECT_CHAT_ACCOUNT) { + if (type == LIST_SELECT_CHAT_ACCOUNT) { row = HDY_ACTION_ROW(gtk_list_box_get_row_at_index (list, 0)); if (row) { diff --git a/src/chatty-connection.c b/src/chatty-connection.c index 8a43f118..c9e1da59 100644 --- a/src/chatty-connection.c +++ b/src/chatty-connection.c @@ -154,8 +154,6 @@ chatty_connection_connect_progress (PurpleConnection *gc, account = purple_connection_get_account (gc); - chatty_dialogs_update_connection_status (); - if ((int)step == 2) { chatty_connection_account_spinner (account, TRUE); } @@ -168,9 +166,7 @@ chatty_connection_error_dialog (PurpleAccount *account, { GtkWidget *dialog; - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - dialog = gtk_message_dialog_new ((GtkWindow*)chatty_dialog->dialog_edit_account, + dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, @@ -230,8 +226,6 @@ chatty_connection_connected (PurpleConnection *gc) } } - chatty_dialogs_update_connection_status (); - chatty_connection_update_ui (); g_hash_table_remove (auto_reconns, account); @@ -243,8 +237,6 @@ chatty_connection_connected (PurpleConnection *gc) static void chatty_connection_disconnected (PurpleConnection *gc) { - chatty_dialogs_update_connection_status (); - chatty_connection_update_ui (); g_debug ("chatty_connection_disconnected"); @@ -394,8 +386,6 @@ chatty_connection_report_disconnect_reason (PurpleConnection *gc, purple_account_set_enabled (account, CHATTY_UI, FALSE); } - chatty_dialogs_update_connection_status (); - monitor = g_network_monitor_get_default (); if (g_network_monitor_get_connectivity (monitor) == G_NETWORK_CONNECTIVITY_FULL) { diff --git a/src/chatty-dialogs.c b/src/chatty-dialogs.c index 81c70dcd..8aebe27d 100644 --- a/src/chatty-dialogs.c +++ b/src/chatty-dialogs.c @@ -24,10 +24,8 @@ #include -static void chatty_dialogs_reset_settings_dialog (void); static void chatty_dialogs_reset_new_contact_dialog (void); static void chatty_dialogs_reset_invite_contact_dialog (void); -static void chatty_entry_set_enabled (GtkWidget *widget, gboolean state); static char *chatty_dialogs_show_dialog_load_avatar (void); static void chatty_dialogs_update_user_avatar (PurpleBuddy *buddy, const char *color); @@ -139,27 +137,12 @@ cb_dialog_delete (GtkWidget *widget, } -static void -cb_button_settings_back_clicked (GtkButton *sender, - gpointer data) -{ - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - chatty_dialogs_reset_settings_dialog (); - - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_settings, - "view-settings"); -} - - static void cb_button_new_chat_back_clicked (GtkButton *sender, gpointer data) { chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - chatty_dialogs_reset_settings_dialog (); - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_new_chat, "view-new-chat"); } @@ -171,278 +154,11 @@ cb_button_muc_info_back_clicked (GtkButton *sender, { chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - chatty_dialogs_reset_settings_dialog (); - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_muc_info, "view-muc-info"); } -static void -cb_button_delete_account_clicked (GtkButton *sender, - gpointer data) -{ - GtkWidget *dialog; - PurpleAccount *account; - int response; - - chatty_data_t *chatty = chatty_get_data (); - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - account = chatty->selected_account; - - dialog = gtk_message_dialog_new ((GtkWindow*)data, - GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, - GTK_MESSAGE_WARNING, - GTK_BUTTONS_OK_CANCEL, - _("Delete Account")); - - gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG(dialog), - _("Delete account %s?"), - purple_account_get_username (account)); - - gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL); - gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); - - response = gtk_dialog_run (GTK_DIALOG(dialog)); - - if (response == GTK_RESPONSE_OK) { - purple_accounts_delete (account); - - chatty_account_populate_account_list (chatty->list_manage_account, - LIST_MANAGE_ACCOUNT); - - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_settings, - "view-settings"); - } - - gtk_widget_destroy (dialog); -} - - -static void -cb_button_edit_pw_clicked (GtkButton *sender, - gpointer data) -{ - GtkEntry *entry_account_pwd; - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - entry_account_pwd = (GtkEntry *)data; - - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_save_account), TRUE); - gtk_widget_set_sensitive (GTK_WIDGET(entry_account_pwd), TRUE); - gtk_entry_set_text (GTK_ENTRY(entry_account_pwd), ""); - gtk_widget_grab_focus (GTK_WIDGET(entry_account_pwd)); -} - - -static void -cb_button_save_account_clicked (GtkButton *sender, - gpointer data) -{ - GtkEntry *entry_account_pwd; - - chatty_data_t *chatty = chatty_get_data (); - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_save_account), FALSE); - - chatty_entry_set_enabled (GTK_WIDGET(chatty_dialog->entry_name), FALSE); - - purple_account_set_username (chatty->selected_account, - gtk_entry_get_text (chatty_dialog->entry_name)); - - entry_account_pwd = (GtkEntry *)data; - - purple_account_set_password (chatty->selected_account, - gtk_entry_get_text (GTK_ENTRY(entry_account_pwd))); - - purple_account_set_remember_password (chatty->selected_account, TRUE); - - purple_account_set_enabled (chatty->selected_account, CHATTY_UI, TRUE); -} - - -static void -cb_radio_button_toggled (GtkWidget *button, - gpointer user_data) -{ - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - if (button == chatty_dialog->radio_button_xmpp) { - gtk_widget_show (GTK_WIDGET(chatty_dialog->entry_account_server)); - gtk_entry_set_text (chatty_dialog->entry_account_server, ""); - } else if (button == chatty_dialog->radio_button_matrix) { - gtk_widget_show (GTK_WIDGET(chatty_dialog->entry_account_server)); - gtk_entry_set_text (chatty_dialog->entry_account_server, "https://chat.librem.one"); - } else if (button == chatty_dialog->radio_button_telegram) { - gtk_widget_hide (GTK_WIDGET(chatty_dialog->entry_account_server)); - } - - gtk_widget_grab_focus (GTK_WIDGET(chatty_dialog->entry_account_name)); -} - - -void -chatty_dialogs_update_connection_status (void) -{ - GtkStack *stack; - int res; - - chatty_data_t *chatty = chatty_get_data (); - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - stack = chatty_dialog->stack_panes_settings; - - if (stack) { - res = g_strcmp0 (gtk_stack_get_visible_child_name (stack), "view-edit-account"); - } - - if (!chatty->selected_account || res) { - return; - } - - if (purple_account_is_connected (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("connected")); - } else if (purple_account_is_connecting (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("connecting…")); - } else if (purple_account_is_disconnected (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("disconnected")); - } -} - - -static void -write_account_data_into_dialog (chatty_data_t *chatty, - chatty_dialog_data_t *chatty_dialog) -{ - PurpleStoredImage *image = NULL; - GtkWidget *avatar = NULL; - GdkPixbuf *pixbuf; - GdkPixbuf *origin_pixbuf; - const char *account_name; - const char *protocol_name; - - account_name = purple_account_get_username (chatty->selected_account); - protocol_name = purple_account_get_protocol_name (chatty->selected_account); - - if (purple_account_is_connected (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("connected")); - } else if (purple_account_is_connecting (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("connecting…")); - } else if (purple_account_is_disconnected (chatty->selected_account)) { - gtk_label_set_text (chatty_dialog->label_status, _("disconnected")); - } - - gtk_entry_set_text (chatty_dialog->entry_name, account_name); - gtk_label_set_text (chatty_dialog->label_protocol, protocol_name); - - image = purple_buddy_icons_find_account_icon (chatty->selected_account); - - avatar = gtk_image_new (); - - if (image != NULL) { - pixbuf = chatty_icon_pixbuf_from_data (purple_imgstore_get_data (image), - purple_imgstore_get_size (image)); - - if (gdk_pixbuf_get_width (pixbuf) >= CHATTY_ICON_SIZE_LARGE || - gdk_pixbuf_get_height (pixbuf) >= CHATTY_ICON_SIZE_LARGE) { - - origin_pixbuf = g_object_ref (pixbuf); - - g_object_unref (pixbuf); - - pixbuf = gdk_pixbuf_scale_simple (origin_pixbuf, - CHATTY_ICON_SIZE_LARGE, - CHATTY_ICON_SIZE_LARGE, - GDK_INTERP_BILINEAR); - - g_object_unref (origin_pixbuf); - } - - gtk_image_set_from_pixbuf (GTK_IMAGE(avatar), chatty_icon_shape_pixbuf_circular (pixbuf)); - - g_object_unref (pixbuf); - purple_imgstore_unref (image); - } else { - gtk_image_set_from_icon_name (GTK_IMAGE(avatar), - "avatar-default-symbolic", - GTK_ICON_SIZE_DIALOG); - } - - gtk_button_set_image (GTK_BUTTON(chatty_dialog->button_account_avatar), - GTK_WIDGET(avatar)); -} - - -static void -cb_list_account_manage_row_activated (GtkListBox *box, - GtkListBoxRow *row, - gpointer user_data) -{ - const gchar *protocol_id; - - chatty_data_t *chatty = chatty_get_data (); - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - chatty_purple_data_t *chatty_purple = chatty_get_purple_data (); - - if (g_object_get_data (G_OBJECT (row), "row-new-account")) { - gtk_widget_grab_focus (GTK_WIDGET(chatty_dialog->entry_account_name)); - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_settings, - "view-add-account"); - } else { - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_settings, - "view-edit-account"); - chatty->selected_account = g_object_get_data (G_OBJECT (row), "row-account"); - - protocol_id = purple_account_get_protocol_id (chatty->selected_account); - - if (chatty_purple->plugin_lurch_loaded && (!g_strcmp0 (protocol_id, "prpl-jabber"))) { - - gtk_widget_show (GTK_WIDGET(chatty_dialog->omemo.listbox_fp_own)); - gtk_widget_show (GTK_WIDGET(chatty_dialog->omemo.listbox_fp_own_dev)); - - gtk_list_box_set_header_func (chatty_dialog->omemo.listbox_fp_own, - hdy_list_box_separator_header, - NULL, NULL); - - gtk_list_box_set_header_func (chatty_dialog->omemo.listbox_fp_own_dev, - hdy_list_box_separator_header, - NULL, NULL); - - chatty_lurch_get_fp_list_own (chatty->selected_account); - } - - write_account_data_into_dialog (chatty, chatty_dialog); - } -} - - -static void -chatty_entry_set_enabled (GtkWidget *widget, - gboolean state) -{ - GtkStyleContext *sc; - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - sc = gtk_widget_get_style_context (GTK_WIDGET(widget)); - - if (state) { - gtk_style_context_remove_class (sc, "entry_hide"); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->entry_name), TRUE); - } else { - gtk_style_context_add_class (sc, "entry_hide"); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->entry_name), FALSE); - } -} - - static void chatty_entry_contact_name_check (GtkEntry *entry, GtkWidget *button) @@ -487,37 +203,6 @@ cb_contact_name_delete_text (GtkEntry *entry, } -static void -cb_account_name_insert_text (GtkEntry *entry, - const gchar *text, - gint length, - gint *position, - gpointer data) -{ - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_add_account), - *position ? TRUE : FALSE); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->entry_account_pwd), - *position ? TRUE : FALSE); -} - - -static void -cb_account_name_delete_text (GtkEntry *entry, - gint start_pos, - gint end_pos, - gpointer data) -{ - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_add_account), - start_pos ? TRUE : FALSE); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->entry_account_pwd), - start_pos ? TRUE : FALSE); -} - - static void cb_invite_name_insert_text (GtkEntry *entry, const gchar *text, @@ -631,72 +316,6 @@ cb_button_invite_contact_clicked (GtkButton *sender, } -static void -cb_button_add_account_clicked (GtkButton *sender, - gpointer data) -{ - PurpleAccount *account; - GtkToggleButton *button_xmpp; - GtkToggleButton *button_matrix; - GtkToggleButton *button_telegram; - const gchar *protocol; - const gchar *user_id; - const gchar *server; - const gchar *pwd; - const gchar *setting = NULL; - const gchar *value; - g_autofree gchar *name; - - chatty_data_t *chatty = chatty_get_data (); - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - user_id = gtk_entry_get_text (GTK_ENTRY(chatty_dialog->entry_account_name)); - server = gtk_entry_get_text (GTK_ENTRY(chatty_dialog->entry_account_server)); - pwd = gtk_entry_get_text (GTK_ENTRY(chatty_dialog->entry_account_pwd)); - - button_xmpp = GTK_TOGGLE_BUTTON(chatty_dialog->radio_button_xmpp); - button_matrix = GTK_TOGGLE_BUTTON(chatty_dialog->radio_button_matrix); - button_telegram = GTK_TOGGLE_BUTTON(chatty_dialog->radio_button_telegram); - - if (gtk_toggle_button_get_active (button_xmpp) == TRUE) { - protocol = "prpl-jabber"; - name = g_strconcat (user_id, "@", server, NULL); - } else if (gtk_toggle_button_get_active (button_matrix) == TRUE) { - protocol = "prpl-matrix"; - setting = "home_server"; - name = g_strdup (user_id); - value = gtk_entry_get_text (GTK_ENTRY(chatty_dialog->entry_account_server)); - } else if (gtk_toggle_button_get_active (button_telegram) == TRUE) { - protocol = "prpl-telegram"; - setting = "password-two-factor"; - value = pwd; - name = g_strdup (user_id); - pwd = NULL; - } - - account = purple_account_new (name, protocol); - - if (pwd) { - purple_account_set_password (account, pwd); - purple_account_set_remember_password (account, TRUE); - } - - if (setting) { - purple_account_set_string (account, setting, value); - } - - chatty->selected_account = account; - - purple_account_set_enabled (account, CHATTY_UI, TRUE); - purple_accounts_add (account); - - chatty_dialogs_reset_settings_dialog (); - - gtk_stack_set_visible_child_name (chatty_dialog->stack_panes_settings, - "view-settings"); -} - - static void cb_button_edit_topic_clicked (GtkToggleButton *sender, gpointer data) @@ -763,67 +382,6 @@ cb_button_user_avatar_clicked (GtkButton *sender, } -static void -cb_button_account_avatar_clicked (GtkButton *sender, - gpointer data) -{ - PurplePluginProtocolInfo *prpl_info; - GdkPixbuf *pixbuf; - GdkPixbuf *origin_pixbuf; - GtkWidget *avatar; - guchar *buffer; - char *file_name = NULL; - size_t len; - - g_autoptr(GError) error = NULL; - - chatty_data_t *chatty = chatty_get_data (); - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - file_name = chatty_dialogs_show_dialog_load_avatar (); - - if (file_name) { - prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_find_prpl - (purple_account_get_protocol_id (chatty->selected_account))); - - buffer = chatty_icon_get_data_from_pixbuf (file_name, prpl_info, &len); - - purple_buddy_icons_set_account_icon (chatty->selected_account, buffer, len); - - pixbuf = gdk_pixbuf_new_from_file (file_name, &error); - - if (error != NULL) { - g_error ("%s Could not create pixbuf from file: %s", __func__, error->message); - return; - } - - avatar = gtk_image_new (); - - if (gdk_pixbuf_get_width (pixbuf) >= CHATTY_ICON_SIZE_LARGE || - gdk_pixbuf_get_height (pixbuf) >= CHATTY_ICON_SIZE_LARGE) { - - origin_pixbuf = g_object_ref (pixbuf); - - g_object_unref (pixbuf); - - pixbuf = gdk_pixbuf_scale_simple (origin_pixbuf, - CHATTY_ICON_SIZE_LARGE, - CHATTY_ICON_SIZE_LARGE, - GDK_INTERP_BILINEAR); - - g_object_unref (origin_pixbuf); - } - - gtk_image_set_from_pixbuf (GTK_IMAGE(avatar), chatty_icon_shape_pixbuf_circular (pixbuf)); - gtk_button_set_image (GTK_BUTTON(chatty_dialog->button_account_avatar), GTK_WIDGET(avatar)); - - g_object_unref (pixbuf); - } - - g_free (file_name); -} - - static gboolean cb_textview_key_released (GtkWidget *widget, GdkEventKey *key_event, @@ -846,44 +404,6 @@ cb_textview_key_released (GtkWidget *widget, } - - -static void -cb_empty_list (GtkWidget *child, - gpointer user_data) -{ - gtk_widget_destroy (GTK_WIDGET(child)); -} - - -static void -chatty_dialogs_reset_settings_dialog (void) -{ - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_save_account), FALSE); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->button_add_account), FALSE); - gtk_widget_set_sensitive (GTK_WIDGET(chatty_dialog->entry_account_pwd), FALSE); - - chatty_entry_set_enabled (GTK_WIDGET(chatty_dialog->entry_name), FALSE); - - gtk_entry_set_text (GTK_ENTRY(chatty_dialog->entry_account_name), ""); - gtk_entry_set_text (GTK_ENTRY(chatty_dialog->entry_account_pwd), ""); - - if (chatty_dialog->omemo.listbox_fp_own) { - gtk_container_foreach (GTK_CONTAINER (chatty_dialog->omemo.listbox_fp_own), - cb_empty_list, - NULL); - } - - if (chatty_dialog->omemo.listbox_fp_own_dev) { - gtk_container_foreach (GTK_CONTAINER (chatty_dialog->omemo.listbox_fp_own_dev), - cb_empty_list, - NULL); - } -} - - static void chatty_dialogs_reset_new_contact_dialog (void) { @@ -907,291 +427,6 @@ chatty_dialogs_reset_invite_contact_dialog (void) } -static void -chatty_dialogs_create_add_account_view (GtkBuilder *builder) -{ - PurplePlugin *protocol; - GtkWidget *dialog; - GtkWidget *button_back; - GtkWindow *window; - GtkListBox *list_protocol_sel; - GtkListBox *list_account_settings; - GtkLabel *label_protocol_sel; - HdyActionRow *action_row_matrix; - HdyActionRow *action_row_telegram; - gboolean further_protocols = FALSE; - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - button_back = GTK_WIDGET (gtk_builder_get_object (builder, "button_add_account_back")); - label_protocol_sel = GTK_LABEL (gtk_builder_get_object (builder, "label_protocol_sel")); - list_protocol_sel = GTK_LIST_BOX (gtk_builder_get_object (builder, "list_protocol_sel")); - list_account_settings = GTK_LIST_BOX (gtk_builder_get_object (builder, "list_account_settings")); - action_row_matrix = HDY_ACTION_ROW (gtk_builder_get_object (builder, "action_row_matrix")); - action_row_telegram = HDY_ACTION_ROW (gtk_builder_get_object (builder, "action_row_telegram")); - chatty_dialog->button_add_account = GTK_WIDGET (gtk_builder_get_object (builder, "button_add_account")); - chatty_dialog->radio_button_xmpp = GTK_WIDGET (gtk_builder_get_object (builder, "radio_button_xmpp")); - chatty_dialog->radio_button_matrix = GTK_WIDGET (gtk_builder_get_object (builder, "radio_button_matrix")); - chatty_dialog->radio_button_telegram = GTK_WIDGET (gtk_builder_get_object (builder, "radio_button_telegram")); - chatty_dialog->entry_account_name = GTK_ENTRY (gtk_builder_get_object (builder, "entry_add_account_id")); - chatty_dialog->entry_account_pwd = GTK_ENTRY (gtk_builder_get_object (builder, "entry_add_account_pwd")); - chatty_dialog->entry_account_server = GTK_ENTRY (gtk_builder_get_object (builder, "entry_add_server_url")); - - protocol = purple_find_prpl ("prpl-matrix"); - - if (protocol) { - gtk_widget_show (GTK_WIDGET(action_row_matrix)); - further_protocols = TRUE; - } - - protocol = purple_find_prpl ("prpl-telegram"); - - if (protocol) { - gtk_widget_show (GTK_WIDGET(action_row_telegram)); - further_protocols = TRUE; - } - - if (further_protocols) { - gtk_label_set_text (label_protocol_sel, _("Select Protocol")); - gtk_widget_show (GTK_WIDGET(list_protocol_sel)); - } - - gtk_list_box_set_header_func (list_protocol_sel, hdy_list_box_separator_header, NULL, NULL); - gtk_list_box_set_header_func (list_account_settings, hdy_list_box_separator_header, NULL, NULL); - - - g_signal_connect (G_OBJECT(chatty_dialog->radio_button_xmpp), - "toggled", - G_CALLBACK(cb_radio_button_toggled), - NULL); - - g_signal_connect (G_OBJECT(chatty_dialog->radio_button_matrix), - "toggled", - G_CALLBACK(cb_radio_button_toggled), - NULL); - - g_signal_connect (G_OBJECT(chatty_dialog->radio_button_telegram), - "toggled", - G_CALLBACK(cb_radio_button_toggled), - NULL); - - g_signal_connect_after (G_OBJECT(chatty_dialog->entry_account_name), - "insert_text", - G_CALLBACK(cb_account_name_insert_text), - NULL); - - g_signal_connect_after (G_OBJECT(chatty_dialog->entry_account_name), - "delete_text", - G_CALLBACK(cb_account_name_delete_text), - NULL); - - dialog = GTK_WIDGET (gtk_builder_get_object (builder, "dialog")); - - window = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); - gtk_window_set_transient_for (GTK_WINDOW(dialog), window); - - g_signal_connect (G_OBJECT(chatty_dialog->button_add_account), - "clicked", - G_CALLBACK (cb_button_add_account_clicked), - NULL); - - g_signal_connect (G_OBJECT(button_back), - "clicked", - G_CALLBACK (cb_button_settings_back_clicked), - NULL); -} - - -static void -chatty_dialogs_create_edit_account_view (GtkBuilder *builder) -{ - GtkWidget *button_back; - GtkWidget *button_edit_pw; - GtkWidget *button_delete; - GtkEntry *entry_account_pwd; - - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - - chatty_dialog->dialog_edit_account = GTK_WIDGET (gtk_builder_get_object (builder, "dialog")); - button_delete = GTK_WIDGET (gtk_builder_get_object (builder, "button_delete_account")); - button_edit_pw = GTK_WIDGET (gtk_builder_get_object (builder, "button_edit_pw")); - chatty_dialog->button_save_account = GTK_WIDGET (gtk_builder_get_object (builder, "button_save_account")); - button_back = GTK_WIDGET (gtk_builder_get_object (builder, "button_edit_account_back")); - chatty_dialog->button_account_avatar = GTK_WIDGET (gtk_builder_get_object (builder, "button_account_avatar")); - chatty_dialog->entry_name = GTK_ENTRY (gtk_builder_get_object (builder, "entry_account_id")); - chatty_dialog->label_protocol = GTK_LABEL (gtk_builder_get_object (builder, "label_protocol")); - chatty_dialog->label_status = GTK_LABEL (gtk_builder_get_object (builder, "label_status")); - entry_account_pwd = GTK_ENTRY (gtk_builder_get_object (builder, "entry_account_pwd")); - chatty_dialog->omemo.listbox_fp_own = GTK_LIST_BOX (gtk_builder_get_object (builder, "listbox_fp_own")); - chatty_dialog->omemo.listbox_fp_own_dev = GTK_LIST_BOX (gtk_builder_get_object (builder, "listbox_fp_own_dev")); - - g_signal_connect (G_OBJECT(button_delete), - "clicked", - G_CALLBACK (cb_button_delete_account_clicked), - (gpointer)chatty_dialog->dialog_edit_account); - - g_signal_connect (G_OBJECT(button_edit_pw), - "clicked", - G_CALLBACK (cb_button_edit_pw_clicked), - (gpointer)entry_account_pwd); - - g_signal_connect (G_OBJECT(chatty_dialog->button_save_account), - "clicked", - G_CALLBACK (cb_button_save_account_clicked), - (gpointer)entry_account_pwd); - - g_signal_connect (G_OBJECT(button_back), - "clicked", - G_CALLBACK (cb_button_settings_back_clicked), - NULL); - - g_signal_connect (G_OBJECT(chatty_dialog->button_account_avatar), - "clicked", - G_CALLBACK (cb_button_account_avatar_clicked), - NULL); -} - - -GtkWidget * -chatty_dialogs_create_dialog_settings (void) -{ - GtkBuilder *builder; - GtkWidget *dialog; - GtkWindow *window; - GtkSwitch *switch_prefs_send_receipts; - GtkSwitch *switch_prefs_message_carbons; - GtkSwitch *switch_prefs_typing_notification; - GtkSwitch *switch_prefs_indicate_offline; - GtkSwitch *switch_prefs_indicate_idle; - GtkSwitch *switch_prefs_indicate_unknown; - GtkSwitch *switch_prefs_convert_smileys; - GtkSwitch *switch_prefs_return_sends; - HdyActionRow *row_pref_message_carbons; - ChattySettings *settings; - - chatty_data_t *chatty = chatty_get_data (); - chatty_dialog_data_t *chatty_dialog = chatty_get_dialog_data (); - chatty_purple_data_t *chatty_purple = chatty_get_purple_data (); - - builder = gtk_builder_new_from_resource ("/sm/puri/chatty/ui/chatty-dialog-settings.ui"); - settings = chatty_settings_get_default (); - - dialog = GTK_WIDGET (gtk_builder_get_object (builder, "dialog")); - - chatty_dialog->stack_panes_settings = GTK_STACK (gtk_builder_get_object (builder, "stack_panes_settings")); - chatty->list_manage_account = GTK_LIST_BOX (gtk_builder_get_object (builder, "list_manage_account")); - switch_prefs_send_receipts = GTK_SWITCH (gtk_builder_get_object (builder, "pref_send_receipts")); - switch_prefs_message_carbons = GTK_SWITCH (gtk_builder_get_object (builder, "pref_message_carbons")); - row_pref_message_carbons = HDY_ACTION_ROW (gtk_builder_get_object (builder, "row_pref_message_carbons")); - switch_prefs_typing_notification = GTK_SWITCH (gtk_builder_get_object (builder, "pref_typing_notification")); - - switch_prefs_indicate_offline = GTK_SWITCH (gtk_builder_get_object (builder, "pref_indicate_offline")); - switch_prefs_indicate_idle = GTK_SWITCH (gtk_builder_get_object (builder, "pref_indicate_idle")); - switch_prefs_indicate_unknown = GTK_SWITCH (gtk_builder_get_object (builder, "pref_indicate_unknown")); - - switch_prefs_convert_smileys = GTK_SWITCH (gtk_builder_get_object (builder, "pref_convert_smileys")); - switch_prefs_return_sends = GTK_SWITCH (gtk_builder_get_object (builder, "pref_return_sends")); - - gtk_list_box_set_header_func (chatty->list_manage_account, hdy_list_box_separator_header, NULL, NULL); - - g_signal_connect (G_OBJECT(dialog), - "delete-event", - G_CALLBACK(cb_dialog_delete), - NULL); - - g_signal_connect (G_OBJECT(chatty->list_manage_account), - "row-activated", - G_CALLBACK(cb_list_account_manage_row_activated), - NULL); - - gtk_switch_set_state (switch_prefs_message_carbons, - chatty_purple->plugin_carbons_loaded); - gtk_switch_set_state (switch_prefs_send_receipts, - chatty_settings_get_send_receipts (settings)); - gtk_switch_set_state (switch_prefs_typing_notification, - chatty_settings_get_send_typing (settings)); - gtk_switch_set_state (switch_prefs_indicate_offline, - chatty_settings_get_greyout_offline_buddies (settings)); - gtk_switch_set_state (switch_prefs_indicate_idle, - chatty_settings_get_blur_idle_buddies (settings)); - gtk_switch_set_state (switch_prefs_indicate_unknown, - chatty_settings_get_indicate_unkown_contacts (settings)); - gtk_switch_set_state (switch_prefs_convert_smileys, - chatty_settings_get_convert_emoticons (settings)); - gtk_switch_set_state (switch_prefs_return_sends, - chatty_settings_get_return_sends_message (settings)); - - chatty_settings_bind_widget (settings, "send-receipts", - GTK_WIDGET(switch_prefs_send_receipts), "active"); - chatty_settings_bind_widget (settings, "send-typing", - GTK_WIDGET(switch_prefs_typing_notification), "active"); - chatty_settings_bind_widget (settings, "greyout-offline-buddies", - GTK_WIDGET(switch_prefs_indicate_offline), "active"); - chatty_settings_bind_widget (settings, "blur-idle-buddies", - GTK_WIDGET(switch_prefs_indicate_idle), "active"); - chatty_settings_bind_widget (settings, "indicate-unknown-contacts", - GTK_WIDGET(switch_prefs_indicate_unknown), "active"); - chatty_settings_bind_widget (settings, "convert-emoticons", - GTK_WIDGET(switch_prefs_convert_smileys), "active"); - chatty_settings_bind_widget (settings, "return-sends-message", - GTK_WIDGET(switch_prefs_return_sends), "active"); - - if (chatty_purple->plugin_carbons_available) { - gtk_widget_show (GTK_WIDGET(row_pref_message_carbons)); - } else { - gtk_widget_hide (GTK_WIDGET(row_pref_message_carbons)); - } - - g_signal_connect (switch_prefs_send_receipts, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_SEND_RECEIPTS); - g_signal_connect (switch_prefs_message_carbons, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_MESSAGE_CARBONS); - g_signal_connect (switch_prefs_typing_notification, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_TYPING_NOTIFICATION); - g_signal_connect (switch_prefs_indicate_offline, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_INDICATE_OFFLINE); - g_signal_connect (switch_prefs_indicate_idle, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_INDICATE_IDLE); - g_signal_connect (switch_prefs_indicate_unknown, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_INDICATE_UNKNOWN); - g_signal_connect (switch_prefs_convert_smileys, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_CONVERT_SMILEY); - g_signal_connect (switch_prefs_return_sends, - "notify::active", - G_CALLBACK(cb_switch_prefs_state_changed), - (gpointer)CHATTY_PREF_RETURN_SENDS); - - chatty_account_populate_account_list (chatty->list_manage_account, - LIST_MANAGE_ACCOUNT); - - - chatty_dialogs_create_edit_account_view (builder); - chatty_dialogs_create_add_account_view (builder); - - window = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); - gtk_window_set_transient_for (GTK_WINDOW(dialog), window); - gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); - - g_object_unref (builder); - - return dialog; -} - - GtkWidget * chatty_dialogs_create_dialog_new_chat (void) { diff --git a/src/chatty-dialogs.h b/src/chatty-dialogs.h index b3b71d97..fbc0dafa 100644 --- a/src/chatty-dialogs.h +++ b/src/chatty-dialogs.h @@ -16,29 +16,17 @@ typedef struct { GtkStack *stack_panes_settings; GtkStack *stack_panes_new_chat; GtkStack *stack_panes_muc_info; - GtkLabel *label_protocol; - GtkLabel *label_status; GtkLabel *label_libremone_hint; GtkListBox *list_select_account; GtkWidget *grid_edit_contact; - GtkWidget *dialog_edit_account; - GtkWidget *button_add_account; - GtkWidget *button_save_account; GtkWidget *button_add_contact; GtkWidget *button_add_gnome_contact; GtkWidget *button_user_avatar; - GtkWidget *button_account_avatar; GtkWidget *box_topic_frame; GtkWidget *textview_muc_topic; - GtkWidget *radio_button_xmpp; - GtkWidget *radio_button_matrix; - GtkWidget *radio_button_telegram; const char *current_topic; const char *new_topic; GtkEntry *entry_name; - GtkEntry *entry_account_name; - GtkEntry *entry_account_pwd; - GtkEntry *entry_account_server; GtkEntry *entry_contact_name; GtkEntry *entry_contact_nick; GtkEntry *entry_invite_name; @@ -55,13 +43,11 @@ typedef struct { chatty_dialog_data_t *chatty_get_dialog_data(void); -GtkWidget *chatty_dialogs_create_dialog_settings (void); GtkWidget *chatty_dialogs_create_dialog_new_chat (void); GtkWidget *chatty_dialogs_create_dialog_muc_info (void); void chatty_dialogs_show_dialog_new_contact (void); void chatty_dialogs_show_dialog_join_muc (void); void chatty_dialogs_show_dialog_user_info (ChattyConversation *chatty_conv); void chatty_dialogs_show_dialog_about_chatty (void); -void chatty_dialogs_update_connection_status (void); #endif diff --git a/src/chatty.gresource.xml b/src/chatty.gresource.xml index 5686a34d..0255cce9 100644 --- a/src/chatty.gresource.xml +++ b/src/chatty.gresource.xml @@ -4,7 +4,6 @@ ui/chatty-contact-row.ui ui/chatty-message-list.ui ui/chatty-message-list-popover.ui - ui/chatty-dialog-settings.ui ui/chatty-settings-dialog.ui ui/chatty-dialog-new-chat.ui ui/chatty-dialog-join-muc.ui diff --git a/src/ui/chatty-dialog-settings.ui b/src/ui/chatty-dialog-settings.ui deleted file mode 100644 index a9c8e22e..00000000 --- a/src/ui/chatty-dialog-settings.ui +++ /dev/null @@ -1,767 +0,0 @@ - - - - - True - False - 360 - 576 - dialog - - - True - False - - - True - False - slide-left-right - - - - Preferences - True - True - - - view-settings - - - - - Edit Account - False - True - - - False - False - True - center - - - - True - False - go-previous-symbolic - 1 - - - - - - - Save - False - True - - - - end - - - - - view-edit-account - - - - - Add Account - False - True - - - False - False - True - center - - - - True - False - go-previous-symbolic - 1 - - - - - - - Add - False - True - - - - end - - - - - view-add-account - - - - - - - - - 0 - True - True - - - True - False - False - slide-left-right - - - True - - - True - Accounts - - - True - False - True - none - - - - - - - - True - Privacy - - - Message Receipts - Confirm received messages - True - False - False - - - True - center - True - - - - - - - Message Carbon Copies - Share chat history among devices - True - False - False - - - True - center - True - - - - - - - Typing Notification - Send typing messages - True - False - False - - - True - center - True - - - - - - - - - True - Chats List - - - Indicate Offline Contacts - Grey out avatars from offline contacts - True - False - False - - - True - center - True - - - - - - - Indicate Idle Contacts - Blur avatars from offline contacts - True - False - False - - - True - center - True - - - - - - - Indicate Unknown Contacts - Color unknown contact ID red - True - False - False - - - True - center - True - - - - - - - - - True - Editor - - - Graphical Emoticons - Convert ASCII emoticons - True - False - False - - - True - center - True - - - - - - - Return = Send Message - Send message with return key - True - False - False - - - True - center - True - - - - - - - - - view-settings - - - - - True - True - never - True - True - - - True - False - fill - fill - 32 - 32 - 32 - 24 - True - 400 - - - True - vertical - False - start - True - - - True - center - False - False - False - 24 - - - True - 96 - avatar-default-symbolic - - - - - - - True - False - start - 24 - 12 - 6 - - - Account ID - 1 - True - - - - 0 - 0 - 1 - 1 - - - - - True - True - True - False - - - - 1 - 0 - 2 - 1 - - - - - Protocol - 1 - True - - - - 0 - 1 - 1 - 1 - - - - - 0 - end - True - - - 1 - 1 - 2 - 1 - - - - - Status - 1 - True - - - - 0 - 2 - 1 - 1 - - - - - 0 - end - True - - - 1 - 2 - 2 - 1 - - - - - Password - 1 - True - - - - 0 - 3 - 1 - 1 - - - - - True - password - False - True - False - - - 1 - 3 - 1 - 1 - - - - - False - 12 - center - True - - - document-edit-symbolic - 1 - True - - - - - 2 - 3 - - - - - start - 12 - Delete Account - True - True - - - 1 - 4 - - - - - - - False - False - True - Own Fingerprint - left - start - 24 - 12 - - - - - - - - - False - False - True - none - - - - - - False - False - True - Other Devices - left - start - 24 - 12 - - - - - - - - - False - False - True - none - - - - - - - - - - view-edit-account - - - - - True - True - never - True - True - - - True - False - fill - fill - 24 - 32 - 24 - 32 - True - 600 - - - True - vertical - False - start - True - - - True - False - True - Add XMPP account - left - start - 12 - - - - - - - - False - False - True - none - 24 - - - - radio_button_xmpp - XMPP - True - - - True - True - - - - - - - radio_button_matrix - Matrix - False - - - True - radio_button_xmpp - True - - - - - - - radio_button_telegram - Telegram - False - - - True - radio_button_xmpp - True - - - - - - - - > - True - False - True - none - 24 - - - - False - False - True - False - - - User ID - 1 - True - start - - - - - True - False - True - end - center - - - - - - - False - False - - False - - - Provider - 1 - True - start - - - - - True - any-xmpp-server - False - True - end - center - - - - - - - False - False - True - False - - - Password - 1 - True - start - - - - - password - True - False - True - False - end - center - - - - - - - - - - - - - view-add-account - - - - - - - - -- GitLab From 74aa069486215475366e139a546de733001b85a6 Mon Sep 17 00:00:00 2001 From: Mohammed Sadiq Date: Sat, 4 Jan 2020 11:37:21 +0530 Subject: [PATCH 3/3] connection: update account list only if non-NULL --- src/chatty-connection.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/chatty-connection.c b/src/chatty-connection.c index c9e1da59..eb70e817 100644 --- a/src/chatty-connection.c +++ b/src/chatty-connection.c @@ -122,6 +122,9 @@ chatty_connection_account_spinner (PurpleAccount *account, chatty_data_t *chatty = chatty_get_data (); + if (!chatty->list_manage_account) + return; + children = gtk_container_get_children (GTK_CONTAINER(chatty->list_manage_account)); for (iter = children; iter != NULL; iter = g_list_next (iter)) { -- GitLab