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 #include <string.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39
  40 #include <gtk/gtk.h>
  41 #include <gdk/gdkkeysyms.h>
  42
  43 #include <epan/epan_dissect.h>
  44 #include <epan/tap.h>
  45 #include <epan/dissectors/packet-rtp.h>
  46 #include <epan/addr_resolv.h>
  47 #include "epan/filesystem.h"
  48
  49 #include "../util.h"
  50 #include "../register.h"
  51 #include "../color.h"
  52 #include "../simple_dialog.h"
  53 #include <wsutil/file_util.h>
  54
  55 #include "gtk/gtkglobals.h"
  56 #include "gtk/file_dlg.h"
  57 #include "gtk/gui_utils.h"
  58 #include "gtk/main.h"
  59 #include "gtk/graph_analysis.h"
  60
  61
  62 /****************************************************************************/
  63
  64
  65 #define OK_TEXT "[ Ok ]"
  66 #define PT_UNDEFINED -1
  67
  68
  69 static GtkWidget *save_to_file_w = NULL;
  70
  71 #define MAX_LABEL 50
  72 #define MAX_COMMENT 100
  73 #define ITEM_HEIGHT 20
  74 #define NODE_WIDTH 100
  75 #define TOP_Y_BORDER 40
  76 #define BOTTOM_Y_BORDER 2
  77 #define COMMENT_WIDTH 400
  78 #define TIME_WIDTH 50
  79
  80 #define NODE_CHARS_WIDTH 20
  81 #define CONV_TIME_HEADER "Conv.| Time    "
  82 #define TIME_HEADER "|Time     "
  83 #define CONV_TIME_EMPTY_HEADER     "     |         "
  84 #define TIME_EMPTY_HEADER     "|         "
  85 #define CONV_TIME_HEADER_LENGTH 16
  86 #define TIME_HEADER_LENGTH 10
  87
  88 /****************************************************************************/
  89 /* Reset the user_data structure */
  90 static void graph_analysis_reset(graph_analysis_data_t* user_data)
  91 {
  92         int i;
  93
  94         user_data->num_nodes = 0;
  95         user_data->num_items = 0;
  96         for (i=0; i<MAX_NUM_NODES; i++){
  97                 user_data->nodes[i].type = AT_NONE;
  98                 user_data->nodes[i].len = 0;
  99                 g_free((void *)user_data->nodes[i].data);
 100                 user_data->nodes[i].data = NULL;
 101         }
 102
 103         user_data->dlg.first_node=0;
 104         user_data->dlg.first_item=0;
 105         user_data->dlg.left_x_border=0;
 106         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 107 }
 108
 109 /****************************************************************************/
 110 /* Reset the user_data structure */
 111 static void graph_analysis_init_dlg(graph_analysis_data_t* user_data)
 112 {
 113         int i;
 114
 115         user_data->num_nodes = 0;
 116         user_data->num_items = 0;
 117         user_data->on_destroy_user_data = NULL;
 118         user_data->data = NULL;
 119         for (i=0; i<MAX_NUM_NODES; i++){
 120                 user_data->nodes[i].type = AT_NONE;
 121                 user_data->nodes[i].len = 0;
 122                 user_data->nodes[i].data = NULL;
 123         }
 124
 125         user_data->dlg.first_node=0;
 126         user_data->dlg.first_item=0;
 127         user_data->dlg.left_x_border=0;
 128         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 129         /* init dialog_graph */
 130         user_data->dlg.needs_redraw=TRUE;
 131         user_data->dlg.draw_area_time=NULL;
 132         user_data->dlg.draw_area=NULL;
 133         user_data->dlg.pixmap=NULL;
 134         user_data->dlg.pixmap_time=NULL;
 135         user_data->dlg.draw_area_comments=NULL;
 136         user_data->dlg.pixmap_comments=NULL;
 137         user_data->dlg.v_scrollbar=NULL;
 138         user_data->dlg.v_scrollbar_adjustment=NULL;
 139         user_data->dlg.hpane=NULL;
 140         user_data->dlg.pixmap_width = 350;
 141         user_data->dlg.pixmap_height=400;
 142         user_data->dlg.first_node=0;
 143         user_data->dlg.first_item=0;
 144         user_data->dlg.left_x_border=0;
 145         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 146         user_data->dlg.window=NULL;
 147         user_data->dlg.parent_w=NULL;
 148         user_data->dlg.inverse = FALSE;
 149         user_data->dlg.title=NULL;
 150 }
 151
 152 /****************************************************************************/
 153 /* CALLBACKS */
 154
 155 /****************************************************************************/
 156 /* close the dialog window */
 157 static void on_destroy(GtkWidget *win _U_, graph_analysis_data_t *user_data)
 158 {
 159         int i;
 160
 161         for (i=0; i<MAX_NUM_NODES; i++){
 162                 user_data->nodes[i].type = AT_NONE;
 163                 user_data->nodes[i].len = 0;
 164                 g_free((void *)user_data->nodes[i].data);
 165                 user_data->nodes[i].data = NULL;
 166         }
 167         user_data->dlg.window = NULL;
 168         g_free(user_data->dlg.title);
 169         user_data->dlg.title = NULL;
 170
 171         if(user_data->on_destroy_user_data){
 172                 user_data->on_destroy_user_data(user_data->data);
 173         }
 174 }
 175
 176 #define RIGHT_ARROW 1
 177 #define LEFT_ARROW 0
 178 #define WIDTH_ARROW 8
 179 #define HEIGHT_ARROW 6
 180
 181 /****************************************************************************/
 182 static void draw_arrow(GdkDrawable *pixmap, GdkGC *gc, gint x, gint y, gboolean direction)
 183 {
 184         GdkPoint arrow_point[3];
 185
 186         arrow_point[0].x = x;
 187         arrow_point[0].y = y-HEIGHT_ARROW/2;
 188         if (direction == RIGHT_ARROW)
 189                 arrow_point[1].x = x+WIDTH_ARROW;
 190         else
 191                 arrow_point[1].x = x-WIDTH_ARROW;
 192         arrow_point[1].y = y;
 193         arrow_point[2].x = x;
 194         arrow_point[2].y = y+HEIGHT_ARROW/2;;
 195
 196         if (GDK_IS_DRAWABLE(pixmap)) {
 197                 gdk_draw_polygon(pixmap, gc, TRUE, arrow_point, 3);
 198         }
 199 }
 200
 201 /****************************************************************************/
 202 /* Adds trailing characters to complete the requested length.               */
 203 /****************************************************************************/
 204
 205 static void enlarge_string(GString *gstr, guint32 length, char pad){
 206
 207         guint32 i;
 208
 209         for (i = gstr->len; i < length; i++){
 210                 g_string_append_c(gstr, pad);
 211         }
 212 }
 213
 214 /****************************************************************************/
 215 /* overwrites the characters in a string, between positions p1 and p2, with */
 216 /*   the characters of text_to_insert                                       */
 217 /*   NB: it does not check that p1 and p2 fit into string                   */
 218 /****************************************************************************/
 219
 220 static void overwrite (GString *gstr, char *text_to_insert, guint32 p1, guint32 p2){
 221
 222         guint32 len;
 223         gsize pos;
 224
 225         if (p1 == p2)
 226                 return;
 227
 228         if (p1 > p2){
 229                 pos = p2;
 230                 len = p1 - p2;
 231         }
 232         else{
 233                 pos = p1;
 234                 len = p2 - p1;
 235         }
 236
 237         if (len > strlen(text_to_insert)){
 238                 len = strlen(text_to_insert);
 239         }
 240
 241         /* ouch this is ugly but gtk1 needs it */
 242         if ((guint32)pos > (guint32)gstr->len)
 243                 pos = gstr->len;
 244
 245         /* ouch this is ugly but gtk1 needs it */
 246         if ((guint32)(pos + len) > (guint32)gstr->len)
 247                 g_string_truncate(gstr, pos);
 248         else
 249                 g_string_erase(gstr, pos, len);
 250
 251         g_string_insert(gstr, pos, text_to_insert);
 252 }
 253
 254
 255 /*
 256  * XXX - We might want to refactor this to write the graph data directly to
 257  * the file instead of loading everything into strings first.
 258  */
 259
 260 /****************************************************************************/
 261 static gboolean dialog_graph_dump_to_file(graph_analysis_data_t* user_data)
 262 {
 263         guint32 i, first_node, display_items, display_nodes;
 264         guint32 start_position, end_position, item_width, header_length;
 265         guint32 current_item;
 266         graph_analysis_item_t *gai;
 267         guint16 first_conv_num = 0;
 268         gboolean several_convs = FALSE;
 269         gboolean first_packet = TRUE;
 270
 271         GString *label_string, *empty_line,*separator_line, *tmp_str, *tmp_str2;
 272         char *empty_header;
 273         char src_port[8],dst_port[8];
 274
 275         GList* list;
 276
 277         FILE *of;
 278
 279         of = ws_fopen(user_data->dlg.save_file,"w");
 280         if (of==NULL){
 281                 return FALSE;
 282         }
 283
 284         label_string   = g_string_new("");
 285         empty_line     = g_string_new("");
 286         separator_line = g_string_new("");
 287         tmp_str        = g_string_new("");
 288         tmp_str2       = g_string_new("");
 289
 290         /* get the items to display and fill the matrix array */
 291         list = g_list_first(user_data->graph_info->list);
 292         current_item = 0;
 293         i = 0;
 294         while (list && current_item < NUM_DISPLAY_ITEMS)
 295         {
 296                 gai = list->data;
 297                 if (gai->display){
 298                         user_data->dlg.items[current_item].frame_num = gai->frame_num;
 299                         user_data->dlg.items[current_item].time = gai->time;
 300                         user_data->dlg.items[current_item].port_src = gai->port_src;
 301                         user_data->dlg.items[current_item].port_dst = gai->port_dst;
 302                         user_data->dlg.items[current_item].frame_label = gai->frame_label;
 303                         user_data->dlg.items[current_item].comment = gai->comment;
 304                         user_data->dlg.items[current_item].conv_num = gai->conv_num;
 305                         user_data->dlg.items[current_item].src_node = gai->src_node;
 306                         user_data->dlg.items[current_item].dst_node = gai->dst_node;
 307                         if (first_packet){
 308                                 first_conv_num = gai->conv_num;
 309                                 first_packet=FALSE;
 310                         }
 311                         if (user_data->dlg.items[current_item].conv_num != first_conv_num){
 312                                 several_convs = TRUE;
 313                         }
 314                         current_item++;
 315                         i++;
 316                 }
 317
 318                 list = g_list_next(list);
 319         }
 320         display_items = current_item;
 321
 322         /* if not items to display */
 323         if (display_items == 0) goto exit;
 324
 325         display_nodes = user_data->num_nodes;
 326
 327         first_node = user_data->dlg.first_node;
 328
 329         /* Write the conv. and time headers */
 330         if (several_convs){
 331                 fprintf(of, CONV_TIME_HEADER);
 332                 empty_header = CONV_TIME_EMPTY_HEADER;
 333                 header_length = CONV_TIME_HEADER_LENGTH;
 334         }
 335         else{
 336                 fprintf(of, TIME_HEADER);
 337                 empty_header = TIME_EMPTY_HEADER;
 338                 header_length = TIME_HEADER_LENGTH;
 339         }
 340
 341         /* Write the node names on top */
 342         for (i=0; i<display_nodes; i+=2){
 343                 /* print the node identifiers */
 344                 g_string_printf(label_string, "| %s",
 345                         get_addr_name(&(user_data->nodes[i+first_node])));
 346                 enlarge_string(label_string, NODE_CHARS_WIDTH*2, ' ');
 347                 fprintf(of, "%s", label_string->str);
 348                 g_string_printf(label_string, "| ");
 349                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 350                 g_string_append(empty_line, label_string->str);
 351         }
 352
 353         fprintf(of, "|\n%s", empty_header);
 354         g_string_printf(label_string, "| ");
 355         enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 356         fprintf(of, "%s", label_string->str);
 357
 358         /* Write the node names on top */
 359         for (i=1; i<display_nodes; i+=2){
 360                 /* print the node identifiers */
 361                 g_string_printf(label_string, "| %s",
 362                         get_addr_name(&(user_data->nodes[i+first_node])));
 363                 if (label_string->len < NODE_CHARS_WIDTH)
 364                 {
 365                         enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 366                         g_string_append(label_string, "| ");
 367                 }
 368                 enlarge_string(label_string, NODE_CHARS_WIDTH*2, ' ');
 369                 fprintf(of, "%s", label_string->str);
 370                 g_string_printf(label_string, "| ");
 371                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 372                 g_string_append(empty_line, label_string->str);
 373         }
 374
 375         fprintf(of, "\n");
 376
 377         g_string_append_c(empty_line, '|');
 378
 379         enlarge_string(separator_line, empty_line->len + header_length, '-');
 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_printf(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_printf(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_append(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_append(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_printf(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 = ws_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_set_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         g_signal_connect(ok_bt, "clicked", G_CALLBACK(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         g_signal_connect(save_to_file_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 583         g_signal_connect(save_to_file_w, "destroy", G_CALLBACK(save_to_file_destroy_cb), NULL);
 584
 585         gtk_widget_show(save_to_file_w);
 586         window_present(save_to_file_w);
 587
 588 }
 589
 590 /****************************************************************************/
 591 static void dialog_graph_draw(graph_analysis_data_t* user_data)
 592 {
 593         guint32 i, last_item, first_item, display_items;
 594         guint32 start_arrow, end_arrow, label_x, src_port_x, dst_port_x, arrow_width;
 595         guint32 current_item;
 596         guint32 left_x_border;
 597         guint32 right_x_border;
 598         guint32 top_y_border;
 599         guint32 bottom_y_border;
 600         graph_analysis_item_t *gai;
 601         guint16 first_conv_num;
 602         gboolean several_convs = FALSE;
 603         gboolean first_packet = TRUE;
 604
 605         GdkGC *frame_fg_color;
 606         GdkGC *frame_bg_color;
 607         GdkGC *div_line_color;
 608
 609         PangoLayout  *layout;
 610         PangoLayout  *big_layout;
 611         PangoLayout  *small_layout;
 612         gint label_width, label_height;
 613         guint32 draw_width, draw_height;
 614         char label_string[MAX_COMMENT];
 615         GList* list;
 616
 617         /* new variables */
 618
 619         if(!user_data->dlg.needs_redraw){
 620                 return;
 621         }
 622         user_data->dlg.needs_redraw=FALSE;
 623
 624         /* Clear out old plt */
 625         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
 626                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
 627                                                    user_data->dlg.draw_area_time->style->white_gc,
 628                                                    TRUE,
 629                                                    0, 0,
 630                                                    user_data->dlg.draw_area_time->allocation.width,
 631                                                    user_data->dlg.draw_area_time->allocation.height);
 632
 633         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
 634                 gdk_draw_rectangle(user_data->dlg.pixmap,
 635                                                    user_data->dlg.draw_area->style->white_gc,
 636                                                    TRUE,
 637                                                    0, 0,
 638                                                    user_data->dlg.draw_area->allocation.width,
 639                                                    user_data->dlg.draw_area->allocation.height);
 640
 641         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) )
 642                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
 643                                                    user_data->dlg.draw_area->style->white_gc,
 644                                                    TRUE,
 645                                                    0, 0,
 646                                                    user_data->dlg.draw_area_comments->allocation.width,
 647                                                    user_data->dlg.draw_area_comments->allocation.height);
 648
 649         /* Calculate the y border */
 650         top_y_border=TOP_Y_BORDER;      /* to display the node address */
 651         bottom_y_border=BOTTOM_Y_BORDER;
 652
 653         draw_height=user_data->dlg.draw_area->allocation.height-top_y_border-bottom_y_border;
 654
 655         first_item = user_data->dlg.first_item;
 656         display_items = draw_height/ITEM_HEIGHT;
 657         last_item = first_item+display_items-1;
 658
 659         /* get the items to display and fill the matrix array */
 660         list = g_list_first(user_data->graph_info->list);
 661         current_item = 0;
 662         i = 0;
 663         while (list)
 664         {
 665                 gai = list->data;
 666                 if (gai->display){
 667                         if (current_item>=display_items) break;         /* the item is outside the display */
 668                         if (i>=first_item){
 669                                 user_data->dlg.items[current_item].frame_num = gai->frame_num;
 670                                 user_data->dlg.items[current_item].time = gai->time;
 671                                 user_data->dlg.items[current_item].port_src = gai->port_src;
 672                                 user_data->dlg.items[current_item].port_dst = gai->port_dst;
 673                                 /* Add "..." if the length is 50 characters */
 674                                 if (strlen(gai->frame_label) > 48) {
 675                                         gai->frame_label[48] = '.';
 676                                         gai->frame_label[47] = '.';
 677                                         gai->frame_label[46] = '.';
 678                                 }
 679                                 user_data->dlg.items[current_item].frame_label = gai->frame_label;
 680                                 user_data->dlg.items[current_item].comment = gai->comment;
 681                                 user_data->dlg.items[current_item].conv_num = gai->conv_num;
 682
 683                                 if (first_packet){
 684                                         first_conv_num = gai->conv_num;
 685                                         first_packet=FALSE;
 686                                 }
 687
 688                                 if (user_data->dlg.items[current_item].conv_num != first_conv_num){
 689                                         several_convs = TRUE;
 690                                 }
 691
 692                                 user_data->dlg.items[current_item].src_node = gai->src_node;
 693                                 user_data->dlg.items[current_item].dst_node = gai->dst_node;
 694                                 user_data->dlg.items[current_item].line_style = gai->line_style;
 695                                 current_item++;
 696                         }
 697                         i++;
 698                 }
 699
 700                 list = g_list_next(list);
 701         }
 702         /* in case the windows is resized so we have to move the top item */
 703         if ((first_item + display_items) > user_data->num_items){
 704                 if (display_items>user_data->num_items)
 705                         first_item=0;
 706                 else
 707                         first_item = user_data->num_items - display_items;
 708         }
 709
 710         /* in case there are less items than possible displayed */
 711         display_items = current_item;
 712         last_item = first_item+display_items-1;
 713
 714         /* if no items to display */
 715         if (display_items == 0) return;
 716
 717
 718         /* Calculate the x borders */
 719         /* We use time from the last display item to calcultate the x left border */
 720         g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[display_items-1].time);
 721         layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 722         big_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 723         small_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 724
 725         /* XXX - to prevent messages like "Couldn't load font x, falling back to y", I've changed font
 726                  description from "Helvetica-Bold 8" to "Helvetica,Sans,Bold 8", this seems to be
 727                  conforming to the API, see http://developer.gnome.org/doc/API/2.0/pango/pango-Fonts.html */
 728         pango_layout_set_font_description(big_layout, pango_font_description_from_string("Helvetica,Sans,Bold 8"));
 729         pango_layout_set_font_description(small_layout, pango_font_description_from_string("Helvetica,Sans,Bold 7"));
 730
 731         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 732
 733         /* resize the "time" draw area */
 734
 735         left_x_border=3;
 736         user_data->dlg.left_x_border = left_x_border;
 737
 738         right_x_border=2;
 739         draw_width=user_data->dlg.pixmap_width-right_x_border-left_x_border;
 740
 741         /* Paint time title background */
 742         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
 743                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
 744                                                    user_data->dlg.draw_area_time->style->bg_gc[2],
 745                                                    TRUE,
 746                                                    0,
 747                                                    0,
 748                                                    user_data->dlg.draw_area_time->allocation.width,
 749                                                    top_y_border);
 750         /* Paint main title background */
 751         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
 752                 gdk_draw_rectangle(user_data->dlg.pixmap,
 753                                                    user_data->dlg.draw_area->style->bg_gc[2],
 754                                                    TRUE,
 755                                                    0,
 756                                                    0,
 757                                                    user_data->dlg.draw_area->allocation.width,
 758                                                    top_y_border);
 759         /* Paint main comment background */
 760         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) )
 761                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
 762                                                    user_data->dlg.draw_area_comments->style->bg_gc[2],
 763                                                    TRUE,
 764                                                    0,
 765                                                    0,
 766                                                    user_data->dlg.draw_area_comments->allocation.width,
 767                                                    top_y_border);
 768
 769
 770         /* Draw the word "Time" on top of time column */
 771         g_snprintf(label_string, label_width, "%s", "Time");
 772         pango_layout_set_text(layout, label_string, -1);
 773         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 774         if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
 775                 gdk_draw_layout(user_data->dlg.pixmap_time,
 776                                                 user_data->dlg.draw_area_time->style->black_gc,
 777                                                 left_x_border,
 778                                                 top_y_border/2-label_height/2,
 779                                                 layout);
 780         }
 781
 782         /* Draw the word "Comment" on top of comment column */
 783         g_snprintf(label_string, label_width, "%s", "Comment");
 784         pango_layout_set_text(layout, label_string, -1);
 785         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 786         if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments)) {
 787                 gdk_draw_layout(user_data->dlg.pixmap_comments,
 788                            user_data->dlg.draw_area_comments->style->black_gc,
 789                            MAX_COMMENT/2-label_width/2,
 790                            top_y_border/2-label_height/2,
 791                            layout);
 792         }
 793
 794         /* Paint the background items */
 795         for (current_item=0; current_item<display_items; current_item++){
 796                 /*select the color. if it is the selected item select blue color */
 797                 if ( current_item+first_item == user_data->dlg.selected_item ) {
 798                         frame_bg_color = user_data->dlg.bg_gc[0];
 799                 } else {
 800                         frame_bg_color = user_data->dlg.bg_gc[1+user_data->dlg.items[current_item].conv_num%MAX_NUM_COL_CONV];
 801                 }
 802
 803                 /* Paint background */
 804                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 805                         gdk_draw_rectangle(user_data->dlg.pixmap,
 806                                                            frame_bg_color,
 807                                                            TRUE,
 808                                                            left_x_border,
 809                                                            top_y_border+current_item*ITEM_HEIGHT,
 810                                                            draw_width,
 811                                                            ITEM_HEIGHT);
 812                 }
 813         }
 814         /* Draw the node names on top and the division lines */
 815         for (i=0; i<user_data->num_nodes; i++){
 816                 /* print the node identifiers */
 817                 /* XXX we assign 5 pixels per character in the node identity */
 818                 g_snprintf(label_string, NODE_WIDTH/5, "%s",
 819                         get_addr_name(&(user_data->nodes[i])));
 820                 pango_layout_set_text(layout, label_string, -1);
 821                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
 822                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 823                         gdk_draw_layout(user_data->dlg.pixmap,
 824                                                         user_data->dlg.draw_area->style->black_gc,
 825                                                         left_x_border+NODE_WIDTH/2-label_width/2+NODE_WIDTH*i,
 826                                                         top_y_border/2-((i&1)?0:label_height),
 827                                                         layout);
 828                 }
 829
 830                 /* draw the node division lines */
 831                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
 832                         gdk_draw_line(user_data->dlg.pixmap, user_data->dlg.div_line_gc[0],
 833                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 834                                                   top_y_border,
 835                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 836                                                   user_data->dlg.draw_area->allocation.height-bottom_y_border);
 837                 }
 838
 839         }
 840
 841         /* Draw the items */
 842         for (current_item=0; current_item<display_items; current_item++){
 843                 /* draw the time */
 844                 g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[current_item].time);
 845                 pango_layout_set_text(layout, label_string, -1);
 846                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
 847                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
 848                         gdk_draw_layout(user_data->dlg.pixmap_time,
 849                                                         user_data->dlg.draw_area->style->black_gc,
 850                                                         3,
 851                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2,
 852                                                         layout);
 853                 }
 854
 855                 /*draw the comments */
 856                 g_snprintf(label_string, MAX_COMMENT, "%s", user_data->dlg.items[current_item].comment);
 857                 pango_layout_set_text(small_layout, label_string, -1);
 858                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
 859                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments)) {
 860                         gdk_draw_layout(user_data->dlg.pixmap_comments,
 861                                                         user_data->dlg.draw_area->style->black_gc,
 862                                                         2,
 863                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2,
 864                                                         small_layout);
 865                 }
 866                 /* select colors */
 867                 if ( current_item+first_item == user_data->dlg.selected_item ){
 868                         frame_fg_color = user_data->dlg.draw_area->style->white_gc;
 869                         div_line_color = user_data->dlg.div_line_gc[1];
 870                 } else {
 871                         frame_fg_color = user_data->dlg.draw_area->style->black_gc;
 872                         div_line_color = user_data->dlg.div_line_gc[0];
 873                 }
 874                 /* draw the arrow line */
 875                 start_arrow = left_x_border+(user_data->dlg.items[current_item].src_node)*NODE_WIDTH+NODE_WIDTH/2;
 876                 end_arrow = left_x_border+(user_data->dlg.items[current_item].dst_node)*NODE_WIDTH+NODE_WIDTH/2;
 877
 878                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
 879                         gdk_draw_line(user_data->dlg.pixmap, frame_fg_color,
 880                                 start_arrow,
 881                                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7,
 882                                 end_arrow,
 883                                 top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7);
 884
 885                         /* draw the additional line when line style is 2 pixels width */
 886                         if (user_data->dlg.items[current_item].line_style == 2) {
 887                                 gdk_draw_line(user_data->dlg.pixmap, frame_fg_color,
 888                                         start_arrow,
 889                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-6,
 890                                         end_arrow,
 891                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-6);
 892                         }
 893                 }
 894
 895                 /* draw the arrow */
 896                 if (start_arrow<end_arrow)
 897                         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);
 898                 else
 899                         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);
 900
 901                 /* draw the frame comment */
 902                 g_snprintf(label_string, MAX_LABEL, "%s", user_data->dlg.items[current_item].frame_label);
 903                 pango_layout_set_text(big_layout, label_string, -1);
 904                 pango_layout_get_pixel_size(big_layout, &label_width, &label_height);
 905                 if (start_arrow<end_arrow){
 906                         arrow_width = end_arrow-start_arrow;
 907                         label_x = arrow_width/2+start_arrow;
 908                 }
 909                 else {
 910                         arrow_width = start_arrow-end_arrow;
 911                         label_x = arrow_width/2+end_arrow;
 912                 }
 913
 914                 if (label_width>(gint)arrow_width) arrow_width = label_width;
 915
 916                 if ((int)left_x_border > ((int)label_x-(int)label_width/2))
 917                         label_x = left_x_border + label_width/2;
 918
 919                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 920                         gdk_draw_layout(user_data->dlg.pixmap,
 921                                                         frame_fg_color,
 922                                                         label_x - label_width/2,
 923                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2-3,
 924                                                         big_layout);
 925                 }
 926
 927                 /* draw the source port number */
 928                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_src);
 929                 pango_layout_set_text(small_layout, label_string, -1);
 930                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
 931                 if (start_arrow<end_arrow){
 932                         src_port_x = start_arrow - label_width - 2;
 933                 }
 934                 else {
 935                         src_port_x = start_arrow + 2;
 936                 }
 937                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 938                         gdk_draw_layout(user_data->dlg.pixmap,
 939                                                         div_line_color,
 940                                                         src_port_x,
 941                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2,
 942                                                         small_layout);
 943                 }
 944
 945                 /* draw the destination port number */
 946                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_dst);
 947                 pango_layout_set_text(small_layout, label_string, -1);
 948                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
 949                 if (start_arrow<end_arrow){
 950                         dst_port_x = end_arrow + 2;
 951                 }
 952                 else {
 953                         dst_port_x = end_arrow - label_width - 2;
 954                 }
 955                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap)) {
 956                         gdk_draw_layout(user_data->dlg.pixmap,
 957                                                         div_line_color,
 958                                                         dst_port_x,
 959                                                         top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2,
 960                                                         small_layout);
 961                 }
 962                 /* draw the div line of the selected item with soft gray*/
 963                 if ( current_item+first_item == user_data->dlg.selected_item )
 964                         for (i=0; i<user_data->num_nodes; i++){
 965                                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap) ) {
 966                                         gdk_draw_line(user_data->dlg.pixmap, user_data->dlg.div_line_gc[1],
 967                                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 968                                                                   (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER,
 969                                                                   left_x_border+NODE_WIDTH/2+NODE_WIDTH*i,
 970                                                                   (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER+ITEM_HEIGHT);
 971                                 }
 972                         }
 973         }
 974
 975         g_object_unref(G_OBJECT(layout));
 976
 977         /* refresh the draw areas */
 978         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_time->window) )
 979                 gdk_draw_pixmap(user_data->dlg.draw_area_time->window,
 980                                                 user_data->dlg.draw_area_time->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area_time)],
 981                                                 user_data->dlg.pixmap_time,
 982                                                 0, 0,
 983                                                 0, 0,
 984                                                 user_data->dlg.draw_area_time->allocation.width, user_data->dlg.draw_area_time->allocation.height);
 985
 986         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area->window) )
 987                 gdk_draw_pixmap(user_data->dlg.draw_area->window,
 988                                                 user_data->dlg.draw_area->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area)],
 989                                                 user_data->dlg.pixmap,
 990                                                 0, 0,
 991                                                 0, 0,
 992                                                 user_data->dlg.draw_area->allocation.width, user_data->dlg.draw_area->allocation.height);
 993
 994         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_comments->window) )
 995                 gdk_draw_pixmap(user_data->dlg.draw_area_comments->window,
 996                                                 user_data->dlg.draw_area_comments->style->fg_gc[GTK_WIDGET_STATE(user_data->dlg.draw_area_comments)],
 997                                                 user_data->dlg.pixmap_comments,
 998                                                 0, 0,
 999                                                 0, 0,
1000                                                 user_data->dlg.draw_area_comments->allocation.width, user_data->dlg.draw_area_comments->allocation.height);
1001
1002         /* update the v_scrollbar */
1003         user_data->dlg.v_scrollbar_adjustment->upper=(gfloat) user_data->num_items-1;
1004         user_data->dlg.v_scrollbar_adjustment->step_increment=1;
1005         user_data->dlg.v_scrollbar_adjustment->page_increment=(gfloat) (last_item-first_item);
1006         user_data->dlg.v_scrollbar_adjustment->page_size=(gfloat) (last_item-first_item);
1007         user_data->dlg.v_scrollbar_adjustment->value=(gfloat) first_item;
1008
1009         gtk_adjustment_changed(user_data->dlg.v_scrollbar_adjustment);
1010         gtk_adjustment_value_changed(user_data->dlg.v_scrollbar_adjustment);
1011 }
1012
1013 /****************************************************************************/
1014 static void dialog_graph_redraw(graph_analysis_data_t* user_data)
1015 {
1016         user_data->dlg.needs_redraw=TRUE;
1017         dialog_graph_draw(user_data);
1018 }
1019
1020 /****************************************************************************/
1021 static gint button_press_event(GtkWidget *widget, GdkEventButton *event _U_)
1022 {
1023         graph_analysis_data_t *user_data;
1024         guint32 item;
1025
1026         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1027
1028         if (event->type != GDK_BUTTON_PRESS) return TRUE;
1029
1030         if (event->y<TOP_Y_BORDER) return TRUE;
1031
1032         /* get the item clicked */
1033         item = ((guint32)event->y - TOP_Y_BORDER) / ITEM_HEIGHT;
1034         if (item >= user_data->num_items) return TRUE;
1035         user_data->dlg.selected_item = item + user_data->dlg.first_item;
1036
1037         user_data->dlg.needs_redraw=TRUE;
1038         dialog_graph_draw(user_data);
1039
1040         cf_goto_frame(&cfile, user_data->dlg.items[item].frame_num);
1041
1042         return TRUE;
1043 }
1044
1045 /****************************************************************************/
1046 static gint scroll_event(GtkWidget *widget, GdkEventScroll *event)
1047 {
1048         graph_analysis_data_t *user_data;
1049
1050         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1051
1052         /* Up scroll */
1053         switch(event->direction) {
1054         case(GDK_SCROLL_UP):
1055                 if (user_data->dlg.first_item == 0) return TRUE;
1056                 if (user_data->dlg.first_item < 3)
1057                         user_data->dlg.first_item = 0;
1058                 else
1059                         user_data->dlg.first_item -= 3;
1060                 break;
1061         case(GDK_SCROLL_DOWN):
1062                 if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1 == user_data->num_items)) return TRUE;
1063                 if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1) > (user_data->num_items-3))
1064                         user_data->dlg.first_item = user_data->num_items-(guint32)user_data->dlg.v_scrollbar_adjustment->page_size-1;
1065                 else
1066                         user_data->dlg.first_item += 3;
1067             break;
1068         case(GDK_SCROLL_LEFT):
1069         case(GDK_SCROLL_RIGHT):
1070                 /* nothing to do */
1071                 break;
1072         }
1073         dialog_graph_redraw(user_data);
1074
1075         return TRUE;
1076 }
1077
1078 /****************************************************************************/
1079 static gint key_press_event(GtkWidget *widget, GdkEventKey *event _U_)
1080 {
1081         graph_analysis_data_t *user_data;
1082
1083         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1084
1085         /* if there is nothing selected, just return */
1086         if (user_data->dlg.selected_item == 0xFFFFFFFF) return TRUE;
1087
1088         /* Up arrow */
1089         if (event->keyval == GDK_Up){
1090                 if (user_data->dlg.selected_item == 0) return TRUE;
1091                 user_data->dlg.selected_item--;
1092                 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) )
1093                         user_data->dlg.first_item = user_data->dlg.selected_item;
1094                 /* Down arrow */
1095         } else if (event->keyval == GDK_Down){
1096                 if (user_data->dlg.selected_item == user_data->num_items-1) return TRUE;
1097                 user_data->dlg.selected_item++;
1098                 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) )
1099                         user_data->dlg.first_item = (guint32)user_data->dlg.selected_item-(guint32)user_data->dlg.v_scrollbar_adjustment->page_size;
1100         } else if (event->keyval == GDK_Left){
1101                 if (user_data->dlg.first_node == 0) return TRUE;
1102                 user_data->dlg.first_node--;
1103         } else return TRUE;
1104
1105         user_data->dlg.needs_redraw=TRUE;
1106         dialog_graph_draw(user_data);
1107
1108         cf_goto_frame(&cfile, user_data->dlg.items[user_data->dlg.selected_item-user_data->dlg.first_item].frame_num);
1109
1110         return TRUE;
1111 }
1112
1113 /****************************************************************************/
1114 static gint expose_event(GtkWidget *widget, GdkEventExpose *event)
1115 {
1116         graph_analysis_data_t *user_data;
1117
1118         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1119         if(!user_data){
1120                 exit(10);
1121         }
1122
1123         if (GDK_IS_DRAWABLE(widget->window))
1124                 gdk_draw_pixmap(widget->window,
1125                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1126                         user_data->dlg.pixmap,
1127                         event->area.x, event->area.y,
1128                         event->area.x, event->area.y,
1129                         event->area.width, event->area.height);
1130
1131         return FALSE;
1132 }
1133
1134 /****************************************************************************/
1135 static gint expose_event_comments(GtkWidget *widget, GdkEventExpose *event)
1136 {
1137         graph_analysis_data_t *user_data;
1138
1139         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1140         if(!user_data){
1141                 exit(10);
1142         }
1143
1144         if (GDK_IS_DRAWABLE(widget->window))
1145                 gdk_draw_pixmap(widget->window,
1146                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1147                         user_data->dlg.pixmap_comments,
1148                         event->area.x, event->area.y,
1149                         event->area.x, event->area.y,
1150                         event->area.width, event->area.height);
1151
1152         return FALSE;
1153 }
1154
1155 /****************************************************************************/
1156 static gint expose_event_time(GtkWidget *widget, GdkEventExpose *event)
1157 {
1158         graph_analysis_data_t *user_data;
1159
1160         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1161         if(!user_data){
1162                 exit(10);
1163         }
1164
1165         if (GDK_IS_DRAWABLE(widget->window) )
1166                 gdk_draw_pixmap(widget->window,
1167                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
1168                         user_data->dlg.pixmap_time,
1169                         event->area.x, event->area.y,
1170                         event->area.x, event->area.y,
1171                         event->area.width, event->area.height);
1172
1173         return FALSE;
1174 }
1175
1176 /****************************************************************************/
1177 static gint configure_event(GtkWidget *widget, GdkEventConfigure *event _U_)
1178 {
1179         graph_analysis_data_t *user_data;
1180         int i;
1181
1182         /* gray and soft gray colors */
1183         static GdkColor color_div_line[2] = {
1184                 {0, 0x64ff, 0x64ff, 0x64ff},
1185                 {0, 0x7fff, 0x7fff, 0x7fff}
1186         };
1187
1188         /* the first color is blue to highlight the selected item */
1189         static GdkColor col[MAX_NUM_COL_CONV+1] = {
1190                 {0,     0x00FF, 0x00FF, 0xFFFF},
1191                 {0,     0x33FF, 0xFFFF, 0x33FF},
1192                 {0,     0x00FF, 0xCCFF, 0xCCFF},
1193                 {0,     0x66FF, 0xFFFF, 0xFFFF},
1194                 {0,     0x99FF, 0x66FF, 0xFFFF},
1195                 {0,     0xFFFF, 0xFFFF, 0x33FF},
1196                 {0,     0xCCFF, 0x99FF, 0xFFFF},
1197                 {0,     0xCCFF, 0xFFFF, 0x33FF},
1198                 {0,     0xFFFF, 0xCCFF, 0xCCFF},
1199                 {0,     0xFFFF, 0x99FF, 0x66FF},
1200                 {0,     0xFFFF, 0xFFFF, 0x99FF}
1201         };
1202
1203         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1204
1205         if(!user_data){
1206                 exit(10);
1207         }
1208
1209         if(user_data->dlg.pixmap){
1210                 gdk_pixmap_unref(user_data->dlg.pixmap);
1211                 user_data->dlg.pixmap=NULL;
1212         }
1213
1214         user_data->dlg.pixmap=gdk_pixmap_new(widget->window,
1215                 widget->allocation.width,
1216                 widget->allocation.height,
1217                 -1);
1218
1219         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
1220                         gdk_draw_rectangle(user_data->dlg.pixmap,
1221                                 widget->style->white_gc,
1222                                 TRUE,
1223                                 0, 0,
1224                                 widget->allocation.width,
1225                                 widget->allocation.height);
1226
1227         /* create gc for division lines and set the line stype to dash */
1228         for (i=0; i<2; i++){
1229                 user_data->dlg.div_line_gc[i]=gdk_gc_new(user_data->dlg.pixmap);
1230                 gdk_gc_set_line_attributes(user_data->dlg.div_line_gc[i], 1, GDK_LINE_ON_OFF_DASH, 0, 0);
1231                 gdk_gc_set_rgb_fg_color(user_data->dlg.div_line_gc[i], &color_div_line[i]);
1232         }
1233
1234         /* create gcs for the background items */
1235         for (i=0; i<MAX_NUM_COL_CONV+1; i++){
1236                 user_data->dlg.bg_gc[i]=gdk_gc_new(user_data->dlg.pixmap);
1237                 gdk_gc_set_rgb_fg_color(user_data->dlg.bg_gc[i], &col[i]);
1238         }
1239
1240         dialog_graph_redraw(user_data);
1241
1242         return TRUE;
1243 }
1244
1245 /****************************************************************************/
1246 static gint configure_event_comments(GtkWidget *widget, GdkEventConfigure *event _U_)
1247 {
1248         graph_analysis_data_t *user_data;
1249
1250         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1251
1252         if(!user_data){
1253                 exit(10);
1254         }
1255
1256         if(user_data->dlg.pixmap_comments){
1257                 gdk_pixmap_unref(user_data->dlg.pixmap_comments);
1258                 user_data->dlg.pixmap_comments=NULL;
1259         }
1260
1261         user_data->dlg.pixmap_comments=gdk_pixmap_new(widget->window,
1262                                                 widget->allocation.width,
1263                                                 widget->allocation.height,
1264                                                 -1);
1265
1266         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap) )
1267                 gdk_draw_rectangle(user_data->dlg.pixmap_comments,
1268                                                 widget->style->white_gc,
1269                                                 TRUE,
1270                                                 0, 0,
1271                                                 widget->allocation.width,
1272                                                 widget->allocation.height);
1273
1274         dialog_graph_redraw(user_data);
1275         return TRUE;
1276 }
1277
1278 /****************************************************************************/
1279 static gint configure_event_time(GtkWidget *widget, GdkEventConfigure *event _U_)
1280 {
1281         graph_analysis_data_t *user_data;
1282
1283         user_data=(graph_analysis_data_t *)g_object_get_data(G_OBJECT(widget), "graph_analysis_data_t");
1284
1285         if(!user_data){
1286                 exit(10);
1287         }
1288
1289         if(user_data->dlg.pixmap_time){
1290                 gdk_pixmap_unref(user_data->dlg.pixmap_time);
1291                 user_data->dlg.pixmap_time=NULL;
1292         }
1293
1294         user_data->dlg.pixmap_time=gdk_pixmap_new(widget->window,
1295                                                 widget->allocation.width,
1296                                                 widget->allocation.height,
1297                                                 -1);
1298
1299         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) )
1300                 gdk_draw_rectangle(user_data->dlg.pixmap_time,
1301                                                 widget->style->white_gc,
1302                                                 TRUE,
1303                                                 0, 0,
1304                                                 widget->allocation.width,
1305                                                 widget->allocation.height);
1306
1307         dialog_graph_redraw(user_data);
1308
1309         return TRUE;
1310 }
1311
1312 /****************************************************************************/
1313 static gint pane_callback(GtkWidget *widget, GParamSpec *pspec _U_, gpointer data)
1314 {
1315         graph_analysis_data_t *user_data=(graph_analysis_data_t *)data;
1316
1317         if(!user_data){
1318                 exit(10);
1319         }
1320         if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) > user_data->dlg.pixmap_width)
1321                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), user_data->dlg.pixmap_width);
1322         else if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) < NODE_WIDTH*2)
1323                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), NODE_WIDTH*2);
1324         /* repaint the comment area because when moving the pane position there are times that the expose_event_comments is not called */
1325         if (GDK_IS_DRAWABLE(user_data->dlg.draw_area_comments->window))
1326                 gdk_draw_pixmap(user_data->dlg.draw_area_comments->window,
1327                         user_data->dlg.draw_area_comments->style->fg_gc[GTK_WIDGET_STATE(widget)],
1328                         user_data->dlg.pixmap_comments,
1329                         0,0,
1330                         0,0,
1331                         user_data->dlg.draw_area_comments->allocation.width,
1332                         user_data->dlg.draw_area_comments->allocation.height);
1333
1334         return TRUE;
1335 }
1336
1337 /****************************************************************************/
1338 static gint v_scrollbar_changed(GtkWidget *widget _U_, gpointer data)
1339 {
1340         graph_analysis_data_t *user_data=(graph_analysis_data_t *)data;
1341         if ((user_data->dlg.first_item+user_data->dlg.v_scrollbar_adjustment->page_size+1 == user_data->num_items)
1342                 && (user_data->dlg.v_scrollbar_adjustment->value >= user_data->dlg.first_item ))
1343                 return TRUE;
1344
1345         if (user_data->dlg.first_item == user_data->dlg.v_scrollbar_adjustment->value)
1346                 return TRUE;
1347
1348         user_data->dlg.first_item = (guint32) user_data->dlg.v_scrollbar_adjustment->value;
1349
1350         dialog_graph_redraw(user_data);
1351
1352         return TRUE;
1353 }
1354
1355 /****************************************************************************/
1356 static void create_draw_area(graph_analysis_data_t* user_data, GtkWidget *box)
1357 {
1358         GtkWidget *vbox;
1359         GtkWidget *hbox;
1360         GtkWidget *viewport;
1361         GtkWidget *scroll_window_comments;
1362         GtkWidget *viewport_comments;
1363
1364         hbox=gtk_hbox_new(FALSE, 0);
1365         gtk_widget_show(hbox);
1366
1367         vbox=gtk_vbox_new(FALSE, 0);
1368         gtk_widget_show(vbox);
1369
1370         /* create "time" draw area */
1371         user_data->dlg.draw_area_time=gtk_drawing_area_new();
1372         gtk_widget_set_size_request(user_data->dlg.draw_area_time, TIME_WIDTH, user_data->dlg.pixmap_height);
1373         g_object_set_data(G_OBJECT(user_data->dlg.draw_area_time), "graph_analysis_data_t", user_data);
1374
1375         /* create "comments" draw area */
1376         user_data->dlg.draw_area_comments=gtk_drawing_area_new();
1377         gtk_widget_set_size_request(user_data->dlg.draw_area_comments, COMMENT_WIDTH, user_data->dlg.pixmap_height);
1378         scroll_window_comments=gtk_scrolled_window_new(NULL, NULL);
1379         gtk_widget_set_size_request(scroll_window_comments, COMMENT_WIDTH/2, user_data->dlg.pixmap_height);
1380         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scroll_window_comments), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
1381         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)));
1382         gtk_container_add(GTK_CONTAINER(viewport_comments), user_data->dlg.draw_area_comments);
1383         gtk_container_add(GTK_CONTAINER(scroll_window_comments), viewport_comments);
1384         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport_comments), GTK_SHADOW_NONE);
1385         g_object_set_data(G_OBJECT(user_data->dlg.draw_area_comments), "graph_analysis_data_t", user_data);
1386         gtk_widget_add_events (user_data->dlg.draw_area_comments, GDK_BUTTON_PRESS_MASK);
1387
1388         g_signal_connect(user_data->dlg.draw_area_comments, "scroll_event",  G_CALLBACK(scroll_event), user_data);
1389         /* create main Graph draw area */
1390         user_data->dlg.draw_area=gtk_drawing_area_new();
1391         if (user_data->num_nodes < 2)
1392                 user_data->dlg.pixmap_width = 2 * NODE_WIDTH;
1393         else
1394                 user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1395         gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1396         user_data->dlg.scroll_window=gtk_scrolled_window_new(NULL, NULL);
1397         if ( user_data->num_nodes < 6)
1398                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1399         else
1400                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1401         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
1402         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)));
1403         gtk_container_add(GTK_CONTAINER(viewport), user_data->dlg.draw_area);
1404         gtk_container_add(GTK_CONTAINER(user_data->dlg.scroll_window), viewport);
1405         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
1406         g_object_set_data(G_OBJECT(user_data->dlg.draw_area), "graph_analysis_data_t", user_data);
1407         GTK_WIDGET_SET_FLAGS(user_data->dlg.draw_area, GTK_CAN_FOCUS);
1408         gtk_widget_grab_focus(user_data->dlg.draw_area);
1409
1410         /* signals needed to handle backing pixmap */
1411         g_signal_connect(user_data->dlg.draw_area, "expose_event", G_CALLBACK(expose_event), NULL);
1412         g_signal_connect(user_data->dlg.draw_area, "configure_event", G_CALLBACK(configure_event), user_data);
1413
1414         /* signals needed to handle backing pixmap comments */
1415         g_signal_connect(user_data->dlg.draw_area_comments, "expose_event", G_CALLBACK(expose_event_comments), NULL);
1416         g_signal_connect(user_data->dlg.draw_area_comments, "configure_event", G_CALLBACK(configure_event_comments), user_data);
1417
1418         /* signals needed to handle backing pixmap time */
1419         g_signal_connect(user_data->dlg.draw_area_time, "expose_event", G_CALLBACK(expose_event_time), NULL);
1420         g_signal_connect(user_data->dlg.draw_area_time, "configure_event", G_CALLBACK(configure_event_time), user_data);
1421
1422         gtk_widget_add_events (user_data->dlg.draw_area, GDK_BUTTON_PRESS_MASK);
1423         g_signal_connect(user_data->dlg.draw_area, "button_press_event", G_CALLBACK(button_press_event), user_data);
1424         g_signal_connect(user_data->dlg.draw_area, "scroll_event",  G_CALLBACK(scroll_event), user_data);
1425         g_signal_connect(user_data->dlg.draw_area, "key_press_event",  G_CALLBACK(key_press_event), user_data);
1426
1427         gtk_widget_show(user_data->dlg.draw_area_time);
1428         gtk_widget_show(user_data->dlg.draw_area);
1429         gtk_widget_show(viewport);
1430         gtk_widget_show(user_data->dlg.draw_area_comments);
1431         gtk_widget_show(viewport_comments);
1432
1433         gtk_widget_show(user_data->dlg.scroll_window);
1434         gtk_widget_show(scroll_window_comments);
1435
1436         gtk_box_pack_start(GTK_BOX(hbox), user_data->dlg.draw_area_time, FALSE, FALSE, 0);
1437
1438         user_data->dlg.hpane = gtk_hpaned_new();
1439         gtk_paned_pack1(GTK_PANED (user_data->dlg.hpane), user_data->dlg.scroll_window, FALSE, TRUE);
1440         gtk_paned_pack2(GTK_PANED (user_data->dlg.hpane), scroll_window_comments, TRUE, TRUE);
1441         g_signal_connect(user_data->dlg.hpane, "notify::position",  G_CALLBACK(pane_callback), user_data);
1442         gtk_widget_show(user_data->dlg.hpane);
1443
1444         gtk_box_pack_start(GTK_BOX(hbox), user_data->dlg.hpane, TRUE, TRUE, 0);
1445
1446         /* create the associated v_scrollbar */
1447         user_data->dlg.v_scrollbar_adjustment=(GtkAdjustment *)gtk_adjustment_new(0,0,0,0,0,0);
1448         user_data->dlg.v_scrollbar=gtk_vscrollbar_new(user_data->dlg.v_scrollbar_adjustment);
1449         gtk_widget_show(user_data->dlg.v_scrollbar);
1450         gtk_box_pack_end(GTK_BOX(hbox), user_data->dlg.v_scrollbar, FALSE, FALSE, 0);
1451         g_signal_connect(user_data->dlg.v_scrollbar_adjustment, "value_changed", G_CALLBACK(v_scrollbar_changed), user_data);
1452
1453         gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 0);
1454 }
1455 /****************************************************************************/
1456 /* PUBLIC */
1457 /****************************************************************************/
1458
1459
1460 /****************************************************************************/
1461 static void dialog_graph_create_window(graph_analysis_data_t* user_data)
1462 {
1463         GtkWidget *vbox;
1464         GtkWidget *hbuttonbox;
1465         GtkWidget *bt_close;
1466         GtkWidget *bt_save;
1467         GtkTooltips *tooltips = gtk_tooltips_new();
1468         const gchar *title_name_ptr;
1469         gchar   *win_name;
1470
1471         title_name_ptr = cf_get_display_name(&cfile);
1472         win_name = g_strdup_printf("%s - Graph Analysis", title_name_ptr);
1473
1474         /* create the main window */
1475         if (user_data->dlg.title)
1476                 user_data->dlg.window=window_new(GTK_WINDOW_TOPLEVEL, user_data->dlg.title);
1477         else
1478                 user_data->dlg.window=window_new(GTK_WINDOW_TOPLEVEL, win_name);
1479
1480
1481         vbox=gtk_vbox_new(FALSE, 0);
1482         gtk_container_add(GTK_CONTAINER(user_data->dlg.window), vbox);
1483         gtk_widget_show(vbox);
1484
1485         create_draw_area(user_data, vbox);
1486
1487         /* button row */
1488         hbuttonbox = gtk_hbutton_box_new ();
1489         gtk_box_pack_start (GTK_BOX (vbox), hbuttonbox, FALSE, FALSE, 0);
1490         gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_SPREAD);
1491         gtk_box_set_spacing (GTK_BOX (hbuttonbox), 30);
1492         gtk_widget_show(hbuttonbox);
1493
1494         bt_save = gtk_button_new_from_stock(GTK_STOCK_SAVE_AS);
1495         gtk_container_add(GTK_CONTAINER(hbuttonbox), bt_save);
1496         gtk_widget_show(bt_save);
1497         g_signal_connect(bt_save, "clicked", G_CALLBACK(on_save_bt_clicked), user_data);
1498         gtk_tooltips_set_tip (tooltips, bt_save, "Save an ASCII representation of the graph to a file", NULL);
1499
1500         bt_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
1501         gtk_container_add (GTK_CONTAINER (hbuttonbox), bt_close);
1502         GTK_WIDGET_SET_FLAGS(bt_close, GTK_CAN_DEFAULT);
1503         gtk_widget_show(bt_close);
1504         gtk_tooltips_set_tip (tooltips, bt_close, "Close this dialog", NULL);
1505         window_set_cancel_button(user_data->dlg.window, bt_close, window_cancel_button_cb);
1506
1507         g_signal_connect(user_data->dlg.window, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1508         g_signal_connect(user_data->dlg.window, "destroy", G_CALLBACK(on_destroy), user_data);
1509
1510         gtk_widget_show(user_data->dlg.window);
1511         window_present(user_data->dlg.window);
1512
1513         /* Destroy our graph window with our parent if the caller specified the parent */
1514         if(user_data->dlg.parent_w) {
1515                 gtk_window_set_transient_for(GTK_WINDOW(user_data->dlg.window),
1516                                              GTK_WINDOW(user_data->dlg.parent_w));
1517                 /* Destruction of this child window */
1518                 gtk_window_set_destroy_with_parent(GTK_WINDOW(user_data->dlg.window), TRUE);
1519         }
1520         g_free(win_name);
1521 }
1522
1523 /* Return the index array if the node is in the array. Return -1 if there is room in the array
1524  * and Return -2 if the array is full
1525  */
1526 /****************************************************************************/
1527 static gint add_or_get_node(graph_analysis_data_t* user_data, address* node) {
1528         guint i;
1529
1530         if (node->type == AT_NONE) return NODE_OVERFLOW;
1531
1532         for (i=0; i<MAX_NUM_NODES && i < user_data->num_nodes ; i++){
1533                 if ( CMP_ADDRESS(&(user_data->nodes[i]), node) == 0 ) return i; /* it is in the array */
1534         }
1535
1536         if (i == MAX_NUM_NODES) {
1537                 return  NODE_OVERFLOW;
1538         } else {
1539                 user_data->num_nodes++;
1540                 COPY_ADDRESS(&(user_data->nodes[i]),node);
1541                 return i;
1542         }
1543 }
1544
1545 /* Get the nodes from the list */
1546 /****************************************************************************/
1547 static void get_nodes(graph_analysis_data_t* user_data)
1548 {
1549         GList* list;
1550         graph_analysis_item_t *gai;
1551
1552         /* fill the node array */
1553         list = g_list_first(user_data->graph_info->list);
1554         while (list)
1555         {
1556                 gai = list->data;
1557                 if (gai->display) {
1558                         user_data->num_items++;
1559                         if (!user_data->dlg.inverse) {
1560                                 gai->src_node = (guint16)add_or_get_node(user_data, &(gai->src_addr));
1561                                 gai->dst_node = (guint16)add_or_get_node(user_data, &(gai->dst_addr));
1562                         } else {
1563                                 gai->dst_node = (guint16)add_or_get_node(user_data, &(gai->src_addr));
1564                                 gai->src_node = (guint16)add_or_get_node(user_data, &(gai->dst_addr));
1565                         }
1566                 }
1567                 list = g_list_next(list);
1568         }
1569 }
1570
1571 /****************************************************************************/
1572 graph_analysis_data_t* graph_analysis_init(void)
1573 {
1574         graph_analysis_data_t* user_data;
1575         /* init */
1576         user_data = g_malloc(sizeof(graph_analysis_data_t));
1577
1578         /* init user_data */
1579         graph_analysis_init_dlg(user_data);
1580
1581         return user_data;
1582 }
1583 /****************************************************************************/
1584 /* PUBLIC */
1585 /****************************************************************************/
1586
1587 /****************************************************************************/
1588 void graph_analysis_create(graph_analysis_data_t* user_data)
1589 {
1590         /* reset the data */
1591         graph_analysis_reset(user_data);
1592
1593         /* get nodes (each node is an address) */
1594         get_nodes(user_data);
1595
1596         /* create the graph windows */
1597         dialog_graph_create_window(user_data);
1598
1599         /* redraw the graph */
1600         dialog_graph_redraw(user_data);
1601
1602         return;
1603 }
1604
1605 /****************************************************************************/
1606 void graph_analysis_update(graph_analysis_data_t* user_data)
1607 {
1608         /* reset the data */
1609         graph_analysis_reset(user_data);
1610
1611         /* get nodes (each node is an address) */
1612         get_nodes(user_data);
1613
1614         user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1615         gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1616         if (user_data->num_nodes < 6)
1617                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1618         else
1619                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1620
1621         /* redraw the graph */
1622         dialog_graph_redraw(user_data);
1623
1624         window_present(user_data->dlg.window);
1625         return;
1626 }
1627
1628
1629 /****************************************************************************/
1630 void graph_analysis_redraw(graph_analysis_data_t* user_data)
1631 {
1632         /* get nodes (each node is an address) */
1633         get_nodes(user_data);
1634
1635         user_data->dlg.pixmap_width = user_data->num_nodes * NODE_WIDTH;
1636     gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.pixmap_width, user_data->dlg.pixmap_height);
1637         if (user_data->num_nodes < 6)
1638                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.pixmap_height);
1639         else
1640                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.pixmap_height);
1641
1642
1643         /* redraw the graph */
1644         dialog_graph_redraw(user_data);
1645
1646         window_present(user_data->dlg.window);
1647         return;
1648 }