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

Home - - - - -

chat_window.c File Reference

#include "intl.h"
#include <string.h>
#include <stdlib.h>
#include <gdk/gdkkeysyms.h>
#include <ctype.h>
#include <assert.h>
#include "chat_window.h"
#include "util.h"
#include "gtkspell.h"
#include "add_contact_window.h"
#include "sound.h"
#include "dialog.h"
#include "globals.h"
#include "status.h"
#include "away_window.h"
#include "message_parse.h"
#include "gtk_eb_html.h"
#include "plugin.h"
#include "contact_actions.h"
#include "smileys.h"
#include "prefs.h"
#include "pixmaps/tb_book_red.xpm"
#include "pixmaps/tb_open.xpm"
#include "pixmaps/tb_volume.xpm"
#include "pixmaps/tb_edit.xpm"
#include "pixmaps/tb_search.xpm"
#include "pixmaps/tb_no.xpm"
#include "pixmaps/tb_mail_send.xpm"
#include "pixmaps/cancel.xpm"
#include "pixmaps/smiley_button.xpm"

Include dependency graph for chat_window.c:

Go to the source code of this file.

Defines
#define	BUF_SIZE   1024
#define	GET_CHAT_WINDOW(cur_cw)
Functions
void	eb_update_window_title (chat_window *cw, gboolean new_message)
void	eb_update_window_title_to_tab (int tab, gboolean new_message)
void	set_tab_red (GtkNotebook *notebook, GtkWidget *child)
void	set_tab_normal (GtkNotebook *notebook, GtkWidget *child)
void	end_conversation (chat_window *cw)
void	destroy_event (GtkWidget *widget, gpointer userdata)
void	close_tab_callback (GtkWidget *button, gpointer userdata)
void	add_unknown_callback (GtkWidget *add_button, gpointer userdata)
void	send_message (GtkWidget *widget, gpointer d)
void	view_log_callback (GtkWidget *widget, gpointer d)
void	insert_smiley (GtkWidget *widget, chat_window *cw)
void	show_smileys_callback (GtkWidget *widget, gpointer d)
void	ignore_dialog_callback (GtkWidget *widget, gpointer userdata)
void	ignore_callback (GtkWidget *ignore_button, gpointer userdata)
void	send_file (GtkWidget *sendf_button, gpointer userdata)
void	set_sound_on_toggle (GtkWidget *sound_button, gpointer userdata)
void	set_sound_on_click (GtkWidget *button, gpointer userdata)
void	close_win (GtkWidget *close_button, gpointer userdata)
void	allow_offline_on_toggle (GtkWidget *allow_button, gpointer userdata)
void	allow_offline_on_click (GtkWidget *button, gpointer userdata)
void	change_local_account_on_click (GtkWidget *button, gpointer userdata)
GtkWidget *	get_local_accounts (chat_window *cw)
void	handle_focus (GtkWidget *widget, GdkEventFocus *event, gpointer userdata)
void	handle_click (GtkWidget *widget, GdkEventButton *event, gpointer userdata)
void	send_typing_status (chat_window *cw)
gboolean	chat_singleline_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data)
gboolean	chat_key_press (GtkWidget *widget, GdkEventKey *event, gpointer data)
void	chat_notebook_switch_callback (GtkNotebook *notebook, GtkNotebookPage *page, gint page_num, gpointer user_data)
chat_window *	find_tabbed_chat_window ()
chat_window *	find_tabbed_chat_window_index (int current_page)
chat_window *	find_tabbed_current_chat_window ()
chat_window *	eb_chat_window_new (eb_local_account *local, struct contact *remote)
void	eb_chat_window_display_error (eb_account *remote, gchar *message)
void	eb_chat_window_do_timestamp (struct contact *c, gboolean online)
void	eb_chat_window_display_remote_message (eb_local_account *account, eb_account *remote, struct service *serv, gchar *o_message)
void	eb_chat_window_display_contact (struct contact *remote_contact)
void	eb_chat_window_display_account (eb_account *remote_account)
void	eb_log_status_changed (eb_account *ea, gchar *status)
void	eb_log_message (FILE *log_file, gchar buff[], gchar *message)
void	eb_restore_last_conv (gchar *file_name, chat_window *cw)
void	eb_chat_window_display_status (eb_account *remote, gchar *message)
Variables
GList *	outgoing_message_filters = NULL
GList *	incoming_message_filters = NULL

---

Define Documentation

#define BUF_SIZE   1024

Definition at line 66 of file chat_window.c. Referenced by eb_chat_window_display_remote_message(), eb_chat_window_do_timestamp(), eb_restore_last_conv(), eb_update_window_title(), eb_update_window_title_to_tab(), ignore_callback(), and send_message().

#define GET_CHAT_WINDOW (  cur_cw    )

Value: {\ if(do_tabbed_chat) { \ chat_window *bck = cur_cw; \ if (cur_cw->notebook) \ cur_cw = find_tabbed_chat_window_index(gtk_notebook_get_current_page(GTK_NOTEBOOK(cur_cw->notebook))); \ if (cur_cw == NULL) \ cur_cw = bck; \ } \ } Definition at line 385 of file chat_window.c. Referenced by allow_offline_on_click(), ignore_callback(), insert_smiley(), send_file(), send_message(), set_sound_on_click(), and view_log_callback().

---

Function Documentation

void add_unknown_callback (  GtkWidget *    add_button, gpointer    userdata )  [static]

Definition at line 356 of file chat_window.c. References contact::accounts, add_unknown_account_window_new(), _chat_window::contact, find_suitable_remote_account(), and _chat_window::perfered. Referenced by eb_chat_window_new(), and handle_click(). { chat_window * cw = userdata; /* if something wierd is going on and the unknown contact has multiple * accounts, find use the perfered account */ cw->perfered = find_suitable_remote_account(cw->perfered, cw->contact); /* if in the weird case that the unknown user has gone offline * just use the first account you see */ if(!cw->perfered) cw->perfered = cw->contact->accounts->data; /* if that fails, something is seriously wrong * bail out while you can */ if(!cw->perfered) return; /* now that we have a valid account, pop up the window already :) */ add_unknown_account_window_new(cw->perfered); }

void allow_offline_on_click (  GtkWidget *    button, gpointer    userdata )  [static]

Definition at line 828 of file chat_window.c. References _chat_window::allow_button, _chat_window::contact, GET_CHAT_WINDOW, and contact::send_offline. Referenced by eb_chat_window_new(), and handle_click(). { chat_window * cw = (chat_window *)userdata; GET_CHAT_WINDOW(cw); if (cw->contact->send_offline) { cw->contact->send_offline = FALSE; gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->allow_button), FALSE); } else { cw->contact->send_offline = TRUE; gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->allow_button), TRUE); } }

void allow_offline_on_toggle (  GtkWidget *    allow_button, gpointer    userdata )  [static]

Definition at line 812 of file chat_window.c. References _chat_window::contact, and contact::send_offline. Referenced by eb_chat_window_new(). { chat_window * cw = (chat_window *)userdata; /*set send_offline based upon toggle button*/ if (GTK_TOGGLE_BUTTON (allow_button)->active) { cw->contact->send_offline = TRUE; } else { cw->contact->send_offline = FALSE; } }

void change_local_account_on_click (  GtkWidget *    button, gpointer    userdata )  [static]

Definition at line 845 of file chat_window.c. References _chat_window_account::cw, _chat_window_account::data, DBG_CORE, eb_debug, and _chat_window::local_user. Referenced by get_local_accounts(). { GtkLabel *label= GTK_LABEL (GTK_BIN (button)->child); chat_window_account *cwa = (chat_window_account *)userdata; chat_window * cw; gchar *account; eb_local_account *ela=NULL; /* Should never happen */ if(!cwa) return; cw=cwa->cw; ela=(eb_local_account *)cwa->data; cw->local_user=ela; /* don't free it */ gtk_label_get(label, &account); eb_debug(DBG_CORE, "change_local_account_on_click: %s\n", account); }

gboolean chat_key_press (  GtkWidget *    widget, GdkEventKey *    event, gpointer    data )  [static]

Definition at line 1084 of file chat_window.c. References eb_update_window_title(), _chat_window::entry, _chat_window::hist_pos, _chat_window::history, _chat_window::notebook, _chat_window::perfered, send_message(), send_typing_status(), and _chat_window::this_msg_in_history. Referenced by eb_chat_window_new(). { chat_window *cw = (chat_window *)data; GdkModifierType modifiers = event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_MOD4_MASK); eb_update_window_title(cw, FALSE); if (event->keyval == GDK_Return) { /* Just print a newline on Shift-Return */ if (event->state & GDK_SHIFT_MASK) { event->state = 0; } else if (do_enter_send) { /*Prevents a newline from being printed*/ gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event"); send_message(NULL, cw); return gtk_true(); } } else if (event->keyval == GDK_Up) { gint p=0; if(cw->history==NULL) { return gtk_true(); } if(cw->hist_pos==NULL) { char * s; GList * node; s= gtk_editable_get_chars(GTK_EDITABLE (cw->entry), 0, -1); for(node=cw->history; node!=NULL ; node=node->next) { cw->hist_pos=node; } if(strlen(s)>0) { cw->history=g_list_append(cw->history, strdup(s)); //cw->hist_pos=cw->history->next; g_free(s); // that strdup() followed by g_free() looks stupid, but it isn't // - strdup() uses vanilla malloc(), and the destroy code uses // vanilla free(), so we can't use something that needs to be // g_free()ed (apparently glib uses an incompatible allocation //system cw->this_msg_in_history=1; } } else { cw->hist_pos=cw->hist_pos->prev; if(cw->hist_pos==NULL) { GList * node; printf("Wrapped!\n"); for(node=cw->history; node!=NULL ; node=node->next) { cw->hist_pos=node; } } } gtk_editable_delete_text(GTK_EDITABLE (cw->entry), 0, -1); gtk_editable_insert_text(GTK_EDITABLE (cw->entry), cw->hist_pos->data, strlen(cw->hist_pos->data), &p); } else if (event->keyval == GDK_Down) { gint p=0; if(cw->history==NULL || cw->hist_pos==NULL) { return gtk_true(); } cw->hist_pos=cw->hist_pos->next; if(cw->hist_pos==NULL) { gtk_editable_delete_text(GTK_EDITABLE (cw->entry), 0, -1); } else { gtk_editable_delete_text(GTK_EDITABLE (cw->entry), 0, -1); gtk_editable_insert_text(GTK_EDITABLE (cw->entry), cw->hist_pos->data, strlen(cw->hist_pos->data), &p); } } else if (cw->notebook != NULL) /* only change tabs if this window is tabbed */ { /* * this does not allow for using the same keyval for both prev and next * when next contains every modifier that previous has (with some more) * but i really don't think that will be a huge problem =) */ if ((modifiers == accel_prev_tab.modifiers) && (event->keyval == accel_prev_tab.keyval)) { gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event"); gtk_notebook_prev_page( GTK_NOTEBOOK(cw->notebook) ); return gtk_true(); } else if ((modifiers == accel_next_tab.modifiers) && (event->keyval == accel_next_tab.keyval)) { gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event"); gtk_notebook_next_page( GTK_NOTEBOOK(cw->notebook) ); return gtk_true(); } } if(cw->perfered==NULL || modifiers) { return gtk_false(); } if(!modifiers) { send_typing_status(cw); } return gtk_false(); }

void chat_notebook_switch_callback (  GtkNotebook *    notebook, GtkNotebookPage *    page, gint    page_num, gpointer    user_data )  [static]

Definition at line 1199 of file chat_window.c. References contact::chatwindow, eb_update_window_title_to_tab(), _chat_window::entry, _chat_window::notebook, _chat_window::notebook_child, and set_tab_normal(). Referenced by eb_chat_window_new(). { /* find the contact for the page we just switched to and turn off their talking penguin icon */ GList * l1; GList * l2; struct contact* c; for(l1 = groups; l1; l1=l1->next ) { for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next ) { // if this contact's chatwindow is equal to this one, // then we need to end the conversation and remove the // notebook tab... c = (struct contact*)l2->data; if (c->chatwindow != NULL) { if (c->chatwindow->notebook_child == page->child) { /* get rid of this pixmap .. no more icons in the tabs */ /* gtk_widget_hide(c->chatwindow->talk_pixmap); */ set_tab_normal(GTK_NOTEBOOK(c->chatwindow->notebook), c->chatwindow->notebook_child); gtk_widget_grab_focus(c->chatwindow->entry); eb_update_window_title_to_tab (page_num, FALSE); } } } } }

gboolean chat_singleline_key_press (  GtkWidget *    widget, GdkEventKey *    event, gpointer    data )  [static]

Definition at line 1074 of file chat_window.c. References send_typing_status(). Referenced by eb_chat_window_new(). { chat_window *cw = (chat_window *)data; if(!(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_MOD4_MASK))) { send_typing_status(cw); } return gtk_true(); }

void close_tab_callback (  GtkWidget *    button, gpointer    userdata )  [static]

Definition at line 321 of file chat_window.c. References gtk_notebook_get_number_pages(), _chat_window::notebook, _chat_window::notebook_child, and _chat_window::window. Referenced by eb_chat_window_new(), and handle_click(). { chat_window *cw = (chat_window*)userdata; GtkWidget *window = cw->window; GtkWidget *notebook = cw->notebook; gint tab_number; /* we got called to kill the tab, so find out which tab number we need to kill */ tab_number = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), cw->notebook_child); gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), tab_number); /* * WARNING: AT THIS POINT IN TIME cw IS NO LONGER AVAILABLE * end_conversation calls a g_free on cw * gtk_notebook_remove_page triggers the destroy signal on the vbox * (which calls end_conversation via destroy_event) */ /* * Question: Now, as soon as the last page from the notebook gets * removed the window disappears, and I didn't find a call to destroy * it so... i've left in this destroy.. but I really don't know if it * is needed... */ if (gtk_notebook_get_number_pages(GTK_NOTEBOOK(notebook)) == 0) { // we just delete the last conversation, no point in having the window // around... note that this also causes end_conversation to be called... gtk_widget_destroy(window); } }

void close_win (  GtkWidget *    close_button, gpointer    userdata )  [static]

Definition at line 801 of file chat_window.c. References _chat_window::smiley_window, and _chat_window::window. Referenced by eb_chat_window_new(), and handle_click(). { chat_window * cw = (chat_window *)userdata; if(cw->smiley_window != NULL && cw->smiley_window->window != NULL) { /* close smileys popup */ gtk_widget_destroy(cw->smiley_window); cw->smiley_window = NULL; } gtk_widget_destroy(cw->window); }

void destroy_event (  GtkWidget *    widget, gpointer    userdata )  [static]

Definition at line 313 of file chat_window.c. References end_conversation(). Referenced by eb_chat_window_new(). { chat_window* cw = (chat_window*)userdata; /* gotta clean up all of the people we're talking with */ end_conversation(cw); }

void eb_chat_window_display_account (  eb_account *    remote_account )

Definition at line 2155 of file chat_window.c. References account::account_contact, contact::chatwindow, eb_chat_window_new(), eb_restore_last_conv(), eb_update_window_title(), _chat_window::entry, find_suitable_local_account(), make_safe_filename(), NAME_MAX, contact::nick, _chat_window::notebook, _chat_window::notebook_child, _chat_window::perfered, account::service_id, set_tab_normal(), and _chat_window::window. Referenced by account_click(). { struct contact * remote_contact = remote_account->account_contact; eb_local_account * account =find_suitable_local_account(NULL, remote_account->service_id); if(!remote_contact->chatwindow || !remote_contact->chatwindow->window) { if(remote_contact->chatwindow) { g_free(remote_contact->chatwindow); } remote_contact->chatwindow = eb_chat_window_new(account, remote_contact); if(remote_contact->chatwindow) { gtk_widget_show(remote_contact->chatwindow->window); if (do_restore_last_conv) { gchar buff[NAME_MAX]; make_safe_filename(buff, remote_contact->nick); eb_restore_last_conv(buff,remote_contact->chatwindow); } gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus (GTK_WINDOW (remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } else /* Did they get denied because they're in the Unknown group? */ return; } else if (remote_contact->chatwindow && remote_contact->chatwindow->window) { gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus (GTK_WINDOW (remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } eb_update_window_title(remote_contact->chatwindow, FALSE); if (remote_contact->chatwindow->notebook != NULL) { int page_num = gtk_notebook_page_num(GTK_NOTEBOOK(remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child); /* no more icons in the tabs */ /* gtk_widget_hide(remote_contact->chatwindow->talk_pixmap); */ set_tab_normal(GTK_NOTEBOOK(remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child); gtk_notebook_set_page(GTK_NOTEBOOK(remote_contact->chatwindow->notebook), page_num); } else { gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus(GTK_WINDOW(remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } remote_contact->chatwindow->perfered = remote_account; }

void eb_chat_window_display_contact (  struct contact *    remote_contact )

Definition at line 2097 of file chat_window.c. References contact::chatwindow, eb_chat_window_new(), eb_restore_last_conv(), _chat_window::entry, find_suitable_local_account(), find_suitable_remote_account(), make_safe_filename(), NAME_MAX, contact::nick, _chat_window::notebook, _chat_window::notebook_child, account::service_id, set_tab_normal(), and _chat_window::window. Referenced by console_session_get_command(), contact_click(), and pounce_contact(). { eb_account *remote_account = find_suitable_remote_account (NULL, remote_contact); eb_local_account *account = NULL; if (remote_account) account = find_suitable_local_account (NULL, remote_account->service_id); if (!remote_contact->chatwindow || !remote_contact->chatwindow->window) { if (remote_contact->chatwindow) { g_free (remote_contact->chatwindow); } remote_contact->chatwindow = eb_chat_window_new (account, remote_contact); if (remote_contact->chatwindow) { gtk_widget_show (remote_contact->chatwindow->window); if (do_restore_last_conv) { gchar buff[NAME_MAX]; make_safe_filename (buff, remote_contact->nick); eb_restore_last_conv (buff, remote_contact->chatwindow); } gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus (GTK_WINDOW (remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } } else { gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus (GTK_WINDOW (remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } if (remote_contact->chatwindow->notebook != NULL) { int page_num = gtk_notebook_page_num (GTK_NOTEBOOK (remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child); /* no more icons in the tabs */ /* gtk_widget_hide(remote_contact->chatwindow->talk_pixmap); */ set_tab_normal (GTK_NOTEBOOK (remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child); gtk_notebook_set_page (GTK_NOTEBOOK (remote_contact->chatwindow->notebook), page_num); } }

void eb_chat_window_display_error (  eb_account *    remote, gchar *    message )

Definition at line 1871 of file chat_window.c. References _, account::account_contact, _chat_window::chat, contact::chatwindow, EXT_GTK_TEXT, and gtk_eb_html_add(). { struct contact * remote_contact = remote->account_contact; if(remote_contact->chatwindow) { gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), _("<b>Error: </b>"), 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), message, 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), "<br>", 0,0,0); } }

void eb_chat_window_display_remote_message (  eb_local_account *    account, eb_account *    remote, struct service *    serv, gchar *    o_message )

Definition at line 1904 of file chat_window.c. References _, account::account_contact, local_account::alias, _chat_window::away_msg_sent, BUF_SIZE, _chat_window::chat, contact::chatwindow, DBG_CORE, eb_chat_window_new(), eb_debug, eb_log_message(), eb_restore_last_conv(), eb_smilify(), eb_update_window_title(), _chat_window::entry, EXT_GTK_TEXT, _chat_window::first_enabled, FIRSTMSG, _chat_window::fp, service_callbacks::get_color, service_callbacks::get_smileys, contact::group, gtk_eb_html_add(), incoming_message_filters, _chat_window::local_user, make_safe_filename(), _grouplist::name, NAME_MAX, contact::nick, _chat_window::notebook, _chat_window::notebook_child, _chat_window::perfered, play_sound(), RECEIVE, _chat_window::receive_enabled, RUN_SERVICE, service::sc, send_message(), set_tab_red(), _chat_window::sound_enabled, and _chat_window::window. Referenced by eb_parse_incomming_message(). { struct contact * remote_contact = remote->account_contact; gchar buff[BUF_SIZE]; gchar buff2[BUF_SIZE]; struct tm * cur_time; time_t t; GList * filter_walk; gchar * message; gboolean firstmsg = FALSE; /* init to false so only play if * first msg is one received rather * than sent */ #ifdef HAVE_ICONV_H /* 'BUF_SIZE*2' e.g. for 'Latin-x' to 'UTF-8', which is 1-byte to 2-byte recoding */ char recode_buff[BUF_SIZE*2 + 1]; #endif /* do we need to ignore this user? If so, do it BEFORE filters so they can't DoS us */ if(!strcasecmp(remote_contact->group->name, _("Ignore") )) return; // Inbound filters here - Meredydd filter_walk=incoming_message_filters; eb_debug(DBG_CORE, "Starting to run incoming filters\n"); message=strdup(o_message); while(filter_walk!=NULL) { gchar * (*ofilter)(eb_local_account *, eb_account *, struct contact *, gchar *); eb_debug(DBG_CORE, "Running an incoming filter\n"); ofilter=(gchar *(*)(eb_local_account *, eb_account *, struct contact *, gchar *))filter_walk->data; message=ofilter(account, remote, remote_contact, message); if(message==NULL) { return; } // Nothing to clean up (I think...) filter_walk=g_list_next(filter_walk); } eb_debug(DBG_CORE, "Finished incoming filters\n"); // end inbound filters message = eb_smilify(message, serv->sc->get_smileys()); if(!remote_contact->chatwindow || !remote_contact->chatwindow->window) { if(remote_contact->chatwindow) g_free(remote_contact->chatwindow); remote_contact->chatwindow = eb_chat_window_new(account, remote_contact); if (!remote_contact->chatwindow) /* this message is ignored */ return; gtk_widget_show(remote_contact->chatwindow->window); firstmsg = TRUE; /* chat window created by * receive msg, so set to true */ if (do_restore_last_conv){ gchar buff[NAME_MAX]; make_safe_filename(buff, remote_contact->nick); eb_restore_last_conv(buff,remote_contact->chatwindow); } } /*for now we will assume the identity that the person in question talked to us last as */ remote_contact->chatwindow->local_user = account; /*also specify that if possible, try to use the same account they used to last talk to us with */ remote_contact->chatwindow->perfered = remote; if (remote_contact->chatwindow->notebook != NULL) { /* no more icons in the tabs */ /* gtk_widget_show(remote_contact->chatwindow->talk_pixmap); */ if (gtk_notebook_page_num(GTK_NOTEBOOK(remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child) != gtk_notebook_get_current_page( GTK_NOTEBOOK(remote_contact->chatwindow->notebook))) { set_tab_red(GTK_NOTEBOOK(remote_contact->chatwindow->notebook), remote_contact->chatwindow->notebook_child); } } else { gdk_window_raise(remote_contact->chatwindow->window->window); gtk_window_set_focus(GTK_WINDOW(remote_contact->chatwindow->window), remote_contact->chatwindow->entry); } eb_update_window_title(remote_contact->chatwindow, TRUE); if(remote_contact->chatwindow->sound_enabled) { if (firstmsg) { if (remote_contact->chatwindow->first_enabled) { play_sound(FIRSTMSG); firstmsg = FALSE; } else { play_sound(RECEIVE); firstmsg = FALSE; } } else if (remote_contact->chatwindow->receive_enabled) play_sound(RECEIVE); } /*for grab the focus*/ if(do_raise_window) { gdk_window_raise(remote_contact->chatwindow->window->window); // gtk_widget_grab_focus(remote_contact->chatwindow->entry); } if (do_convo_timestamp) { gchar * color; color=serv->sc->get_color(); // note do not free() afterwards, may be static time(&t); cur_time = localtime(&t); g_snprintf(buff2, BUF_SIZE, "<FONT COLOR=\"#ff0000\">%d:%.2d:%.2d</FONT> <FONT COLOR=\"%s\">%s:</FONT>", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec, color, remote_contact->nick); } else { g_snprintf(buff2, BUF_SIZE, "%s", remote_contact->nick); } #ifdef HAVE_ICONV_H message = recode_if_needed(message, recode_buff, RECODE_TO_LOCAL); #endif g_snprintf(buff, BUF_SIZE, "<B>%s </B>",buff2); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), buff,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), message,do_ignore_back,do_ignore_fore,do_ignore_font); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), "<BR>",0,0,0); /* Log the message */ if(do_logging) eb_log_message(remote_contact->chatwindow->fp, buff, message); /* If user's away and hasn't yet sent the away message in the last 5 minutes, send, display, & log his away message. We might want to give the option of whether or not to always send the message.*/ if(is_away && (time(NULL) - remote_contact->chatwindow->away_msg_sent) > 300) { send_message(NULL, remote_contact->chatwindow); RUN_SERVICE(account)->send_im( account, remote, gtk_entry_get_text(GTK_ENTRY(away_message))); time(&t); cur_time = localtime(&t); g_snprintf(buff, BUF_SIZE, "<FONT COLOR=\"#0000ff\"><B>%d:%.2d:%.2d %s: </B></FONT>", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec, account->alias); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), buff,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), gtk_entry_get_text(GTK_ENTRY(away_message)),do_ignore_back,do_ignore_fore,do_ignore_font); gtk_eb_html_add(EXT_GTK_TEXT(remote_contact->chatwindow->chat), "<br>", 0,0,0); /* Note that the time the last away message has been sent */ remote_contact->chatwindow->away_msg_sent = time(NULL); /* Log it */ if(do_logging) eb_log_message(remote_contact->chatwindow->fp, buff, gtk_entry_get_text(GTK_ENTRY(away_message))); } free(message); }

void eb_chat_window_display_status (  eb_account *    remote, gchar *    message )

Definition at line 2409 of file chat_window.c. References contact::chatwindow, find_contact_by_handle(), account::handle, and _chat_window::status_label. Referenced by eb_update_status(). { struct contact * remote_contact = find_contact_by_handle(remote->handle); char * tmp = NULL; /* trim @.* part for User is typing */ if (remote_contact == NULL || remote_contact->chatwindow == NULL) { gchar ** tmp_ct = NULL; if (strchr (remote->handle,'@') ) { tmp_ct = g_strsplit (remote->handle,"@",2); remote_contact = find_contact_by_handle(tmp_ct[0]); g_strfreev (tmp_ct); } } if (remote_contact == NULL || remote_contact->chatwindow == NULL) return; if (message != NULL && strlen(message) > 0) tmp = g_strdup_printf("%s", message); else tmp = g_strdup_printf(" "); gtk_label_set_text( GTK_LABEL(remote_contact->chatwindow->status_label), tmp ); g_free(tmp); }

void eb_chat_window_do_timestamp (  struct contact *    c, gboolean    online )

Definition at line 1884 of file chat_window.c. References _, BUF_SIZE, _chat_window::chat, contact::chatwindow, EXT_GTK_TEXT, gtk_eb_html_add(), and contact::nick. Referenced by contact_login(), and contact_logoff(). { gchar buff[BUF_SIZE]; time_t my_time = time(NULL); if(!c || !c->chatwindow) return; if(!do_timestamp) { return; } gtk_eb_html_add(EXT_GTK_TEXT(c->chatwindow->chat), "<hr>", 0,0,0); g_snprintf(buff, BUF_SIZE,_("<b>%s is logged %s @ %s.</b>"), c->nick, (online?_("in"):_("out")), g_strchomp(asctime(localtime(&my_time)))); gtk_eb_html_add(EXT_GTK_TEXT(c->chatwindow->chat), buff, 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(c->chatwindow->chat), "<hr>", 0,0,0); }

chat_window* eb_chat_window_new (  eb_local_account *    local, struct contact *    remote )

Definition at line 1320 of file chat_window.c. References _, add_unknown_callback(), _chat_window::allow_button, allow_offline_on_click(), allow_offline_on_toggle(), _chat_window::away_msg_sent, can_offline_message(), _chat_window::chat, chat_key_press(), chat_notebook_switch_callback(), chat_singleline_key_press(), close_tab_callback(), close_win(), _chat_window::contact, destroy_event(), eb_icon(), _chat_window::entry, EXT_GTK_TEXT, ext_gtk_text_new(), find_tabbed_chat_window(), _chat_window::first_enabled, _chat_window::fp, contact::group, gtk_eb_html_init(), gtkspell_attach(), gtkspell_running(), gtkspell_start(), handle_click(), handle_focus(), ignore_callback(), _chat_window::local_user, make_safe_filename(), _grouplist::name, NAME_MAX, contact::nick, _chat_window::notebook, _chat_window::notebook_child, _chat_window::perfered, _chat_window::receive_enabled, _chat_window::send_enabled, send_file(), send_message(), set_sound_on_click(), set_sound_on_toggle(), show_smileys_callback(), _chat_window::smiley_button, _chat_window::sound_button, _chat_window::sound_enabled, _chat_window::status_label, view_log_callback(), and _chat_window::window. Referenced by eb_chat_window_display_account(), eb_chat_window_display_contact(), and eb_chat_window_display_remote_message(). { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *scrollwindow; GtkWidget *toolbar; GtkWidget *add_button; GtkWidget *sendf_button; GtkWidget *send_button; GtkWidget *view_log_button; GtkWidget *close_button; GtkWidget *ignore_button; GtkWidget *iconwid; GdkPixmap *icon; GdkBitmap *mask; GtkAccelGroup *accel_group; GtkWidget *menu; GtkWidget *button; GtkWidget *separator; GtkWidget *resize_bar; gchar buff[NAME_MAX]; chat_window *cw; chat_window *tab_cw; GtkPositionType pos; GtkWidget *contact_label; if (do_ignore_unknown) { if (!strcmp(_("Unknown"), remote->group->name)) return NULL; } /* first we allocate room for the new chat window */ cw = g_new0(chat_window,1); cw->contact = remote; cw->away_msg_sent = 0; cw->perfered = NULL; cw->local_user = NULL; vbox = gtk_vbox_new(FALSE,0); /* we're doing a tabbed chat */ if (do_tabbed_chat) { /* look for an already open tabbed chat window */ tab_cw = find_tabbed_chat_window(); if (tab_cw == NULL) { /* none exists, create one */ cw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass(GTK_WINDOW(cw->window), "yattm-chat", "Yattm"); gtk_window_set_policy(GTK_WINDOW(cw->window), TRUE, TRUE, TRUE); gtk_widget_realize(cw->window); cw->notebook = gtk_notebook_new(); /* Set tab orientation.... */ pos = GTK_POS_BOTTOM; switch (do_tabbed_chat_orient) { case 1: pos = GTK_POS_TOP; break;; case 2: pos = GTK_POS_LEFT; break;; case 3: pos = GTK_POS_RIGHT; break;; case 0: default: pos = GTK_POS_BOTTOM; break;; } gtk_notebook_set_tab_pos(GTK_NOTEBOOK(cw->notebook), pos); /* End tab orientation */ gtk_notebook_set_scrollable(GTK_NOTEBOOK(cw->notebook), TRUE); gtk_container_add(GTK_CONTAINER(cw->window), cw->notebook); /* setup a signal handler for the notebook to handle page switches */ gtk_signal_connect(GTK_OBJECT(cw->notebook), "switch-page", GTK_SIGNAL_FUNC(chat_notebook_switch_callback), cw); gtk_widget_show(cw->notebook); } else { cw->window = tab_cw->window; cw->notebook = tab_cw->notebook; } /* set up the text and close button */ contact_label = gtk_label_new(remote->nick); gtk_widget_show(contact_label); /* we use vbox as our child. */ gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); cw->notebook_child = vbox; gtk_notebook_append_page(GTK_NOTEBOOK(cw->notebook), cw->notebook_child, contact_label); gtk_widget_show(cw->notebook_child); } else { /* setup like normal */ cw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass(GTK_WINDOW(cw->window), "yattm-chat", "Yattm"); gtk_window_set_policy(GTK_WINDOW(cw->window), TRUE, TRUE, TRUE); gtk_widget_realize(cw->window); cw->notebook = NULL; cw->notebook_child = NULL; gtk_container_add(GTK_CONTAINER(cw->window), vbox); gtk_widget_show(vbox); } /* Next line allows making window smaller than orig. size */ cw->chat = ext_gtk_text_new(NULL,NULL); gtk_eb_html_init(EXT_GTK_TEXT(cw->chat)); scrollwindow = gtk_scrolled_window_new(NULL, EXT_GTK_TEXT(cw->chat)->vadj); /* gtk_widget_realize(cw->window); */ gtk_window_set_title(GTK_WINDOW(cw->window), remote->nick); eb_icon(cw->window->window); gtk_widget_set_usize(scrollwindow, 375, 150); gtk_container_add(GTK_CONTAINER(scrollwindow), cw->chat); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show(scrollwindow); /* Create the bar for resizing chat/window box */ /*Add stuff for multi-line*/ if(do_multi_line) { resize_bar = gtk_vpaned_new(); gtk_paned_set_gutter_size(GTK_PANED(resize_bar), 20); gtk_paned_pack1(GTK_PANED(resize_bar), scrollwindow, TRUE, TRUE); gtk_widget_show(scrollwindow); scrollwindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrollwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); cw->entry = gtk_text_new(NULL, NULL); gtk_widget_set_usize(scrollwindow, 375, 50); gtk_container_add(GTK_CONTAINER(scrollwindow), cw->entry); gtk_text_set_editable(GTK_TEXT(cw->entry), TRUE); gtk_text_set_word_wrap(GTK_TEXT(cw->entry), TRUE); gtk_text_set_line_wrap(GTK_TEXT(cw->entry), TRUE); #ifdef HAVE_ISPELL if(do_spell_checking) { if(!gtkspell_running()) { gchar *ispell_cmd[] = { "ispell", "-a", NULL }; gtkspell_start(NULL, ispell_cmd); } gtkspell_attach(GTK_TEXT(cw->entry)); } #endif gtk_signal_connect(GTK_OBJECT(cw->entry), "key_press_event", GTK_SIGNAL_FUNC(chat_key_press), cw); gtk_paned_pack2(GTK_PANED(resize_bar), scrollwindow, FALSE, FALSE); gtk_widget_show(scrollwindow); gtk_box_pack_start(GTK_BOX(vbox),resize_bar, TRUE, TRUE, 5); gtk_widget_show(resize_bar); } /*Or not multi-line*/ else { cw->entry = gtk_entry_new(); gtk_signal_connect(GTK_OBJECT(cw->entry), "key_press_event", GTK_SIGNAL_FUNC(chat_singleline_key_press), cw); gtk_box_pack_start(GTK_BOX(vbox), scrollwindow, TRUE,TRUE, 5); gtk_box_pack_start(GTK_BOX(vbox), cw->entry, FALSE,FALSE, 5); } gtk_container_set_border_width(GTK_CONTAINER(cw->window), do_tabbed_chat ? 2 : 5); /* gtk_container_add(GTK_CONTAINER(cw->window), vbox); */ gtk_signal_connect(GTK_OBJECT(cw->entry), "activate", GTK_SIGNAL_FUNC(send_message), cw); gtk_signal_connect(GTK_OBJECT(vbox), "destroy", GTK_SIGNAL_FUNC(destroy_event), cw); gtk_signal_connect(GTK_OBJECT(cw->chat), "button_press_event", GTK_SIGNAL_FUNC(handle_click), cw); gtk_signal_connect(GTK_OBJECT(cw->window), "focus_in_event", GTK_SIGNAL_FUNC(handle_focus), cw); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_set_usize(hbox, 200, 25); toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS); 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); /* Adding accelerators to windows*/ accel_group = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(cw->window), accel_group); menu = gtk_menu_new(); /* This is the same as handle_clicks, without showing the menu for accelerators to hopefully work better now. */ /*Add Contact Selection*/ if(!strcmp(cw->contact->group->name, _("Unknown"))) { button = gtk_menu_item_new_with_label(_("Add Contact")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(add_unknown_callback), cw); gtk_menu_append(GTK_MENU(menu), button); } /*Allow Offline Messaging Selection*/ if(can_offline_message(cw->contact)) { button = gtk_menu_item_new_with_label(_("Offline Messaging")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(allow_offline_on_click), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); } /*Sound Selection*/ if (cw->sound_enabled) { button = gtk_menu_item_new_with_label(_("Disable Sounds")); } else { button = gtk_menu_item_new_with_label(_("Enable Sounds")); } gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(set_sound_on_click), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /* Ignore button section */ button = gtk_menu_item_new_with_label(_("Ignore Contact")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(ignore_callback), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_g, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /*Send File Selection*/ button = gtk_menu_item_new_with_label(_("Send File")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(send_file), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_t, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /*Send Selection*/ button = gtk_menu_item_new_with_label(_("Send Message")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(send_message), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /*** MIZHI * view log file selection */ button = gtk_menu_item_new_with_label(_("View log")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(view_log_callback), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_l, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /*Close Selection*/ button = gtk_menu_item_new_with_label(_("Close")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(close_win), cw); gtk_widget_add_accelerator(button, "activate", accel_group, GDK_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_menu_append(GTK_MENU(menu), button); /*This is we decide whether or not the add button should be displayed*/ if (!strcmp(cw->contact->group->name, _("Unknown"))) { /*This is the add button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_book_red_xpm); iconwid = gtk_pixmap_new(icon , mask); gtk_widget_show(iconwid); add_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Add"), _("Add Contact"), _("Add"), iconwid, GTK_SIGNAL_FUNC(add_unknown_callback), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); } /*Decide whether the offline messaging button should be displayed*/ if(can_offline_message(remote)) { icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_edit_xpm); iconwid = gtk_pixmap_new(icon , mask); gtk_widget_show(iconwid); cw->allow_button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL, _("Allow"), _("Allow Offline Messaging CTRL+O"), _("Allow"), iconwid, GTK_SIGNAL_FUNC(allow_offline_on_toggle), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->allow_button), FALSE); } /* smileys */ if(do_smiley == 1) { icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, smiley_button_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); cw->smiley_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), _("Smiley"), _("Insert Smiley"), _("Smiley"), iconwid, GTK_SIGNAL_FUNC(show_smileys_callback), cw); /*Create the separator for the toolbar*/ 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)); } /*This is the sound toggle button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_volume_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); cw->sound_button = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL, _("Sound"), _("Enable Sounds CTRL+S"), _("Sound"), iconwid, GTK_SIGNAL_FUNC(set_sound_on_toggle), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); /*Toggle the sound button based on preferences*/ if (do_play_send) cw->send_enabled=TRUE; if (do_play_receive) cw->receive_enabled = TRUE; if (do_play_first) cw->first_enabled = TRUE; if (do_play_send + do_play_receive + do_play_first > 0) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->sound_button), TRUE); else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->sound_button), FALSE); /*Create the separator for the 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)); /*** MIZHI * create the button for the log viewing functions */ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_search_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); view_log_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "View", _("View Log CTRL+L"), "View", iconwid, GTK_SIGNAL_FUNC(view_log_callback), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); /*This is the send file button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_open_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); sendf_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "sendf", _("Send File CTRL+T"), "sendf", iconwid, GTK_SIGNAL_FUNC(send_file), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); /*This is the ignore button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_no_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); ignore_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "ignore", _("Ignore CTRL+G"), "ignore", iconwid, GTK_SIGNAL_FUNC(ignore_callback), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); /*This is the send button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, tb_mail_send_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); send_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "send", _("Send Message CTRL+R"), "send", iconwid, GTK_SIGNAL_FUNC(send_message), cw); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); /* Vertical separator */ 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)); /*This is the close button*/ icon = gdk_pixmap_create_from_xpm_d(cw->window->window, &mask, NULL, cancel_xpm); iconwid = gtk_pixmap_new(icon, mask); gtk_widget_show(iconwid); if (do_tabbed_chat) { close_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "close", _("Close CTRL+Q"), "close", iconwid, GTK_SIGNAL_FUNC(close_tab_callback), cw); } else { close_button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "close", _("Close CTRL+Q"), "close", iconwid, GTK_SIGNAL_FUNC(close_win), cw); } cw->status_label = gtk_label_new(" "); gtk_box_pack_start(GTK_BOX(hbox), cw->status_label, FALSE, FALSE, 0); gtk_widget_show(cw->status_label); gtk_box_pack_end(GTK_BOX(hbox), toolbar, FALSE, FALSE, 0); gtk_widget_show(toolbar); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); gtk_widget_show(hbox); make_safe_filename(buff, remote->nick); if ((cw->fp = fopen(buff, "a")) == NULL) { perror(buff); do_logging=0; } if(do_logging) { time_t my_time = time(NULL); fprintf(cw->fp, _("%sConversation started on %s %s\n"), (do_strip_html ? "" : "<HR WIDTH=\"100%%\"><P ALIGN=\"CENTER\"><B>"), g_strchomp(asctime(localtime(&my_time))), (do_strip_html?"":"</B></P>")); fflush(cw->fp); } gtk_widget_show(cw->chat); gtk_widget_show(cw->entry); /* gtk_widget_show(vbox); gtk_widget_show(cw->notebook); */ return cw; }

void eb_log_message (  FILE *    log_file, gchar    buff[], gchar *    message )

Definition at line 2227 of file chat_window.c. References strip_html(). Referenced by eb_chat_window_display_remote_message(), eb_log_status_changed(), and send_message(). { gchar * my_name = strdup(buff); gchar * my_message = strdup(message); /* Get rid of the HTML if the user doesn't want it */ if(do_strip_html) { strip_html(my_message); strip_html(my_name); } /* Log the message, using the appropriate formatting */ fprintf(log_file, "%s %s %s %s\n", (do_strip_html ? "" : "<P>"), my_name, my_message, (do_strip_html ? "" : "</P>")); fflush(log_file); free(my_message); free(my_name); }

void eb_log_status_changed (  eb_account *    ea, gchar *    status )

Definition at line 2216 of file chat_window.c. References account::account_contact, contact::chatwindow, eb_log_message(), _chat_window::fp, and account::handle. Referenced by buddy_update_status_and_log(). { if(ea == NULL || ea->account_contact == NULL || ea->account_contact->chatwindow == NULL || ea->account_contact->chatwindow->fp == NULL) return; eb_log_message(ea->account_contact->chatwindow->fp, ea->handle, ((status && status[0])?status:"Available")); }

void eb_restore_last_conv (  gchar *    file_name, chat_window *    cw )

Definition at line 2250 of file chat_window.c. References _, BUF_SIZE, _chat_window::chat, _chat_window::contact, EXT_GTK_TEXT, gtk_eb_html_add(), contact::nick, and strip_html(). Referenced by eb_chat_window_display_account(), eb_chat_window_display_contact(), and eb_chat_window_display_remote_message(). { FILE * fp; gchar buff[1024]; gchar buff2[1024]; gchar *buff3; gchar color[8]; gchar name[512]; gchar *token; long location = -1; long lastlocation = -1; long beforeget; if ( (fp = fopen(file_name, "r")) == NULL) { //there must not be a list logfile... return; } /*find last conversation */ while(!feof(fp)) { beforeget = ftell(fp); fgets(buff, 1024, fp); if(feof(fp)) { break; } g_strchomp(buff); if(!strncmp(buff,_("Conversation started"),strlen(_("Conversation started"))) || !strncmp(buff,_("<HR WIDTH=\"100%\"><P ALIGN=\"CENTER\"><B>Conversation started"),strlen(_("<HR WIDTH=\"100%\"><P ALIGN=\"CENTER\"><B>Conversation started")))) { lastlocation = location; location = beforeget; } } if(lastlocation == -1) { if(location == -1 || location == 0) { fclose(fp); return; } lastlocation = location; } fseek(fp,lastlocation, SEEK_SET); /* now we display the log */ while(!feof(fp)) { fgets(buff,1024,fp); if(feof(fp)) { break; } g_strchomp(buff); if(buff[0] == '<') /*this is html*/ { if(!strncmp(buff,"<HR WIDTH=\"100%\">", strlen("<HR WIDTH=\"100%\">"))) { gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff+strlen("<HR WIDTH=\"100%\">"),0,0,0); } else { gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff, 0,0,0); } gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<br>",0,0,0); if(strlen(buff) > 34 && !strncmp(buff+34,_("ended on"),8)) { break; } } else if(!strncmp(buff,_("Conversation started"),strlen(_("Conversation started")))) { gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<hr>", 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff, 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<br>",0,0,0); } else if(!strncmp(buff,_("Conversation ended"),strlen(_("Conversation ended")))) { gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<br>",0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<hr>",0,0,0); break; } else { strip_html(buff); /*better safe than sorry */ strcpy(buff2, buff); token = strtok(buff2,":"); if(token && (strcmp(buff,token) != 0)) { /* not happy with this if statement at all! */ if(((strlen(token)==3)&&isdigit((int)token[1])&&isdigit(token[2])) || ((strlen(token)==2) && isdigit((int)token[1]))) { /* we must have time stamps */ /* allready have hours */ token = strtok(NULL,":"); /*minutes*/ if(token == NULL) /* we were wrong, this isn't a time stamp */ { break; /* need to test this */ } token = strtok(NULL,":"); /*seconds + name*/ if(token == NULL) /* we were wrong, this isn't a time stamp */ break; /* need to test this */ buff3 = token + strlen(token)+1; /* should be the end of the screen name */ token+=3; } else { /* no time stamps */ buff3 = buff2+strlen(token)+1; token++; } if( !strncmp(token,cw->contact->nick,strlen(cw->contact->nick))) { /* this is the other person */ strcpy(color,"#ff0000"); } else { /* must be me */ strcpy(color,"#0000ff"); } strncpy(name,buff,buff3-buff2); name[buff3-buff2] = '\0'; g_snprintf(buff, BUF_SIZE, "<FONT COLOR=\"%s\"><B>%s </B></FONT>",color, name); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), buff3,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<br>",0,0,0); } else { /* hmm, no ':' must be a non start/blank line */ gtk_eb_html_add(EXT_GTK_TEXT(cw->chat),buff2,0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(cw->chat), "<br>",0,0,0); } } } fclose(fp); }

void eb_update_window_title (  chat_window *    cw, gboolean    new_message )

Definition at line 2470 of file chat_window.c. References local_account::alias, BUF_SIZE, contact::chatwindow, _chat_window::contact, find_tabbed_current_chat_window(), GET_SERVICE, account::handle, _chat_window::local_user, contact::nick, _chat_window::notebook, _chat_window::perfered, and _chat_window::window. Referenced by chat_key_press(), eb_chat_window_display_account(), eb_chat_window_display_remote_message(), handle_focus(), and send_message(). { char buff[BUF_SIZE]; if (!do_tabbed_chat && cw != NULL && cw->contact != NULL && cw->perfered != NULL && cw->local_user != NULL && GET_SERVICE (cw->local_user).name != NULL) { g_snprintf (buff, BUF_SIZE, "%s%s (%s <=> %s via %s)", new_message == TRUE ? "* " : "", cw->contact->nick, cw->local_user->alias, cw->perfered->handle, GET_SERVICE (cw->local_user).name); gtk_window_set_title (GTK_WINDOW (cw->contact->chatwindow->window), buff); } else if (do_tabbed_chat) { if (!new_message) cw = find_tabbed_current_chat_window (); if (cw && cw->notebook != NULL && cw->contact != NULL && cw->local_user != NULL && cw->perfered != NULL && GET_SERVICE (cw->local_user).name != NULL) { g_snprintf (buff, BUF_SIZE, "%s%s (%s <=> %s via %s)", new_message == TRUE ? "* " : "", cw->contact->nick, cw->local_user->alias, cw->perfered->handle, GET_SERVICE (cw->local_user).name); gtk_window_set_title (GTK_WINDOW (cw->contact->chatwindow->window), buff); } } }

void eb_update_window_title_to_tab (  int    tab, gboolean    new_message )

Definition at line 2438 of file chat_window.c. References local_account::alias, BUF_SIZE, contact::chatwindow, _chat_window::contact, find_tabbed_chat_window_index(), GET_SERVICE, account::handle, _chat_window::local_user, contact::nick, _chat_window::notebook, _chat_window::perfered, and _chat_window::window. Referenced by chat_notebook_switch_callback(). { char buff[BUF_SIZE]; chat_window * cw = NULL; cw = find_tabbed_chat_window_index(tab); if (cw && cw->notebook != NULL && cw->contact != NULL && cw->local_user != NULL && cw->perfered != NULL && GET_SERVICE (cw->local_user).name != NULL) { g_snprintf (buff, BUF_SIZE, "%s%s (%s <=> %s via %s)", new_message == TRUE ? "* " : "", cw->contact->nick, cw->local_user->alias, cw->perfered->handle, GET_SERVICE (cw->local_user).name); gtk_window_set_title (GTK_WINDOW (cw->contact->chatwindow->window), buff); } else if(cw && cw->contact != NULL) { gtk_window_set_title (GTK_WINDOW (cw->contact->chatwindow->window), cw->contact->nick); } }

void end_conversation (  chat_window *    cw )  [static]

Definition at line 241 of file chat_window.c. References _, contact::accounts, contact::chatwindow, _chat_window::contact, _chat_window::fp, _chat_window::history, RUN_SERVICE, and account::service_id. Referenced by destroy_event(). { GList * node; /* cw->window=NULL; */ /* will this fix the weird tabbed chat segfault? */ if (cw->contact != NULL) { cw->contact->chatwindow = NULL; } /* * Some protocols like MSN and jabber require that something * needs to be done when you stop a conversation * for every protocol that requires it we call their terminate * method */ for(node = cw->contact->accounts; node; node = node->next) { eb_account *ea = (eb_account*)(node->data); if(eb_services[ea->service_id].sc->terminate_chat) { RUN_SERVICE(ea)->terminate_chat(ea); } } for(node=cw->history; node!=NULL; node=node->next) { free(node->data); node->data=NULL; } g_list_free(cw->history); /* * if we are logging conversations, time stamp when the conversation * has ended */ if(do_logging) { time_t my_time = time(NULL); fprintf(cw->fp, _("%sConversation ended on %s %s\n"), (do_strip_html ? "" : "<P ALIGN=\"CENTER\"><B>"), g_strchomp(asctime(localtime(&my_time))), (do_strip_html ? "" : "</B></P>")); } /* * close the log file */ if ((cw->fp != NULL )) fclose(cw->fp); /* * and free the memory we allocated to the chat window * NOTE: a memset is done to flush out bugs related to the * tabbed chat window */ memset(cw, 0, sizeof(chat_window)); g_free(cw); }

chat_window* find_tabbed_chat_window (    )  [static]

Definition at line 1228 of file chat_window.c. References contact::chatwindow, and _chat_window::notebook. Referenced by eb_chat_window_new(), find_tabbed_chat_window_index(), and find_tabbed_current_chat_window(). { GList * l1; GList * l2; struct contact* c; for(l1 = groups; l1; l1=l1->next ) { for(l2 = ((grouplist*)l1->data)->members; l2; l2=l2->next ) { c = (struct contact*)l2->data; if (c->chatwindow != NULL) { if (c->chatwindow->notebook != NULL) { return c->chatwindow; } } } } return NULL; }

chat_window* find_tabbed_chat_window_index (  int    current_page )  [static]

Definition at line 1251 of file chat_window.c. References contact::chatwindow, find_tabbed_chat_window(), and _chat_window::notebook_child. Referenced by eb_update_window_title_to_tab(). { GList *l1; GList *l2; struct contact *c; chat_window *notebook_window = find_tabbed_chat_window (); if (notebook_window == NULL || notebook_window->notebook == NULL) { return NULL; } for (l1 = groups; l1; l1 = l1->next) { for (l2 = ((grouplist *) l1->data)->members; l2; l2 = l2->next) { c = (struct contact *) l2->data; if (c->chatwindow != NULL) { if (gtk_notebook_page_num (GTK_NOTEBOOK (notebook_window->notebook), c->chatwindow->notebook_child) == current_page) { return c->chatwindow; } } } } return NULL; }

chat_window* find_tabbed_current_chat_window (    )  [static]

Definition at line 1284 of file chat_window.c. References contact::chatwindow, find_tabbed_chat_window(), _chat_window::notebook, and _chat_window::notebook_child. Referenced by eb_update_window_title(). { GList *l1; GList *l2; struct contact *c; int current_page = 0; chat_window *notebook_window = find_tabbed_chat_window (); if (notebook_window == NULL || notebook_window->notebook == NULL) { return NULL; } current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook_window->notebook)); for (l1 = groups; l1; l1 = l1->next) { for (l2 = ((grouplist *) l1->data)->members; l2; l2 = l2->next) { c = (struct contact *) l2->data; if (c->chatwindow != NULL) { if (gtk_notebook_page_num (GTK_NOTEBOOK (notebook_window->notebook), c->chatwindow->notebook_child) == current_page) { return c->chatwindow; } } } } return NULL; }

GtkWidget* get_local_accounts (  chat_window *    cw )

Definition at line 864 of file chat_window.c. References _, local_account::alias, change_local_account_on_click(), _chat_window::contact, _chat_window_account::cw, _chat_window_account::data, DBG_CORE, eb_debug, find_local_account_for_remote(), find_suitable_remote_account(), get_service_name(), account::handle, _chat_window::perfered, and local_account::service_id. Referenced by handle_click(). { GtkWidget *submenu, *label, *button; char *handle=NULL, buff[256]; eb_local_account *first_act=NULL, *subsequent_act=NULL; chat_window_account *cwa=NULL; /* Do we have a preferred remote account, no, get one */ if(!cw->perfered) { cw->perfered = find_suitable_remote_account(NULL, cw->contact); if(!cw->perfered) /* The remote user is not online */ return(NULL); } handle=cw->perfered->handle; eb_debug(DBG_CORE, "Setting menu item with label: %s\n", handle); /* Check to see if we have at least 2 local accounts suitable for the remote account */ first_act = find_local_account_for_remote(cw->perfered, TRUE); subsequent_act = find_local_account_for_remote(NULL, TRUE); if(!first_act || !subsequent_act) return(NULL); first_act = find_local_account_for_remote(cw->perfered, TRUE); /* Start building the menu */ label = gtk_menu_item_new_with_label(_("Change Local Account")); submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(label), submenu); subsequent_act = first_act; do { sprintf(buff, "%s:%s", get_service_name(subsequent_act->service_id), subsequent_act->alias); button = gtk_menu_item_new_with_label(buff); gtk_menu_append(GTK_MENU(submenu), button); cwa = g_new0(chat_window_account, 1); cwa->cw=cw; cwa->data=subsequent_act; gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(change_local_account_on_click), cwa); gtk_widget_show(button); } while( (subsequent_act = find_local_account_for_remote(NULL, TRUE))); gtk_widget_show(label); gtk_widget_show(submenu); return(label); }

void handle_click (  GtkWidget *    widget, GdkEventButton *    event, gpointer    userdata )  [static]

Definition at line 920 of file chat_window.c. References _, add_unknown_callback(), allow_offline_on_click(), can_offline_message(), close_tab_callback(), close_win(), ebmContactData::contact, _chat_window::contact, menu_item_data::data, DBG_CORE, EB_CHAT_WINDOW_MENU, eb_debug, ebmContactData_new(), get_local_accounts(), GetPref(), contact::group, ignore_callback(), menu_item_data::label, menu_data::menu_items, _grouplist::name, contact::nick, send_file(), send_message(), set_sound_on_click(), _chat_window::sound_enabled, and view_log_callback(). Referenced by eb_chat_window_new(). { chat_window * cw = (chat_window*)userdata; if (event->type == GDK_BUTTON_PRESS && event->button == 3) { GtkWidget *menu; GtkWidget *button; menu_data *md=NULL; menu_item_data *mid=NULL; ebmContactData *ecd=NULL; GList *list=NULL; gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event"); menu = gtk_menu_new(); /*Add Contact Selection*/ if(!strcmp(cw->contact->group->name, _("Unknown"))) { button = gtk_menu_item_new_with_label(_("Add Contact")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(add_unknown_callback), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); } /*Allow Offline Messaging Selection*/ if(can_offline_message(cw->contact)) { button = gtk_menu_item_new_with_label(_("Offline Messaging")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(allow_offline_on_click), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); } /*Allow account selection when there are multiple accounts for the same protocl */ button = get_local_accounts(cw); if(button) gtk_menu_append(GTK_MENU(menu), button); /*Sound Selection*/ if (cw->sound_enabled) button = gtk_menu_item_new_with_label(_("Disable Sounds")); else button = gtk_menu_item_new_with_label(_("Enable Sounds")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(set_sound_on_click), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); /*View log selection*/ button = gtk_menu_item_new_with_label(_("View Log")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(view_log_callback), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); /*Send File Selection*/ button = gtk_menu_item_new_with_label(_("Send File")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(send_file), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); /*Ignore Section*/ button = gtk_menu_item_new_with_label(_("Ignore Contact")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(ignore_callback), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); /*Send message Section*/ button = gtk_menu_item_new_with_label(_("Send Message")); gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(send_message), cw); gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); /*Add Plugin Menus*/ md = GetPref(EB_CHAT_WINDOW_MENU); if(md) { for(list = md->menu_items; list; list = g_list_next(list) ) { ecd=ebmContactData_new(); ecd->contact=cw->contact->nick; mid=(menu_item_data *)list->data; mid->data=(ebmCallbackData *)ecd; eb_debug(DBG_CORE, "adding chat window item: %s\n", mid->label); button = gtk_menu_item_new_with_label(mid->label); gtk_menu_append(GTK_MENU(menu), button); gtk_signal_connect(GTK_OBJECT(button), "activate", eb_generic_menu_function, mid); gtk_widget_show(button); } } /*Close Selection*/ button = gtk_menu_item_new_with_label(_("Close")); if (do_tabbed_chat) { gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(close_tab_callback), cw); } else { gtk_signal_connect(GTK_OBJECT(button), "activate", GTK_SIGNAL_FUNC(close_win), cw); } gtk_menu_append(GTK_MENU(menu), button); gtk_widget_show(button); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time ); } }

void handle_focus (  GtkWidget *    widget, GdkEventFocus *    event, gpointer    userdata )  [static]

Definition at line 910 of file chat_window.c. References eb_update_window_title(). Referenced by eb_chat_window_new(). { chat_window * cw = (chat_window *)userdata; eb_update_window_title(cw, FALSE); }

void ignore_callback (  GtkWidget *    ignore_button, gpointer    userdata )  [static]

Definition at line 734 of file chat_window.c. References _, BUF_SIZE, _chat_window::contact, do_dialog(), GET_CHAT_WINDOW, ignore_dialog_callback(), and contact::nick. Referenced by eb_chat_window_new(), and handle_click(). { chat_window * cw = (chat_window *)userdata; gchar *buff = (gchar *)g_new0(gchar *, BUF_SIZE); GET_CHAT_WINDOW(cw); g_snprintf(buff, BUF_SIZE, _("Do you really want to ignore %s?\n"), cw->contact->nick); do_dialog(buff, _("Ignore Contact"), ignore_dialog_callback, cw->contact); g_free(buff); }

void ignore_dialog_callback (  GtkWidget *    widget, gpointer    userdata )  [static]

Definition at line 720 of file chat_window.c. References _, move_contact(), update_contact_list(), and write_contact_list(). Referenced by ignore_callback(). { struct contact *c = (struct contact *)userdata; int response = (int)gtk_object_get_user_data(GTK_OBJECT(widget)); if (response) { move_contact(_("Ignore"), c); update_contact_list (); write_contact_list(); } }

void insert_smiley (  GtkWidget *    widget, chat_window *    cw )  [static]

Definition at line 602 of file chat_window.c. References _chat_window::entry, GET_CHAT_WINDOW, and _chat_window::smiley_window. Referenced by show_smileys_callback(). { gint pos=0; GET_CHAT_WINDOW(cw); if(GTK_EDITABLE(cw->entry) && GTK_EDITABLE(cw->entry)->current_pos) pos=GTK_EDITABLE(cw->entry)->current_pos; gtk_editable_insert_text(GTK_EDITABLE (cw->entry), gtk_widget_get_name(widget), strlen(gtk_widget_get_name(widget)), &pos); gtk_widget_destroy(cw->smiley_window); cw->smiley_window = NULL; }

void send_file (  GtkWidget *    sendf_button, gpointer    userdata )  [static]

Definition at line 747 of file chat_window.c. References _chat_window::chat, _chat_window::contact, eb_do_send_file(), EXT_GTK_TEXT, find_suitable_remote_account(), GET_CHAT_WINDOW, gtk_eb_html_add(), contact::online, and _chat_window::perfered. Referenced by eb_chat_window_new(), and handle_click(). { eb_account *ea; chat_window *data = (chat_window*)userdata; GET_CHAT_WINDOW(data); if ( data->contact->online == 0 ) { gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<hr>", 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<b>Cannot send message - user is offline.</b>", 0, 0, 0); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<hr>", 0,0,0); return; } ea = find_suitable_remote_account(data->perfered, data->contact); eb_do_send_file(ea); }

void send_message (  GtkWidget *    widget, gpointer    d )

Definition at line 395 of file chat_window.c. References local_account::alias, _chat_window::away_msg_sent, BUF_SIZE, can_offline_message(), _chat_window::chat, local_account::connected, _chat_window::contact, convert_eol(), DBG_CORE, eb_debug, eb_log_message(), eb_smilify(), eb_update_window_title(), _chat_window::entry, EXT_GTK_TEXT, find_suitable_local_account(), find_suitable_remote_account(), _chat_window::fp, GET_CHAT_WINDOW, gtk_eb_html_add(), _chat_window::hist_pos, _chat_window::history, linkify(), _chat_window::local_user, _chat_window::notebook, _chat_window::notebook_child, outgoing_message_filters, _chat_window::perfered, play_sound(), RUN_SERVICE, SEND, _chat_window::send_enabled, contact::send_offline, serv_touch_idle(), local_account::service_id, account::service_id, set_tab_normal(), _chat_window::sound_enabled, and _chat_window::this_msg_in_history. Referenced by chat_key_press(), console_session_get_command(), eb_chat_window_display_remote_message(), eb_chat_window_new(), handle_click(), and pounce_contact(). { chat_window * data = (chat_window*)d; gchar buff[BUF_SIZE]; gchar buff2[BUF_SIZE]; gchar * text, *o_text; gchar * link_message; gchar * temp_message; struct tm * cur_time; time_t t; GList * filter_walk; #ifdef HAVE_ICONV_H /* 'BUF_SIZE*2' e.g. for 'Latin-x' to 'UTF-8', which is 1-byte to 2-byte recoding */ char recode_buff[BUF_SIZE*2 + 1]; #endif GET_CHAT_WINDOW(data); /*determine what is the best account to send to*/ data->perfered= find_suitable_remote_account(data->perfered, data->contact); if(!data->perfered) { /*Eventually this will need to become a dialog box that pops up*/ if(data->contact->send_offline && can_offline_message(data->contact)) { data->perfered = can_offline_message(data->contact); } else { gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<hr>", 0,0,0); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<b>Cannot send message - user is offline.</b>", 0, 0, 0); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<hr>", 0,0,0); return; } } if(data->local_user && data->local_user->service_id != data->perfered->service_id) { data->local_user = NULL; } if(data->local_user && !data->local_user->connected) { data->local_user = NULL; } /*determine what is the best local account to use*/ if(!data->local_user) { data->local_user = find_suitable_local_account(data->local_user, data->perfered->service_id); } if(!data->local_user) { return; } eb_update_window_title(data, FALSE); text = gtk_editable_get_chars(GTK_EDITABLE (data->entry), 0, -1); if(strlen(text) == 0) return; if(data->this_msg_in_history) { GList * node=NULL; GList * node2=NULL; for(node=data->history; node!=NULL ; node=node->next) { node2=node; } free(node2->data); node2->data=strdup(text); data->this_msg_in_history=0; } else { data->history=g_list_append(data->history, strdup(text)); data->hist_pos=NULL; } temp_message = eb_smilify(strdup(text), RUN_SERVICE(data->local_user)->get_smileys()); link_message = linkify(temp_message); g_free(temp_message); eb_update_window_title(data, FALSE); // Outbound filters here - Meredydd filter_walk=outgoing_message_filters; eb_debug(DBG_CORE, "Starting to run outgoing filters\n"); while(filter_walk!=NULL) { gchar * (*ifilter)(eb_local_account *, eb_account *, struct contact *, gchar *); eb_debug(DBG_CORE, "Running an outgoing filter\n"); ifilter=(gchar *(*)(eb_local_account *, eb_account *, struct contact *, gchar *))filter_walk->data; text=ifilter(data->local_user, data->perfered, data->contact, text); if(text==NULL) { return; } // Urgh, no cleanup, but it does it on strlen(text)==0 too filter_walk=g_list_next(filter_walk); } eb_debug(DBG_CORE, "Finished outgoing filters\n"); // end outbound filters o_text = text; text = convert_eol(text); g_free(o_text); #ifdef HAVE_ICONV_H if(!eb_services[data->perfered->service_id].can_iconvert) { RUN_SERVICE(data->local_user)->send_im( data->local_user, data->perfered, text); } else { RUN_SERVICE(data->local_user)->send_im( data->local_user, data->perfered, recode_if_needed(text, recode_buff, RECODE_TO_REMOTE) ); } /* seems like variable 'text' is not used any more down the function, so we don't have to assign it (BTW it's freed in the end)*/ #else RUN_SERVICE(data->local_user)->send_im( data->local_user, data->perfered, text); #endif serv_touch_idle(); if(data->sound_enabled && data->send_enabled) play_sound(SEND); if (do_convo_timestamp) { time(&t); cur_time = localtime(&t); g_snprintf(buff2, BUF_SIZE, "%d:%.2d:%.2d %s", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec, data->local_user->alias); } else { g_snprintf(buff2, BUF_SIZE, "%s", data->local_user->alias); } g_snprintf(buff, BUF_SIZE, "<FONT COLOR=\"#0000ff\"><B>%s: </B></FONT>", buff2); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), buff, 1, 0, 0); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), link_message, do_ignore_back, do_ignore_fore, do_ignore_font); gtk_eb_html_add(EXT_GTK_TEXT(data->chat), "<br>", 0, 0, 0); /* If an away message had been sent to this person, reset the away message tracker */ /* It's probably faster to just do the assignment all the time--the test is there for code clarity. */ if (data->away_msg_sent) { data->away_msg_sent = FALSE; } /* Log the message */ if(do_logging) eb_log_message(data->fp, buff, link_message); gtk_editable_delete_text(GTK_EDITABLE (data->entry), 0, -1); g_free(link_message); g_free(text); /* if using tabs, then turn off the chat icon */ if (data->notebook != NULL) { /* no more icons in the tabs */ /* gtk_widget_hide(data->talk_pixmap); */ /* printf("chat icon is off... \n"); */ set_tab_normal(GTK_NOTEBOOK(data->notebook), data->notebook_child); } }

void send_typing_status (  chat_window *    cw )  [static]

Definition at line 1047 of file chat_window.c. References _chat_window::contact, find_suitable_local_account(), find_suitable_remote_account(), _chat_window::local_user, _chat_window::next_typing_send, _chat_window::perfered, RUN_SERVICE, and account::service_id. Referenced by chat_key_press(), and chat_singleline_key_press(). { /* typing send code */ time_t now=time(NULL); if(!do_send_typing_notify) return; if(now>=cw->next_typing_send) { if(!cw->perfered) { if(!cw->contact) return; cw->perfered = find_suitable_remote_account(NULL, cw->contact); if(!cw->perfered) /* The remote user is not online */ return; } cw->local_user=find_suitable_local_account(cw->local_user, cw->perfered->service_id); if(cw->local_user==NULL) { return; } if(RUN_SERVICE(cw->local_user)->send_typing!=NULL) { cw->next_typing_send=now + RUN_SERVICE(cw->local_user)->send_typing(cw->local_user, cw->perfered); } } }

void set_sound_on_click (  GtkWidget *    button, gpointer    userdata )  [static]

Definition at line 781 of file chat_window.c. References GET_CHAT_WINDOW, _chat_window::sound_button, and _chat_window::sound_enabled. Referenced by eb_chat_window_new(), and handle_click(). { chat_window * cw = (chat_window *)userdata; GET_CHAT_WINDOW(cw); if (cw->sound_enabled) { cw->sound_enabled = FALSE; gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->sound_button), FALSE); } else { cw->sound_enabled = TRUE; gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(cw->sound_button), TRUE); } }

void set_sound_on_toggle (  GtkWidget *    sound_button, gpointer    userdata )  [static]

Definition at line 769 of file chat_window.c. References _chat_window::sound_enabled. Referenced by eb_chat_window_new(). { chat_window * cw = (chat_window *)userdata; /*Set the sound_enable variable depending on the toggle button*/ if (GTK_TOGGLE_BUTTON (sound_button)->active) cw->sound_enabled = TRUE; else cw->sound_enabled = FALSE; }

void set_tab_normal (  GtkNotebook *    notebook, GtkWidget *    child )  [static]

Definition at line 219 of file chat_window.c. Referenced by chat_notebook_switch_callback(), eb_chat_window_display_account(), eb_chat_window_display_contact(), and send_message(). { GtkStyle *style; GdkColor color; GtkWidget *label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), child); gtk_widget_realize(label); color.red = 0; color.green = 0; color.blue = 0; style = gtk_style_new(); gdk_font_unref(style->font); style->font = gdk_font_ref(label->style->font); style->fg[0] = GTK_WIDGET(notebook)->style->fg[0]; gtk_widget_set_style(label, style); gtk_style_unref(style); }

void set_tab_red (  GtkNotebook *    notebook, GtkWidget *    child )  [static]

Definition at line 195 of file chat_window.c. Referenced by eb_chat_window_display_remote_message(). { GtkStyle *style; GdkColor color; GtkWidget *label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook), child); gtk_widget_realize(label); color.red = 65000; color.green = 0; color.blue = 0; style = gtk_style_new(); gdk_font_unref(style->font); style->font = gdk_font_ref(label->style->font); style->fg[0] = color; gtk_widget_set_style(label, style); }

void show_smileys_callback (  GtkWidget *    widget, gpointer    d )  [static]

Definition at line 616 of file chat_window.c. References get_smiley_by_name(), insert_smiley(), _chat_window::local_user, protocol_smiley_struct::name, smiley_struct::pixmap, RUN_SERVICE, _chat_window::smiley_window, protocol_smiley_struct::text, and _chat_window::window. Referenced by eb_chat_window_new(). { chat_window *data = (chat_window*) d; GList *smileys = NULL; protocol_smiley * msmiley = NULL; GtkWidget * smileys_table = NULL; GtkWidget * button = NULL; GtkWidget *iconwid; GdkPixmap *icon; GdkBitmap *mask; GList *done = NULL; int len = 0, real_len = 0, x=-1, y=0; int win_w=0, win_h=0, w, h; gint win_x, win_y; if(data->smiley_window != NULL) { /* close popup */ gtk_widget_destroy(data->smiley_window); data->smiley_window = NULL; return; } if (data && data->local_user && RUN_SERVICE(data->local_user)) smileys = RUN_SERVICE(data->local_user)->get_smileys(); else return; len = g_list_length(smileys); smileys_table = gtk_table_new(5,len/5 +((len%5==0)?1:2),TRUE); for(;smileys;smileys=g_list_next(smileys)) { GList * l; gboolean already_done = FALSE; smiley * dsmile = NULL; msmiley = (smileys->data); for(l=done; l; l=g_list_next(l)) { if(!strcmp((char*)l->data, msmiley->name)) { already_done = TRUE; break; } } if(already_done) continue; done = g_list_append(done, msmiley->name); dsmile = get_smiley_by_name(msmiley->name); if(dsmile != NULL) { icon = gdk_pixmap_create_from_xpm_d(data->window->window, &mask, NULL, dsmile->pixmap); iconwid = gtk_pixmap_new(icon, mask); sscanf (dsmile->pixmap [0], "%d %d", &w, &h); if(x<5) { x++; if(y==0) win_h+=h+2; } if(x==5) { y++; x=0; if(x==0) win_w+=w+2; } gtk_widget_show(iconwid); button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_container_add(GTK_CONTAINER(button), iconwid); gtk_widget_show(button); gtk_widget_set_name(button,msmiley->text); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (insert_smiley), data); gtk_table_attach(GTK_TABLE(smileys_table), button, y,y+1, x,x+1, GTK_FILL, GTK_FILL, 0, 0); real_len++; } } g_list_free(done); done = NULL; gtk_table_resize(GTK_TABLE(smileys_table), 5,real_len/5 +((real_len%5==0)?0:1)); data->smiley_window = gtk_window_new(GTK_WINDOW_DIALOG); gtk_window_set_modal(GTK_WINDOW(data->smiley_window), FALSE); gtk_window_set_wmclass(GTK_WINDOW(data->smiley_window), "yattm-chat", "Yattm"); gtk_window_set_title(GTK_WINDOW(data->smiley_window), "Smileys"); gtk_window_set_policy(GTK_WINDOW(data->smiley_window), FALSE, FALSE, FALSE); gtk_widget_realize(data->smiley_window); gtk_widget_show(data->smiley_window); gtk_container_add(GTK_CONTAINER(data->smiley_window), smileys_table); gtk_widget_show(smileys_table); /* move the window a bit after the cursor and in the screen */ gdk_window_get_pointer (NULL, &win_x, &win_y, NULL); win_x += 5; win_y += 5; while ((win_x)+win_w > gdk_screen_width() - 30) win_x -= 20; while ((win_y)+win_h > gdk_screen_height() - 30) win_y -= 20; gdk_window_move_resize(data->smiley_window->window, win_x, win_y, win_w, win_h); }

void view_log_callback (  GtkWidget *    widget, gpointer    d )  [static]

Definition at line 595 of file chat_window.c. References _chat_window::contact, eb_view_log(), and GET_CHAT_WINDOW. Referenced by eb_chat_window_new(), and handle_click(). { chat_window* data = (chat_window*)d; GET_CHAT_WINDOW(data); eb_view_log(data->contact); }

---

Variable Documentation

GList* incoming_message_filters = NULL

Definition at line 193 of file chat_window.c. Referenced by eb_chat_window_display_remote_message().

GList* outgoing_message_filters = NULL

Definition at line 192 of file chat_window.c. Referenced by send_message().

---

Contact: Andy Maloney     [Documentation generated by doxygen]