gtk/graph_analysis.c

   1 /* graph_analysis.c
   2  * Graphic Analysis addition for Wireshark
   3  *
   4  * $Id$
   5  *
   6  * Copyright 2004, Verso Technologies Inc.
   7  * By Alejandro Vaquero <alejandrovaquero@yahoo.com>
   8  *
   9  * based on rtp_analysis.c and io_stat
  10  *
  11  *
  12  * Wireshark - Network traffic analyzer
  13  * By Gerald Combs <gerald@wireshark.org>
  14  * Copyright 1998 Gerald Combs
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation,  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include "graph_analysis.h"
  36
  37 #include <epan/epan_dissect.h>
  38
  39 #include "util.h"
  40 #include <epan/tap.h>
  41 #include "register.h"
  42 #include <epan/dissectors/packet-rtp.h>
  43 #include <epan/addr_resolv.h>
  44
  45 /* in /gtk ... */
  46 #include <gtk/gtk.h>
  47 #if GTK_MAJOR_VERSION >= 2
  48 #include <glib-object.h>
  49 #endif
  50
  51 #include <gdk/gdkkeysyms.h>
  52 #include "gtkglobals.h"
  53
  54 #if 0
  55 #include "dlg_utils.h"
  56 #endif
  57 #include "file_dlg.h"
  58 #include "gui_utils.h"
  59 #include "main.h"
  60 #include "compat_macros.h"
  61 #include "../color.h"
  62 #include "epan/filesystem.h"
  63 #include "file_util.h"
  64
  65 #include <string.h>
  66
  67 #ifdef HAVE_UNISTD_H
  68 #include <unistd.h>
  69 #endif
  70
  71 #include "simple_dialog.h"
  72
  73
  74 /* XXX FIXME */
  75 /* GTK-1.x does not have GDK_IS_DRAWABLE so just define is as always being true
  76  * so that Wireshark compiles.
  77  * At later stage we should implement it as a real fallback for gtk-1.x
  78  * but for the time being   us very few gtk-1.2 users at elast can compile.
  79  */
  80 #if (GTK_MAJOR_VERSION < 2)
  81 #define GDK_IS_DRAWABLE(x) 1
  82 #endif
  83 /****************************************************************************/
  84
  85
  86 #define OK_TEXT "[ Ok ]"
  87 #define PT_UNDEFINED -1
  88
  89
  90 #if GTK_MAJOR_VERSION < 2
  91 GtkRcStyle *rc_style;
  92 GdkColormap *colormap;
  93 #endif
  94
  95 static GtkWidget *save_to_file_w = NULL;
  96
  97 #define MAX_LABEL 50
  98 #define MAX_COMMENT 100
  99 #define ITEM_HEIGHT 20
 100 #define NODE_WIDTH 100
 101 #define TOP_Y_BORDER 40
 102 #define BOTTOM_Y_BORDER 0
 103 #define COMMENT_WIDTH 400
 104 #define TIME_WIDTH 50
 105
 106 #define NODE_CHARS_WIDTH 20
 107 #define CONV_TIME_HEADER "Conv.| Time    "
 108 #define TIME_HEADER "|Time     "
 109 #define CONV_TIME_EMPTY_HEADER     "     |         "
 110 #define TIME_EMPTY_HEADER     "|         "
 111 #define CONV_TIME_HEADER_LENGTH 16
 112 #define TIME_HEADER_LENGTH 10
 113
 114 /****************************************************************************/
 115 /* Reset the user_data structure */
 116 static void graph_analysis_reset(graph_analysis_data_t* user_data)
 117 {
 118         int i;
 119
 120         user_data->num_nodes = 0;
 121         user_data->num_items = 0;
 122         for (i=0; i<MAX_NUM_NODES; i++){
 123                 user_data->nodes[i].type = AT_NONE;
 124                 user_data->nodes[i].len = 0;
 125                 g_free((void *)user_data->nodes[i].data);
 126                 user_data->nodes[i].data = NULL;
 127         }
 128
 129         user_data->dlg.first_node=0;
 130         user_data->dlg.first_item=0;
 131         user_data->dlg.left_x_border=0;
 132         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 133 }
 134
 135 /****************************************************************************/
 136 /* Reset the user_data structure */
 137 static void graph_analysis_init_dlg(graph_analysis_data_t* user_data)
 138 {
 139         int i;
 140
 141         user_data->num_nodes = 0;
 142         user_data->num_items = 0;
 143         user_data->on_destroy_user_data = NULL;
 144         user_data->data = NULL;
 145         for (i=0; i<MAX_NUM_NODES; i++){
 146                 user_data->nodes[i].type = AT_NONE;
 147                 user_data->nodes[i].len = 0;
 148                 user_data->nodes[i].data = NULL;
 149         }
 150
 151         user_data->dlg.first_node=0;
 152         user_data->dlg.first_item=0;
 153         user_data->dlg.left_x_border=0;
 154         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 155         /* init dialog_graph */
 156         user_data->dlg.needs_redraw=TRUE;
 157         user_data->dlg.draw_area_time=NULL;
 158         user_data->dlg.draw_area=NULL;
 159         user_data->dlg.pixmap=NULL;
 160         user_data->dlg.pixmap_time=NULL;
 161         user_data->dlg.draw_area_comments=NULL;
 162         user_data->dlg.pixmap_comments=NULL;
 163         user_data->dlg.v_scrollbar=NULL;
 164         user_data->dlg.v_scrollbar_adjustment=NULL;
 165         user_data->dlg.hpane=NULL;
 166         user_data->dlg.pixmap_width = 350;
 167         user_data->dlg.pixmap_height=400;
 168         user_data->dlg.first_node=0;
 169         user_data->dlg.first_item=0;
 170         user_data->dlg.left_x_border=0;
 171         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 172         user_data->dlg.window=NULL;
 173         user_data->dlg.inverse = FALSE;
 174         user_data->dlg.title=NULL;
 175 }
 176
 177 /****************************************************************************/
 178 /* CALLBACKS */
 179
 180 /****************************************************************************/
 181 /* close the dialog window */
 182 static void on_destroy(GtkWidget *win _U_, graph_analysis_data_t *user_data _U_)
 183 {
 184         int i;
 185
 186         for (i=0; i<MAX_NUM_NODES; i++){
 187                 user_data->nodes[i].type = AT_NONE;
 188                 user_data->nodes[i].len = 0;
 189                 g_free((void *)user_data->nodes[i].data);
 190                 user_data->nodes[i].data = NULL;
 191         }
 192         user_data->dlg.window = NULL;
 193         g_free(user_data->dlg.title);
 194         user_data->dlg.title = NULL;
 195
 196         if(user_data->on_destroy_user_data){
 197         user_data->on_destroy_user_data(user_data->data);
 198         }
 199 }
 200
 201 #define RIGHT_ARROW 1
 202 #define LEFT_ARROW 0
 203 #define WIDTH_ARROW 8
 204 #define HEIGHT_ARROW 6
 205
 206 /****************************************************************************/
 207 static void draw_arrow(GdkDrawable *pixmap, GdkGC *gc, gint x, gint y, gboolean direction)
 208 {
 209         GdkPoint arrow_point[3];
 210
 211         arrow_point[0].x = x;
 212         arrow_point[0].y = y-HEIGHT_ARROW/2;
 213         if (direction == RIGHT_ARROW)
 214                 arrow_point[1].x = x+WIDTH_ARROW;
 215         else
 216                 arrow_point[1].x = x-WIDTH_ARROW;
 217         arrow_point[1].y = y;
 218         arrow_point[2].x = x;
 219         arrow_point[2].y = y+HEIGHT_ARROW/2;;
 220
 221         if (GDK_IS_DRAWABLE(pixmap)) {
 222                 gdk_draw_polygon(pixmap, gc, TRUE, arrow_point, 3);
 223         }
 224 }
 225
 226 /****************************************************************************/
 227 /* Adds trailing characters to complete the requested length.               */
 228 /****************************************************************************/
 229
 230 static void enlarge_string(GString *gstr, guint32 length, char pad){
 231
 232         guint32 i;
 233
 234         for (i = gstr->len; i < length; i++){
 235                 g_string_append_c(gstr, pad);
 236         }
 237 }
 238
 239 /****************************************************************************/
 240 /* overwrites the characters in a string, between positions p1 and p2, with */
 241 /*   the characters of text_to_insert                                       */
 242 /*   NB: it does not check that p1 and p2 fit into string                                       */
 243 /****************************************************************************/
 244
 245 static void overwrite (GString *gstr, char *text_to_insert, guint32 p1, guint32 p2){
 246
 247         guint32 pos, len;
 248
 249         if (p1 == p2)
 250                 return;
 251
 252         if (p1 > p2){
 253                 pos = p2;
 254                 len = p1 - p2;
 255         }
 256         else{
 257                 pos = p1;
 258                 len = p2 - p1;
 259         }
 260
 261         if (len > strlen(text_to_insert)){
 262                 len = strlen(text_to_insert);
 263         }
 264
 265         if (pos > gstr->len)
 266                 pos = gstr->len;
 267
 268         if (pos + len > gstr->len)
 269                 g_string_truncate(gstr, pos);
 270         else
 271                 g_string_erase(gstr, pos, len);
 272
 273         g_string_insert(gstr, pos, text_to_insert);
 274 }
 275
 276
 277 /*
 278  * XXX - We might want to refactor this to write the graph data directly to
 279  * the file instead of loading everything into strings first.
 280  */
 281
 282 /****************************************************************************/
 283 static gboolean dialog_graph_dump_to_file(graph_analysis_data_t* user_data)
 284 {
 285         guint32 i, first_node, display_items, display_nodes;
 286         guint32 start_position, end_position, item_width, header_length;
 287         guint32 current_item;
 288         graph_analysis_item_t *gai;
 289         guint16 first_conv_num = 0;
 290         gboolean several_convs = FALSE;
 291         gboolean first_packet = TRUE;
 292
 293         GString *label_string, *empty_line,*separator_line, *tmp_str, *tmp_str2;
 294         char *empty_header;
 295         char src_port[8],dst_port[8];
 296
 297         GList* list;
 298
 299         FILE *of;
 300
 301         of = eth_fopen(user_data->dlg.save_file,"w");
 302         if (of==NULL){
 303                 return FALSE;
 304         }
 305
 306         label_string   = g_string_new("");
 307         empty_line     = g_string_new("");
 308         separator_line = g_string_new("");
 309         tmp_str        = g_string_new("");
 310         tmp_str2       = g_string_new("");
 311
 312         /* get the items to display and fill the matrix array */
 313         list = g_list_first(user_data->graph_info->list);
 314         current_item = 0;
 315         i = 0;
 316         while (list && current_item < NUM_DISPLAY_ITEMS)
 317         {
 318                 gai = list->data;
 319                 if (gai->display){
 320                         user_data->dlg.items[current_item].frame_num = gai->frame_num;
 321                         user_data->dlg.items[current_item].time = gai->time;
 322                         user_data->dlg.items[current_item].port_src = gai->port_src;
 323                         user_data->dlg.items[current_item].port_dst = gai->port_dst;
 324                         user_data->dlg.items[current_item].frame_label = gai->frame_label;
 325                         user_data->dlg.items[current_item].comment = gai->comment;
 326                         user_data->dlg.items[current_item].conv_num = gai->conv_num;
 327                         user_data->dlg.items[current_item].src_node = gai->src_node;
 328                         user_data->dlg.items[current_item].dst_node = gai->dst_node;
 329                         if (first_packet){
 330                                 first_conv_num = gai->conv_num;
 331                                 first_packet=FALSE;
 332                         }
 333                         if (user_data->dlg.items[current_item].conv_num != first_conv_num){
 334                                 several_convs = TRUE;
 335                         }
 336                         current_item++;
 337                         i++;
 338                 }
 339
 340                 list = g_list_next(list);
 341         }
 342         display_items = current_item;
 343
 344         /* if not items to display */
 345         if (display_items == 0) goto exit;
 346
 347         display_nodes = user_data->num_nodes;
 348
 349         first_node = user_data->dlg.first_node;
 350
 351         /* Write the conv. and time headers */
 352
 353         if (several_convs){
 354                 fprintf (of, CONV_TIME_HEADER);
 355                 empty_header = CONV_TIME_EMPTY_HEADER;
 356                 header_length = CONV_TIME_HEADER_LENGTH;
 357         }
 358         else{
 359                 fprintf (of, TIME_HEADER);
 360                 empty_header = TIME_EMPTY_HEADER;
 361                 header_length = TIME_HEADER_LENGTH;
 362         }
 363
 364         /* Write the node names on top */
 365         for (i=0; i<display_nodes; i++){
 366                 /* print the node identifiers */
 367                 g_string_sprintf(label_string, "| %s",
 368                         get_addr_name(&(user_data->nodes[i+first_node])));
 369                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 370                 fprintf(of, "%s", label_string->str);
 371                 g_string_sprintf(label_string, "| ");
 372                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 373                 g_string_append(empty_line, label_string->str);
 374         }
 375         g_string_append_c(empty_line, '|');
 376
 377         enlarge_string(separator_line, empty_line->len + header_length, '-');
 378
 379         fprintf(of, "|\n");
 380
 381         /*
 382          * Draw the items
 383          */
 384
 385         for (current_item=0; current_item<display_items; current_item++){
 386
 387                 start_position = (user_data->dlg.items[current_item].src_node-first_node)*NODE_CHARS_WIDTH+NODE_CHARS_WIDTH/2;
 388
 389                 end_position = (user_data->dlg.items[current_item].dst_node-first_node)*NODE_CHARS_WIDTH+NODE_CHARS_WIDTH/2;
 390
 391                 if (start_position > end_position){
 392                         item_width=start_position-end_position;
 393                 }
 394                 else if (start_position < end_position){
 395                         item_width=end_position-start_position;
 396                 }
 397                 else{ /* same origin and destination address */
 398                         end_position = start_position+NODE_CHARS_WIDTH;
 399                         item_width = NODE_CHARS_WIDTH;
 400                 }
 401
 402                 /* separator between conversations */
 403                 if (user_data->dlg.items[current_item].conv_num != first_conv_num){
 404                         fprintf(of, "%s\n", separator_line->str);
 405                         first_conv_num=user_data->dlg.items[current_item].conv_num;
 406                 }
 407
 408                 /* write the conversation number */
 409                 if (several_convs){
 410                         g_string_sprintf(label_string, "%i", user_data->dlg.items[current_item].conv_num);
 411                         enlarge_string(label_string, 5, ' ');
 412                         fprintf(of, "%s", label_string->str);
 413                 }
 414
 415                 /* write the time */
 416                 g_string_sprintf(label_string, "|%.3f", user_data->dlg.items[current_item].time);
 417                 enlarge_string(label_string, 10, ' ');
 418                 fprintf(of, "%s", label_string->str);
 419
 420                 /* write the frame label */
 421
 422                 g_string_sprintf(tmp_str, empty_line->str);
 423                 overwrite(tmp_str,user_data->dlg.items[current_item].frame_label,
 424                         start_position,
 425                         end_position
 426                         );
 427                 fprintf(of, "%s", tmp_str->str);
 428
 429                 /* write the comments */
 430                 fprintf(of, "%s\n", user_data->dlg.items[current_item].comment);
 431
 432                 /* write the arrow and frame label*/
 433                 fprintf(of, "%s", empty_header);
 434
 435                 g_string_sprintf(tmp_str, empty_line->str);
 436
 437                 g_string_truncate(tmp_str2, 0);
 438
 439                 if (start_position<end_position){
 440                         enlarge_string(tmp_str2, item_width-2, '-');
 441                         g_string_append_c(tmp_str2, '>');
 442                 }
 443                 else{
 444                         g_string_sprintf(tmp_str2, "<");
 445                         enlarge_string(tmp_str2, item_width-1, '-');
 446                 }
 447
 448                 overwrite(tmp_str,tmp_str2->str,
 449                         start_position,
 450                         end_position
 451                         );
 452
 453                 g_snprintf(src_port,8,"(%i)", user_data->dlg.items[current_item].port_src);
 454                 g_snprintf(dst_port,8,"(%i)", user_data->dlg.items[current_item].port_dst);
 455
 456                 if (start_position<end_position){
 457                         overwrite(tmp_str,src_port,start_position-9,start_position-1);
 458                         overwrite(tmp_str,dst_port,end_position+1,end_position+9);
 459                 }
 460                 else{
 461                         overwrite(tmp_str,src_port,start_position+1,start_position+9);
 462                         overwrite(tmp_str,dst_port,end_position-9,end_position+1);
 463                 }
 464
 465                 fprintf(of,"%s\n",tmp_str->str);
 466         }
 467
 468 exit:
 469         g_string_free(label_string, TRUE);
 470         g_string_free(empty_line, TRUE);
 471         g_string_free(separator_line, TRUE);
 472         g_string_free(tmp_str, TRUE);
 473         g_string_free(tmp_str2, TRUE);
 474
 475         fclose (of);
 476         return TRUE;
 477
 478 }
 479
 480 /****************************************************************************/
 481 static void save_to_file_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
 482 {
 483         /* Note that we no longer have a Save to file dialog box. */
 484         save_to_file_w = NULL;
 485 }
 486
 487 /****************************************************************************/
 488 /* save in a file */
 489
 490 /* first an auxiliary function in case we need an overwrite confirmation dialog */
 491
 492 static void overwrite_existing_file_cb(gpointer dialog _U_, gint btn, gpointer user_data _U_)
 493 {
 494         graph_analysis_data_t *user_data_p;
 495
 496         user_data_p = user_data;
 497
 498         switch(btn) {
 499         case(ESD_BTN_YES):
 500             /* overwrite the file*/
 501             dialog_graph_dump_to_file(user_data);
 502             break;
 503         case(ESD_BTN_NO):
 504             break;
 505         default:
 506             g_assert_not_reached();
 507         }
 508 }
 509
 510 /* and then the save in a file dialog itself */
 511
 512 static void save_to_file_ok_cb(GtkWidget *ok_bt _U_, gpointer user_data _U_)
 513 {
 514         FILE *file_test;
 515         gpointer dialog;
 516         graph_analysis_data_t *user_data_p;
 517
 518         user_data_p = user_data;
 519
 520         user_data_p->dlg.save_file = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION (save_to_file_w)));
 521
 522         /* Perhaps the user specified a directory instead of a file.
 523         Check whether they did. */
 524         if (test_for_directory(user_data_p->dlg.save_file) == EISDIR) {
 525                 /* It's a directory - set the file selection box to display it. */
 526                 set_last_open_dir(user_data_p->dlg.save_file);
 527                 g_free(user_data_p->dlg.save_file);
 528                 file_selection_set_current_folder(save_to_file_w, get_last_open_dir());
 529                 return;
 530         }
 531
 532
 533         /* check whether the file exists */
 534         file_test = eth_fopen(user_data_p->dlg.save_file,"r");
 535         if (file_test!=NULL){
 536
 537                 dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_YES_NO,
 538                   "%sFile: \"%s\" already exists!%s\n\n"
 539                   "Do you want to overwrite it?",
 540                   simple_dialog_primary_start(),user_data_p->dlg.save_file, simple_dialog_primary_end());
 541                 simple_dialog_set_cb(dialog, overwrite_existing_file_cb, user_data);
 542                 fclose(file_test);
 543         }
 544
 545         else{
 546                 if (!dialog_graph_dump_to_file(user_data))
 547                         return;
 548         }
 549         window_destroy(GTK_WIDGET(save_to_file_w));
 550
 551 }
 552
 553 /****************************************************************************/
 554 static void
 555 on_save_bt_clicked                    (GtkButton       *button _U_,
 556                                         gpointer         user_data _U_)
 557 {
 558         GtkWidget *vertb;
 559         GtkWidget *ok_bt;
 560
 561         if (save_to_file_w != NULL) {
 562                 /* There's already a Save to file dialog box; reactivate it. */
 563                 reactivate_window(save_to_file_w);
 564                 return;
 565         }
 566
 567         save_to_file_w = gtk_file_selection_new("Wireshark: Save graph to plain text file");
 568
 569         /* Container for each row of widgets */
 570         vertb = gtk_vbox_new(FALSE, 0);
 571         gtk_container_border_width(GTK_CONTAINER(vertb), 5);
 572         gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(save_to_file_w)->action_area),
 573                 vertb, FALSE, FALSE, 0);
 574         gtk_widget_show (vertb);
 575
 576         ok_bt = GTK_FILE_SELECTION(save_to_file_w)->ok_button;
 577         SIGNAL_CONNECT(ok_bt, "clicked", save_to_file_ok_cb, user_data);
 578
 579         window_set_cancel_button(save_to_file_w,
 580         GTK_FILE_SELECTION(save_to_file_w)->cancel_button, window_cancel_button_cb);
 581
 582         SIGNAL_CONNECT(save_to_file_w, "delete_event", window_delete_event_cb, NULL);
 583         SIGNAL_CONNECT(save_to_file_w, "destroy", save_to_file_destroy_cb,
 584                        NULL);
 585
 586         gtk_widget_show(save_to_file_w);
 587         window_present(save_to_file_w);
 588
 589
 590 }
 591
 592 /****************************************************************************/
 593 static void dialog_graph_draw(graph_analysis_data_t* user_data)
 594 {
 595         guint32 i, last_item, first_item, display_items;
 596         guint32 start_arrow, end_arrow, label_x, src_port_x, dst_port_x, arrow_width;
 597         guint32 current_item;
 598         guint32 left_x_border;
 599         guint32 right_x_border;
 600         guint32 top_y_border;
 601         guint32 bottom_y_border;
 602         graph_analysis_item_t *gai;
 603         guint16 first_conv_num;
 604         gboolean several_convs = FALSE;
 605         gboolean first_packet = TRUE;
 606
 607         GdkGC *frame_fg_color;
 608         GdkGC *frame_bg_color;
 609         GdkGC *div_line_color;
 610
 611 #if GTK_MAJOR_VERSION < 2
 612         GdkFont *font;
 613         FONT_TYPE *big_font;
 614         FONT_TYPE *small_font;
 615 #else
 616         PangoLayout  *layout;
 617         PangoLayout  *big_layout;
 618         PangoLayout  *small_layout;
 619 #endif
 620         guint32 label_width, label_height;
 621         guint32 draw_width, draw_height;
 622         char label_string[MAX_COMMENT];
 623         GList* list;
 624
 625         /* new variables */
 626
 627 #if GTK_MAJOR_VERSION <2
 628         font = user_data->dlg.draw_area->style->font;
 629         big_font = gdk_font_load("-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1");
 630         small_font = gdk_font_load("-adobe-helvetica-bold-r-normal--10-120-75-75-p-70-iso8859-1");
 631 #endif
 632         if(!user_data->dlg.needs_redraw){
 633                 return;
 634         }
 635         user_data->dlg.needs_redraw=FALSE;
 636
 637         /* Clear out old plt */
 638         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
 639                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
 640                                                    user_data->dlg.draw_area_time->style->white_gc,
 641                                                    TRUE,
 642                                                    0, 0,
 643                                                    user_data->dlg.draw_area_time->allocation.width,
 644                                                    user_data->dlg.draw_area_time->allocation.height);
 645
 646         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
 647                 gdk_draw_rectangle(user_data->dlg.pixmap,
 648                                                    user_data->dlg.draw_area->style->white_gc,
 649                                                    TRUE,
 650                                                    0, 0,
 651                                                    user_data->dlg.draw_area->allocation.width,
 652                                                    user_data->dlg.draw_area->allocation.height);
 653
 654         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) )
 655                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
 656                                                    user_data->dlg.draw_area->style->white_gc,
 657                                                    TRUE,
 658                                                    0, 0,
 659                                                    user_data->dlg.draw_area_comments->allocation.width,
 660                                                    user_data->dlg.draw_area_comments->allocation.height);
 661
 662         /* Calculate the y border */
 663         top_y_border=TOP_Y_BORDER;      /* to display the node address */
 664         bottom_y_border=2;
 665
 666             draw_height=user_data->dlg.draw_area->allocation.height-top_y_border-bottom_y_border;
 667
 668         first_item = user_data->dlg.first_item;
 669         display_items = draw_height/ITEM_HEIGHT;
 670         last_item = first_item+display_items-1;
 671
 672         /* get the items to display and fill the matrix array */
 673         list = g_list_first(user_data->graph_info->list);
 674         current_item = 0;
 675         i = 0;
 676         while (list)
 677         {
 678                 gai = list->data;
 679                 if (gai->display){
 680                         if (current_item>=display_items) break;         /* the item is outside the display */
 681                         if (i>=first_item){
 682                                 user_data->dlg.items[current_item].frame_num = gai->frame_num;
 683                                 user_data->dlg.items[current_item].time = gai->time;
 684                                 user_data->dlg.items[current_item].port_src = gai->port_src;
 685                                 user_data->dlg.items[current_item].port_dst = gai->port_dst;
 686                                 /* Add "..." if the length is 50 characters */
 687                                 if (strlen(gai->frame_label) > 48) {
 688                                         gai->frame_label[48] = '.';
 689                                         gai->frame_label[47] = '.';
 690                                         gai->frame_label[46] = '.';
 691                                 }
 692                                 user_data->dlg.items[current_item].frame_label = gai->frame_label;
 693                                 user_data->dlg.items[current_item].comment = gai->comment;
 694                                 user_data->dlg.items[current_item].conv_num = gai->conv_num;
 695
 696                                 if (first_packet){
 697                                         first_conv_num = gai->conv_num;
 698                                         first_packet=FALSE;
 699                                 }
 700
 701                                 if (user_data->dlg.items[current_item].conv_num != first_conv_num){
 702                                         several_convs = TRUE;
 703                                 }
 704
 705                                 user_data->dlg.items[current_item].src_node = gai->src_node;
 706                                 user_data->dlg.items[current_item].dst_node = gai->dst_node;
 707                                 user_data->dlg.items[current_item].line_style = gai->line_style;
 708                                 current_item++;
 709                         }
 710                         i++;
 711                 }
 712
 713                 list = g_list_next(list);
 714         }
 715         /* in case the windows is resized so we have to move the top item */
 716         if ((first_item + display_items) > user_data->num_items){
 717                 if (display_items>user_data->num_items)
 718                         first_item=0;
 719                 else
 720                         first_item = user_data->num_items - display_items;
 721         }
 722
 723         /* in case there are less items than possible displayed */
 724         display_items = current_item;
 725         last_item = first_item+display_items-1;
 726
 727         /* if not items to display */
 728         if (display_items == 0) return;
 729
 730
 731         /* Calculate the x borders */
 732         /* We use time from the last display item to calcultate the x left border */
 733         g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[display_items-1].time);
 734 #if GTK_MAJOR_VERSION < 2
 735         label_width=gdk_string_width(font, label_string);
 736         label_height=gdk_string_height(font, label_string);
 737 #else
 738         layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 739         big_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 740         small_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 741
 742         /* XXX - to prevent messages like "Couldn't load font x, falling back to y", I've changed font
 743            description from "Helvetica-Bold 8" to "Helvetica,Sans,Bold 8", this seems to be
 744            conforming to the API, see http://developer.gnome.org/doc/API/2.0/pango/pango-Fonts.html */
 745         pango_layout_set_font_description(big_layout, pango_font_description_from_string("Helvetica,Sans,Bold 8"));
 746         pango_layout_set_font_description(small_layout, pango_font_description_from_string("Helvetica,Sans,Bold 7"));
 747
 748         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 749 #endif
 750
 751                 /* resize the "time" draw area */
 752
 753         left_x_border=3;
 754         user_data->dlg.left_x_border = left_x_border;
 755
 756         right_x_border=2;
 757         draw_width=user_data->dlg.pixmap_width-right_x_border-left_x_border;
 758
 759         /* Paint time title background */
 760         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
 761                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
 762                                                    user_data->dlg.draw_area_time->style->bg_gc[2],
 763                                                    TRUE,
 764                                                    0,
 765                                                    0,
 766                                                    user_data->dlg.draw_area_time->allocation.width,
 767                                                    top_y_border);
 768         /* Paint main title background */
 769         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
 770                 gdk_draw_rectangle(user_data->dlg.pixmap,
 771                                                    user_data->dlg.draw_area->style->bg_gc[2],
 772                                                    TRUE,
 773                                                    0,
 774                                                    0,
 775                                                    user_data->dlg.draw_area->allocation.width,
 776                                                    top_y_border);
 777         /* Paint main comment background */
 778         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) )
 779                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
 780                                                    user_data->dlg.draw_area_comments->style->bg_gc[2],
 781                                                    TRUE,
 782                                                    0,
 783                                                    0,
 784                                                    user_data->dlg.draw_area_comments->allocation.width,
 785                                                    top_y_border);
 786
 787
 788         /* Draw the word "Time" on top of time column */
 789         g_snprintf(label_string, label_width, "%s", "Time");
 790 #if GTK_MAJOR_VERSION < 2
 791         label_width=gdk_string_width(font, label_string);
 792         label_height=gdk_string_height(font, label_string);
 793         gdk_draw_string(user_data->dlg.pixmap_time,
 794                font,
 795                user_data->dlg.draw_area_time->style->black_gc,
 796                left_x_border+4,
 797                top_y_border/2-label_height/2,
 798                label_string);
 799 #else
 800         pango_layout_set_text(layout, label_string, -1);
 801         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 802         if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
 803                 gdk_draw_layout(user_data->dlg.pixmap_time,
 804                                                 user_data->dlg.draw_area_time->style->black_gc,
 805                                                 left_x_border,
 806                                                 top_y_border/2-label_height/2,
 807                                                 layout);
 808         }
 809 #endif
 810
 811         /* Draw the word "Comment" on top of comment column */
 812         g_snprintf(label_string, label_width, "%s", "Comment");
 813 #if GTK_MAJOR_VERSION < 2
 814         label_width=gdk_string_width(font, label_string);
 815         label_height=gdk_string_height(font, label_string);
 816         gdk_draw_string(user_data->dlg.pixmap_comments,
 817                font,
 818                user_data->dlg.draw_area_comments->style->black_gc,
 819                MAX_COMMENT/2-label_width/2,
 820                top_y_border/2-label_height/2,
 821                label_string);
 822 #else
 823         pango_layout_set_text(layout, label_string, -1);
 824         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 825         if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments)) {
 826                 gdk_draw_layout(user_data->dlg.pixmap_comments,
 827                            user_data->dlg.draw_area_comments->style->black_gc,
 828                            MAX_COMMENT/2-label_width/2,
 829                            top_y_border/2-label_height/2,
 830                            layout);
 831         }
 832 #endif
 833
 834         /* Paint the background items */
 835         for (current_item=0; current_item<display_items; current_item++){
 836                 /*select the color. if it is the selected item select blue color */
 837                 if ( current_item+first_item == user_data->dlg.selected_item ) {
 838                         frame_bg_color = user_data->dlg.bg_gc[0];
 839                 } else {
 840                         frame_bg_color = user_data->dlg.bg_gc[1+user_data->dlg.items[current_item].conv_num%MAX_NUM_COL_CONV];
 841                 }
 842
 843                 /* Paint background */
 844                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 845                         gdk_draw_rectangle(user_data->dlg.pixmap,
 846                                                            frame_bg_color,
 847                                                            TRUE,
 848                                                            left_x_border,
 849                                                            top_y_border+current_item*ITEM_HEIGHT,
 850                                                            draw_width,
 851                                                            ITEM_HEIGHT);
 852                 }
 853         }
 854         /* Draw the node names on top and the division lines */
 855         for (i=0; i<user_data->num_nodes; i++){
 856                 /* print the node identifiers */
 857                 /* XXX we assign 5 pixels per character in the node identity */
 858                 g_snprintf(label_string, NODE_WIDTH/5, "%s",
 859                         get_addr_name(&(user_data->nodes[i])));
 860 #if GTK_MAJOR_VERSION < 2
 861                 label_width=gdk_string_width(font, label_string);
 862                 label_height=gdk_string_height(font, label_string);
 863                         gdk_draw_string(user_data->dlg.pixmap,
 864                 font,
 865                 user_data->dlg.draw_area->style->black_gc,
 866                 left_x_border+NODE_WIDTH/2-label_width/2+NODE_WIDTH*i,
 867                 top_y_border/2-label_height/2,
 868                 label_string);
 869 #else
 870                 pango_layout_set_text(layout, label_string, -1);
 871                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
 872                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 873                         gdk_draw_layout(user_data->dlg.pixmap,
 874                                                         user_data->dlg.draw_area->style->black_gc,
 875                                                         left_x_border+NODE_WIDTH/2-label_width/2+NODE_WIDTH*i,
 876                                                         top_y_border/2-label_height/2,
 877                                                         layout);
 878                 }
 879 #endif
 880
 881                 /* draw the node division lines */
 882                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
 883                         gdk_draw_line(user_data->dlg.pixmap, user_data->dlg.div_line_gc[0],
 884                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 885                                                   top_y_border,
 886                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 887                                                   user_data->dlg.draw_area->allocation.height-bottom_y_border);
 888                 }
 889
 890         }
 891
 892         /* Draw the items */
 893         for (current_item=0; current_item<display_items; current_item++){
 894                 /* draw the time */
 895                 g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[current_item].time);
 896 #if GTK_MAJOR_VERSION < 2
 897                 label_width=gdk_string_width(font, label_string);
 898                 label_height=gdk_string_height(font, label_string);
 899                         gdk_draw_string(user_data->dlg.pixmap_time,
 900                 font,
 901                 user_data->dlg.draw_area->style->black_gc,
 902                 3,
 903                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2+label_height/4,
 904                 label_string);
 905 #else
 906                 pango_layout_set_text(layout, label_string, -1);
 907                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
 908                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
 909                         gdk_draw_layout(user_data->dlg.pixmap_time,
 910                                                         user_data->dlg.draw_area->style->black_gc,
 911                                                         3,
 912                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2,
 913                                                         layout);
 914                 }
 915 #endif
 916
 917                 /*draw the comments */
 918                 g_snprintf(label_string, MAX_COMMENT, "%s", user_data->dlg.items[current_item].comment);
 919 #if GTK_MAJOR_VERSION < 2
 920                 label_width=gdk_string_width(small_font, label_string);
 921                 label_height=gdk_string_height(small_font, label_string);
 922                 gdk_draw_string(user_data->dlg.pixmap_comments,
 923                 small_font,
 924                 user_data->dlg.draw_area_comments->style->black_gc,
 925                 2,
 926                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2+label_height/4,
 927                 label_string);
 928 #else
 929                 pango_layout_set_text(small_layout, label_string, -1);
 930                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
 931                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments)) {
 932                         gdk_draw_layout(user_data->dlg.pixmap_comments,
 933                                                         user_data->dlg.draw_area->style->black_gc,
 934                                                         2,
 935                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2,
 936                                                         small_layout);
 937                 }
 938 #endif
 939                 /* select colors */
 940                 if ( current_item+first_item == user_data->dlg.selected_item ){
 941                         frame_fg_color = user_data->dlg.draw_area->style->white_gc;
 942                         div_line_color = user_data->dlg.div_line_gc[1];
 943                 } else {
 944                         frame_fg_color = user_data->dlg.draw_area->style->black_gc;
 945                         div_line_color = user_data->dlg.div_line_gc[0];
 946                 }
 947                 /* draw the arrow line */
 948                 start_arrow = left_x_border+(user_data->dlg.items[current_item].src_node)*NODE_WIDTH+NODE_WIDTH/2;
 949                 end_arrow = left_x_border+(user_data->dlg.items[current_item].dst_node)*NODE_WIDTH+NODE_WIDTH/2;
 950
 951                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
 952                         gdk_draw_line(user_data->dlg.pixmap, frame_fg_color,
 953                                 start_arrow,
 954                                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7,
 955                                 end_arrow,
 956                                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7);
 957
 958                         /* draw the additional line when line style is 2 pixels width */
 959                         if (user_data->dlg.items[current_item].line_style == 2) {
 960                                 gdk_draw_line(user_data->dlg.pixmap, frame_fg_color,
 961                                         start_arrow,
 962                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-6,
 963                                         end_arrow,
 964                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-6);
 965                         }
 966                 }
 967
 968                 /* draw the arrow */
 969                 if (start_arrow<end_arrow)
 970                         draw_arrow(user_data->dlg.pixmap, frame_fg_color, end_arrow-WIDTH_ARROW,top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7, RIGHT_ARROW);
 971                 else
 972                         draw_arrow(user_data->dlg.pixmap, frame_fg_color, end_arrow+WIDTH_ARROW,top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7, LEFT_ARROW);
 973
 974                 /* draw the frame comment */
 975                 g_snprintf(label_string, MAX_LABEL, "%s", user_data->dlg.items[current_item].frame_label);
 976 #if GTK_MAJOR_VERSION < 2
 977                 label_width=gdk_string_width(big_font, label_string);
 978                 label_height=gdk_string_height(big_font, label_string);
 979 #else
 980                 pango_layout_set_text(big_layout, label_string, -1);
 981                 pango_layout_get_pixel_size(big_layout, &label_width, &label_height);
 982 #endif
 983                 if (start_arrow<end_arrow){
 984                         arrow_width = end_arrow-start_arrow;
 985                         label_x = arrow_width/2+start_arrow;
 986                 }
 987                 else {
 988                         arrow_width = start_arrow-end_arrow;
 989                         label_x = arrow_width/2+end_arrow;
 990                 }
 991
 992                 if (label_width>arrow_width) arrow_width = label_width;
 993
 994                 if ((int)left_x_border > ((int)label_x-(int)label_width/2))
 995                         label_x = left_x_border + label_width/2;
 996
 997 #if GTK_MAJOR_VERSION < 2
 998                 gdk_draw_string(user_data->dlg.pixmap,
 999                         big_font,
1000                         frame_fg_color,
1001                         label_x - label_width/2,
1002                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2+label_height/4-3,
1003                         label_string);
1004 #else
1005                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
1006                         gdk_draw_layout(user_data->dlg.pixmap,
1007                                                         frame_fg_color,
1008                                                         label_x - label_width/2,
1009                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2-3,
1010                                                         big_layout);
1011                 }
1012 #endif
1013
1014
1015                 /* draw the source port number */
1016                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_src);
1017 #if GTK_MAJOR_VERSION < 2
1018                 label_width=gdk_string_width(small_font, label_string);
1019                 label_height=gdk_string_height(small_font, label_string);
1020 #else
1021                 pango_layout_set_text(small_layout, label_string, -1);
1022                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
1023 #endif
1024                 if (start_arrow<end_arrow){
1025                         src_port_x = start_arrow - label_width - 2;
1026                 }
1027                 else {
1028                         src_port_x = start_arrow + 2;
1029                 }
1030 #if GTK_MAJOR_VERSION < 2
1031                 gdk_draw_string(user_data->dlg.pixmap,
1032                         small_font,
1033                         div_line_color,
1034                         src_port_x,
1035                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2+label_height/4-2,
1036                         label_string);
1037 #else
1038                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
1039                         gdk_draw_layout(user_data->dlg.pixmap,
1040                                                         div_line_color,
1041                                                         src_port_x,
1042                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2,
1043                                                         small_layout);
1044                 }
1045 #endif
1046
1047                 /* draw the destination port number */
1048                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_dst);
1049 #if GTK_MAJOR_VERSION < 2
1050                 label_width=gdk_string_width(small_font, label_string);
1051                 label_height=gdk_string_height(small_font, label_string);
1052 #else
1053                 pango_layout_set_text(small_layout, label_string, -1);
1054                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
1055 #endif
1056                 if (start_arrow<end_arrow){
1057                         dst_port_x = end_arrow + 2;
1058                 }
1059                 else {
1060                         dst_port_x = end_arrow - label_width - 2;
1061                 }
1062 #if GTK_MAJOR_VERSION < 2
1063                 gdk_draw_string(user_data->dlg.pixmap,
1064                         small_font,
1065                         div_line_color,
1066                         dst_port_x,
1067                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2+label_height/4-2,
1068                         label_string);
1069 #else
1070                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
1071                         gdk_draw_layout(user_data->dlg.pixmap,
1072                                                         div_line_color,
1073                                                         dst_port_x,
1074                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2,
1075                                                         small_layout);
1076                 }
1077 #endif
1078                 /* draw the div line of the selected item with soft gray*/
1079                 if ( current_item+first_item == user_data->dlg.selected_item )
1080                         for (i=0; i<user_data->num_nodes; i++){
1081                                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
1082                                         gdk_draw_line(user_data->dlg.pixmap, user_data->dlg.div_line_gc[1],
1083                                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
1084                                                                   (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER,
1085                                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
1086                                                                   (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER+ITEM_HEIGHT);
1087                                 }
1088                         }
1089         }
1090
1091
1092 #if GTK_MAJOR_VERSION >= 2
1093         g_object_unref(G_OBJECT(layout));
1094 #endif
1095
1096         /* refresh the draw areas */
1097         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_time->window) )
1098                 gdk_draw_pixmap(user_data->dlg.draw_area_time->window,
1099                                                 user_data->dlg.draw_area_time->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area_time)],
1100                                                 user_data->dlg.pixmap_time,
1101                                                 0, 0,
1102                                                 0, 0,
1103                                                 user_data->dlg.draw_area_time->allocation.width, user_data->dlg.draw_area_time->allocation.height);
1104
1105         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area->window) )
1106                 gdk_draw_pixmap(user_data->dlg.draw_area->window,
1107                                                 user_data->dlg.draw_area->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area)],
1108                                                 user_data->dlg.pixmap,
1109                                                 0, 0,
1110                                                 0, 0,
1111                                                 user_data->dlg.draw_area->allocation.width, user_data->dlg.draw_area->allocation.height);
1112
1113         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_comments->window) )
1114                 gdk_draw_pixmap(user_data->dlg.draw_area_comments->window,
1115                                                 user_data->dlg.draw_area_comments->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area_comments)],
1116                                                 user_data->dlg.pixmap_comments,
1117                                                 0, 0,
1118                                                 0, 0,
1119                                                 user_data->dlg.draw_area_comments->allocation.width, user_data->dlg.draw_area_comments->allocation.height);
1120
1121         /* update the v_scrollbar */
1122         user_data->dlg.v_scrollbar_adjustment->upper=(gfloat) user_data->num_items-1;
1123         user_data->dlg.v_scrollbar_adjustment->step_increment=1;
1124         user_data->dlg.v_scrollbar_adjustment->page_increment=(gfloat) (last_item-first_item);
1125         user_data->dlg.v_scrollbar_adjustment->page_size=(gfloat) (last_item-first_item);
1126         user_data->dlg.v_scrollbar_adjustment->value=(gfloat) first_item;
1127
1128         gtk_adjustment_changed(user_data->dlg.v_scrollbar_adjustment);
1129         gtk_adjustment_value_changed(user_data->dlg.v_scrollbar_adjustment);
1130 }
1131
1132 /****************************************************************************/
1133 static void dialog_graph_redraw(graph_analysis_data_t* user_data)
1134 {
1135         user_data->dlg.needs_redraw=TRUE;
1136         dialog_graph_draw(user_data);
1137 }
1138
1139 /****************************************************************************/
1140 static gint button_press_event(GtkWidget *widget, GdkEventButton *event _U_)
1141 {
1142         graph_analysis_data_t *user_data;
1143                 guint32 item;
1144
1145         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1146
1147         if (event->type != GDK_BUTTON_PRESS) return TRUE;
1148
1149         if (event->y<TOP_Y_BORDER) return TRUE;
1150
1151         /* get the item clicked */
1152         item = ((guint32)event->y - TOP_Y_BORDER) / ITEM_HEIGHT;
1153         user_data->dlg.selected_item = item + user_data->dlg.first_item;
1154
1155         user_data->dlg.needs_redraw=TRUE;
1156         dialog_graph_draw(user_data);
1157
1158         cf_goto_frame(&cfile, user_data->dlg.items[item].frame_num);
1159
1160         return TRUE;
1161 }
1162
1163 #if GTK_MAJOR_VERSION >= 2
1164 /* scroll events are not available in gtk-1.2 */
1165 /****************************************************************************/
1166 static gint scroll_event(GtkWidget *widget, GdkEventScroll *event)
1167 {
1168         graph_analysis_data_t *user_data;
1169
1170         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1171
1172         /* Up scroll */
1173         switch(event->direction) {
1174         case(GDK_SCROLL_UP):
1175                 if (user_data->dlg.first_item == 0) return TRUE;
1176                 if (user_data->dlg.first_item < 3)
1177                         user_data->dlg.first_item = 0;
1178                 else
1179                         user_data->dlg.first_item -= 3;
1180                 break;
1181         case(GDK_SCROLL_DOWN):
1182                 if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1 == user_data->num_items)) return TRUE;
1183                 if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1) > (user_data->num_items-3))
1184                         user_data->dlg.first_item = user_data->num_items-(guint32)user_data->dlg.v_scrollbar_adjustment->page_size-1;
1185                 else
1186                         user_data->dlg.first_item += 3;
1187             break;
1188         case(GDK_SCROLL_LEFT):
1189         case(GDK_SCROLL_RIGHT):
1190             /* nothing to do */
1191             break;
1192         }
1193         dialog_graph_redraw(user_data);
1194
1195         return TRUE;
1196 }
1197 #endif
1198
1199 /****************************************************************************/
1200 static gint key_press_event(GtkWidget *widget, GdkEventKey *event _U_)
1201 {
1202         graph_analysis_data_t *user_data;
1203
1204         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1205
1206         /* if there is nothing selected, just return */
1207         if (user_data->dlg.selected_item == 0xFFFFFFFF) return TRUE;
1208
1209         /* Up arrow */
1210         if (event->keyval == GDK_Up){
1211                 if (user_data->dlg.selected_item == 0) return TRUE;
1212                 user_data->dlg.selected_item--;
1213                 if ( (user_data->dlg.selected_item<user_data->dlg.first_item) || (user_data->dlg.selected_item>user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size) )
1214                         user_data->dlg.first_item = user_data->dlg.selected_item;
1215                 /* Down arrow */
1216         } else if (event->keyval == GDK_Down){
1217                 if (user_data->dlg.selected_item == user_data->num_items-1) return TRUE;
1218                 user_data->dlg.selected_item++;
1219                 if ( (user_data->dlg.selected_item<user_data->dlg.first_item) || (user_data->dlg.selected_item>user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size) )
1220                         user_data->dlg.first_item = (guint32)user_data->dlg.selected_item-(guint32)user_data->dlg.v_scrollbar_adjustment->page_size;
1221         } else if (event->keyval == GDK_Left){
1222                 if (user_data->dlg.first_node == 0) return TRUE;
1223                 user_data->dlg.first_node--;
1224         } else return TRUE;
1225
1226         user_data->dlg.needs_redraw=TRUE;
1227         dialog_graph_draw(user_data);
1228
1229         cf_goto_frame(&cfile, user_data->dlg.items[user_data->dlg.selected_item-user_data->dlg.first_item].frame_num);
1230
1231         return TRUE;
1232 }
1233
1234 /****************************************************************************/
1235 static gint expose_event(GtkWidget *widget, GdkEventExpose *event)
1236 {
1237         graph_analysis_data_t *user_data;
1238
1239         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1240         if(!user_data){
1241                 exit(10);
1242         }
1243
1244         if (GDK_IS_DRAWABLE(widget->window) )
1245                 gdk_draw_pixmap(widget->window,
1246                 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1247                 user_data->dlg.pixmap,
1248                 event->area.x, event->area.y,
1249                 event->area.x, event->area.y,
1250                 event->area.width, event->area.height);
1251
1252         return FALSE;
1253 }
1254
1255 /****************************************************************************/
1256 static gint expose_event_comments(GtkWidget *widget, GdkEventExpose *event)
1257 {
1258         graph_analysis_data_t *user_data;
1259
1260         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1261         if(!user_data){
1262                 exit(10);
1263         }
1264
1265         if (GDK_IS_DRAWABLE(widget->window) )
1266                 gdk_draw_pixmap(widget->window,
1267                 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1268                 user_data->dlg.pixmap_comments,
1269                 event->area.x, event->area.y,
1270                 event->area.x, event->area.y,
1271                 event->area.width, event->area.height);
1272
1273         return FALSE;
1274 }
1275
1276 /****************************************************************************/
1277 static gint expose_event_time(GtkWidget *widget, GdkEventExpose *event)
1278 {
1279         graph_analysis_data_t *user_data;
1280
1281         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1282         if(!user_data){
1283                 exit(10);
1284         }
1285
1286         if (GDK_IS_DRAWABLE(widget->window) )
1287                 gdk_draw_pixmap(widget->window,
1288                 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1289                 user_data->dlg.pixmap_time,
1290                 event->area.x, event->area.y,
1291                 event->area.x, event->area.y,
1292                 event->area.width, event->area.height);
1293
1294         return FALSE;
1295 }
1296
1297 /****************************************************************************/
1298 static gint configure_event(GtkWidget *widget, GdkEventConfigure *event _U_)
1299 {
1300         graph_analysis_data_t *user_data;
1301         int i;
1302
1303         /* gray and soft gray colors */
1304         static GdkColor color_div_line[2] = {
1305                 {0, 0x64ff, 0x64ff, 0x64ff},
1306                 {0, 0x7fff, 0x7fff, 0x7fff}
1307         };
1308
1309         /* the first calor is blue to highlight the selected item */
1310         static GdkColor col[MAX_NUM_COL_CONV+1] = {
1311                 {0,     0x00FF, 0x00FF, 0xFFFF},
1312         {0,     0x33FF, 0xFFFF, 0x33FF},
1313         {0,     0x00FF, 0xCCFF, 0xCCFF},
1314                 {0,     0x66FF, 0xFFFF, 0xFFFF},
1315                 {0,     0x99FF, 0x66FF, 0xFFFF},
1316                 {0,     0xFFFF, 0xFFFF, 0x33FF},
1317                 {0,     0xCCFF, 0x99FF, 0xFFFF},
1318                 {0,     0xCCFF, 0xFFFF, 0x33FF},
1319                 {0,     0xFFFF, 0xCCFF, 0xCCFF},
1320                 {0,     0xFFFF, 0x99FF, 0x66FF},
1321                 {0,     0xFFFF, 0xFFFF, 0x99FF}
1322         };
1323
1324         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1325
1326         if(!user_data){
1327                 exit(10);
1328         }
1329
1330         if(user_data->dlg.pixmap){
1331                 gdk_pixmap_unref(user_data->dlg.pixmap);
1332                 user_data->dlg.pixmap=NULL;
1333         }
1334
1335         user_data->dlg.pixmap=gdk_pixmap_new(widget->window,
1336                         widget->allocation.width,
1337                         widget->allocation.height,
1338                         -1);
1339
1340         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
1341                         gdk_draw_rectangle(user_data->dlg.pixmap,
1342                 widget->style->white_gc,
1343                 TRUE,
1344                 0, 0,
1345                 widget->allocation.width,
1346                 widget->allocation.height);
1347
1348         /* create gc for division lines and set the line stype to dash*/
1349         for (i=0; i<2; i++){
1350                 user_data->dlg.div_line_gc[i]=gdk_gc_new(user_data->dlg.pixmap);
1351                 gdk_gc_set_line_attributes(user_data->dlg.div_line_gc[i], 1, GDK_LINE_ON_OFF_DASH, 0, 0);
1352 #if GTK_MAJOR_VERSION < 2
1353                 colormap = gtk_widget_get_colormap (widget);
1354                 if (!gdk_color_alloc (colormap, &color_div_line[i])){
1355                                          g_warning ("Couldn't allocate color");
1356                 }
1357                 gdk_gc_set_foreground(user_data->dlg.div_line_gc[i], &color_div_line[i]);
1358 #else
1359         gdk_gc_set_rgb_fg_color(user_data->dlg.div_line_gc[i], &color_div_line[i]);
1360 #endif
1361         }
1362
1363         /* create gcs for the background items */
1364         for (i=0; i<MAX_NUM_COL_CONV+1; i++){
1365                 user_data->dlg.bg_gc[i]=gdk_gc_new(user_data->dlg.pixmap);
1366 #if GTK_MAJOR_VERSION < 2
1367                 colormap = gtk_widget_get_colormap (widget);
1368                 if (!gdk_color_alloc (colormap, &col[i])){
1369                                          g_warning ("Couldn't allocate color");
1370                 }
1371                 gdk_gc_set_foreground(user_data->dlg.bg_gc[i], &col[i]);
1372 #else
1373         gdk_gc_set_rgb_fg_color(user_data->dlg.bg_gc[i], &col[i]);
1374 #endif
1375         }
1376
1377                 dialog_graph_redraw(user_data);
1378
1379         return TRUE;
1380 }
1381
1382 /****************************************************************************/
1383 static gint configure_event_comments(GtkWidget *widget, GdkEventConfigure *event _U_)
1384 {
1385         graph_analysis_data_t *user_data;
1386
1387         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1388
1389         if(!user_data){
1390                 exit(10);
1391         }
1392
1393         if(user_data->dlg.pixmap_comments){
1394                 gdk_pixmap_unref(user_data->dlg.pixmap_comments);
1395                 user_data->dlg.pixmap_comments=NULL;
1396         }
1397
1398         user_data->dlg.pixmap_comments=gdk_pixmap_new(widget->window,
1399                                                 widget->allocation.width,
1400                         widget->allocation.height,
1401                         -1);
1402
1403         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
1404                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
1405                                                    widget->style->white_gc,
1406                                                    TRUE,
1407                                                    0, 0,
1408                                                    widget->allocation.width,
1409                                                    widget->allocation.height);
1410
1411         dialog_graph_redraw(user_data);
1412         return TRUE;
1413 }
1414
1415 /****************************************************************************/
1416 static gint configure_event_time(GtkWidget *widget, GdkEventConfigure *event _U_)
1417 {
1418         graph_analysis_data_t *user_data;
1419
1420         user_data=(graph_analysis_data_t *)OBJECT_GET_DATA(widget, "graph_analysis_data_t");
1421
1422         if(!user_data){
1423                 exit(10);
1424         }
1425
1426         if(user_data->dlg.pixmap_time){
1427                 gdk_pixmap_unref(user_data->dlg.pixmap_time);
1428                 user_data->dlg.pixmap_time=NULL;
1429         }
1430
1431         user_data->dlg.pixmap_time=gdk_pixmap_new(widget->window,
1432                                                 widget->allocation.width,
1433                         widget->allocation.height,
1434                         -1);
1435
1436         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
1437                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
1438                                                    widget->style->white_gc,
1439                                                    TRUE,
1440                                                    0, 0,
1441                                                    widget->allocation.width,
1442                                                    widget->allocation.height);
1443
1444         dialog_graph_redraw(user_data);
1445
1446
1447         return TRUE;
1448 }
1449 #if GTK_MAJOR_VERSION >= 2
1450 /****************************************************************************/
1451 static gint pane_callback(GtkWidget *widget, GParamSpec *pspec _U_, gpointer data)
1452 {
1453         graph_analysis_data_t *user_data=(graph_analysis_data_t *)data;
1454
1455         if(!user_data){
1456                 exit(10);
1457         }
1458         if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) > user_data->dlg.pixmap_width)
1459                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), user_data->dlg.pixmap_width);
1460         else if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) < NODE_WIDTH*2)
1461                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), NODE_WIDTH*2);
1462         /* repaint the comment area because when moving the pane position thre are times that the expose_event_comments is not called */
1463         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_comments->window) )
1464                 gdk_draw_pixmap(user_data->dlg.draw_area_comments->window,
1465                 user_data->dlg.draw_area_comments->style->fg_gc[GTK_WIDGET_STATE(widget)],
1466                 user_data->dlg.pixmap_comments,
1467                                         0,0,
1468                                         0,0,
1469                                         user_data->dlg.draw_area_comments->allocation.width,
1470                 user_data->dlg.draw_area_comments->allocation.height);
1471         return TRUE;
1472 }
1473 #endif
1474
1475 /****************************************************************************/
1476 static gint v_scrollbar_changed(GtkWidget *widget _U_, gpointer data)
1477 {
1478         graph_analysis_data_t *user_data=(graph_analysis_data_t *)data;
1479         if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1 == user_data->num_items)
1480                 && (user_data->dlg.v_scrollbar_adjustment->value >= user_data->dlg.first_item ))
1481                 return TRUE;
1482
1483         if (user_data->dlg.first_item == user_data->dlg.v_scrollbar_adjustment->value)
1484                 return TRUE;
1485
1486         user_data->dlg.first_item = (guint32) user_data->dlg.v_scrollbar_adjustment->value;
1487
1488         dialog_graph_redraw(user_data);
1489         return TRUE;
1490 }
1491
1492 /****************************************************************************/
1493 static void create_draw_area(graph_analysis_data_t* user_data, GtkWidget *box)
1494 {
1495         GtkWidget *vbox;
1496         GtkWidget *hbox;
1497         GtkWidget *viewport;
1498         GtkWidget *scroll_window_comments;
1499         GtkWidget *viewport_comments;
1500
1501         hbox=gtk_hbox_new(FALSE, 0);
1502         gtk_widget_show(hbox);
1503
1504         vbox=gtk_vbox_new(FALSE, 0);
1505         gtk_widget_show(vbox);
1506
1507         /* create "time" draw area */
1508         user_data->dlg.draw_area_time=gtk_drawing_area_new();
1509         WIDGET_SET_SIZE(user_data->dlg.draw_area_time, TIME_WIDTH, user_data->dlg.pixmap_height);
1510         OBJECT_SET_DATA(user_data->dlg.draw_area_time, "graph_analysis_data_t", user_data);
1511
1512         /* create "comments" draw area */
1513         user_data->dlg.draw_area_comments=gtk_drawing_area_new();
1514         WIDGET_SET_SIZE(user_data->dlg.draw_area_comments, COMMENT_WIDTH, user_data->dlg.pixmap_height);
1515         scroll_window_comments=gtk_scrolled_window_new(NULL, NULL);
1516         WIDGET_SET_SIZE(scroll_window_comments, COMMENT_WIDTH/2, user_data->dlg.pixmap_height);
1517         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window_comments), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
1518         viewport_comments = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scroll_window_comments)), gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scroll_window_comments)));
1519         gtk_container_add(GTK_CONTAINER(viewport_comments), user_data->dlg.draw_area_comments);
1520         gtk_container_add(GTK_CONTAINER(scroll_window_comments), viewport_comments);
1521         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport_comments), GTK_SHADOW_NONE);
1522         OBJECT_SET_DATA(user_data->dlg.draw_area_comments, "graph_analysis_data_t", user_data);
1523         gtk_widget_add_events (user_data->dlg.draw_area_comments, GDK_BUTTON_PRESS_MASK);
1524
1525 #if GTK_MAJOR_VERSION >= 2
1526         SIGNAL_CONNECT(user_data->dlg.draw_area_comments, "scroll_event",  scroll_event, user_data);
1527 #endif
1528         /* create main Graph draw area */
1529         user_data->dlg.draw_area=gtk_drawing_area_new();
1530         if (user_data->num_nodes < 2)
1531                 user_data->dlg.pixmap_width = 2 * NODE_WIDTH;
1532         else
1533                 user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1534         WIDGET_SET_SIZE(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1535         user_data->dlg.scroll_window=gtk_scrolled_window_new(NULL, NULL);
1536         if ( user_data->num_nodes < 6)
1537                 WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1538         else
1539                 WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1540         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
1541         viewport = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window)), gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window)));
1542         gtk_container_add(GTK_CONTAINER(viewport), user_data->dlg.draw_area);
1543         gtk_container_add(GTK_CONTAINER(user_data->dlg.scroll_window), viewport);
1544         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
1545         OBJECT_SET_DATA(user_data->dlg.draw_area, "graph_analysis_data_t", user_data);
1546         GTK_WIDGET_SET_FLAGS(user_data->dlg.draw_area, GTK_CAN_FOCUS);
1547         gtk_widget_grab_focus(user_data->dlg.draw_area);
1548
1549         /* signals needed to handle backing pixmap */
1550         SIGNAL_CONNECT(user_data->dlg.draw_area, "expose_event", expose_event, NULL);
1551         SIGNAL_CONNECT(user_data->dlg.draw_area, "configure_event", configure_event, user_data);
1552
1553         /* signals needed to handle backing pixmap comments*/
1554         SIGNAL_CONNECT(user_data->dlg.draw_area_comments, "expose_event", expose_event_comments, NULL);
1555         SIGNAL_CONNECT(user_data->dlg.draw_area_comments, "configure_event", configure_event_comments, user_data);
1556
1557         /* signals needed to handle backing pixmap time*/
1558         SIGNAL_CONNECT(user_data->dlg.draw_area_time, "expose_event", expose_event_time, NULL);
1559         SIGNAL_CONNECT(user_data->dlg.draw_area_time, "configure_event", configure_event_time, user_data);
1560
1561         gtk_widget_add_events (user_data->dlg.draw_area, GDK_BUTTON_PRESS_MASK);
1562         SIGNAL_CONNECT(user_data->dlg.draw_area, "button_press_event", button_press_event, user_data);
1563 #if GTK_MAJOR_VERSION >= 2
1564         SIGNAL_CONNECT(user_data->dlg.draw_area, "scroll_event",  scroll_event, user_data);
1565 #endif
1566         SIGNAL_CONNECT(user_data->dlg.draw_area, "key_press_event",  key_press_event, user_data);
1567
1568         gtk_widget_show(user_data->dlg.draw_area_time);
1569         gtk_widget_show(user_data->dlg.draw_area);
1570         gtk_widget_show(viewport);
1571         gtk_widget_show(user_data->dlg.draw_area_comments);
1572         gtk_widget_show(viewport_comments);
1573
1574         gtk_widget_show(user_data->dlg.scroll_window);
1575         gtk_widget_show(scroll_window_comments);
1576
1577         gtk_box_pack_start(GTK_BOX(hbox), user_data->dlg.draw_area_time, FALSE, FALSE, 0);
1578
1579                 user_data->dlg.hpane = gtk_hpaned_new();
1580                 gtk_paned_pack1(GTK_PANED (user_data->dlg.hpane), user_data->dlg.scroll_window, FALSE, TRUE);
1581                 gtk_paned_pack2(GTK_PANED (user_data->dlg.hpane), scroll_window_comments, TRUE, TRUE);
1582 #if GTK_MAJOR_VERSION >= 2
1583         SIGNAL_CONNECT(user_data->dlg.hpane, "notify::position",  pane_callback, user_data);
1584 #endif
1585         gtk_widget_show(user_data->dlg.hpane);
1586
1587         gtk_box_pack_start(GTK_BOX(hbox), user_data->dlg.hpane, TRUE, TRUE, 0);
1588
1589        /* create the associated v_scrollbar */
1590         user_data->dlg.v_scrollbar_adjustment=(GtkAdjustment *)gtk_adjustment_new(0,0,0,0,0,0);
1591         user_data->dlg.v_scrollbar=gtk_vscrollbar_new(user_data->dlg.v_scrollbar_adjustment);
1592         gtk_widget_show(user_data->dlg.v_scrollbar);
1593         gtk_box_pack_end(GTK_BOX(hbox), user_data->dlg.v_scrollbar, FALSE, FALSE, 0);
1594         SIGNAL_CONNECT(user_data->dlg.v_scrollbar_adjustment, "value_changed", v_scrollbar_changed, user_data);
1595
1596
1597         gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 0);
1598 }
1599 /****************************************************************************/
1600 /* PUBLIC */
1601 /****************************************************************************/
1602
1603
1604 /****************************************************************************/
1605 static void dialog_graph_create_window(graph_analysis_data_t* user_data)
1606 {
1607         GtkWidget *vbox;
1608         GtkWidget *hbuttonbox;
1609         GtkWidget *bt_close;
1610         GtkWidget *bt_save;
1611         GtkTooltips *tooltips = gtk_tooltips_new();
1612
1613         /* create the main window */
1614                 if (user_data->dlg.title)
1615                 user_data->dlg.window=window_new(GTK_WINDOW_TOPLEVEL, user_data->dlg.title);
1616                 else
1617                 user_data->dlg.window=window_new(GTK_WINDOW_TOPLEVEL, "Graph Analysis");
1618
1619
1620         vbox=gtk_vbox_new(FALSE, 0);
1621         gtk_container_add(GTK_CONTAINER(user_data->dlg.window), vbox);
1622         gtk_widget_show(vbox);
1623
1624         create_draw_area(user_data, vbox);
1625
1626         /* button row */
1627         hbuttonbox = gtk_hbutton_box_new ();
1628         gtk_box_pack_start (GTK_BOX (vbox), hbuttonbox, FALSE, FALSE, 0);
1629         gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_SPREAD);
1630         gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox), 30);
1631         gtk_widget_show(hbuttonbox);
1632
1633         bt_save = BUTTON_NEW_FROM_STOCK(GTK_STOCK_SAVE_AS);
1634         gtk_container_add(GTK_CONTAINER(hbuttonbox), bt_save);
1635         gtk_widget_show(bt_save);
1636         SIGNAL_CONNECT(bt_save, "clicked", on_save_bt_clicked, user_data);
1637         gtk_tooltips_set_tip (tooltips, bt_save, "Save an ASCII representation of the graph to a file", NULL);
1638
1639         bt_close = BUTTON_NEW_FROM_STOCK(GTK_STOCK_CLOSE);
1640         gtk_container_add (GTK_CONTAINER (hbuttonbox), bt_close);
1641         GTK_WIDGET_SET_FLAGS(bt_close, GTK_CAN_DEFAULT);
1642         gtk_widget_show(bt_close);
1643         gtk_tooltips_set_tip (tooltips, bt_close, "Close this dialog", NULL);
1644         window_set_cancel_button(user_data->dlg.window, bt_close, window_cancel_button_cb);
1645
1646         SIGNAL_CONNECT(user_data->dlg.window, "delete_event", window_delete_event_cb, NULL);
1647         SIGNAL_CONNECT(user_data->dlg.window, "destroy", on_destroy, user_data);
1648
1649         gtk_widget_show(user_data->dlg.window);
1650         window_present(user_data->dlg.window);
1651 }
1652
1653 /* Return the index array if the node is in the array. Return -1 if there is room in the array
1654  * and Return -2 if the array is full
1655  */
1656 /****************************************************************************/
1657 static gint is_node_array(graph_analysis_data_t* user_data, address* node)
1658 {
1659         int i;
1660         for (i=0; i<MAX_NUM_NODES; i++){
1661                 if (user_data->nodes[i].type == AT_NONE)        return -1;      /* it is not in the array */
1662                 if (ADDRESSES_EQUAL((&user_data->nodes[i]),node)) return i;     /* it is in the array */
1663         }
1664         return -2;              /* array full */
1665 }
1666
1667
1668 /* Get the nodes from the list */
1669 /****************************************************************************/
1670 static void get_nodes(graph_analysis_data_t* user_data)
1671 {
1672         GList* list;
1673         graph_analysis_item_t *gai;
1674         gint index;
1675
1676         /* fill the node array */
1677         list = g_list_first(user_data->graph_info->list);
1678         while (list)
1679         {
1680                 gai = list->data;
1681                 if (gai->display){
1682                         user_data->num_items++;
1683                         if (!user_data->dlg.inverse) {
1684                                 /* check source node address */
1685                                 index = is_node_array(user_data, &(gai->src_addr));
1686                                 switch(index){
1687                                         case -2: /* array full */
1688                                                 gai->src_node = NODE_OVERFLOW;
1689                                                 break;
1690                                         case -1: /* not in array */
1691                                                 COPY_ADDRESS(&(user_data->nodes[user_data->num_nodes]),&(gai->src_addr));
1692                                                 gai->src_node = user_data->num_nodes;
1693                                                 user_data->num_nodes++;
1694                                                 break;
1695                                         default: /* it is in the array, just update the src_node */
1696                                                 gai->src_node = (guint16)index;
1697                                 }
1698
1699                                 /* check destination node address*/
1700                                 index = is_node_array(user_data, &(gai->dst_addr));
1701                                 switch(index){
1702                                         case -2: /* array full */
1703                                                 gai->dst_node = NODE_OVERFLOW;
1704                                                 break;
1705                                         case -1: /* not in array */
1706                                                 COPY_ADDRESS(&(user_data->nodes[user_data->num_nodes]),&(gai->dst_addr));
1707                                                 gai->dst_node = user_data->num_nodes;
1708                                                 user_data->num_nodes++;
1709                                                 break;
1710                                         default: /* it is in the array, just update the dst_node */
1711                                                 gai->dst_node = (guint16)index;
1712                                 }
1713                         } else {
1714                                 /* check destination node address*/
1715                                 index = is_node_array(user_data, &(gai->dst_addr));
1716                                 switch(index){
1717                                         case -2: /* array full */
1718                                                 gai->dst_node = NODE_OVERFLOW;
1719                                                 break;
1720                                         case -1: /* not in array */
1721                                                 COPY_ADDRESS(&(user_data->nodes[user_data->num_nodes]),&(gai->dst_addr));
1722                                                 gai->dst_node = user_data->num_nodes;
1723                                                 user_data->num_nodes++;
1724                                                 break;
1725                                         default: /* it is in the array, just update the dst_node */
1726                                                 gai->dst_node = (guint16)index;
1727                                 }
1728
1729                                 /* check source node address */
1730                                 index = is_node_array(user_data, &(gai->src_addr));
1731                                 switch(index){
1732                                         case -2: /* array full */
1733                                                 gai->src_node = NODE_OVERFLOW;
1734                                                 break;
1735                                         case -1: /* not in array */
1736                                                 COPY_ADDRESS(&(user_data->nodes[user_data->num_nodes]),&(gai->src_addr));
1737                                                 gai->src_node = user_data->num_nodes;
1738                                                 user_data->num_nodes++;
1739                                                 break;
1740                                         default: /* it is in the array, just update the src_node */
1741                                                 gai->src_node = (guint16)index;
1742                                 }
1743
1744                         }
1745                 }
1746
1747                 list = g_list_next(list);
1748         }
1749 }
1750
1751 /****************************************************************************/
1752 graph_analysis_data_t* graph_analysis_init(void)
1753 {
1754         graph_analysis_data_t* user_data;
1755         /* init */
1756         user_data = g_malloc(sizeof(graph_analysis_data_t));
1757
1758         /* init user_data */
1759         graph_analysis_init_dlg(user_data);
1760
1761         return user_data;
1762 }
1763 /****************************************************************************/
1764 /* PUBLIC */
1765 /****************************************************************************/
1766
1767 /****************************************************************************/
1768 void graph_analysis_create(graph_analysis_data_t* user_data)
1769 {
1770         /* reset the data */
1771         graph_analysis_reset(user_data);
1772
1773         /* get nodes (each node is an address) */
1774         get_nodes(user_data);
1775
1776         /* create the graph windows */
1777         dialog_graph_create_window(user_data);
1778
1779         /* redraw the graph */
1780         dialog_graph_redraw(user_data);
1781
1782         return;
1783 }
1784
1785 /****************************************************************************/
1786 void graph_analysis_update(graph_analysis_data_t* user_data)
1787 {
1788         /* reset the data */
1789         graph_analysis_reset(user_data);
1790
1791         /* get nodes (each node is an address) */
1792         get_nodes(user_data);
1793
1794         user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1795         WIDGET_SET_SIZE(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1796         if ( user_data->num_nodes < 6)
1797                 WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1798         else
1799                 WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1800
1801         /* redraw the graph */
1802         dialog_graph_redraw(user_data);
1803
1804         window_present(user_data->dlg.window);
1805         return;
1806 }
1807
1808
1809 /****************************************************************************/
1810 void graph_analysis_redraw(graph_analysis_data_t* user_data)
1811 {
1812         /* get nodes (each node is an address) */
1813         get_nodes(user_data);
1814
1815         user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1816     WIDGET_SET_SIZE(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1817         if ( user_data->num_nodes < 6)
1818                         WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1819                 else
1820                         WIDGET_SET_SIZE(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1821
1822
1823         /* redraw the graph */
1824         dialog_graph_redraw(user_data);
1825
1826     window_present(user_data->dlg.window);
1827         return;
1828 }