src/fe-gtk/userlistgui.c

   1 /* X-Chat
   2  * Copyright (C) 1998 Peter Zelezny.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22
  23 #include "fe-gtk.h"
  24
  25 #include <gtk/gtkbox.h>
  26 #include <gtk/gtklabel.h>
  27 #include <gtk/gtkdnd.h>
  28 #include <gtk/gtkentry.h>
  29 #include <gtk/gtktreeview.h>
  30 #include <gtk/gtktreeselection.h>
  31 #include <gtk/gtkscrolledwindow.h>
  32 #include <gtk/gtkcellrendererpixbuf.h>
  33 #include <gtk/gtkcellrenderertext.h>
  34 #include <gtk/gtkliststore.h>
  35 #include <gdk/gdkkeysyms.h>
  36
  37 #include "../common/xchat.h"
  38 #include "../common/util.h"
  39 #include "../common/userlist.h"
  40 #include "../common/modes.h"
  41 #include "../common/notify.h"
  42 #include "../common/xchatc.h"
  43 #include "gtkutil.h"
  44 #include "palette.h"
  45 #include "maingui.h"
  46 #include "menu.h"
  47 #include "pixmaps.h"
  48 #include "userlistgui.h"
  49
  50 #ifdef USE_GTKSPELL
  51 #include <gtk/gtktextview.h>
  52 #endif
  53
  54
  55 enum
  56 {
  57         COL_PIX=0,              // GdkPixbuf *
  58         COL_NICK=1,             // char *
  59         COL_HOST=2,             // char *
  60         COL_USER=3,             // struct User *
  61         COL_GDKCOLOR=4  // GdkColor *
  62 };
  63
  64
  65 GdkPixbuf *
  66 get_user_icon (server *serv, struct User *user)
  67 {
  68         char *pre;
  69         int level;
  70
  71         if (!user)
  72                 return NULL;
  73
  74         /* these ones are hardcoded */
  75         switch (user->prefix[0])
  76         {
  77         case 0: return NULL;
  78         case '@': return pix_op;
  79         case '%': return pix_hop;
  80         case '+': return pix_voice;
  81         }
  82
  83         /* find out how many levels above Op this user is */
  84         pre = strchr (serv->nick_prefixes, '@');
  85         if (pre && pre != serv->nick_prefixes)
  86         {
  87                 pre--;
  88                 level = 0;
  89                 while (1)
  90                 {
  91                         if (pre[0] == user->prefix[0])
  92                         {
  93                                 switch (level)
  94                                 {
  95                                 case 0: return pix_red; /* 1 level above op */
  96                                 case 1: return pix_purple;       /* 2 levels above op */
  97                                 }
  98                                 break;  /* 3+, no icons */
  99                         }
 100                         level++;
 101                         if (pre == serv->nick_prefixes)
 102                                 break;
 103                         pre--;
 104                 }
 105         }
 106
 107         return NULL;
 108 }
 109
 110 void
 111 fe_userlist_numbers (session *sess)
 112 {
 113         char tbuf[256];
 114
 115         if (sess == current_tab || !sess->gui->is_tab)
 116         {
 117                 if (sess->total)
 118                 {
 119                         snprintf (tbuf, sizeof (tbuf), _("%d ops, %d total"), sess->ops, sess->total);
 120                         tbuf[sizeof (tbuf) - 1] = 0;
 121                         gtk_label_set_text (GTK_LABEL (sess->gui->namelistinfo), tbuf);
 122                 } else
 123                 {
 124                         gtk_label_set_text (GTK_LABEL (sess->gui->namelistinfo), NULL);
 125                 }
 126
 127                 if (sess->type == SESS_CHANNEL && prefs.gui_tweaks & 1)
 128                         fe_set_title (sess);
 129         }
 130 }
 131
 132 static void
 133 scroll_to_iter (GtkTreeIter *iter, GtkTreeView *treeview, GtkTreeModel *model)
 134 {
 135         GtkTreePath *path = gtk_tree_model_get_path (model, iter);
 136         if (path)
 137         {
 138                 gtk_tree_view_scroll_to_cell (treeview, path, NULL, TRUE, 0.5, 0.5);
 139                 gtk_tree_path_free (path);
 140         }
 141 }
 142
 143 /* select a row in the userlist by nick-name */
 144
 145 void
 146 userlist_select (session *sess, char *name)
 147 {
 148         GtkTreeIter iter;
 149         GtkTreeView *treeview = GTK_TREE_VIEW (sess->gui->user_tree);
 150         GtkTreeModel *model = gtk_tree_view_get_model (treeview);
 151         GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
 152         struct User *row_user;
 153
 154         if (gtk_tree_model_get_iter_first (model, &iter))
 155         {
 156                 do
 157                 {
 158                         gtk_tree_model_get (model, &iter, COL_USER, &row_user, -1);
 159                         if (sess->server->p_cmp (row_user->nick, name) == 0)
 160                         {
 161                                 if (gtk_tree_selection_iter_is_selected (selection, &iter))
 162                                         gtk_tree_selection_unselect_iter (selection, &iter);
 163                                 else
 164                                         gtk_tree_selection_select_iter (selection, &iter);
 165
 166                                 /* and make sure it's visible */
 167                                 scroll_to_iter (&iter, treeview, model);
 168                                 return;
 169                         }
 170                 }
 171                 while (gtk_tree_model_iter_next (model, &iter));
 172         }
 173 }
 174
 175 char **
 176 userlist_selection_list (GtkWidget *widget, int *num_ret)
 177 {
 178         GtkTreeIter iter;
 179         GtkTreeView *treeview = (GtkTreeView *) widget;
 180         GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
 181         GtkTreeModel *model = gtk_tree_view_get_model (treeview);
 182         struct User *user;
 183         int i, num_sel;
 184         char **nicks;
 185
 186         *num_ret = 0;
 187         /* first, count the number of selections */
 188         num_sel = 0;
 189         if (gtk_tree_model_get_iter_first (model, &iter))
 190         {
 191                 do
 192                 {
 193                         if (gtk_tree_selection_iter_is_selected (selection, &iter))
 194                                 num_sel++;
 195                 }
 196                 while (gtk_tree_model_iter_next (model, &iter));
 197         }
 198
 199         if (num_sel < 1)
 200                 return NULL;
 201
 202         nicks = malloc (sizeof (char *) * (num_sel + 1));
 203
 204         i = 0;
 205         gtk_tree_model_get_iter_first (model, &iter);
 206         do
 207         {
 208                 if (gtk_tree_selection_iter_is_selected (selection, &iter))
 209                 {
 210                         gtk_tree_model_get (model, &iter, COL_USER, &user, -1);
 211                         nicks[i] = g_strdup (user->nick);
 212                         i++;
 213                         nicks[i] = NULL;
 214                 }
 215         }
 216         while (gtk_tree_model_iter_next (model, &iter));
 217
 218         *num_ret = i;
 219         return nicks;
 220 }
 221
 222 void
 223 fe_userlist_set_selected (struct session *sess)
 224 {
 225         GtkListStore *store = sess->res->user_model;
 226         GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sess->gui->user_tree));
 227         GtkTreeIter iter;
 228         struct User *user;
 229
 230         /* if it's not front-most tab it doesn't own the GtkTreeView! */
 231         if (store != (GtkListStore*) gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree)))
 232                 return;
 233
 234         if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter))
 235         {
 236                 do
 237                 {
 238                         gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_USER, &user, -1);
 239
 240                         if (gtk_tree_selection_iter_is_selected (selection, &iter))
 241                                 user->selected = 1;
 242                         else
 243                                 user->selected = 0;
 244
 245                 } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter));
 246         }
 247 }
 248
 249 static GtkTreeIter *
 250 find_row (GtkTreeView *treeview, GtkTreeModel *model, struct User *user,
 251                          int *selected)
 252 {
 253         static GtkTreeIter iter;
 254         struct User *row_user;
 255
 256         *selected = FALSE;
 257         if (gtk_tree_model_get_iter_first (model, &iter))
 258         {
 259                 do
 260                 {
 261                         gtk_tree_model_get (model, &iter, COL_USER, &row_user, -1);
 262                         if (row_user == user)
 263                         {
 264                                 if (gtk_tree_view_get_model (treeview) == model)
 265                                 {
 266                                         if (gtk_tree_selection_iter_is_selected (gtk_tree_view_get_selection (treeview), &iter))
 267                                                 *selected = TRUE;
 268                                 }
 269                                 return &iter;
 270                         }
 271                 }
 272                 while (gtk_tree_model_iter_next (model, &iter));
 273         }
 274
 275         return NULL;
 276 }
 277
 278 void
 279 userlist_set_value (GtkWidget *treeview, gfloat val)
 280 {
 281         gtk_adjustment_set_value (
 282                         gtk_tree_view_get_vadjustment (GTK_TREE_VIEW (treeview)), val);
 283 }
 284
 285 gfloat
 286 userlist_get_value (GtkWidget *treeview)
 287 {
 288         return gtk_tree_view_get_vadjustment (GTK_TREE_VIEW (treeview))->value;
 289 }
 290
 291 int
 292 fe_userlist_remove (session *sess, struct User *user)
 293 {
 294         GtkTreeIter *iter;
 295 /*      GtkAdjustment *adj;
 296         gfloat val, end;*/
 297         int sel;
 298
 299         iter = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
 300                                                   sess->res->user_model, user, &sel);
 301         if (!iter)
 302                 return 0;
 303
 304 /*      adj = gtk_tree_view_get_vadjustment (GTK_TREE_VIEW (sess->gui->user_tree));
 305         val = adj->value;*/
 306
 307         gtk_list_store_remove (sess->res->user_model, iter);
 308
 309         /* is it the front-most tab? */
 310 /*      if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree))
 311                  == sess->res->user_model)
 312         {
 313                 end = adj->upper - adj->lower - adj->page_size;
 314                 if (val > end)
 315                         val = end;
 316                 gtk_adjustment_set_value (adj, val);
 317         }*/
 318
 319         return sel;
 320 }
 321
 322 void
 323 fe_userlist_rehash (session *sess, struct User *user)
 324 {
 325         GtkTreeIter *iter;
 326         int sel;
 327         int do_away = TRUE;
 328
 329         iter = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
 330                                                   sess->res->user_model, user, &sel);
 331         if (!iter)
 332                 return;
 333
 334         if (prefs.away_size_max < 1 || !prefs.away_track)
 335                 do_away = FALSE;
 336
 337         gtk_list_store_set (GTK_LIST_STORE (sess->res->user_model), iter,
 338                                                           COL_HOST, user->hostname,
 339                                                           COL_GDKCOLOR, (do_away)
 340                                                                         ?       (user->away ? &colors[COL_AWAY] : NULL)
 341                                                                         :       (NULL),
 342                                                           -1);
 343 }
 344
 345 void
 346 fe_userlist_insert (session *sess, struct User *newuser, int row, int sel)
 347 {
 348         GtkTreeModel *model = sess->res->user_model;
 349         GdkPixbuf *pix = get_user_icon (sess->server, newuser);
 350         GtkTreeIter iter;
 351         int do_away = TRUE;
 352         char *nick;
 353
 354         if (prefs.away_size_max < 1 || !prefs.away_track)
 355                 do_away = FALSE;
 356
 357         nick = newuser->nick;
 358         if (prefs.gui_tweaks & 64)
 359         {
 360                 nick = malloc (strlen (newuser->nick) + 2);
 361                 nick[0] = newuser->prefix[0];
 362                 if (!nick[0] || nick[0] == ' ')
 363                         strcpy (nick, newuser->nick);
 364                 else
 365                         strcpy (nick + 1, newuser->nick);
 366                 pix = NULL;
 367         }
 368
 369         gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, row,
 370                                                                         COL_PIX, pix,
 371                                                                         COL_NICK, nick,
 372                                                                         COL_HOST, newuser->hostname,
 373                                                                         COL_USER, newuser,
 374                                                                         COL_GDKCOLOR, (do_away)
 375                                                                                 ?       (newuser->away ? &colors[COL_AWAY] : NULL)
 376                                                                                 :       (NULL),
 377                                                                   -1);
 378
 379         if (prefs.gui_tweaks & 64)
 380                 free (nick);
 381
 382         /* is it me? */
 383         if (newuser->me && sess->gui->nick_box)
 384         {
 385                 if (!sess->gui->is_tab || sess == current_tab)
 386                         mg_set_access_icon (sess->gui, pix, sess->server->is_away);
 387         }
 388
 389 #if 0
 390         if (prefs.hilitenotify && notify_isnotify (sess, newuser->nick))
 391         {
 392                 gtk_clist_set_foreground ((GtkCList *) sess->gui->user_clist, row,
 393                                                                                   &colors[prefs.nu_color]);
 394         }
 395 #endif
 396
 397         /* is it the front-most tab? */
 398         if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree))
 399                  == model)
 400         {
 401                 if (sel)
 402                         gtk_tree_selection_select_iter (gtk_tree_view_get_selection
 403                                                                                 (GTK_TREE_VIEW (sess->gui->user_tree)), &iter);
 404         }
 405 }
 406
 407 void
 408 fe_userlist_move (session *sess, struct User *user, int new_row)
 409 {
 410         fe_userlist_insert (sess, user, new_row, fe_userlist_remove (sess, user));
 411 }
 412
 413 void
 414 fe_userlist_clear (session *sess)
 415 {
 416         gtk_list_store_clear (sess->res->user_model);
 417 }
 418
 419 static void
 420 userlist_dnd_drop (GtkTreeView *widget, GdkDragContext *context,
 421                                                  gint x, gint y, GtkSelectionData *selection_data,
 422                                                  guint info, guint ttime, gpointer userdata)
 423 {
 424         struct User *user;
 425         GtkTreePath *path;
 426         GtkTreeModel *model;
 427         GtkTreeIter iter;
 428
 429         if (!gtk_tree_view_get_path_at_pos (widget, x, y, &path, NULL, NULL, NULL))
 430                 return;
 431
 432         model = gtk_tree_view_get_model (widget);
 433         if (!gtk_tree_model_get_iter (model, &iter, path))
 434                 return;
 435         gtk_tree_model_get (model, &iter, COL_USER, &user, -1);
 436
 437         mg_dnd_drop_file (current_sess, user->nick, selection_data->data);
 438 }
 439
 440 static gboolean
 441 userlist_dnd_motion (GtkTreeView *widget, GdkDragContext *context, gint x,
 442                                                         gint y, guint ttime, gpointer tree)
 443 {
 444         GtkTreePath *path;
 445         GtkTreeSelection *sel;
 446
 447         if (!tree)
 448                 return FALSE;
 449
 450         if (gtk_tree_view_get_path_at_pos (widget, x, y, &path, NULL, NULL, NULL))
 451         {
 452                 sel = gtk_tree_view_get_selection (widget);
 453                 gtk_tree_selection_unselect_all (sel);
 454                 gtk_tree_selection_select_path (sel, path);
 455         }
 456
 457         return FALSE;
 458 }
 459
 460 static gboolean
 461 userlist_dnd_leave (GtkTreeView *widget, GdkDragContext *context, guint ttime)
 462 {
 463         gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (widget));
 464         return TRUE;
 465 }
 466
 467 void *
 468 userlist_create_model (void)
 469 {
 470         return gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
 471                                                                                 G_TYPE_POINTER, GDK_TYPE_COLOR);
 472 }
 473
 474 static void
 475 userlist_add_columns (GtkTreeView * treeview)
 476 {
 477         GtkCellRenderer *renderer;
 478
 479         /* icon column */
 480         renderer = gtk_cell_renderer_pixbuf_new ();
 481         if (prefs.gui_tweaks & 32)
 482                 g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
 483         gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 484                                                                                                                                 -1, NULL, renderer,
 485                                                                                                                                 "pixbuf", 0, NULL);
 486
 487         /* nick column */
 488         renderer = gtk_cell_renderer_text_new ();
 489         if (prefs.gui_tweaks & 32)
 490                 g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
 491         gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1);
 492         gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 493                                                                                                                                 -1, NULL, renderer,
 494                                                                                                         "text", 1, "foreground-gdk", 4, NULL);
 495
 496         if (prefs.showhostname_in_userlist)
 497         {
 498                 /* hostname column */
 499                 renderer = gtk_cell_renderer_text_new ();
 500                 if (prefs.gui_tweaks & 32)
 501                         g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
 502                 gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1);
 503                 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
 504                                                                                                                                         -1, NULL, renderer,
 505                                                                                                                                         "text", 2, NULL);
 506         }
 507 }
 508
 509 static gint
 510 userlist_click_cb (GtkWidget *widget, GdkEventButton *event, gpointer userdata)
 511 {
 512         char **nicks;
 513         int i;
 514         GtkTreeSelection *sel;
 515         GtkTreePath *path;
 516
 517         if (!event)
 518                 return FALSE;
 519
 520         if (!(event->state & GDK_CONTROL_MASK) &&
 521                 event->type == GDK_2BUTTON_PRESS && prefs.doubleclickuser[0])
 522         {
 523                 nicks = userlist_selection_list (widget, &i);
 524                 if (nicks)
 525                 {
 526                         nick_command_parse (current_sess, prefs.doubleclickuser, nicks[0],
 527                                                                           nicks[0]);
 528                         while (i)
 529                         {
 530                                 i--;
 531                                 g_free (nicks[i]);
 532                         }
 533                         free (nicks);
 534                 }
 535                 return TRUE;
 536         }
 537
 538         if (event->button == 3)
 539         {
 540                 /* do we have a multi-selection? */
 541                 nicks = userlist_selection_list (widget, &i);
 542                 if (nicks && i > 1)
 543                 {
 544                         menu_nickmenu (current_sess, event, nicks[0], i);
 545                         while (i)
 546                         {
 547                                 i--;
 548                                 g_free (nicks[i]);
 549                         }
 550                         free (nicks);
 551                         return TRUE;
 552                 }
 553                 if (nicks)
 554                 {
 555                         g_free (nicks[0]);
 556                         free (nicks);
 557                 }
 558
 559                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
 560                 if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
 561                          event->x, event->y, &path, 0, 0, 0))
 562                 {
 563                         gtk_tree_selection_unselect_all (sel);
 564                         gtk_tree_selection_select_path (sel, path);
 565                         gtk_tree_path_free (path);
 566                         nicks = userlist_selection_list (widget, &i);
 567                         if (nicks)
 568                         {
 569                                 menu_nickmenu (current_sess, event, nicks[0], i);
 570                                 while (i)
 571                                 {
 572                                         i--;
 573                                         g_free (nicks[i]);
 574                                 }
 575                                 free (nicks);
 576                         }
 577                 } else
 578                 {
 579                         gtk_tree_selection_unselect_all (sel);
 580                 }
 581
 582                 return TRUE;
 583         }
 584
 585         return FALSE;
 586 }
 587
 588 static gboolean
 589 userlist_key_cb (GtkWidget *wid, GdkEventKey *evt, gpointer userdata)
 590 {
 591         if (evt->keyval >= GDK_asterisk && evt->keyval <= GDK_z)
 592         {
 593                 /* dirty trick to avoid auto-selection */
 594                 SPELL_ENTRY_SET_EDITABLE (current_sess->gui->input_box, FALSE);
 595                 gtk_widget_grab_focus (current_sess->gui->input_box);
 596                 SPELL_ENTRY_SET_EDITABLE (current_sess->gui->input_box, TRUE);
 597                 gtk_widget_event (current_sess->gui->input_box, (GdkEvent *)evt);
 598                 return TRUE;
 599         }
 600
 601         return FALSE;
 602 }
 603
 604 GtkWidget *
 605 userlist_create (GtkWidget *box)
 606 {
 607         GtkWidget *sw, *treeview;
 608         static const GtkTargetEntry dnd_dest_targets[] =
 609         {
 610                 {"text/uri-list", 0, 1},
 611                 {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
 612         };
 613         static const GtkTargetEntry dnd_src_target[] =
 614         {
 615                 {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
 616         };
 617
 618         sw = gtk_scrolled_window_new (NULL, NULL);
 619         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 620                                                                                                          GTK_SHADOW_ETCHED_IN);
 621         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 622                                                                                           prefs.showhostname_in_userlist ?
 623                                                                                                 GTK_POLICY_AUTOMATIC :
 624                                                                                                 GTK_POLICY_NEVER,
 625                                                                                           GTK_POLICY_AUTOMATIC);
 626         gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
 627         gtk_widget_show (sw);
 628
 629         treeview = gtk_tree_view_new ();
 630         gtk_widget_set_name (treeview, "xchat-userlist");
 631         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
 632         gtk_tree_selection_set_mode (gtk_tree_view_get_selection
 633                                                                                   (GTK_TREE_VIEW (treeview)),
 634                                                                                   GTK_SELECTION_MULTIPLE);
 635
 636         /* set up drops */
 637         gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2,
 638                                                          GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
 639         gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE);
 640
 641         /* file DND (for DCC) */
 642         g_signal_connect (G_OBJECT (treeview), "drag_motion",
 643                                                         G_CALLBACK (userlist_dnd_motion), treeview);
 644         g_signal_connect (G_OBJECT (treeview), "drag_leave",
 645                                                         G_CALLBACK (userlist_dnd_leave), 0);
 646         g_signal_connect (G_OBJECT (treeview), "drag_data_received",
 647                                                         G_CALLBACK (userlist_dnd_drop), treeview);
 648
 649         g_signal_connect (G_OBJECT (treeview), "button_press_event",
 650                                                         G_CALLBACK (userlist_click_cb), 0);
 651         g_signal_connect (G_OBJECT (treeview), "key_press_event",
 652                                                         G_CALLBACK (userlist_key_cb), 0);
 653
 654         /* tree/chanview DND */
 655         g_signal_connect (G_OBJECT (treeview), "drag_begin",
 656                                                         G_CALLBACK (mg_drag_begin_cb), NULL);
 657         g_signal_connect (G_OBJECT (treeview), "drag_drop",
 658                                                         G_CALLBACK (mg_drag_drop_cb), NULL);
 659         g_signal_connect (G_OBJECT (treeview), "drag_motion",
 660                                                         G_CALLBACK (mg_drag_motion_cb), NULL);
 661         g_signal_connect (G_OBJECT (treeview), "drag_end",
 662                                                         G_CALLBACK (mg_drag_end_cb), NULL);
 663
 664         userlist_add_columns (GTK_TREE_VIEW (treeview));
 665
 666         gtk_container_add (GTK_CONTAINER (sw), treeview);
 667         gtk_widget_show (treeview);
 668
 669         return treeview;
 670 }
 671
 672 void
 673 userlist_show (session *sess)
 674 {
 675         gtk_tree_view_set_model (GTK_TREE_VIEW (sess->gui->user_tree),
 676                                                                          sess->res->user_model);
 677 }
 678
 679 void
 680 fe_uselect (session *sess, char *word[], int do_clear, int scroll_to)
 681 {
 682         int thisname;
 683         char *name;
 684         GtkTreeIter iter;
 685         GtkTreeView *treeview = GTK_TREE_VIEW (sess->gui->user_tree);
 686         GtkTreeModel *model = gtk_tree_view_get_model (treeview);
 687         GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
 688         struct User *row_user;
 689
 690         if (gtk_tree_model_get_iter_first (model, &iter))
 691         {
 692                 if (do_clear)
 693                         gtk_tree_selection_unselect_all (selection);
 694
 695                 do
 696                 {
 697                         if (*word[0])
 698                         {
 699                                 gtk_tree_model_get (model, &iter, COL_USER, &row_user, -1);
 700                                 thisname = 0;
 701                                 while ( *(name = word[thisname++]) )
 702                                 {
 703                                         if (sess->server->p_cmp (row_user->nick, name) == 0)
 704                                         {
 705                                                 gtk_tree_selection_select_iter (selection, &iter);
 706                                                 if (scroll_to)
 707                                                         scroll_to_iter (&iter, treeview, model);
 708                                                 break;
 709                                         }
 710                                 }
 711                         }
 712
 713                 }
 714                 while (gtk_tree_model_iter_next (model, &iter));
 715         }
 716 }