Yattm - unified GTK instant-messaging client
[Generated for version 0.2-17 - Mon Jan 6 19:01:23 GMT+1 2003]

Home - - - - -

editcontacts.c

Go to the documentation of this file.

/*
 * Yattm 
 *
 * Copyright (C) 1999, Torrey Searle <tsearle@uci.edu>
 *
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * editcontacts.c
 */


#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "intl.h"
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "gtk_globals.h"
#include "status.h"
#include "util.h"
#include "dialog.h"
#include "value_pair.h"

#include "pixmaps/ok.xpm"
#include "pixmaps/cancel.xpm"
#include "pixmaps/tb_trash.xpm"
#include "pixmaps/tb_edit.xpm"
#include "pixmaps/tb_preferences.xpm"

enum
{
    USER_NAME,
    PASSWORD,
    SERVICE_TYPE
};

typedef char * account_row[3];

static GtkWidget * account_list;
static GtkWidget * account_window = NULL;
static GtkWidget * username;
static GtkWidget * password;
static GtkWidget * service_type;
static GtkWidget * mod_button;
static GtkWidget * del_button;
static gint selected_row = -1;
static gboolean is_open = FALSE;
static gint num_accounts = 0;

static void destroy(GtkWidget * widget, gpointer data)
{
    is_open = FALSE;
    num_accounts = 0;
    selected_row = -1;
}

static void read_contacts()
{
    account_row text;
    GList * node;

    for(node = accounts; node; node = node->next)
    {
        eb_local_account * ela = node->data;
        GList * pairs = RUN_SERVICE(ela)->write_local_config(ela);

        text[SERVICE_TYPE] = eb_services[ela->service_id].name;

        text[USER_NAME] = value_pair_get_value(pairs, "SCREEN_NAME");

        text[PASSWORD] = value_pair_get_value(pairs, "PASSWORD");

        /* gtk_clist_append copies our strings, so we don't need to */
        gtk_clist_append(GTK_CLIST(account_list), text);
        value_pair_free(pairs);
        num_accounts++;
    }
}

static void selection_unmade(GtkWidget *clist,
                                gint    row,
                                gint    column,
                                GdkEventButton *event,
                                gpointer    data)
{
    gtk_entry_set_text(GTK_ENTRY(username),  "");
    gtk_entry_set_text(GTK_ENTRY(password),  "");
}

static void selection_made(GtkWidget      *clist,
                            gint            row,
                            gint            column,
                            GdkEventButton *event,
                            gpointer        data)
{

    gchar *entry_name;
    gchar *entry_pass;
    gchar *entry_service;

    selected_row = row;

    /* Put data in selected row into the entry boxes for revision */
    
    gtk_clist_get_text(GTK_CLIST(clist), row, USER_NAME, &entry_name); 
    gtk_clist_get_text(GTK_CLIST(clist), row, PASSWORD, &entry_pass); 
    gtk_clist_get_text(GTK_CLIST(clist), row, SERVICE_TYPE, &entry_service); 
    gtk_entry_set_text(GTK_ENTRY(username),  entry_name);
    gtk_entry_set_text(GTK_ENTRY(password),  entry_pass);
    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(service_type)->entry), entry_service);
    
    gtk_widget_set_sensitive(mod_button, TRUE);
    gtk_widget_set_sensitive(del_button, TRUE);
    
   return;
}

static void remove_callback(GtkWidget * widget, gpointer data)
{
    if(selected_row != -1)
    {
        gtk_clist_remove(GTK_CLIST(account_list), selected_row);
        num_accounts--;
        selected_row = -1;
    }
}

static char * check_login_validity(char * text[])
{
    GList * services = get_service_list();
    GList * l = services;
    /* 
     * okay, this should really be text[SERVICE_TYPE], text[USER_NAME] ...
     * change it if you think this is confusing
     */
    if (USER_NAME[text] == NULL || strlen(USER_NAME[text]) == 0)
        return NULL;

    while (l) {
        if(!strcmp(l->data, SERVICE_TYPE[text]))
            return eb_services[get_service_id(l->data)].sc->check_login(USER_NAME[text], PASSWORD[text]);
        l = l->next;
    }
    
    return NULL;
}

static void add_callback(GtkWidget * widget, gpointer data)
{
    char * text[3];
    char * error_message = NULL;
    text[USER_NAME] = gtk_entry_get_text(GTK_ENTRY(username));
    text[PASSWORD] = gtk_entry_get_text(GTK_ENTRY(password));
    text[SERVICE_TYPE] = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(service_type)->entry));
    
    error_message = check_login_validity(text);
    if(error_message)
    {
        do_error_dialog(error_message,
                _("Wrong parameters"));
        return;
    }

    gtk_clist_append(GTK_CLIST(account_list), text);
    num_accounts++;
    printf("num_accounts %d\n",num_accounts);
    gtk_entry_set_text(GTK_ENTRY(username), "");
    gtk_entry_set_text(GTK_ENTRY(password), "");
}

static void modify_callback(GtkWidget * widget, gpointer data)
{
    char * text[3];
    
    /* update selected row in list */
    
    text[USER_NAME] = gtk_entry_get_text(GTK_ENTRY(username));
    gtk_clist_set_text(GTK_CLIST(account_list), 
            selected_row, USER_NAME, text[USER_NAME]);
    
    text[PASSWORD] = gtk_entry_get_text(GTK_ENTRY(password));
    gtk_clist_set_text(GTK_CLIST(account_list), 
                        selected_row, PASSWORD, text[PASSWORD]);

    text[SERVICE_TYPE] = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(service_type)->entry));
    gtk_clist_set_text(GTK_CLIST(account_list), 
                        selected_row, SERVICE_TYPE, text[SERVICE_TYPE]);

    /* reset the entry fields */

    gtk_entry_set_text(GTK_ENTRY(username), "");
    gtk_entry_set_text(GTK_ENTRY(password), "");
}

static void cancel_callback(GtkWidget *widget, gpointer data)
{
    gtk_widget_destroy(account_window);
    if(!statuswindow)
        gtk_main_quit();
}

static void ok_callback(GtkWidget * widget, gpointer data)
{
    FILE * fp;
    char buff[1024];
    char * service, *user, *pass;
    int i;
    int id;
    gboolean had_accounts=(accounts != NULL);
    GList *pairs=NULL;
    GList *existing_accounts = NULL, *new_accounts = NULL, *acc_walk = NULL;
    eb_local_account *ela=NULL;

    if (gtk_entry_get_text(GTK_ENTRY(username)) != NULL
    &&  strlen(gtk_entry_get_text(GTK_ENTRY(username))) > 0) {
        add_callback(widget,data);
    }
    
    g_snprintf(buff, 1024, "%saccounts",config_dir);

    fp=fdopen(creat(buff, 0700), "w");
    
    if (num_accounts == 0) {
        do_error_dialog(_("You didn't define any account."), _("Error"));
        return;
    }
    
    for(i = 0; i < num_accounts; i++)
    {
        gtk_clist_get_text(GTK_CLIST(account_list), i, SERVICE_TYPE, &service); 
        gtk_clist_get_text(GTK_CLIST(account_list), i, USER_NAME, &user); 
        gtk_clist_get_text(GTK_CLIST(account_list), i, PASSWORD, &pass); 
        id=get_service_id(service);
        if(accounts && (ela = find_local_account_by_handle(user, id))) {
            /* If the account exits, just update the password
             */
            GList * config = NULL;  
            config = eb_services[id].sc->write_local_config(ela);
            config = value_pair_remove(config, "PASSWORD");
            config = value_pair_add(config, "PASSWORD", pass);
            fprintf(fp, "<ACCOUNT %s>\n", service);
            value_pair_print_values(config, fp, 1); 
            fprintf(fp, "</ACCOUNT>\n");
            existing_accounts = g_list_append(existing_accounts, ela);
        }
        else {
            GList * config = NULL;  
            eb_debug(DBG_CORE, "Adding new account %s service %s\n", user, service);
            pairs = value_pair_add(NULL, "SCREEN_NAME", user);
            pairs = value_pair_add(pairs, "PASSWORD", pass);
            save_account_info(service, pairs);
            ela = eb_services[id].sc->read_local_account_config(pairs);
            //prevent segfault
            if(ela != NULL) {
                // Is this an account for which a module is not loaded?
                if(ela->service_id==-1)
                    ela->service_id=id;
                new_accounts = g_list_append(new_accounts, ela);
                config = eb_services[id].sc->write_local_config(ela);
                fprintf(fp, "<ACCOUNT %s>\n", service);
                value_pair_print_values(config, fp, 1); 
                fprintf(fp, "</ACCOUNT>\n");
            } else {
                do_error_dialog(_("Can't add account : unknown service"), _("Error"));
            }
        }
    }

    
    fclose(fp);

    acc_walk = accounts;
    if (acc_walk) {
        while(acc_walk != NULL && acc_walk->data != NULL) {
            if (g_list_find(existing_accounts, acc_walk->data) == NULL) {
                eb_local_account *removed = (eb_local_account *)(acc_walk->data);
                /* removed account */
                if(removed->connected 
                && RUN_SERVICE(removed)->logout != NULL)
                    RUN_SERVICE(removed)->logout(removed);
                accounts = g_list_remove(accounts,acc_walk->data);
            }
            acc_walk = acc_walk->next;
        }
    }
    
    acc_walk = new_accounts;
    if (acc_walk) {
        while(acc_walk != NULL) {
            accounts = g_list_append(accounts,acc_walk->data);
            acc_walk = acc_walk->next;
        }       
    }
    
    gtk_widget_destroy(account_window);

    /* if this was an initial launch, start up EB */
    if(!had_accounts)
    {
        load_accounts();
        load_contacts();
        eb_status_window();
    }
    else
        rebuild_set_status_menu();
}
        
void eb_new_user()
{
    char * text[] ={_("Screen Name"), 
            _("Password"), 
            _("Service Type")};
    GtkWidget * box;
    GtkWidget * window_box;
    GtkWidget * hbox;
    GtkWidget * button_box;
    GtkWidget * label;
    GtkWidget * iconwid;
    GtkWidget * toolbar;
    GtkWidget * toolitem;
    GtkWidget * separator;
    GList * list;
    GdkPixmap *icon;
    GdkBitmap *mask;

    if(is_open)
        return;

    is_open = 1;

    account_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(account_window), GTK_WIN_POS_MOUSE);
    gtk_widget_realize(account_window);
    account_list = gtk_clist_new_with_titles(3,text); 
    gtk_clist_set_column_visibility(GTK_CLIST(account_list), PASSWORD, FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(account_window), 5);
    gtk_signal_connect(GTK_OBJECT(account_list), "select_row",
                        GTK_SIGNAL_FUNC(selection_made),
                        NULL);
    gtk_signal_connect(GTK_OBJECT(account_list), "unselect_row",
                        GTK_SIGNAL_FUNC(selection_unmade), 
                        NULL);
    
    box = gtk_vbox_new(FALSE, 0);
    window_box = gtk_vbox_new(FALSE,5);
    hbox = gtk_hbox_new(FALSE, 5);
    gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);

    /*Screen Name Section*/
   
    label = gtk_label_new(_("Screen Name:"));
    gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
    gtk_widget_show(label);
    username = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(box), username, FALSE, FALSE, 2);
    gtk_widget_show(username);

    /*Password Section*/
   
    label = gtk_label_new(_("Password:"));
    gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
    gtk_widget_show(label);
    password = gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(password), FALSE);
    gtk_box_pack_start(GTK_BOX(box), password, FALSE, FALSE, 2);
    gtk_widget_show(password);

    /*Service Type Section*/
   
    label = gtk_label_new(_("Service Type:"));
    gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 5);
    gtk_widget_show(label);
    service_type = gtk_combo_new();
    list = get_service_list();
    gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(service_type)->entry), FALSE);
    gtk_combo_set_popdown_strings(GTK_COMBO(service_type), list);
    g_list_free(list);
    gtk_widget_show(service_type);
    gtk_box_pack_start(GTK_BOX(box), service_type, FALSE, FALSE, 2);
    
    gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 2);  
    gtk_widget_show(box);
    
    box = gtk_vbox_new(FALSE, 0);

    read_contacts();

    gtk_box_pack_start(GTK_BOX(box), account_list, TRUE, TRUE, 0);
    gtk_widget_show(account_list);

    gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 2);
    gtk_widget_show(box);

    gtk_box_pack_start(GTK_BOX(window_box), hbox, TRUE, TRUE, 0);
    gtk_widget_show(hbox);

    separator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(window_box), separator, TRUE, TRUE, 0);
    gtk_widget_show(separator);

    /*Initialize Toolbar*/

    toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
    gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolbar), GTK_RELIEF_NONE);
    gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
    gtk_toolbar_set_space_size(GTK_TOOLBAR(toolbar), 5);
   
    /*Add Button*/
   
    icon = gdk_pixmap_create_from_xpm_d(account_window->window, &mask, NULL, tb_preferences_xpm);
    iconwid = gtk_pixmap_new(icon, mask);
    gtk_widget_show(iconwid);
    toolitem = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
                        _("Add"),
                                        _("Add Account"),
                                        _("Add"),
                                        iconwid,
                                        GTK_SIGNAL_FUNC(add_callback),
                                        NULL);
    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
    
    /*Delete Button*/
    
    icon = gdk_pixmap_create_from_xpm_d(account_window->window, &mask, NULL, tb_trash_xpm);
    iconwid = gtk_pixmap_new(icon, mask);
    gtk_widget_show(iconwid);
    del_button = gtk_toolbar_append_item (GTK_TOOLBAR(toolbar),
                        _("Delete"),
                                        _("Delete Account"),
                                        _("Delete"),
                                        iconwid,
                                        GTK_SIGNAL_FUNC(remove_callback),
                                        NULL);
    gtk_widget_set_sensitive(del_button, FALSE);
    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
   
    /* Modify Button */
    
    icon = gdk_pixmap_create_from_xpm_d(account_window->window, &mask, NULL, tb_edit_xpm);
    iconwid = gtk_pixmap_new(icon, mask);
    gtk_widget_show(iconwid);
    mod_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
                            _("Modify"),
                                            _("Modify Account"),
                                            _("Modify"),
                                             iconwid,
                                             GTK_SIGNAL_FUNC(modify_callback),
                                             NULL);
    gtk_widget_set_sensitive(mod_button, FALSE);
    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

    separator = gtk_vseparator_new();
    gtk_widget_set_usize(GTK_WIDGET(separator), 0, 20);
    gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar), separator, NULL, NULL);
    gtk_widget_show(separator);
    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
   
    /*Okay Button*/
    
    icon = gdk_pixmap_create_from_xpm_d(account_window->window, &mask, NULL, ok_xpm);
    iconwid = gtk_pixmap_new(icon, mask);
    gtk_widget_show(iconwid);
    toolitem = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
                        _("Ok"),
                                        _("Ok"),
                                        _("Ok"),
                                        iconwid,
                                        GTK_SIGNAL_FUNC(ok_callback),
                                        NULL);
    gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

    /*Cancel Button*/
    
    icon = gdk_pixmap_create_from_xpm_d(account_window->window, &mask, NULL, cancel_xpm);
    iconwid = gtk_pixmap_new(icon, mask);
    gtk_widget_show(iconwid);
    toolitem = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
                        _("Cancel"),
                                        _("Cancel"),
                                        _("Cancel"),
                                        iconwid,
                                        GTK_SIGNAL_FUNC(cancel_callback),
                                        NULL);

    /*Buttons End*/
   
    button_box = gtk_hbox_new(FALSE, 0);
   
    gtk_box_pack_end(GTK_BOX(button_box), toolbar, FALSE, FALSE, 0);
    gtk_widget_show(toolbar);
   
    gtk_box_pack_start(GTK_BOX(window_box), button_box, FALSE, FALSE, 0);
    gtk_widget_show(button_box);
   
    gtk_widget_show(window_box);

    gtk_container_add(GTK_CONTAINER(account_window), window_box);
   
    gtk_window_set_title(GTK_WINDOW(account_window), _("Yattm Account Editor"));
    eb_icon(account_window->window);

    gtk_signal_connect(GTK_OBJECT(account_window), "destroy",
                       GTK_SIGNAL_FUNC(destroy), NULL );
    gtk_widget_show(account_window);
}

---

Contact: Andy Maloney     [Documentation generated by doxygen]