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

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
 *
 */

/*
 * chat_window.c
 * implementation for the conversation window
 * This is the window where you will be doing most of your talking :)
 *
 */

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

#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"

#define BUF_SIZE 1024  /* Maximum message length */
#ifndef NAME_MAX
#define NAME_MAX 4096
#endif


#ifdef HAVE_ICONV_H
#include <iconv.h>
#include <errno.h>

/*
    Recodes source text with iconv() and puts it in translated_text
    returns pointer to recoded text
*/

#define RECODE_TO_REMOTE    1
#define RECODE_TO_LOCAL     0

/* forward declaration */
static chat_window * find_tabbed_chat_window_index (int current_page);
char *
recode_if_needed(char * source_text, char * recoded_text, int direction)
{
  size_t inleft;
  size_t outleft;
  char * ptr_src_text = source_text;
  char * ptr_recoded_text = recoded_text;
  iconv_t conv_desc;
  int tries;

  if( use_recoding == 1 )
    {
      if( direction == RECODE_TO_REMOTE )
    {
      conv_desc = iconv_open( cGetLocalPref("remote_encoding"), cGetLocalPref("local_encoding") );
    }
      else
    {
      conv_desc = iconv_open( cGetLocalPref("local_encoding"), cGetLocalPref("remote_encoding") );
    }

      if( conv_desc != (iconv_t)(-1) )
    {
      ptr_src_text = source_text;
      inleft = strlen(source_text) + 1;
      /* 'inleft*2' e.g. for 'Latin-x' to 'UTF-8', 
         which is 1-byte to 2-byte recoding */
      outleft = inleft * 2 + 1;
        
      for(tries = 0; tries < 4; tries++ )
        {
          if( iconv(conv_desc, &ptr_src_text, &inleft,
            &ptr_recoded_text, &outleft) == (size_t)(-1) )
        {
          if( inleft && errno == EILSEQ )
            {
            
              /* errno == EILSEQ, ptr_sec_text -> offending symbol
             errno == EIBVAL, ptr_sec_text -> beginning of incomplete mb seq
             errno == E2BIG (output buf is too small)
              */
        
              if( tries == 3 )
            {
              strcpy( ptr_recoded_text, ptr_src_text );
              fprintf( stderr, "Yattm: recoding broke 3 times,"
                   " leaving the rest of the line as it is...\n");
              break;
            } else
              {
                /* trying to skip offending character
                   this may break input stream if it's multibyte
                */
                *ptr_recoded_text = '.'; /*  *ptr_src_text;  */
                ptr_recoded_text++;
                ptr_src_text++;
                inleft--;
                outleft--;
                fprintf( stderr, "Yattm: charachter cannot be recoded, "
                     "trying to skip it...\n");
                continue;
              }
            }
          else if (errno == EINVAL )
            {
              fprintf( stderr, "Yattm: recoding broke - "
                   "incomplete multibyte sequence at the end of the line.\n");
              break;
            }
          else if (errno == E2BIG )
            {
              fprintf( stderr, "Yattm: recoding buffer too small?!! Oops! :(\n");
              break;
            }
          else
            {
              fprintf( stderr, "Yattm: unknown recoding error.\n");
              break;
            }
        }
        }
      *(ptr_recoded_text + strlen(ptr_src_text)) = '\0'; // just in case :)

      iconv_close(conv_desc);
      return recoded_text;
    }
      else
    {
      fprintf( stderr, "Yattm: recoding from %s to %s is not valid, sorry!\n"
           "Turning recoding off.\n",
           cGetLocalPref("local_encoding"), cGetLocalPref("remote_encoding"));
      use_recoding = 0;
      return source_text;
    }
    }

  return source_text;
}

#endif  /* HAVE_ICONV_H */


/* declare functions */
void eb_update_window_title(chat_window * cw, gboolean new_message);
void eb_update_window_title_to_tab(int tab, gboolean new_message);

GList *outgoing_message_filters=NULL;
GList *incoming_message_filters=NULL;

static void set_tab_red(GtkNotebook *notebook, GtkWidget *child)
{
  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);


}

static void set_tab_normal(GtkNotebook *notebook, GtkWidget *child)
{
  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);
}


static void end_conversation(chat_window* cw)
{
  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);
}

/*
 * They guy closed the chat window, so we need to clean up
 */

static void destroy_event(GtkWidget *widget, gpointer userdata)
{
  chat_window* cw = (chat_window*)userdata;
  /* gotta clean up all of the people we're talking with */

  end_conversation(cw);
}

static void close_tab_callback(GtkWidget *button, gpointer userdata)
{
  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);
  }
}

static void add_unknown_callback(GtkWidget * add_button, gpointer userdata)
{
  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);
}

#define GET_CHAT_WINDOW(cur_cw) {\
  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; \
  } \
}

void send_message(GtkWidget *widget, gpointer d)
{
  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);
  }
}

/*These are the action handlers for the buttons*/

/*** MIZHI
 * callback function for viewing the log
 */
static void view_log_callback(GtkWidget *widget, gpointer d)
{
    chat_window* data = (chat_window*)d;
    GET_CHAT_WINDOW(data);
    eb_view_log(data->contact);
}

static void insert_smiley (GtkWidget * widget, chat_window * cw) 
{
    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;
}

static void show_smileys_callback(GtkWidget *widget, gpointer d)
{
  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);
  
}

/*This is the callback for ignoring a user*/

static void ignore_dialog_callback (GtkWidget *widget, gpointer userdata)
{
  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();
    }

}

static void ignore_callback (GtkWidget *ignore_button, gpointer userdata)
{
  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);
}

/*This is the callback for file x-fer*/
static void send_file (GtkWidget * sendf_button, gpointer userdata)
{
  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);
}

/*These are the callback for setting the sound*/

static void set_sound_on_toggle(GtkWidget * sound_button, gpointer userdata)
{
  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;
}

static void set_sound_on_click(GtkWidget * button, gpointer userdata)
{
  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);
    }
}

/*This is the callback for closing the window*/

static void close_win (GtkWidget * close_button, gpointer userdata)
{
  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);
}

static void allow_offline_on_toggle (GtkWidget *allow_button, gpointer userdata)
{ 
  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;
    }
}

static void allow_offline_on_click (GtkWidget * button, gpointer userdata)
{
  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);      
    }
}

static void change_local_account_on_click (GtkWidget * button, gpointer userdata)
{
  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);
}

GtkWidget *get_local_accounts(chat_window *cw)
{
      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);
}

static void handle_focus(GtkWidget *widget, GdkEventFocus * event, 
             gpointer userdata)
{
    chat_window * cw = (chat_window *)userdata;
    eb_update_window_title(cw, FALSE);

}

/*This handles the right mouse button clicks*/

static void handle_click(GtkWidget *widget, GdkEventButton * event, 
             gpointer userdata)
{
  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 );
    }
}

static void send_typing_status(chat_window *cw)
{
  /* 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);
    }
  }
}

static gboolean chat_singleline_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  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();
}

static gboolean chat_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  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();
}

static void chat_notebook_switch_callback(GtkNotebook *notebook, GtkNotebookPage *page, gint page_num, gpointer user_data)
{
  /* 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);
        }
      }
    }
    }
}


static chat_window* find_tabbed_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;
}

static chat_window *
find_tabbed_chat_window_index (int current_page)
{
  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;
}
static chat_window *
find_tabbed_current_chat_window ()
{
  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;
}

chat_window * eb_chat_window_new(eb_local_account * local, struct contact * remote)
{
  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_chat_window_display_error(eb_account * remote, gchar * message)
{
  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_do_timestamp(struct contact * c, gboolean online)
{
  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);
}


void eb_chat_window_display_remote_message(eb_local_account * account,
                       eb_account * remote,
                                           struct service * serv,
                       gchar * o_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_contact(struct contact * remote_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_account(eb_account * remote_account)
{
  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_log_status_changed(eb_account *ea, gchar *status)
{
    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_log_message(FILE *log_file, gchar buff[], gchar *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_restore_last_conv(gchar *file_name, chat_window* cw)
{
  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_chat_window_display_status(eb_account * remote,
                   gchar * message)
{
  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_update_window_title_to_tab (int tab, gboolean new_message)
{
  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
eb_update_window_title (chat_window * cw, gboolean new_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);


    }
    }
}

---

Contact: Andy Maloney     [Documentation generated by doxygen]